@serendie/ui 3.2.0 → 3.2.1-dev.202604251106

package/dist/node_modules/@zag-js/date-picker/dist/date-picker.machine.js

@@ -0,0 +1,1042 @@
+import { toCalendar as B, toZoned as p, toCalendarDateTime as y } from "../../../@internationalized/date/dist/conversion.js";
+import { DateFormatter as Z } from "../../../@internationalized/date/dist/DateFormatter.js";
+import { createLiveRegion as H } from "../../live-region/dist/index.js";
+import { getPlacement as U } from "../../popper/dist/get-placement.js";
+import { getInputEls as m, getYearSelectEl as W, getMonthSelectEl as G, getTriggerEl as D, getFocusedCell as F, getContentEl as A, getClearTriggerEl as _, getControlEl as $, getPositionerEl as j } from "./date-picker.dom.js";
+import { isValidDate as M, adjustStartAndEndDate as N, sortDates as x, getPreviousView as K, getNextView as q, isAboveMinView as z, getVisibleRangeText as X, clampView as J, eachView as Q, isBelowMinView as ee } from "./date-picker.utils.js";
+import { createMachine as te, createGuards as ne } from "../../core/dist/create-machine.js";
+import { isDateOutsideRange as se, isDateEqual as f, isNextRangeInvalid as oe, isPreviousRangeInvalid as ae } from "../../date-utils/dist/assertion.js";
+import { alignDate as k } from "../../date-utils/dist/align.js";
+import { constrainValue as E } from "../../date-utils/dist/constrain.js";
+import { setElementValue as O } from "../../dom-query/dist/form.js";
+import { raf as V } from "../../dom-query/dist/raf.js";
+import { getDecadeRange as L } from "../../date-utils/dist/date-year.js";
+import { getTodayDate as b } from "../../date-utils/dist/mutation.js";
+import { getPreviousSection as ie, getNextSection as ce, getPreviousPage as ue, getNextPage as le, getAdjustedDateFn as re } from "../../date-utils/dist/pagination.js";
+import { restoreTextSelection as de, disableTextSelection as ge } from "../../dom-query/dist/text-selection.js";
+import { formatSelectedDate as h } from "../../date-utils/dist/format.js";
+import { trackDismissableElement as fe } from "../../dismissable/dist/dismissable-layer.js";
+import { getEndDate as ve } from "../../date-utils/dist/duration.js";
+import { parseDateString as Ve } from "../../date-utils/dist/parse-date.js";
+var { and: r } = ne();
+function me(e, t) {
+  if ((e == null ? void 0 : e.length) !== (t == null ? void 0 : t.length)) return !1;
+  const n = Math.max(e.length, t.length);
+  for (let s = 0; s < n; s++)
+    if (!f(e[s], t[s])) return !1;
+  return !0;
+}
+function C(e, t) {
+  return e.map((n) => n == null ? "" : t("format")(n, { locale: t("locale"), timeZone: t("timeZone") }));
+}
+var Be = te({
+  props({ props: e }) {
+    const t = e.locale || "en-US", n = e.timeZone || "UTC", s = e.selectionMode || "single", o = e.numOfMonths || 1;
+    let a;
+    if (e.createCalendar) {
+      const v = new Intl.DateTimeFormat(t).resolvedOptions().calendar;
+      v !== "gregory" && v !== "iso8601" && (a = e.createCalendar(v));
+    }
+    const i = (d) => !a || d.calendar.identifier === a.identifier ? d : B(d, a), u = e.defaultValue ? x(e.defaultValue).map((d) => E(i(d), e.min, e.max)) : void 0, l = e.value ? x(e.value).map((d) => E(i(d), e.min, e.max)) : void 0;
+    let g = e.focusedValue || e.defaultFocusedValue || (l == null ? void 0 : l[0]) || (u == null ? void 0 : u[0]) || b(n, a);
+    g = E(i(g), e.min, e.max);
+    const w = "day", R = "year", Y = J(e.view || w, w, R);
+    return {
+      locale: t,
+      numOfMonths: o,
+      timeZone: n,
+      selectionMode: s,
+      defaultView: Y,
+      minView: w,
+      maxView: R,
+      outsideDaySelectable: !1,
+      closeOnSelect: !0,
+      format(d, { locale: v, timeZone: S }) {
+        return new Z(v, {
+          timeZone: S,
+          day: "2-digit",
+          month: "2-digit",
+          year: "numeric",
+          calendar: a == null ? void 0 : a.identifier
+        }).format(d.toDate(S));
+      },
+      parse(d, { locale: v, timeZone: S }) {
+        return Ve(d, v, S);
+      },
+      ...e,
+      focusedValue: typeof e.focusedValue > "u" ? void 0 : g,
+      defaultFocusedValue: g,
+      value: l,
+      defaultValue: u ?? [],
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      }
+    };
+  },
+  initialState({ prop: e }) {
+    return e("open") || e("defaultOpen") || e("inline") ? "open" : "idle";
+  },
+  refs() {
+    return {
+      announcer: void 0
+    };
+  },
+  context({ prop: e, bindable: t, getContext: n }) {
+    return {
+      focusedValue: t(() => ({
+        defaultValue: e("defaultFocusedValue"),
+        value: e("focusedValue"),
+        isEqual: f,
+        hash: (s) => s.toString(),
+        sync: !0,
+        onChange(s) {
+          var l;
+          const o = n(), a = o.get("view"), i = o.get("value"), u = C(i, e);
+          (l = e("onFocusChange")) == null || l({ value: i, valueAsString: u, view: a, focusedValue: s });
+        }
+      })),
+      value: t(() => ({
+        defaultValue: e("defaultValue"),
+        value: e("value"),
+        isEqual: me,
+        hash: (s) => s.map((o) => (o == null ? void 0 : o.toString()) ?? "").join(","),
+        onChange(s) {
+          var i;
+          const o = n(), a = C(s, e);
+          (i = e("onValueChange")) == null || i({ value: s, valueAsString: a, view: o.get("view") });
+        }
+      })),
+      inputValue: t(() => ({
+        defaultValue: ""
+      })),
+      activeIndex: t(() => ({
+        defaultValue: 0,
+        sync: !0
+      })),
+      hoveredValue: t(() => ({
+        defaultValue: null,
+        isEqual: f
+      })),
+      view: t(() => ({
+        defaultValue: e("defaultView"),
+        value: e("view"),
+        onChange(s) {
+          var o;
+          (o = e("onViewChange")) == null || o({ view: s });
+        }
+      })),
+      startValue: t(() => {
+        const s = e("focusedValue") || e("defaultFocusedValue");
+        return {
+          defaultValue: k(s, "start", { months: e("numOfMonths") }, e("locale")),
+          isEqual: f,
+          hash: (o) => o.toString()
+        };
+      }),
+      currentPlacement: t(() => ({
+        defaultValue: void 0
+      })),
+      restoreFocus: t(() => ({
+        defaultValue: !1
+      }))
+    };
+  },
+  computed: {
+    isInteractive: ({ prop: e }) => !e("disabled") && !e("readOnly"),
+    visibleDuration: ({ prop: e }) => ({ months: e("numOfMonths") }),
+    endValue: ({ context: e, computed: t }) => ve(e.get("startValue"), t("visibleDuration")),
+    visibleRange: ({ context: e, computed: t }) => ({ start: e.get("startValue"), end: t("endValue") }),
+    visibleRangeText: ({ context: e, prop: t, computed: n }) => X({
+      view: e.get("view"),
+      startValue: e.get("startValue"),
+      endValue: n("endValue"),
+      locale: t("locale"),
+      timeZone: t("timeZone"),
+      selectionMode: t("selectionMode")
+    }),
+    isPrevVisibleRangeValid: ({ context: e, prop: t }) => !ae(e.get("startValue"), t("min"), t("max")),
+    isNextVisibleRangeValid: ({ prop: e, computed: t }) => !oe(t("endValue"), e("min"), e("max")),
+    valueAsString: ({ context: e, prop: t }) => C(e.get("value"), t)
+  },
+  effects: ["setupLiveRegion"],
+  watch({ track: e, prop: t, context: n, action: s, computed: o }) {
+    e([() => t("locale")], () => {
+      s(["setStartValue", "syncInputElement"]);
+    }), e([() => n.hash("focusedValue")], () => {
+      s(["setStartValue", "focusActiveCellIfNeeded", "setHoveredValueIfKeyboard"]);
+    }), e([() => n.hash("startValue")], () => {
+      s(["syncMonthSelectElement", "syncYearSelectElement", "invokeOnVisibleRangeChange"]);
+    }), e([() => n.get("inputValue")], () => {
+      s(["syncInputValue"]);
+    }), e([() => n.hash("value")], () => {
+      s(["syncInputElement"]);
+    }), e([() => o("valueAsString").toString()], () => {
+      s(["announceValueText"]);
+    }), e([() => n.get("view")], () => {
+      s(["focusActiveCell"]);
+    }), e([() => t("open")], () => {
+      s(["toggleVisibility"]);
+    });
+  },
+  on: {
+    "VALUE.SET": {
+      actions: ["setDateValue", "setFocusedDate"]
+    },
+    "VIEW.SET": {
+      actions: ["setView"]
+    },
+    "FOCUS.SET": {
+      actions: ["setFocusedDate"]
+    },
+    "VALUE.CLEAR": {
+      actions: ["clearDateValue", "clearFocusedDate", "focusFirstInputElement"]
+    },
+    "INPUT.CHANGE": [
+      {
+        guard: "isInputValueEmpty",
+        actions: ["setInputValue", "clearDateValue", "clearFocusedDate"]
+      },
+      {
+        actions: ["setInputValue", "focusParsedDate"]
+      }
+    ],
+    "INPUT.ENTER": {
+      actions: ["focusParsedDate", "selectFocusedDate"]
+    },
+    "INPUT.FOCUS": {
+      actions: ["setActiveIndex"]
+    },
+    "INPUT.BLUR": [
+      {
+        guard: "shouldFixOnBlur",
+        actions: ["setActiveIndexToStart", "selectParsedDate"]
+      },
+      {
+        actions: ["setActiveIndexToStart"]
+      }
+    ],
+    "PRESET.CLICK": [
+      {
+        guard: "isOpenControlled",
+        actions: ["setDateValue", "setFocusedDate", "invokeOnClose"]
+      },
+      {
+        target: "focused",
+        actions: ["setDateValue", "setFocusedDate", "focusInputElement"]
+      }
+    ],
+    "GOTO.NEXT": [
+      {
+        guard: "isYearView",
+        actions: ["focusNextDecade", "announceVisibleRange"]
+      },
+      {
+        guard: "isMonthView",
+        actions: ["focusNextYear", "announceVisibleRange"]
+      },
+      {
+        actions: ["focusNextPage"]
+      }
+    ],
+    "GOTO.PREV": [
+      {
+        guard: "isYearView",
+        actions: ["focusPreviousDecade", "announceVisibleRange"]
+      },
+      {
+        guard: "isMonthView",
+        actions: ["focusPreviousYear", "announceVisibleRange"]
+      },
+      {
+        actions: ["focusPreviousPage"]
+      }
+    ]
+  },
+  states: {
+    idle: {
+      tags: ["closed"],
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open",
+          actions: ["focusFirstSelectedDate", "focusActiveCell"]
+        },
+        "TRIGGER.CLICK": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["focusFirstSelectedDate", "focusActiveCell", "invokeOnOpen"]
+          }
+        ],
+        OPEN: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["focusFirstSelectedDate", "focusActiveCell", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    focused: {
+      tags: ["closed"],
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open",
+          actions: ["focusFirstSelectedDate", "focusActiveCell"]
+        },
+        "TRIGGER.CLICK": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["focusFirstSelectedDate", "focusActiveCell", "invokeOnOpen"]
+          }
+        ],
+        OPEN: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["focusFirstSelectedDate", "focusActiveCell", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    open: {
+      tags: ["open"],
+      effects: ["trackDismissableElement", "trackPositioning"],
+      exit: ["clearHoveredDate", "resetView"],
+      on: {
+        "CONTROLLED.CLOSE": [
+          {
+            guard: r("shouldRestoreFocus", "isInteractOutsideEvent"),
+            target: "focused",
+            actions: ["focusTriggerElement"]
+          },
+          {
+            guard: "shouldRestoreFocus",
+            target: "focused",
+            actions: ["focusInputElement"]
+          },
+          {
+            target: "idle"
+          }
+        ],
+        "CELL.CLICK": [
+          {
+            guard: "isAboveMinView",
+            actions: ["setFocusedValueForView", "setPreviousView"]
+          },
+          {
+            guard: r("isRangePicker", "hasSelectedRange"),
+            actions: ["setActiveIndexToStart", "resetSelection", "setActiveIndexToEnd"]
+          },
+          // === Grouped transitions (based on `closeOnSelect` and `isOpenControlled`) ===
+          {
+            guard: r("isRangePicker", "isSelectingEndDate", "closeOnSelect", "isOpenControlled"),
+            actions: [
+              "setFocusedDate",
+              "setSelectedDate",
+              "setActiveIndexToStart",
+              "clearHoveredDate",
+              "invokeOnClose",
+              "setRestoreFocus"
+            ]
+          },
+          {
+            guard: r("isRangePicker", "isSelectingEndDate", "closeOnSelect"),
+            target: "focused",
+            actions: [
+              "setFocusedDate",
+              "setSelectedDate",
+              "setActiveIndexToStart",
+              "clearHoveredDate",
+              "invokeOnClose",
+              "focusInputElement"
+            ]
+          },
+          {
+            guard: r("isRangePicker", "isSelectingEndDate"),
+            actions: ["setFocusedDate", "setSelectedDate", "setActiveIndexToStart", "clearHoveredDate"]
+          },
+          // ===
+          {
+            guard: "isRangePicker",
+            actions: ["setFocusedDate", "setSelectedDate", "setActiveIndexToEnd"]
+          },
+          {
+            guard: r("isMultiPicker", "canSelectDate"),
+            actions: ["setFocusedDate", "toggleSelectedDate"]
+          },
+          {
+            guard: "isMultiPicker",
+            actions: ["setFocusedDate"]
+          },
+          // === Grouped transitions (based on `closeOnSelect` and `isOpenControlled`) ===
+          {
+            guard: r("closeOnSelect", "isOpenControlled"),
+            actions: ["setFocusedDate", "setSelectedDate", "invokeOnClose"]
+          },
+          {
+            guard: "closeOnSelect",
+            target: "focused",
+            actions: ["setFocusedDate", "setSelectedDate", "invokeOnClose", "focusInputElement"]
+          },
+          {
+            actions: ["setFocusedDate", "setSelectedDate"]
+          }
+          // ===
+        ],
+        "CELL.POINTER_MOVE": {
+          guard: r("isRangePicker", "isSelectingEndDate"),
+          actions: ["setHoveredDate", "setFocusedDate"]
+        },
+        "TABLE.POINTER_LEAVE": {
+          guard: "isRangePicker",
+          actions: ["clearHoveredDate"]
+        },
+        "TABLE.POINTER_DOWN": {
+          actions: ["disableTextSelection"]
+        },
+        "TABLE.POINTER_UP": {
+          actions: ["enableTextSelection"]
+        },
+        "TABLE.ESCAPE": [
+          {
+            guard: "isOpenControlled",
+            actions: ["focusFirstSelectedDate", "invokeOnClose"]
+          },
+          {
+            target: "focused",
+            actions: ["focusFirstSelectedDate", "invokeOnClose", "focusTriggerElement"]
+          }
+        ],
+        "TABLE.ENTER": [
+          {
+            guard: "isAboveMinView",
+            actions: ["setPreviousView"]
+          },
+          {
+            guard: r("isRangePicker", "hasSelectedRange"),
+            actions: ["setActiveIndexToStart", "clearDateValue", "setSelectedDate", "setActiveIndexToEnd"]
+          },
+          // === Grouped transitions (based on `closeOnSelect` and `isOpenControlled`) ===
+          {
+            guard: r("isRangePicker", "isSelectingEndDate", "closeOnSelect", "isOpenControlled"),
+            actions: ["setSelectedDate", "setActiveIndexToStart", "clearHoveredDate", "invokeOnClose"]
+          },
+          {
+            guard: r("isRangePicker", "isSelectingEndDate", "closeOnSelect"),
+            target: "focused",
+            actions: [
+              "setSelectedDate",
+              "setActiveIndexToStart",
+              "clearHoveredDate",
+              "invokeOnClose",
+              "focusInputElement"
+            ]
+          },
+          {
+            guard: r("isRangePicker", "isSelectingEndDate"),
+            actions: ["setSelectedDate", "setActiveIndexToStart", "clearHoveredDate"]
+          },
+          // ===
+          {
+            guard: "isRangePicker",
+            actions: ["setSelectedDate", "setActiveIndexToEnd", "focusNextDay"]
+          },
+          {
+            guard: r("isMultiPicker", "canSelectDate"),
+            actions: ["toggleSelectedDate"]
+          },
+          {
+            guard: "isMultiPicker"
+          },
+          // === Grouped transitions (based on `closeOnSelect` and `isOpenControlled`) ===
+          {
+            guard: r("closeOnSelect", "isOpenControlled"),
+            actions: ["selectFocusedDate", "invokeOnClose"]
+          },
+          {
+            guard: "closeOnSelect",
+            target: "focused",
+            actions: ["selectFocusedDate", "invokeOnClose", "focusInputElement"]
+          },
+          {
+            actions: ["selectFocusedDate"]
+          }
+          // ===
+        ],
+        "TABLE.ARROW_RIGHT": [
+          {
+            guard: "isMonthView",
+            actions: ["focusNextMonth"]
+          },
+          {
+            guard: "isYearView",
+            actions: ["focusNextYear"]
+          },
+          {
+            actions: ["focusNextDay", "setHoveredDate"]
+          }
+        ],
+        "TABLE.ARROW_LEFT": [
+          {
+            guard: "isMonthView",
+            actions: ["focusPreviousMonth"]
+          },
+          {
+            guard: "isYearView",
+            actions: ["focusPreviousYear"]
+          },
+          {
+            actions: ["focusPreviousDay"]
+          }
+        ],
+        "TABLE.ARROW_UP": [
+          {
+            guard: "isMonthView",
+            actions: ["focusPreviousMonthColumn"]
+          },
+          {
+            guard: "isYearView",
+            actions: ["focusPreviousYearColumn"]
+          },
+          {
+            actions: ["focusPreviousWeek"]
+          }
+        ],
+        "TABLE.ARROW_DOWN": [
+          {
+            guard: "isMonthView",
+            actions: ["focusNextMonthColumn"]
+          },
+          {
+            guard: "isYearView",
+            actions: ["focusNextYearColumn"]
+          },
+          {
+            actions: ["focusNextWeek"]
+          }
+        ],
+        "TABLE.PAGE_UP": {
+          actions: ["focusPreviousSection"]
+        },
+        "TABLE.PAGE_DOWN": {
+          actions: ["focusNextSection"]
+        },
+        "TABLE.HOME": [
+          {
+            guard: "isMonthView",
+            actions: ["focusFirstMonth"]
+          },
+          {
+            guard: "isYearView",
+            actions: ["focusFirstYear"]
+          },
+          {
+            actions: ["focusSectionStart"]
+          }
+        ],
+        "TABLE.END": [
+          {
+            guard: "isMonthView",
+            actions: ["focusLastMonth"]
+          },
+          {
+            guard: "isYearView",
+            actions: ["focusLastYear"]
+          },
+          {
+            actions: ["focusSectionEnd"]
+          }
+        ],
+        "TRIGGER.CLICK": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "focused",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "VIEW.TOGGLE": {
+          actions: ["setNextView"]
+        },
+        INTERACT_OUTSIDE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setActiveIndexToStart", "invokeOnClose"]
+          },
+          {
+            guard: "shouldRestoreFocus",
+            target: "focused",
+            actions: ["setActiveIndexToStart", "invokeOnClose", "focusTriggerElement"]
+          },
+          {
+            target: "idle",
+            actions: ["setActiveIndexToStart", "invokeOnClose"]
+          }
+        ],
+        CLOSE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setActiveIndexToStart", "invokeOnClose"]
+          },
+          {
+            target: "idle",
+            actions: ["setActiveIndexToStart", "invokeOnClose"]
+          }
+        ]
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isAboveMinView: ({ context: e, prop: t }) => z(e.get("view"), t("minView")),
+      isDayView: ({ context: e, event: t }) => (t.view || e.get("view")) === "day",
+      isMonthView: ({ context: e, event: t }) => (t.view || e.get("view")) === "month",
+      isYearView: ({ context: e, event: t }) => (t.view || e.get("view")) === "year",
+      isRangePicker: ({ prop: e }) => e("selectionMode") === "range",
+      hasSelectedRange: ({ context: e }) => e.get("value").length === 2,
+      isMultiPicker: ({ prop: e }) => e("selectionMode") === "multiple",
+      canSelectDate: ({ context: e, prop: t, event: n }) => {
+        const s = t("maxSelectedDates");
+        if (s == null) return !0;
+        const o = e.get("value"), a = n.value ?? e.get("focusedValue");
+        return o.some((u) => f(u, a)) ? !0 : o.length < s;
+      },
+      shouldRestoreFocus: ({ context: e }) => !!e.get("restoreFocus"),
+      isSelectingEndDate: ({ context: e }) => e.get("activeIndex") === 1,
+      closeOnSelect: ({ prop: e }) => !!e("closeOnSelect"),
+      isOpenControlled: ({ prop: e }) => e("open") != null || !!e("inline"),
+      isInteractOutsideEvent: ({ event: e }) => {
+        var t;
+        return ((t = e.previousEvent) == null ? void 0 : t.type) === "INTERACT_OUTSIDE";
+      },
+      isInputValueEmpty: ({ event: e }) => e.value.trim() === "",
+      shouldFixOnBlur: ({ event: e }) => !!e.fixOnBlur
+    },
+    effects: {
+      trackPositioning({ context: e, prop: t, scope: n }) {
+        if (t("inline")) return;
+        e.get("currentPlacement") || e.set("currentPlacement", t("positioning").placement);
+        const s = $(n);
+        return U(s, () => j(n), {
+          ...t("positioning"),
+          defer: !0,
+          onComplete(a) {
+            e.set("currentPlacement", a.placement);
+          }
+        });
+      },
+      setupLiveRegion({ scope: e, refs: t }) {
+        const n = e.getDoc();
+        return t.set("announcer", H({ level: "assertive", document: n })), () => {
+          var s, o;
+          return (o = (s = t.get("announcer")) == null ? void 0 : s.destroy) == null ? void 0 : o.call(s);
+        };
+      },
+      trackDismissableElement({ scope: e, send: t, context: n, prop: s }) {
+        return s("inline") ? void 0 : fe(() => A(e), {
+          type: "popover",
+          defer: !0,
+          exclude: [...m(e), D(e), _(e)],
+          onInteractOutside(a) {
+            n.set("restoreFocus", !a.detail.focusable);
+          },
+          onDismiss() {
+            t({ type: "INTERACT_OUTSIDE" });
+          },
+          onEscapeKeyDown(a) {
+            a.preventDefault(), t({ type: "TABLE.ESCAPE", src: "dismissable" });
+          }
+        });
+      }
+    },
+    actions: {
+      setNextView({ context: e, prop: t }) {
+        const n = q(e.get("view"), t("minView"), t("maxView"));
+        e.set("view", n);
+      },
+      setPreviousView({ context: e, prop: t }) {
+        const n = K(e.get("view"), t("minView"), t("maxView"));
+        e.set("view", n);
+      },
+      setView({ context: e, event: t }) {
+        e.set("view", t.view);
+      },
+      setRestoreFocus({ context: e }) {
+        e.set("restoreFocus", !0);
+      },
+      announceValueText({ context: e, prop: t, refs: n }) {
+        var u;
+        const s = e.get("value"), o = t("locale"), a = t("timeZone");
+        let i;
+        if (t("selectionMode") === "range") {
+          const [l, g] = s;
+          l && g ? i = h(l, g, o, a) : l ? i = h(l, null, o, a) : g ? i = h(g, null, o, a) : i = "";
+        } else
+          i = s.map((l) => h(l, null, o, a)).filter(Boolean).join(",");
+        (u = n.get("announcer")) == null || u.announce(i, 3e3);
+      },
+      announceVisibleRange({ computed: e, refs: t }) {
+        var s;
+        const { formatted: n } = e("visibleRangeText");
+        (s = t.get("announcer")) == null || s.announce(n);
+      },
+      disableTextSelection({ scope: e }) {
+        ge({ target: A(e), doc: e.getDoc() });
+      },
+      enableTextSelection({ scope: e }) {
+        de({ doc: e.getDoc(), target: A(e) });
+      },
+      focusFirstSelectedDate(e) {
+        const { context: t } = e;
+        t.get("value").length && c(e, t.get("value")[0]);
+      },
+      syncInputElement({ scope: e, computed: t }) {
+        V(() => {
+          m(e).forEach((s, o) => {
+            O(s, t("valueAsString")[o] || "");
+          });
+        });
+      },
+      setFocusedDate(e) {
+        const { event: t } = e, n = Array.isArray(t.value) ? t.value[0] : t.value;
+        c(e, n);
+      },
+      setFocusedValueForView(e) {
+        const { context: t, event: n } = e;
+        c(e, t.get("focusedValue").set({ [t.get("view")]: n.value }));
+      },
+      focusNextMonth(e) {
+        const { context: t } = e;
+        c(e, t.get("focusedValue").add({ months: 1 }));
+      },
+      focusPreviousMonth(e) {
+        const { context: t } = e;
+        c(e, t.get("focusedValue").subtract({ months: 1 }));
+      },
+      setDateValue({ context: e, event: t, prop: n }) {
+        if (!Array.isArray(t.value)) return;
+        const s = t.value.map((o) => E(o, n("min"), n("max")));
+        e.set("value", s);
+      },
+      clearDateValue({ context: e }) {
+        e.set("value", []);
+      },
+      setSelectedDate(e) {
+        const { context: t, event: n } = e, s = Array.from(t.get("value")), o = t.get("activeIndex"), a = s[o], i = I(e, n.value ?? t.get("focusedValue"));
+        s[o] = P(a, i), t.set("value", N(s));
+      },
+      resetSelection(e) {
+        const { context: t, event: n } = e, s = t.get("value")[0], o = I(e, n.value ?? t.get("focusedValue"));
+        t.set("value", [P(s, o)]);
+      },
+      toggleSelectedDate(e) {
+        const { context: t, event: n } = e, s = I(e, n.value ?? t.get("focusedValue")), o = t.get("value"), a = o.findIndex((i) => f(i, s));
+        if (a === -1) {
+          const i = [...o, s];
+          t.set("value", x(i));
+        } else {
+          const i = Array.from(o);
+          i.splice(a, 1), t.set("value", x(i));
+        }
+      },
+      setHoveredDate({ context: e, event: t }) {
+        e.set("hoveredValue", t.value);
+      },
+      clearHoveredDate({ context: e }) {
+        e.set("hoveredValue", null);
+      },
+      selectFocusedDate({ context: e, computed: t }) {
+        const n = Array.from(e.get("value")), s = e.get("activeIndex"), o = n[s], a = e.get("focusedValue").copy();
+        n[s] = P(o, a), e.set("value", N(n));
+        const i = t("valueAsString");
+        e.set("inputValue", i[s]);
+      },
+      focusPreviousDay(e) {
+        const { context: t } = e, n = t.get("focusedValue").subtract({ days: 1 });
+        c(e, n);
+      },
+      focusNextDay(e) {
+        const { context: t } = e, n = t.get("focusedValue").add({ days: 1 });
+        c(e, n);
+      },
+      focusPreviousWeek(e) {
+        const { context: t } = e, n = t.get("focusedValue").subtract({ weeks: 1 });
+        c(e, n);
+      },
+      focusNextWeek(e) {
+        const { context: t } = e, n = t.get("focusedValue").add({ weeks: 1 });
+        c(e, n);
+      },
+      focusNextPage(e) {
+        const { context: t, computed: n, prop: s } = e, o = le(
+          t.get("focusedValue"),
+          t.get("startValue"),
+          n("visibleDuration"),
+          s("locale"),
+          s("min"),
+          s("max")
+        );
+        T(e, o);
+      },
+      focusPreviousPage(e) {
+        const { context: t, computed: n, prop: s } = e, o = ue(
+          t.get("focusedValue"),
+          t.get("startValue"),
+          n("visibleDuration"),
+          s("locale"),
+          s("min"),
+          s("max")
+        );
+        T(e, o);
+      },
+      focusSectionStart(e) {
+        const { context: t } = e;
+        c(e, t.get("startValue").copy());
+      },
+      focusSectionEnd(e) {
+        const { computed: t } = e;
+        c(e, t("endValue").copy());
+      },
+      focusNextSection(e) {
+        const { context: t, event: n, computed: s, prop: o } = e, a = ce(
+          t.get("focusedValue"),
+          t.get("startValue"),
+          n.larger,
+          s("visibleDuration"),
+          o("locale"),
+          o("min"),
+          o("max")
+        );
+        a && T(e, a);
+      },
+      focusPreviousSection(e) {
+        const { context: t, event: n, computed: s, prop: o } = e, a = ie(
+          t.get("focusedValue"),
+          t.get("startValue"),
+          n.larger,
+          s("visibleDuration"),
+          o("locale"),
+          o("min"),
+          o("max")
+        );
+        a && T(e, a);
+      },
+      focusNextYear(e) {
+        const { context: t } = e, n = t.get("focusedValue").add({ years: 1 });
+        c(e, n);
+      },
+      focusPreviousYear(e) {
+        const { context: t } = e, n = t.get("focusedValue").subtract({ years: 1 });
+        c(e, n);
+      },
+      focusNextDecade(e) {
+        const { context: t } = e, n = t.get("focusedValue").add({ years: 10 });
+        c(e, n);
+      },
+      focusPreviousDecade(e) {
+        const { context: t } = e, n = t.get("focusedValue").subtract({ years: 10 });
+        c(e, n);
+      },
+      clearFocusedDate(e) {
+        const { context: t, prop: n } = e, s = t.get("focusedValue").calendar;
+        c(e, b(n("timeZone"), s));
+      },
+      focusPreviousMonthColumn(e) {
+        const { context: t, event: n } = e, s = t.get("focusedValue").subtract({ months: n.columns });
+        c(e, s);
+      },
+      focusNextMonthColumn(e) {
+        const { context: t, event: n } = e, s = t.get("focusedValue").add({ months: n.columns });
+        c(e, s);
+      },
+      focusPreviousYearColumn(e) {
+        const { context: t, event: n } = e, s = t.get("focusedValue").subtract({ years: n.columns });
+        c(e, s);
+      },
+      focusNextYearColumn(e) {
+        const { context: t, event: n } = e, s = t.get("focusedValue").add({ years: n.columns });
+        c(e, s);
+      },
+      focusFirstMonth(e) {
+        var o, a;
+        const { context: t } = e, n = t.get("focusedValue"), s = ((a = (o = n.calendar).getMinimumMonthInYear) == null ? void 0 : a.call(o, n)) ?? 1;
+        c(e, n.set({ month: s }));
+      },
+      focusLastMonth(e) {
+        const { context: t } = e, n = t.get("focusedValue"), s = n.calendar.getMonthsInYear(n);
+        c(e, n.set({ month: s }));
+      },
+      focusFirstYear(e) {
+        const { context: t } = e, n = L(t.get("focusedValue").year), s = t.get("focusedValue").set({ year: n[0] });
+        c(e, s);
+      },
+      focusLastYear(e) {
+        const { context: t } = e, n = L(t.get("focusedValue").year), s = t.get("focusedValue").set({ year: n[n.length - 1] });
+        c(e, s);
+      },
+      setActiveIndex({ context: e, event: t }) {
+        e.set("activeIndex", t.index);
+      },
+      setActiveIndexToEnd({ context: e }) {
+        e.set("activeIndex", 1);
+      },
+      setActiveIndexToStart({ context: e }) {
+        e.set("activeIndex", 0);
+      },
+      focusActiveCell({ scope: e, context: t, event: n }) {
+        n.src !== "input.click" && V(() => {
+          var o;
+          const s = t.get("view");
+          (o = F(e, s)) == null || o.focus({ preventScroll: !0 });
+        });
+      },
+      focusActiveCellIfNeeded({ scope: e, context: t, event: n }) {
+        n.focus && V(() => {
+          var o;
+          const s = t.get("view");
+          (o = F(e, s)) == null || o.focus({ preventScroll: !0 });
+        });
+      },
+      setHoveredValueIfKeyboard({ context: e, event: t, prop: n }) {
+        !t.type.startsWith("TABLE.ARROW") || n("selectionMode") !== "range" || e.get("activeIndex") === 0 || e.set("hoveredValue", e.get("focusedValue").copy());
+      },
+      focusTriggerElement({ scope: e }) {
+        V(() => {
+          var t;
+          (t = D(e)) == null || t.focus({ preventScroll: !0 });
+        });
+      },
+      focusFirstInputElement({ scope: e, event: t }) {
+        t.focus !== !1 && V(() => {
+          const [n] = m(e), s = n ?? D(e);
+          s == null || s.focus({ preventScroll: !0 });
+        });
+      },
+      focusInputElement({ scope: e }) {
+        V(() => {
+          var a;
+          const t = m(e);
+          if (t.length === 0) {
+            (a = D(e)) == null || a.focus({ preventScroll: !0 });
+            return;
+          }
+          const n = t.findLastIndex((i) => i.value !== ""), s = Math.max(n, 0), o = t[s];
+          o == null || o.focus({ preventScroll: !0 }), o == null || o.setSelectionRange(o.value.length, o.value.length);
+        });
+      },
+      syncMonthSelectElement({ scope: e, context: t }) {
+        const n = G(e);
+        O(n, t.get("startValue").month.toString());
+      },
+      syncYearSelectElement({ scope: e, context: t }) {
+        const n = W(e);
+        O(n, t.get("startValue").year.toString());
+      },
+      setInputValue({ context: e, event: t }) {
+        e.get("activeIndex") === t.index && e.set("inputValue", t.value);
+      },
+      syncInputValue({ scope: e, context: t, event: n }) {
+        queueMicrotask(() => {
+          const s = m(e), o = n.index ?? t.get("activeIndex");
+          O(s[o], t.get("inputValue"));
+        });
+      },
+      focusParsedDate(e) {
+        const { event: t, prop: n } = e;
+        if (t.index == null) return;
+        const o = n("parse")(t.value, { locale: n("locale"), timeZone: n("timeZone") });
+        !o || !M(o) || c(e, o);
+      },
+      selectParsedDate({ context: e, event: t, prop: n }) {
+        if (t.index == null) return;
+        let o = n("parse")(t.value, { locale: n("locale"), timeZone: n("timeZone") });
+        if ((!o || !M(o)) && t.value && (o = e.get("focusedValue").copy()), !o) return;
+        o = E(o, n("min"), n("max"));
+        const a = Array.from(e.get("value"));
+        a[t.index] = o, e.set("value", a);
+        const i = C(a, n);
+        e.set("inputValue", i[t.index]);
+      },
+      resetView({ context: e }) {
+        e.set("view", e.initial("view"));
+      },
+      setStartValue({ context: e, computed: t, prop: n }) {
+        const s = e.get("focusedValue");
+        if (!se(s, e.get("startValue"), t("endValue"))) return;
+        const a = k(s, "start", { months: n("numOfMonths") }, n("locale"));
+        e.set("startValue", a);
+      },
+      invokeOnOpen({ prop: e, context: t }) {
+        var n;
+        e("inline") || (n = e("onOpenChange")) == null || n({ open: !0, value: t.get("value") });
+      },
+      invokeOnClose({ prop: e, context: t }) {
+        var n;
+        e("inline") || (n = e("onOpenChange")) == null || n({ open: !1, value: t.get("value") });
+      },
+      invokeOnVisibleRangeChange({ prop: e, context: t, computed: n }) {
+        var s;
+        (s = e("onVisibleRangeChange")) == null || s({
+          view: t.get("view"),
+          visibleRange: n("visibleRange")
+        });
+      },
+      toggleVisibility({ event: e, send: t, prop: n }) {
+        t({ type: n("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE", previousEvent: e });
+      }
+    }
+  }
+}), I = (e, t) => {
+  const { context: n, prop: s } = e, o = n.get("view");
+  let a = typeof t == "number" ? n.get("focusedValue").set({ [o]: t }) : t;
+  return Q((i) => {
+    ee(i, s("minView")) && (a = a.set({ [i]: i === "day" ? 1 : 0 }));
+  }), a;
+}, P = (e, t) => {
+  if (!e || !("hour" in e))
+    return t;
+  const n = "timeZone" in e;
+  let s = t;
+  return "hour" in t || (n ? s = p(y(t), e.timeZone) : s = y(t)), s.set({
+    hour: e.hour,
+    minute: e.minute,
+    second: e.second,
+    millisecond: e.millisecond
+  });
+};
+function c(e, t) {
+  const { context: n, prop: s, computed: o } = e;
+  if (!t) return;
+  const a = I(e, t);
+  if (f(n.get("focusedValue"), a)) return;
+  const u = re(o("visibleDuration"), s("locale"), s("min"), s("max"))({
+    focusedDate: a,
+    startDate: n.get("startValue")
+  });
+  n.set("startValue", u.startDate), n.set("focusedValue", u.focusedDate);
+}
+function T(e, t) {
+  const { context: n } = e;
+  n.set("startValue", t.startDate);
+  const s = n.get("focusedValue");
+  f(s, t.focusedDate) || n.set("focusedValue", t.focusedDate);
+}
+export {
+  Be as machine
+};