@nori-ui/core 1.1.0 → 1.2.0

package/dist/components/DatePicker/index.cjs

@@ -0,0 +1,3875 @@
+'use strict';
+
+var date = require('@internationalized/date');
+var react = require('react');
+var reactNative = require('react-native');
+var jsxRuntime = require('nativewind/jsx-runtime');
+var reactDom = require('react-dom');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var detectLocale = /* @__PURE__ */ __name(() => {
+  try {
+    return new Intl.DateTimeFormat().resolvedOptions().locale;
+  } catch {
+    return "en-US";
+  }
+}, "detectLocale");
+var LocaleContext = react.createContext(null);
+LocaleContext.displayName = "LocaleContext";
+var useLocale = /* @__PURE__ */ __name(() => {
+  const ctx = react.useContext(LocaleContext);
+  return ctx ?? detectLocale();
+}, "useLocale");
+
+// src/theme/px.ts
+function px(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const n = Number.parseFloat(value);
+  return Number.isFinite(n) ? n : 0;
+}
+__name(px, "px");
+
+// ../tokens/build/theme.ts
+var theme = {
+  color: {
+    danger: "#ef4444",
+    info: "#3b82f6",
+    neutral: {
+      "100": "#f4f4f5",
+      "200": "#e4e4e7",
+      "300": "#d4d4d8",
+      "400": "#a1a1aa",
+      "50": "#fafafa",
+      "500": "#71717a",
+      "600": "#52525b",
+      "700": "#3f3f46",
+      "800": "#27272a",
+      "900": "#18181b"
+    },
+    primary: {
+      "100": "#ccfbf1",
+      "200": "#99f6e4",
+      "300": "#5eead4",
+      "400": "#2dd4bf",
+      "50": "#f0fdfa",
+      "500": "#14b8a6",
+      "600": "#0d9488",
+      "700": "#0f766e",
+      "800": "#115e59",
+      "900": "#134e4a"
+    },
+    success: "#22c55e",
+    warning: "#f59e0b"
+  },
+  fontFamily: {
+    body: "system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif",
+    display: "ui-serif, Georgia, 'Times New Roman', serif",
+    mono: "ui-monospace, 'SF Mono', Menlo, Consolas, 'DejaVu Sans Mono', monospace"
+  },
+  fontSize: {
+    "2xl": "24px",
+    "3xl": "30px",
+    "4xl": "36px",
+    lg: "18px",
+    md: "16px",
+    sm: "14px",
+    xl: "20px",
+    xs: "12px"
+  },
+  fontWeight: {
+    bold: "700",
+    medium: "500",
+    regular: "400",
+    semibold: "600"
+  },
+  lineHeight: {
+    normal: "1.4",
+    relaxed: "1.6",
+    tight: "1.2"
+  },
+  radius: {
+    "2xl": "16px",
+    full: "9999px",
+    lg: "8px",
+    md: "6px",
+    none: "0px",
+    sm: "4px",
+    xl: "12px"
+  },
+  semantic: {
+    background: {
+      default: "#fafafa",
+      elevated: "#ffffff",
+      subtle: "#f4f4f5"
+    },
+    border: {
+      default: "#e4e4e7",
+      strong: "#d4d4d8"
+    },
+    interactive: {
+      destructive: "#ef4444",
+      primary: "#0d9488",
+      primaryHover: "#0f766e",
+      primaryPressed: "#115e59"
+    },
+    text: {
+      default: "#18181b",
+      inverted: "#fafafa",
+      muted: "#52525b"
+    }
+  },
+  shadow: {
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+    sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)"
+  },
+  spacing: {
+    "0": "0px",
+    "1": "4px",
+    "10": "40px",
+    "12": "48px",
+    "16": "64px",
+    "2": "8px",
+    "20": "80px",
+    "24": "96px",
+    "3": "12px",
+    "4": "16px",
+    "5": "20px",
+    "6": "24px",
+    "8": "32px"
+  }
+};
+var themeDark = {
+  color: {
+    danger: "#ef4444",
+    info: "#3b82f6",
+    neutral: {
+      "100": "#f4f4f5",
+      "200": "#e4e4e7",
+      "300": "#d4d4d8",
+      "400": "#a1a1aa",
+      "50": "#fafafa",
+      "500": "#71717a",
+      "600": "#52525b",
+      "700": "#3f3f46",
+      "800": "#27272a",
+      "900": "#18181b"
+    },
+    primary: {
+      "100": "#ccfbf1",
+      "200": "#99f6e4",
+      "300": "#5eead4",
+      "400": "#2dd4bf",
+      "50": "#f0fdfa",
+      "500": "#14b8a6",
+      "600": "#0d9488",
+      "700": "#0f766e",
+      "800": "#115e59",
+      "900": "#134e4a"
+    },
+    success: "#22c55e",
+    warning: "#f59e0b"
+  },
+  fontFamily: {
+    body: "system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif",
+    display: "ui-serif, Georgia, 'Times New Roman', serif",
+    mono: "ui-monospace, 'SF Mono', Menlo, Consolas, 'DejaVu Sans Mono', monospace"
+  },
+  fontSize: {
+    "2xl": "24px",
+    "3xl": "30px",
+    "4xl": "36px",
+    lg: "18px",
+    md: "16px",
+    sm: "14px",
+    xl: "20px",
+    xs: "12px"
+  },
+  fontWeight: {
+    bold: "700",
+    medium: "500",
+    regular: "400",
+    semibold: "600"
+  },
+  lineHeight: {
+    normal: "1.4",
+    relaxed: "1.6",
+    tight: "1.2"
+  },
+  radius: {
+    "2xl": "16px",
+    full: "9999px",
+    lg: "8px",
+    md: "6px",
+    none: "0px",
+    sm: "4px",
+    xl: "12px"
+  },
+  semantic: {
+    background: {
+      default: "#18181b",
+      elevated: "#3f3f46",
+      subtle: "#27272a"
+    },
+    border: {
+      default: "#3f3f46",
+      strong: "#52525b"
+    },
+    interactive: {
+      destructive: "#ef4444",
+      primary: "#2dd4bf",
+      primaryHover: "#5eead4",
+      primaryPressed: "#99f6e4"
+    },
+    text: {
+      default: "#fafafa",
+      inverted: "#18181b",
+      muted: "#a1a1aa"
+    }
+  },
+  shadow: {
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+    sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)"
+  },
+  spacing: {
+    "0": "0px",
+    "1": "4px",
+    "10": "40px",
+    "12": "48px",
+    "16": "64px",
+    "2": "8px",
+    "20": "80px",
+    "24": "96px",
+    "3": "12px",
+    "4": "16px",
+    "5": "20px",
+    "6": "24px",
+    "8": "32px"
+  }
+};
+var defaultTheme = {
+  light: theme,
+  dark: themeDark
+};
+var ThemeContext = react.createContext(defaultTheme);
+ThemeContext.displayName = "ThemeContext";
+var ColorSchemeOverrideContext = react.createContext(null);
+ColorSchemeOverrideContext.displayName = "ColorSchemeOverrideContext";
+var isWeb = reactNative.Platform.OS === "web";
+function readWebScheme() {
+  if (typeof document === "undefined") {
+    return "light";
+  }
+  const root = document.documentElement;
+  if (root.classList.contains("dark")) {
+    return "dark";
+  }
+  if (root.getAttribute("data-theme") === "dark") {
+    return "dark";
+  }
+  return "light";
+}
+__name(readWebScheme, "readWebScheme");
+function useColorScheme() {
+  const override = react.useContext(ColorSchemeOverrideContext);
+  const [scheme, setScheme] = react.useState(() => {
+    if (isWeb) {
+      return readWebScheme();
+    }
+    return reactNative.Appearance.getColorScheme() ?? "light";
+  });
+  react.useEffect(() => {
+    if (isWeb) {
+      const root = document.documentElement;
+      const update = /* @__PURE__ */ __name(() => setScheme(readWebScheme()), "update");
+      const observer = new MutationObserver(update);
+      observer.observe(root, { attributes: true, attributeFilter: ["class", "data-theme"] });
+      update();
+      return () => observer.disconnect();
+    }
+    const sub = reactNative.Appearance.addChangeListener(({ colorScheme }) => {
+      setScheme(colorScheme ?? "light");
+    });
+    return () => sub.remove();
+  }, []);
+  return override ?? scheme;
+}
+__name(useColorScheme, "useColorScheme");
+
+// src/theme/use-theme-colors.ts
+function useThemeColors() {
+  const scheme = useColorScheme();
+  const themePair = react.useContext(ThemeContext);
+  return scheme === "dark" ? themePair.dark : themePair.light;
+}
+__name(useThemeColors, "useThemeColors");
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  const out = [];
+  for (const input of inputs) {
+    append(out, input);
+  }
+  return out.join(" ");
+}
+__name(cn, "cn");
+function append(out, input) {
+  if (!input) {
+    return;
+  }
+  if (typeof input === "string") {
+    if (input.length > 0) {
+      out.push(input);
+    }
+    return;
+  }
+  if (typeof input === "number") {
+    return;
+  }
+  if (Array.isArray(input)) {
+    for (const inner of input) {
+      append(out, inner);
+    }
+    return;
+  }
+  if (typeof input === "object") {
+    for (const key of Object.keys(input)) {
+      if (input[key]) {
+        out.push(key);
+      }
+    }
+  }
+}
+__name(append, "append");
+
+// src/components/Calendar/scroll/ScrollBody.tsx
+var ScrollBody = /* @__PURE__ */ __name((_props) => {
+  throw new Error(
+    "[Calendar] ScrollBody: no platform implementation resolved. Ensure your bundler honors *.web.tsx / *.native.tsx extensions."
+  );
+}, "ScrollBody");
+
+// src/components/Calendar/state/locale-utils.ts
+var getFirstDayOfWeek = /* @__PURE__ */ __name((locale) => {
+  try {
+    const loc = new Intl.Locale(locale);
+    const info = loc.getWeekInfo?.() ?? loc.weekInfo;
+    if (typeof info?.firstDay === "number") {
+      return info.firstDay === 7 ? 0 : info.firstDay;
+    }
+  } catch {
+  }
+  return FIRST_DAY_FALLBACK[locale] ?? FIRST_DAY_FALLBACK[locale.split("-")[0] ?? ""] ?? 1;
+}, "getFirstDayOfWeek");
+var FIRST_DAY_FALLBACK = {
+  en: 0,
+  "en-US": 0,
+  "en-CA": 0,
+  "en-GB": 1,
+  "en-AU": 1,
+  de: 1,
+  fr: 1,
+  ja: 0,
+  ar: 0,
+  he: 0,
+  fa: 6
+};
+var getWeekendDays = /* @__PURE__ */ __name((locale) => {
+  try {
+    const loc = new Intl.Locale(locale);
+    const info = loc.getWeekInfo?.() ?? loc.weekInfo;
+    if (info?.weekend && Array.isArray(info.weekend) && info.weekend.length === 2) {
+      const [a, b] = info.weekend.map((d) => d === 7 ? 0 : d);
+      return [a, b];
+    }
+  } catch {
+  }
+  return WEEKEND_FALLBACK[locale] ?? WEEKEND_FALLBACK[locale.split("-")[0] ?? ""] ?? [6, 0];
+}, "getWeekendDays");
+var WEEKEND_FALLBACK = {
+  "en-US": [6, 0],
+  "de-DE": [6, 0],
+  "fr-FR": [6, 0],
+  "ja-JP": [6, 0],
+  "ar-SA": [5, 6],
+  "ar-AE": [5, 6],
+  "he-IL": [5, 6],
+  "fa-IR": [4, 5],
+  en: [6, 0],
+  de: [6, 0],
+  fr: [6, 0],
+  ar: [5, 6],
+  he: [5, 6]
+};
+var formatWeekdayNames = /* @__PURE__ */ __name((locale, format = "short") => {
+  const fmt = new Intl.DateTimeFormat(locale, { weekday: format });
+  const start = getFirstDayOfWeek(locale);
+  return Array.from({ length: 7 }, (_, i) => {
+    const d = new Date(Date.UTC(2026, 0, 4 + (start + i) % 7));
+    return fmt.format(d);
+  });
+}, "formatWeekdayNames");
+var formatMonthYearTitle = /* @__PURE__ */ __name((date, locale) => {
+  const fmt = new Intl.DateTimeFormat(locale, { month: "long", year: "numeric" });
+  return fmt.format(date.toDate("UTC"));
+}, "formatMonthYearTitle");
+var formatMonthNames = /* @__PURE__ */ __name((locale) => {
+  const fmt = new Intl.DateTimeFormat(locale, { month: "long" });
+  return Array.from({ length: 12 }, (_, m) => fmt.format(new Date(Date.UTC(2026, m, 15))));
+}, "formatMonthNames");
+var useCalendarKeyboard = /* @__PURE__ */ __name((props) => {
+  const { focusedDate, moveFocus, selectDate, firstDayOfWeek = 0 } = props;
+  const onKeyDown = react.useCallback(
+    (event) => {
+      const focusedDow = focusedDate.toDate("UTC").getUTCDay();
+      switch (event.key) {
+        case "ArrowLeft":
+          event.preventDefault();
+          moveFocus({ days: -1 });
+          return;
+        case "ArrowRight":
+          event.preventDefault();
+          moveFocus({ days: 1 });
+          return;
+        case "ArrowUp":
+          event.preventDefault();
+          moveFocus({ weeks: -1 });
+          return;
+        case "ArrowDown":
+          event.preventDefault();
+          moveFocus({ weeks: 1 });
+          return;
+        case "PageUp":
+          event.preventDefault();
+          moveFocus(event.shiftKey ? { years: -1 } : { months: -1 });
+          return;
+        case "PageDown":
+          event.preventDefault();
+          moveFocus(event.shiftKey ? { years: 1 } : { months: 1 });
+          return;
+        case "Home": {
+          event.preventDefault();
+          const back = (focusedDow - firstDayOfWeek + 7) % 7;
+          moveFocus({ days: -back });
+          return;
+        }
+        case "End": {
+          event.preventDefault();
+          const back = (focusedDow - firstDayOfWeek + 7) % 7;
+          const forward = 6 - back;
+          moveFocus({ days: forward });
+          return;
+        }
+        case "Enter":
+        case " ":
+          event.preventDefault();
+          selectDate(focusedDate, "keyboard");
+          return;
+        default:
+          return;
+      }
+    },
+    [focusedDate, firstDayOfWeek, moveFocus, selectDate]
+  );
+  return { onKeyDown };
+}, "useCalendarKeyboard");
+
+// src/components/Calendar/state/constraints.ts
+var cmp = /* @__PURE__ */ __name((a, b) => a.compare(b), "cmp");
+var isOutOfRange = /* @__PURE__ */ __name((date, bounds = {}) => {
+  if (bounds.minValue && cmp(date, bounds.minValue) < 0) {
+    return true;
+  }
+  if (bounds.maxValue && cmp(date, bounds.maxValue) > 0) {
+    return true;
+  }
+  return false;
+}, "isOutOfRange");
+var composeUnavailable = /* @__PURE__ */ __name((c) => (date) => {
+  if (isOutOfRange(date, c)) {
+    return true;
+  }
+  if (c.isDateUnavailable?.(date)) {
+    return true;
+  }
+  return false;
+}, "composeUnavailable");
+
+// src/components/Calendar/state/use-calendar-state.ts
+var initialFocus = /* @__PURE__ */ __name((mode, value, fallback) => {
+  if (!value) {
+    return fallback;
+  }
+  if (mode === "single") {
+    return value ?? fallback;
+  }
+  if (mode === "range") {
+    const r = value;
+    return r?.start ?? fallback;
+  }
+  const arr = value;
+  return arr[0] ?? fallback;
+}, "initialFocus");
+var useCalendarState = /* @__PURE__ */ __name((props) => {
+  const mode = props.mode ?? "single";
+  const fallback = date.today(date.getLocalTimeZone());
+  const [internalValue, setInternalValue] = react.useState(() => {
+    if (props.value !== void 0) {
+      return props.value;
+    }
+    if (props.defaultValue !== void 0) {
+      return props.defaultValue;
+    }
+    return mode === "multiple" ? [] : null;
+  });
+  const isControlled = props.value !== void 0;
+  const value = isControlled ? props.value : internalValue;
+  const [internalView, setInternalView] = react.useState(props.defaultView ?? "day");
+  const isViewControlled = props.view !== void 0;
+  const view = isViewControlled ? props.view : internalView;
+  const [focusedDate, setFocusedDate] = react.useState(() => initialFocus(mode, value, fallback));
+  const isUnavailable = react.useMemo(
+    () => composeUnavailable({
+      ...props.minValue !== void 0 ? { minValue: props.minValue } : {},
+      ...props.maxValue !== void 0 ? { maxValue: props.maxValue } : {},
+      ...props.isDateUnavailable !== void 0 ? { isDateUnavailable: props.isDateUnavailable } : {}
+    }),
+    [props.minValue, props.maxValue, props.isDateUnavailable]
+  );
+  const setView = react.useCallback(
+    (next) => {
+      if (!isViewControlled) {
+        setInternalView(next);
+      }
+      props.onViewChange?.(next);
+    },
+    [isViewControlled, props.onViewChange]
+  );
+  const moveFocus = react.useCallback(
+    (delta) => {
+      setFocusedDate((cur) => {
+        let next = cur;
+        if (delta.days) {
+          next = next.add({ days: delta.days });
+        }
+        if (delta.weeks) {
+          next = next.add({ weeks: delta.weeks });
+        }
+        if (delta.months) {
+          next = next.add({ months: delta.months });
+        }
+        if (delta.years) {
+          next = next.add({ years: delta.years });
+        }
+        if (!isUnavailable(next)) {
+          return next;
+        }
+        const totalDelta = (delta.days ?? 0) + (delta.weeks ?? 0) * 7 + (delta.months ?? 0) * 30 + (delta.years ?? 0) * 365;
+        const sign = totalDelta >= 0 ? 1 : -1;
+        for (let i = 1; i <= 100; i++) {
+          const candidate = next.add({ days: sign * i });
+          if (!isUnavailable(candidate)) {
+            return candidate;
+          }
+        }
+        return cur;
+      });
+    },
+    [isUnavailable]
+  );
+  const selectDate = react.useCallback(
+    (date, source) => {
+      if (isUnavailable(date)) {
+        return;
+      }
+      const meta = { view, source };
+      let next;
+      if (mode === "single") {
+        next = date;
+      } else if (mode === "multiple") {
+        const arr = value ?? [];
+        const exists = arr.some((d) => d.compare(date) === 0);
+        next = exists ? arr.filter((d) => d.compare(date) !== 0) : [...arr, date];
+      } else {
+        return;
+      }
+      if (!isControlled) {
+        setInternalValue(next);
+      }
+      props.onChange?.(next, meta);
+      setFocusedDate(date);
+    },
+    [isControlled, isUnavailable, mode, props.onChange, value, view]
+  );
+  return {
+    value,
+    view,
+    focusedDate,
+    setView,
+    moveFocus,
+    setFocusedDate,
+    selectDate,
+    isUnavailable
+  };
+}, "useCalendarState");
+var order = /* @__PURE__ */ __name((a, b) => a.compare(b) <= 0 ? [a, b] : [b, a], "order");
+var nightsBetween = /* @__PURE__ */ __name((a, b) => {
+  const [first, last] = order(a, b);
+  return Math.round((last.toDate("UTC").getTime() - first.toDate("UTC").getTime()) / 864e5);
+}, "nightsBetween");
+var useRangeState = /* @__PURE__ */ __name((props) => {
+  const [internal, setInternal] = react.useState(props.defaultValue ?? null);
+  const isControlled = props.value !== void 0;
+  const value = isControlled ? props.value ?? null : internal;
+  const [hoveredDate, setHoveredDate] = react.useState(null);
+  const isUnavailable = react.useMemo(
+    () => composeUnavailable({
+      ...props.minValue !== void 0 ? { minValue: props.minValue } : {},
+      ...props.maxValue !== void 0 ? { maxValue: props.maxValue } : {},
+      ...props.isDateUnavailable !== void 0 ? { isDateUnavailable: props.isDateUnavailable } : {}
+    }),
+    [props.minValue, props.maxValue, props.isDateUnavailable]
+  );
+  const commit = react.useCallback(
+    (next, source) => {
+      if (!isControlled) {
+        setInternal(next);
+      }
+      props.onChange?.(next, { view: "day", source });
+    },
+    [isControlled, props.onChange]
+  );
+  const selectDate = react.useCallback(
+    (date, source = "click") => {
+      if (isUnavailable(date)) {
+        return;
+      }
+      if (!value || value.end !== null) {
+        commit({ start: date, end: null }, source);
+        setHoveredDate(null);
+        return;
+      }
+      const nights = nightsBetween(value.start, date);
+      if (props.minNights !== void 0 && nights < props.minNights) {
+        return;
+      }
+      if (props.maxNights !== void 0 && nights > props.maxNights) {
+        return;
+      }
+      const [start, end] = order(value.start, date);
+      commit({ start, end }, source);
+      setHoveredDate(null);
+    },
+    [commit, isUnavailable, props.maxNights, props.minNights, value]
+  );
+  const previewRange = react.useMemo(() => {
+    if (!value || value.end !== null || !hoveredDate) {
+      return null;
+    }
+    const [start, end] = order(value.start, hoveredDate);
+    return { start, end };
+  }, [hoveredDate, value]);
+  return {
+    value,
+    previewRange,
+    hoveredDate,
+    selectDate,
+    setHoveredDate,
+    isUnavailable
+  };
+}, "useRangeState");
+
+// src/i18n/default-dictionary.ts
+var defaultDictionary = {
+  // generic / shared
+  "common.cancel": "Cancel",
+  "common.confirm": "Confirm",
+  "common.close": "Close",
+  "common.back": "Back",
+  "common.loading": "Loading",
+  "common.error": "Something went wrong",
+  "common.retry": "Try again",
+  // breadcrumb
+  "breadcrumb.ariaLabel": "Breadcrumb",
+  "breadcrumb.expandLabel": "Show full path",
+  "breadcrumb.ellipsisLabel": "More",
+  "breadcrumb.currentPageLabel": "Current page",
+  "breadcrumb.siblingMenuLabel": "Open sibling pages",
+  // pagination
+  "pagination.ariaLabel": "Pagination",
+  "pagination.previous": "Previous page",
+  "pagination.next": "Next page",
+  "pagination.first": "First page",
+  "pagination.last": "Last page",
+  "pagination.ellipsis": "More pages",
+  "pagination.currentPage": "Current page",
+  "pagination.gotoPage": "Go to page {{page}}",
+  "pagination.range": "Showing {{from}}\u2013{{to}} of {{total}}",
+  "pagination.pageOf": "Page {{page}} of {{total}}",
+  "pagination.pageSizeLabel": "Items per page",
+  "pagination.jumperLabel": "Go to page",
+  "pagination.jumperPlaceholder": "#",
+  // floatButton
+  "floatButton.backToTop": "Back to top",
+  // calendar
+  "calendar.header.previous": "Previous month",
+  "calendar.header.next": "Next month",
+  "calendar.header.openMonthView": "Open month picker",
+  "calendar.header.openYearView": "Open year picker",
+  "calendar.header.openDayView": "Open day picker",
+  "calendar.today": "Today",
+  "calendar.clear": "Clear",
+  // button
+  "button.loadingLabel": "Loading",
+  // input
+  "input.clear": "Clear",
+  "input.passwordShow": "Show password",
+  "input.passwordHide": "Hide password",
+  // checkbox / switch
+  "checkbox.checked": "Checked",
+  "checkbox.unchecked": "Unchecked",
+  "switch.on": "On",
+  "switch.off": "Off",
+  // field
+  "field.requiredIndicator": "*",
+  "field.requiredLabel": "required"
+};
+
+// src/i18n/resolve.ts
+function resolveI18n(input, defaults) {
+  if (typeof input === "function") {
+    return (keyOrKeys, options) => input(keyOrKeys, options);
+  }
+  const dict = input ?? {};
+  return (keyOrKeys, options) => {
+    const keys = Array.isArray(keyOrKeys) ? keyOrKeys : [keyOrKeys];
+    for (const rawKey of keys) {
+      const key = pluralize(rawKey, options?.count);
+      const template = dict[key] ?? defaults[key];
+      if (template !== void 0) {
+        return interpolate(template, options);
+      }
+    }
+    const lastKey = keys[keys.length - 1];
+    if (options?.defaultValue !== void 0) {
+      return interpolate(options.defaultValue, options);
+    }
+    return lastKey ?? "";
+  };
+}
+__name(resolveI18n, "resolveI18n");
+function pluralize(key, count) {
+  if (count === void 0) {
+    return key;
+  }
+  if (count === 1) {
+    return `${key}_one`;
+  }
+  return `${key}_other`;
+}
+__name(pluralize, "pluralize");
+function interpolate(template, options) {
+  if (!options) {
+    return template;
+  }
+  return template.replace(/\{\{\s*([A-Za-z0-9_.-]+)\s*\}\}/g, (_match, name) => {
+    const value = options[name];
+    return value === void 0 || value === null ? "" : String(value);
+  });
+}
+__name(interpolate, "interpolate");
+var defaultValue = {
+  t: resolveI18n(void 0, defaultDictionary)
+};
+var I18nContext = react.createContext(defaultValue);
+I18nContext.displayName = "I18nContext";
+
+// src/i18n/use-translation.ts
+function useTranslation() {
+  return react.useContext(I18nContext);
+}
+__name(useTranslation, "useTranslation");
+var isWeb2 = reactNative.Platform.OS === "web";
+var make = /* @__PURE__ */ __name(({ path, glyph }) => /* @__PURE__ */ __name(function PlaceholderIcon({ size = 20, color = "currentColor" }) {
+  const colors = useThemeColors();
+  if (isWeb2) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "svg",
+      {
+        width: size,
+        height: size,
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: color,
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        "aria-hidden": "true",
+        children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: path })
+      }
+    );
+  }
+  const resolvedColor = color === "currentColor" ? colors.semantic.text.default : color;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Text,
+    {
+      accessibilityElementsHidden: true,
+      importantForAccessibility: "no-hide-descendants",
+      style: { fontSize: size, lineHeight: size, color: resolvedColor },
+      children: glyph
+    }
+  );
+}, "PlaceholderIcon"), "make");
+var defaultSemanticIcons = {
+  checkmark: make({ path: "M20 6 9 17l-5-5", glyph: "\u2713" }),
+  close: make({ path: "M18 6 6 18 M6 6l12 12", glyph: "\u2715" }),
+  eye: make({
+    path: "M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12z M12 9a3 3 0 1 0 0 6 3 3 0 0 0 0-6z",
+    glyph: "\u{1F441}"
+  }),
+  eyeOff: make({
+    path: "M17.94 17.94A10 10 0 0 1 2 12s3.5-7 10-7c2 0 3.8.6 5.4 1.5 M1 1l22 22",
+    glyph: "\u{1F648}"
+  }),
+  chevronDown: make({ path: "m6 9 6 6 6-6", glyph: "\u2304" }),
+  chevronUp: make({ path: "m18 15-6-6-6 6", glyph: "\u2303" }),
+  alertTriangle: make({
+    path: "M12 9v4 M12 17h.01 M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z",
+    glyph: "\u26A0"
+  }),
+  info: make({
+    path: "M12 8h.01 M11 12h1v4h1 M12 22C6.48 22 2 17.52 2 12 2 6.48 6.48 2 12 2c5.52 0 10 4.48 10 10 0 5.52-4.48 10-10 10z",
+    glyph: "\u24D8"
+  }),
+  check: make({ path: "M20 6 9 17l-5-5", glyph: "\u2713" }),
+  x: make({ path: "M18 6 6 18 M6 6l12 12", glyph: "\u2715" })
+};
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_ITEM_HEIGHT = 36;
+var DEFAULT_MAX_MENU = 320;
+var SEARCH_DEBOUNCE_MS = 150;
+var VIRTUAL_OVERSCAN = 4;
+var TYPE_AHEAD_RESET_MS = 500;
+var defaultFilter = /* @__PURE__ */ __name((option, search) => {
+  if (!search) {
+    return true;
+  }
+  return option.label.toLowerCase().includes(search.toLowerCase());
+}, "defaultFilter");
+var Select = /* @__PURE__ */ __name((props) => {
+  const {
+    options: staticOptions,
+    loadOptions,
+    pageSize = DEFAULT_PAGE_SIZE,
+    searchable: searchableProp,
+    searchPlaceholder = "Search\u2026",
+    filterOption,
+    renderOption,
+    placeholder = "Select\u2026",
+    locale,
+    sortByLocale = true,
+    noOptionsMessage = "No options",
+    loadingMessage = "Loading\u2026",
+    disabled = false,
+    dir = "ltr",
+    virtualized: virtualizedProp,
+    itemHeight = DEFAULT_ITEM_HEIGHT,
+    maxMenuHeight = DEFAULT_MAX_MENU,
+    className,
+    testID,
+    id,
+    name
+  } = props;
+  const ariaLabel = props["aria-label"];
+  const ariaLabelledBy = props["aria-labelledby"];
+  const ariaDescribedBy = props["aria-describedby"];
+  const ariaInvalid = props["aria-invalid"];
+  const ariaRequired = props["aria-required"];
+  const multiple = props.multiple === true;
+  const maxSelected = multiple ? props.maxSelected : void 0;
+  const maxChips = multiple ? props.maxChips ?? 3 : void 0;
+  const baseId = react.useId();
+  const colors = useThemeColors();
+  const [open, setOpen] = react.useState(false);
+  const controlledValues = multiple ? props.value : props.value !== void 0 ? [props.value] : void 0;
+  const defaultValues = multiple ? props.defaultValue ?? [] : props.defaultValue !== void 0 ? [props.defaultValue] : [];
+  const [innerValues, setInnerValues] = react.useState(defaultValues);
+  const isControlled = controlledValues !== void 0;
+  const currentValues = isControlled ? controlledValues : innerValues;
+  const current = currentValues[0];
+  const [searchInput, setSearchInput] = react.useState("");
+  const [debouncedSearch, setDebouncedSearch] = react.useState("");
+  const [activeIndex, setActiveIndex] = react.useState(0);
+  react.useEffect(() => {
+    const t = setTimeout(() => setDebouncedSearch(searchInput), SEARCH_DEBOUNCE_MS);
+    return () => clearTimeout(t);
+  }, [searchInput]);
+  const [asyncItems, setAsyncItems] = react.useState([]);
+  const [asyncLoading, setAsyncLoading] = react.useState(false);
+  const [asyncTotal, setAsyncTotal] = react.useState(void 0);
+  const asyncRequestId = react.useRef(0);
+  const isAsync = loadOptions !== void 0;
+  react.useEffect(() => {
+    if (!isAsync || !loadOptions || !open) {
+      return;
+    }
+    const requestId = ++asyncRequestId.current;
+    setAsyncLoading(true);
+    setAsyncItems([]);
+    setAsyncTotal(void 0);
+    loadOptions({ search: debouncedSearch, offset: 0, limit: pageSize }).then((result) => {
+      if (requestId !== asyncRequestId.current) {
+        return;
+      }
+      setAsyncItems(result.items.slice());
+      setAsyncTotal(result.total);
+    }).catch(() => {
+    }).finally(() => {
+      if (requestId === asyncRequestId.current) {
+        setAsyncLoading(false);
+      }
+    });
+  }, [debouncedSearch, isAsync, loadOptions, pageSize, open]);
+  const loadMore = react.useCallback(() => {
+    if (!isAsync || !loadOptions || asyncLoading) {
+      return;
+    }
+    const haveAll = asyncTotal !== void 0 && asyncItems.length >= asyncTotal;
+    if (haveAll) {
+      return;
+    }
+    const requestId = ++asyncRequestId.current;
+    setAsyncLoading(true);
+    loadOptions({ search: debouncedSearch, offset: asyncItems.length, limit: pageSize }).then((result) => {
+      if (requestId !== asyncRequestId.current) {
+        return;
+      }
+      setAsyncItems((prev) => prev.concat(result.items));
+      if (result.total !== void 0) {
+        setAsyncTotal(result.total);
+      }
+    }).catch(() => void 0).finally(() => {
+      if (requestId === asyncRequestId.current) {
+        setAsyncLoading(false);
+      }
+    });
+  }, [asyncItems.length, asyncLoading, asyncTotal, debouncedSearch, isAsync, loadOptions, pageSize]);
+  const visibleOptions = react.useMemo(() => {
+    const source = isAsync ? asyncItems : staticOptions ?? [];
+    const filtered = isAsync ? source.slice() : source.filter((opt) => (filterOption ?? defaultFilter)(opt, debouncedSearch));
+    if (locale && sortByLocale) {
+      const collator = new Intl.Collator(locale, { sensitivity: "base", numeric: true });
+      return filtered.slice().sort((a, b) => {
+        const ga = a.group ?? "";
+        const gb = b.group ?? "";
+        const groupDelta = collator.compare(ga, gb);
+        if (groupDelta !== 0) {
+          return groupDelta;
+        }
+        return collator.compare(a.label, b.label);
+      });
+    }
+    return filtered;
+  }, [isAsync, asyncItems, staticOptions, filterOption, debouncedSearch, locale, sortByLocale]);
+  const selectedOption = react.useMemo(() => {
+    const all = isAsync ? asyncItems : staticOptions ?? [];
+    return all.find((o) => o.value === current);
+  }, [asyncItems, isAsync, staticOptions, current]);
+  const selectedOptions = react.useMemo(() => {
+    if (!multiple) {
+      return [];
+    }
+    const all = isAsync ? asyncItems : staticOptions ?? [];
+    const map = new Map(all.map((o) => [o.value, o]));
+    return currentValues.map((v) => map.get(v)).filter((o) => o !== void 0);
+  }, [multiple, currentValues, asyncItems, isAsync, staticOptions]);
+  const searchable = searchableProp ?? (isAsync || staticOptions !== void 0 && staticOptions.length >= 10);
+  const virtualized = virtualizedProp ?? visibleOptions.length > 100;
+  react.useEffect(() => {
+    setActiveIndex((idx) => Math.min(Math.max(0, idx), Math.max(0, visibleOptions.length - 1)));
+  }, [visibleOptions.length]);
+  const onSelect = react.useCallback(
+    (option) => {
+      if (option.disabled) {
+        return;
+      }
+      if (multiple) {
+        const has = currentValues.includes(option.value);
+        let nextValues;
+        if (has) {
+          nextValues = currentValues.filter((v) => v !== option.value);
+        } else {
+          if (maxSelected !== void 0 && currentValues.length >= maxSelected) {
+            return;
+          }
+          nextValues = [...currentValues, option.value];
+        }
+        if (!isControlled) {
+          setInnerValues(nextValues);
+        }
+        const allOpts = [
+          ...staticOptions ?? [],
+          ...asyncItems
+        ];
+        const optMap = new Map(allOpts.map((o) => [o.value, o]));
+        const selectedOpts = nextValues.map((v) => optMap.get(v)).filter((o) => o !== void 0);
+        props.onChange?.(nextValues, selectedOpts);
+        return;
+      }
+      if (!isControlled) {
+        setInnerValues([option.value]);
+      }
+      props.onChange?.(option.value, option);
+      setOpen(false);
+      setSearchInput("");
+    },
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `props` is the discriminated union — destructuring it would defeat the narrowing; the asyncItems / staticOptions captures intentionally re-trigger the callback when the option pool changes
+    [multiple, isControlled, currentValues, maxSelected, staticOptions, asyncItems, props]
+  );
+  const clearAll = react.useCallback(() => {
+    if (!isControlled) {
+      setInnerValues([]);
+    }
+    props.onChange?.([], []);
+  }, [isControlled, props]);
+  const moveActive = react.useCallback(
+    (delta) => {
+      setActiveIndex((idx) => {
+        if (visibleOptions.length === 0) {
+          return 0;
+        }
+        let next = (idx + delta + visibleOptions.length) % visibleOptions.length;
+        for (let attempts = 0; attempts < visibleOptions.length; attempts += 1) {
+          if (!visibleOptions[next]?.disabled) {
+            return next;
+          }
+          next = (next + delta + visibleOptions.length) % visibleOptions.length;
+        }
+        return idx;
+      });
+    },
+    [visibleOptions]
+  );
+  const typeAheadRef = react.useRef({
+    buffer: "",
+    timer: null
+  });
+  react.useEffect(() => {
+    return () => {
+      if (typeAheadRef.current.timer) {
+        clearTimeout(typeAheadRef.current.timer);
+        typeAheadRef.current.timer = null;
+      }
+    };
+  }, []);
+  const handleTypeAhead = react.useCallback(
+    (char) => {
+      if (visibleOptions.length === 0) {
+        return;
+      }
+      if (typeAheadRef.current.timer) {
+        clearTimeout(typeAheadRef.current.timer);
+      }
+      const nextBuffer = typeAheadRef.current.buffer + char.toLowerCase();
+      typeAheadRef.current.buffer = nextBuffer;
+      typeAheadRef.current.timer = setTimeout(() => {
+        typeAheadRef.current.buffer = "";
+        typeAheadRef.current.timer = null;
+      }, TYPE_AHEAD_RESET_MS);
+      const allSame = nextBuffer.length > 1 && nextBuffer.split("").every((c) => c === nextBuffer[0]);
+      const cycleMode = nextBuffer.length === 1 || allSame;
+      const needle = cycleMode ? nextBuffer.charAt(0) : nextBuffer;
+      const len = visibleOptions.length;
+      const startFrom = cycleMode ? (activeIndex + 1) % len : 0;
+      for (let i = 0; i < len; i += 1) {
+        const idx = (startFrom + i) % len;
+        const opt = visibleOptions[idx];
+        if (!opt || opt.disabled) {
+          continue;
+        }
+        if (opt.label.toLowerCase().startsWith(needle)) {
+          setActiveIndex(idx);
+          return;
+        }
+      }
+    },
+    [visibleOptions, activeIndex]
+  );
+  const handleListKeyDown = react.useCallback(
+    (event) => {
+      switch (event.key) {
+        case "ArrowDown":
+          event.preventDefault();
+          moveActive(1);
+          return true;
+        case "ArrowUp":
+          event.preventDefault();
+          moveActive(-1);
+          return true;
+        case "Home": {
+          event.preventDefault();
+          const idx = visibleOptions.findIndex((o) => !o.disabled);
+          if (idx >= 0) {
+            setActiveIndex(idx);
+          }
+          return true;
+        }
+        case "End": {
+          event.preventDefault();
+          for (let i = visibleOptions.length - 1; i >= 0; i -= 1) {
+            if (!visibleOptions[i]?.disabled) {
+              setActiveIndex(i);
+              break;
+            }
+          }
+          return true;
+        }
+        case "Enter": {
+          const opt = visibleOptions[activeIndex];
+          if (opt) {
+            event.preventDefault();
+            onSelect(opt);
+          }
+          return true;
+        }
+        case "Escape":
+          event.preventDefault();
+          setOpen(false);
+          if (reactNative.Platform.OS === "web") {
+            const trigger = triggerRef.current;
+            trigger?.focus?.();
+          }
+          return true;
+        case "Tab":
+          setOpen(false);
+          return true;
+      }
+      return false;
+    },
+    [moveActive, activeIndex, visibleOptions, onSelect]
+  );
+  const handleSearchKeyDown = react.useCallback(
+    (event) => {
+      handleListKeyDown(event);
+    },
+    [handleListKeyDown]
+  );
+  const handlePopupKeyDown = react.useCallback(
+    (event) => {
+      if (handleListKeyDown(event)) {
+        return;
+      }
+      if (event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== " ") {
+        event.preventDefault();
+        handleTypeAhead(event.key);
+      }
+    },
+    [handleListKeyDown, handleTypeAhead]
+  );
+  const handleTriggerKeyDown = react.useCallback(
+    (event) => {
+      switch (event.key) {
+        case " ":
+        case "Enter":
+        case "ArrowDown":
+        case "ArrowUp":
+          event.preventDefault();
+          setOpen(true);
+          return;
+      }
+      if (!disabled && event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey) {
+        event.preventDefault();
+        setOpen(true);
+        handleTypeAhead(event.key);
+      }
+    },
+    [disabled, handleTypeAhead]
+  );
+  const containerRef = react.useRef(null);
+  const triggerRef = react.useRef(null);
+  const popupRef = react.useRef(null);
+  react.useEffect(() => {
+    if (reactNative.Platform.OS !== "web" || typeof document === "undefined" || typeof document.addEventListener !== "function") {
+      return;
+    }
+    if (!open) {
+      return;
+    }
+    const onDocClick = /* @__PURE__ */ __name((event) => {
+      const node = containerRef.current;
+      const popup = popupRef.current;
+      const target = event.target;
+      if (node?.contains(target)) {
+        return;
+      }
+      if (popup?.contains(target)) {
+        return;
+      }
+      setOpen(false);
+    }, "onDocClick");
+    document.addEventListener("mousedown", onDocClick);
+    return () => document.removeEventListener("mousedown", onDocClick);
+  }, [open]);
+  const [triggerRect, setTriggerRect] = react.useState(
+    null
+  );
+  const measureTrigger = react.useCallback(() => {
+    const node = triggerRef.current;
+    if (!node) {
+      return;
+    }
+    if (reactNative.Platform.OS === "web" && typeof node.getBoundingClientRect === "function") {
+      const rect = node.getBoundingClientRect();
+      setTriggerRect({ top: rect.top, left: rect.left, width: rect.width, height: rect.height });
+      return;
+    }
+    if (typeof node.measure === "function") {
+      node.measure((_x, _y, w, h, pageX, pageY) => {
+        setTriggerRect({ top: pageY, left: pageX, width: w, height: h });
+      });
+    }
+  }, []);
+  react.useEffect(() => {
+    if (!open) {
+      return;
+    }
+    if (reactNative.Platform.OS !== "web" || typeof window === "undefined" || typeof window.addEventListener !== "function") {
+      return;
+    }
+    measureTrigger();
+    window.addEventListener("scroll", measureTrigger, true);
+    window.addEventListener("resize", measureTrigger);
+    return () => {
+      window.removeEventListener("scroll", measureTrigger, true);
+      window.removeEventListener("resize", measureTrigger);
+    };
+  }, [open, measureTrigger]);
+  react.useEffect(() => {
+    if (!open || searchable || reactNative.Platform.OS !== "web") {
+      return;
+    }
+    const id2 = requestAnimationFrame(() => {
+      const node = popupRef.current;
+      node?.focus?.();
+    });
+    return () => cancelAnimationFrame(id2);
+  }, [open, searchable]);
+  const onListScroll = react.useCallback(
+    (event) => {
+      if (!isAsync) {
+        return;
+      }
+      const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
+      const remaining = contentSize.height - contentOffset.y - layoutMeasurement.height;
+      if (remaining < itemHeight * 4) {
+        loadMore();
+      }
+    },
+    [isAsync, itemHeight, loadMore]
+  );
+  const triggerStyle = {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: px(colors.spacing["2"]),
+    paddingHorizontal: px(colors.spacing["3"]),
+    paddingVertical: px(colors.spacing["2"]),
+    minHeight: 36,
+    // component-density literal — not from theme
+    borderWidth: 1,
+    borderColor: colors.semantic.border.default,
+    borderRadius: px(colors.radius.md),
+    backgroundColor: colors.semantic.background.elevated,
+    opacity: disabled ? 0.6 : 1
+  };
+  const winDims = reactNative.useWindowDimensions();
+  const popupStyle = triggerRect ? {
+    position: reactNative.Platform.OS === "web" ? "fixed" : "absolute",
+    top: triggerRect.top + triggerRect.height + px(colors.spacing["1"]),
+    left: dir === "rtl" ? void 0 : triggerRect.left,
+    right: dir === "rtl" ? reactNative.Platform.OS === "web" && typeof window !== "undefined" ? window.innerWidth - (triggerRect.left + triggerRect.width) : winDims.width - (triggerRect.left + triggerRect.width) : void 0,
+    minWidth: Math.max(200, triggerRect.width),
+    backgroundColor: colors.semantic.background.elevated,
+    borderRadius: px(colors.radius.lg),
+    borderWidth: 1,
+    borderColor: colors.semantic.border.default,
+    // 2147483646 (max int32 - 1) so we sit above any third-party
+    // chrome (toasts, modals, dev banners) without picking a fight
+    // for the very top slot. Combined with portaling to body below,
+    // this also dodges any ancestor stacking context that would
+    // otherwise trap our z-index inside a sibling preview frame.
+    zIndex: 2147483646,
+    ...{ boxShadow: "0 10px 15px -3px rgba(0,0,0,0.1), 0 4px 6px -4px rgba(0,0,0,0.1)" }
+  } : {
+    // Trigger not yet measured — render off-screen until the
+    // first measurement lands. Avoids a one-frame flash at (0,0).
+    position: reactNative.Platform.OS === "web" ? "fixed" : "absolute",
+    top: -9999,
+    left: -9999
+  };
+  const containerProps = {
+    ref: /* @__PURE__ */ __name((node) => {
+      containerRef.current = node;
+    }, "ref"),
+    ...testID !== void 0 ? { testID } : {},
+    dir
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { ...containerProps, className: cn("relative", className), style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.Pressable,
+      {
+        ref: (node) => {
+          triggerRef.current = node;
+        },
+        ...{
+          onKeyDown: handleTriggerKeyDown,
+          role: "combobox",
+          accessibilityRole: "combobox",
+          "aria-expanded": open,
+          "aria-controls": `${baseId}-listbox`,
+          "aria-haspopup": "listbox",
+          tabIndex: disabled ? -1 : 0,
+          ...id !== void 0 ? { id, nativeID: id } : {},
+          ...name !== void 0 ? { name } : {},
+          ...ariaLabel !== void 0 ? { "aria-label": ariaLabel, accessibilityLabel: ariaLabel } : {},
+          ...ariaLabelledBy !== void 0 ? { "aria-labelledby": ariaLabelledBy, accessibilityLabelledBy: ariaLabelledBy } : {},
+          ...ariaDescribedBy !== void 0 ? { "aria-describedby": ariaDescribedBy, accessibilityDescribedBy: ariaDescribedBy } : {},
+          ...ariaInvalid === true ? { "aria-invalid": true } : {},
+          ...ariaRequired === true ? { "aria-required": true } : {},
+          ...disabled ? { "aria-disabled": true, disabled: true } : {}
+        },
+        onPress: () => {
+          if (disabled) {
+            return;
+          }
+          measureTrigger();
+          setOpen((v) => !v);
+        },
+        style: triggerStyle,
+        children: [
+          multiple ? /* @__PURE__ */ jsxRuntime.jsx(MultiTriggerLabel, { options: selectedOptions, placeholder, maxChips: maxChips ?? 3 }) : /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Text,
+            {
+              style: {
+                color: selectedOption ? colors.semantic.text.default : colors.semantic.text.muted,
+                fontFamily: colors.fontFamily.body,
+                fontSize: px(colors.fontSize.sm),
+                flex: 1
+              },
+              numberOfLines: 1,
+              children: selectedOption?.label ?? placeholder
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(defaultSemanticIcons.chevronDown, { size: 16, color: colors.semantic.text.muted })
+        ]
+      }
+    ),
+    open ? renderPopup() : null
+  ] });
+  function renderPopup() {
+    const popup = /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.View,
+      {
+        ref: (node) => {
+          popupRef.current = node;
+        },
+        ...{
+          role: "listbox",
+          id: `${baseId}-listbox`,
+          ...multiple ? { "aria-multiselectable": true } : {},
+          // Without a search field there's no input to capture
+          // keystrokes — make the popup itself focusable and own
+          // arrow / Enter / Escape / type-ahead. With a search
+          // field these belong to the input below.
+          ...searchable ? {} : { tabIndex: -1, onKeyDown: handlePopupKeyDown }
+        },
+        style: popupStyle,
+        children: [
+          searchable ? /* @__PURE__ */ jsxRuntime.jsx(
+            SearchInput,
+            {
+              value: searchInput,
+              onChange: setSearchInput,
+              onKeyDown: handleSearchKeyDown,
+              placeholder: searchPlaceholder,
+              dir
+            }
+          ) : null,
+          multiple && currentValues.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(MultiSelectionHeader, { count: currentValues.length, onClearAll: clearAll }) : null,
+          /* @__PURE__ */ jsxRuntime.jsx(
+            SelectList,
+            {
+              options: visibleOptions,
+              activeIndex,
+              currentValue: current,
+              selectedValues: currentValues,
+              multiple,
+              onSelect,
+              onActiveChange: setActiveIndex,
+              ...renderOption !== void 0 ? { renderOption } : {},
+              itemHeight,
+              maxHeight: maxMenuHeight,
+              virtualized,
+              loading: isAsync && asyncLoading,
+              loadingMessage,
+              noOptionsMessage,
+              listboxId: `${baseId}-listbox`,
+              onScroll: onListScroll
+            }
+          )
+        ]
+      }
+    );
+    if (reactNative.Platform.OS === "web" && typeof document !== "undefined") {
+      return reactDom.createPortal(popup, document.body);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Modal, { transparent: true, visible: true, animationType: "fade", onRequestClose: () => setOpen(false), statusBarTranslucent: true, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          onPress: () => setOpen(false),
+          style: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+          }
+        }
+      ),
+      popup
+    ] });
+  }
+}, "Select");
+var SearchInput = /* @__PURE__ */ __name(({ value, onChange, onKeyDown, placeholder, dir }) => {
+  const colors = useThemeColors();
+  const inputRef = react.useRef(null);
+  react.useEffect(() => {
+    inputRef.current?.focus?.();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: {
+        paddingHorizontal: px(colors.spacing["2"]),
+        paddingVertical: px(colors.spacing["2"]),
+        borderBottomWidth: 1,
+        borderBottomColor: colors.semantic.border.default
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: inputRef,
+          type: "text",
+          value,
+          onChange: (event) => onChange(event.target.value),
+          onKeyDown,
+          placeholder,
+          dir,
+          "aria-label": "Search options",
+          style: {
+            width: "100%",
+            // Inline `padding: '6px 8px'` shorthand intentionally kept as a
+            // string for the native HTML <input> — it's not an RN style prop.
+            padding: `${px(colors.spacing["2"]) - 2}px ${px(colors.spacing["2"])}px`,
+            fontFamily: colors.fontFamily.body,
+            fontSize: px(colors.fontSize.sm),
+            color: colors.semantic.text.default,
+            backgroundColor: colors.semantic.background.elevated,
+            border: `1px solid ${colors.semantic.border.default}`,
+            borderRadius: px(colors.radius.sm),
+            outline: "none"
+          }
+        }
+      )
+    }
+  );
+}, "SearchInput");
+var SelectList = /* @__PURE__ */ __name(({
+  options,
+  activeIndex,
+  currentValue,
+  selectedValues,
+  multiple,
+  onSelect,
+  onActiveChange,
+  renderOption,
+  itemHeight,
+  maxHeight,
+  virtualized,
+  loading,
+  loadingMessage,
+  noOptionsMessage,
+  listboxId,
+  onScroll
+}) => {
+  const colors = useThemeColors();
+  const [scrollTop, setScrollTop] = react.useState(0);
+  const totalHeight = options.length * itemHeight;
+  const visibleStart = virtualized ? Math.max(0, Math.floor(scrollTop / itemHeight) - VIRTUAL_OVERSCAN) : 0;
+  const visibleEnd = virtualized ? Math.min(options.length, Math.ceil((scrollTop + maxHeight) / itemHeight) + VIRTUAL_OVERSCAN) : options.length;
+  const handleScroll = /* @__PURE__ */ __name((event) => {
+    if (virtualized) {
+      setScrollTop(event.nativeEvent.contentOffset.y);
+    }
+    onScroll(event);
+  }, "handleScroll");
+  if (loading && options.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { padding: px(colors.spacing["4"]), alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Text,
+      {
+        style: {
+          color: colors.semantic.text.muted,
+          fontFamily: colors.fontFamily.body,
+          fontSize: px(colors.fontSize.sm)
+        },
+        children: loadingMessage
+      }
+    ) });
+  }
+  if (options.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { padding: px(colors.spacing["4"]), alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Text,
+      {
+        style: {
+          color: colors.semantic.text.muted,
+          fontFamily: colors.fontFamily.body,
+          fontSize: px(colors.fontSize.sm)
+        },
+        children: noOptionsMessage
+      }
+    ) });
+  }
+  const items = [];
+  let lastGroup;
+  for (let i = visibleStart; i < visibleEnd; i += 1) {
+    const opt = options[i];
+    if (!opt) {
+      continue;
+    }
+    if (opt.group !== lastGroup && opt.group !== void 0) {
+      items.push(
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.View,
+          {
+            style: {
+              paddingHorizontal: px(colors.spacing["3"]),
+              paddingTop: px(colors.spacing["2"]),
+              paddingBottom: px(colors.spacing["1"]),
+              position: virtualized ? "absolute" : "relative",
+              top: virtualized ? i * itemHeight - px(colors.spacing["4"]) : void 0,
+              left: 0,
+              right: 0
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              reactNative.Text,
+              {
+                style: {
+                  color: colors.semantic.text.muted,
+                  fontFamily: colors.fontFamily.body,
+                  fontSize: 11,
+                  // group header — component-density literal — not from theme (smaller than xs)
+                  fontWeight: colors.fontWeight.semibold,
+                  textTransform: "uppercase",
+                  letterSpacing: 0.5
+                },
+                children: opt.group
+              }
+            )
+          },
+          `grp-${i}-${opt.group}`
+        )
+      );
+      lastGroup = opt.group;
+    }
+    const selected = multiple ? selectedValues.includes(opt.value) : opt.value === currentValue;
+    const active = i === activeIndex;
+    const itemNode = renderOption ? renderOption(opt, { selected, active }) : /* @__PURE__ */ jsxRuntime.jsx(DefaultOptionRow, { option: opt, selected, active, multiple });
+    items.push(
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          ...{
+            role: "option",
+            accessibilityRole: "none",
+            "aria-selected": selected,
+            onMouseEnter: /* @__PURE__ */ __name(() => onActiveChange(i), "onMouseEnter"),
+            ...opt.disabled ? { "aria-disabled": true, disabled: true } : {}
+          },
+          onPress: () => onSelect(opt),
+          style: {
+            position: virtualized ? "absolute" : "relative",
+            top: virtualized ? i * itemHeight : void 0,
+            left: 0,
+            right: 0,
+            height: itemHeight,
+            flexDirection: "row",
+            alignItems: "center",
+            paddingHorizontal: px(colors.spacing["3"]),
+            backgroundColor: active ? colors.semantic.background.subtle : "transparent",
+            opacity: opt.disabled ? 0.5 : 1
+          },
+          children: itemNode
+        },
+        `opt-${i}-${opt.value}`
+      )
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.ScrollView,
+    {
+      nativeID: listboxId,
+      onScroll: handleScroll,
+      scrollEventThrottle: 16,
+      style: { maxHeight },
+      contentContainerStyle: virtualized ? { height: totalHeight, position: "relative" } : void 0,
+      children: items
+    }
+  );
+}, "SelectList");
+var DefaultOptionRow = /* @__PURE__ */ __name(({
+  option,
+  selected,
+  active,
+  multiple = false
+}) => {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { flexDirection: "row", alignItems: "center", flex: 1, gap: px(colors.spacing["2"]) }, children: [
+    multiple ? (
+      // Inline checkbox-style indicator. We don't reuse <Checkbox>
+      // here because the row is already a Pressable — nesting two
+      // pressable surfaces breaks tap handling on native; this
+      // is purely visual (the Pressable parent owns the toggle).
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.View,
+        {
+          "aria-hidden": true,
+          accessibilityElementsHidden: true,
+          importantForAccessibility: "no-hide-descendants",
+          style: {
+            width: 18,
+            height: 18,
+            borderWidth: 1,
+            borderRadius: px(colors.radius.sm),
+            borderColor: selected ? colors.semantic.interactive.primary : colors.semantic.border.strong,
+            backgroundColor: selected ? colors.semantic.interactive.primary : "transparent",
+            alignItems: "center",
+            justifyContent: "center"
+          },
+          children: selected ? /* @__PURE__ */ jsxRuntime.jsx(defaultSemanticIcons.check, { size: 12, color: colors.semantic.text.inverted }) : null
+        }
+      )
+    ) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Text,
+      {
+        style: {
+          color: colors.semantic.text.default,
+          fontFamily: colors.fontFamily.body,
+          fontSize: px(colors.fontSize.sm),
+          fontWeight: selected ? colors.fontWeight.semibold : colors.fontWeight.regular,
+          flex: 1
+        },
+        numberOfLines: 1,
+        children: option.label
+      }
+    ),
+    selected && !multiple ? /* @__PURE__ */ jsxRuntime.jsx(defaultSemanticIcons.check, { size: 16, color: colors.semantic.interactive.primary }) : null,
+    active ? null : null
+  ] });
+}, "DefaultOptionRow");
+var MultiTriggerLabel = /* @__PURE__ */ __name(({
+  options,
+  placeholder,
+  maxChips
+}) => {
+  const colors = useThemeColors();
+  if (options.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Text,
+      {
+        style: {
+          color: colors.semantic.text.muted,
+          fontFamily: colors.fontFamily.body,
+          fontSize: px(colors.fontSize.sm),
+          flex: 1
+        },
+        numberOfLines: 1,
+        children: placeholder
+      }
+    );
+  }
+  if (options.length > maxChips) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.Text,
+      {
+        style: {
+          color: colors.semantic.text.default,
+          fontFamily: colors.fontFamily.body,
+          fontSize: px(colors.fontSize.sm),
+          fontWeight: colors.fontWeight.medium,
+          fontVariant: ["tabular-nums"],
+          flex: 1
+        },
+        numberOfLines: 1,
+        children: [
+          options.length,
+          " selected"
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: {
+        flexDirection: "row",
+        alignItems: "center",
+        flexWrap: "wrap",
+        rowGap: px(colors.spacing["1"]),
+        columnGap: px(colors.spacing["1"]),
+        flex: 1
+      },
+      children: options.map((opt) => /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.View,
+        {
+          style: {
+            flexDirection: "row",
+            alignItems: "center",
+            paddingHorizontal: px(colors.spacing["2"]),
+            paddingVertical: 2,
+            borderRadius: px(colors.radius.sm),
+            backgroundColor: colors.semantic.background.subtle,
+            borderWidth: 1,
+            borderColor: colors.semantic.border.default
+          },
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Text,
+            {
+              style: {
+                color: colors.semantic.text.default,
+                fontFamily: colors.fontFamily.body,
+                fontSize: px(colors.fontSize.sm)
+              },
+              numberOfLines: 1,
+              children: opt.label
+            }
+          )
+        },
+        `chip-${opt.value}`
+      ))
+    }
+  );
+}, "MultiTriggerLabel");
+var MultiSelectionHeader = /* @__PURE__ */ __name(({ count, onClearAll }) => {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      style: {
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "space-between",
+        paddingHorizontal: px(colors.spacing["3"]),
+        paddingVertical: px(colors.spacing["2"]),
+        borderBottomWidth: 1,
+        borderBottomColor: colors.semantic.border.default
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          reactNative.Text,
+          {
+            style: {
+              color: colors.semantic.text.muted,
+              fontFamily: colors.fontFamily.body,
+              fontSize: px(colors.fontSize.sm),
+              fontVariant: ["tabular-nums"]
+            },
+            children: [
+              count,
+              " selected"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Pressable,
+          {
+            role: "button",
+            accessibilityRole: "button",
+            "aria-label": "Clear all",
+            accessibilityLabel: "Clear all",
+            onPress: onClearAll,
+            style: ({ pressed }) => ({
+              paddingHorizontal: px(colors.spacing["2"]),
+              paddingVertical: 2,
+              borderRadius: px(colors.radius.sm),
+              opacity: pressed ? 0.6 : 1
+            }),
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              reactNative.Text,
+              {
+                style: {
+                  color: colors.semantic.interactive.primary,
+                  fontFamily: colors.fontFamily.body,
+                  fontSize: px(colors.fontSize.sm),
+                  fontWeight: colors.fontWeight.medium
+                },
+                children: "Clear all"
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+}, "MultiSelectionHeader");
+var CaptionContext = react.createContext(null);
+CaptionContext.displayName = "CalendarCaptionContext";
+var CaptionProvider = /* @__PURE__ */ __name(({ value, children }) => /* @__PURE__ */ jsxRuntime.jsx(CaptionContext.Provider, { value, children }), "CaptionProvider");
+var ARROW_BUTTON_GAP = 8;
+var NavButton = /* @__PURE__ */ __name(({ label, onPress, children }) => {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityRole: "button",
+      accessibilityLabel: label,
+      onPress,
+      style: ({ pressed, hovered, focused }) => {
+        const base = {
+          width: 32,
+          height: 32,
+          alignItems: "center",
+          justifyContent: "center",
+          borderRadius: 8
+        };
+        const transition = {
+          transitionProperty: "background-color, border-color, transform",
+          transitionDuration: "140ms",
+          transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)",
+          outlineStyle: "none"
+        };
+        const bg = pressed ? colors.color.primary["200"] : hovered ? colors.color.primary["100"] : "transparent";
+        const border = focused ? { borderWidth: 2, borderColor: colors.semantic.interactive.primary } : { borderWidth: 0 };
+        return [base, transition, { backgroundColor: bg, transform: [{ scale: pressed ? 0.94 : 1 }] }, border];
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: { color: colors.semantic.text.default, fontSize: 16, lineHeight: 16, fontWeight: "500" }, children })
+    }
+  );
+}, "NavButton");
+var TitleButton = /* @__PURE__ */ __name(({
+  text,
+  ariaLabel,
+  onPress,
+  drilldown
+}) => {
+  const colors = useThemeColors();
+  if (!onPress) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { paddingHorizontal: 12, paddingVertical: 6, alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Text,
+      {
+        style: {
+          color: colors.semantic.text.default,
+          fontSize: 15,
+          fontWeight: "600",
+          letterSpacing: -0.1
+        },
+        children: text
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.Pressable,
+    {
+      accessibilityRole: "button",
+      accessibilityLabel: ariaLabel,
+      onPress,
+      style: ({ pressed, hovered, focused }) => {
+        const base = {
+          flexDirection: "row",
+          alignItems: "center",
+          gap: 6,
+          paddingHorizontal: 12,
+          paddingVertical: 6,
+          borderRadius: 8
+        };
+        const transition = {
+          transitionProperty: "background-color, transform",
+          transitionDuration: "140ms",
+          transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)",
+          outlineStyle: "none"
+        };
+        const bg = pressed ? colors.color.primary["200"] : hovered ? colors.color.primary["100"] : "transparent";
+        const border = focused ? { borderWidth: 2, borderColor: colors.semantic.interactive.primary } : { borderWidth: 0 };
+        return [base, transition, { backgroundColor: bg, transform: [{ scale: pressed ? 0.97 : 1 }] }, border];
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Text,
+          {
+            style: {
+              color: colors.semantic.text.default,
+              fontSize: 15,
+              fontWeight: "600",
+              letterSpacing: -0.1
+            },
+            children: text
+          }
+        ),
+        drilldown ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { "aria-hidden": true, style: { color: colors.semantic.text.muted, fontSize: 10, opacity: 0.7 }, children: "\u25BE" }) : null
+      ]
+    }
+  );
+}, "TitleButton");
+var Caption = /* @__PURE__ */ __name(({
+  months,
+  locale,
+  view,
+  caption,
+  gridWidth,
+  monthGap,
+  yearRange,
+  isMonthDisabled,
+  isYearDisabled,
+  onPrev,
+  onNext,
+  onTitlePress,
+  onSetMonth,
+  onSetYear,
+  children
+}) => {
+  const { t } = useTranslation();
+  const titleText = /* @__PURE__ */ __name((m) => {
+    if (view === "day") {
+      return formatMonthYearTitle(m, locale);
+    }
+    if (view === "month") {
+      return String(m.year);
+    }
+    const start = m.year - m.year % 10;
+    return `${start} \u2013 ${start + 11}`;
+  }, "titleText");
+  const titleAriaKey = view === "day" ? "calendar.header.openMonthView" : view === "month" ? "calendar.header.openYearView" : "calendar.header.openDayView";
+  const showMultiTitles = view === "day" && months.length > 1;
+  const titleRowWidth = showMultiTitles ? months.length * gridWidth + (months.length - 1) * monthGap : gridWidth;
+  const monthNames = react.useMemo(() => formatMonthNames(locale), [locale]);
+  const focused = months[0] ?? void 0;
+  if (!focused) {
+    return null;
+  }
+  const ctxValue = {
+    month: focused.month,
+    year: focused.year,
+    visibleMonth: focused,
+    monthOptions: monthNames.map((label, i) => ({
+      value: i + 1,
+      label,
+      disabled: isMonthDisabled?.(focused.year, i + 1) ?? false
+    })),
+    yearOptions: Array.from({ length: yearRange[1] - yearRange[0] + 1 }, (_, i) => ({
+      value: yearRange[0] + i,
+      label: String(yearRange[0] + i),
+      disabled: isYearDisabled?.(yearRange[0] + i) ?? false
+    })),
+    setMonth: /* @__PURE__ */ __name((m) => onSetMonth(0, m), "setMonth"),
+    setYear: /* @__PURE__ */ __name((y) => onSetYear(0, y), "setYear"),
+    goPrev: onPrev,
+    goNext: onNext
+  };
+  if (caption === "custom") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.View,
+      {
+        style: {
+          flexDirection: "row",
+          alignItems: "center",
+          paddingBottom: 10,
+          gap: ARROW_BUTTON_GAP,
+          alignSelf: "center"
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(CaptionProvider, { value: ctxValue, children })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      style: {
+        flexDirection: "row",
+        alignItems: "center",
+        paddingBottom: 10,
+        gap: ARROW_BUTTON_GAP,
+        alignSelf: "center"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(NavButton, { label: t("calendar.header.previous", { defaultValue: "Previous month" }), onPress: onPrev, children: "\u2039" }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { flexDirection: "row", gap: monthGap, width: titleRowWidth }, children: showMultiTitles ? months.map((m, i) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { width: gridWidth, alignItems: "center" }, children: caption === "dropdown" && view === "day" ? /* @__PURE__ */ jsxRuntime.jsx(
+          DropdownPair,
+          {
+            month: m.month,
+            year: m.year,
+            monthOptions: monthNames.map((label, j) => ({
+              value: j + 1,
+              label,
+              disabled: isMonthDisabled?.(m.year, j + 1) ?? false
+            })),
+            yearOptions: makeYearOptions(yearRange, isYearDisabled),
+            onMonthChange: (next) => onSetMonth(i, next),
+            onYearChange: (next) => onSetYear(i, next)
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx(
+          TitleButton,
+          {
+            text: titleText(m),
+            ariaLabel: t(titleAriaKey, { defaultValue: "Change view" }),
+            onPress: () => onTitlePress(m),
+            drilldown: true
+          }
+        ) }, `${m.year}-${m.month}`)) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { width: gridWidth, alignItems: "center" }, children: caption === "dropdown" && view === "day" ? /* @__PURE__ */ jsxRuntime.jsx(
+          DropdownPair,
+          {
+            month: focused.month,
+            year: focused.year,
+            monthOptions: monthNames.map((label, j) => ({
+              value: j + 1,
+              label,
+              disabled: isMonthDisabled?.(focused.year, j + 1) ?? false
+            })),
+            yearOptions: makeYearOptions(yearRange, isYearDisabled),
+            onMonthChange: (next) => onSetMonth(0, next),
+            onYearChange: (next) => onSetYear(0, next)
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx(
+          TitleButton,
+          {
+            text: titleText(focused),
+            ariaLabel: t(titleAriaKey, { defaultValue: "Change view" }),
+            onPress: () => onTitlePress(focused),
+            drilldown: true
+          }
+        ) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(NavButton, { label: t("calendar.header.next", { defaultValue: "Next month" }), onPress: onNext, children: "\u203A" })
+      ]
+    }
+  );
+}, "Caption");
+var makeYearOptions = /* @__PURE__ */ __name((yearRange, isYearDisabled) => Array.from({ length: yearRange[1] - yearRange[0] + 1 }, (_, i) => ({
+  value: yearRange[0] + i,
+  label: String(yearRange[0] + i),
+  disabled: isYearDisabled?.(yearRange[0] + i) ?? false
+})), "makeYearOptions");
+var DropdownPair = /* @__PURE__ */ __name(({ month, year, monthOptions, yearOptions, onMonthChange, onYearChange }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { flexDirection: "row", gap: 6 }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Select,
+      {
+        value: String(month),
+        onChange: (v) => onMonthChange(Number(v)),
+        options: monthOptions.map((o) => ({
+          value: String(o.value),
+          label: o.label,
+          disabled: o.disabled
+        })),
+        "aria-label": "Month",
+        searchable: false
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Select,
+      {
+        value: String(year),
+        onChange: (v) => onYearChange(Number(v)),
+        options: yearOptions.map((o) => ({
+          value: String(o.value),
+          label: o.label,
+          disabled: o.disabled
+        })),
+        "aria-label": "Year",
+        searchable: false
+      }
+    )
+  ] });
+}, "DropdownPair");
+var CELL_SIZE = 40;
+var formatterCache = /* @__PURE__ */ new Map();
+var RUNTIME_DEFAULT_LOCALE_KEY = "__default__";
+var getDayFormatter = /* @__PURE__ */ __name((locale) => {
+  const key = locale ?? RUNTIME_DEFAULT_LOCALE_KEY;
+  const cached = formatterCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const fmt = new Intl.DateTimeFormat(locale, {
+      weekday: "long",
+      month: "long",
+      day: "numeric",
+      year: "numeric",
+      timeZone: "UTC"
+    });
+    formatterCache.set(key, fmt);
+    return fmt;
+  } catch {
+    return null;
+  }
+}, "getDayFormatter");
+var formatDayLabel = /* @__PURE__ */ __name((ctx, locale) => {
+  const jsDate = new Date(Date.UTC(ctx.date.year, ctx.date.month - 1, ctx.date.day));
+  const fmt = getDayFormatter(locale);
+  const base = fmt ? fmt.format(jsDate) : (
+    // Fallback if the runtime rejects the locale tag.
+    `${ctx.date.month}/${ctx.date.day}/${ctx.date.year}`
+  );
+  const suffixes = [];
+  if (ctx.isToday) {
+    suffixes.push("today");
+  }
+  if (ctx.isSelected || ctx.isRangeStart || ctx.isRangeEnd) {
+    suffixes.push("selected");
+  }
+  if (ctx.isInRange && !ctx.isRangeStart && !ctx.isRangeEnd) {
+    suffixes.push("in range");
+  }
+  if (ctx.isUnavailable) {
+    suffixes.push("unavailable");
+  }
+  return suffixes.length > 0 ? `${base}, ${suffixes.join(", ")}` : base;
+}, "formatDayLabel");
+var DayCell = /* @__PURE__ */ __name(({ ctx, onPress, onHoverIn, onHoverOut, renderDay, locale }) => {
+  const colors = useThemeColors();
+  const accessibilityLabel = formatDayLabel(ctx, locale);
+  const isSelectedLike = ctx.isSelected || ctx.isRangeStart || ctx.isRangeEnd;
+  const isInsideRange = ctx.isInRange || ctx.isInPreviewRange;
+  const isRangeMiddle = isInsideRange && !isSelectedLike;
+  const dataState = ctx.isSelected ? "selected" : ctx.isRangeStart ? "range-start" : ctx.isRangeEnd ? "range-end" : ctx.isInPreviewRange ? "preview" : ctx.isInRange ? "in-range" : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityRole: "button",
+      accessibilityLabel,
+      accessibilityState: { disabled: ctx.isUnavailable, selected: isSelectedLike },
+      disabled: ctx.isUnavailable,
+      onPress,
+      ...onHoverIn ? { onHoverIn } : {},
+      ...onHoverOut ? { onHoverOut } : {},
+      style: ({ pressed, hovered, focused }) => {
+        const base = {
+          width: CELL_SIZE,
+          height: CELL_SIZE,
+          alignItems: "center",
+          justifyContent: "center",
+          borderRadius: 999,
+          // perfect circle for endpoints/selected
+          position: "relative"
+        };
+        if (ctx.isUnavailable) {
+          return [base, { opacity: 0.28 }];
+        }
+        let backgroundColor;
+        let transform;
+        let borderWidth;
+        let borderColor;
+        if (isSelectedLike) {
+          backgroundColor = colors.semantic.interactive.primary;
+          if (pressed) {
+            backgroundColor = colors.semantic.interactive.primaryPressed;
+          } else if (hovered) {
+            backgroundColor = colors.semantic.interactive.primaryHover;
+          }
+          transform = [{ scale: pressed ? 0.94 : 1 }];
+        } else if (isRangeMiddle) {
+          backgroundColor = hovered ? colors.color.primary["200"] : "transparent";
+          transform = [{ scale: pressed ? 0.94 : 1 }];
+        } else {
+          if (pressed) {
+            backgroundColor = colors.color.primary["200"];
+          } else if (hovered) {
+            backgroundColor = colors.color.primary["100"];
+          } else {
+            backgroundColor = "transparent";
+          }
+          transform = [{ scale: pressed ? 0.94 : 1 }];
+        }
+        if ((ctx.isFocused || focused) && !isSelectedLike) {
+          borderWidth = 2;
+          borderColor = colors.semantic.interactive.primary;
+        }
+        const transition = {
+          transitionProperty: "background-color, transform, border-color, opacity",
+          transitionDuration: "140ms",
+          transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)",
+          outlineStyle: "none"
+        };
+        return [
+          base,
+          transition,
+          {
+            backgroundColor,
+            ...transform ? { transform } : {},
+            ...borderWidth ? { borderWidth, borderColor } : {}
+          }
+        ];
+      },
+      ...{
+        dataSet: {
+          dayKey: `${ctx.date.year}-${ctx.date.month}-${ctx.date.day}`,
+          ...dataState ? { state: dataState } : {}
+        }
+      },
+      children: renderDay ? renderDay(ctx) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Text,
+          {
+            style: {
+              color: isSelectedLike ? colors.semantic.text.inverted : ctx.isOutsideMonth ? colors.semantic.text.muted : colors.semantic.text.default,
+              fontSize: 14,
+              fontWeight: ctx.isToday ? "600" : "400",
+              opacity: ctx.isOutsideMonth ? 0.55 : 1,
+              transitionProperty: "color",
+              transitionDuration: "140ms"
+            },
+            children: ctx.date.day
+          }
+        ),
+        ctx.isToday ? /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.View,
+          {
+            style: {
+              position: "absolute",
+              bottom: 5,
+              width: 4,
+              height: 4,
+              borderRadius: 999,
+              backgroundColor: isSelectedLike ? colors.semantic.text.inverted : colors.semantic.interactive.primary
+            }
+          }
+        ) : null
+      ] })
+    }
+  );
+}, "DayCell");
+var isInRange = /* @__PURE__ */ __name((date, range) => {
+  if (!range?.end) {
+    return false;
+  }
+  return date.compare(range.start) >= 0 && date.compare(range.end) <= 0;
+}, "isInRange");
+var buildContext = /* @__PURE__ */ __name((date, args) => {
+  const isOutsideMonth = date.month !== args.visibleMonth.month;
+  const isToday = date.compare(args.todayDate) === 0;
+  const dow = date.toDate("UTC").getUTCDay();
+  const isWeekend = args.weekendDays.includes(dow);
+  let isSelected = false;
+  let isRangeStart = false;
+  let isRangeEnd = false;
+  let inRange = false;
+  if (args.mode === "single") {
+    const v = args.value;
+    isSelected = !!v && v.compare(date) === 0;
+  } else if (args.mode === "range") {
+    const r = args.value;
+    if (r) {
+      isRangeStart = r.start.compare(date) === 0;
+      isRangeEnd = r.end !== null && r.end.compare(date) === 0;
+      inRange = isInRange(date, r);
+    }
+  } else {
+    const arr = args.value;
+    isSelected = arr.some((x) => x.compare(date) === 0);
+  }
+  return {
+    date,
+    isOutsideMonth,
+    isToday,
+    isSelected,
+    isRangeStart,
+    isRangeEnd,
+    isInRange: inRange,
+    isInPreviewRange: isInRange(date, args.previewRange ?? null),
+    isUnavailable: args.isUnavailable(date),
+    isFocused: args.focusedDate.compare(date) === 0,
+    isWeekend
+  };
+}, "buildContext");
+var ROW_KEYS = ["row-0", "row-1", "row-2", "row-3", "row-4", "row-5"];
+var DayGrid = /* @__PURE__ */ __name((props) => {
+  const {
+    visibleMonth,
+    locale,
+    mode,
+    value,
+    previewRange,
+    focusedDate,
+    isUnavailable,
+    weekendDays,
+    firstDayOfWeek,
+    onDayPress,
+    onDayHover,
+    renderDay
+  } = props;
+  const colors = useThemeColors();
+  const fdow = firstDayOfWeek ?? getFirstDayOfWeek(locale);
+  const cells = react.useMemo(() => {
+    const start = date.startOfMonth(visibleMonth);
+    const startDow = start.toDate("UTC").getUTCDay();
+    const back = (startDow - fdow + 7) % 7;
+    const first = start.subtract({ days: back });
+    const total = 42;
+    return Array.from({ length: total }, (_, i) => first.add({ days: i }));
+  }, [visibleMonth, fdow]);
+  const weekdayNames = react.useMemo(() => formatWeekdayNames(locale), [locale]);
+  const todayDate = react.useMemo(() => date.today(date.getLocalTimeZone()), []);
+  const gridWidth = 7 * CELL_SIZE;
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { role: "grid", style: { width: gridWidth }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { role: "row", style: { flexDirection: "row", marginBottom: 4 }, children: weekdayNames.map((name) => /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.View,
+      {
+        role: "columnheader",
+        style: { width: CELL_SIZE, alignItems: "center", paddingVertical: 6 },
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Text,
+          {
+            style: {
+              fontSize: 11,
+              fontWeight: "500",
+              letterSpacing: 0.6,
+              color: colors.semantic.text.muted,
+              textTransform: "uppercase"
+            },
+            children: name
+          }
+        )
+      },
+      name
+    )) }),
+    ROW_KEYS.map((rowKey, row) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { role: "row", style: { flexDirection: "row" }, children: cells.slice(row * 7, row * 7 + 7).map((date) => {
+      const ctx = buildContext(date, {
+        visibleMonth,
+        mode,
+        value,
+        ...previewRange !== void 0 ? { previewRange } : {},
+        focusedDate,
+        isUnavailable,
+        weekendDays,
+        todayDate
+      });
+      const isSelectedLike = ctx.isSelected || ctx.isRangeStart || ctx.isRangeEnd;
+      const isInsideRange = ctx.isInRange || ctx.isInPreviewRange;
+      const wrapperStyle = {
+        width: CELL_SIZE,
+        height: CELL_SIZE,
+        position: "relative"
+      };
+      const rangeFillTint = colors.color.primary["100"];
+      let rangeFillStyle = null;
+      if (ctx.isRangeStart && !ctx.isRangeEnd) {
+        rangeFillStyle = {
+          position: "absolute",
+          top: 0,
+          bottom: 0,
+          left: "50%",
+          right: 0,
+          backgroundColor: rangeFillTint
+        };
+      } else if (ctx.isRangeEnd && !ctx.isRangeStart) {
+        rangeFillStyle = {
+          position: "absolute",
+          top: 0,
+          bottom: 0,
+          left: 0,
+          right: "50%",
+          backgroundColor: rangeFillTint
+        };
+      } else if (isInsideRange && !isSelectedLike) {
+        rangeFillStyle = {
+          position: "absolute",
+          top: 0,
+          bottom: 0,
+          left: 0,
+          right: 0,
+          backgroundColor: rangeFillTint
+        };
+      }
+      const gridcellProps = {
+        role: "gridcell",
+        ...isSelectedLike ? { "aria-selected": true } : {}
+      };
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        reactNative.View,
+        {
+          ...gridcellProps,
+          style: wrapperStyle,
+          children: [
+            rangeFillStyle ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: rangeFillStyle }) : null,
+            /* @__PURE__ */ jsxRuntime.jsx(
+              DayCell,
+              {
+                ctx,
+                locale,
+                onPress: () => onDayPress(date),
+                ...onDayHover ? {
+                  onHoverIn: /* @__PURE__ */ __name(() => onDayHover(date), "onHoverIn"),
+                  onHoverOut: /* @__PURE__ */ __name(() => onDayHover(null), "onHoverOut")
+                } : {},
+                ...renderDay ? { renderDay } : {}
+              }
+            )
+          ]
+        },
+        `${date.year}-${date.month}-${date.day}`
+      );
+    }) }, rowKey))
+  ] });
+}, "DayGrid");
+var Footer = /* @__PURE__ */ __name(({ children }) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { paddingTop: 12 }, children }), "Footer");
+var ROW_KEYS2 = ["r0", "r1", "r2", "r3"];
+var MonthGrid = /* @__PURE__ */ __name(({ visibleMonth, locale, availableWidth, onSelect }) => {
+  const colors = useThemeColors();
+  const names = formatMonthNames(locale);
+  const cellHeight = 56;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { width: availableWidth, paddingVertical: 8 }, children: ROW_KEYS2.map((rowKey, row) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { flexDirection: "row", marginBottom: 4 }, children: [0, 1, 2].map((col) => {
+    const idx = row * 3 + col;
+    const monthNumber = idx + 1;
+    const isCurrent = monthNumber === visibleMonth.month;
+    const name = names[idx] ?? "";
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { flex: 1, paddingHorizontal: 4 }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: name,
+        onPress: () => onSelect(monthNumber),
+        style: ({
+          pressed,
+          hovered,
+          focused
+        }) => {
+          const base = {
+            height: cellHeight,
+            alignItems: "center",
+            justifyContent: "center",
+            borderRadius: 10
+          };
+          const transition = {
+            transitionProperty: "background-color, transform, border-color",
+            transitionDuration: "140ms",
+            transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)",
+            outlineStyle: "none"
+          };
+          let bg;
+          if (isCurrent) {
+            bg = pressed ? colors.semantic.interactive.primaryPressed : hovered ? colors.semantic.interactive.primaryHover : colors.semantic.interactive.primary;
+          } else if (pressed) {
+            bg = colors.color.primary["200"];
+          } else if (hovered) {
+            bg = colors.color.primary["100"];
+          } else {
+            bg = "transparent";
+          }
+          const border = focused && !isCurrent ? { borderWidth: 2, borderColor: colors.semantic.interactive.primary } : { borderWidth: 0 };
+          return [
+            base,
+            transition,
+            { backgroundColor: bg, transform: [{ scale: pressed ? 0.96 : 1 }] },
+            border
+          ];
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Text,
+          {
+            style: {
+              color: isCurrent ? colors.semantic.text.inverted : colors.semantic.text.default,
+              fontSize: 14,
+              fontWeight: isCurrent ? "600" : "500"
+            },
+            children: name
+          }
+        )
+      }
+    ) }, monthNumber);
+  }) }, rowKey)) });
+}, "MonthGrid");
+var ROW_KEYS3 = ["r0", "r1", "r2"];
+var YearGrid = /* @__PURE__ */ __name(({ visibleMonth, availableWidth, onSelect }) => {
+  const colors = useThemeColors();
+  const decadeStart = visibleMonth.year - visibleMonth.year % 10;
+  const years = Array.from({ length: 12 }, (_, i) => decadeStart + i - 1);
+  const cellHeight = 60;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { width: availableWidth, paddingVertical: 8 }, children: ROW_KEYS3.map((rowKey, row) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { flexDirection: "row", marginBottom: 4 }, children: [0, 1, 2, 3].map((col) => {
+    const year = years[row * 4 + col];
+    if (year === void 0) {
+      return null;
+    }
+    const isCurrent = year === visibleMonth.year;
+    const isAdjacentDecade = year < decadeStart || year >= decadeStart + 10;
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { flex: 1, paddingHorizontal: 4 }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: String(year),
+        onPress: () => onSelect(year),
+        style: ({
+          pressed,
+          hovered,
+          focused
+        }) => {
+          const base = {
+            height: cellHeight,
+            alignItems: "center",
+            justifyContent: "center",
+            borderRadius: 10
+          };
+          const transition = {
+            transitionProperty: "background-color, transform, border-color",
+            transitionDuration: "140ms",
+            transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)",
+            outlineStyle: "none"
+          };
+          let bg;
+          if (isCurrent) {
+            bg = pressed ? colors.semantic.interactive.primaryPressed : hovered ? colors.semantic.interactive.primaryHover : colors.semantic.interactive.primary;
+          } else if (pressed) {
+            bg = colors.color.primary["200"];
+          } else if (hovered) {
+            bg = colors.color.primary["100"];
+          } else {
+            bg = "transparent";
+          }
+          const border = focused && !isCurrent ? { borderWidth: 2, borderColor: colors.semantic.interactive.primary } : { borderWidth: 0 };
+          return [
+            base,
+            transition,
+            { backgroundColor: bg, transform: [{ scale: pressed ? 0.96 : 1 }] },
+            border
+          ];
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Text,
+          {
+            style: {
+              color: isCurrent ? colors.semantic.text.inverted : colors.semantic.text.default,
+              fontSize: 14,
+              fontWeight: isCurrent ? "600" : "500",
+              opacity: isAdjacentDecade ? 0.45 : 1
+            },
+            children: year
+          }
+        )
+      }
+    ) }, year);
+  }) }, rowKey)) });
+}, "YearGrid");
+var GRID_WIDTH = 7 * CELL_SIZE;
+var MONTH_GAP = 16;
+var ARROW_AREA = 32 + 8;
+var SURFACE_PADDING = 16;
+var SURFACE_BORDER = 1;
+var requiredOuterWidth = /* @__PURE__ */ __name((n) => 2 * (ARROW_AREA + SURFACE_PADDING + SURFACE_BORDER) + n * GRID_WIDTH + (n - 1) * MONTH_GAP, "requiredOuterWidth");
+var focusDayCell = /* @__PURE__ */ __name((root, date, force) => {
+  if (!root) {
+    return;
+  }
+  if (typeof document === "undefined" || typeof root.contains !== "function") {
+    return;
+  }
+  if (!force && !root.contains(document.activeElement)) {
+    return;
+  }
+  const sel = `[data-day-key="${date.year}-${date.month}-${date.day}"]`;
+  const cell = root.querySelector(sel);
+  const isDisabled = cell?.disabled === true;
+  if (cell && !isDisabled) {
+    if (cell !== document.activeElement) {
+      cell.focus();
+    }
+    return;
+  }
+  if (force && !root.contains(document.activeElement)) {
+    root.focus();
+  }
+}, "focusDayCell");
+var FadeIn = /* @__PURE__ */ __name(({ children }) => {
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    const id = requestAnimationFrame(() => setMounted(true));
+    return () => cancelAnimationFrame(id);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: {
+        opacity: mounted ? 1 : 0,
+        transform: [{ translateY: mounted ? 0 : 4 }],
+        transitionProperty: "opacity, transform",
+        transitionDuration: "220ms",
+        transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)"
+      },
+      children
+    }
+  );
+}, "FadeIn");
+var resolveYearRange = /* @__PURE__ */ __name((input, minValue, maxValue, focusedYear) => {
+  if (input) {
+    return input;
+  }
+  if (minValue && maxValue) {
+    return [minValue.year, maxValue.year];
+  }
+  if (minValue) {
+    return [minValue.year, Math.max(minValue.year, focusedYear + 10)];
+  }
+  if (maxValue) {
+    return [Math.min(maxValue.year, focusedYear - 100), maxValue.year];
+  }
+  return [focusedYear - 100, focusedYear + 10];
+}, "resolveYearRange");
+var pickVisibleMonths = /* @__PURE__ */ __name((input, measuredWidth) => {
+  const target = typeof input === "number" ? input : 2;
+  if (measuredWidth == null || measuredWidth === 0) {
+    return typeof input === "number" ? input : 1;
+  }
+  for (let n = target; n >= 1; n--) {
+    if (measuredWidth >= requiredOuterWidth(n)) {
+      return n;
+    }
+  }
+  return 1;
+}, "pickVisibleMonths");
+var CalendarRoot = /* @__PURE__ */ __name((props) => {
+  const [containerWidth, setContainerWidth] = react.useState(null);
+  const onLayout = react.useCallback((e) => {
+    const next = e.nativeEvent.layout.width;
+    setContainerWidth((prev) => prev === next ? prev : next);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { onLayout, style: { width: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsx(CalendarSurface, { containerWidth: containerWidth ?? 0, ...props }) });
+}, "CalendarRoot");
+var CalendarSurface = /* @__PURE__ */ __name((props) => {
+  const providerLocale = useLocale();
+  const locale = props.locale ?? providerLocale;
+  if ((props.mode ?? "single") === "range") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      RangeCalendar,
+      {
+        ...props,
+        locale
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SingleOrMultiCalendar,
+    {
+      ...props,
+      locale
+    }
+  );
+}, "CalendarSurface");
+var surfaceMetrics = /* @__PURE__ */ __name((visibleMonths) => {
+  const innerWidth = 2 * ARROW_AREA + visibleMonths * GRID_WIDTH + (visibleMonths - 1) * MONTH_GAP;
+  return {
+    innerWidth,
+    // Body grids row width (excludes arrow area)
+    gridsRowWidth: visibleMonths * GRID_WIDTH + (visibleMonths - 1) * MONTH_GAP
+  };
+}, "surfaceMetrics");
+var SingleOrMultiCalendar = /* @__PURE__ */ __name((props) => {
+  const { locale, renderDay, containerWidth } = props;
+  const colors = useThemeColors();
+  const firstDayOfWeek = props.firstDayOfWeek ?? getFirstDayOfWeek(locale);
+  const weekendDays = props.weekendDays ?? getWeekendDays(locale);
+  const visibleMonths = props.behavior === "scroll" ? 1 : pickVisibleMonths(props.visibleMonths, containerWidth);
+  const { innerWidth, gridsRowWidth } = surfaceMetrics(visibleMonths);
+  react.useEffect(() => {
+    if (process.env.NODE_ENV !== "production" && props.behavior === "scroll" && typeof props.visibleMonths === "number" && props.visibleMonths > 1) {
+      console.warn('[Calendar] visibleMonths is ignored when behavior="scroll"; falling back to single column.');
+    }
+  }, [props.behavior, props.visibleMonths]);
+  const containerRef = react.useRef(null);
+  const state = useCalendarState({
+    ...props.mode !== void 0 ? { mode: props.mode } : {},
+    locale,
+    ...props.value !== void 0 ? { value: props.value } : {},
+    ...props.defaultValue !== void 0 ? { defaultValue: props.defaultValue } : {},
+    ...props.onChange !== void 0 ? { onChange: props.onChange } : {},
+    ...props.view !== void 0 ? { view: props.view } : {},
+    ...props.defaultView !== void 0 ? { defaultView: props.defaultView } : {},
+    ...props.onViewChange !== void 0 ? { onViewChange: props.onViewChange } : {},
+    ...props.minValue !== void 0 ? { minValue: props.minValue } : {},
+    ...props.maxValue !== void 0 ? { maxValue: props.maxValue } : {},
+    ...props.isDateUnavailable !== void 0 ? { isDateUnavailable: props.isDateUnavailable } : {}
+  });
+  const [anchor, setAnchor] = react.useState(state.focusedDate);
+  const anchorRef = react.useRef(anchor);
+  react.useEffect(() => {
+    anchorRef.current = anchor;
+  }, [anchor]);
+  react.useEffect(() => {
+    const start = anchorRef.current;
+    const end = start.add({ months: visibleMonths });
+    if (state.focusedDate.compare(start) < 0 || state.focusedDate.compare(end) >= 0) {
+      setAnchor(state.focusedDate);
+    }
+  }, [state.focusedDate, visibleMonths]);
+  const keyboardNavRef = react.useRef(false);
+  react.useLayoutEffect(() => {
+    focusDayCell(containerRef.current, state.focusedDate, keyboardNavRef.current);
+    keyboardNavRef.current = false;
+  }, [state.focusedDate, state.value]);
+  const months = react.useMemo(
+    () => Array.from({ length: visibleMonths }, (_, i) => anchor.add({ months: i })),
+    [anchor, visibleMonths]
+  );
+  const keyboard = useCalendarKeyboard({
+    focusedDate: state.focusedDate,
+    moveFocus: /* @__PURE__ */ __name((delta) => {
+      state.moveFocus(delta);
+      if (delta.months || delta.years) {
+        setAnchor((a) => {
+          let next = a;
+          if (delta.months) {
+            next = next.add({ months: delta.months });
+          }
+          if (delta.years) {
+            next = next.add({ years: delta.years });
+          }
+          return next;
+        });
+      }
+    }, "moveFocus"),
+    selectDate: state.selectDate,
+    setView: state.setView,
+    view: state.view,
+    firstDayOfWeek
+  });
+  const onPrev = /* @__PURE__ */ __name(() => {
+    if (state.view === "year") {
+      setAnchor((a) => a.add({ years: -10 }));
+    } else if (state.view === "month") {
+      setAnchor((a) => a.add({ years: -1 }));
+    } else if (props.behavior === "scroll") {
+      state.moveFocus({ months: -1 });
+    } else {
+      setAnchor((a) => a.add({ months: -1 }));
+    }
+  }, "onPrev");
+  const onNext = /* @__PURE__ */ __name(() => {
+    if (state.view === "year") {
+      setAnchor((a) => a.add({ years: 10 }));
+    } else if (state.view === "month") {
+      setAnchor((a) => a.add({ years: 1 }));
+    } else if (props.behavior === "scroll") {
+      state.moveFocus({ months: 1 });
+    } else {
+      setAnchor((a) => a.add({ months: 1 }));
+    }
+  }, "onNext");
+  const onTitlePress = /* @__PURE__ */ __name(() => state.setView(state.view === "day" ? "month" : state.view === "month" ? "year" : "day"), "onTitlePress");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      ref: (node) => {
+        containerRef.current = node;
+        if (typeof props.ref === "function") {
+          props.ref(node);
+        } else if (props.ref) {
+          props.ref.current = node;
+        }
+      },
+      ...props.testID !== void 0 ? { testID: props.testID } : {},
+      onKeyDown: (e) => {
+        keyboardNavRef.current = true;
+        keyboard.onKeyDown(e);
+      },
+      tabIndex: 0,
+      style: {
+        padding: SURFACE_PADDING,
+        backgroundColor: colors.semantic.background.elevated,
+        borderRadius: 16,
+        borderWidth: SURFACE_BORDER,
+        borderColor: colors.semantic.border.default,
+        shadowColor: "#000",
+        shadowOpacity: 0.04,
+        shadowRadius: 12,
+        shadowOffset: { width: 0, height: 4 },
+        width: innerWidth + 2 * SURFACE_PADDING + 2 * SURFACE_BORDER,
+        maxWidth: "100%",
+        alignSelf: "center"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          Caption,
+          {
+            months,
+            locale,
+            view: state.view,
+            caption: props.caption ?? "title",
+            gridWidth: GRID_WIDTH,
+            monthGap: MONTH_GAP,
+            yearRange: resolveYearRange(props.yearRange, props.minValue, props.maxValue, anchor.year),
+            onPrev,
+            onNext,
+            onTitlePress,
+            onSetMonth: (slot, m) => {
+              const picked = (months[slot] ?? anchor).set({ month: m, day: 1 });
+              setAnchor(picked.subtract({ months: slot }));
+            },
+            onSetYear: (slot, y) => {
+              const picked = (months[slot] ?? anchor).set({ year: y, day: 1 });
+              setAnchor(picked.subtract({ months: slot }));
+            },
+            children: props.children
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(FadeIn, { children: [
+          state.view === "day" && (props.behavior === "scroll" ? /* @__PURE__ */ jsxRuntime.jsx(
+            ScrollBody,
+            {
+              mode: props.mode ?? "single",
+              locale,
+              focusedDate: state.focusedDate,
+              onFocusedMonthChange: (next) => setAnchor(next),
+              value: state.value,
+              onSelectDate: (date) => state.selectDate(date, "click"),
+              firstDayOfWeek,
+              weekendDays,
+              ...props.minValue !== void 0 ? { minValue: props.minValue } : {},
+              ...props.maxValue !== void 0 ? { maxValue: props.maxValue } : {},
+              ...props.isDateUnavailable !== void 0 ? { isDateUnavailable: props.isDateUnavailable } : {},
+              ...renderDay ? { renderDay } : {}
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.View,
+            {
+              style: { flexDirection: "row", gap: MONTH_GAP, alignSelf: "center", width: gridsRowWidth },
+              children: months.map((m) => /* @__PURE__ */ jsxRuntime.jsx(
+                DayGrid,
+                {
+                  visibleMonth: m,
+                  locale,
+                  mode: props.mode ?? "single",
+                  value: state.value,
+                  focusedDate: state.focusedDate,
+                  isUnavailable: state.isUnavailable,
+                  weekendDays,
+                  firstDayOfWeek,
+                  onDayPress: (date) => state.selectDate(date, "click"),
+                  ...renderDay ? { renderDay } : {}
+                },
+                `${m.year}-${m.month}`
+              ))
+            }
+          )),
+          state.view === "month" && /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+            MonthGrid,
+            {
+              visibleMonth: anchor,
+              locale,
+              availableWidth: gridsRowWidth,
+              onSelect: (month) => {
+                setAnchor(new date.CalendarDate(anchor.year, month, 1));
+                state.setView("day");
+              }
+            }
+          ) }),
+          state.view === "year" && /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+            YearGrid,
+            {
+              visibleMonth: anchor,
+              availableWidth: gridsRowWidth,
+              onSelect: (year) => {
+                setAnchor(new date.CalendarDate(year, anchor.month, 1));
+                state.setView("month");
+              }
+            }
+          ) }),
+          props.children && (props.caption ?? "title") !== "custom" ? /* @__PURE__ */ jsxRuntime.jsx(Footer, { children: props.children }) : null
+        ] }, `smc-${state.view}`)
+      ]
+    }
+  );
+}, "SingleOrMultiCalendar");
+var RangeCalendar = /* @__PURE__ */ __name((props) => {
+  const { locale, renderDay, containerWidth } = props;
+  const colors = useThemeColors();
+  const firstDayOfWeek = props.firstDayOfWeek ?? getFirstDayOfWeek(locale);
+  const weekendDays = props.weekendDays ?? getWeekendDays(locale);
+  const visibleMonths = props.behavior === "scroll" ? 1 : pickVisibleMonths(props.visibleMonths, containerWidth);
+  const { innerWidth, gridsRowWidth } = surfaceMetrics(visibleMonths);
+  react.useEffect(() => {
+    if (process.env.NODE_ENV !== "production" && props.behavior === "scroll" && typeof props.visibleMonths === "number" && props.visibleMonths > 1) {
+      console.warn('[Calendar] visibleMonths is ignored when behavior="scroll"; falling back to single column.');
+    }
+  }, [props.behavior, props.visibleMonths]);
+  const containerRef = react.useRef(null);
+  const range = useRangeState({
+    ...props.value !== void 0 ? { value: props.value } : {},
+    ...props.defaultValue !== void 0 ? { defaultValue: props.defaultValue } : {},
+    ...props.onChange !== void 0 ? { onChange: props.onChange } : {},
+    ...props.minValue !== void 0 ? { minValue: props.minValue } : {},
+    ...props.maxValue !== void 0 ? { maxValue: props.maxValue } : {},
+    ...props.isDateUnavailable !== void 0 ? { isDateUnavailable: props.isDateUnavailable } : {},
+    ...props.minNights !== void 0 ? { minNights: props.minNights } : {},
+    ...props.maxNights !== void 0 ? { maxNights: props.maxNights } : {}
+  });
+  const initialFocus2 = range.value?.start ?? date.today(date.getLocalTimeZone());
+  const [focusedDate, setFocusedDate] = react.useState(initialFocus2);
+  const keyboardNavRef = react.useRef(false);
+  react.useLayoutEffect(() => {
+    focusDayCell(containerRef.current, focusedDate, keyboardNavRef.current);
+    keyboardNavRef.current = false;
+  }, [focusedDate, range.value]);
+  const [anchor, setAnchor] = react.useState(initialFocus2);
+  const [internalView, setInternalView] = react.useState(props.defaultView ?? "day");
+  const isViewControlled = props.view !== void 0;
+  const view = isViewControlled ? props.view : internalView;
+  const setView = react.useCallback(
+    (next) => {
+      if (!isViewControlled) {
+        setInternalView(next);
+      }
+      props.onViewChange?.(next);
+    },
+    [isViewControlled, props.onViewChange]
+  );
+  const months = react.useMemo(
+    () => Array.from({ length: visibleMonths }, (_, i) => anchor.add({ months: i })),
+    [anchor, visibleMonths]
+  );
+  const keyboard = useCalendarKeyboard({
+    focusedDate,
+    moveFocus: /* @__PURE__ */ __name((delta) => {
+      setFocusedDate((f) => {
+        let next = f;
+        if (delta.days) {
+          next = next.add({ days: delta.days });
+        }
+        if (delta.weeks) {
+          next = next.add({ weeks: delta.weeks });
+        }
+        if (delta.months) {
+          next = next.add({ months: delta.months });
+        }
+        if (delta.years) {
+          next = next.add({ years: delta.years });
+        }
+        return next;
+      });
+      if (delta.months || delta.years) {
+        setAnchor((a) => {
+          let next = a;
+          if (delta.months) {
+            next = next.add({ months: delta.months });
+          }
+          if (delta.years) {
+            next = next.add({ years: delta.years });
+          }
+          return next;
+        });
+      }
+    }, "moveFocus"),
+    selectDate: /* @__PURE__ */ __name((date) => range.selectDate(date, "keyboard"), "selectDate"),
+    setView,
+    view,
+    firstDayOfWeek
+  });
+  const onPrev = /* @__PURE__ */ __name(() => {
+    if (view === "year") {
+      setAnchor((a) => a.add({ years: -10 }));
+    } else if (view === "month") {
+      setAnchor((a) => a.add({ years: -1 }));
+    } else if (props.behavior === "scroll") {
+      setFocusedDate((f) => f.add({ months: -1 }));
+    } else {
+      setAnchor((a) => a.add({ months: -1 }));
+    }
+  }, "onPrev");
+  const onNext = /* @__PURE__ */ __name(() => {
+    if (view === "year") {
+      setAnchor((a) => a.add({ years: 10 }));
+    } else if (view === "month") {
+      setAnchor((a) => a.add({ years: 1 }));
+    } else if (props.behavior === "scroll") {
+      setFocusedDate((f) => f.add({ months: 1 }));
+    } else {
+      setAnchor((a) => a.add({ months: 1 }));
+    }
+  }, "onNext");
+  const [drilldownSlot, setDrilldownSlot] = react.useState(0);
+  const onTitlePress = /* @__PURE__ */ __name((clicked) => {
+    const slot = months.findIndex((m) => m.year === clicked.year && m.month === clicked.month);
+    setDrilldownSlot(slot >= 0 ? slot : 0);
+    if (clicked.compare(anchor) !== 0) {
+      setAnchor(clicked);
+    }
+    setView(view === "day" ? "month" : view === "month" ? "year" : "day");
+  }, "onTitlePress");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      ref: (node) => {
+        containerRef.current = node;
+        if (typeof props.ref === "function") {
+          props.ref(node);
+        } else if (props.ref) {
+          props.ref.current = node;
+        }
+      },
+      ...props.testID !== void 0 ? { testID: props.testID } : {},
+      onKeyDown: (e) => {
+        keyboardNavRef.current = true;
+        keyboard.onKeyDown(e);
+      },
+      tabIndex: 0,
+      style: {
+        padding: SURFACE_PADDING,
+        backgroundColor: colors.semantic.background.elevated,
+        borderRadius: 16,
+        borderWidth: SURFACE_BORDER,
+        borderColor: colors.semantic.border.default,
+        shadowColor: "#000",
+        shadowOpacity: 0.04,
+        shadowRadius: 12,
+        shadowOffset: { width: 0, height: 4 },
+        width: innerWidth + 2 * SURFACE_PADDING + 2 * SURFACE_BORDER,
+        maxWidth: "100%",
+        alignSelf: "center"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          Caption,
+          {
+            months,
+            locale,
+            view,
+            caption: props.caption ?? "title",
+            gridWidth: GRID_WIDTH,
+            monthGap: MONTH_GAP,
+            yearRange: resolveYearRange(props.yearRange, props.minValue, props.maxValue, anchor.year),
+            onPrev,
+            onNext,
+            onTitlePress,
+            onSetMonth: (slot, m) => {
+              const picked = (months[slot] ?? anchor).set({ month: m, day: 1 });
+              setAnchor(picked.subtract({ months: slot }));
+            },
+            onSetYear: (slot, y) => {
+              const picked = (months[slot] ?? anchor).set({ year: y, day: 1 });
+              setAnchor(picked.subtract({ months: slot }));
+            },
+            children: props.children
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(FadeIn, { children: [
+          view === "day" && (props.behavior === "scroll" ? /* @__PURE__ */ jsxRuntime.jsx(
+            ScrollBody,
+            {
+              mode: "range",
+              locale,
+              focusedDate,
+              onFocusedMonthChange: (next) => setAnchor(next),
+              value: range.value,
+              previewRange: range.previewRange,
+              onSelectDate: (date) => range.selectDate(date),
+              firstDayOfWeek,
+              weekendDays,
+              ...props.minValue !== void 0 ? { minValue: props.minValue } : {},
+              ...props.maxValue !== void 0 ? { maxValue: props.maxValue } : {},
+              ...props.isDateUnavailable !== void 0 ? { isDateUnavailable: props.isDateUnavailable } : {},
+              ...renderDay ? { renderDay } : {}
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.View,
+            {
+              style: { flexDirection: "row", gap: MONTH_GAP, alignSelf: "center", width: gridsRowWidth },
+              children: months.map((m) => /* @__PURE__ */ jsxRuntime.jsx(
+                DayGrid,
+                {
+                  visibleMonth: m,
+                  locale,
+                  mode: "range",
+                  value: range.value,
+                  previewRange: range.previewRange,
+                  focusedDate,
+                  isUnavailable: range.isUnavailable,
+                  weekendDays,
+                  firstDayOfWeek,
+                  onDayPress: (date) => range.selectDate(date),
+                  onDayHover: (date) => range.setHoveredDate(date),
+                  ...renderDay ? { renderDay } : {}
+                },
+                `${m.year}-${m.month}`
+              ))
+            }
+          )),
+          view === "month" && /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+            MonthGrid,
+            {
+              visibleMonth: anchor,
+              locale,
+              availableWidth: gridsRowWidth,
+              onSelect: (month) => {
+                const picked = new date.CalendarDate(anchor.year, month, 1);
+                setAnchor(picked.subtract({ months: drilldownSlot }));
+                setView("day");
+              }
+            }
+          ) }),
+          view === "year" && /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { alignItems: "center" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+            YearGrid,
+            {
+              visibleMonth: anchor,
+              availableWidth: gridsRowWidth,
+              onSelect: (year) => {
+                const picked = new date.CalendarDate(year, anchor.month, 1);
+                setAnchor(picked.subtract({ months: drilldownSlot }));
+                setView("month");
+              }
+            }
+          ) }),
+          props.children && (props.caption ?? "title") !== "custom" ? /* @__PURE__ */ jsxRuntime.jsx(Footer, { children: props.children }) : null
+        ] }, `range-${view}`)
+      ]
+    }
+  );
+}, "RangeCalendar");
+var CalendarCaption = /* @__PURE__ */ __name(({ children }) => /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }), "CalendarCaption");
+CalendarCaption.displayName = "CalendarCaption";
+var Calendar = CalendarRoot;
+Calendar.Caption = CalendarCaption;
+
+// src/slot/compose-refs.ts
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (ref == null) {
+        continue;
+      }
+      if (typeof ref === "function") {
+        ref(node);
+      } else {
+        ref.current = node;
+      }
+    }
+  };
+}
+__name(composeRefs, "composeRefs");
+var Slot = react.forwardRef(/* @__PURE__ */ __name(function Slot2(props, forwardedRef) {
+  const { children, ...slotProps } = props;
+  if (!react.isValidElement(children)) {
+    return null;
+  }
+  const child = react.Children.only(children);
+  const merged = mergeProps(slotProps, child.props);
+  const childRef = child.ref;
+  if (forwardedRef || childRef) {
+    merged.ref = composeRefs(forwardedRef, childRef);
+  }
+  return react.cloneElement(child, merged);
+}, "Slot"));
+Slot.displayName = "Slot";
+function mergeProps(outer, inner) {
+  const merged = { ...outer };
+  for (const key of Object.keys(inner)) {
+    const outerValue = outer[key];
+    const innerValue = inner[key];
+    if (key === "className" || key === "class") {
+      merged[key] = joinClass(outerValue, innerValue);
+      continue;
+    }
+    if (key === "style") {
+      merged[key] = {
+        ...outerValue,
+        ...innerValue
+      };
+      continue;
+    }
+    if (isEventHandler(key, outerValue, innerValue)) {
+      merged[key] = composeHandlers(outerValue, innerValue);
+      continue;
+    }
+    merged[key] = innerValue;
+  }
+  return merged;
+}
+__name(mergeProps, "mergeProps");
+function joinClass(outer, inner) {
+  const a = typeof outer === "string" ? outer : "";
+  const b = typeof inner === "string" ? inner : "";
+  const joined = [a, b].filter(Boolean).join(" ");
+  return joined.length > 0 ? joined : void 0;
+}
+__name(joinClass, "joinClass");
+function isEventHandler(key, outer, inner) {
+  if (!key.startsWith("on") || key.length < 3) {
+    return false;
+  }
+  if (key[2] !== key[2]?.toUpperCase()) {
+    return false;
+  }
+  return typeof outer === "function" && typeof inner === "function";
+}
+__name(isEventHandler, "isEventHandler");
+function composeHandlers(outer, inner) {
+  return (...args) => {
+    outer(...args);
+    inner(...args);
+  };
+}
+__name(composeHandlers, "composeHandlers");
+var PopoverContext = react.createContext(null);
+var usePopoverContext = /* @__PURE__ */ __name((label) => {
+  const ctx = react.useContext(PopoverContext);
+  if (!ctx) {
+    throw new Error(`<${label}> must be rendered inside a <Popover>.`);
+  }
+  return ctx;
+}, "usePopoverContext");
+var PopoverRoot = /* @__PURE__ */ __name(({ open, defaultOpen = false, onOpenChange, children }) => {
+  const [inner, setInner] = react.useState(defaultOpen);
+  const isControlled = open !== void 0;
+  const current = isControlled ? open : inner;
+  const setOpen = react.useCallback(
+    (next) => {
+      if (!isControlled) {
+        setInner(next);
+      }
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  const baseId = react.useId();
+  const triggerRef = react.useRef(null);
+  const contentRef = react.useRef(null);
+  const [triggerRect, setTriggerRect] = react.useState(null);
+  const measureTrigger = react.useCallback(() => {
+    const node = triggerRef.current;
+    if (!node || typeof node.getBoundingClientRect !== "function") {
+      return;
+    }
+    const rect = node.getBoundingClientRect();
+    setTriggerRect({ top: rect.top, left: rect.left, width: rect.width, height: rect.height });
+  }, []);
+  const ctxValue = {
+    open: current,
+    setOpen,
+    contentId: `${baseId}-content`,
+    triggerRef,
+    contentRef,
+    triggerRect,
+    measureTrigger
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(PopoverContext.Provider, { value: ctxValue, children });
+}, "PopoverRoot");
+var PopoverTrigger = /* @__PURE__ */ __name(({ asChild = true, children, className, testID }) => {
+  const ctx = usePopoverContext("PopoverTrigger");
+  const onPress = react.useCallback(() => {
+    ctx.measureTrigger();
+    ctx.setOpen(!ctx.open);
+  }, [ctx]);
+  if (asChild && react.isValidElement(children)) {
+    const child = children;
+    const fire = /* @__PURE__ */ __name((existing) => (event) => {
+      existing?.(event);
+      ctx.measureTrigger();
+      ctx.setOpen(!ctx.open);
+    }, "fire");
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Slot,
+      {
+        ref: (node) => {
+          ctx.triggerRef.current = node;
+        },
+        onClick: fire(child.props.onClick),
+        onPress: fire(child.props.onPress),
+        "aria-haspopup": "dialog",
+        "aria-expanded": ctx.open,
+        "aria-controls": ctx.contentId,
+        ...testID !== void 0 ? { "data-testid": testID } : {},
+        ...className !== void 0 ? { className } : {},
+        children: child
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      ref: (node) => {
+        ctx.triggerRef.current = node;
+      },
+      onPress,
+      ...{
+        "aria-haspopup": "dialog",
+        "aria-expanded": ctx.open,
+        "aria-controls": ctx.contentId
+      },
+      ...testID !== void 0 ? { testID } : {},
+      ...className !== void 0 ? { className } : {},
+      children: wrapStringChildren(children)
+    }
+  );
+}, "PopoverTrigger");
+function wrapStringChildren(children) {
+  if (typeof children === "string" || typeof children === "number") {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { children });
+  }
+  return children;
+}
+__name(wrapStringChildren, "wrapStringChildren");
+var GAP = 4;
+var MIN_WIDTH = 200;
+var VIEWPORT_MARGIN = 8;
+function computePosition(rect, side, align, contentSize) {
+  const cw = contentSize?.width ?? MIN_WIDTH;
+  const ch = contentSize?.height ?? 0;
+  let top = 0;
+  let left = 0;
+  switch (side) {
+    case "top":
+      top = rect.top - GAP - ch;
+      break;
+    case "bottom":
+      top = rect.top + rect.height + GAP;
+      break;
+    case "left":
+      left = rect.left - GAP - cw;
+      break;
+    case "right":
+      left = rect.left + rect.width + GAP;
+      break;
+  }
+  if (side === "top" || side === "bottom") {
+    switch (align) {
+      case "start":
+        left = rect.left;
+        break;
+      case "center":
+        left = rect.left + rect.width / 2 - cw / 2;
+        break;
+      case "end":
+        left = rect.left + rect.width - cw;
+        break;
+    }
+  } else {
+    switch (align) {
+      case "start":
+        top = rect.top;
+        break;
+      case "center":
+        top = rect.top + rect.height / 2 - ch / 2;
+        break;
+      case "end":
+        top = rect.top + rect.height - ch;
+        break;
+    }
+  }
+  return { top, left };
+}
+__name(computePosition, "computePosition");
+var PopoverContent = /* @__PURE__ */ __name(({
+  side = "bottom",
+  align = "center",
+  children,
+  className,
+  testID,
+  ...rest
+}) => {
+  const ctx = usePopoverContext("PopoverContent");
+  const colors = useThemeColors();
+  const ariaLabel = rest["aria-label"];
+  const [contentSize, setContentSize] = react.useState(null);
+  react.useEffect(() => {
+    if (!ctx.open) {
+      return;
+    }
+    if (reactNative.Platform.OS !== "web") {
+      return;
+    }
+    if (typeof document === "undefined") {
+      return;
+    }
+    ctx.measureTrigger();
+    const onDocMouseDown = /* @__PURE__ */ __name((event) => {
+      const target = event.target;
+      const trigger = ctx.triggerRef.current;
+      const content2 = ctx.contentRef.current;
+      if (trigger?.contains(target)) {
+        return;
+      }
+      if (content2?.contains(target)) {
+        return;
+      }
+      ctx.setOpen(false);
+    }, "onDocMouseDown");
+    const onKeyDown = /* @__PURE__ */ __name((event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        ctx.setOpen(false);
+      }
+    }, "onKeyDown");
+    const onResize = /* @__PURE__ */ __name(() => ctx.measureTrigger(), "onResize");
+    const onScroll = /* @__PURE__ */ __name(() => ctx.measureTrigger(), "onScroll");
+    document.addEventListener("mousedown", onDocMouseDown);
+    document.addEventListener("keydown", onKeyDown);
+    window.addEventListener("resize", onResize);
+    window.addEventListener("scroll", onScroll, true);
+    return () => {
+      document.removeEventListener("mousedown", onDocMouseDown);
+      document.removeEventListener("keydown", onKeyDown);
+      window.removeEventListener("resize", onResize);
+      window.removeEventListener("scroll", onScroll, true);
+    };
+  }, [ctx.open, ctx.measureTrigger, ctx.setOpen, ctx.triggerRef, ctx.contentRef]);
+  react.useEffect(() => {
+    if (!ctx.open) {
+      setContentSize(null);
+    }
+  }, [ctx.open]);
+  if (!ctx.open) {
+    return null;
+  }
+  const position = ctx.triggerRect ? computePosition(ctx.triggerRect, side, align, contentSize) : null;
+  const viewportWidth = reactNative.Dimensions.get("window").width;
+  const maxContentWidth = Math.max(MIN_WIDTH, viewportWidth - VIEWPORT_MARGIN * 2);
+  const contentBaseStyle = {
+    minWidth: MIN_WIDTH,
+    maxWidth: maxContentWidth,
+    borderRadius: px(colors.radius.lg),
+    borderWidth: 1,
+    borderColor: colors.semantic.border.default,
+    backgroundColor: colors.semantic.background.elevated,
+    padding: px(colors.spacing["4"]),
+    ...reactNative.Platform.OS === "web" ? {
+      boxShadow: "0 10px 15px -3px rgba(0,0,0,0.1), 0 4px 6px -4px rgba(0,0,0,0.1)",
+      // Subtle scale-in. Skipped on native (do nothing fancy there).
+      transition: "opacity 120ms ease-out, transform 120ms ease-out",
+      transform: "scale(1)",
+      opacity: 1
+    } : { elevation: 8 }
+  };
+  const measuredWidth = contentSize?.width ?? maxContentWidth;
+  const clampedLeft = position ? Math.min(
+    Math.max(VIEWPORT_MARGIN, position.left),
+    Math.max(VIEWPORT_MARGIN, viewportWidth - measuredWidth - VIEWPORT_MARGIN)
+  ) : 0;
+  const positionedStyle = reactNative.Platform.OS === "web" ? position ? {
+    position: "fixed",
+    top: position.top,
+    left: clampedLeft,
+    zIndex: 50
+  } : {
+    // Trigger not yet measured — render off-screen for a
+    // frame to avoid a flash at (0,0).
+    position: "fixed",
+    top: -9999,
+    left: -9999,
+    zIndex: 50
+  } : {};
+  const content = /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      ref: (node) => {
+        ctx.contentRef.current = node;
+        if (reactNative.Platform.OS !== "web") {
+          return;
+        }
+        if (!node) {
+          return;
+        }
+        if (typeof node.getBoundingClientRect !== "function") {
+          return;
+        }
+        const rect = node.getBoundingClientRect();
+        if (!contentSize || contentSize.width !== rect.width || contentSize.height !== rect.height) {
+          setContentSize({ width: rect.width, height: rect.height });
+        }
+      },
+      ...{
+        role: "dialog",
+        id: ctx.contentId,
+        ...ariaLabel !== void 0 ? { "aria-label": ariaLabel, accessibilityLabel: ariaLabel } : {}
+      },
+      ...testID !== void 0 ? { testID } : {},
+      className: cn(
+        "rounded-lg border border-semantic-border-default bg-semantic-background-elevated",
+        className
+      ),
+      style: [contentBaseStyle, positionedStyle],
+      children
+    }
+  );
+  if (reactNative.Platform.OS === "web") {
+    return content;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Modal, { visible: ctx.open, transparent: true, animationType: "fade", onRequestClose: () => ctx.setOpen(false), children: /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Pressable,
+    {
+      accessibilityRole: "none",
+      "aria-hidden": true,
+      onPress: () => ctx.setOpen(false),
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "transparent"
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          onPress: (event) => event.stopPropagation?.(),
+          style: {
+            position: "absolute",
+            top: ctx.triggerRect ? side === "top" ? Math.max(VIEWPORT_MARGIN, ctx.triggerRect.top - GAP - 80) : ctx.triggerRect.top + ctx.triggerRect.height + GAP : 80,
+            // Clamp horizontally so a wide popover near the
+            // right edge can still grow leftward without
+            // overflowing the screen.
+            left: ctx.triggerRect ? Math.min(
+              Math.max(VIEWPORT_MARGIN, ctx.triggerRect.left),
+              Math.max(VIEWPORT_MARGIN, viewportWidth - measuredWidth - VIEWPORT_MARGIN)
+            ) : VIEWPORT_MARGIN * 2
+          },
+          children: content
+        }
+      )
+    }
+  ) });
+}, "PopoverContent");
+var Popover = Object.assign(PopoverRoot, {
+  Trigger: PopoverTrigger,
+  Content: PopoverContent
+});
+function formatDate(date$1, locale) {
+  try {
+    return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(date$1.toDate(date.getLocalTimeZone()));
+  } catch {
+    return `${date$1.year}-${String(date$1.month).padStart(2, "0")}-${String(date$1.day).padStart(2, "0")}`;
+  }
+}
+__name(formatDate, "formatDate");
+function CalendarIcon({ size = 16, color = "currentColor" }) {
+  const colors = useThemeColors();
+  if (reactNative.Platform.OS === "web") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "svg",
+      {
+        width: size,
+        height: size,
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: color,
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        "aria-hidden": "true",
+        children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 2v4M16 2v4M3 10h18M5 4h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2z" })
+      }
+    );
+  }
+  const resolvedColor = color === "currentColor" ? colors.semantic.text.muted : color;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Text,
+    {
+      accessibilityElementsHidden: true,
+      importantForAccessibility: "no-hide-descendants",
+      style: { fontSize: size, lineHeight: size, color: resolvedColor },
+      children: "\u{1F4C5}"
+    }
+  );
+}
+__name(CalendarIcon, "CalendarIcon");
+function buildCalendarOptional(minValue, maxValue, isDateUnavailable, firstDayOfWeek) {
+  const out = {};
+  if (minValue !== void 0) {
+    out.minValue = minValue;
+  }
+  if (maxValue !== void 0) {
+    out.maxValue = maxValue;
+  }
+  if (isDateUnavailable !== void 0) {
+    out.isDateUnavailable = isDateUnavailable;
+  }
+  if (firstDayOfWeek !== void 0) {
+    out.firstDayOfWeek = firstDayOfWeek;
+  }
+  return out;
+}
+__name(buildCalendarOptional, "buildCalendarOptional");
+function buildTriggerAriaProps(ariaProps) {
+  const out = {};
+  if (ariaProps["aria-labelledby"] !== void 0) {
+    out["aria-labelledby"] = ariaProps["aria-labelledby"];
+  }
+  if (ariaProps["aria-describedby"] !== void 0) {
+    out["aria-describedby"] = ariaProps["aria-describedby"];
+  }
+  if (ariaProps["aria-invalid"] !== void 0) {
+    out["aria-invalid"] = ariaProps["aria-invalid"];
+  }
+  if (ariaProps["aria-required"] !== void 0) {
+    out["aria-required"] = ariaProps["aria-required"];
+  }
+  return out;
+}
+__name(buildTriggerAriaProps, "buildTriggerAriaProps");
+var DatePickerRoot = /* @__PURE__ */ __name(({
+  value,
+  defaultValue: defaultValue2,
+  onChange,
+  locale: localeProp,
+  minValue,
+  maxValue,
+  isDateUnavailable,
+  firstDayOfWeek,
+  placeholder,
+  disabled = false,
+  id,
+  name: _name,
+  className,
+  testID,
+  ...ariaProps
+}) => {
+  const providerLocale = useLocale();
+  const locale = localeProp ?? providerLocale;
+  const [open, setOpen] = react.useState(false);
+  const isControlled = value !== void 0;
+  const [inner, setInner] = react.useState(defaultValue2 ?? null);
+  const current = isControlled ? value ?? null : inner;
+  const handleChange = react.useCallback(
+    (date) => {
+      if (!isControlled) {
+        setInner(date);
+      }
+      onChange?.(date);
+      setOpen(false);
+    },
+    [isControlled, onChange]
+  );
+  const handleOpenChange = react.useCallback(
+    (next) => {
+      if (!disabled) {
+        setOpen(next);
+      }
+    },
+    [disabled]
+  );
+  const displayValue = current ? formatDate(current, locale) : null;
+  const calendarOptional = buildCalendarOptional(minValue, maxValue, isDateUnavailable, firstDayOfWeek);
+  const triggerAriaProps = buildTriggerAriaProps(ariaProps);
+  const colors = useThemeColors();
+  const hasError = ariaProps["aria-invalid"] === true || ariaProps["aria-invalid"] === "true";
+  const pressableStyle = {
+    flexDirection: "row",
+    alignItems: "center",
+    borderWidth: 1,
+    borderRadius: px(colors.radius.md),
+    paddingHorizontal: px(colors.spacing["3"]),
+    paddingVertical: px(colors.spacing["2"]),
+    backgroundColor: colors.semantic.background.elevated,
+    borderColor: hasError ? colors.color.danger : colors.semantic.border.default,
+    opacity: disabled ? 0.6 : 1
+  };
+  const textStyle = {
+    flex: 1,
+    fontFamily: colors.fontFamily.body,
+    fontSize: px(colors.fontSize.md),
+    color: displayValue ? colors.semantic.text.default : colors.semantic.text.muted
+  };
+  const triggerExtraProps = {
+    role: "combobox",
+    accessibilityRole: "button",
+    "aria-haspopup": "dialog",
+    "aria-expanded": open,
+    ...triggerAriaProps
+  };
+  if (id !== void 0) {
+    triggerExtraProps.id = id;
+    triggerExtraProps.nativeID = id;
+  }
+  if (testID !== void 0) {
+    triggerExtraProps.testID = testID;
+  }
+  if (hasError) {
+    triggerExtraProps["aria-invalid"] = true;
+  }
+  if (ariaProps["aria-required"]) {
+    triggerExtraProps["aria-required"] = true;
+  }
+  if (disabled) {
+    triggerExtraProps["aria-disabled"] = true;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(Popover, { open, onOpenChange: handleOpenChange, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Popover.Trigger, { asChild: false, className: cn(className), children: /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.Pressable,
+      {
+        onPress: disabled ? void 0 : () => setOpen(!open),
+        disabled,
+        className: cn(
+          "flex-row items-center rounded-md border px-3 py-2",
+          hasError ? "border-semantic-interactive-destructive" : "border-semantic-border-default",
+          disabled ? "opacity-60" : void 0,
+          className
+        ),
+        style: pressableStyle,
+        ...triggerExtraProps,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: textStyle, numberOfLines: 1, children: displayValue ?? placeholder ?? "" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { marginLeft: px(colors.spacing["2"]) }, children: /* @__PURE__ */ jsxRuntime.jsx(CalendarIcon, { size: 16, color: colors.semantic.text.muted }) })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Popover.Content, { "aria-label": "Date picker", side: "bottom", align: "start", children: /* @__PURE__ */ jsxRuntime.jsx(
+      Calendar,
+      {
+        mode: "single",
+        value: current,
+        onChange: (date) => {
+          handleChange(date);
+        },
+        locale,
+        ...calendarOptional
+      }
+    ) })
+  ] });
+}, "DatePickerRoot");
+var DatePickerRange = /* @__PURE__ */ __name(({
+  value,
+  defaultValue: defaultValue2,
+  onChange,
+  locale: localeProp,
+  minValue,
+  maxValue,
+  isDateUnavailable,
+  firstDayOfWeek,
+  placeholder,
+  disabled = false,
+  id,
+  name: _name,
+  className,
+  testID,
+  ...ariaProps
+}) => {
+  const providerLocale = useLocale();
+  const locale = localeProp ?? providerLocale;
+  const [open, setOpen] = react.useState(false);
+  const isControlled = value !== void 0;
+  const [inner, setInner] = react.useState(defaultValue2 ?? { start: null, end: null });
+  const current = isControlled ? value ?? { start: null, end: null } : inner;
+  const calendarValue = current.start !== null ? { start: current.start, end: current.end } : null;
+  const handleChange = react.useCallback(
+    (calRange) => {
+      const next = {
+        start: calRange?.start ?? null,
+        end: calRange?.end ?? null
+      };
+      if (!isControlled) {
+        setInner(next);
+      }
+      onChange?.(next);
+      if (next.start !== null && next.end !== null) {
+        setOpen(false);
+      }
+    },
+    [isControlled, onChange]
+  );
+  const handleOpenChange = react.useCallback(
+    (next) => {
+      if (!disabled) {
+        setOpen(next);
+      }
+    },
+    [disabled]
+  );
+  let displayValue = null;
+  if (current.start !== null) {
+    const startStr = formatDate(current.start, locale);
+    const endStr = current.end !== null ? formatDate(current.end, locale) : "";
+    displayValue = `${startStr} \u2013 ${endStr}`;
+  }
+  const calendarOptional = buildCalendarOptional(minValue, maxValue, isDateUnavailable, firstDayOfWeek);
+  const triggerAriaProps = buildTriggerAriaProps(ariaProps);
+  const colors = useThemeColors();
+  const hasError = ariaProps["aria-invalid"] === true || ariaProps["aria-invalid"] === "true";
+  const pressableStyle = {
+    flexDirection: "row",
+    alignItems: "center",
+    borderWidth: 1,
+    borderRadius: px(colors.radius.md),
+    paddingHorizontal: px(colors.spacing["3"]),
+    paddingVertical: px(colors.spacing["2"]),
+    backgroundColor: colors.semantic.background.elevated,
+    borderColor: hasError ? colors.color.danger : colors.semantic.border.default,
+    opacity: disabled ? 0.6 : 1
+  };
+  const textStyle = {
+    flex: 1,
+    fontFamily: colors.fontFamily.body,
+    fontSize: px(colors.fontSize.md),
+    color: displayValue ? colors.semantic.text.default : colors.semantic.text.muted
+  };
+  const triggerExtraProps = {
+    role: "combobox",
+    accessibilityRole: "button",
+    "aria-haspopup": "dialog",
+    "aria-expanded": open,
+    ...triggerAriaProps
+  };
+  if (id !== void 0) {
+    triggerExtraProps.id = id;
+    triggerExtraProps.nativeID = id;
+  }
+  if (testID !== void 0) {
+    triggerExtraProps.testID = testID;
+  }
+  if (hasError) {
+    triggerExtraProps["aria-invalid"] = true;
+  }
+  if (ariaProps["aria-required"]) {
+    triggerExtraProps["aria-required"] = true;
+  }
+  if (disabled) {
+    triggerExtraProps["aria-disabled"] = true;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(Popover, { open, onOpenChange: handleOpenChange, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Popover.Trigger, { asChild: false, className: cn(className), children: /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.Pressable,
+      {
+        onPress: disabled ? void 0 : () => setOpen(!open),
+        disabled,
+        className: cn(
+          "flex-row items-center rounded-md border px-3 py-2",
+          hasError ? "border-semantic-interactive-destructive" : "border-semantic-border-default",
+          disabled ? "opacity-60" : void 0,
+          className
+        ),
+        style: pressableStyle,
+        ...triggerExtraProps,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: textStyle, numberOfLines: 1, children: displayValue ?? placeholder ?? "" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { marginLeft: px(colors.spacing["2"]) }, children: /* @__PURE__ */ jsxRuntime.jsx(CalendarIcon, { size: 16, color: colors.semantic.text.muted }) })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Popover.Content, { "aria-label": "Date range picker", side: "bottom", align: "start", children: /* @__PURE__ */ jsxRuntime.jsx(
+      Calendar,
+      {
+        mode: "range",
+        value: calendarValue,
+        onChange: (range) => {
+          handleChange(range);
+        },
+        locale,
+        ...calendarOptional
+      }
+    ) })
+  ] });
+}, "DatePickerRange");
+var DatePicker = Object.assign(DatePickerRoot, {
+  Range: DatePickerRange
+});
+
+exports.DatePicker = DatePicker;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map