@ark-ui/solid 3.0.0-0 → 3.0.0-1

package/dist/cjs/index.js

@@ -0,0 +1,4517 @@
+'use strict';
+
+var web = require('solid-js/web');
+var solid = require('@zag-js/solid');
+var solidJs = require('solid-js');
+var collapsible$1 = require('@zag-js/collapsible');
+var accordion$1 = require('@zag-js/accordion');
+var avatar$1 = require('@zag-js/avatar');
+var anatomy = require('@ark-ui/anatomy');
+var carousel$1 = require('@zag-js/carousel');
+var checkbox$1 = require('@zag-js/checkbox');
+var clipboard$1 = require('@zag-js/clipboard');
+var presence = require('@zag-js/presence');
+var colorPicker$1 = require('@zag-js/color-picker');
+var combobox$1 = require('@zag-js/combobox');
+var datePicker$1 = require('@zag-js/date-picker');
+var dialog$1 = require('@zag-js/dialog');
+var editable$1 = require('@zag-js/editable');
+var fileUpload$1 = require('@zag-js/file-upload');
+var i18nUtils = require('@zag-js/i18n-utils');
+var hoverCard$1 = require('@zag-js/hover-card');
+var menu$1 = require('@zag-js/menu');
+var numberInput$1 = require('@zag-js/number-input');
+var pagination$1 = require('@zag-js/pagination');
+var pinInput$1 = require('@zag-js/pin-input');
+var popover$1 = require('@zag-js/popover');
+var progress$1 = require('@zag-js/progress');
+var radio = require('@zag-js/radio-group');
+var rating = require('@zag-js/rating-group');
+var select$1 = require('@zag-js/select');
+var slider$1 = require('@zag-js/slider');
+var splitter$1 = require('@zag-js/splitter');
+var zagSwitch = require('@zag-js/switch');
+var tabs$1 = require('@zag-js/tabs');
+var tagsInput$1 = require('@zag-js/tags-input');
+var toast$1 = require('@zag-js/toast');
+var toggleGroup$1 = require('@zag-js/toggle-group');
+var tooltip$1 = require('@zag-js/tooltip');
+var treeView$1 = require('@zag-js/tree-view');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var collapsible__namespace = /*#__PURE__*/_interopNamespaceDefault(collapsible$1);
+var accordion__namespace = /*#__PURE__*/_interopNamespaceDefault(accordion$1);
+var avatar__namespace = /*#__PURE__*/_interopNamespaceDefault(avatar$1);
+var carousel__namespace = /*#__PURE__*/_interopNamespaceDefault(carousel$1);
+var checkbox__namespace = /*#__PURE__*/_interopNamespaceDefault(checkbox$1);
+var clipboard__namespace = /*#__PURE__*/_interopNamespaceDefault(clipboard$1);
+var presence__namespace = /*#__PURE__*/_interopNamespaceDefault(presence);
+var colorPicker__namespace = /*#__PURE__*/_interopNamespaceDefault(colorPicker$1);
+var combobox__namespace = /*#__PURE__*/_interopNamespaceDefault(combobox$1);
+var datePicker__namespace = /*#__PURE__*/_interopNamespaceDefault(datePicker$1);
+var dialog__namespace = /*#__PURE__*/_interopNamespaceDefault(dialog$1);
+var editable__namespace = /*#__PURE__*/_interopNamespaceDefault(editable$1);
+var fileUpload__namespace = /*#__PURE__*/_interopNamespaceDefault(fileUpload$1);
+var hoverCard__namespace = /*#__PURE__*/_interopNamespaceDefault(hoverCard$1);
+var menu__namespace = /*#__PURE__*/_interopNamespaceDefault(menu$1);
+var numberInput__namespace = /*#__PURE__*/_interopNamespaceDefault(numberInput$1);
+var pagination__namespace = /*#__PURE__*/_interopNamespaceDefault(pagination$1);
+var pinInput__namespace = /*#__PURE__*/_interopNamespaceDefault(pinInput$1);
+var popover__namespace = /*#__PURE__*/_interopNamespaceDefault(popover$1);
+var progress__namespace = /*#__PURE__*/_interopNamespaceDefault(progress$1);
+var radio__namespace = /*#__PURE__*/_interopNamespaceDefault(radio);
+var rating__namespace = /*#__PURE__*/_interopNamespaceDefault(rating);
+var select__namespace = /*#__PURE__*/_interopNamespaceDefault(select$1);
+var slider__namespace = /*#__PURE__*/_interopNamespaceDefault(slider$1);
+var splitter__namespace = /*#__PURE__*/_interopNamespaceDefault(splitter$1);
+var zagSwitch__namespace = /*#__PURE__*/_interopNamespaceDefault(zagSwitch);
+var tabs__namespace = /*#__PURE__*/_interopNamespaceDefault(tabs$1);
+var tagsInput__namespace = /*#__PURE__*/_interopNamespaceDefault(tagsInput$1);
+var toast__namespace = /*#__PURE__*/_interopNamespaceDefault(toast$1);
+var toggleGroup__namespace = /*#__PURE__*/_interopNamespaceDefault(toggleGroup$1);
+var tooltip__namespace = /*#__PURE__*/_interopNamespaceDefault(tooltip$1);
+var treeView__namespace = /*#__PURE__*/_interopNamespaceDefault(treeView$1);
+
+function getErrorMessage(hook, provider) {
+  return `${hook} returned \`undefined\`. Seems you forgot to wrap component within ${provider}`;
+}
+function createContext(options = {}) {
+  const {
+    strict = true,
+    hookName = 'useContext',
+    providerName = 'Provider',
+    errorMessage
+  } = options;
+  const Context = solidJs.createContext(undefined);
+  function useContext() {
+    const context = solidJs.useContext(Context);
+    if (!context && strict) {
+      const error = new Error(errorMessage ?? getErrorMessage(hookName, providerName));
+      error.name = 'ContextError';
+      Error.captureStackTrace?.(error, useContext);
+      throw error;
+    }
+    return context;
+  }
+  return [Context.Provider, useContext, Context];
+}
+
+const [AccordionProvider, useAccordionContext] = createContext({
+  hookName: 'useAccordionContext',
+  providerName: '<AccordionProvider />'
+});
+
+const AccordionContext = props => props.children(useAccordionContext());
+
+const withAsProp = Component => {
+  const ArkComponent = props => {
+    const [localProps, otherProps] = solidJs.splitProps(props, ['asChild']);
+    if (localProps.asChild) {
+      if (typeof otherProps.children !== 'function') {
+        throw new Error('Children must be a function');
+      }
+
+      // @ts-expect-error TODO improve
+      const fn = userProps => {
+        const [, restProps] = solidJs.splitProps(otherProps, ['children', 'ref']);
+        return {
+          ref: otherProps.ref,
+          ...solid.mergeProps(restProps, userProps)
+        };
+      };
+      return web.memo(() => otherProps.children(fn));
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return web.createComponent(web.Dynamic, web.mergeProps({
+      component: Component
+    }, otherProps));
+  };
+  return ArkComponent;
+};
+function jsxFactory() {
+  const cache = new Map();
+  return new Proxy(withAsProp, {
+    apply(_target, _thisArg, argArray) {
+      return withAsProp(argArray[0]);
+    },
+    get(_, element) {
+      const asElement = element;
+      if (!cache.has(asElement)) {
+        cache.set(asElement, withAsProp(asElement));
+      }
+      return cache.get(asElement);
+    }
+  });
+}
+const ark = jsxFactory();
+
+const [CollapsibleProvider, useCollapsibleContext] = createContext({
+  hookName: 'useCollapsibleContext',
+  providerName: '<CollapsibleProvider />'
+});
+
+const CollapsibleContent = props => {
+  const api = useCollapsibleContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !api().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const CollapsibleContext = props => props.children(useCollapsibleContext());
+
+const createSplitProps = () => (props, keys) => solidJs.splitProps(props, keys);
+
+const [EnvironmentProvider, useEnvironmentContext] = createContext({
+  hookName: 'useEnvironmentContext',
+  providerName: '<EnvironmentProvider />',
+  strict: false
+});
+
+var _tmpl$$c = /*#__PURE__*/web.template(`<span hidden>`);
+const Environment = props => {
+  // eslint-disable-next-line prefer-const
+  let spanRef = undefined;
+
+  // @ts-expect-error TODO fix
+  const currentEnv = solidJs.createMemo(() => () => props.value ?? spanRef?.ownerDocument ?? document);
+  return web.createComponent(EnvironmentProvider, {
+    get value() {
+      return currentEnv();
+    },
+    get children() {
+      return [web.memo(() => props.children), web.memo(() => web.memo(() => !!!props.value)() && (() => {
+        var _el$ = _tmpl$$c();
+        var _ref$ = spanRef;
+        typeof _ref$ === "function" ? web.use(_ref$, _el$) : spanRef = _el$;
+        return _el$;
+      })())];
+    }
+  });
+};
+
+const [RenderStrategyProvider, useRenderStrategyContext] = createContext({
+  hookName: 'useRenderStrategyContext',
+  providerName: '<RenderStrategyProvider />'
+});
+const splitRenderStrategyProps = props => createSplitProps()(props, ['lazyMount', 'unmountOnExit']);
+
+const useCollapsible = props => {
+  const getRootNode = useEnvironmentContext();
+  const [renderStrategyProps, collapsibleProps] = splitRenderStrategyProps(props);
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, collapsibleProps);
+  const [state, send] = solid.useMachine(collapsible__namespace.machine(context), {
+    context
+  });
+  const [wasVisible, setWasVisible] = solidJs.createSignal(false);
+  solidJs.createEffect(() => {
+    const isPresent = api().isVisible;
+    if (isPresent) setWasVisible(true);
+  });
+  const api = solidJs.createMemo(() => collapsible__namespace.connect(state, send, solid.normalizeProps));
+  return solidJs.createMemo(() => ({
+    ...api(),
+    isUnmounted: !api().isVisible && !wasVisible() && renderStrategyProps.lazyMount || renderStrategyProps.unmountOnExit && !api().isVisible && wasVisible()
+  }));
+};
+
+const CollapsibleRoot = props => {
+  const [useCollapsibleProps, localProps] = createSplitProps()(props, ['dir', 'disabled', 'getRootNode', 'id', 'ids', 'lazyMount', 'onExitComplete', 'onOpenChange', 'open', 'unmountOnExit']);
+  const api = useCollapsible(useCollapsibleProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(CollapsibleProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const CollapsibleTrigger = props => {
+  const api = useCollapsibleContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var collapsible = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Content: CollapsibleContent,
+  Context: CollapsibleContext,
+  Root: CollapsibleRoot,
+  Trigger: CollapsibleTrigger
+});
+
+const [AccordionItemProvider, useAccordionItemContext] = createContext({
+  hookName: 'useAccordionItemContext',
+  providerName: '<AccordionItemProvider />'
+});
+const [AccordionItemPropsProvider, useAccordionItemPropsContext] = createContext({
+  hookName: 'useAccordionItemPropsContext',
+  providerName: '<AccordionItemPropsProvider />'
+});
+
+const AccordionItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['value', 'disabled']);
+  const context = useAccordionContext();
+  const renderStrategyProps = useRenderStrategyContext();
+  const mergedProps = solid.mergeProps(() => context().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => context().getItemState(itemProps));
+  const itemContentProps = context().getItemContentProps(itemProps);
+  return web.createComponent(AccordionItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(AccordionItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(CollapsibleRoot, web.mergeProps({
+            get open() {
+              return itemState().isOpen;
+            },
+            get ids() {
+              return {
+                content: itemContentProps.id
+              };
+            }
+          }, renderStrategyProps, mergedProps));
+        }
+      });
+    }
+  });
+};
+
+const AccordionItemContent = props => {
+  const context = useAccordionContext();
+  const itemProps = useAccordionItemPropsContext();
+  const itemContentProps = solidJs.createMemo(() => {
+    const ownProps = context().getItemContentProps(itemProps);
+    delete ownProps.hidden;
+    return ownProps;
+  });
+  const mergedProps = solid.mergeProps(itemContentProps, props);
+  return web.createComponent(CollapsibleContent, mergedProps);
+};
+
+const AccordionItemIndicator = props => {
+  const context = useAccordionContext();
+  const itemProps = useAccordionItemPropsContext();
+  const mergedProps = solid.mergeProps(() => context().getItemIndicatorProps(itemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const AccordionItemTrigger = props => {
+  const context = useAccordionContext();
+  const itemProps = useAccordionItemPropsContext();
+  const collapsible = useCollapsibleContext();
+  const mergedProps = solid.mergeProps(() => context().getItemTriggerProps(itemProps), props);
+  const [ariaControls, buttonProps] = solidJs.splitProps(mergedProps, ['aria-controls']);
+  return web.createComponent(ark.button, web.mergeProps(buttonProps, () => !collapsible().isUnmounted && ariaControls));
+};
+
+const useAccordion = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solidJs.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(accordion__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => accordion__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const AccordionRoot = props => {
+  const [renderStrategyProps, accordionProps] = splitRenderStrategyProps(props);
+  const [useAccordionProps, localProps] = createSplitProps()(accordionProps, ['collapsible', 'dir', 'disabled', 'getRootNode', 'id', 'ids', 'multiple', 'onFocusChange', 'onValueChange', 'orientation', 'value']);
+  const api = useAccordion(useAccordionProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(AccordionProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const AccordionItemContext = props => props.children(useAccordionItemContext());
+
+var accordion = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: AccordionContext,
+  Item: AccordionItem,
+  ItemContent: AccordionItemContent,
+  ItemContext: AccordionItemContext,
+  ItemIndicator: AccordionItemIndicator,
+  ItemTrigger: AccordionItemTrigger,
+  Root: AccordionRoot
+});
+
+const [AvatarProvider, useAvatarContext] = createContext({
+  hookName: 'useAvatarContext',
+  providerName: '<AvatarProvider />'
+});
+
+const AvatarContext = props => props.children(useAvatarContext());
+
+const AvatarFallback = props => {
+  const context = useAvatarContext();
+  const mergedProps = solid.mergeProps(() => context().fallbackProps, props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const AvatarImage = props => {
+  const context = useAvatarContext();
+  const mergedProps = solid.mergeProps(() => context().imageProps, props);
+  return web.createComponent(ark.img, mergedProps);
+};
+
+const useAvatar = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(avatar__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => avatar__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const AvatarRoot = props => {
+  const [useAvatarProps, localProps] = createSplitProps()(props, ['dir', 'getRootNode', 'id', 'onLoadingStatusChange']);
+  const context = useAvatar(useAvatarProps);
+  const mergedProps = solid.mergeProps(() => context().rootProps, localProps);
+  return web.createComponent(AvatarProvider, {
+    value: context,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var avatar = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: AvatarContext,
+  Fallback: AvatarFallback,
+  Image: AvatarImage,
+  Root: AvatarRoot
+});
+
+const [CarouselProvider, useCarouselContext] = createContext({
+  hookName: 'useCarouselContext',
+  providerName: '<CarouselProvider />'
+});
+
+const CarouselContext = props => props.children(useCarouselContext());
+
+const CarouselControl = props => {
+  const mergedProps = solid.mergeProps(() => anatomy.carouselAnatomy.build().control.attrs, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const CarouselIndicator = props => {
+  const [indicatorProps, localProps] = createSplitProps()(props, ['index', 'readOnly']);
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().getIndicatorProps(indicatorProps), localProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const CarouselIndicatorGroup = props => {
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().indicatorGroupProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const CarouselItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['index']);
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const CarouselItemGroup = props => {
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().itemGroupProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const CarouselNextTrigger = props => {
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().nextTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const CarouselPrevTrigger = props => {
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().prevTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const useCarousel = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(carousel__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => carousel__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const CarouselRoot = props => {
+  const [useCarouselProps, localProps] = createSplitProps()(props, ['align', 'dir', 'getRootNode', 'id', 'ids', 'index', 'loop', 'onIndexChange', 'orientation', 'slidesPerView', 'spacing']);
+  const api = useCarousel(useCarouselProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(CarouselProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const CarouselViewport = props => {
+  const api = useCarouselContext();
+  const mergedProps = solid.mergeProps(() => api().viewportProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+var carousel = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: CarouselContext,
+  Control: CarouselControl,
+  Indicator: CarouselIndicator,
+  IndicatorGroup: CarouselIndicatorGroup,
+  Item: CarouselItem,
+  ItemGroup: CarouselItemGroup,
+  NextTrigger: CarouselNextTrigger,
+  PrevTrigger: CarouselPrevTrigger,
+  Root: CarouselRoot,
+  Viewport: CarouselViewport
+});
+
+const [CheckboxProvider, useCheckboxContext] = createContext({
+  hookName: 'useCheckboxContext',
+  providerName: '<CheckboxProvider />'
+});
+
+const CheckboxContext = props => props.children(useCheckboxContext());
+
+var _tmpl$$b = /*#__PURE__*/web.template(`<input>`);
+const CheckboxControl = props => {
+  const api = useCheckboxContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return [web.createComponent(ark.div, mergedProps), (() => {
+    var _el$ = _tmpl$$b();
+    web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+    return _el$;
+  })()];
+};
+
+const CheckboxIndicator = props => {
+  const api = useCheckboxContext();
+  const mergedProps = solid.mergeProps(() => api().indicatorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const CheckboxLabel = props => {
+  const checkbox = useCheckboxContext();
+  const mergedProps = solid.mergeProps(() => checkbox().labelProps, props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const useCheckbox = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(checkbox__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => checkbox__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const CheckboxRoot = props => {
+  const [useCheckboxProps, labelprops] = createSplitProps()(props, ['checked', 'dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'invalid', 'name', 'onCheckedChange', 'required', 'value']);
+  const api = useCheckbox(useCheckboxProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, labelprops);
+  return web.createComponent(CheckboxProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.label, mergedProps);
+    }
+  });
+};
+
+var checkbox = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: CheckboxContext,
+  Control: CheckboxControl,
+  Indicator: CheckboxIndicator,
+  Label: CheckboxLabel,
+  Root: CheckboxRoot
+});
+
+const [ClipboardProvider, useClipboardContext] = createContext({
+  hookName: 'useClipboardContext',
+  providerName: '<ClipboardProvider />'
+});
+
+const ClipboardContext = props => props.children(useClipboardContext());
+
+const ClipboardControl = props => {
+  const api = useClipboardContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ClipboardIndicator = props => {
+  const [indicatorProps, localProps] = createSplitProps()(props, ['copied']);
+  const api = useClipboardContext();
+  const mergedProps = solid.mergeProps(api().getIndicatorProps({
+    copied: api().isCopied
+  }), localProps);
+  // @ts-expect-error TODO fix
+  const getChildren = solidJs.children(() => localProps.children);
+  return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+    get children() {
+      return web.createComponent(solidJs.Show, {
+        get when() {
+          return api().isCopied;
+        },
+        get fallback() {
+          return getChildren();
+        },
+        get children() {
+          return indicatorProps.copied;
+        }
+      });
+    }
+  }));
+};
+
+const ClipboardInput = props => {
+  const api = useClipboardContext();
+  const mergedProps = solid.mergeProps(() => api().inputProps, props);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const ClipboardLabel = props => {
+  const api = useClipboardContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useClipboard = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(clipboard__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => clipboard__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const ClipboardRoot = props => {
+  const [useClipboardProps, localProps] = createSplitProps()(props, ['getRootNode', 'id', 'ids', 'value', 'timeout', 'onCopyStatusChange']);
+  const api = useClipboard(useClipboardProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(ClipboardProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ClipboardTrigger = props => {
+  const api = useClipboardContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var clipboard = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: ClipboardContext,
+  Control: ClipboardControl,
+  Indicator: ClipboardIndicator,
+  Input: ClipboardInput,
+  Label: ClipboardLabel,
+  Root: ClipboardRoot,
+  Trigger: ClipboardTrigger
+});
+
+const [ColorPickerAreaProvider, useColorPickerAreaContext] = createContext({
+  hookName: 'useColorPickerAreaContext',
+  providerName: '<ColorPickerAreaProvider />'
+});
+
+const [ColorPickerProvider, useColorPickerContext] = createContext({
+  hookName: 'useColorPickerContext',
+  providerName: '<ColorPickerProvider />'
+});
+
+const ColorPickerArea = props => {
+  const [channelProps, divprops] = createSplitProps()(props, ['xChannel', 'yChannel']);
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getAreaProps(channelProps), divprops);
+  return web.createComponent(ColorPickerAreaProvider, {
+    value: channelProps,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ColorPickerAreaBackground = props => {
+  const colorAreaProps = useColorPickerAreaContext();
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getAreaBackgroundProps(colorAreaProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerAreaThumb = props => {
+  const colorAreaProps = useColorPickerAreaContext();
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getAreaThumbProps(colorAreaProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerChannelInput = props => {
+  const [channelProps, inputProps] = createSplitProps()(props, ['channel', 'orientation']);
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getChannelInputProps(channelProps), inputProps);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const [ColorPickerChannelSliderProvider, useColorPickerChannelSliderContext] = createContext({
+  hookName: 'useColorPickerChannelSliderContext',
+  providerName: '<ColorPickerChannelSliderProvider />'
+});
+
+const ColorPickerChannelSlider = props => {
+  const [channelProps, localProps] = createSplitProps()(props, ['channel', 'orientation']);
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getChannelSliderProps(channelProps), localProps);
+  return web.createComponent(ColorPickerChannelSliderProvider, {
+    value: channelProps,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ColorPickerChannelSliderThumb = props => {
+  const sliderContext = useColorPickerChannelSliderContext();
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getChannelSliderThumbProps(sliderContext), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerChannelSliderTrack = props => {
+  const sliderContext = useColorPickerChannelSliderContext();
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getChannelSliderTrackProps(sliderContext), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const splitPresenceProps = props => createSplitProps()(props, ['lazyMount', 'onExitComplete', 'present', 'unmountOnExit']);
+
+const usePresence = props => {
+  const [renderStrategyProps, context] = splitRenderStrategyProps(props);
+  const [wasEverPresent, setWasEverPresent] = solidJs.createSignal(false);
+  const [state, send] = solid.useMachine(presence__namespace.machine(context), {
+    context
+  });
+  const api = solidJs.createMemo(() => presence__namespace.connect(state, send, solid.normalizeProps));
+  solidJs.createEffect(() => {
+    const isPresent = api().isPresent;
+    if (isPresent) setWasEverPresent(true);
+  });
+  return solidJs.createMemo(() => ({
+    isUnmounted: !api().isPresent && !wasEverPresent() && renderStrategyProps.lazyMount || renderStrategyProps.unmountOnExit && !api().isPresent && wasEverPresent(),
+    isPresent: api().isPresent,
+    presenceProps: {
+      ref: api().setNode,
+      hidden: !api().isPresent,
+      'data-state': context.present ? 'open' : 'closed'
+    }
+  }));
+};
+
+const Presence = props => {
+  const [presenceProps, localProps] = splitPresenceProps(props);
+  const api = usePresence(presenceProps);
+  const mergedProps = solid.mergeProps(() => api().presenceProps, localProps);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !api().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+        "data-scope": "presence",
+        "data-part": "root"
+      }));
+    }
+  });
+};
+
+const [PresenceProvider, usePresenceContext] = createContext({
+  hookName: 'usePresenceContext',
+  providerName: '<PresenceProvider />'
+});
+
+const ColorPickerContent = props => {
+  const api = useColorPickerContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ColorPickerContext = props => props.children(useColorPickerContext());
+
+const ColorPickerControl = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerEyeDropperTrigger = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().eyeDropperTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const ColorPickerFormatSelect = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().formatSelectProps, props);
+  return web.createComponent(ark.select, web.mergeProps(mergedProps, {
+    get children() {
+      return web.createComponent(solidJs.Index, {
+        each: ['rgba', 'hsla', 'hsba'],
+        children: format => web.createComponent(ark.option, {
+          get value() {
+            return format();
+          },
+          get children() {
+            return format();
+          }
+        })
+      });
+    }
+  }));
+};
+
+const ColorPickerFormatTrigger = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().formatTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const ColorPickerLabel = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const ColorPickerPositioner = props => {
+  const api = useColorPickerContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useColorPicker = props => {
+  const [local, rest] = solidJs.splitProps(props, ['value']);
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps(() => ({
+    id: solidJs.createUniqueId(),
+    getRootNode,
+    value: local.value ? colorPicker__namespace.parse(local.value) : undefined
+  }), rest);
+  const [state, send] = solid.useMachine(colorPicker__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => colorPicker__namespace.connect(state, send, solid.normalizeProps));
+};
+
+var _tmpl$$a = /*#__PURE__*/web.template(`<input>`);
+const ColorPickerRoot = props => {
+  const [presenceProps, colorPickerProps] = splitPresenceProps(props);
+  const [useColorPickerProps, localProps] = createSplitProps()(colorPickerProps, ['closeOnSelect', 'dir', 'disabled', 'format', 'getRootNode', 'id', 'ids', 'initialFocusEl', 'name', 'name', 'onFocusOutside', 'onFormatChange', 'onInteractOutside', 'onOpenChange', 'onPointerDownOutside', 'onValueChange', 'onValueChangeEnd', 'open', 'positioning', 'readOnly', 'value']);
+  const api = useColorPicker(useColorPickerProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(ColorPickerProvider, {
+    value: api,
+    get children() {
+      return [web.createComponent(PresenceProvider, {
+        value: apiPresence,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      }), (() => {
+        var _el$ = _tmpl$$a();
+        web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+        return _el$;
+      })()];
+    }
+  });
+};
+
+const [ColorPickerSwatchProvider, useColorPickerSwatchContext] = createContext({
+  hookName: 'useColorPickerSwatchContext',
+  providerName: '<ColorPickerSwatchProvider />'
+});
+
+const ColorPickerSwatch = props => {
+  const [swatchProps, localProps] = createSplitProps()(props, ['respectAlpha', 'value']);
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getSwatchProps(swatchProps), localProps);
+  return web.createComponent(ColorPickerSwatchProvider, {
+    value: swatchProps,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ColorPickerSwatchGroup = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().swatchGroupProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerSwatchIndicator = props => {
+  const api = useColorPickerContext();
+  const swatchProps = useColorPickerSwatchContext();
+  const mergedProps = solid.mergeProps(() => api().getSwatchIndicatorProps(swatchProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerSwatchTrigger = props => {
+  const [triggerProps, localProps] = createSplitProps()(props, ['value', 'disabled']);
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getSwatchTriggerProps(triggerProps), localProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const ColorPickerTransparencyGrid = props => {
+  const [gridProps, localProps] = createSplitProps()(props, ['size']);
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().getTransparencyGridProps(gridProps), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ColorPickerTrigger = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const ColorPickerValueText = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => anatomy.colorPickerAnatomy.build().valueText.attrs, props);
+  return web.createComponent(ark.span, web.mergeProps(mergedProps, {
+    get children() {
+      return api().valueAsString || props.children;
+    }
+  }));
+};
+
+const ColorPickerView = props => {
+  const api = useColorPickerContext();
+  const mergedProps = solid.mergeProps(() => anatomy.colorPickerAnatomy.build().view.attrs, props);
+
+  // TODO @segunadebayo
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return api().format === props.format;
+    },
+    get children() {
+      return web.createComponent(ark.div, web.mergeProps({
+        get ["data-format"]() {
+          return props.format;
+        }
+      }, mergedProps));
+    }
+  });
+};
+
+var colorPicker = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Area: ColorPickerArea,
+  AreaBackground: ColorPickerAreaBackground,
+  AreaThumb: ColorPickerAreaThumb,
+  ChannelInput: ColorPickerChannelInput,
+  ChannelSlider: ColorPickerChannelSlider,
+  ChannelSliderThumb: ColorPickerChannelSliderThumb,
+  ChannelSliderTrack: ColorPickerChannelSliderTrack,
+  Content: ColorPickerContent,
+  Context: ColorPickerContext,
+  Control: ColorPickerControl,
+  EyeDropperTrigger: ColorPickerEyeDropperTrigger,
+  FormatSelect: ColorPickerFormatSelect,
+  FormatTrigger: ColorPickerFormatTrigger,
+  Label: ColorPickerLabel,
+  Positioner: ColorPickerPositioner,
+  Root: ColorPickerRoot,
+  Swatch: ColorPickerSwatch,
+  SwatchGroup: ColorPickerSwatchGroup,
+  SwatchIndicator: ColorPickerSwatchIndicator,
+  SwatchTrigger: ColorPickerSwatchTrigger,
+  TransparencyGrid: ColorPickerTransparencyGrid,
+  Trigger: ColorPickerTrigger,
+  ValueText: ColorPickerValueText,
+  View: ColorPickerView
+});
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const [ComboboxProvider, useComboboxContext] = createContext({
+  hookName: 'useComboboxContext',
+  providerName: '<ComboboxProvider />'
+});
+
+const ComboboxClearTrigger = props => {
+  const combobox = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => combobox().clearTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const ComboboxContent = props => {
+  const api = useComboboxContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ComboboxContext = props => props.children(useComboboxContext());
+
+const ComboboxControl = props => {
+  const combobox = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => combobox().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ComboboxInput = props => {
+  const combobox = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => combobox().inputProps, props);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const [ComboboxItemProvider, useComboboxItemContext] = createContext({
+  hookName: 'useComboboxItemContext',
+  providerName: '<ComboboxItemProvider />'
+});
+const [ComboboxItemPropsProvider, useComboboxItemPropsContext] = createContext({
+  hookName: 'useComboboxItemPropsContext',
+  providerName: '<ComboboxItemPropsProvider />'
+});
+
+const ComboboxItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['item']);
+  const api = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => api().getItemState(itemProps));
+  return web.createComponent(ComboboxItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(ComboboxItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const ComboboxItemContext = props => props.children(useComboboxItemContext());
+
+const ComboboxItemGroup = props => {
+  const [groupProps, localProps] = createSplitProps()(props, ['id']);
+  const combobox = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => combobox().getItemGroupProps(groupProps), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ComboboxItemGroupLabel = props => {
+  const [labelProps, localProps] = createSplitProps()(props, ['for']);
+  const api = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => api().getItemGroupLabelProps({
+    htmlFor: labelProps.for
+  }), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ComboboxItemIndicator = props => {
+  const combobox = useComboboxContext();
+  const itemProps = useComboboxItemPropsContext();
+  const mergedProps = solid.mergeProps(() => combobox().getItemIndicatorProps(itemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ComboboxItemText = props => {
+  const api = useComboboxContext();
+  const itemProps = useComboboxItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemTextProps(itemProps), props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const ComboboxLabel = props => {
+  const combobox = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => combobox().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const ComboboxPositioner = props => {
+  const api = useComboboxContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useCombobox = props => {
+  const [collectionOptions, rest] = createSplitProps()(props, ['isItemDisabled', 'itemToValue', 'itemToString', 'items']);
+  const collection = () => combobox__namespace.collection(collectionOptions);
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode,
+    collection: collection()
+  }, rest);
+  const [state, send] = solid.useMachine(combobox__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => combobox__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const ComboboxRoot = props => {
+  const [presenceProps, comboboxProps] = splitPresenceProps(props);
+  const [useComboboxProps, localProps] = createSplitProps()(comboboxProps, ['allowCustomValue', 'autoFocus', 'closeOnSelect', 'dir', 'disabled', 'form', 'getRootNode', 'highlightedValue', 'id', 'ids', 'inputBehavior', 'inputValue', 'invalid', 'isItemDisabled', 'items', 'itemToString', 'itemToValue', 'loop', 'multiple', 'name', 'onFocusOutside', 'onHighlightChange', 'onInputValueChange', 'onInteractOutside', 'onOpenChange', 'onOpenChange', 'onPointerDownOutside', 'onValueChange', 'openOnClick', 'placeholder', 'positioning', 'readOnly', 'selectionBehavior', 'selectOnBlur', 'translations', 'value']);
+  const api = useCombobox(useComboboxProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(ComboboxProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(PresenceProvider, {
+        value: apiPresence,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const ComboboxTrigger = props => {
+  const combobox = useComboboxContext();
+  const mergedProps = solid.mergeProps(() => combobox().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var combobox = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ClearTrigger: ComboboxClearTrigger,
+  Content: ComboboxContent,
+  Context: ComboboxContext,
+  Control: ComboboxControl,
+  Input: ComboboxInput,
+  Item: ComboboxItem,
+  ItemContext: ComboboxItemContext,
+  ItemGroup: ComboboxItemGroup,
+  ItemGroupLabel: ComboboxItemGroupLabel,
+  ItemIndicator: ComboboxItemIndicator,
+  ItemText: ComboboxItemText,
+  Label: ComboboxLabel,
+  Positioner: ComboboxPositioner,
+  Root: ComboboxRoot,
+  Trigger: ComboboxTrigger
+});
+
+const [DatePickerProvider, useDatePickerContext] = createContext({
+  hookName: 'useDatePickerContext',
+  providerName: '<DatePickerProvider />'
+});
+
+const DatePickerClearTrigger = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().clearTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DatePickerContent = props => {
+  const api = useDatePickerContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const DatePickerContext = props => props.children(useDatePickerContext());
+
+const DatePickerControl = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const DatePickerInput = props => {
+  const [inputProps, localProps] = createSplitProps()(props, ['index']);
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().getInputProps(inputProps), localProps);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const DatePickerLabel = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+var _tmpl$$9 = /*#__PURE__*/web.template(`<option>`);
+const DatePickerMonthSelect = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().monthSelectProps, props);
+  return web.createComponent(ark.select, web.mergeProps(mergedProps, {
+    get children() {
+      return api().getMonths().map(month => (() => {
+        var _el$ = _tmpl$$9();
+        web.insert(_el$, () => month.label);
+        web.effect(() => _el$.value = month.value);
+        return _el$;
+      })());
+    }
+  }));
+};
+
+const [DatePickerViewProvider, useDatePickerViewContext] = createContext({
+  hookName: 'useDatePickerViewContext',
+  providerName: '<DatePickerViewProvider />'
+});
+
+const DatePickerNextTrigger = props => {
+  const api = useDatePickerContext();
+  const viewProps = useDatePickerViewContext();
+  const mergedProps = solid.mergeProps(() => api().getNextTriggerProps(viewProps), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DatePickerPositioner = props => {
+  const api = useDatePickerContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const DatePickerPresetTrigger = props => {
+  const [presetTriggerProps, localProps] = createSplitProps()(props, ['value']);
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().getPresetTriggerProps(presetTriggerProps), localProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DatePickerPrevTrigger = props => {
+  const api = useDatePickerContext();
+  const viewProps = useDatePickerViewContext();
+  const mergedProps = solid.mergeProps(() => api().getPrevTriggerProps(viewProps), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DatePickerRangeText = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().rangeTextProps, props);
+  return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+    get children() {
+      return api().visibleRangeText.start;
+    }
+  }));
+};
+
+const useDatePicker = props => {
+  const getRootNode = useEnvironmentContext();
+  const [localProps, restProps] = solidJs.splitProps(props, ['value', 'focusedValue', 'min', 'max']);
+  const context = solid.mergeProps(() => ({
+    id: solidJs.createUniqueId(),
+    getRootNode,
+    focusedValue: localProps.focusedValue ? datePicker__namespace.parse(localProps.focusedValue) : undefined,
+    value: localProps.value ? datePicker__namespace.parse(localProps.value) : undefined,
+    max: localProps.max ? datePicker__namespace.parse(localProps.max) : undefined,
+    min: localProps.min ? datePicker__namespace.parse(localProps.min) : undefined
+  }), restProps);
+  const [state, send] = solid.useMachine(datePicker__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => datePicker__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const DatePickerRoot = props => {
+  const [presenceProps, datePickerProps] = splitPresenceProps(props);
+  const [useDatePickerProps, localProps] = createSplitProps()(datePickerProps, ['closeOnSelect', 'dir', 'disabled', 'fixedWeeks', 'focusedValue', 'format', 'getRootNode', 'id', 'ids', 'isDateUnavailable', 'isDateUnavailable', 'locale', 'max', 'min', 'modal', 'name', 'numOfMonths', 'onFocusChange', 'onOpenChange', 'onValueChange', 'onViewChange', 'open', 'positioning', 'readOnly', 'selectionMode', 'startOfWeek', 'timeZone', 'translations', 'value', 'view']);
+  const api = useDatePicker(useDatePickerProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(DatePickerProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(PresenceProvider, {
+        value: apiPresence,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const [DatePickerTableProvider, useDatePickerTableContext] = createContext({
+  hookName: 'useDatePickerTableContext',
+  providerName: '<DatePickerTableProvider />'
+});
+
+const DatePickerTable = props => {
+  const [{
+    columns
+  }, localProps] = createSplitProps()(props, ['columns']);
+  const api = useDatePickerContext();
+  const viewProps = useDatePickerViewContext();
+  const tableProps = {
+    columns,
+    id: solidJs.createUniqueId(),
+    ...viewProps
+  };
+  const mergedProps = solid.mergeProps(() => api().getTableProps(tableProps), localProps);
+  return web.createComponent(DatePickerTableProvider, {
+    value: tableProps,
+    get children() {
+      return web.createComponent(ark.table, mergedProps);
+    }
+  });
+};
+
+const DatePickerTableBody = props => {
+  const api = useDatePickerContext();
+  const tableProps = useDatePickerTableContext();
+  const mergedProps = solid.mergeProps(() => api().getTableBodyProps(tableProps), props);
+  return web.createComponent(ark.tbody, mergedProps);
+};
+
+const [DatePickerTableCellProvider, useDatePickerTableCellContext] = createContext({
+  hookName: 'useDatePickerTableCellContext',
+  providerName: '<DatePickerTableCellProvider />'
+});
+
+const DatePickerTableCell = props => {
+  const [cellProps, localProps] = createSplitProps()(props, ['disabled', 'value', 'visibleRange', 'columns']);
+  const api = useDatePickerContext();
+  const viewProps = useDatePickerViewContext();
+  const tableCellProps = {
+    day: api().getDayTableCellProps,
+    month: api().getMonthTableCellProps,
+    year: api().getYearTableCellProps
+    // @ts-expect-error use filter guard
+  }[viewProps.view](cellProps);
+  const mergedProps = solid.mergeProps(() => tableCellProps, localProps);
+  return web.createComponent(DatePickerTableCellProvider, {
+    value: cellProps,
+    get children() {
+      return web.createComponent(ark.td, mergedProps);
+    }
+  });
+};
+
+const DatePickerTableCellTrigger = props => {
+  const api = useDatePickerContext();
+  const cellProps = useDatePickerTableCellContext();
+  const viewProps = useDatePickerViewContext();
+  const triggerProps = {
+    day: api().getDayTableCellTriggerProps,
+    month: api().getMonthTableCellTriggerProps,
+    year: api().getYearTableCellTriggerProps
+    // @ts-expect-error value is number filter
+  }[viewProps.view](cellProps);
+  const mergedProps = solid.mergeProps(() => triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DatePickerTableHead = props => {
+  const api = useDatePickerContext();
+  const tableProps = useDatePickerTableContext();
+  const mergedProps = solid.mergeProps(() => api().getTableHeadProps(tableProps), props);
+  return web.createComponent(ark.thead, mergedProps);
+};
+
+const DatePickerTableHeader = props => {
+  const api = useDatePickerContext();
+  const tableProps = useDatePickerTableContext();
+  const mergedProps = solid.mergeProps(() => api().getTableHeaderProps(tableProps), props);
+  return web.createComponent(ark.th, mergedProps);
+};
+
+const DatePickerTableRow = props => {
+  const api = useDatePickerContext();
+  const tableProps = useDatePickerTableContext();
+  const mergedProps = solid.mergeProps(() => api().getTableRowProps(tableProps), props);
+  return web.createComponent(ark.tr, mergedProps);
+};
+
+const DatePickerTrigger = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DatePickerView = props => {
+  const [viewProps, localProps] = createSplitProps()(props, ['view']);
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => anatomy.datePickerAnatomy.build().view.attrs, localProps);
+  return web.createComponent(DatePickerViewProvider, {
+    value: viewProps,
+    get children() {
+      return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+        get hidden() {
+          return api().view !== viewProps.view;
+        }
+      }));
+    }
+  });
+};
+
+const DatePickerViewControl = props => {
+  const api = useDatePickerContext();
+  const viewProps = useDatePickerViewContext();
+  const mergedProps = solid.mergeProps(() => api().getViewControlProps(viewProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const DatePickerViewTrigger = props => {
+  const api = useDatePickerContext();
+  const viewProps = useDatePickerViewContext();
+  const mergedProps = solid.mergeProps(() => api().getViewTriggerProps(viewProps), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var _tmpl$$8 = /*#__PURE__*/web.template(`<option>`);
+const DatePickerYearSelect = props => {
+  const api = useDatePickerContext();
+  const mergedProps = solid.mergeProps(() => api().yearSelectProps, props);
+  return web.createComponent(ark.select, web.mergeProps(mergedProps, {
+    get children() {
+      return getYearsRange({
+        from: 1_000,
+        to: 4_000
+      }).map(year => (() => {
+        var _el$ = _tmpl$$8();
+        _el$.value = year;
+        web.insert(_el$, year);
+        return _el$;
+      })());
+    }
+  }));
+};
+function getYearsRange(range) {
+  const years = [];
+  for (let year = range.from; year <= range.to; year += 1) {
+    years.push(year);
+  }
+  return years;
+}
+
+var datePicker = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ClearTrigger: DatePickerClearTrigger,
+  Content: DatePickerContent,
+  Context: DatePickerContext,
+  Control: DatePickerControl,
+  Input: DatePickerInput,
+  Label: DatePickerLabel,
+  MonthSelect: DatePickerMonthSelect,
+  NextTrigger: DatePickerNextTrigger,
+  Positioner: DatePickerPositioner,
+  PresetTrigger: DatePickerPresetTrigger,
+  PrevTrigger: DatePickerPrevTrigger,
+  RangeText: DatePickerRangeText,
+  Root: DatePickerRoot,
+  Table: DatePickerTable,
+  TableBody: DatePickerTableBody,
+  TableCell: DatePickerTableCell,
+  TableCellTrigger: DatePickerTableCellTrigger,
+  TableHead: DatePickerTableHead,
+  TableHeader: DatePickerTableHeader,
+  TableRow: DatePickerTableRow,
+  Trigger: DatePickerTrigger,
+  View: DatePickerView,
+  ViewControl: DatePickerViewControl,
+  ViewTrigger: DatePickerViewTrigger,
+  YearSelect: DatePickerYearSelect
+});
+
+const [DialogProvider, useDialogContext] = createContext({
+  hookName: 'useDialogContext',
+  providerName: '<DialogProvider />'
+});
+
+const DialogBackdrop = props => {
+  const api = useDialogContext();
+  const renderStrategyProps = useRenderStrategyContext();
+  const presenceApi = usePresence(solid.mergeProps(renderStrategyProps, () => ({
+    present: api().isOpen
+  })));
+  const mergedProps = solid.mergeProps(() => api().backdropProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const DialogCloseTrigger = props => {
+  const dialog = useDialogContext();
+  const mergedProps = solid.mergeProps(() => dialog().closeTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const DialogContent = props => {
+  const api = useDialogContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const DialogContext = props => props.children(useDialogContext());
+
+const DialogDescription = props => {
+  const dialog = useDialogContext();
+  const mergedProps = solid.mergeProps(() => dialog().descriptionProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const DialogPositioner = props => {
+  const api = useDialogContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useDialog = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(dialog__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => dialog__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const DialogRoot = props => {
+  const [presenceProps, dialogProps] = splitPresenceProps(props);
+  const [renderStrategyProps] = splitRenderStrategyProps(presenceProps);
+  const [useDialogProps, localProps] = createSplitProps()(dialogProps, ['aria-label', 'closeOnEscapeKeyDown', 'closeOnInteractOutside', 'dir', 'finalFocusEl', 'getRootNode', 'id', 'ids', 'initialFocusEl', 'modal', 'onEscapeKeyDown', 'onFocusOutside', 'onInteractOutside', 'onOpenChange', 'onPointerDownOutside', 'open', 'preventScroll', 'restoreFocus', 'role', 'trapFocus']);
+  const api = useDialog(useDialogProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  return web.createComponent(DialogProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return web.createComponent(PresenceProvider, {
+            value: apiPresence,
+            get children() {
+              return localProps.children;
+            }
+          });
+        }
+      });
+    }
+  });
+};
+
+const DialogTitle = props => {
+  const dialog = useDialogContext();
+  const mergedProps = solid.mergeProps(() => dialog().titleProps, props);
+  return web.createComponent(ark.h2, mergedProps);
+};
+
+const DialogTrigger = props => {
+  const api = useDialogContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, () => ({
+    'aria-controls': presenceApi().isUnmounted && null
+  }), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var dialog = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Backdrop: DialogBackdrop,
+  CloseTrigger: DialogCloseTrigger,
+  Content: DialogContent,
+  Context: DialogContext,
+  Description: DialogDescription,
+  Positioner: DialogPositioner,
+  Root: DialogRoot,
+  Title: DialogTitle,
+  Trigger: DialogTrigger
+});
+
+const [EditableProvider, useEditableContext] = createContext({
+  hookName: 'useEditableContext',
+  providerName: '<EditableProvider />'
+});
+
+const EditableArea = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().areaProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const EditableCancelTrigger = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().cancelTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const EditableContext = props => props.children(useEditableContext());
+
+const EditableControl = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const EditableEditTrigger = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().editTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const EditableInput = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().inputProps, props);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const EditableLabel = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const EditablePreview = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().previewProps, props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const useEditable = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(editable__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => editable__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const EditableRoot = props => {
+  const [useEditableProps, localProps] = createSplitProps()(props, ['activationMode', 'autoResize', 'dir', 'disabled', 'finalFocusEl', 'form', 'getRootNode', 'id', 'ids', 'invalid', 'maxLength', 'name', 'onEdit', 'onFocusOutside', 'onInteractOutside', 'onPointerDownOutside', 'onValueChange', 'onValueCommit', 'onValueRevert', 'placeholder', 'readOnly', 'selectOnFocus', 'startWithEditView', 'submitMode', 'translations', 'value']);
+  const api = useEditable(useEditableProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(EditableProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const EditableSubmitTrigger = props => {
+  const api = useEditableContext();
+  const mergedProps = solid.mergeProps(() => api().submitTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var editable = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Area: EditableArea,
+  CancelTrigger: EditableCancelTrigger,
+  Context: EditableContext,
+  Control: EditableControl,
+  EditTrigger: EditableEditTrigger,
+  Input: EditableInput,
+  Label: EditableLabel,
+  Preview: EditablePreview,
+  Root: EditableRoot,
+  SubmitTrigger: EditableSubmitTrigger
+});
+
+const [FileUploadProvider, useFileUploadContext] = createContext({
+  hookName: 'useFileUploadContext',
+  providerName: '<FileUploadProvider />'
+});
+
+const FileUploadContext = props => props.children(useFileUploadContext());
+
+var _tmpl$$7 = /*#__PURE__*/web.template(`<input>`);
+const FileUploadDropzone = props => {
+  const api = useFileUploadContext();
+  const mergedProps = solid.mergeProps(() => api().dropzoneProps, props);
+  return [web.createComponent(ark.div, mergedProps), (() => {
+    var _el$ = _tmpl$$7();
+    web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+    return _el$;
+  })()];
+};
+
+const [FileUploadItemProvider, useFileUploadItemContext] = createContext({
+  hookName: 'useFileUploadItemContext',
+  providerName: '<FileUploadItemProvider />'
+});
+
+const FileUploadItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['file']);
+  const api = useFileUploadContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  return web.createComponent(FileUploadItemProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(ark.li, mergedProps);
+    }
+  });
+};
+
+const FileUploadItemDeleteTrigger = props => {
+  const api = useFileUploadContext();
+  const item = useFileUploadItemContext();
+  const mergedProps = solid.mergeProps(() => api().getItemDeleteTriggerProps(item), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const FileUploadItemGroup = props => {
+  const api = useFileUploadContext();
+  const mergedProps = solid.mergeProps(() => api().itemGroupProps, props);
+  return web.createComponent(ark.ul, mergedProps);
+};
+
+const FileUploadItemName = props => {
+  const api = useFileUploadContext();
+  const item = useFileUploadItemContext();
+  const mergedProps = solid.mergeProps(() => api().getItemNameProps(item), props);
+  return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+    get children() {
+      return props.children || item.file.name;
+    }
+  }));
+};
+
+const FileUploadItemPreview = props => {
+  const api = useFileUploadContext();
+  const item = useFileUploadItemContext();
+  const mergedProps = solid.mergeProps(() => api().getItemPreviewProps(item), props);
+  if (!item.file.type.match(props.type ?? '.*')) return null;
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const FileUploadItemPreviewImage = props => {
+  const api = useFileUploadContext();
+  const item = useFileUploadItemContext();
+  const [url, setUrl] = solidJs.createSignal('');
+  api().createFileUrl(item.file, url => setUrl(url));
+  const mergedProps = solid.mergeProps(api().getItemPreviewImageProps({
+    ...item,
+    url: url()
+  }), props);
+  return web.createComponent(ark.img, mergedProps);
+};
+
+const FileUploadItemSizeText = props => {
+  const api = useFileUploadContext();
+  const item = useFileUploadItemContext();
+  const mergedProps = solid.mergeProps(() => api().getItemSizeTextProps(item), props);
+  return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+    get children() {
+      return props.children || api().getFileSize(item.file);
+    }
+  }));
+};
+
+const FileUploadLabel = props => {
+  const api = useFileUploadContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useFileUpload = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(fileUpload__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => fileUpload__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const FileUploadRoot = props => {
+  const [fileUploadProps, localProps] = createSplitProps()(props, ['accept', 'allowDrop', 'capture', 'dir', 'directory', 'disabled', 'getRootNode', 'id', 'ids', 'locale', 'maxFiles', 'maxFileSize', 'minFileSize', 'name', 'onFileAccept', 'onFileChange', 'onFileReject', 'translations', 'validate']);
+  const api = useFileUpload(fileUploadProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(FileUploadProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const FileUploadTrigger = props => {
+  const api = useFileUploadContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var fileUpload = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: FileUploadContext,
+  Dropzone: FileUploadDropzone,
+  Item: FileUploadItem,
+  ItemDeleteTrigger: FileUploadItemDeleteTrigger,
+  ItemGroup: FileUploadItemGroup,
+  ItemName: FileUploadItemName,
+  ItemPreview: FileUploadItemPreview,
+  ItemPreviewImage: FileUploadItemPreviewImage,
+  ItemSizeText: FileUploadItemSizeText,
+  Label: FileUploadLabel,
+  Root: FileUploadRoot,
+  Trigger: FileUploadTrigger
+});
+
+const [LocaleContextProvider, useLocaleContext] = createContext({
+  hookName: 'useEnvironmentContext',
+  providerName: '<EnvironmentProvider />',
+  strict: false,
+  defaultValue: () => ({
+    dir: 'ltr',
+    locale: 'en-US'
+  })
+});
+
+const LocaleProvider = props => {
+  const [localeProps, restProps] = solidJs.splitProps(props, ['locale', 'defaultLocale']);
+  const [locale, setLocale] = solidJs.createSignal(localeProps.defaultLocale || localeProps.locale || 'en-US');
+  const getRootNode = useEnvironmentContext();
+  solidJs.createEffect(() => {
+    const cleanup = i18nUtils.trackLocale({
+      locale: localeProps.locale,
+      getRootNode,
+      onLocaleChange(locale) {
+        setLocale(locale.locale);
+      }
+    });
+    solidJs.onCleanup(cleanup);
+  });
+  const context = solidJs.createMemo(() => ({
+    locale: locale(),
+    dir: i18nUtils.isRTL(locale()) ? 'rtl' : 'ltr'
+  }));
+  return web.createComponent(LocaleContextProvider, {
+    value: context,
+    get children() {
+      return restProps.children;
+    }
+  });
+};
+
+const FormatByte = props => {
+  const [valueProps, intlProps] = solidJs.splitProps(props, ['value']);
+  const ctx = useLocaleContext();
+  const text = solidJs.createMemo(() => i18nUtils.formatBytes(valueProps.value, ctx().locale, intlProps));
+  return text;
+};
+
+const FormatNumber = props => {
+  const [valueProps, intlProps] = solidJs.splitProps(props, ['value']);
+  const ctx = useLocaleContext();
+  const text = solidJs.createMemo(() => i18nUtils.formatNumber(valueProps.value, ctx().locale, intlProps));
+  return text;
+};
+
+var format = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Byte: FormatByte,
+  Number: FormatNumber
+});
+
+const [HoverCardProvider, useHoverCardContext] = createContext({
+  hookName: 'useHoverCardContext',
+  providerName: '<HoverCardProvider />'
+});
+
+const HoverCardArrow = props => {
+  const hoverCard = useHoverCardContext();
+  const mergedProps = solid.mergeProps(() => hoverCard().arrowProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const HoverCardArrowTip = props => {
+  const hoverCard = useHoverCardContext();
+  const mergedProps = solid.mergeProps(() => hoverCard().arrowTipProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const HoverCardContent = props => {
+  const api = useHoverCardContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const HoverCardContext = props => props.children(useHoverCardContext());
+
+const HoverCardPositioner = props => {
+  const api = useHoverCardContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useHoverCard = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(hoverCard__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => hoverCard__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const HoverCardRoot = props => {
+  const [presenceProps, hoverCardProps] = splitPresenceProps(props);
+  const [useHoverCardProps, localProps] = createSplitProps()(hoverCardProps, ['closeDelay', 'dir', 'getRootNode', 'id', 'ids', 'onOpenChange', 'open', 'openDelay', 'positioning']);
+  const api = useHoverCard(useHoverCardProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  return web.createComponent(HoverCardProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(PresenceProvider, {
+        value: apiPresence,
+        get children() {
+          return localProps.children;
+        }
+      });
+    }
+  });
+};
+
+const HoverCardTrigger = props => {
+  const hoverCard = useHoverCardContext();
+  const mergedProps = solid.mergeProps(() => hoverCard().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var hoverCard = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Arrow: HoverCardArrow,
+  ArrowTip: HoverCardArrowTip,
+  Content: HoverCardContent,
+  Context: HoverCardContext,
+  Positioner: HoverCardPositioner,
+  Root: HoverCardRoot,
+  Trigger: HoverCardTrigger
+});
+
+const [MenuProvider, useMenuContext] = createContext({
+  hookName: 'useMenuContext',
+  providerName: '<MenuProvider />',
+  strict: false
+});
+
+const MenuArrow = props => {
+  const context = useMenuContext();
+  const mergedProps = solid.mergeProps(() => context().arrowProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const MenuArrowTip = props => {
+  const context = useMenuContext();
+  const mergedProps = solid.mergeProps(() => context().arrowTipProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const MenuContent = props => {
+  const context = useMenuContext();
+  const presenceContext = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => context().contentProps, () => presenceContext().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceContext().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const MenuContext = props => props.children(useMenuContext());
+
+const MenuContextTrigger = props => {
+  const context = useMenuContext();
+  const mergedProps = solid.mergeProps(() => context().contextTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const MenuIndicator = props => {
+  const context = useMenuContext();
+  const mergedProps = solid.mergeProps(() => context().indicatorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const [MenuItemProvider, useMenuItemContext] = createContext({
+  hookName: 'useMenuItemContext',
+  providerName: '<MenuItemProvider />'
+});
+
+const MenuItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['closeOnSelect', 'disabled', 'value', 'valueText']);
+  const context = useMenuContext();
+  const mergedProps = solid.mergeProps(() => context().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => context().getItemState(itemProps));
+  return web.createComponent(MenuItemProvider, {
+    value: itemState,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const MenuItemContext = props => props.children(useMenuItemContext());
+
+const [MenuItemGroupProvider, useMenuItemGroupContext] = createContext({
+  hookName: 'useMenuItemGroupContext',
+  providerName: '<MenuItemGroupProvider />'
+});
+
+const MenuItemGroup = props => {
+  const [optionalItemGroupProps, localProps] = createSplitProps()(props, ['id']);
+  const itemGroupProps = solid.mergeProps({
+    id: solidJs.createUniqueId()
+  }, optionalItemGroupProps);
+  const menu = useMenuContext();
+  const mergedProps = solid.mergeProps(() => menu().getItemGroupProps(itemGroupProps), localProps);
+  return web.createComponent(MenuItemGroupProvider, {
+    value: itemGroupProps,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const MenuItemGroupLabel = props => {
+  const context = useMenuContext();
+  const itemGroupContext = useMenuItemGroupContext();
+  const mergedProps = solid.mergeProps(context().getItemGroupLabelProps({
+    htmlFor: itemGroupContext.id
+  }), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+createContext({
+  hookName: 'useMenuOptionItemContext',
+  providerName: '<MenuOptionItemProvider />'
+});
+const [MenuOptionItemPropsProvider, useMenuOptionItemPropsContext] = createContext({
+  hookName: 'useMenuOptionItemPropsContext',
+  providerName: '<MenuOptionItemPropsProvider />'
+});
+
+const MenuItemIndicator = props => {
+  const context = useMenuContext();
+  const optionItemProps = useMenuOptionItemPropsContext();
+  const mergedProps = solid.mergeProps(() => context().getItemIndicatorProps(optionItemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const MenuItemText = props => {
+  const context = useMenuContext();
+  const optionItemProps = useMenuOptionItemPropsContext();
+  const mergedProps = solid.mergeProps(() => context().getItemTextProps(optionItemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const MenuPositioner = props => {
+  const context = useMenuContext();
+  const presence = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => context().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presence().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useMenu = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send, machine] = solid.useMachine(menu__namespace.machine(context), {
+    context
+  });
+  const api = solidJs.createMemo(() => menu__namespace.connect(state, send, solid.normalizeProps));
+  return {
+    api,
+    machine
+  };
+};
+
+const [MenuMachineProvider, useMenuMachineContext] = createContext({
+  hookName: 'useMenuMachineContext',
+  providerName: '<MenuMachineProvider />',
+  strict: false
+});
+
+const [MenuTriggerItemProvider, useMenuTriggerItemContext] = createContext({
+  hookName: 'useMenuMachineContext',
+  providerName: '<MenuMachineProvider />',
+  strict: false
+});
+
+const MenuRoot = props => {
+  const [presenceProps, menuProps] = splitPresenceProps(props);
+  const [useMenuProps, localProps] = createSplitProps()(menuProps, ['anchorPoint', 'aria-label', 'closeOnSelect', 'dir', 'getRootNode', 'highlightedValue', 'id', 'ids', 'loop', 'onEscapeKeyDown', 'onFocusOutside', 'onHighlightChange', 'onInteractOutside', 'onOpenChange', 'onPointerDownOutside', 'onSelect', 'open', 'positioning']);
+  const parentApi = useMenuContext();
+  const parentMachine = useMenuMachineContext();
+  const menu = useMenu(useMenuProps);
+  const presenceApi = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: menu.api().isOpen
+  })));
+  solidJs.createEffect(() => {
+    if (!parentMachine) return;
+    parentApi?.().setChild(menu.machine);
+    menu.api().setParent(parentMachine);
+  });
+  const triggerItemContext = () => parentApi?.().getTriggerItemProps(menu.api());
+  return web.createComponent(MenuTriggerItemProvider, {
+    value: triggerItemContext,
+    get children() {
+      return web.createComponent(MenuMachineProvider, {
+        get value() {
+          return menu.machine;
+        },
+        get children() {
+          return web.createComponent(MenuProvider, {
+            get value() {
+              return menu.api;
+            },
+            get children() {
+              return web.createComponent(PresenceProvider, {
+                value: presenceApi,
+                get children() {
+                  return localProps.children;
+                }
+              });
+            }
+          });
+        }
+      });
+    }
+  });
+};
+
+const MenuSeparator = props => {
+  const menu = useMenuContext();
+  const mergedProps = solid.mergeProps(() => menu().separatorProps, props);
+  return web.createComponent(ark.hr, mergedProps);
+};
+
+const MenuTrigger = props => {
+  const api = useMenuContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, () => ({
+    'aria-controls': presenceApi().isUnmounted && null
+  }), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const MenuTriggerItem = props => {
+  const getTriggerItemProps = useMenuTriggerItemContext();
+  const mergedProps = solid.mergeProps(() => getTriggerItemProps?.(), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const MenuCheckboxItem = props => {
+  const [partialOptionItemProps, localProps] = createSplitProps()(props, ['checked', 'closeOnSelect', 'disabled', 'onCheckedChange', 'value', 'valueText']);
+  const optionItemProps = solid.mergeProps(partialOptionItemProps, {
+    type: 'checkbox'
+  });
+  const context = useMenuContext();
+  const mergedProps = solid.mergeProps(() => context().getOptionItemProps(optionItemProps), localProps);
+  const itemState = solidJs.createMemo(() => context().getItemState(optionItemProps));
+  return web.createComponent(MenuOptionItemPropsProvider, {
+    value: optionItemProps,
+    get children() {
+      return web.createComponent(MenuItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const MenuRadioItem = props => {
+  const [partialItemProps, localProps] = createSplitProps()(props, ['closeOnSelect', 'disabled', 'value', 'valueText']);
+  const context = useMenuContext();
+  const itemGroup = useMenuItemGroupContext();
+  const optionItemProps = solid.mergeProps(partialItemProps, () => ({
+    type: 'radio',
+    checked: itemGroup.value === partialItemProps.value,
+    onCheckedChange: () => itemGroup.onValueChange?.({
+      value: partialItemProps.value
+    })
+  }));
+  const mergedProps = solid.mergeProps(() => context().getOptionItemProps(optionItemProps), localProps);
+  const itemState = solidJs.createMemo(() => context().getItemState(optionItemProps));
+  return web.createComponent(MenuOptionItemPropsProvider, {
+    value: optionItemProps,
+    get children() {
+      return web.createComponent(MenuItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const MenuRadioItemGroup = props => {
+  const [optionalItemGroupProps, localProps] = createSplitProps()(props, ['id', 'onValueChange', 'value']);
+  const context = useMenuContext();
+  const itemGroupProps = solid.mergeProps({
+    id: solidJs.createUniqueId()
+  }, optionalItemGroupProps);
+  const mergedProps = solid.mergeProps(() => context().getItemGroupProps(itemGroupProps), localProps);
+  return web.createComponent(MenuItemGroupProvider, {
+    value: itemGroupProps,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var menu = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Arrow: MenuArrow,
+  ArrowTip: MenuArrowTip,
+  CheckboxItem: MenuCheckboxItem,
+  Content: MenuContent,
+  Context: MenuContext,
+  ContextTrigger: MenuContextTrigger,
+  Indicator: MenuIndicator,
+  Item: MenuItem,
+  ItemContext: MenuItemContext,
+  ItemGroup: MenuItemGroup,
+  ItemGroupLabel: MenuItemGroupLabel,
+  ItemIndicator: MenuItemIndicator,
+  ItemText: MenuItemText,
+  Positioner: MenuPositioner,
+  RadioItem: MenuRadioItem,
+  RadioItemGroup: MenuRadioItemGroup,
+  Root: MenuRoot,
+  Separator: MenuSeparator,
+  Trigger: MenuTrigger,
+  TriggerItem: MenuTriggerItem
+});
+
+const [NumberInputProvider, useNumberInputContext] = createContext({
+  hookName: 'useNumberInputContext',
+  providerName: '<NumberInputProvider />'
+});
+
+const NumberInputContext = props => props.children(useNumberInputContext());
+
+const NumberInputControl = props => {
+  const api = useNumberInputContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const NumberInputDecrementTrigger = props => {
+  const api = useNumberInputContext();
+  const mergedProps = solid.mergeProps(() => api().decrementTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const NumberInputIncrementTrigger = props => {
+  const api = useNumberInputContext();
+  const mergedProps = solid.mergeProps(() => api().incrementTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const NumberInputInput = props => {
+  const api = useNumberInputContext();
+  const mergedProps = solid.mergeProps(() => api().inputProps, props);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const NumberInputLabel = props => {
+  const api = useNumberInputContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useNumberInput = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(numberInput__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => numberInput__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const NumberInputRoot = props => {
+  const [useNumberInputProps, localProps] = createSplitProps()(props, ['allowMouseWheel', 'allowOverflow', 'clampValueOnBlur', 'dir', 'disabled', 'focusInputOnChange', 'form', 'formatOptions', 'getRootNode', 'id', 'ids', 'inputMode', 'invalid', 'locale', 'max', 'min', 'name', 'onFocusChange', 'onValueChange', 'onValueInvalid', 'pattern', 'readOnly', 'spinOnPress', 'step', 'translations', 'value']);
+  const api = useNumberInput(useNumberInputProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(NumberInputProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const NumberInputScrubber = props => {
+  const api = useNumberInputContext();
+  const mergedProps = solid.mergeProps(() => api().scrubberProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+var numberInput = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: NumberInputContext,
+  Control: NumberInputControl,
+  DecrementTrigger: NumberInputDecrementTrigger,
+  IncrementTrigger: NumberInputIncrementTrigger,
+  Input: NumberInputInput,
+  Label: NumberInputLabel,
+  Root: NumberInputRoot,
+  Scrubber: NumberInputScrubber
+});
+
+const [PaginationProvider, usePaginationContext] = createContext({
+  hookName: 'usePaginationContext',
+  providerName: '<PaginationProvider />'
+});
+
+const PaginationContext = props => props.children(usePaginationContext());
+
+const PaginationEllipsis = props => {
+  const [ellipsisProps, localProps] = createSplitProps()(props, ['index']);
+  const api = usePaginationContext();
+  const mergedProps = solid.mergeProps(() => api().getEllipsisProps(ellipsisProps), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PaginationItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['value', 'type']);
+  const api = usePaginationContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const PaginationNextTrigger = props => {
+  const api = usePaginationContext();
+  const mergedProps = solid.mergeProps(() => api().nextTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const PaginationPrevTrigger = props => {
+  const api = usePaginationContext();
+  const mergedProps = solid.mergeProps(() => api().prevTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const usePagination = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(pagination__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => pagination__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const PaginationRoot = props => {
+  const [usePaginationProps, localProps] = createSplitProps()(props, ['count', 'dir', 'getRootNode', 'id', 'ids', 'onPageChange', 'page', 'pageSize', 'siblingCount', 'translations', 'type']);
+  const api = usePagination(usePaginationProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(PaginationProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.nav, mergedProps);
+    }
+  });
+};
+
+var pagination = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: PaginationContext,
+  Ellipsis: PaginationEllipsis,
+  Item: PaginationItem,
+  NextTrigger: PaginationNextTrigger,
+  PrevTrigger: PaginationPrevTrigger,
+  Root: PaginationRoot
+});
+
+const [PinInputProvider, usePinInputContext] = createContext({
+  hookName: 'usePinInputContext',
+  providerName: '<PinInputProvider />'
+});
+
+const PinInputContext = props => props.children(usePinInputContext());
+
+const PinInputControl = props => {
+  const api = usePinInputContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PinInputInput = props => {
+  const [inputProps, localProps] = createSplitProps()(props, ['index']);
+  const api = usePinInputContext();
+  const mergedProps = solid.mergeProps(() => api().getInputProps(inputProps), localProps);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const PinInputLabel = props => {
+  const api = usePinInputContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const usePinInput = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(pinInput__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => pinInput__namespace.connect(state, send, solid.normalizeProps));
+};
+
+var _tmpl$$6 = /*#__PURE__*/web.template(`<input>`);
+const PinInputRoot = props => {
+  const [usePinInputProps, localProps] = createSplitProps()(props, ['autoFocus', 'blurOnComplete', 'dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'invalid', 'mask', 'name', 'onValueChange', 'onValueComplete', 'onValueInvalid', 'otp', 'pattern', 'placeholder', 'selectOnFocus', 'translations', 'type', 'value']);
+  const api = usePinInput(usePinInputProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(PinInputProvider, {
+    value: api,
+    get children() {
+      return [web.createComponent(ark.div, mergedProps), (() => {
+        var _el$ = _tmpl$$6();
+        web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+        return _el$;
+      })()];
+    }
+  });
+};
+
+var pinInput = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: PinInputContext,
+  Control: PinInputControl,
+  Input: PinInputInput,
+  Label: PinInputLabel,
+  Root: PinInputRoot
+});
+
+const [PopoverProvider, usePopoverContext] = createContext({
+  hookName: 'usePopoverContext',
+  providerName: '<PopoverProvider />'
+});
+
+const PopoverAnchor = props => {
+  const api = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => api().anchorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PopoverArrow = props => {
+  const popover = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => popover().arrowProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PopoverArrowTip = props => {
+  const popover = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => popover().arrowTipProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PopoverCloseTrigger = props => {
+  const api = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => api().closeTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const PopoverContent = props => {
+  const api = usePopoverContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const PopoverContext = props => props.children(usePopoverContext());
+
+const PopoverDescription = props => {
+  const api = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => api().descriptionProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PopoverIndicator = props => {
+  const popover = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => popover().indicatorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PopoverPositioner = props => {
+  const api = usePopoverContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const usePopover = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(popover__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => popover__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const PopoverRoot = props => {
+  const [presenceProps, popoverProps] = splitPresenceProps(props);
+  const [usePopoverProps, localProps] = createSplitProps()(popoverProps, ['autoFocus', 'closeOnEsc', 'closeOnInteractOutside', 'dir', 'getRootNode', 'id', 'ids', 'initialFocusEl', 'modal', 'onEscapeKeyDown', 'onFocusOutside', 'onInteractOutside', 'onOpenChange', 'onPointerDownOutside', 'open', 'portalled', 'positioning']);
+  const api = usePopover(usePopoverProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  return web.createComponent(PopoverProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(PresenceProvider, {
+        value: apiPresence,
+        get children() {
+          return localProps.children;
+        }
+      });
+    }
+  });
+};
+
+const PopoverTitle = props => {
+  const api = usePopoverContext();
+  const mergedProps = solid.mergeProps(() => api().titleProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const PopoverTrigger = props => {
+  const api = usePopoverContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, () => ({
+    'aria-controls': presenceApi().isUnmounted && null
+  }), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var popover = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Anchor: PopoverAnchor,
+  Arrow: PopoverArrow,
+  ArrowTip: PopoverArrowTip,
+  CloseTrigger: PopoverCloseTrigger,
+  Content: PopoverContent,
+  Context: PopoverContext,
+  Description: PopoverDescription,
+  Indicator: PopoverIndicator,
+  Positioner: PopoverPositioner,
+  Root: PopoverRoot,
+  Title: PopoverTitle,
+  Trigger: PopoverTrigger
+});
+
+const [ProgressProvider, useProgressContext] = createContext({
+  hookName: 'useProgressContext',
+  providerName: '<ProgressProvider />'
+});
+
+const ProgressCircle = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().circleProps, props);
+  return web.createComponent(ark.svg, mergedProps);
+};
+
+const ProgressCircleRange = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().circleRangeProps, props);
+  return web.createComponent(ark.circle, mergedProps);
+};
+
+const ProgressCircleTrack = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().circleTrackProps, props);
+  return web.createComponent(ark.circle, mergedProps);
+};
+
+const ProgressContext = props => props.children(useProgressContext());
+
+const ProgressLabel = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const ProgressRange = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().rangeProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const useProgress = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(progress__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => progress__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const ProgressRoot = props => {
+  const [progressProps, localProps] = createSplitProps()(props, ['dir', 'getRootNode', 'id', 'max', 'min', 'orientation', 'translations', 'value']);
+  const api = useProgress(progressProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(ProgressProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const ProgressTrack = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().trackProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ProgressValueText = props => {
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().valueTextProps, props);
+  return web.createComponent(ark.span, web.mergeProps(mergedProps, {
+    get children() {
+      return props.children || api().valueAsString;
+    }
+  }));
+};
+
+const ProgressView = props => {
+  const [state, localProps] = createSplitProps()(props, ['state']);
+  const api = useProgressContext();
+  const mergedProps = solid.mergeProps(() => api().getViewProps(state), localProps);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+var progress = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Circle: ProgressCircle,
+  CircleRange: ProgressCircleRange,
+  CircleTrack: ProgressCircleTrack,
+  Context: ProgressContext,
+  Label: ProgressLabel,
+  Range: ProgressRange,
+  Root: ProgressRoot,
+  Track: ProgressTrack,
+  ValueText: ProgressValueText,
+  View: ProgressView
+});
+
+const [RadioGroupProvider, useRadioGroupContext] = createContext({
+  hookName: 'useRadioGroupContext',
+  providerName: '<RadioGroupProvider />'
+});
+
+const RadioGroupIndicator = props => {
+  const api = useRadioGroupContext();
+  const mergedProps = solid.mergeProps(() => api().indicatorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const [RadioGroupItemProvider, useRadioGroupItemContext] = createContext({
+  hookName: 'useRadioGroupItemContext',
+  providerName: '<RadioGroupItemProvider />'
+});
+const [RadioGroupItemPropsProvider, useRadioGroupItemPropsContext] = createContext({
+  hookName: 'useRadioGroupItemPropsContext',
+  providerName: '<RadioGroupItemPropsProvider />'
+});
+
+const RadioGroupItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['value', 'disabled', 'invalid']);
+  const api = useRadioGroupContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => api().getItemState(itemProps));
+  return web.createComponent(RadioGroupItemProvider, {
+    value: itemState,
+    get children() {
+      return web.createComponent(RadioGroupItemPropsProvider, {
+        value: itemProps,
+        get children() {
+          return web.createComponent(ark.label, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+var _tmpl$$5 = /*#__PURE__*/web.template(`<input>`);
+const RadioGroupItemControl = props => {
+  const api = useRadioGroupContext();
+  const itemProps = useRadioGroupItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemControlProps(itemProps), props);
+  return [web.createComponent(ark.div, mergedProps), (() => {
+    var _el$ = _tmpl$$5();
+    web.spread(_el$, web.mergeProps(() => api().getItemHiddenInputProps(itemProps)), false, false);
+    return _el$;
+  })()];
+};
+
+const RadioGroupItemText = props => {
+  const api = useRadioGroupContext();
+  const itemProps = useRadioGroupItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemTextProps(itemProps), props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const RadioGroupLabel = props => {
+  const api = useRadioGroupContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useRadioGroup = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(radio__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => radio__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const RadioGroupRoot = props => {
+  const [useRadioGroupProps, localProps] = createSplitProps()(props, ['dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'name', 'onValueChange', 'orientation', 'value']);
+  const api = useRadioGroup(useRadioGroupProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(RadioGroupProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var radioGroup = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Indicator: RadioGroupIndicator,
+  Item: RadioGroupItem,
+  ItemControl: RadioGroupItemControl,
+  ItemText: RadioGroupItemText,
+  Label: RadioGroupLabel,
+  Root: RadioGroupRoot
+});
+
+const [RatingGroupProvider, useRatingGroupContext] = createContext({
+  hookName: 'useRatingGroupContext',
+  providerName: '<RatingGroupProvider />'
+});
+
+const RatingGroupContext = props => props.children(useRatingGroupContext());
+
+var _tmpl$$4 = /*#__PURE__*/web.template(`<input>`);
+const RatingGroupControl = props => {
+  const api = useRatingGroupContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return [web.createComponent(ark.div, mergedProps), (() => {
+    var _el$ = _tmpl$$4();
+    web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+    return _el$;
+  })()];
+};
+
+const [RatingGroupItemProvider, useRatingGroupItemContext] = createContext({
+  hookName: 'useRatingGroupItemContext',
+  providerName: '<RatingGroupItemProvider />'
+});
+
+const RatingGroupItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['index']);
+  const api = useRatingGroupContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => api().getItemState(itemProps));
+  return web.createComponent(RatingGroupItemProvider, {
+    value: itemState,
+    get children() {
+      return web.createComponent(ark.span, mergedProps);
+    }
+  });
+};
+
+const RatingGroupItemContext = props => props.children(useRatingGroupItemContext());
+
+const RatingGroupLabel = props => {
+  const api = useRatingGroupContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useRatingGroup = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(rating__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => rating__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const RatingGroupRoot = props => {
+  const [useRatingProps, localProps] = createSplitProps()(props, ['allowHalf', 'autoFocus', 'count', 'dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'name', 'onHoverChange', 'onValueChange', 'readOnly', 'translations', 'value']);
+  const api = useRatingGroup(useRatingProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(RatingGroupProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var ratingGroup = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: RatingGroupContext,
+  Control: RatingGroupControl,
+  Item: RatingGroupItem,
+  ItemContext: RatingGroupItemContext,
+  Label: RatingGroupLabel,
+  Root: RatingGroupRoot
+});
+
+const [SegmentGroupProvider, useSegmentGroupContext] = createContext({
+  hookName: 'useSegmentGroupContext',
+  providerName: '<SegmentGroupProvider />'
+});
+
+const SegmentGroupContext = props => props.children(useSegmentGroupContext());
+
+const SegmentGroupIndicator = props => {
+  const api = useSegmentGroupContext();
+  const mergedProps = solid.mergeProps(() => api().indicatorProps, anatomy.segmentGroupAnatomy.build().indicator.attrs, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const [SegmentGroupItemProvider, useSegmentGroupItemContext] = createContext({
+  hookName: 'useSegmentGroupItemContext',
+  providerName: '<SegmentGroupItemProvider />'
+});
+const [SegmentGroupItemPropsProvider, useSegmentGroupItemPropsContext] = createContext({
+  hookName: 'useSegmentGroupItemPropsContext',
+  providerName: '<SegmentGroupItemPropsProvider />'
+});
+
+const SegmentGroupItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['value', 'disabled', 'invalid']);
+  const api = useSegmentGroupContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), anatomy.segmentGroupAnatomy.build().item.attrs, localProps);
+  const itemState = solidJs.createMemo(() => api().getItemState(itemProps));
+  return web.createComponent(SegmentGroupItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(SegmentGroupItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(ark.label, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const SegmentGroupItemContext = props => props.children(useSegmentGroupItemContext());
+
+var _tmpl$$3 = /*#__PURE__*/web.template(`<input>`);
+const SegmentGroupItemControl = props => {
+  const api = useSegmentGroupContext();
+  const itemProps = useSegmentGroupItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemControlProps(itemProps), anatomy.segmentGroupAnatomy.build().itemControl.attrs, props);
+  return [web.createComponent(ark.div, mergedProps), (() => {
+    var _el$ = _tmpl$$3();
+    web.spread(_el$, web.mergeProps(() => api().getItemHiddenInputProps(itemProps)), false, false);
+    return _el$;
+  })()];
+};
+
+const SegmentGroupItemText = props => {
+  const api = useSegmentGroupContext();
+  const itemProps = useSegmentGroupItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemTextProps(itemProps), anatomy.segmentGroupAnatomy.build().itemText.attrs, props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const SegmentGroupLabel = props => {
+  const api = useSegmentGroupContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, anatomy.segmentGroupAnatomy.build().label.attrs, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useSegmentGroup = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(radio__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => radio__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const SegmentGroupRoot = props => {
+  const [useSegmentGroupProps, localProps] = createSplitProps()(props, ['dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'name', 'onValueChange', 'orientation', 'value']);
+  const api = useSegmentGroup(useSegmentGroupProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, anatomy.segmentGroupAnatomy.build().root.attrs, localProps);
+  return web.createComponent(SegmentGroupProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var segmentGroup = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: SegmentGroupContext,
+  Indicator: SegmentGroupIndicator,
+  Item: SegmentGroupItem,
+  ItemContext: SegmentGroupItemContext,
+  ItemControl: SegmentGroupItemControl,
+  ItemText: SegmentGroupItemText,
+  Label: SegmentGroupLabel,
+  Root: SegmentGroupRoot
+});
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const [SelectProvider, useSelectContext] = createContext({
+  hookName: 'useSelectContext',
+  providerName: '<SelectProvider />'
+});
+
+const SelectClearTrigger = props => {
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().clearTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const SelectContent = props => {
+  const api = useSelectContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var _tmpl$$2 = /*#__PURE__*/web.template(`<option value="">`),
+  _tmpl$2 = /*#__PURE__*/web.template(`<select>`),
+  _tmpl$3 = /*#__PURE__*/web.template(`<option>`);
+const SelectControl = props => {
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  const isValueEmpty = solidJs.createMemo(() => api().value.length === 0);
+  return [web.createComponent(ark.div, mergedProps), (() => {
+    var _el$ = _tmpl$2();
+    web.spread(_el$, web.mergeProps(() => api().hiddenSelectProps), false, true);
+    web.insert(_el$, web.createComponent(solidJs.Show, {
+      get when() {
+        return isValueEmpty();
+      },
+      get children() {
+        return _tmpl$$2();
+      }
+    }), null);
+    web.insert(_el$, web.createComponent(solidJs.Index, {
+      get each() {
+        return api().collection.toArray();
+      },
+      children: option => (() => {
+        var _el$3 = _tmpl$3();
+        web.insert(_el$3, () => option().label);
+        web.effect(() => _el$3.value = option().value);
+        return _el$3;
+      })()
+    }), null);
+    return _el$;
+  })()];
+};
+
+const SelectIndicator = props => {
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().indicatorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const [SelectItemProvider, useSelectItemContext] = createContext({
+  hookName: 'useSelectItemContext',
+  providerName: '<SelectItemProvider />'
+});
+const [SelectItemPropsProvider, useSelectItemPropsContext] = createContext({
+  hookName: 'useSelectItemPropsContext',
+  providerName: '<SelectItemPropsProvider />'
+});
+
+const SelectItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['item']);
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => api().getItemState(itemProps));
+  return web.createComponent(SelectItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(SelectItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const SelectItemGroup = props => {
+  const [itemGroupProps, localProps] = createSplitProps()(props, ['id']);
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().getItemGroupProps(itemGroupProps), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SelectItemGroupLabel = props => {
+  const [labelProps, localProps] = createSplitProps()(props, ['for']);
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().getItemGroupLabelProps({
+    htmlFor: labelProps.for
+  }), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SelectItemIndicator = props => {
+  const api = useSelectContext();
+  const itemProps = useSelectItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemIndicatorProps(itemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SelectItemText = props => {
+  const api = useSelectContext();
+  const itemProps = useSelectItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemTextProps(itemProps), props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const SelectLabel = props => {
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const SelectPositioner = props => {
+  const api = useSelectContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useSelect = props => {
+  const [collectionOptions, rest] = createSplitProps()(props, ['isItemDisabled', 'itemToValue', 'itemToString', 'items']);
+  const collection = () => select__namespace.collection(collectionOptions);
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode,
+    collection: collection()
+  }, rest);
+  const [state, send] = solid.useMachine(select__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => select__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const SelectRoot = props => {
+  const [presenceProps, selectProps] = splitPresenceProps(props);
+  const [useSelectProps, localProps] = createSplitProps()(selectProps, ['closeOnSelect', 'dir', 'disabled', 'form', 'getRootNode', 'highlightedValue', 'id', 'ids', 'invalid', 'isItemDisabled', 'items', 'itemToString', 'itemToValue', 'loop', 'multiple', 'name', 'onFocusOutside', 'onHighlightChange', 'onInteractOutside', 'onOpenChange', 'onPointerDownOutside', 'onValueChange', 'open', 'positioning', 'readOnly', 'scrollToIndexFn', 'selectOnBlur', 'value']);
+  const api = useSelect(useSelectProps);
+  const presenceApi = usePresence(solid.mergeProps(() => ({
+    present: api().isOpen
+  }), presenceProps));
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(SelectProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(PresenceProvider, {
+        value: presenceApi,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const SelectTrigger = props => {
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const SelectValueText = props => {
+  const api = useSelectContext();
+  const mergedProps = solid.mergeProps(() => anatomy.selectAnatomy.build().valueText.attrs, props);
+  return web.createComponent(ark.span, web.mergeProps(mergedProps, {
+    get children() {
+      return api().valueAsString || props.placeholder;
+    }
+  }));
+};
+
+const SelectContext = props => props.children(useSelectContext());
+
+const SelectItemContext = props => props.children(useSelectItemContext());
+
+var select = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ClearTrigger: SelectClearTrigger,
+  Content: SelectContent,
+  Context: SelectContext,
+  Control: SelectControl,
+  Indicator: SelectIndicator,
+  Item: SelectItem,
+  ItemContext: SelectItemContext,
+  ItemGroup: SelectItemGroup,
+  ItemGroupLabel: SelectItemGroupLabel,
+  ItemIndicator: SelectItemIndicator,
+  ItemText: SelectItemText,
+  Label: SelectLabel,
+  Positioner: SelectPositioner,
+  Root: SelectRoot,
+  Trigger: SelectTrigger,
+  ValueText: SelectValueText
+});
+
+const [SliderProvider, useSliderContext] = createContext({
+  hookName: 'useSliderContext',
+  providerName: '<SliderProvider />'
+});
+
+const SliderContext = props => props.children(useSliderContext());
+
+const SliderControl = props => {
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SliderLabel = props => {
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const SliderMarker = props => {
+  const [markerProps, localProps] = createSplitProps()(props, ['value']);
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().getMarkerProps(markerProps), localProps);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const SliderMarkerGroup = props => {
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().markerGroupProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SliderRange = props => {
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().rangeProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const useSlider = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(slider__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => slider__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const SliderRoot = props => {
+  const [useSliderProps, localProps] = createSplitProps()(props, ['aria-label', 'aria-labelledby', 'dir', 'disabled', 'form', 'getAriaValueText', 'getRootNode', 'id', 'ids', 'invalid', 'max', 'min', 'minStepsBetweenThumbs', 'name', 'onFocusChange', 'onValueChange', 'onValueChangeEnd', 'orientation', 'origin', 'readOnly', 'step', 'thumbAlignment', 'thumbAlignment', 'thumbSize', 'value']);
+  const api = useSlider(useSliderProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(SliderProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const SliderThumb = props => {
+  const [thumbProps, localProps] = createSplitProps()(props, ['index', 'name']);
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().getThumbProps(thumbProps), localProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SliderTrack = props => {
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().trackProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SliderValueText = props => {
+  const api = useSliderContext();
+  const mergedProps = solid.mergeProps(() => api().valueTextProps, props);
+  return web.createComponent(ark.div, web.mergeProps(mergedProps, {
+    get children() {
+      return props.children || api().value.join(',');
+    }
+  }));
+};
+
+var slider = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: SliderContext,
+  Control: SliderControl,
+  Label: SliderLabel,
+  Marker: SliderMarker,
+  MarkerGroup: SliderMarkerGroup,
+  Range: SliderRange,
+  Root: SliderRoot,
+  Thumb: SliderThumb,
+  Track: SliderTrack,
+  ValueText: SliderValueText
+});
+
+const [SplitterProvider, useSplitterContext] = createContext({
+  hookName: 'useSplitterContext',
+  providerName: '<SplitterProvider />'
+});
+
+const SplitterContext = props => props.children(useSplitterContext());
+
+const SplitterPanel = props => {
+  const [panelProps, restProps] = createSplitProps()(props, ['id', 'snapSize']);
+  const api = useSplitterContext();
+  const mergedProps = solid.mergeProps(() => api().getPanelProps(panelProps), restProps);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const SplitterResizeTrigger = props => {
+  const [resizeTriggerProps, restProps] = createSplitProps()(props, ['disabled', 'id', 'step']);
+  const api = useSplitterContext();
+  const mergedProps = solid.mergeProps(() => api().getResizeTriggerProps(resizeTriggerProps), restProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const useSplitter = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(splitter__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => splitter__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const SplitterRoot = props => {
+  const [useSplitterProps, localProps] = createSplitProps()(props, ['dir', 'getRootNode', 'id', 'ids', 'onSizeChange', 'onSizeChangeEnd', 'orientation', 'size']);
+  const api = useSplitter(useSplitterProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(SplitterProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var splitter = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: SplitterContext,
+  Panel: SplitterPanel,
+  ResizeTrigger: SplitterResizeTrigger,
+  Root: SplitterRoot
+});
+
+const [SwitchProvider, useSwitchContext] = createContext({
+  hookName: 'useSwitchContext',
+  providerName: '<SwitchProvider />'
+});
+
+const SwitchContext = props => props.children(useSwitchContext());
+
+var _tmpl$$1 = /*#__PURE__*/web.template(`<input>`);
+const SwitchControl = props => {
+  const api = useSwitchContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return [web.createComponent(ark.span, mergedProps), (() => {
+    var _el$ = _tmpl$$1();
+    web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+    return _el$;
+  })()];
+};
+
+const SwitchLabel = props => {
+  const api = useSwitchContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const useSwitch = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(zagSwitch__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => zagSwitch__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const SwitchRoot = props => {
+  const [switchProps, localProps] = createSplitProps()(props, ['checked', 'dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'invalid', 'label', 'name', 'onCheckedChange', 'required', 'value']);
+  const api = useSwitch(switchProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(SwitchProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.label, mergedProps);
+    }
+  });
+};
+
+const SwitchThumb = props => {
+  const api = useSwitchContext();
+  const mergedProps = solid.mergeProps(() => api().thumbProps, props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+var _switch = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: SwitchContext,
+  Control: SwitchControl,
+  Label: SwitchLabel,
+  Root: SwitchRoot,
+  Thumb: SwitchThumb
+});
+
+const [TabsProvider, useTabsContext] = createContext({
+  hookName: 'useTabsContext',
+  providerName: '<TabsProvider />'
+});
+
+const TabContent = props => {
+  const [contentProps, localProps] = createSplitProps()(props, ['value']);
+  const api = useTabsContext();
+  const renderStrategyProps = useRenderStrategyContext();
+  const presenceApi = usePresence(solid.mergeProps(renderStrategyProps, () => ({
+    present: api().value === contentProps.value
+  })));
+  const mergedProps = solid.mergeProps(() => api().getContentProps(contentProps), () => presenceApi().presenceProps, localProps);
+  return web.createComponent(PresenceProvider, {
+    value: presenceApi,
+    get children() {
+      return web.createComponent(solidJs.Show, {
+        get when() {
+          return !presenceApi().isUnmounted;
+        },
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const TabIndicator = props => {
+  const api = useTabsContext();
+  const mergedProps = solid.mergeProps(() => api().indicatorProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TabList = props => {
+  const api = useTabsContext();
+  const mergedProps = solid.mergeProps(() => api().listProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TabTrigger = props => {
+  const [triggerProps, localProps] = createSplitProps()(props, ['disabled', 'value']);
+  const api = useTabsContext();
+  const mergedProps = solid.mergeProps(() => api().getTriggerProps(triggerProps), localProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const TabsContext = props => props.children(useTabsContext());
+
+const useTabs = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(tabs__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => tabs__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const TabsRoot = props => {
+  const [renderStrategyProps, tabsProps] = splitRenderStrategyProps(props);
+  const [useTabsProps, restProps] = createSplitProps()(tabsProps, ['activationMode', 'dir', 'getRootNode', 'id', 'ids', 'loop', 'onFocusChange', 'onValueChange', 'orientation', 'translations', 'value']);
+  const api = useTabs(useTabsProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, restProps);
+  return web.createComponent(TabsProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+var tabs = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Content: TabContent,
+  Context: TabsContext,
+  Indicator: TabIndicator,
+  List: TabList,
+  Root: TabsRoot,
+  Trigger: TabTrigger
+});
+
+const [TagsInputProvider, useTagsInputContext] = createContext({
+  hookName: 'useTagsInputContext',
+  providerName: '<TagsInputProvider />'
+});
+
+const TagsInputClearTrigger = props => {
+  const api = useTagsInputContext();
+  const mergedProps = solid.mergeProps(() => api().clearTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const TagsInputContext = props => props.children(useTagsInputContext());
+
+const TagsInputControl = props => {
+  const api = useTagsInputContext();
+  const mergedProps = solid.mergeProps(() => api().controlProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TagsInputInput = props => {
+  const api = useTagsInputContext();
+  const mergedProps = solid.mergeProps(() => api().inputProps, props);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const [TagsInputItemProvider, useTagsInputItemContext] = createContext({
+  hookName: 'useTagsInputItemContext',
+  providerName: '<TagsInputItemProvider />'
+});
+const [TagsInputItemPropsProvider, useTagsInputItemPropsContext] = createContext({
+  hookName: 'useTagsInputItemPropsContext',
+  providerName: '<TagsInputItemPropsProvider />'
+});
+
+const TagsInputItem = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['disabled', 'index', 'value']);
+  const api = useTagsInputContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  const itemState = solidJs.createMemo(() => api().getItemState(itemProps));
+  return web.createComponent(TagsInputItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(TagsInputItemProvider, {
+        value: itemState,
+        get children() {
+          return web.createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const TagsInputItemContext = props => props.children(useTagsInputItemContext());
+
+const TagsInputItemDeleteTrigger = props => {
+  const api = useTagsInputContext();
+  const itemProps = useTagsInputItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemDeleteTriggerProps(itemProps), props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const TagsInputItemInput = props => {
+  const api = useTagsInputContext();
+  const itemProps = useTagsInputItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemInputProps(itemProps), props);
+  return web.createComponent(ark.input, mergedProps);
+};
+
+const TagsInputItemPreview = props => {
+  const api = useTagsInputContext();
+  const itemProps = useTagsInputItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemPreviewProps(itemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TagsInputItemText = props => {
+  const api = useTagsInputContext();
+  const itemProps = useTagsInputItemPropsContext();
+  const mergedProps = solid.mergeProps(() => api().getItemTextProps(itemProps), props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const TagsInputLabel = props => {
+  const api = useTagsInputContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useTagsInput = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(tagsInput__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => tagsInput__namespace.connect(state, send, solid.normalizeProps));
+};
+
+var _tmpl$ = /*#__PURE__*/web.template(`<input>`);
+const TagsInputRoot = props => {
+  const [useTagsInputProps, localProps] = createSplitProps()(props, ['addOnPaste', 'allowEditTag', 'allowOverflow', 'autoFocus', 'blurBehavior', 'delimiter', 'dir', 'disabled', 'form', 'getRootNode', 'id', 'ids', 'inputValue', 'invalid', 'max', 'maxLength', 'name', 'onFocusOutside', 'onHighlightChange', 'onInteractOutside', 'onPointerDownOutside', 'onValueChange', 'onValueInvalid', 'readOnly', 'translations', 'validate', 'value']);
+  const api = useTagsInput(useTagsInputProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(TagsInputProvider, {
+    value: api,
+    get children() {
+      return [web.createComponent(ark.div, mergedProps), (() => {
+        var _el$ = _tmpl$();
+        web.spread(_el$, web.mergeProps(() => api().hiddenInputProps), false, false);
+        return _el$;
+      })()];
+    }
+  });
+};
+
+var tagsInput = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ClearTrigger: TagsInputClearTrigger,
+  Context: TagsInputContext,
+  Control: TagsInputControl,
+  Input: TagsInputInput,
+  Item: TagsInputItem,
+  ItemContext: TagsInputItemContext,
+  ItemDeleteTrigger: TagsInputItemDeleteTrigger,
+  ItemInput: TagsInputItemInput,
+  ItemPreview: TagsInputItemPreview,
+  ItemText: TagsInputItemText,
+  Label: TagsInputLabel,
+  Root: TagsInputRoot
+});
+
+const ToastGroup = props => {
+  return web.createComponent(ark.ol, props);
+};
+
+const [ToastProvider, useToastContext] = createContext({
+  hookName: 'useToastContext',
+  providerName: '<ToastProvider />'
+});
+
+const createToaster = props => {
+  const service = toast__namespace.group.machine({
+    id: '1',
+    ...props
+  }).start();
+  const [state, send] = solid.useActor(service);
+  const api = solidJs.createMemo(() => toast__namespace.group.connect(state, send, solid.normalizeProps));
+  const subscribe = fn => {
+    // @ts-expect-error FIX LATER IT EXISTS
+    return service.subscribe(state => fn(state.context.toasts));
+  };
+  const Toaster = toasterProps => {
+    const getRootNode = useEnvironmentContext();
+    solidJs.createEffect(() => {
+      service.setContext({
+        getRootNode
+      });
+      solidJs.onCleanup(() => service.stop());
+    });
+    const mergedProps = solid.mergeProps(() => api().getGroupProps({
+      placement: props.placement
+    }), toasterProps);
+    return web.createComponent(ToastGroup, web.mergeProps(mergedProps, {
+      get children() {
+        return web.createComponent(solidJs.Index, {
+          get each() {
+            return api().toastsByPlacement[props.placement];
+          },
+          children: toast => web.createComponent(ToastProviderFactory, {
+            get service() {
+              return toast();
+            }
+          })
+        });
+      }
+    }));
+  };
+  return [Toaster, solidJs.createMemo(() => Object.assign(api(), {
+    subscribe
+  }))];
+};
+const ToastProviderFactory = props => {
+  const [state, send] = solid.useActor(props.service);
+  const api = solidJs.createMemo(() => toast__namespace.connect(state, send, solid.normalizeProps));
+  return web.createComponent(ToastProvider, {
+    value: api,
+    get children() {
+      return state.context.render?.(api);
+    }
+  });
+};
+
+const ToastCloseTrigger = props => {
+  const api = useToastContext();
+  const mergedProps = solid.mergeProps(() => api().closeTriggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const ToastContext = props => props.children(useToastContext());
+
+const ToastDescription = props => {
+  const api = useToastContext();
+  const mergedProps = solid.mergeProps(() => api().descriptionProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const ToastRoot = props => {
+  const api = useToastContext();
+  const mergedProps = solid.mergeProps(() => api().rootProps, props);
+  return web.createComponent(ark.li, mergedProps);
+};
+
+const ToastTitle = props => {
+  const api = useToastContext();
+  const mergedProps = solid.mergeProps(() => api().titleProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+var toast = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  CloseTrigger: ToastCloseTrigger,
+  Context: ToastContext,
+  Description: ToastDescription,
+  Group: ToastGroup,
+  Root: ToastRoot,
+  Title: ToastTitle
+});
+
+const [ToggleGroupProvider, useToggleGroupContext] = createContext({
+  hookName: 'useToggleGroupContext',
+  providerName: '<ToggleGroupProvider />'
+});
+
+const ToggleGroupContext = props => props.children(useToggleGroupContext());
+
+const ToggleGroupItem = props => {
+  const [toggleProps, restProps] = createSplitProps()(props, ['value', 'disabled']);
+  const api = useToggleGroupContext();
+  const mergedProps = solid.mergeProps(() => api().getItemProps(toggleProps), restProps);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+const useToggleGroup = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(toggleGroup__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => toggleGroup__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const ToggleGroupRoot = props => {
+  const [useToggleGroupProps, restProps] = createSplitProps()(props, ['dir', 'disabled', 'getRootNode', 'id', 'ids', 'loop', 'multiple', 'onValueChange', 'orientation', 'rovingFocus', 'value']);
+  const api = useToggleGroup(useToggleGroupProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, restProps);
+  return web.createComponent(ToggleGroupProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+var toggleGroup = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Context: ToggleGroupContext,
+  Item: ToggleGroupItem,
+  Root: ToggleGroupRoot
+});
+
+const [TooltipProvider, useTooltipContext] = createContext({
+  hookName: 'useTooltipContext',
+  providerName: '<TooltipProvider />'
+});
+
+const TooltipArrow = props => {
+  const tooltip = useTooltipContext();
+  const mergedProps = solid.mergeProps(() => tooltip().arrowProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TooltipArrowTip = props => {
+  const api = useTooltipContext();
+  const mergedProps = solid.mergeProps(() => api().arrowTipProps, props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TooltipContent = props => {
+  const api = useTooltipContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().contentProps, () => presenceApi().presenceProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const TooltipContext = props => props.children(useTooltipContext());
+
+const TooltipPositioner = props => {
+  const api = useTooltipContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = solid.mergeProps(() => api().positionerProps, props);
+  return web.createComponent(solidJs.Show, {
+    get when() {
+      return !presenceApi().isUnmounted;
+    },
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const useTooltip = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(tooltip__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => tooltip__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const TooltipRoot = props => {
+  const [presenceProps, tooltipProps] = splitPresenceProps(props);
+  const [useTooltipProps, localProps] = createSplitProps()(tooltipProps, ['aria-label', 'closeDelay', 'closeOnEsc', 'closeOnPointerDown', 'dir', 'disabled', 'getRootNode', 'id', 'ids', 'interactive', 'onOpenChange', 'open', 'openDelay', 'positioning']);
+  const api = useTooltip(useTooltipProps);
+  const apiPresence = usePresence(solid.mergeProps(presenceProps, () => ({
+    present: api().isOpen
+  })));
+  return web.createComponent(TooltipProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(PresenceProvider, {
+        value: apiPresence,
+        get children() {
+          return localProps.children;
+        }
+      });
+    }
+  });
+};
+
+const TooltipTrigger = props => {
+  const api = useTooltipContext();
+  const mergedProps = solid.mergeProps(() => api().triggerProps, props);
+  return web.createComponent(ark.button, mergedProps);
+};
+
+var tooltip = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Arrow: TooltipArrow,
+  ArrowTip: TooltipArrowTip,
+  Content: TooltipContent,
+  Context: TooltipContext,
+  Positioner: TooltipPositioner,
+  Root: TooltipRoot,
+  Trigger: TooltipTrigger
+});
+
+const [TreeViewBranchProvider, useTreeViewBranchContext] = createContext({
+  hookName: 'useTreeViewBranchContext',
+  providerName: '<TreeViewBranchProvider />'
+});
+
+const [TreeViewProvider, useTreeViewContext] = createContext({
+  hookName: 'useTreeViewContext',
+  providerName: '<TreeViewProvider />'
+});
+
+const [TreeViewDepthProvider, useTreeViewDepthContext] = createContext({
+  hookName: 'useTreeViewDepthContext',
+  providerName: '<TreeViewDepthProvider />'
+});
+
+const TreeViewBranch = props => {
+  const [itemProps, localProps] = createSplitProps()(props, ['disabled', 'id']);
+  const api = useTreeViewContext();
+  const depth = useTreeViewDepthContext();
+  const branchProps = solid.mergeProps(itemProps, {
+    depth
+  });
+  const mergedProps = solid.mergeProps(() => api().getBranchProps(branchProps), localProps);
+  return web.createComponent(TreeViewDepthProvider, {
+    value: depth + 1,
+    get children() {
+      return web.createComponent(TreeViewBranchProvider, {
+        value: branchProps,
+        get children() {
+          return web.createComponent(ark.li, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+const TreeViewBranchContent = props => {
+  const api = useTreeViewContext();
+  const branchProps = useTreeViewBranchContext();
+  const mergedProps = solid.mergeProps(() => api().getBranchContentProps(branchProps), props);
+  return web.createComponent(ark.ul, mergedProps);
+};
+
+const TreeViewBranchControl = props => {
+  const api = useTreeViewContext();
+  const branchProps = useTreeViewBranchContext();
+  const mergedProps = solid.mergeProps(() => api().getBranchControlProps(branchProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TreeViewBranchIndicator = props => {
+  const api = useTreeViewContext();
+  const branchProps = useTreeViewBranchContext();
+  const mergedProps = solid.mergeProps(() => api().getBranchIndicatorProps(branchProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TreeViewBranchText = props => {
+  const api = useTreeViewContext();
+  const branchProps = useTreeViewBranchContext();
+  const mergedProps = solid.mergeProps(() => api().getBranchTextProps(branchProps), props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const TreeViewBranchTrigger = props => {
+  const api = useTreeViewContext();
+  const branchProps = useTreeViewBranchContext();
+  const mergedProps = solid.mergeProps(() => api().getBranchTriggerProps(branchProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TreeViewContext = props => props.children(useTreeViewContext());
+
+const [TreeViewItemProvider, useTreeViewItemContext] = createContext({
+  hookName: 'useTreeViewItemContext',
+  providerName: '<TreeViewItemProvider />'
+});
+
+const TreeViewItem = props => {
+  const [_itemProps, localProps] = createSplitProps()(props, ['id', 'disabled']);
+  const api = useTreeViewContext();
+  const depth = useTreeViewDepthContext();
+  const itemProps = solid.mergeProps(_itemProps, {
+    depth
+  });
+  const mergedProps = solid.mergeProps(() => api().getItemProps(itemProps), localProps);
+  return web.createComponent(TreeViewItemProvider, {
+    value: itemProps,
+    get children() {
+      return web.createComponent(ark.li, mergedProps);
+    }
+  });
+};
+
+const TreeViewItemIndicator = props => {
+  const api = useTreeViewContext();
+  const itemProps = useTreeViewItemContext();
+  const mergedProps = solid.mergeProps(() => api().getItemIndicatorProps(itemProps), props);
+  return web.createComponent(ark.div, mergedProps);
+};
+
+const TreeViewItemText = props => {
+  const api = useTreeViewContext();
+  const itemProps = useTreeViewItemContext();
+  const mergedProps = solid.mergeProps(() => api().getItemTextProps(itemProps), props);
+  return web.createComponent(ark.span, mergedProps);
+};
+
+const TreeViewLabel = props => {
+  const api = useTreeViewContext();
+  const mergedProps = solid.mergeProps(() => api().labelProps, props);
+  return web.createComponent(ark.label, mergedProps);
+};
+
+const useTreeView = props => {
+  const getRootNode = useEnvironmentContext();
+  const context = solid.mergeProps({
+    id: solidJs.createUniqueId(),
+    getRootNode
+  }, props);
+  const [state, send] = solid.useMachine(treeView__namespace.machine(context), {
+    context
+  });
+  return solidJs.createMemo(() => treeView__namespace.connect(state, send, solid.normalizeProps));
+};
+
+const TreeViewRoot = props => {
+  const [useTreeViewProps, localProps] = createSplitProps()(props, ['dir', 'expandedIds', 'focusedId', 'getRootNode', 'id', 'onExpandedChange', 'onFocusChange', 'onSelectionChange', 'openOnClick', 'selectedIds', 'selectionMode']);
+  const api = useTreeView(useTreeViewProps);
+  const mergedProps = solid.mergeProps(() => api().rootProps, localProps);
+  return web.createComponent(TreeViewProvider, {
+    value: api,
+    get children() {
+      return web.createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+const TreeViewTree = props => {
+  const api = useTreeViewContext();
+  const mergedProps = solid.mergeProps(() => api().treeProps, props);
+  return web.createComponent(TreeViewDepthProvider, {
+    value: 1,
+    get children() {
+      return web.createComponent(ark.ul, mergedProps);
+    }
+  });
+};
+
+var treeView = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Branch: TreeViewBranch,
+  BranchContent: TreeViewBranchContent,
+  BranchControl: TreeViewBranchControl,
+  BranchIndicator: TreeViewBranchIndicator,
+  BranchText: TreeViewBranchText,
+  BranchTrigger: TreeViewBranchTrigger,
+  Context: TreeViewContext,
+  Item: TreeViewItem,
+  ItemIndicator: TreeViewItemIndicator,
+  ItemText: TreeViewItemText,
+  Label: TreeViewLabel,
+  Root: TreeViewRoot,
+  Tree: TreeViewTree
+});
+
+exports.Accordion = accordion;
+exports.AccordionContext = AccordionContext;
+exports.AccordionItem = AccordionItem;
+exports.AccordionItemContent = AccordionItemContent;
+exports.AccordionItemIndicator = AccordionItemIndicator;
+exports.AccordionItemTrigger = AccordionItemTrigger;
+exports.AccordionRoot = AccordionRoot;
+exports.Avatar = avatar;
+exports.AvatarContext = AvatarContext;
+exports.AvatarFallback = AvatarFallback;
+exports.AvatarImage = AvatarImage;
+exports.AvatarRoot = AvatarRoot;
+exports.Carousel = carousel;
+exports.CarouselContext = CarouselContext;
+exports.CarouselControl = CarouselControl;
+exports.CarouselIndicator = CarouselIndicator;
+exports.CarouselIndicatorGroup = CarouselIndicatorGroup;
+exports.CarouselItem = CarouselItem;
+exports.CarouselItemGroup = CarouselItemGroup;
+exports.CarouselNextTrigger = CarouselNextTrigger;
+exports.CarouselPrevTrigger = CarouselPrevTrigger;
+exports.CarouselRoot = CarouselRoot;
+exports.CarouselViewport = CarouselViewport;
+exports.Checkbox = checkbox;
+exports.CheckboxContext = CheckboxContext;
+exports.CheckboxControl = CheckboxControl;
+exports.CheckboxIndicator = CheckboxIndicator;
+exports.CheckboxLabel = CheckboxLabel;
+exports.CheckboxRoot = CheckboxRoot;
+exports.Clipboard = clipboard;
+exports.ClipboardContext = ClipboardContext;
+exports.ClipboardControl = ClipboardControl;
+exports.ClipboardIndicator = ClipboardIndicator;
+exports.ClipboardInput = ClipboardInput;
+exports.ClipboardLabel = ClipboardLabel;
+exports.ClipboardRoot = ClipboardRoot;
+exports.ClipboardTrigger = ClipboardTrigger;
+exports.Collapsible = collapsible;
+exports.CollapsibleContent = CollapsibleContent;
+exports.CollapsibleContext = CollapsibleContext;
+exports.CollapsibleRoot = CollapsibleRoot;
+exports.CollapsibleTrigger = CollapsibleTrigger;
+exports.ColorPicker = colorPicker;
+exports.ColorPickerArea = ColorPickerArea;
+exports.ColorPickerAreaBackground = ColorPickerAreaBackground;
+exports.ColorPickerAreaThumb = ColorPickerAreaThumb;
+exports.ColorPickerChannelInput = ColorPickerChannelInput;
+exports.ColorPickerChannelSlider = ColorPickerChannelSlider;
+exports.ColorPickerChannelSliderThumb = ColorPickerChannelSliderThumb;
+exports.ColorPickerChannelSliderTrack = ColorPickerChannelSliderTrack;
+exports.ColorPickerContent = ColorPickerContent;
+exports.ColorPickerContext = ColorPickerContext;
+exports.ColorPickerControl = ColorPickerControl;
+exports.ColorPickerEyeDropperTrigger = ColorPickerEyeDropperTrigger;
+exports.ColorPickerFormatSelect = ColorPickerFormatSelect;
+exports.ColorPickerFormatTrigger = ColorPickerFormatTrigger;
+exports.ColorPickerLabel = ColorPickerLabel;
+exports.ColorPickerPositioner = ColorPickerPositioner;
+exports.ColorPickerRoot = ColorPickerRoot;
+exports.ColorPickerSwatch = ColorPickerSwatch;
+exports.ColorPickerSwatchGroup = ColorPickerSwatchGroup;
+exports.ColorPickerSwatchIndicator = ColorPickerSwatchIndicator;
+exports.ColorPickerSwatchTrigger = ColorPickerSwatchTrigger;
+exports.ColorPickerTransparencyGrid = ColorPickerTransparencyGrid;
+exports.ColorPickerTrigger = ColorPickerTrigger;
+exports.ColorPickerValueText = ColorPickerValueText;
+exports.ColorPickerView = ColorPickerView;
+exports.Combobox = combobox;
+exports.ComboboxClearTrigger = ComboboxClearTrigger;
+exports.ComboboxContent = ComboboxContent;
+exports.ComboboxContext = ComboboxContext;
+exports.ComboboxControl = ComboboxControl;
+exports.ComboboxInput = ComboboxInput;
+exports.ComboboxItem = ComboboxItem;
+exports.ComboboxItemContext = ComboboxItemContext;
+exports.ComboboxItemGroup = ComboboxItemGroup;
+exports.ComboboxItemGroupLabel = ComboboxItemGroupLabel;
+exports.ComboboxItemIndicator = ComboboxItemIndicator;
+exports.ComboboxItemText = ComboboxItemText;
+exports.ComboboxLabel = ComboboxLabel;
+exports.ComboboxPositioner = ComboboxPositioner;
+exports.ComboboxRoot = ComboboxRoot;
+exports.ComboboxTrigger = ComboboxTrigger;
+exports.DatePicker = datePicker;
+exports.DatePickerClearTrigger = DatePickerClearTrigger;
+exports.DatePickerContent = DatePickerContent;
+exports.DatePickerContext = DatePickerContext;
+exports.DatePickerControl = DatePickerControl;
+exports.DatePickerInput = DatePickerInput;
+exports.DatePickerLabel = DatePickerLabel;
+exports.DatePickerMonthSelect = DatePickerMonthSelect;
+exports.DatePickerNextTrigger = DatePickerNextTrigger;
+exports.DatePickerPositioner = DatePickerPositioner;
+exports.DatePickerPresetTrigger = DatePickerPresetTrigger;
+exports.DatePickerPrevTrigger = DatePickerPrevTrigger;
+exports.DatePickerRangeText = DatePickerRangeText;
+exports.DatePickerRoot = DatePickerRoot;
+exports.DatePickerTable = DatePickerTable;
+exports.DatePickerTableBody = DatePickerTableBody;
+exports.DatePickerTableCell = DatePickerTableCell;
+exports.DatePickerTableCellTrigger = DatePickerTableCellTrigger;
+exports.DatePickerTableHead = DatePickerTableHead;
+exports.DatePickerTableHeader = DatePickerTableHeader;
+exports.DatePickerTableRow = DatePickerTableRow;
+exports.DatePickerTrigger = DatePickerTrigger;
+exports.DatePickerView = DatePickerView;
+exports.DatePickerViewControl = DatePickerViewControl;
+exports.DatePickerViewTrigger = DatePickerViewTrigger;
+exports.DatePickerYearSelect = DatePickerYearSelect;
+exports.Dialog = dialog;
+exports.DialogBackdrop = DialogBackdrop;
+exports.DialogCloseTrigger = DialogCloseTrigger;
+exports.DialogContent = DialogContent;
+exports.DialogContext = DialogContext;
+exports.DialogDescription = DialogDescription;
+exports.DialogPositioner = DialogPositioner;
+exports.DialogRoot = DialogRoot;
+exports.DialogTitle = DialogTitle;
+exports.DialogTrigger = DialogTrigger;
+exports.Editable = editable;
+exports.EditableArea = EditableArea;
+exports.EditableCancelTrigger = EditableCancelTrigger;
+exports.EditableContext = EditableContext;
+exports.EditableControl = EditableControl;
+exports.EditableEditTrigger = EditableEditTrigger;
+exports.EditableInput = EditableInput;
+exports.EditableLabel = EditableLabel;
+exports.EditablePreview = EditablePreview;
+exports.EditableRoot = EditableRoot;
+exports.EditableSubmitTrigger = EditableSubmitTrigger;
+exports.Environment = Environment;
+exports.FileUpload = fileUpload;
+exports.FileUploadContext = FileUploadContext;
+exports.FileUploadDropzone = FileUploadDropzone;
+exports.FileUploadItem = FileUploadItem;
+exports.FileUploadItemDeleteTrigger = FileUploadItemDeleteTrigger;
+exports.FileUploadItemGroup = FileUploadItemGroup;
+exports.FileUploadItemName = FileUploadItemName;
+exports.FileUploadItemPreview = FileUploadItemPreview;
+exports.FileUploadItemPreviewImage = FileUploadItemPreviewImage;
+exports.FileUploadItemSizeText = FileUploadItemSizeText;
+exports.FileUploadLabel = FileUploadLabel;
+exports.FileUploadRoot = FileUploadRoot;
+exports.FileUploadTrigger = FileUploadTrigger;
+exports.Format = format;
+exports.FormatByte = FormatByte;
+exports.FormatNumber = FormatNumber;
+exports.HoverCard = hoverCard;
+exports.HoverCardArrow = HoverCardArrow;
+exports.HoverCardArrowTip = HoverCardArrowTip;
+exports.HoverCardContent = HoverCardContent;
+exports.HoverCardContext = HoverCardContext;
+exports.HoverCardPositioner = HoverCardPositioner;
+exports.HoverCardRoot = HoverCardRoot;
+exports.HoverCardTrigger = HoverCardTrigger;
+exports.LocaleProvider = LocaleProvider;
+exports.Menu = menu;
+exports.MenuArrow = MenuArrow;
+exports.MenuArrowTip = MenuArrowTip;
+exports.MenuContent = MenuContent;
+exports.MenuContext = MenuContext;
+exports.MenuContextTrigger = MenuContextTrigger;
+exports.MenuIndicator = MenuIndicator;
+exports.MenuItem = MenuItem;
+exports.MenuItemContext = MenuItemContext;
+exports.MenuItemGroup = MenuItemGroup;
+exports.MenuItemGroupLabel = MenuItemGroupLabel;
+exports.MenuItemIndicator = MenuItemIndicator;
+exports.MenuItemText = MenuItemText;
+exports.MenuPositioner = MenuPositioner;
+exports.MenuRoot = MenuRoot;
+exports.MenuSeparator = MenuSeparator;
+exports.MenuTrigger = MenuTrigger;
+exports.MenuTriggerItem = MenuTriggerItem;
+exports.NumberInput = numberInput;
+exports.NumberInputContext = NumberInputContext;
+exports.NumberInputControl = NumberInputControl;
+exports.NumberInputDecrementTrigger = NumberInputDecrementTrigger;
+exports.NumberInputIncrementTrigger = NumberInputIncrementTrigger;
+exports.NumberInputInput = NumberInputInput;
+exports.NumberInputLabel = NumberInputLabel;
+exports.NumberInputRoot = NumberInputRoot;
+exports.NumberInputScrubber = NumberInputScrubber;
+exports.Pagination = pagination;
+exports.PaginationContext = PaginationContext;
+exports.PaginationEllipsis = PaginationEllipsis;
+exports.PaginationItem = PaginationItem;
+exports.PaginationNextTrigger = PaginationNextTrigger;
+exports.PaginationPrevTrigger = PaginationPrevTrigger;
+exports.PaginationRoot = PaginationRoot;
+exports.PinInput = pinInput;
+exports.PinInputContext = PinInputContext;
+exports.PinInputControl = PinInputControl;
+exports.PinInputInput = PinInputInput;
+exports.PinInputLabel = PinInputLabel;
+exports.PinInputRoot = PinInputRoot;
+exports.Popover = popover;
+exports.PopoverAnchor = PopoverAnchor;
+exports.PopoverArrow = PopoverArrow;
+exports.PopoverArrowTip = PopoverArrowTip;
+exports.PopoverCloseTrigger = PopoverCloseTrigger;
+exports.PopoverContent = PopoverContent;
+exports.PopoverContext = PopoverContext;
+exports.PopoverDescription = PopoverDescription;
+exports.PopoverIndicator = PopoverIndicator;
+exports.PopoverPositioner = PopoverPositioner;
+exports.PopoverRoot = PopoverRoot;
+exports.PopoverTitle = PopoverTitle;
+exports.PopoverTrigger = PopoverTrigger;
+exports.Presence = Presence;
+exports.PresenceProvider = PresenceProvider;
+exports.Progress = progress;
+exports.ProgressCircle = ProgressCircle;
+exports.ProgressCircleRange = ProgressCircleRange;
+exports.ProgressCircleTrack = ProgressCircleTrack;
+exports.ProgressContext = ProgressContext;
+exports.ProgressLabel = ProgressLabel;
+exports.ProgressRange = ProgressRange;
+exports.ProgressRoot = ProgressRoot;
+exports.ProgressTrack = ProgressTrack;
+exports.ProgressValueText = ProgressValueText;
+exports.ProgressView = ProgressView;
+exports.RadioGroup = radioGroup;
+exports.RadioGroupIndicator = RadioGroupIndicator;
+exports.RadioGroupItem = RadioGroupItem;
+exports.RadioGroupItemControl = RadioGroupItemControl;
+exports.RadioGroupItemText = RadioGroupItemText;
+exports.RadioGroupLabel = RadioGroupLabel;
+exports.RadioGroupRoot = RadioGroupRoot;
+exports.RatingGroup = ratingGroup;
+exports.RatingGroupContext = RatingGroupContext;
+exports.RatingGroupControl = RatingGroupControl;
+exports.RatingGroupItem = RatingGroupItem;
+exports.RatingGroupItemContext = RatingGroupItemContext;
+exports.RatingGroupLabel = RatingGroupLabel;
+exports.RatingGroupRoot = RatingGroupRoot;
+exports.SegmentGroup = segmentGroup;
+exports.SegmentGroupContext = SegmentGroupContext;
+exports.SegmentGroupIndicator = SegmentGroupIndicator;
+exports.SegmentGroupItem = SegmentGroupItem;
+exports.SegmentGroupItemContext = SegmentGroupItemContext;
+exports.SegmentGroupItemControl = SegmentGroupItemControl;
+exports.SegmentGroupItemText = SegmentGroupItemText;
+exports.SegmentGroupLabel = SegmentGroupLabel;
+exports.SegmentGroupRoot = SegmentGroupRoot;
+exports.Select = select;
+exports.SelectClearTrigger = SelectClearTrigger;
+exports.SelectContent = SelectContent;
+exports.SelectControl = SelectControl;
+exports.SelectIndicator = SelectIndicator;
+exports.SelectItem = SelectItem;
+exports.SelectItemGroup = SelectItemGroup;
+exports.SelectItemGroupLabel = SelectItemGroupLabel;
+exports.SelectItemIndicator = SelectItemIndicator;
+exports.SelectItemText = SelectItemText;
+exports.SelectLabel = SelectLabel;
+exports.SelectPositioner = SelectPositioner;
+exports.SelectRoot = SelectRoot;
+exports.SelectTrigger = SelectTrigger;
+exports.SelectValueText = SelectValueText;
+exports.Slider = slider;
+exports.SliderContext = SliderContext;
+exports.SliderControl = SliderControl;
+exports.SliderLabel = SliderLabel;
+exports.SliderMarker = SliderMarker;
+exports.SliderMarkerGroup = SliderMarkerGroup;
+exports.SliderRange = SliderRange;
+exports.SliderRoot = SliderRoot;
+exports.SliderThumb = SliderThumb;
+exports.SliderTrack = SliderTrack;
+exports.SliderValueText = SliderValueText;
+exports.Splitter = splitter;
+exports.SplitterContext = SplitterContext;
+exports.SplitterPanel = SplitterPanel;
+exports.SplitterResizeTrigger = SplitterResizeTrigger;
+exports.SplitterRoot = SplitterRoot;
+exports.Switch = _switch;
+exports.SwitchContext = SwitchContext;
+exports.SwitchControl = SwitchControl;
+exports.SwitchLabel = SwitchLabel;
+exports.SwitchRoot = SwitchRoot;
+exports.SwitchThumb = SwitchThumb;
+exports.TabContent = TabContent;
+exports.TabIndicator = TabIndicator;
+exports.TabList = TabList;
+exports.TabTrigger = TabTrigger;
+exports.Tabs = tabs;
+exports.TabsContext = TabsContext;
+exports.TabsRoot = TabsRoot;
+exports.TagsInput = tagsInput;
+exports.TagsInputClearTrigger = TagsInputClearTrigger;
+exports.TagsInputContext = TagsInputContext;
+exports.TagsInputControl = TagsInputControl;
+exports.TagsInputInput = TagsInputInput;
+exports.TagsInputItem = TagsInputItem;
+exports.TagsInputItemContext = TagsInputItemContext;
+exports.TagsInputItemDeleteTrigger = TagsInputItemDeleteTrigger;
+exports.TagsInputItemInput = TagsInputItemInput;
+exports.TagsInputItemPreview = TagsInputItemPreview;
+exports.TagsInputItemText = TagsInputItemText;
+exports.TagsInputLabel = TagsInputLabel;
+exports.TagsInputRoot = TagsInputRoot;
+exports.Toast = toast;
+exports.ToastCloseTrigger = ToastCloseTrigger;
+exports.ToastContext = ToastContext;
+exports.ToastDescription = ToastDescription;
+exports.ToastGroup = ToastGroup;
+exports.ToastRoot = ToastRoot;
+exports.ToastTitle = ToastTitle;
+exports.ToggleGroup = toggleGroup;
+exports.ToggleGroupContext = ToggleGroupContext;
+exports.ToggleGroupItem = ToggleGroupItem;
+exports.ToggleGroupRoot = ToggleGroupRoot;
+exports.Tooltip = tooltip;
+exports.TooltipArrow = TooltipArrow;
+exports.TooltipArrowTip = TooltipArrowTip;
+exports.TooltipContent = TooltipContent;
+exports.TooltipContext = TooltipContext;
+exports.TooltipPositioner = TooltipPositioner;
+exports.TooltipRoot = TooltipRoot;
+exports.TooltipTrigger = TooltipTrigger;
+exports.TreeView = treeView;
+exports.TreeViewBranch = TreeViewBranch;
+exports.TreeViewBranchContent = TreeViewBranchContent;
+exports.TreeViewBranchControl = TreeViewBranchControl;
+exports.TreeViewBranchIndicator = TreeViewBranchIndicator;
+exports.TreeViewBranchText = TreeViewBranchText;
+exports.TreeViewBranchTrigger = TreeViewBranchTrigger;
+exports.TreeViewContext = TreeViewContext;
+exports.TreeViewItem = TreeViewItem;
+exports.TreeViewItemIndicator = TreeViewItemIndicator;
+exports.TreeViewItemText = TreeViewItemText;
+exports.TreeViewLabel = TreeViewLabel;
+exports.TreeViewRoot = TreeViewRoot;
+exports.TreeViewTree = TreeViewTree;
+exports.ark = ark;
+exports.createToaster = createToaster;
+exports.splitPresenceProps = splitPresenceProps;
+exports.useAccordionContext = useAccordionContext;
+exports.useAccordionItemContext = useAccordionItemContext;
+exports.useAvatarContext = useAvatarContext;
+exports.useCarouselContext = useCarouselContext;
+exports.useCheckboxContext = useCheckboxContext;
+exports.useClipboardContext = useClipboardContext;
+exports.useCollapsibleContext = useCollapsibleContext;
+exports.useColorPickerContext = useColorPickerContext;
+exports.useComboboxContext = useComboboxContext;
+exports.useComboboxItemContext = useComboboxItemContext;
+exports.useDatePickerContext = useDatePickerContext;
+exports.useDialogContext = useDialogContext;
+exports.useEditableContext = useEditableContext;
+exports.useEnvironmentContext = useEnvironmentContext;
+exports.useFileUploadContext = useFileUploadContext;
+exports.useHoverCardContext = useHoverCardContext;
+exports.useLocaleContext = useLocaleContext;
+exports.useMenuContext = useMenuContext;
+exports.useMenuItemContext = useMenuItemContext;
+exports.useNumberInputContext = useNumberInputContext;
+exports.usePaginationContext = usePaginationContext;
+exports.usePinInputContext = usePinInputContext;
+exports.usePopoverContext = usePopoverContext;
+exports.usePresence = usePresence;
+exports.usePresenceContext = usePresenceContext;
+exports.useProgressContext = useProgressContext;
+exports.useRadioGroupContext = useRadioGroupContext;
+exports.useRadioGroupItemContext = useRadioGroupItemContext;
+exports.useRatingGroupContext = useRatingGroupContext;
+exports.useRatingGroupItemContext = useRatingGroupItemContext;
+exports.useSegmentGroupContext = useSegmentGroupContext;
+exports.useSegmentGroupItemContext = useSegmentGroupItemContext;
+exports.useSelectContext = useSelectContext;
+exports.useSelectItemContext = useSelectItemContext;
+exports.useSliderContext = useSliderContext;
+exports.useSplitterContext = useSplitterContext;
+exports.useSwitchContext = useSwitchContext;
+exports.useTabsContext = useTabsContext;
+exports.useTagsInputContext = useTagsInputContext;
+exports.useTagsInputItemContext = useTagsInputItemContext;
+exports.useToastContext = useToastContext;
+exports.useToggleGroupContext = useToggleGroupContext;
+exports.useTooltipContext = useTooltipContext;
+exports.useTreeViewContext = useTreeViewContext;
+//# sourceMappingURL=index.js.map