https://kyn-care.com/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-WKJRI6UZ.js?v=9ce4103e

17// node_modules/@radix-ui/primitive/dist/index.mjs
18function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
19  return function handleEvent(event) {
20    originalEventHandler == null ? void 0 : originalEventHandler(event);
21    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
22      return ourEventHandler == null ? void 0 : ourEventHandler(event);
23    }
24  };
25}
26

27// node_modules/@radix-ui/react-context/dist/index.mjs
28var React = __toESM(require_react(), 1);
29var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
30function createContextScope(scopeName, createContextScopeDeps = []) {
31  let defaultContexts = [];
32  function createContext3(rootComponentName, defaultContext) {
33    const BaseContext = React.createContext(defaultContext);
34    const index = defaultContexts.length;
35    defaultContexts = [...defaultContexts, defaultContext];
36    const Provider = (props) => {
37      var _a;
38      const { scope, children, ...context } = props;
39      const Context = ((_a = scope == null ? void 0 : scope[scopeName]) == null ? void 0 : _a[index]) || BaseContext;
40      const value = React.useMemo(() => context, Object.values(context));
41      return (0, import_jsx_runtime.jsx)(Context.Provider, { value, children });
42    };
43    Provider.displayName = rootComponentName + "Provider";
44    function useContext2(consumerName, scope) {
45      var _a;
46      const Context = ((_a = scope == null ? void 0 : scope[scopeName]) == null ? void 0 : _a[index]) || BaseContext;
47      const context = React.useContext(Context);
48      if (context) return context;
49      if (defaultContext !== void 0) return defaultContext;
50      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
51    }
52    return [Provider, useContext2];
53  }
54  const createScope = () => {
55    const scopeContexts = defaultContexts.map((defaultContext) => {
56      return React.createContext(defaultContext);
57    });
58    return function useScope(scope) {
59      const contexts = (scope == null ? void 0 : scope[scopeName]) || scopeContexts;
60      return React.useMemo(
61        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
62        [scope, contexts]
63      );
64    };
65  };
66  createScope.scopeName = scopeName;
67  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
68}
69function composeContextScopes(...scopes) {
70  const baseScope = scopes[0];
71  if (scopes.length === 1) return baseScope;
72  const createScope = () => {
73    const scopeHooks = scopes.map((createScope2) => ({
74      useScope: createScope2(),
75      scopeName: createScope2.scopeName
76    }));
77    return function useComposedScopes(overrideScopes) {
78      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
79        const scopeProps = useScope(overrideScopes);
80        const currentScope = scopeProps[`__scope${scopeName}`];
81        return { ...nextScopes2, ...currentScope };
82      }, {});
83      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
84    };
85  };
86  createScope.scopeName = baseScope.scopeName;
87  return createScope;
88}
89

90// node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs
91var React2 = __toESM(require_react(), 1);
92function useCallbackRef(callback) {
93  const callbackRef = React2.useRef(callback);
94  React2.useEffect(() => {
95    callbackRef.current = callback;
96  });
97  return React2.useMemo(() => (...args) => {
98    var _a;
99    return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
100  }, []);
101}
102

103// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
104var React3 = __toESM(require_react(), 1);
105function useControllableState({
106  prop,
107  defaultProp,
108  onChange = () => {
109  }
110}) {
111  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });
112  const isControlled = prop !== void 0;
113  const value = isControlled ? prop : uncontrolledProp;
114  const handleChange = useCallbackRef(onChange);
115  const setValue = React3.useCallback(
116    (nextValue) => {
117      if (isControlled) {
118        const setter = nextValue;
119        const value2 = typeof nextValue === "function" ? setter(prop) : nextValue;
120        if (value2 !== prop) handleChange(value2);
121      } else {
122        setUncontrolledProp(nextValue);
123      }
124    },
125    [isControlled, prop, setUncontrolledProp, handleChange]
126  );
127  return [value, setValue];
128}
129function useUncontrolledState({
130  defaultProp,
131  onChange
132}) {
133  const uncontrolledState = React3.useState(defaultProp);
134  const [value] = uncontrolledState;
135  const prevValueRef = React3.useRef(value);
136  const handleChange = useCallbackRef(onChange);
137  React3.useEffect(() => {
138    if (prevValueRef.current !== value) {
139      handleChange(value);
140      prevValueRef.current = value;
141    }
142  }, [value, prevValueRef, handleChange]);
143  return uncontrolledState;
144}
145

146// node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
147var React4 = __toESM(require_react(), 1);
148var useLayoutEffect2 = Boolean(globalThis == null ? void 0 : globalThis.document) ? React4.useLayoutEffect : () => {
149};
150

151// node_modules/@radix-ui/react-primitive/dist/index.mjs
152var React5 = __toESM(require_react(), 1);
153var ReactDOM = __toESM(require_react_dom(), 1);
154var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
155var NODES = [
156  "a",
157  "button",
158  "div",
159  "form",
160  "h2",
161  "h3",
162  "img",
163  "input",
164  "label",
165  "li",
166  "nav",
167  "ol",
168  "p",
169  "span",
170  "svg",
171  "ul"
172];
173var Primitive = NODES.reduce((primitive, node) => {
174  const Node = React5.forwardRef((props, forwardedRef) => {
175    const { asChild, ...primitiveProps } = props;
176    const Comp = asChild ? Slot : node;
177    if (typeof window !== "undefined") {
178      window[Symbol.for("radix-ui")] = true;
179    }
180    return (0, import_jsx_runtime2.jsx)(Comp, { ...primitiveProps, ref: forwardedRef });
181  });
182  Node.displayName = `Primitive.${node}`;
183  return { ...primitive, [node]: Node };
184}, {});
185function dispatchDiscreteCustomEvent(target, event) {
186  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));
187}
188
189export {
190  composeEventHandlers,
191  createContextScope,
192  useCallbackRef,
193  useControllableState,
194  useLayoutEffect2,
195  Primitive,
196  dispatchDiscreteCustomEvent
197};
198//# sourceMappingURL=chunk-WKJRI6UZ.js.map