@prokodo/ui 0.0.26 → 0.0.28

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useSwitch/useSwitch.js

@@ -1,58 +1,87 @@
-import * as g from "react";
-import y from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useControlled/useControlled.js";
-import H from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
-import R from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/isFocusVisible/isFocusVisible.js";
-function q(b) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+import useControlled from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useControlled/useControlled.js";
+import useForkRef from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
+import isFocusVisible from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/isFocusVisible/isFocusVisible.js";
+function useSwitch(props) {
   const {
-    checked: a,
-    defaultChecked: r,
-    disabled: n,
-    onBlur: u,
-    onChange: l,
-    onFocus: d,
-    onFocusVisible: i,
-    readOnly: k,
-    required: B
-  } = b, [C, F] = y({
-    controlled: a,
-    default: !!r,
+    checked: checkedProp,
+    defaultChecked,
+    disabled,
+    onBlur,
+    onChange,
+    onFocus,
+    onFocusVisible,
+    readOnly,
+    required
+  } = props;
+  const [checked, setCheckedState] = useControlled({
+    controlled: checkedProp,
+    default: Boolean(defaultChecked),
     name: "Switch",
     state: "checked"
-  }), I = (e) => (c) => {
-    var t;
-    c.nativeEvent.defaultPrevented || (F(c.target.checked), l == null || l(c), (t = e.onChange) == null || t.call(e, c));
-  }, [o, f] = g.useState(!1);
-  n && o && f(!1);
-  const s = g.useRef(null), S = (e) => (c) => {
-    var t;
-    s.current || (s.current = c.currentTarget), R(c.target) && (f(!0), i == null || i(c)), d == null || d(c), (t = e.onFocus) == null || t.call(e, c);
-  }, w = (e) => (c) => {
-    var t;
-    R(c.target) || f(!1), u == null || u(c), (t = e.onBlur) == null || t.call(e, c);
-  }, m = H(s);
+  });
+  const createHandleInputChange = /* @__PURE__ */ __name((otherProps) => (event) => {
+    var _a;
+    if (event.nativeEvent.defaultPrevented) {
+      return;
+    }
+    setCheckedState(event.target.checked);
+    onChange == null ? void 0 : onChange(event);
+    (_a = otherProps.onChange) == null ? void 0 : _a.call(otherProps, event);
+  }, "createHandleInputChange");
+  const [focusVisible, setFocusVisible] = React.useState(false);
+  if (disabled && focusVisible) {
+    setFocusVisible(false);
+  }
+  const inputRef = React.useRef(null);
+  const createHandleFocus = /* @__PURE__ */ __name((otherProps) => (event) => {
+    var _a;
+    if (!inputRef.current) {
+      inputRef.current = event.currentTarget;
+    }
+    if (isFocusVisible(event.target)) {
+      setFocusVisible(true);
+      onFocusVisible == null ? void 0 : onFocusVisible(event);
+    }
+    onFocus == null ? void 0 : onFocus(event);
+    (_a = otherProps.onFocus) == null ? void 0 : _a.call(otherProps, event);
+  }, "createHandleFocus");
+  const createHandleBlur = /* @__PURE__ */ __name((otherProps) => (event) => {
+    var _a;
+    if (!isFocusVisible(event.target)) {
+      setFocusVisible(false);
+    }
+    onBlur == null ? void 0 : onBlur(event);
+    (_a = otherProps.onBlur) == null ? void 0 : _a.call(otherProps, event);
+  }, "createHandleBlur");
+  const handleInputRef = useForkRef(inputRef);
+  const getInputProps = /* @__PURE__ */ __name((otherProps = {}) => ({
+    checked: checkedProp,
+    defaultChecked,
+    disabled,
+    readOnly,
+    ref: handleInputRef,
+    required,
+    type: "checkbox",
+    role: "switch",
+    "aria-checked": checkedProp,
+    ...otherProps,
+    onChange: createHandleInputChange(otherProps),
+    onFocus: createHandleFocus(otherProps),
+    onBlur: createHandleBlur(otherProps)
+  }), "getInputProps");
   return {
-    checked: C,
-    disabled: !!n,
-    focusVisible: o,
-    getInputProps: (e = {}) => ({
-      checked: a,
-      defaultChecked: r,
-      disabled: n,
-      readOnly: k,
-      ref: m,
-      required: B,
-      type: "checkbox",
-      role: "switch",
-      "aria-checked": a,
-      ...e,
-      onChange: I(e),
-      onFocus: S(e),
-      onBlur: w(e)
-    }),
-    inputRef: m,
-    readOnly: !!k
+    checked,
+    disabled: Boolean(disabled),
+    focusVisible,
+    getInputProps,
+    inputRef: handleInputRef,
+    readOnly: Boolean(readOnly)
   };
 }
+__name(useSwitch, "useSwitch");
 export {
-  q as useSwitch
+  useSwitch
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useTransition/TransitionContext.js

@@ -1,6 +1,8 @@
-import * as t from "react";
-const o = /* @__PURE__ */ t.createContext(null);
-process.env.NODE_ENV !== "production" && (o.displayName = "TransitionContext");
+import * as React from "react";
+const TransitionContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  TransitionContext.displayName = "TransitionContext";
+}
 export {
-  o as TransitionContext
+  TransitionContext
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useTransition/useTransitionTrigger.js

@@ -1,27 +1,55 @@
-import * as t from "react";
-function x(e) {
-  const [f, r] = t.useState(!0), i = t.useRef(!1), n = t.useRef(0), [l, a] = t.useState(!1), o = t.useRef(e);
-  t.useEffect(() => {
-    !e && // checking registeredTransitions.current instead of hasTransition to avoid this effect re-firing whenever hasTransition changes
-    n.current > 0 && // prevents waiting for a pending transition right after mounting
-    o.current !== e && (i.current = !0, r(!1)), o.current = e;
-  }, [e]);
-  const c = t.useCallback(() => {
-    i.current = !1, r(!0);
-  }, []), u = t.useCallback(() => (n.current += 1, a(!0), () => {
-    n.current -= 1, n.current === 0 && a(!1);
-  }), []);
-  let s;
-  return l ? e ? s = !1 : s = !i.current && f : s = !e, {
-    contextValue: t.useMemo(() => ({
-      requestedEnter: e,
-      onExited: c,
-      registerTransition: u,
-      hasExited: s
-    }), [c, e, u, s]),
-    hasExited: s
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+function useTransitionTrigger(requestEnter) {
+  const [exitTransitionFinished, setExitTransitionFinished] = React.useState(true);
+  const hasPendingExitTransition = React.useRef(false);
+  const registeredTransitions = React.useRef(0);
+  const [hasTransition, setHasTransition] = React.useState(false);
+  const previousRequestEnter = React.useRef(requestEnter);
+  React.useEffect(() => {
+    if (!requestEnter && // checking registeredTransitions.current instead of hasTransition to avoid this effect re-firing whenever hasTransition changes
+    registeredTransitions.current > 0 && // prevents waiting for a pending transition right after mounting
+    previousRequestEnter.current !== requestEnter) {
+      hasPendingExitTransition.current = true;
+      setExitTransitionFinished(false);
+    }
+    previousRequestEnter.current = requestEnter;
+  }, [requestEnter]);
+  const handleExited = React.useCallback(() => {
+    hasPendingExitTransition.current = false;
+    setExitTransitionFinished(true);
+  }, []);
+  const registerTransition = React.useCallback(() => {
+    registeredTransitions.current += 1;
+    setHasTransition(true);
+    return () => {
+      registeredTransitions.current -= 1;
+      if (registeredTransitions.current === 0) {
+        setHasTransition(false);
+      }
+    };
+  }, []);
+  let hasExited;
+  if (!hasTransition) {
+    hasExited = !requestEnter;
+  } else if (requestEnter) {
+    hasExited = false;
+  } else {
+    hasExited = !hasPendingExitTransition.current && exitTransitionFinished;
+  }
+  const contextValue = React.useMemo(() => ({
+    requestedEnter: requestEnter,
+    onExited: handleExited,
+    registerTransition,
+    hasExited
+  }), [handleExited, requestEnter, registerTransition, hasExited]);
+  return {
+    contextValue,
+    hasExited
   };
 }
+__name(useTransitionTrigger, "useTransitionTrigger");
 export {
-  x as useTransitionTrigger
+  useTransitionTrigger
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/ClassNameConfigurator.js

@@ -1,14 +1,25 @@
-import * as e from "react";
-const r = {
-  disableDefaultClasses: !1
-}, t = /* @__PURE__ */ e.createContext(r);
-process.env.NODE_ENV !== "production" && (t.displayName = "ClassNameConfiguratorContext");
-function n(s) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+const defaultContextValue = {
+  disableDefaultClasses: false
+};
+const ClassNameConfiguratorContext = /* @__PURE__ */ React.createContext(defaultContextValue);
+if (process.env.NODE_ENV !== "production") {
+  ClassNameConfiguratorContext.displayName = "ClassNameConfiguratorContext";
+}
+function useClassNamesOverride(generateUtilityClass) {
   const {
-    disableDefaultClasses: a
-  } = e.useContext(t);
-  return (o) => a ? "" : s(o);
+    disableDefaultClasses
+  } = React.useContext(ClassNameConfiguratorContext);
+  return (slot) => {
+    if (disableDefaultClasses) {
+      return "";
+    }
+    return generateUtilityClass(slot);
+  };
 }
+__name(useClassNamesOverride, "useClassNamesOverride");
 export {
-  n as useClassNamesOverride
+  useClassNamesOverride
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/areArraysEqual.js

@@ -1,6 +1,9 @@
-function u(t, l, r = (e, n) => e === n) {
-  return t.length === l.length && t.every((e, n) => r(e, l[n]));
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function areArraysEqual(array1, array2, itemComparer = (a, b) => a === b) {
+  return array1.length === array2.length && array1.every((value, index) => itemComparer(value, array2[index]));
 }
+__name(areArraysEqual, "areArraysEqual");
 export {
-  u as areArraysEqual
+  areArraysEqual
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/combineHooksSlotProps.js

@@ -1,15 +1,19 @@
-function u(n, r) {
-  return function(o = {}) {
-    const t = {
-      ...o,
-      ...n(o)
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function combineHooksSlotProps(getFirstProps, getSecondProps) {
+  return /* @__PURE__ */ __name(function getCombinedProps(external = {}) {
+    const firstResult = {
+      ...external,
+      ...getFirstProps(external)
     };
-    return {
-      ...t,
-      ...r(t)
+    const result = {
+      ...firstResult,
+      ...getSecondProps(firstResult)
     };
-  };
+    return result;
+  }, "getCombinedProps");
 }
+__name(combineHooksSlotProps, "combineHooksSlotProps");
 export {
-  u as combineHooksSlotProps
+  combineHooksSlotProps
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/isHostComponent.js

@@ -1,6 +1,9 @@
-function n(t) {
-  return typeof t == "string";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function isHostComponent(element) {
+  return typeof element === "string";
 }
+__name(isHostComponent, "isHostComponent");
 export {
-  n as isHostComponent
+  isHostComponent
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/resolveComponentProps.js

@@ -1,6 +1,12 @@
-function f(e, r, t) {
-  return typeof e == "function" ? e(r, t) : e;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function resolveComponentProps(componentProps, ownerState, slotState) {
+  if (typeof componentProps === "function") {
+    return componentProps(ownerState, slotState);
+  }
+  return componentProps;
 }
+__name(resolveComponentProps, "resolveComponentProps");
 export {
-  f as resolveComponentProps
+  resolveComponentProps
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/useControllableReducer.js

@@ -1,70 +1,101 @@
-import * as c from "react";
-function g(u, e) {
-  return u === e;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+function areEqual(a, b) {
+  return a === b;
 }
-const S = {}, R = () => {
-};
-function m(u, e) {
-  const l = {
-    ...u
+__name(areEqual, "areEqual");
+const EMPTY_OBJECT = {};
+const NOOP = /* @__PURE__ */ __name(() => {
+}, "NOOP");
+function getControlledState(internalState, controlledProps) {
+  const augmentedState = {
+    ...internalState
   };
-  return Object.keys(e).forEach((o) => {
-    e[o] !== void 0 && (l[o] = e[o]);
-  }), l;
+  Object.keys(controlledProps).forEach((key) => {
+    if (controlledProps[key] !== void 0) {
+      augmentedState[key] = controlledProps[key];
+    }
+  });
+  return augmentedState;
 }
-function x(u) {
+__name(getControlledState, "getControlledState");
+function useStateChangeDetection(parameters) {
   const {
-    nextState: e,
-    initialState: l,
-    stateComparers: o,
-    onStateChange: t,
-    controlledProps: p,
-    lastActionRef: s
-  } = u, f = c.useRef(l);
-  c.useEffect(() => {
-    if (s.current === null)
+    nextState,
+    initialState,
+    stateComparers,
+    onStateChange,
+    controlledProps,
+    lastActionRef
+  } = parameters;
+  const internalPreviousStateRef = React.useRef(initialState);
+  React.useEffect(() => {
+    if (lastActionRef.current === null) {
       return;
-    const a = m(f.current, p);
-    Object.keys(e).forEach((i) => {
-      const C = o[i] ?? g, r = e[i], d = a[i];
-      (d == null && r != null || d != null && r == null || d != null && r != null && !C(r, d)) && (t == null || t(s.current.event ?? null, i, r, s.current.type ?? "", e));
-    }), f.current = e, s.current = null;
-  }, [f, e, s, t, o, p]);
-}
-function $(u) {
-  const e = c.useRef(null), {
-    reducer: l,
-    initialState: o,
-    controlledProps: t = S,
-    stateComparers: p = S,
-    onStateChange: s = R,
-    actionContext: f,
-    componentName: a = ""
-  } = u, i = c.useRef(t);
-  process.env.NODE_ENV !== "production" && c.useEffect(() => {
-    Object.keys(t).forEach((n) => {
-      i.current[n] !== void 0 && t[n] === void 0 && console.error(`useControllableReducer: ${a ? `The ${a} component` : "A component"} is changing a controlled prop to be uncontrolled: ${n}`), i.current[n] === void 0 && t[n] !== void 0 && console.error(`useControllableReducer: ${a ? `The ${a} component` : "A component"} is changing an uncontrolled prop to be controlled: ${n}`);
+    }
+    const previousState = getControlledState(internalPreviousStateRef.current, controlledProps);
+    Object.keys(nextState).forEach((key) => {
+      const stateComparer = stateComparers[key] ?? areEqual;
+      const nextStateItem = nextState[key];
+      const previousStateItem = previousState[key];
+      if (previousStateItem == null && nextStateItem != null || previousStateItem != null && nextStateItem == null || previousStateItem != null && nextStateItem != null && !stateComparer(nextStateItem, previousStateItem)) {
+        onStateChange == null ? void 0 : onStateChange(lastActionRef.current.event ?? null, key, nextStateItem, lastActionRef.current.type ?? "", nextState);
+      }
     });
-  }, [t, a]);
-  const C = c.useCallback((n, h) => {
-    e.current = h;
-    const E = m(n, t);
-    return l(E, h);
-  }, [t, l]), [r, d] = c.useReducer(C, o), b = c.useCallback((n) => {
-    d({
-      ...n,
-      context: f
+    internalPreviousStateRef.current = nextState;
+    lastActionRef.current = null;
+  }, [internalPreviousStateRef, nextState, lastActionRef, onStateChange, stateComparers, controlledProps]);
+}
+__name(useStateChangeDetection, "useStateChangeDetection");
+function useControllableReducer(parameters) {
+  const lastActionRef = React.useRef(null);
+  const {
+    reducer,
+    initialState,
+    controlledProps = EMPTY_OBJECT,
+    stateComparers = EMPTY_OBJECT,
+    onStateChange = NOOP,
+    actionContext,
+    componentName = ""
+  } = parameters;
+  const controlledPropsRef = React.useRef(controlledProps);
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      Object.keys(controlledProps).forEach((key) => {
+        if (controlledPropsRef.current[key] !== void 0 && controlledProps[key] === void 0) {
+          console.error(`useControllableReducer: ${componentName ? `The ${componentName} component` : "A component"} is changing a controlled prop to be uncontrolled: ${key}`);
+        }
+        if (controlledPropsRef.current[key] === void 0 && controlledProps[key] !== void 0) {
+          console.error(`useControllableReducer: ${componentName ? `The ${componentName} component` : "A component"} is changing an uncontrolled prop to be controlled: ${key}`);
+        }
+      });
+    }, [controlledProps, componentName]);
+  }
+  const reducerWithControlledState = React.useCallback((state, action) => {
+    lastActionRef.current = action;
+    const controlledState = getControlledState(state, controlledProps);
+    const newState = reducer(controlledState, action);
+    return newState;
+  }, [controlledProps, reducer]);
+  const [nextState, dispatch] = React.useReducer(reducerWithControlledState, initialState);
+  const dispatchWithContext = React.useCallback((action) => {
+    dispatch({
+      ...action,
+      context: actionContext
     });
-  }, [f]);
-  return x({
-    nextState: r,
-    initialState: o,
-    stateComparers: p ?? S,
-    onStateChange: s ?? R,
-    controlledProps: t,
-    lastActionRef: e
-  }), [m(r, t), b];
+  }, [actionContext]);
+  useStateChangeDetection({
+    nextState,
+    initialState,
+    stateComparers: stateComparers ?? EMPTY_OBJECT,
+    onStateChange: onStateChange ?? NOOP,
+    controlledProps,
+    lastActionRef
+  });
+  return [getControlledState(nextState, controlledProps), dispatchWithContext];
 }
+__name(useControllableReducer, "useControllableReducer");
 export {
-  $ as useControllableReducer
+  useControllableReducer
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/useRootElementName.js

@@ -1,17 +1,25 @@
-import * as m from "react";
-function p(n) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+function useRootElementName(parameters) {
   const {
-    rootElementName: e = "",
-    componentName: t
-  } = n, [o, r] = m.useState(e.toUpperCase());
-  process.env.NODE_ENV !== "production" && m.useEffect(() => {
-    e && o !== e.toUpperCase() && console.error(`useRootElementName: the \`rootElementName\` prop of ${t ? `the ${t} component` : "a component"} expected the '${e}' element, but a '${o.toLowerCase()}' was rendered instead`, "This may cause hydration issues in an SSR context, for example in a Next.js app");
-  }, [e, o, t]);
-  const s = m.useCallback((a) => {
-    r((a == null ? void 0 : a.tagName) ?? "");
+    rootElementName: rootElementNameProp = "",
+    componentName
+  } = parameters;
+  const [rootElementName, setRootElementName] = React.useState(rootElementNameProp.toUpperCase());
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      if (rootElementNameProp && rootElementName !== rootElementNameProp.toUpperCase()) {
+        console.error(`useRootElementName: the \`rootElementName\` prop of ${componentName ? `the ${componentName} component` : "a component"} expected the '${rootElementNameProp}' element, but a '${rootElementName.toLowerCase()}' was rendered instead`, "This may cause hydration issues in an SSR context, for example in a Next.js app");
+      }
+    }, [rootElementNameProp, rootElementName, componentName]);
+  }
+  const updateRootElementName = React.useCallback((instance) => {
+    setRootElementName((instance == null ? void 0 : instance.tagName) ?? "");
   }, []);
-  return [o, s];
+  return [rootElementName, updateRootElementName];
 }
+__name(useRootElementName, "useRootElementName");
 export {
-  p as useRootElementName
+  useRootElementName
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/utils/useTextNavigation.js

@@ -1,17 +1,28 @@
-import * as n from "react";
-const c = 500;
-function o(i) {
-  const a = n.useRef({
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+const TEXT_NAVIGATION_RESET_TIMEOUT = 500;
+function useTextNavigation(callback) {
+  const textCriteriaRef = React.useRef({
     searchString: "",
     lastTime: null
   });
-  return n.useCallback((t) => {
-    if (t.key.length === 1 && t.key !== " ") {
-      const e = a.current, r = t.key.toLowerCase(), s = performance.now();
-      e.searchString.length > 0 && e.lastTime && s - e.lastTime > c ? e.searchString = r : (e.searchString.length !== 1 || r !== e.searchString) && (e.searchString += r), e.lastTime = s, i(e.searchString, t);
+  return React.useCallback((event) => {
+    if (event.key.length === 1 && event.key !== " ") {
+      const textCriteria = textCriteriaRef.current;
+      const lowerKey = event.key.toLowerCase();
+      const currentTime = performance.now();
+      if (textCriteria.searchString.length > 0 && textCriteria.lastTime && currentTime - textCriteria.lastTime > TEXT_NAVIGATION_RESET_TIMEOUT) {
+        textCriteria.searchString = lowerKey;
+      } else if (textCriteria.searchString.length !== 1 || lowerKey !== textCriteria.searchString) {
+        textCriteria.searchString += lowerKey;
+      }
+      textCriteria.lastTime = currentTime;
+      callback(textCriteria.searchString, event);
     }
-  }, [i]);
+  }, [callback]);
 }
+__name(useTextNavigation, "useTextNavigation");
 export {
-  o as useTextNavigation
+  useTextNavigation
 };

package/dist/node_modules/.pnpm/@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/HTMLElementType/HTMLElementType.js

@@ -1,9 +1,20 @@
-function p(r, n, l, t, u) {
-  if (process.env.NODE_ENV === "production")
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function HTMLElementType(props, propName, componentName, location, propFullName) {
+  if (process.env.NODE_ENV === "production") {
     return null;
-  const e = r[n], o = u || n;
-  return e == null ? null : e && e.nodeType !== 1 ? new Error(`Invalid ${t} \`${o}\` supplied to \`${l}\`. Expected an HTMLElement.`) : null;
+  }
+  const propValue = props[propName];
+  const safePropName = propFullName || propName;
+  if (propValue == null) {
+    return null;
+  }
+  if (propValue && propValue.nodeType !== 1) {
+    return new Error(`Invalid ${location} \`${safePropName}\` supplied to \`${componentName}\`. Expected an HTMLElement.`);
+  }
+  return null;
 }
+__name(HTMLElementType, "HTMLElementType");
 export {
-  p as default
+  HTMLElementType as default
 };

package/dist/node_modules/.pnpm/@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/appendOwnerState/appendOwnerState.js

@@ -1,13 +1,19 @@
-import a from "../isHostComponent/isHostComponent.js";
-function f(t, n, e) {
-  return t === void 0 || a(t) ? n : {
-    ...n,
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import isHostComponent from "../isHostComponent/isHostComponent.js";
+function appendOwnerState(elementType, otherProps, ownerState) {
+  if (elementType === void 0 || isHostComponent(elementType)) {
+    return otherProps;
+  }
+  return {
+    ...otherProps,
     ownerState: {
-      ...n.ownerState,
-      ...e
+      ...otherProps.ownerState,
+      ...ownerState
     }
   };
 }
+__name(appendOwnerState, "appendOwnerState");
 export {
-  f as default
+  appendOwnerState as default
 };