@vuer-ai/vuer-uikit 0.0.121 → 0.1.0

package/dist/{chunk-B6CIRZI4.cjs → chunk-BZI74LKX.cjs}

@@ -29,6 +29,7 @@ var badgeVariants = classVarianceAuthority.cva(
     variants: {
       variant: {
         default: "bg-brand-primary",
+        outline: "text-text-primary bg-transparent border border-bg-tertiary",
         secondary: "bg-bg-secondary text-text-primary",
         destructive: "bg-danger-primary",
         success: "bg-accent-success",

package/dist/{chunk-KWSH253U.cjs → chunk-CMO3SLOU.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
-var chunkQF3JWGWX_cjs = require('./chunk-QF3JWGWX.cjs');
+var chunk2KBNQ5PY_cjs = require('./chunk-2KBNQ5PY.cjs');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
 var QuaternionInput = react.forwardRef(function QuaternionInput2({ value, onValuesChange, ...props }, ref) {
   return /* @__PURE__ */ jsxRuntime.jsx(
-    chunkQF3JWGWX_cjs.VectorInput,
+    chunk2KBNQ5PY_cjs.VectorInput,
     {
       ref,
       value,

package/dist/{chunk-HGN7J4CP.mjs → chunk-D2LUQKPM.mjs}

@@ -30,6 +30,8 @@ var InputNumbers = forwardRef(function InputNumbers2({
   onValuesChange,
   prefix,
   suffix,
+  disabledItems,
+  onSuffixBatchAction,
   step = 0.1,
   min,
   max,
@@ -50,6 +52,9 @@ var InputNumbers = forwardRef(function InputNumbers2({
   const dragStart = useRef({ x: 0, y: 0 });
   const initialDragStart = useRef({ x: 0, y: 0 });
   const accumulatedDelta = useRef(0);
+  const isSuffixDrag = useRef(false);
+  const lastMouseMoveTime = useRef(0);
+  const accumulatedValues = useRef(value);
   const applyConstraints = useCallback(
     (numValue, index) => {
       const currentMin = Array.isArray(min) ? min[index] : min;
@@ -72,28 +77,41 @@ var InputNumbers = forwardRef(function InputNumbers2({
     };
     document.addEventListener("click", stopClick2, true);
   }, []);
-  const handleMouseDown = useCallback((e) => {
-    if (e.button !== 0) return;
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragging(true);
-    setCursorState("dragging-y");
-    dragStart.current = { x: e.clientX, y: e.clientY };
-    initialDragStart.current = { x: e.clientX, y: e.clientY };
-    accumulatedDelta.current = 0;
-    inputChange.current = false;
-    dragDirection.current = "none";
-    selectRange.current[0] = getHoverElementAndIndex(
-      document.elementFromPoint(e.clientX, e.clientY),
-      inputs.current
-    );
-  }, []);
+  const handleMouseDown = useCallback(
+    (e) => {
+      if (e.button !== 0) return;
+      e.preventDefault();
+      e.stopPropagation();
+      const target = e.target;
+      const suffixElement = target.closest('[data-side="right"]');
+      isSuffixDrag.current = !!suffixElement;
+      setIsDragging(true);
+      setCursorState("dragging-y");
+      dragStart.current = { x: e.clientX, y: e.clientY };
+      initialDragStart.current = { x: e.clientX, y: e.clientY };
+      accumulatedDelta.current = 0;
+      inputChange.current = false;
+      dragDirection.current = "none";
+      lastMouseMoveTime.current = Date.now();
+      accumulatedValues.current = [...value];
+      selectRange.current[0] = getHoverElementAndIndex(
+        document.elementFromPoint(e.clientX, e.clientY),
+        inputs.current
+      );
+    },
+    [value]
+  );
   const handleMouseMove = useCallback(
     (e) => {
       if (!isDragging) return;
       e.preventDefault();
       e.stopPropagation();
       const deltaX = e.clientX - dragStart.current.x;
+      const now = Date.now();
+      const timeDelta = Math.max(1, now - lastMouseMoveTime.current);
+      lastMouseMoveTime.current = now;
+      const velocity = Math.abs(deltaX) / timeDelta;
+      const velocityMultiplier = Math.max(0.5, Math.min(3, velocity * 2));
       const totalDeltaX = e.clientX - initialDragStart.current.x;
       const totalDeltaY = e.clientY - initialDragStart.current.y;
       if (dragDirection.current === "none") {
@@ -104,19 +122,19 @@ var InputNumbers = forwardRef(function InputNumbers2({
             input?.blur();
           });
         }
-      } else if (dragDirection.current === "y" && Math.abs(totalDeltaX) > 5) {
+      } else if (dragDirection.current === "y" && Math.abs(totalDeltaX) > 5 && !isSuffixDrag.current) {
         dragDirection.current = "x";
         setCursorState("dragging-x");
       }
-      if (dragDirection.current === "x") {
-        accumulatedDelta.current += deltaX / 2;
+      if (dragDirection.current === "x" && !isSuffixDrag.current) {
+        accumulatedDelta.current += deltaX / 2 * velocityMultiplier;
         dragStart.current = { x: e.clientX, y: e.clientY };
         if (selectRange.current[1] === null) {
           selectRange.current[1] = selectRange.current[0];
         }
         if (Math.abs(accumulatedDelta.current) >= (inputChange.current ? 1 : 5)) {
           const multiplyStep = e.shiftKey ? 5 : e.altKey ? 1 / 5 : 1;
-          const newValue = value.map((v, i) => {
+          const newValues = accumulatedValues.current.map((v, i) => {
             const [first, last] = selectRange.current;
             if (first === null || last === null) {
               return v;
@@ -131,7 +149,8 @@ var InputNumbers = forwardRef(function InputNumbers2({
               return v;
             }
           });
-          onValuesChange?.(newValue);
+          accumulatedValues.current = newValues;
+          onValuesChange?.(newValues);
           accumulatedDelta.current = 0;
           inputChange.current = true;
         }
@@ -149,17 +168,28 @@ var InputNumbers = forwardRef(function InputNumbers2({
         stopClick();
       }
     },
-    [isDragging, value, onValuesChange, step, min, max, stopClick, applyConstraints]
+    [isDragging, onValuesChange, step, min, max, stopClick, applyConstraints]
   );
   const handleMouseUp = useCallback(() => {
     if (!isDragging) return;
+    if (isSuffixDrag.current && onSuffixBatchAction) {
+      const [first, last] = selectRange.current;
+      if (first !== null) {
+        const actualLast = last === null || last === first ? first : last;
+        const minIndex = Math.min(first, actualLast);
+        const maxIndex = Math.max(first, actualLast);
+        const indices = Array.from({ length: maxIndex - minIndex + 1 }, (_, i) => minIndex + i);
+        onSuffixBatchAction(indices);
+      }
+    }
     setIsDragging(false);
     setCursorState("default");
     selectRange.current = [null, null];
     inputChange.current = false;
     dragDirection.current = "none";
+    isSuffixDrag.current = false;
     changeElementsHoverState(inputs.current, selectRange.current, "none");
-  }, [isDragging]);
+  }, [isDragging, onSuffixBatchAction]);
   React.useEffect(() => {
     if (isDragging) {
       const handleGlobalMouseMove = (e) => {
@@ -260,73 +290,82 @@ var InputNumbers = forwardRef(function InputNumbers2({
         "data-[hover=y]:cursor-ns-resize"
       ]),
       style: useGrid ? gridStyles : void 0,
-      children: value.map((item, index) => /* @__PURE__ */ jsxs(
-        InputRoot,
-        {
-          ref: (r) => {
-            inputs.current.set(index.toString(), r);
-            return () => {
-              inputs.current.delete(index.toString());
-            };
-          },
-          size,
-          side,
-          type: "number",
-          step: Array.isArray(step) ? step[index] ?? 0.1 : step,
-          value: item,
-          onClick: () => {
-            inputs.current.get(index.toString())?.focus();
-          },
-          onChange: valueChangeHandler(index),
-          onKeyDown: handleKeyDown(index),
-          "data-hover": "none",
-          className: cn([
-            "group/number-input",
-            "cursor-text",
-            cursorState === "dragging-x" && [
-              "hover:!bg-bg-secondary",
-              "data-[hover=x]:hover:!bg-bg-tertiary"
-            ],
-            "data-[hover=down]:bg-bg-tertiary",
-            "data-[hover=x]:bg-bg-tertiary",
-            "data-[hover=y]:bg-bg-tertiary",
-            "data-[hover=x]:cursor-col-resize",
-            "data-[hover=y]:cursor-ns-resize"
-          ]),
-          inputClassName: cn([
-            "cursor-text",
-            "group-data-[hover=x]/number-input:cursor-col-resize",
-            "group-data-[hover=y]/number-input:cursor-ns-resize"
-          ]),
-          children: [
-            prefix?.[index] && /* @__PURE__ */ jsx(
-              InputSlot,
-              {
-                side: "left",
-                className: cn(
-                  "cursor-text",
-                  "group-data-[hover=x]/number-input:cursor-col-resize",
-                  "group-data-[hover=y]/number-input:cursor-ns-resize"
-                ),
-                children: prefix[index]
+      children: (Array.isArray(value) ? value : []).map((item, index) => {
+        const isDisabled = disabledItems?.[index] ?? false;
+        return /* @__PURE__ */ jsxs(
+          InputRoot,
+          {
+            ref: (r) => {
+              inputs.current.set(index.toString(), r);
+              return () => {
+                inputs.current.delete(index.toString());
+              };
+            },
+            size,
+            side,
+            type: "number",
+            step: Array.isArray(step) ? step[index] ?? 0.1 : step,
+            value: item,
+            disabled: isDisabled,
+            onClick: () => {
+              if (!isDisabled) {
+                inputs.current.get(index.toString())?.focus();
               }
-            ),
-            suffix?.[index] && /* @__PURE__ */ jsx(
-              InputSlot,
-              {
-                side: "right",
-                className: cn(
-                  "cursor-text",
-                  "group-data-[hover=x]/number-input:cursor-col-resize",
-                  "group-data-[hover=y]/number-input:cursor-ns-resize"
-                ),
-                children: suffix[index]
-              }
-            )
-          ]
-        },
-        index
-      ))
+            },
+            onChange: valueChangeHandler(index),
+            onKeyDown: handleKeyDown(index),
+            "data-hover": "none",
+            "data-input-index": index,
+            className: cn([
+              "group/number-input",
+              "cursor-text",
+              cursorState === "dragging-x" && [
+                "hover:!bg-bg-secondary",
+                "data-[hover=x]:hover:!bg-bg-tertiary"
+              ],
+              "data-[hover=down]:bg-bg-tertiary",
+              "data-[hover=x]:bg-bg-tertiary",
+              "data-[hover=y]:bg-bg-tertiary",
+              "data-[hover=x]:cursor-col-resize",
+              "data-[hover=y]:cursor-ns-resize",
+              isDisabled && "cursor-not-allowed opacity-50"
+            ]),
+            inputClassName: cn([
+              "cursor-text",
+              "group-data-[hover=x]/number-input:cursor-col-resize",
+              "group-data-[hover=y]/number-input:cursor-ns-resize",
+              isDisabled && "cursor-not-allowed"
+            ]),
+            children: [
+              prefix?.[index] && /* @__PURE__ */ jsx(
+                InputSlot,
+                {
+                  side: "left",
+                  className: cn(
+                    "cursor-text",
+                    "group-data-[hover=x]/number-input:cursor-col-resize",
+                    "group-data-[hover=y]/number-input:cursor-ns-resize"
+                  ),
+                  children: prefix[index]
+                }
+              ),
+              suffix?.[index] && /* @__PURE__ */ jsx(
+                InputSlot,
+                {
+                  side: "right",
+                  className: cn(
+                    "cursor-none",
+                    "group-data-[hover=x]/number-input:cursor-col-resize",
+                    "group-data-[hover=y]/number-input:cursor-ns-resize"
+                  ),
+                  children: suffix[index]
+                }
+              )
+            ]
+          },
+          index
+        );
+      })
     }
   );
 });

package/dist/chunk-DF7WIFZK.cjs

@@ -0,0 +1,316 @@
+'use strict';
+
+var chunkP6DICGAV_cjs = require('./chunk-P6DICGAV.cjs');
+var chunk6LTCLQH3_cjs = require('./chunk-6LTCLQH3.cjs');
+var react = require('react');
+var reactDom = require('react-dom');
+var jsxRuntime = require('react/jsx-runtime');
+
+var SPRING_CONFIG = {
+  stiffness: 0.15,
+  // How snappy (higher = faster)
+  damping: 0.75};
+var SQUISH_CONFIG = {
+  maxSquish: 0.15,
+  // Maximum squish amount (0.15 = 15% squish)
+  velocityScale: 8e-3,
+  // How much velocity affects squish
+  recovery: 0.15
+  // How fast squish recovers
+};
+var CursorProvider = ({
+  children,
+  maxOffsetX = 5,
+  maxOffsetY = 20,
+  cursorSize = 20,
+  boundaryThreshold = 4,
+  outerThreshold = 8,
+  cursorClassName,
+  className,
+  as: Component = "div",
+  ...props
+}) => {
+  const [isClient, setIsClient] = react.useState(false);
+  const [isMouseInside, setIsMouseInside] = react.useState(false);
+  const cursorRef = react.useRef(null);
+  const cursorInnerRef = react.useRef(null);
+  const mousePositionRef = react.useRef({ x: 0, y: 0 });
+  const prevMousePositionRef = react.useRef({ x: 0, y: 0 });
+  const hoveredElementIdRef = react.useRef(null);
+  const hoveredElementRef = react.useRef(null);
+  const elementDimensionsRef = react.useRef({ width: 0, height: 0, x: 0, y: 0, right: 0, bottom: 0 });
+  const elementBorderRadiusRef = react.useRef("9999px");
+  const animationFrameRef = react.useRef(null);
+  const springRef = react.useRef({
+    x: 0,
+    y: 0,
+    width: cursorSize,
+    height: cursorSize,
+    velocityX: 0,
+    velocityY: 0,
+    velocityW: 0,
+    velocityH: 0,
+    scaleX: 1,
+    scaleY: 1
+  });
+  const targetRef = react.useRef({
+    x: 0,
+    y: 0,
+    width: cursorSize,
+    height: cursorSize
+  });
+  const [hoveredElementId, setHoveredElementId] = react.useState(null);
+  react.useEffect(() => {
+    setIsClient(true);
+  }, []);
+  const updateTarget = react.useCallback(() => {
+    const mouse = mousePositionRef.current;
+    const dims = elementDimensionsRef.current;
+    const isHovering = hoveredElementIdRef.current !== null;
+    if (isHovering && dims.width > 0) {
+      const distFromLeft = mouse.x - dims.x;
+      const distFromRight = dims.x + dims.width - mouse.x;
+      const distFromTop = mouse.y - dims.y;
+      const distFromBottom = dims.y + dims.height - mouse.y;
+      const totalThreshold = boundaryThreshold + outerThreshold;
+      let offsetX = 0;
+      let offsetY = 0;
+      if (distFromLeft < boundaryThreshold) {
+        const progress = Math.min(1, (boundaryThreshold - distFromLeft) / totalThreshold);
+        offsetX = -maxOffsetX * progress;
+      } else if (distFromRight < boundaryThreshold) {
+        const progress = Math.min(1, (boundaryThreshold - distFromRight) / totalThreshold);
+        offsetX = maxOffsetX * progress;
+      }
+      if (distFromTop < boundaryThreshold) {
+        const progress = Math.min(1, (boundaryThreshold - distFromTop) / totalThreshold);
+        offsetY = -maxOffsetY * progress;
+      } else if (distFromBottom < boundaryThreshold) {
+        const progress = Math.min(1, (boundaryThreshold - distFromBottom) / totalThreshold);
+        offsetY = maxOffsetY * progress;
+      }
+      targetRef.current = {
+        x: dims.x + offsetX,
+        y: dims.y + offsetY,
+        width: dims.width,
+        height: dims.height
+      };
+    } else {
+      targetRef.current = {
+        x: mouse.x - cursorSize / 2,
+        y: mouse.y - cursorSize / 2,
+        width: cursorSize,
+        height: cursorSize
+      };
+    }
+  }, [cursorSize, maxOffsetX, maxOffsetY, boundaryThreshold, outerThreshold]);
+  const animate = react.useCallback(() => {
+    const cursor = cursorRef.current;
+    const cursorInner = cursorInnerRef.current;
+    if (!cursor || !cursorInner) {
+      animationFrameRef.current = requestAnimationFrame(animate);
+      return;
+    }
+    const spring = springRef.current;
+    const target = targetRef.current;
+    const { stiffness, damping } = SPRING_CONFIG;
+    const mouse = mousePositionRef.current;
+    const prevMouse = prevMousePositionRef.current;
+    const mouseVelocityX = mouse.x - prevMouse.x;
+    const mouseVelocityY = mouse.y - prevMouse.y;
+    prevMousePositionRef.current = { ...mouse };
+    const forceX = (target.x - spring.x) * stiffness;
+    const forceY = (target.y - spring.y) * stiffness;
+    spring.velocityX = (spring.velocityX + forceX) * damping;
+    spring.velocityY = (spring.velocityY + forceY) * damping;
+    spring.x += spring.velocityX;
+    spring.y += spring.velocityY;
+    const forceW = (target.width - spring.width) * stiffness;
+    const forceH = (target.height - spring.height) * stiffness;
+    spring.velocityW = (spring.velocityW + forceW) * damping;
+    spring.velocityH = (spring.velocityH + forceH) * damping;
+    spring.width += spring.velocityW;
+    spring.height += spring.velocityH;
+    const targetScaleX = 1 - Math.abs(mouseVelocityY) * SQUISH_CONFIG.velocityScale;
+    const targetScaleY = 1 - Math.abs(mouseVelocityX) * SQUISH_CONFIG.velocityScale;
+    const clampedTargetScaleX = Math.max(1 - SQUISH_CONFIG.maxSquish, Math.min(1, targetScaleX));
+    const clampedTargetScaleY = Math.max(1 - SQUISH_CONFIG.maxSquish, Math.min(1, targetScaleY));
+    spring.scaleX += (clampedTargetScaleX - spring.scaleX) * SQUISH_CONFIG.recovery;
+    spring.scaleY += (clampedTargetScaleY - spring.scaleY) * SQUISH_CONFIG.recovery;
+    const bounceSquishX = 1 - Math.abs(spring.velocityY) * 0.02;
+    const bounceSquishY = 1 - Math.abs(spring.velocityX) * 0.02;
+    const finalScaleX = Math.max(0.85, spring.scaleX * bounceSquishX);
+    const finalScaleY = Math.max(0.85, spring.scaleY * bounceSquishY);
+    cursor.style.transform = `translate3d(${spring.x}px, ${spring.y}px, 0)`;
+    cursor.style.width = `${spring.width}px`;
+    cursor.style.height = `${spring.height}px`;
+    cursorInner.style.transform = `scale(${finalScaleX}, ${finalScaleY})`;
+    const isHovering = hoveredElementIdRef.current !== null;
+    if (isHovering) {
+      cursorInner.style.borderRadius = elementBorderRadiusRef.current;
+    } else {
+      cursorInner.style.borderRadius = "9999px";
+    }
+    animationFrameRef.current = requestAnimationFrame(animate);
+  }, []);
+  react.useEffect(() => {
+    if (!isClient) return;
+    animationFrameRef.current = requestAnimationFrame(animate);
+    return () => {
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+      }
+    };
+  }, [isClient, animate]);
+  react.useEffect(() => {
+    if (!isClient) return;
+    const handleMouseMove = (e) => {
+      mousePositionRef.current = { x: e.clientX, y: e.clientY };
+      updateTarget();
+    };
+    document.addEventListener("mousemove", handleMouseMove, { passive: true });
+    return () => document.removeEventListener("mousemove", handleMouseMove);
+  }, [isClient, updateTarget]);
+  const handleMouseEnter = react.useCallback(() => {
+    setIsMouseInside(true);
+    const mouse = mousePositionRef.current;
+    springRef.current.x = mouse.x - cursorSize / 2;
+    springRef.current.y = mouse.y - cursorSize / 2;
+    updateTarget();
+  }, [cursorSize, updateTarget]);
+  const handleMouseLeave = react.useCallback(() => {
+    setIsMouseInside(false);
+    hoveredElementIdRef.current = null;
+    hoveredElementRef.current = null;
+    setHoveredElementId(null);
+    updateTarget();
+  }, [updateTarget]);
+  const checkMouseInElement = react.useCallback(() => {
+    if (!hoveredElementRef.current || !hoveredElementIdRef.current) return;
+    const rect = hoveredElementRef.current.getBoundingClientRect();
+    const mouse = mousePositionRef.current;
+    elementDimensionsRef.current = {
+      width: rect.width,
+      height: rect.height,
+      x: rect.left,
+      y: rect.top,
+      right: rect.right,
+      bottom: rect.bottom
+    };
+    const isInside = mouse.x >= rect.left && mouse.x <= rect.right && mouse.y >= rect.top && mouse.y <= rect.bottom;
+    if (!isInside) {
+      hoveredElementIdRef.current = null;
+      hoveredElementRef.current = null;
+      setHoveredElementId(null);
+    }
+    updateTarget();
+  }, [updateTarget]);
+  react.useEffect(() => {
+    if (!isClient) return;
+    const handleScroll = () => checkMouseInElement();
+    document.addEventListener("scroll", handleScroll, { passive: true, capture: true });
+    return () => document.removeEventListener("scroll", handleScroll, { capture: true });
+  }, [checkMouseInElement, isClient]);
+  const registerHoveredElement = react.useCallback(
+    (id, dimensions, element) => {
+      hoveredElementIdRef.current = id;
+      elementDimensionsRef.current = {
+        width: dimensions.width,
+        height: dimensions.height,
+        x: dimensions.left,
+        y: dimensions.top,
+        right: dimensions.right,
+        bottom: dimensions.bottom
+      };
+      if (element) {
+        hoveredElementRef.current = element;
+        const computedStyle = window.getComputedStyle(element);
+        elementBorderRadiusRef.current = computedStyle.borderRadius || "8px";
+      }
+      setHoveredElementId(id);
+      updateTarget();
+    },
+    [updateTarget]
+  );
+  const unregisterHoveredElement = react.useCallback(() => {
+    hoveredElementIdRef.current = null;
+    hoveredElementRef.current = null;
+    elementBorderRadiusRef.current = "9999px";
+    setHoveredElementId(null);
+    updateTarget();
+  }, [updateTarget]);
+  const updateElementDimensions = react.useCallback(
+    (dimensions) => {
+      if (hoveredElementIdRef.current) {
+        elementDimensionsRef.current = {
+          width: dimensions.width,
+          height: dimensions.height,
+          x: dimensions.left,
+          y: dimensions.top,
+          right: dimensions.right,
+          bottom: dimensions.bottom
+        };
+        updateTarget();
+      }
+    },
+    [updateTarget]
+  );
+  const contextValue = react.useMemo(
+    () => ({
+      mousePosition: mousePositionRef.current,
+      hoveredElementId,
+      elementDimensions: elementDimensionsRef.current,
+      registerHoveredElement,
+      unregisterHoveredElement,
+      updateElementDimensions
+    }),
+    [hoveredElementId, registerHoveredElement, unregisterHoveredElement, updateElementDimensions]
+  );
+  const cursorElement = isClient && /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: cursorRef,
+      className: "pointer-events-none fixed z-50",
+      style: {
+        left: 0,
+        top: 0,
+        width: cursorSize,
+        height: cursorSize,
+        display: isMouseInside ? "block" : "none",
+        willChange: "transform, width, height"
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          ref: cursorInnerRef,
+          className: chunk6LTCLQH3_cjs.cn("h-full w-full border border-white/50", cursorClassName),
+          style: {
+            backgroundColor: "rgba(156, 163, 175, 0.2)",
+            boxShadow: "0 0 25px rgba(255, 255, 255, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.5)",
+            borderRadius: "9999px",
+            transformOrigin: "center center"
+          }
+        }
+      )
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    isClient && typeof document !== "undefined" && document.body && reactDom.createPortal(cursorElement, document.body),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkP6DICGAV_cjs.CursorContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(
+      Component,
+      {
+        ...props,
+        className: chunk6LTCLQH3_cjs.cn(className),
+        style: {
+          cursor: isMouseInside && !hoveredElementId ? "none" : "auto",
+          ...props.style
+        },
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        children
+      }
+    ) })
+  ] });
+};
+
+exports.CursorProvider = CursorProvider;