@overmap-ai/blocks 1.0.31-tailwind-components.18 → 1.0.31-tailwind-components.20

package/dist/blocks.umd.cjs

@@ -863,7 +863,7 @@
     }, [filterFunction, filterValue, values]);
     return [filteredOptions, filterValue, setFilterValue];
   }
-  const useSize = (target) => {
+  const useSize$1 = (target) => {
     const [size2, setSize] = React.useState();
     React.useLayoutEffect(() => {
       var _a;
@@ -1334,7 +1334,7 @@
       return !hideLayout && /* @__PURE__ */ jsxRuntime.jsx("div", { className: classVarianceAuthority.cx(className, "flex grow h-full"), ref, ...rest, children });
     })
   );
-  const Root$1 = React.memo((props) => {
+  const Root$2 = React.memo((props) => {
     const { children, small = false, hideLayout = false } = props;
     const [showLeftSlideOut, setShowLeftSlideOut] = React.useState(false);
     const [showRightSlideOut, setShowRightSlideOut] = React.useState(false);
@@ -1351,9 +1351,9 @@
     );
     return /* @__PURE__ */ jsxRuntime.jsx(LayoutContext.Provider, { value: contextValue, children });
   });
-  Root$1.displayName = "Layout.Root";
+  Root$2.displayName = "Layout.Root";
   function usePointerDownOutside(onPointerDownOutside, ownerElement = globalThis == null ? void 0 : globalThis.document.body) {
-    const handlePointerDownOutside = useCallbackRef$1(onPointerDownOutside);
+    const handlePointerDownOutside = useCallbackRef$2(onPointerDownOutside);
     const isPointerInsideReactTreeRef = React.useRef(false);
     const handleClickRef = React.useRef(() => {
     });
@@ -1405,7 +1405,7 @@
       target.dispatchEvent(event);
     }
   }
-  function useCallbackRef$1(callback) {
+  function useCallbackRef$2(callback) {
     const callbackRef = React.useRef(callback);
     React.useEffect(() => {
       callbackRef.current = callback;
@@ -1689,7 +1689,7 @@
     })
   );
   const Layout = {
-    Root: Root$1,
+    Root: Root$2,
     Container,
     SlideOutOverlay,
     LeftSlideOut,
@@ -1699,6 +1699,7 @@
   const linkCva = classVarianceAuthority.cva(["cursor-pointer"], {
     variants: {
       size: {
+        none: ["[font-size:inherit]", "leading-[inherit]"],
         xs: ["text-xs"],
         sm: ["text-sm"],
         md: ["text-base"],
@@ -1726,7 +1727,7 @@
       }
     },
     defaultVariants: {
-      size: "xl",
+      size: "none",
       weight: "regular",
       align: "left"
     }
@@ -1735,7 +1736,7 @@
     const providerContext = useProvider();
     const {
       className,
-      size: size2 = "md",
+      size: size2,
       weight = "regular",
       align = "left",
       highContrast = false,
@@ -7862,7 +7863,7 @@
     Item: RadioGroupItem,
     Root: RadioGroupRoot
   };
-  function createContextScope(scopeName, createContextScopeDeps = []) {
+  function createContextScope$1(scopeName, createContextScopeDeps = []) {
     let defaultContexts = [];
     function createContext3(rootComponentName, defaultContext) {
       const BaseContext = React__namespace.createContext(defaultContext);
@@ -7899,9 +7900,9 @@
       };
     };
     createScope.scopeName = scopeName;
-    return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+    return [createContext3, composeContextScopes$1(createScope, ...createContextScopeDeps)];
   }
-  function composeContextScopes(...scopes) {
+  function composeContextScopes$1(...scopes) {
     const baseScope = scopes[0];
     if (scopes.length === 1) return baseScope;
     const createScope = () => {
@@ -7921,7 +7922,7 @@
     createScope.scopeName = baseScope.scopeName;
     return createScope;
   }
-  var NODES = [
+  var NODES$1 = [
     "a",
     "button",
     "div",
@@ -7939,7 +7940,7 @@
     "svg",
     "ul"
   ];
-  var Primitive = NODES.reduce((primitive, node) => {
+  var Primitive$1 = NODES$1.reduce((primitive, node) => {
     const Node2 = React__namespace.forwardRef((props, forwardedRef) => {
       const { asChild, ...primitiveProps } = props;
       const Comp = asChild ? reactSlot.Slot : node;
@@ -7951,7 +7952,7 @@
     Node2.displayName = `Primitive.${node}`;
     return { ...primitive, [node]: Node2 };
   }, {});
-  function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  function composeEventHandlers$1(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
     return function handleEvent(event) {
       originalEventHandler == null ? void 0 : originalEventHandler(event);
       if (checkForDefaultPrevented === false || !event.defaultPrevented) {
@@ -7959,18 +7960,18 @@
       }
     };
   }
-  function setRef(ref, value) {
+  function setRef$1(ref, value) {
     if (typeof ref === "function") {
       return ref(value);
     } else if (ref !== null && ref !== void 0) {
       ref.current = value;
     }
   }
-  function composeRefs(...refs) {
+  function composeRefs$1(...refs) {
     return (node) => {
       let hasCleanup = false;
       const cleanups = refs.map((ref) => {
-        const cleanup = setRef(ref, node);
+        const cleanup = setRef$1(ref, node);
         if (!hasCleanup && typeof cleanup == "function") {
           hasCleanup = true;
         }
@@ -7983,19 +7984,19 @@
             if (typeof cleanup == "function") {
               cleanup();
             } else {
-              setRef(refs[i], null);
+              setRef$1(refs[i], null);
             }
           }
         };
       }
     };
   }
-  function useComposedRefs(...refs) {
-    return React__namespace.useCallback(composeRefs(...refs), refs);
+  function useComposedRefs$1(...refs) {
+    return React__namespace.useCallback(composeRefs$1(...refs), refs);
   }
   function createCollection(name) {
     const PROVIDER_NAME = name + "CollectionProvider";
-    const [createCollectionContext, createCollectionScope2] = createContextScope(PROVIDER_NAME);
+    const [createCollectionContext, createCollectionScope2] = createContextScope$1(PROVIDER_NAME);
     const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(
       PROVIDER_NAME,
       { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
@@ -8012,7 +8013,7 @@
       (props, forwardedRef) => {
         const { scope, children } = props;
         const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
-        const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
+        const composedRefs = useComposedRefs$1(forwardedRef, context.collectionRef);
         return /* @__PURE__ */ jsxRuntime.jsx(reactSlot.Slot, { ref: composedRefs, children });
       }
     );
@@ -8023,7 +8024,7 @@
       (props, forwardedRef) => {
         const { scope, children, ...itemData } = props;
         const ref = React.useRef(null);
-        const composedRefs = useComposedRefs(forwardedRef, ref);
+        const composedRefs = useComposedRefs$1(forwardedRef, ref);
         const context = useCollectionContext(ITEM_SLOT_NAME, scope);
         React.useEffect(() => {
           context.itemMap.set(ref, { ref, ...itemData });
@@ -8053,18 +8054,18 @@
       createCollectionScope2
     ];
   }
-  var useLayoutEffect2 = Boolean(globalThis == null ? void 0 : globalThis.document) ? React__namespace.useLayoutEffect : () => {
+  var useLayoutEffect2$1 = Boolean(globalThis == null ? void 0 : globalThis.document) ? React__namespace.useLayoutEffect : () => {
   };
   var useReactId = React__namespace["useId".toString()] || (() => void 0);
   var count = 0;
   function useId(deterministicId) {
     const [id, setId] = React__namespace.useState(useReactId());
-    useLayoutEffect2(() => {
+    useLayoutEffect2$1(() => {
       setId((reactId) => reactId ?? String(count++));
     }, [deterministicId]);
     return id ? `radix-${id}` : "";
   }
-  function useCallbackRef(callback) {
+  function useCallbackRef$1(callback) {
     const callbackRef = React__namespace.useRef(callback);
     React__namespace.useEffect(() => {
       callbackRef.current = callback;
@@ -8074,16 +8075,16 @@
       return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
     }, []);
   }
-  function useControllableState({
+  function useControllableState$1({
     prop,
     defaultProp,
     onChange = () => {
     }
   }) {
-    const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });
+    const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState$1({ defaultProp, onChange });
     const isControlled = prop !== void 0;
     const value = isControlled ? prop : uncontrolledProp;
-    const handleChange = useCallbackRef(onChange);
+    const handleChange = useCallbackRef$1(onChange);
     const setValue = React__namespace.useCallback(
       (nextValue) => {
         if (isControlled) {
@@ -8098,14 +8099,14 @@
     );
     return [value, setValue];
   }
-  function useUncontrolledState({
+  function useUncontrolledState$1({
     defaultProp,
     onChange
   }) {
     const uncontrolledState = React__namespace.useState(defaultProp);
     const [value] = uncontrolledState;
     const prevValueRef = React__namespace.useRef(value);
-    const handleChange = useCallbackRef(onChange);
+    const handleChange = useCallbackRef$1(onChange);
     React__namespace.useEffect(() => {
       if (prevValueRef.current !== value) {
         handleChange(value);
@@ -8123,7 +8124,7 @@
   var EVENT_OPTIONS = { bubbles: false, cancelable: true };
   var GROUP_NAME = "RovingFocusGroup";
   var [Collection, useCollection, createCollectionScope] = createCollection(GROUP_NAME);
-  var [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope(
+  var [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope$1(
     GROUP_NAME,
     [createCollectionScope]
   );
@@ -8148,15 +8149,15 @@
       ...groupProps
     } = props;
     const ref = React__namespace.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const composedRefs = useComposedRefs$1(forwardedRef, ref);
     const direction = useDirection(dir);
-    const [currentTabStopId = null, setCurrentTabStopId] = useControllableState({
+    const [currentTabStopId = null, setCurrentTabStopId] = useControllableState$1({
       prop: currentTabStopIdProp,
       defaultProp: defaultCurrentTabStopId,
       onChange: onCurrentTabStopIdChange
     });
     const [isTabbingBackOut, setIsTabbingBackOut] = React__namespace.useState(false);
-    const handleEntryFocus = useCallbackRef(onEntryFocus);
+    const handleEntryFocus = useCallbackRef$1(onEntryFocus);
     const getItems = useCollection(__scopeRovingFocusGroup);
     const isClickFocusRef = React__namespace.useRef(false);
     const [focusableItemsCount, setFocusableItemsCount] = React__namespace.useState(0);
@@ -8189,17 +8190,17 @@
           []
         ),
         children: /* @__PURE__ */ jsxRuntime.jsx(
-          Primitive.div,
+          Primitive$1.div,
           {
             tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,
             "data-orientation": orientation,
             ...groupProps,
             ref: composedRefs,
             style: { outline: "none", ...props.style },
-            onMouseDown: composeEventHandlers(props.onMouseDown, () => {
+            onMouseDown: composeEventHandlers$1(props.onMouseDown, () => {
               isClickFocusRef.current = true;
             }),
-            onFocus: composeEventHandlers(props.onFocus, (event) => {
+            onFocus: composeEventHandlers$1(props.onFocus, (event) => {
               const isKeyboardFocus = !isClickFocusRef.current;
               if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {
                 const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);
@@ -8217,7 +8218,7 @@
               }
               isClickFocusRef.current = false;
             }),
-            onBlur: composeEventHandlers(props.onBlur, () => setIsTabbingBackOut(false))
+            onBlur: composeEventHandlers$1(props.onBlur, () => setIsTabbingBackOut(false))
           }
         )
       }
@@ -8253,18 +8254,18 @@
           focusable,
           active,
           children: /* @__PURE__ */ jsxRuntime.jsx(
-            Primitive.span,
+            Primitive$1.span,
             {
               tabIndex: isCurrentTabStop ? 0 : -1,
               "data-orientation": context.orientation,
               ...itemProps,
               ref: forwardedRef,
-              onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {
+              onMouseDown: composeEventHandlers$1(props.onMouseDown, (event) => {
                 if (!focusable) event.preventDefault();
                 else context.onItemFocus(id);
               }),
-              onFocus: composeEventHandlers(props.onFocus, () => context.onItemFocus(id)),
-              onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+              onFocus: composeEventHandlers$1(props.onFocus, () => context.onItemFocus(id)),
+              onKeyDown: composeEventHandlers$1(props.onKeyDown, (event) => {
                 if (event.key === "Tab" && event.shiftKey) {
                   context.onItemShiftTab();
                   return;
@@ -8323,10 +8324,10 @@
   function wrapArray(array, startIndex) {
     return array.map((_, index2) => array[(startIndex + index2) % array.length]);
   }
-  var Root = RovingFocusGroup;
+  var Root$1 = RovingFocusGroup;
   var Item = RovingFocusGroupItem;
   var TOGGLE_GROUP_NAME = "ToggleGroup";
-  var [createToggleGroupContext, createToggleGroupScope] = createContextScope(TOGGLE_GROUP_NAME, [
+  var [createToggleGroupContext, createToggleGroupScope] = createContextScope$1(TOGGLE_GROUP_NAME, [
     createRovingFocusGroupScope
   ]);
   var useRovingFocusGroupScope = createRovingFocusGroupScope();
@@ -8352,7 +8353,7 @@
       },
       ...toggleGroupSingleProps
     } = props;
-    const [value, setValue] = useControllableState({
+    const [value, setValue] = useControllableState$1({
       prop: valueProp,
       defaultProp: defaultValue,
       onChange: onValueChange
@@ -8377,7 +8378,7 @@
       },
       ...toggleGroupMultipleProps
     } = props;
-    const [value = [], setValue] = useControllableState({
+    const [value = [], setValue] = useControllableState$1({
       prop: valueProp,
       defaultProp: defaultValue,
       onChange: onValueChange
@@ -8419,16 +8420,16 @@
       const direction = useDirection(dir);
       const commonProps = { role: "group", dir: direction, ...toggleGroupProps };
       return /* @__PURE__ */ jsxRuntime.jsx(ToggleGroupContext, { scope: __scopeToggleGroup, rovingFocus, disabled, children: rovingFocus ? /* @__PURE__ */ jsxRuntime.jsx(
-        Root,
+        Root$1,
         {
           asChild: true,
           ...rovingFocusGroupScope,
           orientation,
           dir: direction,
           loop,
-          children: /* @__PURE__ */ jsxRuntime.jsx(Primitive.div, { ...commonProps, ref: forwardedRef })
+          children: /* @__PURE__ */ jsxRuntime.jsx(Primitive$1.div, { ...commonProps, ref: forwardedRef })
         }
-      ) : /* @__PURE__ */ jsxRuntime.jsx(Primitive.div, { ...commonProps, ref: forwardedRef }) });
+      ) : /* @__PURE__ */ jsxRuntime.jsx(Primitive$1.div, { ...commonProps, ref: forwardedRef }) });
     }
   );
   var ITEM_NAME = "ToggleGroupItem";
@@ -8885,6 +8886,563 @@
     return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "size-5 rounded-full border border-2 border-(--base-a12) border-b-transparent animate-spin" });
   });
   Spinner.displayName = "Spinner";
+  function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+    return function handleEvent(event) {
+      originalEventHandler == null ? void 0 : originalEventHandler(event);
+      if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+        return ourEventHandler == null ? void 0 : ourEventHandler(event);
+      }
+    };
+  }
+  function setRef(ref, value) {
+    if (typeof ref === "function") {
+      return ref(value);
+    } else if (ref !== null && ref !== void 0) {
+      ref.current = value;
+    }
+  }
+  function composeRefs(...refs) {
+    return (node) => {
+      let hasCleanup = false;
+      const cleanups = refs.map((ref) => {
+        const cleanup = setRef(ref, node);
+        if (!hasCleanup && typeof cleanup == "function") {
+          hasCleanup = true;
+        }
+        return cleanup;
+      });
+      if (hasCleanup) {
+        return () => {
+          for (let i = 0; i < cleanups.length; i++) {
+            const cleanup = cleanups[i];
+            if (typeof cleanup == "function") {
+              cleanup();
+            } else {
+              setRef(refs[i], null);
+            }
+          }
+        };
+      }
+    };
+  }
+  function useComposedRefs(...refs) {
+    return React__namespace.useCallback(composeRefs(...refs), refs);
+  }
+  function createContextScope(scopeName, createContextScopeDeps = []) {
+    let defaultContexts = [];
+    function createContext3(rootComponentName, defaultContext) {
+      const BaseContext = React__namespace.createContext(defaultContext);
+      const index2 = defaultContexts.length;
+      defaultContexts = [...defaultContexts, defaultContext];
+      const Provider2 = (props) => {
+        var _a;
+        const { scope, children, ...context } = props;
+        const Context = ((_a = scope == null ? void 0 : scope[scopeName]) == null ? void 0 : _a[index2]) || BaseContext;
+        const value = React__namespace.useMemo(() => context, Object.values(context));
+        return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+      };
+      Provider2.displayName = rootComponentName + "Provider";
+      function useContext2(consumerName, scope) {
+        var _a;
+        const Context = ((_a = scope == null ? void 0 : scope[scopeName]) == null ? void 0 : _a[index2]) || BaseContext;
+        const context = React__namespace.useContext(Context);
+        if (context) return context;
+        if (defaultContext !== void 0) return defaultContext;
+        throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+      }
+      return [Provider2, useContext2];
+    }
+    const createScope = () => {
+      const scopeContexts = defaultContexts.map((defaultContext) => {
+        return React__namespace.createContext(defaultContext);
+      });
+      return function useScope(scope) {
+        const contexts = (scope == null ? void 0 : scope[scopeName]) || scopeContexts;
+        return React__namespace.useMemo(
+          () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+          [scope, contexts]
+        );
+      };
+    };
+    createScope.scopeName = scopeName;
+    return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+  }
+  function composeContextScopes(...scopes) {
+    const baseScope = scopes[0];
+    if (scopes.length === 1) return baseScope;
+    const createScope = () => {
+      const scopeHooks = scopes.map((createScope2) => ({
+        useScope: createScope2(),
+        scopeName: createScope2.scopeName
+      }));
+      return function useComposedScopes(overrideScopes) {
+        const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+          const scopeProps = useScope(overrideScopes);
+          const currentScope = scopeProps[`__scope${scopeName}`];
+          return { ...nextScopes2, ...currentScope };
+        }, {});
+        return React__namespace.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+      };
+    };
+    createScope.scopeName = baseScope.scopeName;
+    return createScope;
+  }
+  function useCallbackRef(callback) {
+    const callbackRef = React__namespace.useRef(callback);
+    React__namespace.useEffect(() => {
+      callbackRef.current = callback;
+    });
+    return React__namespace.useMemo(() => (...args) => {
+      var _a;
+      return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
+    }, []);
+  }
+  function useControllableState({
+    prop,
+    defaultProp,
+    onChange = () => {
+    }
+  }) {
+    const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });
+    const isControlled = prop !== void 0;
+    const value = isControlled ? prop : uncontrolledProp;
+    const handleChange = useCallbackRef(onChange);
+    const setValue = React__namespace.useCallback(
+      (nextValue) => {
+        if (isControlled) {
+          const setter = nextValue;
+          const value2 = typeof nextValue === "function" ? setter(prop) : nextValue;
+          if (value2 !== prop) handleChange(value2);
+        } else {
+          setUncontrolledProp(nextValue);
+        }
+      },
+      [isControlled, prop, setUncontrolledProp, handleChange]
+    );
+    return [value, setValue];
+  }
+  function useUncontrolledState({
+    defaultProp,
+    onChange
+  }) {
+    const uncontrolledState = React__namespace.useState(defaultProp);
+    const [value] = uncontrolledState;
+    const prevValueRef = React__namespace.useRef(value);
+    const handleChange = useCallbackRef(onChange);
+    React__namespace.useEffect(() => {
+      if (prevValueRef.current !== value) {
+        handleChange(value);
+        prevValueRef.current = value;
+      }
+    }, [value, prevValueRef, handleChange]);
+    return uncontrolledState;
+  }
+  function usePrevious(value) {
+    const ref = React__namespace.useRef({ value, previous: value });
+    return React__namespace.useMemo(() => {
+      if (ref.current.value !== value) {
+        ref.current.previous = ref.current.value;
+        ref.current.value = value;
+      }
+      return ref.current.previous;
+    }, [value]);
+  }
+  var useLayoutEffect2 = Boolean(globalThis == null ? void 0 : globalThis.document) ? React__namespace.useLayoutEffect : () => {
+  };
+  function useSize(element) {
+    const [size2, setSize] = React__namespace.useState(void 0);
+    useLayoutEffect2(() => {
+      if (element) {
+        setSize({ width: element.offsetWidth, height: element.offsetHeight });
+        const resizeObserver = new ResizeObserver((entries) => {
+          if (!Array.isArray(entries)) {
+            return;
+          }
+          if (!entries.length) {
+            return;
+          }
+          const entry = entries[0];
+          let width;
+          let height;
+          if ("borderBoxSize" in entry) {
+            const borderSizeEntry = entry["borderBoxSize"];
+            const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+            width = borderSize["inlineSize"];
+            height = borderSize["blockSize"];
+          } else {
+            width = element.offsetWidth;
+            height = element.offsetHeight;
+          }
+          setSize({ width, height });
+        });
+        resizeObserver.observe(element, { box: "border-box" });
+        return () => resizeObserver.unobserve(element);
+      } else {
+        setSize(void 0);
+      }
+    }, [element]);
+    return size2;
+  }
+  var NODES = [
+    "a",
+    "button",
+    "div",
+    "form",
+    "h2",
+    "h3",
+    "img",
+    "input",
+    "label",
+    "li",
+    "nav",
+    "ol",
+    "p",
+    "span",
+    "svg",
+    "ul"
+  ];
+  var Primitive = NODES.reduce((primitive, node) => {
+    const Node2 = React__namespace.forwardRef((props, forwardedRef) => {
+      const { asChild, ...primitiveProps } = props;
+      const Comp = asChild ? reactSlot.Slot : node;
+      if (typeof window !== "undefined") {
+        window[Symbol.for("radix-ui")] = true;
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(Comp, { ...primitiveProps, ref: forwardedRef });
+    });
+    Node2.displayName = `Primitive.${node}`;
+    return { ...primitive, [node]: Node2 };
+  }, {});
+  var SWITCH_NAME = "Switch";
+  var [createSwitchContext, createSwitchScope] = createContextScope(SWITCH_NAME);
+  var [SwitchProvider, useSwitchContext] = createSwitchContext(SWITCH_NAME);
+  var Switch$1 = React__namespace.forwardRef(
+    (props, forwardedRef) => {
+      const {
+        __scopeSwitch,
+        name,
+        checked: checkedProp,
+        defaultChecked,
+        required,
+        disabled,
+        value = "on",
+        onCheckedChange,
+        form,
+        ...switchProps
+      } = props;
+      const [button, setButton] = React__namespace.useState(null);
+      const composedRefs = useComposedRefs(forwardedRef, (node) => setButton(node));
+      const hasConsumerStoppedPropagationRef = React__namespace.useRef(false);
+      const isFormControl = button ? form || !!button.closest("form") : true;
+      const [checked = false, setChecked] = useControllableState({
+        prop: checkedProp,
+        defaultProp: defaultChecked,
+        onChange: onCheckedChange
+      });
+      return /* @__PURE__ */ jsxRuntime.jsxs(SwitchProvider, { scope: __scopeSwitch, checked, disabled, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          Primitive.button,
+          {
+            type: "button",
+            role: "switch",
+            "aria-checked": checked,
+            "aria-required": required,
+            "data-state": getState(checked),
+            "data-disabled": disabled ? "" : void 0,
+            disabled,
+            value,
+            ...switchProps,
+            ref: composedRefs,
+            onClick: composeEventHandlers(props.onClick, (event) => {
+              setChecked((prevChecked) => !prevChecked);
+              if (isFormControl) {
+                hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();
+                if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
+              }
+            })
+          }
+        ),
+        isFormControl && /* @__PURE__ */ jsxRuntime.jsx(
+          BubbleInput,
+          {
+            control: button,
+            bubbles: !hasConsumerStoppedPropagationRef.current,
+            name,
+            value,
+            checked,
+            required,
+            disabled,
+            form,
+            style: { transform: "translateX(-100%)" }
+          }
+        )
+      ] });
+    }
+  );
+  Switch$1.displayName = SWITCH_NAME;
+  var THUMB_NAME = "SwitchThumb";
+  var SwitchThumb$1 = React__namespace.forwardRef(
+    (props, forwardedRef) => {
+      const { __scopeSwitch, ...thumbProps } = props;
+      const context = useSwitchContext(THUMB_NAME, __scopeSwitch);
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Primitive.span,
+        {
+          "data-state": getState(context.checked),
+          "data-disabled": context.disabled ? "" : void 0,
+          ...thumbProps,
+          ref: forwardedRef
+        }
+      );
+    }
+  );
+  SwitchThumb$1.displayName = THUMB_NAME;
+  var BubbleInput = (props) => {
+    const { control, checked, bubbles = true, ...inputProps } = props;
+    const ref = React__namespace.useRef(null);
+    const prevChecked = usePrevious(checked);
+    const controlSize = useSize(control);
+    React__namespace.useEffect(() => {
+      const input = ref.current;
+      const inputProto = window.HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(inputProto, "checked");
+      const setChecked = descriptor.set;
+      if (prevChecked !== checked && setChecked) {
+        const event = new Event("click", { bubbles });
+        setChecked.call(input, checked);
+        input.dispatchEvent(event);
+      }
+    }, [prevChecked, checked, bubbles]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type: "checkbox",
+        "aria-hidden": true,
+        defaultChecked: checked,
+        ...inputProps,
+        tabIndex: -1,
+        ref,
+        style: {
+          ...props.style,
+          ...controlSize,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0
+        }
+      }
+    );
+  };
+  function getState(checked) {
+    return checked ? "checked" : "unchecked";
+  }
+  var Root = Switch$1;
+  var Thumb = SwitchThumb$1;
+  const SwitchContext = React.createContext({});
+  const switchRoot = classVarianceAuthority.cva(
+    [
+      "shrink-0",
+      "overflow-hidden",
+      "relative",
+      "outline-none",
+      "rounded-full",
+      "transition-colors",
+      "ring-1",
+      "ring-(--base-a4)",
+      "bg-(--base-4)",
+      "data-[state=checked]:bg-(--accent-track)",
+      "data-[state=checked]:ring-(--accent-track)"
+    ],
+    {
+      variants: {
+        size: {
+          xs: ["h-5", "w-10"],
+          sm: ["h-6", "w-12"],
+          md: ["h-7", "w-14"],
+          lg: ["h-8", "w-16"],
+          xl: ["h-9", "w-[4.5rem]"]
+        }
+      },
+      defaultVariants: {
+        size: "md"
+      }
+    }
+  );
+  const switchThumb = classVarianceAuthority.cva(
+    [
+      "rounded-full",
+      "block",
+      "flex",
+      "items-center",
+      "justify-center",
+      "transition-transform",
+      "data-[state='checked']:translate-x-[100%]",
+      "bg-(--base-contrast)"
+    ],
+    {
+      variants: {
+        size: {
+          xs: ["h-5", "w-5"],
+          sm: ["h-6", "w-6"],
+          md: ["h-7", "w-7"],
+          lg: ["h-8", "w-8"],
+          xl: ["h-9", "w-9"]
+        }
+      },
+      defaultVariants: {
+        size: "md"
+      }
+    }
+  );
+  const SwitchRoot = React.memo(
+    React.forwardRef((props, ref) => {
+      const providerContext = useProvider();
+      const { className, size: size2 = "md", children, accentColor = providerContext.accentColor, ...rest } = props;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Root,
+        {
+          className: classVarianceAuthority.cx(className, switchRoot({ size: size2 })),
+          ref,
+          "data-accent-color": accentColor,
+          ...rest,
+          children: /* @__PURE__ */ jsxRuntime.jsx(SwitchContext.Provider, { value: { size: size2 }, children })
+        }
+      );
+    })
+  );
+  const SwitchThumb = React.memo(
+    React.forwardRef((props, ref) => {
+      const { className, ...rest } = props;
+      const { size: size2 } = React.useContext(SwitchContext);
+      return /* @__PURE__ */ jsxRuntime.jsx(Thumb, { className: classVarianceAuthority.cx(className, switchThumb({ size: size2 })), ref, ...rest });
+    })
+  );
+  const Switch = {
+    Root: SwitchRoot,
+    Thumb: SwitchThumb
+  };
+  const TableBody = React.forwardRef((props, ref) => {
+    const { className, ...rest } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("tbody", { ref, className: classVarianceAuthority.cx(className), ...rest });
+  });
+  TableBody.displayName = "TableBody";
+  const TableContext = React.createContext({});
+  const tableRootCva = classVarianceAuthority.cva(["text-left border-collapse"], {
+    variants: {
+      variant: {
+        ghost: [],
+        surface: ["border-1", "border-(--accent-a6)", "box-border", "overflow-hidden"]
+      },
+      size: {
+        xs: ["text-xs"],
+        sm: ["text-sm"],
+        md: ["text-md"],
+        lg: ["text-lg"],
+        xl: ["text-xl"]
+      }
+    }
+  });
+  const tableCellCva = classVarianceAuthority.cva([], {
+    variants: {
+      variant: {
+        surface: [],
+        ghost: []
+      },
+      cell: {
+        true: [],
+        false: []
+      },
+      size: {
+        xs: ["p-1"],
+        sm: ["p-2"],
+        md: ["p-3"],
+        lg: ["p-4"],
+        xl: ["p-5"]
+      },
+      border: {
+        grid: ["box-border", "border", "border-(--accent-a6)"],
+        row: ["box-border", "border-b", "border-(--accent-a6)"],
+        col: ["box-border", "border-x", "border-(--accent-a6)"],
+        none: []
+      }
+    },
+    compoundVariants: [
+      {
+        variant: "surface",
+        cell: true,
+        className: ["bg-(--accent-a1)"]
+      },
+      {
+        variant: "surface",
+        cell: false,
+        className: ["bg-(--accent-a2)"]
+      }
+    ]
+  });
+  const TableCell = React.forwardRef((props, ref) => {
+    const { className, ...rest } = props;
+    const { size: size2, border, variant } = React.useContext(TableContext);
+    return /* @__PURE__ */ jsxRuntime.jsx("td", { ref, className: classVarianceAuthority.cx(className, tableCellCva({ size: size2, border, cell: true, variant })), ...rest });
+  });
+  TableCell.displayName = "TableCell";
+  const TableColumnHeaderCell = React.forwardRef(
+    (props, ref) => {
+      const { className, ...rest } = props;
+      const { size: size2, border, variant } = React.useContext(TableContext);
+      return /* @__PURE__ */ jsxRuntime.jsx("th", { ref, className: classVarianceAuthority.cx(className, tableCellCva({ size: size2, border, cell: false, variant })), ...rest });
+    }
+  );
+  TableColumnHeaderCell.displayName = "TableColumnHeaderCell";
+  const TableFooter = React.forwardRef((props, ref) => {
+    const { className, ...rest } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("tfoot", { ref, className: classVarianceAuthority.cx(className), ...rest });
+  });
+  TableFooter.displayName = "TableFooter";
+  const TableHeader = React.forwardRef((props, ref) => {
+    const { className, ...rest } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("thead", { ref, className: classVarianceAuthority.cx(className), ...rest });
+  });
+  TableHeader.displayName = "TableHeader";
+  const TableRoot = React.forwardRef((props, ref) => {
+    const providerContext = useProvider();
+    const { children, className, size: size2 = "md", border = "row", accentColor = "base", variant = "ghost", ...rest } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "table",
+      {
+        ref,
+        className: classVarianceAuthority.cx(
+          className,
+          tableRootCva({ size: size2, variant }),
+          radiusCva({ radius: providerContext.radius, maxLarge: true })
+        ),
+        "data-accent-color": accentColor,
+        ...rest,
+        children: /* @__PURE__ */ jsxRuntime.jsx(TableContext.Provider, { value: { size: size2, border, variant }, children })
+      }
+    );
+  });
+  TableRoot.displayName = "TableRoot";
+  const TableRow = React.forwardRef((props, ref) => {
+    const { className, ...rest } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx("tr", { ref, className: classVarianceAuthority.cx(className), ...rest });
+  });
+  TableRow.displayName = "TableRow";
+  const TableRowHeaderCell = React.forwardRef((props, ref) => {
+    const { className, ...rest } = props;
+    const { size: size2, border, variant } = React.useContext(TableContext);
+    return /* @__PURE__ */ jsxRuntime.jsx("th", { ref, className: classVarianceAuthority.cx(className, tableCellCva({ size: size2, border, cell: true, variant })), ...rest });
+  });
+  TableRowHeaderCell.displayName = "TableRow";
+  const Table = {
+    Root: TableRoot,
+    Header: TableHeader,
+    Body: TableBody,
+    Footer: TableFooter,
+    Row: TableRow,
+    Cell: TableCell,
+    RowHeaderCell: TableRowHeaderCell,
+    ColumnHeaderCell: TableColumnHeaderCell
+  };
   const TabsListContext = React.createContext({});
   const tabsListCva = classVarianceAuthority.cva(["flex", "border-box", "inset-shadow-[0_-1px_0_0_var(--base-a6)]"], {
     variants: {
@@ -9539,6 +10097,18 @@
   exports2.SlideOutV2 = SlideOutV2;
   exports2.SlideOutV3 = SlideOutV3;
   exports2.Spinner = Spinner;
+  exports2.Switch = Switch;
+  exports2.SwitchRoot = SwitchRoot;
+  exports2.SwitchThumb = SwitchThumb;
+  exports2.Table = Table;
+  exports2.TableBody = TableBody;
+  exports2.TableCell = TableCell;
+  exports2.TableColumnHeaderCell = TableColumnHeaderCell;
+  exports2.TableFooter = TableFooter;
+  exports2.TableHeader = TableHeader;
+  exports2.TableRoot = TableRoot;
+  exports2.TableRow = TableRow;
+  exports2.TableRowHeaderCell = TableRowHeaderCell;
   exports2.Tabs = Tabs;
   exports2.TabsList = TabsList;
   exports2.TabsRoot = TabsRoot;
@@ -9563,7 +10133,7 @@
   exports2.usePagesContext = usePagesContext;
   exports2.useProvider = useProvider;
   exports2.useSelectedIndicatorContext = useSelectedIndicatorContext;
-  exports2.useSize = useSize;
+  exports2.useSize = useSize$1;
   exports2.useStopEventPropagation = useStopEventPropagation;
   exports2.useSubContext = useSubContext;
   exports2.useTextFilter = useTextFilter;