@vuer-ai/vuer-uikit 0.0.121 → 0.1.0

package/dist/{chunk-HVACIZB5.cjs → chunk-DKLVWYTC.cjs}

@@ -1,13 +1,14 @@
 'use strict';
 
-var chunkKR7VBV3B_cjs = require('./chunk-KR7VBV3B.cjs');
+var chunkXIDCYS6G_cjs = require('./chunk-XIDCYS6G.cjs');
 var chunkNIACIZWY_cjs = require('./chunk-NIACIZWY.cjs');
 var chunkR22VW3EK_cjs = require('./chunk-R22VW3EK.cjs');
 var lucideReact = require('lucide-react');
+var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
 var LiquidToggle = ({ className, ...props }) => {
-  const { isLiquid, toggleLiquid } = chunkKR7VBV3B_cjs.useTheme();
+  const { isLiquid, toggleLiquid } = chunkXIDCYS6G_cjs.useTheme();
   return /* @__PURE__ */ jsxRuntime.jsxs(chunkNIACIZWY_cjs.Tooltip, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(chunkNIACIZWY_cjs.TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
       chunkR22VW3EK_cjs.Button,
@@ -24,19 +25,35 @@ var LiquidToggle = ({ className, ...props }) => {
     /* @__PURE__ */ jsxRuntime.jsx(chunkNIACIZWY_cjs.TooltipContent, { children: isLiquid ? "Dock Layout" : "Liquid Layout" })
   ] });
 };
+var QUICK_TOGGLE_TIMEOUT = 1500;
 var ThemeColorToggle = (props) => {
-  const { baseTheme, setBaseTheme, resolvedTheme } = chunkKR7VBV3B_cjs.useTheme();
+  const { baseTheme, setBaseTheme, resolvedTheme } = chunkXIDCYS6G_cjs.useTheme();
+  const lastClickRef = react.useRef(0);
+  const isDark = resolvedTheme?.includes("dark");
+  const isSystem = baseTheme === "system";
   const handleThemeChange = () => {
-    if (baseTheme === "light") {
-      setBaseTheme("dark");
-    } else if (baseTheme === "dark") {
-      setBaseTheme("system");
-    } else if (baseTheme === "system") {
-      setBaseTheme("light");
+    const now = Date.now();
+    const timeSinceLastClick = now - lastClickRef.current;
+    lastClickRef.current = now;
+    const isQuickToggle = timeSinceLastClick < QUICK_TOGGLE_TIMEOUT;
+    if (isQuickToggle) {
+      if (baseTheme === "light") {
+        setBaseTheme("dark");
+      } else if (baseTheme === "dark") {
+        setBaseTheme("system");
+      } else {
+        setBaseTheme("light");
+      }
+    } else {
+      if (baseTheme === "system") {
+        setBaseTheme(isDark ? "light" : "dark");
+      } else if (baseTheme === "light") {
+        setBaseTheme("dark");
+      } else {
+        setBaseTheme("light");
+      }
     }
   };
-  const isDark = resolvedTheme?.includes("dark");
-  const isSystem = baseTheme === "system";
   return /* @__PURE__ */ jsxRuntime.jsx(
     chunkR22VW3EK_cjs.Button,
     {
@@ -45,7 +62,7 @@ var ThemeColorToggle = (props) => {
       "aria-label": `Current theme: ${isSystem ? "system" : isDark ? "dark" : "light"}`,
       ...props,
       onClick: handleThemeChange,
-      children: isSystem ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.SunMoon, { size: 20 }) : isDark ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Moon, { size: 20 }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Sun, { size: 20 })
+      children: isSystem ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.SunMoon, { size: 24 }) : isDark ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Moon, { size: 24 }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Sun, { size: 24 })
     }
   );
 };

package/dist/chunk-DKWLF3KW.mjs

@@ -0,0 +1,149 @@
+import { useRef, useMemo, useCallback } from 'react';
+
+// src/ui/virtual-list/useVirtualList.ts
+function findStartIndex(measurements, itemCount, scrollTop, itemHeight, estimatedItemHeight) {
+  if (itemCount === 0) return 0;
+  if (typeof itemHeight === "number") {
+    return Math.floor(scrollTop / itemHeight);
+  }
+  let low = 0;
+  let high = itemCount - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const measurement = measurements.get(mid);
+    const offset = measurement?.offset ?? mid * estimatedItemHeight;
+    if (offset < scrollTop) {
+      low = mid + 1;
+    } else if (offset > scrollTop) {
+      high = mid - 1;
+    } else {
+      return mid;
+    }
+  }
+  return Math.max(0, low - 1);
+}
+function useVirtualList({
+  items,
+  itemHeight,
+  estimatedItemHeight,
+  containerHeight,
+  overscan,
+  scrollTop
+}) {
+  const measurementsRef = useRef(/* @__PURE__ */ new Map());
+  const measurements = measurementsRef.current;
+  const isFixed = typeof itemHeight === "number";
+  const totalHeight = useMemo(() => {
+    if (isFixed) {
+      return items.length * itemHeight;
+    }
+    let height = 0;
+    for (let i = 0; i < items.length; i++) {
+      const measurement = measurements.get(i);
+      height += measurement?.height ?? estimatedItemHeight;
+    }
+    return height;
+  }, [items.length, itemHeight, isFixed, estimatedItemHeight, measurements]);
+  const visibleRange = useMemo(() => {
+    if (items.length === 0) {
+      return { start: 0, end: 0 };
+    }
+    const startIndex = findStartIndex(
+      measurements,
+      items.length,
+      scrollTop,
+      itemHeight,
+      estimatedItemHeight
+    );
+    let endIndex;
+    if (isFixed) {
+      endIndex = Math.min(items.length - 1, Math.ceil((scrollTop + containerHeight) / itemHeight));
+    } else {
+      let accumulatedHeight = 0;
+      endIndex = startIndex;
+      const startMeasurement = measurements.get(startIndex);
+      const startOffset = startMeasurement?.offset ?? startIndex * estimatedItemHeight;
+      accumulatedHeight = startOffset - scrollTop;
+      while (endIndex < items.length - 1 && accumulatedHeight < containerHeight) {
+        const measurement = measurements.get(endIndex);
+        accumulatedHeight += measurement?.height ?? estimatedItemHeight;
+        endIndex++;
+      }
+    }
+    const start = Math.max(0, startIndex - overscan);
+    const end = Math.min(items.length - 1, endIndex + overscan);
+    return { start, end };
+  }, [
+    items.length,
+    scrollTop,
+    containerHeight,
+    overscan,
+    itemHeight,
+    isFixed,
+    estimatedItemHeight,
+    measurements
+  ]);
+  const getItemStyle = useCallback(
+    (index) => {
+      let top;
+      if (isFixed) {
+        top = index * itemHeight;
+      } else {
+        const measurement = measurements.get(index);
+        if (measurement) {
+          top = measurement.offset;
+        } else {
+          let offset = 0;
+          for (let i = 0; i < index; i++) {
+            const m = measurements.get(i);
+            offset += m?.height ?? estimatedItemHeight;
+          }
+          top = offset;
+        }
+      }
+      return {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        transform: `translateY(${top}px)`,
+        ...isFixed && { height: itemHeight }
+      };
+    },
+    [itemHeight, isFixed, estimatedItemHeight, measurements]
+  );
+  const measureItem = useCallback(
+    (index, height) => {
+      const currentMeasurement = measurements.get(index);
+      if (currentMeasurement?.height === height) {
+        return;
+      }
+      let offset = 0;
+      for (let i = 0; i < index; i++) {
+        const m = measurements.get(i);
+        offset += m?.height ?? estimatedItemHeight;
+      }
+      measurements.set(index, { offset, height });
+      let currentOffset = offset + height;
+      for (let i = index + 1; i < items.length; i++) {
+        const m = measurements.get(i);
+        if (m) {
+          measurements.set(i, { ...m, offset: currentOffset });
+          currentOffset += m.height;
+        } else {
+          break;
+        }
+      }
+    },
+    [items.length, estimatedItemHeight, measurements]
+  );
+  return {
+    visibleRange,
+    totalHeight,
+    getItemStyle,
+    measureItem,
+    measurements
+  };
+}
+
+export { useVirtualList };

package/dist/{chunk-4WKFVKFF.cjs → chunk-DPJPOBUT.cjs}

@@ -4,8 +4,8 @@ var chunk6LTCLQH3_cjs = require('./chunk-6LTCLQH3.cjs');
 var jsxRuntime = require('react/jsx-runtime');
 
 var DIAL_PACKAGE_NAME = "@vuer-ai/dial-cli" ;
-var DIAL_PACKAGE_VERSION = "0.0.23" ;
-var DIAL_GIT_HASH = "93872f6" ;
+var DIAL_PACKAGE_VERSION = "0.0.25" ;
+var DIAL_GIT_HASH = "d89e683" ;
 function DialBadge({
   className,
   package: showPackage = true,

package/dist/{chunk-XHNM6XE3.mjs → chunk-EG6JETUN.mjs}

@@ -1,4 +1,4 @@
-import { EulerInput } from './chunk-7MR3M2HW.mjs';
+import { EulerInput } from './chunk-L2DME42Q.mjs';
 import { forwardRef } from 'react';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-QYYMLZFE.mjs → chunk-EXM6QMNR.mjs}

@@ -1,4 +1,4 @@
-import { InputNumbers } from './chunk-HGN7J4CP.mjs';
+import { InputNumbers } from './chunk-D2LUQKPM.mjs';
 import { Button } from './chunk-5JYH7TXY.mjs';
 import { cn } from './chunk-HBEU2PU2.mjs';
 import { forwardRef, useState } from 'react';

package/dist/{chunk-2KQXKQNU.mjs → chunk-EYMZP5PL.mjs}

@@ -1,4 +1,4 @@
-import { InputNumbers } from './chunk-HGN7J4CP.mjs';
+import { InputNumbers } from './chunk-D2LUQKPM.mjs';
 import { forwardRef } from 'react';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/chunk-FRM27RLN.cjs

@@ -0,0 +1,264 @@
+'use strict';
+
+var chunkJ74A5LNZ_cjs = require('./chunk-J74A5LNZ.cjs');
+var chunk6LTCLQH3_cjs = require('./chunk-6LTCLQH3.cjs');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function VirtualGridInner({
+  data,
+  rowCount,
+  columnCount,
+  rowHeight,
+  columnWidth,
+  height,
+  width = "100%",
+  overscanRows = 2,
+  overscanColumns = 2,
+  getCellKey,
+  getColSpan,
+  getRowSpan,
+  children,
+  stickyHeader = false,
+  stickyColumn = false,
+  className,
+  style,
+  ...props
+}, ref) {
+  const containerRef = React.useRef(null);
+  const stickyLayerRef = React.useRef(null);
+  const [scrollTop, setScrollTop] = React.useState(0);
+  const [scrollLeft, setScrollLeft] = React.useState(0);
+  const [containerWidth, setContainerWidth] = React.useState(0);
+  const [containerHeight, setContainerHeight] = React.useState(0);
+  const scrollRef = React.useRef({ top: 0, left: 0 });
+  const setRefs = React.useCallback(
+    (node) => {
+      containerRef.current = node;
+      if (typeof ref === "function") {
+        ref(node);
+      } else if (ref) {
+        ref.current = node;
+      }
+    },
+    [ref]
+  );
+  React.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        setContainerWidth(entry.contentRect.width);
+        setContainerHeight(entry.contentRect.height);
+      }
+    });
+    resizeObserver.observe(container);
+    setContainerWidth(container.clientWidth);
+    setContainerHeight(container.clientHeight);
+    return () => resizeObserver.disconnect();
+  }, []);
+  const {
+    visibleRange,
+    totalWidth,
+    totalHeight,
+    getCellStyle,
+    getRowOffset,
+    getColumnOffset,
+    getRowHeight,
+    getColumnWidth
+  } = chunkJ74A5LNZ_cjs.useVirtualGrid({
+    rowCount,
+    columnCount,
+    rowHeight,
+    columnWidth,
+    containerWidth,
+    containerHeight,
+    scrollTop,
+    scrollLeft,
+    overscanRows,
+    overscanColumns,
+    getColSpan,
+    getRowSpan
+  });
+  const rafRef = React.useRef(null);
+  const handleScroll = React.useCallback((e) => {
+    const newScrollTop = e.currentTarget.scrollTop;
+    const newScrollLeft = e.currentTarget.scrollLeft;
+    scrollRef.current = { top: newScrollTop, left: newScrollLeft };
+    if (stickyLayerRef.current) {
+      stickyLayerRef.current.style.setProperty("--scroll-top", `${Math.round(newScrollTop)}px`);
+      stickyLayerRef.current.style.setProperty("--scroll-left", `${Math.round(newScrollLeft)}px`);
+    }
+    if (rafRef.current) {
+      cancelAnimationFrame(rafRef.current);
+    }
+    rafRef.current = requestAnimationFrame(() => {
+      setScrollTop(newScrollTop);
+      setScrollLeft(newScrollLeft);
+    });
+  }, []);
+  React.useEffect(() => {
+    return () => {
+      if (rafRef.current) {
+        cancelAnimationFrame(rafRef.current);
+      }
+    };
+  }, []);
+  React.useLayoutEffect(() => {
+    if (stickyLayerRef.current) {
+      stickyLayerRef.current.style.setProperty("--scroll-top", "0px");
+      stickyLayerRef.current.style.setProperty("--scroll-left", "0px");
+    }
+  }, []);
+  const coveredCells = /* @__PURE__ */ new Set();
+  if (getColSpan || getRowSpan) {
+    for (let row = visibleRange.startRow; row <= visibleRange.endRow; row++) {
+      for (let col = visibleRange.startCol; col <= visibleRange.endCol; col++) {
+        const colspan = getColSpan?.(row, col) ?? 1;
+        const rowspan = getRowSpan?.(row, col) ?? 1;
+        if (colspan > 1 || rowspan > 1) {
+          for (let r = row; r < row + rowspan; r++) {
+            for (let c = col; c < col + colspan; c++) {
+              if (r !== row || c !== col) {
+                coveredCells.add(`${r}-${c}`);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const visibleCells = [];
+  for (let row = visibleRange.startRow; row <= visibleRange.endRow && row < rowCount; row++) {
+    for (let col = visibleRange.startCol; col <= visibleRange.endCol && col < columnCount; col++) {
+      if (coveredCells.has(`${row}-${col}`)) {
+        continue;
+      }
+      if (stickyHeader && row === 0 || stickyColumn && col === 0) {
+        continue;
+      }
+      const cellData = data[row]?.[col];
+      const key = getCellKey ? getCellKey(row, col) : `${row}-${col}`;
+      const cellStyle = getCellStyle(row, col);
+      visibleCells.push(
+        /* @__PURE__ */ jsxRuntime.jsx(React__default.default.Fragment, { children: children(cellData, row, col, cellStyle) }, key)
+      );
+    }
+  }
+  const stickyContentStyle = { width: "100%", height: "100%" };
+  const stickyHeaderCells = [];
+  if (stickyHeader && rowCount > 0) {
+    for (let col = visibleRange.startCol; col <= visibleRange.endCol && col < columnCount; col++) {
+      if (stickyColumn && col === 0) continue;
+      if (coveredCells.has(`0-${col}`)) continue;
+      const cellData = data[0]?.[col];
+      const key = getCellKey ? getCellKey(0, col) : `header-${col}`;
+      stickyHeaderCells.push(
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "sticky-header-cell",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: getColumnWidth(col),
+              height: getRowHeight(0),
+              transform: `translate3d(${getColumnOffset(col)}px, var(--scroll-top, 0px), 0)`,
+              willChange: "transform",
+              zIndex: 2
+            },
+            children: children(cellData, 0, col, stickyContentStyle)
+          },
+          key
+        )
+      );
+    }
+  }
+  const stickyColumnCells = [];
+  if (stickyColumn && columnCount > 0) {
+    for (let row = visibleRange.startRow; row <= visibleRange.endRow && row < rowCount; row++) {
+      if (stickyHeader && row === 0) continue;
+      if (coveredCells.has(`${row}-0`)) continue;
+      const cellData = data[row]?.[0];
+      const key = getCellKey ? getCellKey(row, 0) : `sticky-col-${row}`;
+      stickyColumnCells.push(
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "sticky-column-cell",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: getColumnWidth(0),
+              height: getRowHeight(row),
+              transform: `translate3d(var(--scroll-left, 0px), ${getRowOffset(row)}px, 0)`,
+              willChange: "transform",
+              zIndex: 2
+            },
+            children: children(cellData, row, 0, stickyContentStyle)
+          },
+          key
+        )
+      );
+    }
+  }
+  const stickyCornerCell = stickyHeader && stickyColumn && rowCount > 0 && columnCount > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "sticky-corner-cell",
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: getColumnWidth(0),
+        height: getRowHeight(0),
+        transform: `translate3d(var(--scroll-left, 0px), var(--scroll-top, 0px), 0)`,
+        willChange: "transform",
+        zIndex: 3
+      },
+      children: children(data[0]?.[0], 0, 0, stickyContentStyle)
+    },
+    "sticky-corner"
+  ) : null;
+  const hasStickyElements = stickyHeader || stickyColumn;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setRefs,
+      className: chunk6LTCLQH3_cjs.cn("relative overflow-auto", className),
+      style: {
+        height,
+        width,
+        ...style
+      },
+      onScroll: handleScroll,
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          ref: hasStickyElements ? stickyLayerRef : void 0,
+          style: {
+            height: totalHeight,
+            width: totalWidth,
+            position: "relative"
+          },
+          children: [
+            stickyCornerCell,
+            stickyHeaderCells,
+            stickyColumnCells,
+            visibleCells
+          ]
+        }
+      )
+    }
+  );
+}
+var VirtualGrid = React.forwardRef(VirtualGridInner);
+
+exports.VirtualGrid = VirtualGrid;

package/dist/chunk-FTB337IJ.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+var chunkYDF6VWBW_cjs = require('./chunk-YDF6VWBW.cjs');
+var chunk6LTCLQH3_cjs = require('./chunk-6LTCLQH3.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function VirtualListInner({
+  items,
+  itemHeight,
+  estimatedItemHeight = 40,
+  height = "100%",
+  overscan = 3,
+  getItemKey,
+  children,
+  onScroll,
+  onRangeChange,
+  className,
+  style,
+  ...props
+}, ref) {
+  const containerRef = react.useRef(null);
+  const [scrollTop, setScrollTop] = react.useState(0);
+  const [containerHeight, setContainerHeight] = react.useState(0);
+  const setRefs = react.useCallback(
+    (node) => {
+      containerRef.current = node;
+      if (typeof ref === "function") {
+        ref(node);
+      } else if (ref) {
+        ref.current = node;
+      }
+    },
+    [ref]
+  );
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        setContainerHeight(entry.contentRect.height);
+      }
+    });
+    resizeObserver.observe(container);
+    setContainerHeight(container.clientHeight);
+    return () => resizeObserver.disconnect();
+  }, []);
+  const { visibleRange, totalHeight, getItemStyle, measureItem } = chunkYDF6VWBW_cjs.useVirtualList({
+    items,
+    itemHeight,
+    estimatedItemHeight,
+    containerHeight,
+    overscan,
+    scrollTop
+  });
+  const handleScroll = react.useCallback(
+    (e) => {
+      const newScrollTop = e.currentTarget.scrollTop;
+      setScrollTop(newScrollTop);
+      onScroll?.(newScrollTop);
+    },
+    [onScroll]
+  );
+  const prevRangeRef = react.useRef({ start: -1, end: -1 });
+  react.useEffect(() => {
+    if (visibleRange.start !== prevRangeRef.current.start || visibleRange.end !== prevRangeRef.current.end) {
+      prevRangeRef.current = visibleRange;
+      onRangeChange?.(visibleRange.start, visibleRange.end);
+    }
+  }, [visibleRange, onRangeChange]);
+  const visibleItems = [];
+  const isDynamic = itemHeight === "dynamic";
+  const dynamicChildStyle = { width: "100%" };
+  for (let i = visibleRange.start; i <= visibleRange.end && i < items.length; i++) {
+    const item = items[i];
+    const key = getItemKey ? getItemKey(item, i) : i;
+    const itemStyle = getItemStyle(i);
+    visibleItems.push(
+      /* @__PURE__ */ jsxRuntime.jsx(
+        VirtualListItem,
+        {
+          index: i,
+          isDynamic,
+          measureItem,
+          style: itemStyle,
+          children: children(item, i, isDynamic ? dynamicChildStyle : itemStyle)
+        },
+        key
+      )
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setRefs,
+      className: chunk6LTCLQH3_cjs.cn("relative w-full overflow-auto", className),
+      style: {
+        height,
+        ...style
+      },
+      onScroll: handleScroll,
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          style: {
+            height: totalHeight,
+            position: "relative",
+            width: "100%"
+          },
+          children: visibleItems
+        }
+      )
+    }
+  );
+}
+function VirtualListItem({
+  children,
+  index,
+  isDynamic,
+  measureItem,
+  style
+}) {
+  const itemRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!isDynamic || !itemRef.current) return;
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        measureItem(index, entry.contentRect.height);
+      }
+    });
+    resizeObserver.observe(itemRef.current);
+    measureItem(index, itemRef.current.offsetHeight);
+    return () => resizeObserver.disconnect();
+  }, [index, isDynamic, measureItem]);
+  if (!isDynamic) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: itemRef, style, children });
+}
+var VirtualList = react.forwardRef(VirtualListInner);
+
+exports.VirtualList = VirtualList;

package/dist/{chunk-PZDC5ZKG.mjs → chunk-G35PQKU5.mjs}

@@ -1,9 +1,9 @@
-import { withCursor } from './chunk-RAHKRYQJ.mjs';
-import { Tabs } from './chunk-3P2OP4KO.mjs';
+import { Tabs } from './chunk-2J466BYZ.mjs';
 import { Textarea } from './chunk-Y2IIKDRY.mjs';
 import { InputRoot } from './chunk-HGTL7DFT.mjs';
-import { SelectTrigger } from './chunk-O5YP3JQ4.mjs';
+import { SelectTrigger } from './chunk-4W7JKZVN.mjs';
 import { Button } from './chunk-5JYH7TXY.mjs';
+import { withCursor } from './chunk-RAHKRYQJ.mjs';
 
 // src/highlight-cursor/enhanced-components.tsx
 var CursorButton = withCursor(Button);

package/dist/{chunk-BLG4IPRR.mjs → chunk-GAAP5JO4.mjs}

@@ -1,4 +1,4 @@
-import { InputNumbers } from './chunk-HGN7J4CP.mjs';
+import { InputNumbers } from './chunk-D2LUQKPM.mjs';
 import { forwardRef } from 'react';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-LOMLR5AA.mjs → chunk-HI4LO6IJ.mjs}

@@ -1,4 +1,4 @@
-import { InputNumbers } from './chunk-HGN7J4CP.mjs';
+import { InputNumbers } from './chunk-D2LUQKPM.mjs';
 import { forwardRef } from 'react';
 import { jsx } from 'react/jsx-runtime';