@seed-design/react 0.0.1-alpha-20250210081704

package/lib/index.mjs

@@ -0,0 +1,2318 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/components/ActionButton/ActionButton.tsx
+import { Primitive as Primitive2 } from "@seed-design/react-primitive";
+import { actionButton } from "@seed-design/recipe/actionButton";
+import clsx2 from "clsx";
+import * as React2 from "react";
+
+// src/utils/createStyleContext.tsx
+import clsx from "clsx";
+import { createContext, forwardRef, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+function createStyleContext(recipe) {
+  const ClassNamesContext = createContext(null);
+  const PropsContext = createContext(null);
+  const ClassNamesProvider4 = ({
+    children,
+    value
+  }) => {
+    return /* @__PURE__ */ jsx(ClassNamesContext.Provider, { value, children });
+  };
+  const PropsProvider2 = ({ children, value }) => {
+    return /* @__PURE__ */ jsx(PropsContext.Provider, { value, children });
+  };
+  function useClassNames5() {
+    const context = useContext(ClassNamesContext);
+    if (context === null) {
+      throw new Error(
+        "useClassNames must be used within a ClassNamesProvider. Did you forget to wrap your component in a ClassNamesProvider?"
+      );
+    }
+    return context;
+  }
+  function useProps() {
+    return useContext(PropsContext);
+  }
+  const withRootProvider6 = (Component, options) => {
+    const { defaultProps } = options != null ? options : {};
+    const StyledComponent = (innerProps) => {
+      const props = { ...defaultProps != null ? defaultProps : {}, ...useProps(), ...innerProps };
+      const [variantProps, otherProps] = recipe.splitVariantProps(props);
+      const classNames = recipe(variantProps);
+      return /* @__PURE__ */ jsx(ClassNamesProvider4, { value: classNames, children: /* @__PURE__ */ jsx(Component, { ...otherProps }) });
+    };
+    StyledComponent.displayName = Component.displayName || Component.name;
+    return StyledComponent;
+  };
+  const withProvider24 = (Component, slot, options) => {
+    const { defaultProps } = options != null ? options : {};
+    const StyledComponent = forwardRef((innerProps, ref) => {
+      const props = { ...defaultProps != null ? defaultProps : {}, ...useProps(), ...innerProps };
+      const [variantProps, otherProps] = recipe.splitVariantProps(props);
+      const classNames = recipe(variantProps);
+      const className = classNames[slot];
+      return /* @__PURE__ */ jsx(ClassNamesProvider4, { value: classNames, children: /* @__PURE__ */ jsx(Component, { ref, ...otherProps, className: clsx(className, props.className) }) });
+    });
+    StyledComponent.displayName = Component.displayName || Component.name;
+    return StyledComponent;
+  };
+  const withContext30 = (Component, slot) => {
+    const StyledComponent = forwardRef((props, ref) => {
+      const classNames = useClassNames5();
+      const className = classNames == null ? void 0 : classNames[slot];
+      return /* @__PURE__ */ jsx(Component, { ref, ...props, className: clsx(className, props.className) });
+    });
+    StyledComponent.displayName = Component.displayName || Component.name;
+    return StyledComponent;
+  };
+  return {
+    ClassNamesProvider: ClassNamesProvider4,
+    PropsProvider: PropsProvider2,
+    useClassNames: useClassNames5,
+    useProps,
+    withRootProvider: withRootProvider6,
+    withProvider: withProvider24,
+    withContext: withContext30
+  };
+}
+
+// src/utils/createWithStateProps.tsx
+import { forwardRef as forwardRef2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function createWithStateProps(useContexts, options) {
+  var _a;
+  const strict = (_a = options == null ? void 0 : options.strict) != null ? _a : true;
+  return function withStateProps18(Component) {
+    const Node = forwardRef2((props, ref) => {
+      var _a2;
+      const stateProps = {};
+      for (const useContext4 of useContexts) {
+        Object.assign(stateProps, (_a2 = useContext4({ strict })) == null ? void 0 : _a2.stateProps);
+      }
+      return /* @__PURE__ */ jsx2(Component, { ref, ...stateProps, ...props });
+    });
+    Node.displayName = Component.displayName || Component.name;
+    return Node;
+  };
+}
+
+// src/components/private/Icon.tsx
+import { Primitive } from "@seed-design/react-primitive";
+import { forwardRef as forwardRef3 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var Icon = forwardRef3(({ svg, ...otherProps }, ref) => {
+  return (
+    // biome-ignore lint/a11y/noSvgWithoutTitle: SVG is used as a child of a button element, so it is not required to have a title
+    /* @__PURE__ */ jsx3(Primitive.svg, { ref, "aria-hidden": true, asChild: true, ...otherProps, children: svg })
+  );
+});
+
+// src/components/private/usePendingButton.tsx
+import { elementProps } from "@seed-design/dom-utils";
+import * as React from "react";
+function usePendingButton(props) {
+  const { loading, disabled } = props;
+  const stateProps = elementProps({
+    "data-loading": loading ? "" : void 0,
+    "data-disabled": disabled ? "" : void 0
+  });
+  return {
+    loading,
+    disabled,
+    stateProps
+  };
+}
+var PendingButtonContext = React.createContext(null);
+var PendingButtonProvider = PendingButtonContext.Provider;
+var usePendingButtonContext = () => {
+  const context = React.useContext(PendingButtonContext);
+  if (context === null) {
+    throw new Error("usePendingButtonContext should be used within UsePendingButtonProvider");
+  }
+  return context;
+};
+
+// src/components/ActionButton/ActionButton.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var { ClassNamesProvider, withContext } = createStyleContext(actionButton);
+var withStateProps = createWithStateProps([usePendingButtonContext]);
+var ActionButtonRoot = React2.forwardRef(
+  ({
+    variant = "brandSolid",
+    size = "medium",
+    loading = false,
+    layout = "withText",
+    className,
+    ...otherProps
+  }, ref) => {
+    const classNames = actionButton({ variant, layout, size });
+    const api = usePendingButton({ loading, disabled: otherProps.disabled });
+    if (layout === "iconOnly" && !(otherProps["aria-label"] || otherProps["aria-labelledby"])) {
+      console.warn(
+        "When layout is 'iconOnly', 'aria-label' or 'aria-labelledby' should be provided."
+      );
+    }
+    return /* @__PURE__ */ jsx4(ClassNamesProvider, { value: classNames, children: /* @__PURE__ */ jsx4(PendingButtonProvider, { value: api, children: /* @__PURE__ */ jsx4(
+      Primitive2.button,
+      {
+        ref,
+        className: clsx2(classNames.root, className),
+        ...api.stateProps,
+        ...otherProps
+      }
+    ) }) });
+  }
+);
+ActionButtonRoot.displayName = "ActionButton";
+var ActionButtonLabel = withContext(
+  withStateProps(Primitive2.span),
+  "label"
+);
+var ActionButtonPrefixIcon = withContext(
+  withStateProps(Icon),
+  "prefixIcon"
+);
+var ActionButtonSuffixIcon = withContext(
+  withStateProps(Icon),
+  "suffixIcon"
+);
+var ActionButtonIcon = withContext(
+  withStateProps(Icon),
+  "icon"
+);
+var ActionButtonProgressIndicator = withContext(withStateProps(Primitive2.div), "progressIndicator");
+
+// src/components/ActionButton/ActionButton.namespace.ts
+var ActionButton_namespace_exports = {};
+__export(ActionButton_namespace_exports, {
+  Icon: () => ActionButtonIcon,
+  Label: () => ActionButtonLabel,
+  PrefixIcon: () => ActionButtonPrefixIcon,
+  ProgressIndicator: () => ActionButtonProgressIndicator,
+  Root: () => ActionButtonRoot,
+  SuffixIcon: () => ActionButtonSuffixIcon
+});
+
+// src/components/ActionChip/ActionChip.tsx
+import { Primitive as Primitive3 } from "@seed-design/react-primitive";
+import { actionChip } from "@seed-design/recipe/actionChip";
+var { withProvider, withContext: withContext2 } = createStyleContext(actionChip);
+var ActionChipRoot = withProvider(
+  Primitive3.button,
+  "root"
+);
+ActionChipRoot.displayName = "ActionChip";
+var ActionChipLabel = withContext2(
+  Primitive3.span,
+  "label"
+);
+var ActionChipPrefixIcon = withContext2(
+  Icon,
+  "prefixIcon"
+);
+var ActionChipSuffixIcon = withContext2(
+  Icon,
+  "suffixIcon"
+);
+var ActionChipIcon = withContext2(Icon, "icon");
+var ActionChipCount = withContext2(
+  Primitive3.span,
+  "count"
+);
+
+// src/components/ActionChip/ActionChip.namespace.ts
+var ActionChip_namespace_exports = {};
+__export(ActionChip_namespace_exports, {
+  Count: () => ActionChipCount,
+  Icon: () => ActionChipIcon,
+  Label: () => ActionChipLabel,
+  PrefixIcon: () => ActionChipPrefixIcon,
+  Root: () => ActionChipRoot,
+  SuffixIcon: () => ActionChipSuffixIcon
+});
+
+// src/components/ActionSheet/ActionSheet.tsx
+import { Dialog as DialogPrimitive, useDialogContext } from "@seed-design/react-dialog";
+import { Primitive as Primitive4 } from "@seed-design/react-primitive";
+import { actionSheet } from "@seed-design/recipe/actionSheet";
+import {
+  actionSheetCloseButton
+} from "@seed-design/recipe/actionSheetCloseButton";
+import {
+  actionSheetItem
+} from "@seed-design/recipe/actionSheetItem";
+var { withRootProvider, withContext: withContext3 } = createStyleContext(actionSheet);
+var { withProvider: withItemProvider, withContext: withItemContext } = createStyleContext(actionSheetItem);
+var { withProvider: withCloseButtonProvider, withContext: withCloseButtonContext } = createStyleContext(actionSheetCloseButton);
+var withStateProps2 = createWithStateProps([useDialogContext]);
+var ActionSheetRoot = withRootProvider(DialogPrimitive.Root, {
+  defaultProps: {
+    lazyMount: true,
+    unmountOnExit: true
+  }
+});
+var ActionSheetTrigger = DialogPrimitive.Trigger;
+var ActionSheetPositioner = withContext3(
+  DialogPrimitive.Positioner,
+  "positioner"
+);
+var ActionSheetBackdrop = withContext3(
+  DialogPrimitive.Backdrop,
+  "backdrop"
+);
+var ActionSheetContent = withContext3(
+  DialogPrimitive.Content,
+  "content"
+);
+var ActionSheetHeader = withContext3(
+  withStateProps2(Primitive4.div),
+  "header"
+);
+var ActionSheetTitle = withContext3(
+  withStateProps2(Primitive4.h2),
+  "title"
+);
+var ActionSheetDescription = withContext3(withStateProps2(Primitive4.p), "description");
+var ActionSheetList = withContext3(
+  withStateProps2(Primitive4.div),
+  "list"
+);
+var ActionSheetItem = withItemProvider(
+  withStateProps2(Primitive4.button),
+  "root"
+);
+var ActionSheetItemLabel = withItemContext(
+  withStateProps2(Primitive4.span),
+  "label"
+);
+var ActionSheetCloseButton = withCloseButtonProvider(DialogPrimitive.CloseButton, "root");
+var ActionSheetCloseButtonLabel = withCloseButtonContext(Primitive4.span, "label");
+
+// src/components/ActionSheet/ActionSheet.namespace.ts
+var ActionSheet_namespace_exports = {};
+__export(ActionSheet_namespace_exports, {
+  Backdrop: () => ActionSheetBackdrop,
+  CloseButton: () => ActionSheetCloseButton,
+  CloseButtonLabel: () => ActionSheetCloseButtonLabel,
+  Content: () => ActionSheetContent,
+  Description: () => ActionSheetDescription,
+  Header: () => ActionSheetHeader,
+  Item: () => ActionSheetItem,
+  ItemLabel: () => ActionSheetItemLabel,
+  List: () => ActionSheetList,
+  Positioner: () => ActionSheetPositioner,
+  Root: () => ActionSheetRoot,
+  Title: () => ActionSheetTitle,
+  Trigger: () => ActionSheetTrigger
+});
+
+// src/components/Avatar/Avatar.tsx
+import { Avatar as AvatarPrimitive } from "@seed-design/react-avatar";
+import { Primitive as Primitive5 } from "@seed-design/react-primitive";
+import { avatar } from "@seed-design/recipe/avatar";
+import { avatarStack } from "@seed-design/recipe/avatarStack";
+import clsx3 from "clsx";
+import * as React3 from "react";
+import { useMemo } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var { PropsProvider, withProvider: withProvider2, withContext: withContext4 } = createStyleContext(avatar);
+var AvatarRoot = withProvider2(
+  AvatarPrimitive.Root,
+  "root"
+);
+var AvatarImage = withContext4(
+  AvatarPrimitive.Image,
+  "image"
+);
+var AvatarFallback = withContext4(
+  AvatarPrimitive.Fallback,
+  "fallback"
+);
+var AvatarBadge = withContext4(Primitive5.div, "badge");
+var AvatarStack = React3.forwardRef(
+  ({ className, children, size, ...otherProps }, ref) => {
+    const classNames = avatarStack({ size });
+    const avatars = React3.Children.toArray(children);
+    return /* @__PURE__ */ jsx5(PropsProvider, { value: useMemo(() => ({ size }), [size]), children: /* @__PURE__ */ jsx5("div", { ref, className: clsx3(classNames.root, className), ...otherProps, children: avatars.map((avatar2, index) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: There is no unique key for each child
+      /* @__PURE__ */ jsx5("div", { className: classNames.item, children: avatar2 }, index)
+    )) }) });
+  }
+);
+
+// src/components/Avatar/Avatar.namespace.ts
+var Avatar_namespace_exports = {};
+__export(Avatar_namespace_exports, {
+  Badge: () => AvatarBadge,
+  Fallback: () => AvatarFallback,
+  Image: () => AvatarImage,
+  Root: () => AvatarRoot,
+  Stack: () => AvatarStack
+});
+
+// src/components/Badge/Badge.tsx
+import { Primitive as Primitive6 } from "@seed-design/react-primitive";
+import { badge } from "@seed-design/recipe/badge";
+var { withProvider: withProvider3, withContext: withContext5 } = createStyleContext(badge);
+var BadgeRoot = withProvider3(Primitive6.span, "root");
+var BadgeLabel = withContext5(Primitive6.span, "label");
+
+// src/components/Badge/Badge.namespace.ts
+var Badge_namespace_exports = {};
+__export(Badge_namespace_exports, {
+  Label: () => BadgeLabel,
+  Root: () => BadgeRoot
+});
+
+// src/components/BottomSheet/BottomSheet.tsx
+import { Dialog as DialogPrimitive2, useDialogContext as useDialogContext2 } from "@seed-design/react-dialog";
+import { Primitive as Primitive7 } from "@seed-design/react-primitive";
+import { bottomSheet } from "@seed-design/recipe/bottomSheet";
+
+// src/components/Box/Box.tsx
+import { vars } from "@seed-design/vars";
+import clsx4 from "clsx";
+import * as React4 from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function handleColor(color) {
+  var _a;
+  if (!color) {
+    return void 0;
+  }
+  const [type, value] = color.split(".");
+  return (_a = vars.$color[type][value]) != null ? _a : void 0;
+}
+function handleDimension(dimension) {
+  var _a, _b;
+  if (!dimension) {
+    return void 0;
+  }
+  const [type, value] = dimension.split(".");
+  return (_b = (_a = vars.$dimension[dimension]) != null ? _a : vars.$dimension[type][value]) != null ? _b : void 0;
+}
+function handleSize(size) {
+  var _a;
+  if (!size) {
+    return void 0;
+  }
+  if (size === "full") {
+    return "100%";
+  }
+  return (_a = vars.$dimension[size]) != null ? _a : size;
+}
+function handleRadius(radius) {
+  var _a;
+  if (!radius) {
+    return void 0;
+  }
+  return (_a = vars.$radius[radius]) != null ? _a : void 0;
+}
+function handleDisplay(display) {
+  if (!display) {
+    return void 0;
+  }
+  return {
+    block: "block",
+    flex: "flex",
+    inlineFlex: "inline-flex",
+    inline: "inline",
+    inlineBlock: "inline-block",
+    none: "none"
+  }[display];
+}
+function handleFlexDirection(flexDirection) {
+  if (!flexDirection) {
+    return void 0;
+  }
+  return {
+    row: "row",
+    column: "column",
+    rowReverse: "row-reverse",
+    columnReverse: "column-reverse"
+  }[flexDirection];
+}
+function handleJustifyContent(justifyContent) {
+  if (!justifyContent) {
+    return void 0;
+  }
+  return {
+    flexStart: "flex-start",
+    flexEnd: "flex-end",
+    center: "center",
+    spaceBetween: "space-between",
+    spaceAround: "space-around"
+  }[justifyContent];
+}
+function handleAlignItems(alignItems) {
+  if (!alignItems) {
+    return void 0;
+  }
+  return {
+    flexStart: "flex-start",
+    flexEnd: "flex-end",
+    center: "center",
+    stretch: "stretch"
+  }[alignItems];
+}
+var Box = React4.forwardRef((props, ref) => {
+  const {
+    as: Comp = "div",
+    background,
+    color,
+    borderColor,
+    borderWidth,
+    borderTopWidth,
+    borderRightWidth,
+    borderBottomWidth,
+    borderLeftWidth,
+    borderRadius,
+    borderTopLeftRadius,
+    borderTopRightRadius,
+    borderBottomRightRadius,
+    borderBottomLeftRadius,
+    width,
+    minWidth,
+    maxWidth,
+    height,
+    minHeight,
+    maxHeight,
+    padding,
+    paddingX,
+    paddingY,
+    paddingTop,
+    paddingRight,
+    paddingBottom,
+    paddingLeft,
+    display,
+    position,
+    overflowX,
+    overflowY,
+    flexGrow,
+    flexShrink,
+    flexDirection,
+    flexWrap,
+    justifyContent,
+    alignItems,
+    alignContent,
+    alignSelf,
+    gap,
+    className,
+    style,
+    ...nativeProps
+  } = props;
+  return /* @__PURE__ */ jsx6(
+    Comp,
+    {
+      ref,
+      className: clsx4("seed-box", className),
+      style: {
+        "--seed-box-background": handleColor(background),
+        "--seed-box-color": handleColor(color),
+        "--seed-box-border-color": handleColor(borderColor),
+        "--seed-box-border-width": borderWidth !== void 0 ? `${borderWidth}px` : void 0,
+        "--seed-box-border-top-width": borderTopWidth !== void 0 ? `${borderTopWidth}px` : void 0,
+        "--seed-box-border-right-width": borderRightWidth !== void 0 ? `${borderRightWidth}px` : void 0,
+        "--seed-box-border-bottom-width": borderBottomWidth !== void 0 ? `${borderBottomWidth}px` : void 0,
+        "--seed-box-border-left-width": borderLeftWidth !== void 0 ? `${borderLeftWidth}px` : void 0,
+        "--seed-box-border-radius": handleRadius(borderRadius),
+        "--seed-box-border-top-left-radius": handleRadius(borderTopLeftRadius),
+        "--seed-box-border-top-right-radius": handleRadius(borderTopRightRadius),
+        "--seed-box-border-bottom-right-radius": handleRadius(borderBottomRightRadius),
+        "--seed-box-border-bottom-left-radius": handleRadius(borderBottomLeftRadius),
+        "--seed-box-width": handleSize(width),
+        "--seed-box-min-width": handleSize(minWidth),
+        "--seed-box-max-width": handleSize(maxWidth),
+        "--seed-box-height": handleSize(height),
+        "--seed-box-min-height": handleSize(minHeight),
+        "--seed-box-max-height": handleSize(maxHeight),
+        "--seed-box-padding": handleDimension(padding),
+        "--seed-box-padding-x": handleDimension(paddingX),
+        "--seed-box-padding-y": handleDimension(paddingY),
+        "--seed-box-padding-top": handleDimension(paddingTop),
+        "--seed-box-padding-right": handleDimension(paddingRight),
+        "--seed-box-padding-bottom": handleDimension(paddingBottom),
+        "--seed-box-padding-left": handleDimension(paddingLeft),
+        "--seed-box-gap": handleDimension(gap),
+        "--seed-box-display": handleDisplay(display),
+        "--seed-box-position": position,
+        "--seed-box-overflow-x": overflowX,
+        "--seed-box-overflow-y": overflowY,
+        "--seed-box-flex-grow": flexGrow,
+        "--seed-box-flex-shrink": flexShrink,
+        "--seed-box-flex-direction": handleFlexDirection(flexDirection),
+        "--seed-box-flex-wrap": flexWrap,
+        "--seed-box-justify-content": handleJustifyContent(justifyContent),
+        "--seed-box-align-items": handleAlignItems(alignItems),
+        "--seed-box-align-content": handleAlignItems(alignContent),
+        "--seed-box-align-self": handleAlignItems(alignSelf),
+        ...style
+      },
+      ...nativeProps
+    }
+  );
+});
+
+// src/components/BottomSheet/BottomSheet.tsx
+var { withRootProvider: withRootProvider2, withContext: withContext6 } = createStyleContext(bottomSheet);
+var withStateProps3 = createWithStateProps([useDialogContext2]);
+var BottomSheetRoot = withRootProvider2(DialogPrimitive2.Root, {
+  defaultProps: {
+    lazyMount: true,
+    unmountOnExit: true
+  }
+});
+var BottomSheetTrigger = DialogPrimitive2.Trigger;
+var BottomSheetPositioner = withContext6(
+  DialogPrimitive2.Positioner,
+  "positioner"
+);
+var BottomSheetBackdrop = withContext6(
+  DialogPrimitive2.Backdrop,
+  "backdrop"
+);
+var BottomSheetContent = withContext6(
+  DialogPrimitive2.Content,
+  "content"
+);
+var BottomSheetHeader = withContext6(
+  withStateProps3(Primitive7.div),
+  "header"
+);
+var BottomSheetTitle = withContext6(
+  withStateProps3(Primitive7.h2),
+  "title"
+);
+var BottomSheetDescription = withContext6(withStateProps3(Primitive7.p), "description");
+var BottomSheetBody = withContext6(
+  withStateProps3(Box),
+  "body"
+);
+var BottomSheetFooter = withContext6(
+  withStateProps3(Primitive7.div),
+  "footer"
+);
+var BottomSheetCloseButton = withContext6(
+  withStateProps3(Primitive7.button),
+  "closeButton"
+);
+var BottomSheetCloseIcon = withContext6(
+  Icon,
+  "closeIcon"
+);
+
+// src/components/BottomSheet/BottomSheet.namespace.ts
+var BottomSheet_namespace_exports = {};
+__export(BottomSheet_namespace_exports, {
+  Backdrop: () => BottomSheetBackdrop,
+  Body: () => BottomSheetBody,
+  CloseButton: () => BottomSheetCloseButton,
+  CloseIcon: () => BottomSheetCloseIcon,
+  Content: () => BottomSheetContent,
+  Description: () => BottomSheetDescription,
+  Footer: () => BottomSheetFooter,
+  Header: () => BottomSheetHeader,
+  Positioner: () => BottomSheetPositioner,
+  Root: () => BottomSheetRoot,
+  Title: () => BottomSheetTitle,
+  Trigger: () => BottomSheetTrigger
+});
+
+// src/components/Callout/Callout.tsx
+import clsx5 from "clsx";
+import * as React6 from "react";
+import { Primitive as Primitive9 } from "@seed-design/react-primitive";
+import { callout } from "@seed-design/recipe/callout";
+
+// src/components/private/useDismissible.tsx
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { buttonProps, elementProps as elementProps2, mergeProps } from "@seed-design/dom-utils";
+import { Primitive as Primitive8 } from "@seed-design/react-primitive";
+import * as React5 from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function useDismissible(props) {
+  const [open = true, setOpen] = useControllableState({
+    prop: props.open,
+    defaultProp: props.defaultOpen,
+    onChange: (open2) => {
+      var _a;
+      if (!open2) {
+        (_a = props.onDismiss) == null ? void 0 : _a.call(props);
+      }
+    }
+  });
+  const dismiss = React5.useCallback(() => setOpen(false), [setOpen]);
+  return {
+    open,
+    dismiss,
+    rootProps: elementProps2({}),
+    dismissButtonProps: buttonProps({
+      onClick: (e) => {
+        if (e.defaultPrevented) return;
+        dismiss();
+      }
+    })
+  };
+}
+var DismissibleContext = React5.createContext(null);
+var DismissibleProvider = DismissibleContext.Provider;
+var useDismissibleContext = () => {
+  const context = React5.useContext(DismissibleContext);
+  if (context === null) {
+    throw new Error("useDismissibleContext should be used within DismissibleProvider");
+  }
+  return context;
+};
+var DismissibleRoot = React5.forwardRef(
+  ({ defaultOpen, open, onDismiss, ...otherProps }, ref) => {
+    const api = useDismissible({ defaultOpen, open, onDismiss });
+    if (!api.open) return null;
+    return /* @__PURE__ */ jsx7(DismissibleProvider, { value: api, children: /* @__PURE__ */ jsx7(Primitive8.div, { ref, ...otherProps }) });
+  }
+);
+var DismissibleDismissButton = React5.forwardRef((props, ref) => {
+  const { dismissButtonProps } = useDismissibleContext();
+  return /* @__PURE__ */ jsx7(Primitive8.button, { ref, ...mergeProps(dismissButtonProps, props) });
+});
+
+// src/components/Callout/Callout.tsx
+import { Fragment, jsx as jsx8, jsxs } from "react/jsx-runtime";
+var { withContext: withContext7, withProvider: withProvider4, useClassNames } = createStyleContext(callout);
+var CalloutRoot = withProvider4(DismissibleRoot, "root");
+var CalloutIcon = withContext7(Icon, "icon");
+var CalloutTextContent = withContext7(
+  Primitive9.div,
+  "textContent"
+);
+var CalloutTitle = React6.forwardRef(
+  ({ className, ...otherProps }, ref) => {
+    const classNames = useClassNames();
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx8(Primitive9.span, { ref, className: clsx5(classNames.title, className), ...otherProps }),
+      /* @__PURE__ */ jsx8(Primitive9.span, { className: classNames.spacer, children: " " })
+    ] });
+  }
+);
+CalloutTitle.displayName = "CalloutTitle";
+var CalloutDescription = withContext7(
+  Primitive9.span,
+  "description"
+);
+var CalloutLink = React6.forwardRef(
+  ({ className, ...otherProps }, ref) => {
+    const classNames = useClassNames();
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx8(Primitive9.span, { className: classNames.spacer, children: " " }),
+      /* @__PURE__ */ jsx8(
+        Primitive9.button,
+        {
+          ref,
+          className: clsx5(classNames.linkLabel, className),
+          ...otherProps
+        }
+      )
+    ] });
+  }
+);
+CalloutLink.displayName = "CalloutLink";
+var CalloutDismissButton = withContext7(
+  DismissibleDismissButton,
+  "dismissButton"
+);
+var CalloutDismissIcon = withContext7(
+  Icon,
+  "dismissIcon"
+);
+var CalloutActionableIcon = withContext7(
+  Icon,
+  "actionableIcon"
+);
+
+// src/components/Callout/Callout.namespace.ts
+var Callout_namespace_exports = {};
+__export(Callout_namespace_exports, {
+  ActionableIcon: () => CalloutActionableIcon,
+  Description: () => CalloutDescription,
+  DismissButton: () => CalloutDismissButton,
+  DismissIcon: () => CalloutDismissIcon,
+  Icon: () => CalloutIcon,
+  Link: () => CalloutLink,
+  Root: () => CalloutRoot,
+  TextContent: () => CalloutTextContent,
+  Title: () => CalloutTitle
+});
+
+// src/components/Celcius/Celcius.tsx
+var Celcius = (props) => {
+  return `${props.value}\xB0C`;
+};
+
+// src/components/Checkbox/Checkbox.tsx
+import { mergeProps as mergeProps2 } from "@seed-design/dom-utils";
+import { Checkbox as CheckboxPrimitive, useCheckboxContext } from "@seed-design/react-checkbox";
+import { Primitive as Primitive10 } from "@seed-design/react-primitive";
+import { checkbox } from "@seed-design/recipe/checkbox";
+import { forwardRef as forwardRef9 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var { withProvider: withProvider5, withContext: withContext8, useClassNames: useClassNames2 } = createStyleContext(checkbox);
+var withStateProps4 = createWithStateProps([useCheckboxContext]);
+var CheckboxRoot = withProvider5(
+  CheckboxPrimitive.Root,
+  "root"
+);
+var CheckboxControl = withContext8(
+  CheckboxPrimitive.Control,
+  "control"
+);
+var CheckboxIndicator = forwardRef9(
+  ({
+    unchecked: uncheckedSvg,
+    checked: checkedSvg,
+    indeterminate: indeterminateSvg,
+    ...otherProps
+  }, ref) => {
+    const { stateProps, checked, indeterminate } = useCheckboxContext();
+    const classNames = useClassNames2();
+    const mergedProps = mergeProps2(
+      stateProps,
+      { className: classNames.icon },
+      otherProps
+    );
+    if (indeterminate && !indeterminateSvg) {
+      console.warn(
+        "CheckboxIndicator: the `indeterminate` prop must be provided when the checkbox is in an indeterminate state."
+      );
+    }
+    if (indeterminate) return /* @__PURE__ */ jsx9(Icon, { ref, svg: indeterminateSvg, ...mergedProps });
+    if (checked) return /* @__PURE__ */ jsx9(Icon, { ref, svg: checkedSvg, ...mergedProps });
+    if (uncheckedSvg) return /* @__PURE__ */ jsx9(Icon, { ref, svg: uncheckedSvg, ...mergedProps });
+    return null;
+  }
+);
+CheckboxIndicator.displayName = "CheckboxIndicator";
+var CheckboxLabel = withContext8(
+  withStateProps4(Primitive10.span),
+  "label"
+);
+var CheckboxHiddenInput = CheckboxPrimitive.HiddenInput;
+
+// src/components/Checkbox/Checkbox.namespace.ts
+var Checkbox_namespace_exports = {};
+__export(Checkbox_namespace_exports, {
+  Control: () => CheckboxControl,
+  HiddenInput: () => CheckboxHiddenInput,
+  Indicator: () => CheckboxIndicator,
+  Label: () => CheckboxLabel,
+  Root: () => CheckboxRoot
+});
+
+// src/components/ChipTabs/ChipTabs.tsx
+import { Primitive as Primitive11 } from "@seed-design/react-primitive";
+import {
+  Tabs as TabsPrimitive,
+  useTabsContext,
+  useTabsTriggerContext
+} from "@seed-design/react-tabs";
+import { chipTabs } from "@seed-design/recipe/chipTabs";
+var { withProvider: withProvider6, withContext: withContext9 } = createStyleContext(chipTabs);
+var withStateProps5 = createWithStateProps([useTabsContext, useTabsTriggerContext], {
+  strict: false
+});
+var ChipTabsRoot = withProvider6(
+  TabsPrimitive.Root,
+  "root"
+);
+var ChipTabsList = withContext9(
+  TabsPrimitive.List,
+  "list"
+);
+var ChipTabsTrigger = withContext9(
+  TabsPrimitive.Trigger,
+  "trigger"
+);
+var ChipTabsTriggerLabel = withContext9(
+  withStateProps5(Primitive11.span),
+  "triggerLabel"
+);
+var ChipTabsContent = withContext9(
+  TabsPrimitive.Content,
+  "content"
+);
+var ChipTabsCarousel = withContext9(
+  TabsPrimitive.Carousel,
+  "carousel"
+);
+var ChipTabsCarouselCamera = withContext9(
+  TabsPrimitive.CarouselCamera,
+  "carouselCamera"
+);
+
+// src/components/ChipTabs/ChipTabs.namespace.ts
+var ChipTabs_namespace_exports = {};
+__export(ChipTabs_namespace_exports, {
+  Carousel: () => ChipTabsCarousel,
+  CarouselCamera: () => ChipTabsCarouselCamera,
+  Content: () => ChipTabsContent,
+  List: () => ChipTabsList,
+  Root: () => ChipTabsRoot,
+  Trigger: () => ChipTabsTrigger,
+  TriggerLabel: () => ChipTabsTriggerLabel
+});
+
+// src/components/Columns/Columns.tsx
+import * as React7 from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var Columns = React7.forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx10(
+    Box,
+    {
+      ref,
+      display: "flex",
+      flexDirection: "row",
+      flexWrap: "nowrap",
+      justifyContent: "flexStart",
+      ...props
+    }
+  );
+});
+var Column = React7.forwardRef((props, ref) => {
+  const { width, ...otherProps } = props;
+  return /* @__PURE__ */ jsx10(
+    Box,
+    {
+      ref,
+      display: "flex",
+      flexDirection: "column",
+      width: width !== "content" ? "full" : void 0,
+      flexShrink: width ? 0 : void 0,
+      flexGrow: width ? 0 : 1,
+      ...otherProps
+    }
+  );
+});
+
+// src/components/ControlChip/ControlChip.tsx
+import { useCheckboxContext as useCheckboxContext2 } from "@seed-design/react-checkbox";
+import { Primitive as Primitive12 } from "@seed-design/react-primitive";
+import { useRadioGroupItemContext } from "@seed-design/react-radio-group";
+import { controlChip } from "@seed-design/recipe/controlChip";
+var { withProvider: withProvider7, withContext: withContext10 } = createStyleContext(controlChip);
+var withStateProps6 = createWithStateProps([useCheckboxContext2, useRadioGroupItemContext], {
+  strict: false
+});
+var ControlChipRoot = withProvider7(
+  Primitive12.button,
+  "root"
+);
+var ControlChipLabel = withContext10(
+  withStateProps6(Primitive12.span),
+  "label"
+);
+var ControlChipPrefixIcon = withContext10(
+  withStateProps6(Icon),
+  "prefixIcon"
+);
+var ControlChipSuffixIcon = withContext10(
+  withStateProps6(Icon),
+  "suffixIcon"
+);
+var ControlChipIcon = withContext10(
+  withStateProps6(Icon),
+  "icon"
+);
+var ControlChipCount = withContext10(
+  withStateProps6(Primitive12.span),
+  "count"
+);
+
+// src/components/ControlChip/ControlChip.namespace.ts
+var ControlChip_namespace_exports = {};
+__export(ControlChip_namespace_exports, {
+  Count: () => ControlChipCount,
+  Icon: () => ControlChipIcon,
+  Label: () => ControlChipLabel,
+  PrefixIcon: () => ControlChipPrefixIcon,
+  Root: () => ControlChipRoot,
+  SuffixIcon: () => ControlChipSuffixIcon
+});
+
+// src/components/Dialog/Dialog.tsx
+import { Dialog as DialogPrimitive3, useDialogContext as useDialogContext3 } from "@seed-design/react-dialog";
+import { Primitive as Primitive13 } from "@seed-design/react-primitive";
+import { dialog } from "@seed-design/recipe/dialog";
+import { forwardRef as forwardRef11 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var { withRootProvider: withRootProvider3, withContext: withContext11 } = createStyleContext(dialog);
+var withStateProps7 = createWithStateProps([useDialogContext3]);
+var DialogRoot = withRootProvider3(DialogPrimitive3.Root, {
+  defaultProps: {
+    lazyMount: true,
+    unmountOnExit: true
+  }
+});
+var DialogTrigger = DialogPrimitive3.Trigger;
+var DialogPositioner = withContext11(
+  DialogPrimitive3.Positioner,
+  "positioner"
+);
+var DialogBackdrop = withContext11(
+  DialogPrimitive3.Backdrop,
+  "backdrop"
+);
+var DialogContent = withContext11(
+  DialogPrimitive3.Content,
+  "content"
+);
+var DialogHeader = withContext11(Primitive13.div, "header");
+var DialogTitle = withContext11(
+  withStateProps7(Primitive13.span),
+  "title"
+);
+var DialogDescription = withContext11(
+  withStateProps7(Primitive13.div),
+  "description"
+);
+var DialogFooter = withContext11(Primitive13.div, "footer");
+var DialogAction = forwardRef11((props, ref) => {
+  const api = useDialogContext3();
+  return /* @__PURE__ */ jsx11(Primitive13.button, { ...props, ref, onClick: () => api.setOpen(false) });
+});
+
+// src/components/Dialog/Dialog.namespace.ts
+var Dialog_namespace_exports = {};
+__export(Dialog_namespace_exports, {
+  Action: () => DialogAction,
+  Backdrop: () => DialogBackdrop,
+  Content: () => DialogContent,
+  Description: () => DialogDescription,
+  Footer: () => DialogFooter,
+  Header: () => DialogHeader,
+  Positioner: () => DialogPositioner,
+  Root: () => DialogRoot,
+  Title: () => DialogTitle,
+  Trigger: () => DialogTrigger
+});
+
+// src/components/ExtendedActionSheet/ExtendedActionSheet.tsx
+import { Dialog as DialogPrimitive4, useDialogContext as useDialogContext4 } from "@seed-design/react-dialog";
+import { Primitive as Primitive14 } from "@seed-design/react-primitive";
+import {
+  extendedActionSheet
+} from "@seed-design/recipe/extendedActionSheet";
+import {
+  extendedActionSheetCloseButton
+} from "@seed-design/recipe/extendedActionSheetCloseButton";
+import {
+  extendedActionSheetItem
+} from "@seed-design/recipe/extendedActionSheetItem";
+var { withRootProvider: withRootProvider4, withContext: withContext12 } = createStyleContext(extendedActionSheet);
+var { withProvider: withItemProvider2, withContext: withItemContext2 } = createStyleContext(extendedActionSheetItem);
+var { withProvider: withCloseButtonProvider2, withContext: withCloseButtonContext2 } = createStyleContext(extendedActionSheetCloseButton);
+var withStateProps8 = createWithStateProps([useDialogContext4]);
+var ExtendedActionSheetRoot = withRootProvider4(
+  DialogPrimitive4.Root,
+  {
+    defaultProps: {
+      lazyMount: true,
+      unmountOnExit: true
+    }
+  }
+);
+var ExtendedActionSheetTrigger = DialogPrimitive4.Trigger;
+var ExtendedActionSheetPositioner = withContext12(DialogPrimitive4.Positioner, "positioner");
+var ExtendedActionSheetBackdrop = withContext12(DialogPrimitive4.Backdrop, "backdrop");
+var ExtendedActionSheetContent = withContext12(DialogPrimitive4.Content, "content");
+var ExtendedActionSheetHeader = withContext12(withStateProps8(Primitive14.div), "header");
+var ExtendedActionSheetTitle = withContext12(withStateProps8(Primitive14.h2), "title");
+var ExtendedActionSheetList = withContext12(
+  withStateProps8(Primitive14.div),
+  "list"
+);
+var ExtendedActionSheetGroup = withContext12(
+  withStateProps8(Primitive14.div),
+  "group"
+);
+var ExtendedActionSheetItem = withItemProvider2(withStateProps8(Primitive14.button), "root");
+var ExtendedActionSheetItemLabel = withItemContext2(withStateProps8(Primitive14.span), "label");
+var ExtendedActionSheetItemPrefixIcon = withItemContext2(withStateProps8(Icon), "prefixIcon");
+var ExtendedActionSheetFooter = withContext12(withStateProps8(Primitive14.div), "footer");
+var ExtendedActionSheetCloseButton = withCloseButtonProvider2(DialogPrimitive4.CloseButton, "root");
+var ExtendedActionSheetCloseButtonLabel = withCloseButtonContext2(Primitive14.span, "label");
+
+// src/components/ExtendedActionSheet/ExtendedActionSheet.namespace.ts
+var ExtendedActionSheet_namespace_exports = {};
+__export(ExtendedActionSheet_namespace_exports, {
+  Backdrop: () => ExtendedActionSheetBackdrop,
+  CloseButton: () => ExtendedActionSheetCloseButton,
+  CloseButtonLabel: () => ExtendedActionSheetCloseButtonLabel,
+  Content: () => ExtendedActionSheetContent,
+  Footer: () => ExtendedActionSheetFooter,
+  Group: () => ExtendedActionSheetGroup,
+  Header: () => ExtendedActionSheetHeader,
+  Item: () => ExtendedActionSheetItem,
+  ItemLabel: () => ExtendedActionSheetItemLabel,
+  ItemPrefixIcon: () => ExtendedActionSheetItemPrefixIcon,
+  List: () => ExtendedActionSheetList,
+  Positioner: () => ExtendedActionSheetPositioner,
+  Root: () => ExtendedActionSheetRoot,
+  Title: () => ExtendedActionSheetTitle,
+  Trigger: () => ExtendedActionSheetTrigger
+});
+
+// src/components/ExtendedFab/ExtendedFab.tsx
+import { Primitive as Primitive15 } from "@seed-design/react-primitive";
+import { extendedFab } from "@seed-design/recipe/extendedFab";
+var { withContext: withContext13, withProvider: withProvider8 } = createStyleContext(extendedFab);
+var ExtendedFabRoot = withProvider8(
+  Primitive15.button,
+  "root",
+  {
+    defaultProps: {
+      variant: "neutralSolid",
+      size: "medium"
+    }
+  }
+);
+var ExtendedFabLabel = withContext13(
+  Primitive15.span,
+  "label"
+);
+var ExtendedFabPrefixIcon = withContext13(
+  Icon,
+  "prefixIcon"
+);
+
+// src/components/ExtendedFab/ExtendedFab.namespace.ts
+var ExtendedFab_namespace_exports = {};
+__export(ExtendedFab_namespace_exports, {
+  Label: () => ExtendedFabLabel,
+  PrefixIcon: () => ExtendedFabPrefixIcon,
+  Root: () => ExtendedFabRoot
+});
+
+// src/components/Fab/Fab.tsx
+import { Primitive as Primitive16 } from "@seed-design/react-primitive";
+import { fab } from "@seed-design/recipe/fab";
+var { withContext: withContext14, withProvider: withProvider9 } = createStyleContext(fab);
+var FabRoot = withProvider9(Primitive16.button, "root");
+var FabIcon = withContext14(Icon, "icon");
+
+// src/components/Fab/Fab.namespace.ts
+var Fab_namespace_exports = {};
+__export(Fab_namespace_exports, {
+  Icon: () => FabIcon,
+  Root: () => FabRoot
+});
+
+// src/components/Flex/Flex.tsx
+import * as React8 from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var Flex = React8.forwardRef((props, ref) => {
+  const { direction, wrap, ...rest } = props;
+  return /* @__PURE__ */ jsx12(Box, { ref, display: "flex", flexDirection: direction, flexWrap: wrap, ...rest });
+});
+
+// src/components/HelpBubble/HelpBubble.tsx
+import { Popover as PopoverPrimitive, usePopoverContext } from "@seed-design/react-popover";
+import { Primitive as Primitive17 } from "@seed-design/react-primitive";
+import { helpBubble } from "@seed-design/recipe/helpBubble";
+import { forwardRef as forwardRef13 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var { withRootProvider: withRootProvider5, withContext: withContext15 } = createStyleContext(helpBubble);
+var withStateProps9 = createWithStateProps([usePopoverContext]);
+var HelpBubbleRoot = withRootProvider5(PopoverPrimitive.Root, {
+  defaultProps: {
+    placement: "top",
+    gutter: 4,
+    overflowPadding: 16,
+    arrowPadding: 14,
+    flip: true,
+    slide: true,
+    strategy: "absolute"
+  }
+});
+var HelpBubbleAnchor = PopoverPrimitive.Anchor;
+var HelpBubbleTrigger = PopoverPrimitive.Trigger;
+var HelpBubblePositioner = withContext15(
+  PopoverPrimitive.Positioner,
+  "positioner"
+);
+var HelpBubbleBackdrop = withContext15(
+  withStateProps9(Primitive17.div),
+  "backdrop"
+);
+var HelpBubbleContent = withContext15(
+  withStateProps9(Box),
+  "content"
+);
+var HelpBubbleArrow = withContext15(
+  PopoverPrimitive.Arrow,
+  "arrow"
+);
+var HelpBubbleArrowTip = forwardRef13(
+  (props, ref) => {
+    var _a, _b;
+    const { tipRadius = 1, ...otherProps } = props;
+    const api = usePopoverContext();
+    const width = ((_a = api.rects.arrow) == null ? void 0 : _a.width) || 0;
+    const height = ((_b = api.rects.arrow) == null ? void 0 : _b.height) || 0;
+    const pathData = `M0,0
+      H${width}
+      L${width / 2 + tipRadius},${height - tipRadius}
+      Q${width / 2},${height} ${width / 2 - tipRadius},${height - tipRadius}
+      Z`;
+    return /* @__PURE__ */ jsx13(
+      "svg",
+      {
+        "aria-hidden": "true",
+        width,
+        height: width,
+        viewBox: `0 0 ${width} ${height > width ? height : width}`,
+        ref,
+        ...otherProps,
+        children: /* @__PURE__ */ jsx13("path", { stroke: "none", d: pathData })
+      }
+    );
+  }
+);
+var HelpBubbleCloseButton = withContext15(
+  PopoverPrimitive.CloseButton,
+  "closeButton"
+);
+var HelpBubbleCloseIcon = withContext15(
+  withStateProps9(Icon),
+  "closeIcon"
+);
+var HelpBubbleTitle = withContext15(
+  withStateProps9(Primitive17.span),
+  "title"
+);
+var HelpBubbleDescription = withContext15(
+  withStateProps9(Primitive17.div),
+  "description"
+);
+
+// src/components/HelpBubble/HelpBubble.namespace.ts
+var HelpBubble_namespace_exports = {};
+__export(HelpBubble_namespace_exports, {
+  Anchor: () => HelpBubbleAnchor,
+  Arrow: () => HelpBubbleArrow,
+  ArrowTip: () => HelpBubbleArrowTip,
+  Backdrop: () => HelpBubbleBackdrop,
+  CloseButton: () => HelpBubbleCloseButton,
+  CloseIcon: () => HelpBubbleCloseIcon,
+  Content: () => HelpBubbleContent,
+  Description: () => HelpBubbleDescription,
+  Positioner: () => HelpBubblePositioner,
+  Root: () => HelpBubbleRoot,
+  Title: () => HelpBubbleTitle,
+  Trigger: () => HelpBubbleTrigger
+});
+
+// src/components/Inline/Inline.tsx
+import * as React9 from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var Inline = React9.forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx14(
+    Box,
+    {
+      ref,
+      display: "flex",
+      flexDirection: "row",
+      flexWrap: "wrap",
+      alignItems: "flexStart",
+      justifyContent: "flexStart",
+      ...props
+    }
+  );
+});
+
+// src/components/InlineBanner/InlineBanner.tsx
+import clsx6 from "clsx";
+import * as React10 from "react";
+import { Primitive as Primitive18 } from "@seed-design/react-primitive";
+import { inlineBanner } from "@seed-design/recipe/inlineBanner";
+import { Fragment as Fragment2, jsx as jsx15, jsxs as jsxs2 } from "react/jsx-runtime";
+var { withContext: withContext16, withProvider: withProvider10, useClassNames: useClassNames3 } = createStyleContext(inlineBanner);
+var InlineBannerRoot = withProvider10(
+  DismissibleRoot,
+  "root"
+);
+var InlineBannerContent = withContext16(
+  Primitive18.div,
+  "content"
+);
+var InlineBannerIcon = withContext16(Icon, "icon");
+var InlineBannerTextContent = React10.forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx15(Primitive18.div, { ref, ...props });
+});
+InlineBannerTextContent.displayName = "InlineBannerTextContent";
+var InlineBannerTitle = React10.forwardRef(
+  ({ className, ...otherProps }, ref) => {
+    const classNames = useClassNames3();
+    return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx15(Primitive18.span, { ref, className: clsx6(classNames.title, className), ...otherProps }),
+      /* @__PURE__ */ jsx15(Primitive18.span, { className: classNames.spacer, children: " " })
+    ] });
+  }
+);
+InlineBannerTitle.displayName = "InlineBannerTitle";
+var InlineBannerDescription = withContext16(
+  Primitive18.span,
+  "description"
+);
+var InlineBannerLink = withContext16(
+  Primitive18.button,
+  "linkLabel"
+);
+var InlineBannerDismissButton = withContext16(DismissibleDismissButton, "dismissButton");
+var InlineBannerDismissIcon = withContext16(
+  Icon,
+  "dismissIcon"
+);
+var InlineBannerActionableIcon = withContext16(Icon, "actionableIcon");
+
+// src/components/InlineBanner/InlineBanner.namespace.ts
+var InlineBanner_namespace_exports = {};
+__export(InlineBanner_namespace_exports, {
+  ActionableIcon: () => InlineBannerActionableIcon,
+  Content: () => InlineBannerContent,
+  Description: () => InlineBannerDescription,
+  DismissButton: () => InlineBannerDismissButton,
+  DismissIcon: () => InlineBannerDismissIcon,
+  Icon: () => InlineBannerIcon,
+  Link: () => InlineBannerLink,
+  Root: () => InlineBannerRoot,
+  TextContent: () => InlineBannerTextContent,
+  Title: () => InlineBannerTitle
+});
+
+// src/components/MannerTempBadge/MannerTempBadge.tsx
+import { Primitive as Primitive19 } from "@seed-design/react-primitive";
+import {
+  mannerTempBadge
+} from "@seed-design/recipe/mannerTempBadge";
+var { withProvider: withProvider11, withContext: withContext17 } = createStyleContext(mannerTempBadge);
+var MannerTempBadgeRoot = withProvider11(
+  Primitive19.span,
+  "root"
+);
+var MannerTempBadgeLabel = withContext17(
+  Primitive19.span,
+  "label"
+);
+
+// src/components/MannerTempBadge/MannerTempBadge.namespace.ts
+var MannerTempBadge_namespace_exports = {};
+__export(MannerTempBadge_namespace_exports, {
+  Label: () => MannerTempBadgeLabel,
+  Root: () => MannerTempBadgeRoot
+});
+
+// src/components/ProgressCircle/ProgressCircle.tsx
+import { ProgressCircle as ProgressCirclePrimitive } from "@seed-design/react-progress";
+import {
+  progressCircle
+} from "@seed-design/recipe/progressCircle";
+var { withContext: withContext18, withProvider: withProvider12 } = createStyleContext(progressCircle);
+var ProgressCircleRoot = withProvider12(
+  ProgressCirclePrimitive.Root,
+  "root"
+);
+var ProgressCircleTrack = withContext18(
+  ProgressCirclePrimitive.Track,
+  "track"
+);
+var ProgressCircleRange = withContext18(
+  ProgressCirclePrimitive.Range,
+  "range"
+);
+
+// src/components/ProgressCircle/ProgressCircle.namespace.ts
+var ProgressCircle_namespace_exports = {};
+__export(ProgressCircle_namespace_exports, {
+  Range: () => ProgressCircleRange,
+  Root: () => ProgressCircleRoot,
+  Track: () => ProgressCircleTrack
+});
+
+// src/components/PullToRefresh/PullToRefresh.tsx
+import { PullToRefresh as PullToRefreshPrimitive } from "@seed-design/react-pull-to-refresh";
+import { pullToRefresh } from "@seed-design/recipe/pullToRefresh";
+var { withContext: withContext19, withProvider: withProvider13 } = createStyleContext(pullToRefresh);
+var PullToRefreshRoot = withProvider13(
+  PullToRefreshPrimitive.Root,
+  "root"
+);
+var PullToRefreshIndicator = withContext19(
+  PullToRefreshPrimitive.Indicator,
+  "indicator"
+);
+var PullToRefreshContent = PullToRefreshPrimitive.Content;
+
+// src/components/PullToRefresh/PullToRefresh.namespace.ts
+var PullToRefresh_namespace_exports = {};
+__export(PullToRefresh_namespace_exports, {
+  Content: () => PullToRefreshContent,
+  Indicator: () => PullToRefreshIndicator,
+  Root: () => PullToRefreshRoot
+});
+
+// src/components/ReactionButton/ReactionButton.tsx
+import { Primitive as Primitive20 } from "@seed-design/react-primitive";
+import { Toggle as TogglePrimitive, useToggleContext } from "@seed-design/react-toggle";
+import {
+  reactionButton
+} from "@seed-design/recipe/reactionButton";
+import clsx7 from "clsx";
+import * as React11 from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var { ClassNamesProvider: ClassNamesProvider2, withContext: withContext20 } = createStyleContext(reactionButton);
+var withStateProps10 = createWithStateProps([usePendingButtonContext, useToggleContext]);
+var ReactionButtonRoot = React11.forwardRef(
+  ({ size = "small", loading = false, className, ...otherProps }, ref) => {
+    const classNames = reactionButton({ size });
+    const api = usePendingButton({ loading, disabled: otherProps.disabled });
+    return /* @__PURE__ */ jsx16(ClassNamesProvider2, { value: classNames, children: /* @__PURE__ */ jsx16(PendingButtonProvider, { value: api, children: /* @__PURE__ */ jsx16(
+      TogglePrimitive.Root,
+      {
+        ref,
+        className: clsx7(classNames.root, className),
+        ...api.stateProps,
+        ...otherProps
+      }
+    ) }) });
+  }
+);
+ReactionButtonRoot.displayName = "ReactionButton";
+var ReactionButtonLabel = withContext20(
+  withStateProps10(Primitive20.span),
+  "label"
+);
+var ReactionButtonCount = withContext20(
+  withStateProps10(Primitive20.span),
+  "count"
+);
+var ReactionButtonPrefixIcon = withContext20(
+  withStateProps10(Icon),
+  "prefixIcon"
+);
+var ReactionButtonProgressIndicator = withContext20(withStateProps10(Primitive20.div), "progressIndicator");
+
+// src/components/ReactionButton/ReactionButton.namespace.ts
+var ReactionButton_namespace_exports = {};
+__export(ReactionButton_namespace_exports, {
+  Count: () => ReactionButtonCount,
+  Label: () => ReactionButtonLabel,
+  PrefixIcon: () => ReactionButtonPrefixIcon,
+  ProgressIndicator: () => ReactionButtonProgressIndicator,
+  Root: () => ReactionButtonRoot
+});
+
+// src/components/SegmentedControl/SegmentedControl.tsx
+import { Primitive as Primitive21 } from "@seed-design/react-primitive";
+import {
+  SegmentedControl as SegmentedControlPrimitive,
+  useSegmentedControlItemContext
+} from "@seed-design/react-segmented-control";
+import {
+  segmentedControl
+} from "@seed-design/recipe/segmentedControl";
+var { withProvider: withProvider14, withContext: withContext21 } = createStyleContext(segmentedControl);
+var withStateProps11 = createWithStateProps([useSegmentedControlItemContext]);
+var SegmentedControlRoot = withProvider14(
+  SegmentedControlPrimitive.Root,
+  "root"
+);
+var SegmentedControlIndicator = withContext21(Primitive21.div, "indicator");
+var SegmentedControlItem = withContext21(
+  SegmentedControlPrimitive.Item,
+  "item"
+);
+var SegmentedControlItemHiddenInput = SegmentedControlPrimitive.ItemHiddenInput;
+var SegmentedControlItemLabel = withContext21(withStateProps11(Primitive21.span), "itemLabel");
+
+// src/components/SegmentedControl/SegmentedControl.namespace.ts
+var SegmentedControl_namespace_exports = {};
+__export(SegmentedControl_namespace_exports, {
+  Indicator: () => SegmentedControlIndicator,
+  Item: () => SegmentedControlItem,
+  Root: () => SegmentedControlRoot,
+  SegmentHiddenInput: () => SegmentedControlItemHiddenInput,
+  SegmentLabel: () => SegmentedControlItemLabel
+});
+
+// src/components/SelectBox/CheckSelectBox.tsx
+import { Checkbox as CheckboxPrimitive2, useCheckboxContext as useCheckboxContext3 } from "@seed-design/react-checkbox";
+import { Primitive as Primitive22 } from "@seed-design/react-primitive";
+import { selectBox } from "@seed-design/recipe/selectBox";
+import { selectBoxGroup } from "@seed-design/recipe/selectBoxGroup";
+import { forwardRef as forwardRef17 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var { withProvider: withGroupProvider } = createStyleContext(selectBoxGroup);
+var { withProvider: withProvider15, withContext: withContext22 } = createStyleContext(selectBox);
+var withStateProps12 = createWithStateProps([useCheckboxContext3]);
+var CheckSelectBoxGroup = withGroupProvider(
+  forwardRef17((props, ref) => /* @__PURE__ */ jsx17(Primitive22.div, { ref, role: "group", ...props })),
+  "root"
+);
+var CheckSelectBoxRoot = withProvider15(
+  CheckboxPrimitive2.Root,
+  "root"
+);
+var CheckSelectBoxContent = withContext22(
+  withStateProps12(Primitive22.div),
+  "content"
+);
+var CheckSelectBoxLabel = withContext22(
+  withStateProps12(Primitive22.span),
+  "label"
+);
+var CheckSelectBoxDescription = withContext22(withStateProps12(Primitive22.span), "description");
+var CheckSelectBoxControl = withContext22(
+  CheckboxPrimitive2.Control,
+  "checkboxControl"
+);
+var CheckSelectBoxIcon = withContext22(
+  withStateProps12(Icon),
+  "checkboxIcon"
+);
+var CheckSelectBoxHiddenInput = CheckboxPrimitive2.HiddenInput;
+
+// src/components/SelectBox/RadioSelectBox.tsx
+import { Primitive as Primitive23 } from "@seed-design/react-primitive";
+import {
+  RadioGroup as RadioGroupPrimitive,
+  useRadioGroupItemContext as useRadioGroupItemContext2
+} from "@seed-design/react-radio-group";
+import { selectBox as selectBox2 } from "@seed-design/recipe/selectBox";
+import { selectBoxGroup as selectBoxGroup2 } from "@seed-design/recipe/selectBoxGroup";
+var { withProvider: withGroupProvider2 } = createStyleContext(selectBoxGroup2);
+var { withProvider: withProvider16, withContext: withContext23 } = createStyleContext(selectBox2);
+var withStateProps13 = createWithStateProps([useRadioGroupItemContext2]);
+var RadioSelectBoxRoot = withGroupProvider2(
+  RadioGroupPrimitive.Root,
+  "root"
+);
+var RadioSelectBoxItem = withProvider16(
+  RadioGroupPrimitive.Item,
+  "root"
+);
+var RadioSelectBoxContent = withContext23(
+  withStateProps13(Primitive23.div),
+  "content"
+);
+var RadioSelectBoxLabel = withContext23(
+  withStateProps13(Primitive23.span),
+  "label"
+);
+var RadioSelectBoxDescription = withContext23(withStateProps13(Primitive23.span), "description");
+var RadioSelectBoxControl = withContext23(
+  RadioGroupPrimitive.ItemControl,
+  "radioControl"
+);
+var RadioSelectBoxIcon = withContext23(
+  withStateProps13(Icon),
+  "radioIcon"
+);
+var RadioSelectBoxHiddenInput = RadioGroupPrimitive.ItemHiddenInput;
+
+// src/components/SelectBox/CheckSelectBox.namespace.ts
+var CheckSelectBox_namespace_exports = {};
+__export(CheckSelectBox_namespace_exports, {
+  Content: () => CheckSelectBoxContent,
+  Control: () => CheckSelectBoxControl,
+  Description: () => CheckSelectBoxDescription,
+  Group: () => CheckSelectBoxGroup,
+  HiddenInput: () => CheckSelectBoxHiddenInput,
+  Icon: () => CheckSelectBoxIcon,
+  Label: () => CheckSelectBoxLabel,
+  Root: () => CheckSelectBoxRoot
+});
+
+// src/components/SelectBox/RadioSelectBox.namespace.ts
+var RadioSelectBox_namespace_exports = {};
+__export(RadioSelectBox_namespace_exports, {
+  Content: () => RadioSelectBoxContent,
+  Control: () => RadioSelectBoxControl,
+  Description: () => RadioSelectBoxDescription,
+  HiddenInput: () => RadioSelectBoxHiddenInput,
+  Icon: () => RadioSelectBoxIcon,
+  Item: () => RadioSelectBoxItem,
+  Label: () => RadioSelectBoxLabel,
+  Root: () => RadioSelectBoxRoot
+});
+
+// src/components/Skeleton/Skeleton.tsx
+import { skeleton } from "@seed-design/recipe/skeleton";
+var { withProvider: withProvider17 } = createStyleContext(skeleton);
+var Skeleton = withProvider17(Box, "root");
+
+// src/components/Snackbar/Snackbar.tsx
+import { Primitive as Primitive24 } from "@seed-design/react-primitive";
+import { Snackbar as SnackbarPrimitive } from "@seed-design/react-snackbar";
+import { snackbar } from "@seed-design/recipe/snackbar";
+import { snackbarRegion } from "@seed-design/recipe/snackbarRegion";
+import { visuallyHidden } from "@seed-design/recipe/visuallyHidden";
+import clsx8 from "clsx";
+import { forwardRef as forwardRef18, useMemo as useMemo2 } from "react";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var { withProvider: withRegionProvider } = createStyleContext(snackbarRegion);
+var { withProvider: withProvider18, withContext: withContext24 } = createStyleContext(snackbar);
+var SnackbarRootProvider = SnackbarPrimitive.RootProvider;
+var SnackbarRegion = withRegionProvider(
+  SnackbarPrimitive.Region,
+  "root"
+);
+var SnackbarRoot = withProvider18(
+  SnackbarPrimitive.Root,
+  "root"
+);
+var SnackbarMessage = withContext24(
+  Primitive24.span,
+  "message"
+);
+var SnackbarPrefixIcon = withContext24(
+  Icon,
+  "prefixIcon"
+);
+var SnackbarActionButton = withContext24(
+  Primitive24.button,
+  "actionButton"
+);
+var SnackbarCloseButton = forwardRef18(
+  (props, ref) => {
+    const { className, ...otherProps } = props;
+    const classNames = useMemo2(() => visuallyHidden(), []);
+    return /* @__PURE__ */ jsx18(
+      SnackbarPrimitive.CloseButton,
+      {
+        ref,
+        className: clsx8(classNames.root, className),
+        ...otherProps
+      }
+    );
+  }
+);
+var SnackbarRenderer = SnackbarPrimitive.Renderer;
+var SnackbarAvoidOverlap = SnackbarPrimitive.AvoidOverlap;
+
+// src/components/Snackbar/index.ts
+import {
+  useSnackbarContext as useSnackbarContext2
+} from "@seed-design/react-snackbar";
+
+// src/components/Snackbar/useSnackbarAdapter.ts
+import { useSnackbarContext } from "@seed-design/react-snackbar";
+import { useMemo as useMemo3 } from "react";
+function useSnackbarAdapter() {
+  const api = useSnackbarContext();
+  const adapter = useMemo3(
+    () => ({
+      visible: api.visible,
+      create: (options) => {
+        var _a, _b;
+        return api.create({
+          timeout: (_a = options.timeout) != null ? _a : 5e3,
+          removeDelay: (_b = options.removeDelay) != null ? _b : 200,
+          onClose: options.onClose,
+          render: options.render
+        });
+      },
+      dismiss: api.dismiss
+    }),
+    [api]
+  );
+  return adapter;
+}
+
+// src/components/Snackbar/Snackbar.namespace.ts
+var Snackbar_namespace_exports = {};
+__export(Snackbar_namespace_exports, {
+  ActionButton: () => SnackbarActionButton,
+  AvoidOverlap: () => SnackbarAvoidOverlap,
+  CloseButton: () => SnackbarCloseButton,
+  Message: () => SnackbarMessage,
+  PrefixIcon: () => SnackbarPrefixIcon,
+  Region: () => SnackbarRegion,
+  Renderer: () => SnackbarRenderer,
+  Root: () => SnackbarRoot,
+  RootProvider: () => SnackbarRootProvider
+});
+
+// src/components/Stack/Stack.tsx
+import * as React12 from "react";
+import { jsx as jsx19 } from "react/jsx-runtime";
+var Stack = React12.forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx19(Box, { ref, display: "flex", flexDirection: "column", ...props });
+});
+
+// src/components/Switch/Switch.tsx
+import { Switch as SwitchPrimitive, useSwitchContext } from "@seed-design/react-switch";
+import { switchStyle } from "@seed-design/recipe/switch";
+import { Primitive as Primitive25 } from "@seed-design/react-primitive";
+var { withProvider: withProvider19, withContext: withContext25 } = createStyleContext(switchStyle);
+var withStateProps14 = createWithStateProps([useSwitchContext]);
+var SwitchRoot = withProvider19(
+  SwitchPrimitive.Root,
+  "root"
+);
+var SwitchControl = withContext25(
+  SwitchPrimitive.Control,
+  "control"
+);
+var SwitchThumb = withContext25(
+  SwitchPrimitive.Thumb,
+  "thumb"
+);
+var SwitchLabel = withContext25(
+  withStateProps14(Primitive25.span),
+  "label"
+);
+var SwitchHiddenInput = SwitchPrimitive.HiddenInput;
+
+// src/components/Switch/Switch.namespace.ts
+var Switch_namespace_exports = {};
+__export(Switch_namespace_exports, {
+  Control: () => SwitchControl,
+  HiddenInput: () => SwitchHiddenInput,
+  Label: () => SwitchLabel,
+  Root: () => SwitchRoot,
+  Thumb: () => SwitchThumb
+});
+
+// src/components/Tabs/Tabs.tsx
+import { Primitive as Primitive26 } from "@seed-design/react-primitive";
+import {
+  Tabs as TabsPrimitive2,
+  useTabsContext as useTabsContext2,
+  useTabsTriggerContext as useTabsTriggerContext2
+} from "@seed-design/react-tabs";
+import { tabs } from "@seed-design/recipe/tabs";
+var { withProvider: withProvider20, withContext: withContext26 } = createStyleContext(tabs);
+var withStateProps15 = createWithStateProps([useTabsContext2, useTabsTriggerContext2], {
+  strict: false
+});
+var TabsRoot = withProvider20(TabsPrimitive2.Root, "root");
+var TabsList = withContext26(TabsPrimitive2.List, "list");
+var TabsTrigger = withContext26(
+  TabsPrimitive2.Trigger,
+  "trigger"
+);
+var TabsTriggerLabel = withContext26(
+  withStateProps15(Primitive26.span),
+  "triggerLabel"
+);
+var TabsTriggerNotification = withContext26(
+  withStateProps15(Primitive26.div),
+  "triggerNotification"
+);
+var TabsIndicator = withContext26(
+  TabsPrimitive2.Indicator,
+  "indicator"
+);
+var TabsContent = withContext26(
+  TabsPrimitive2.Content,
+  "content"
+);
+var TabsCarousel = withContext26(
+  TabsPrimitive2.Carousel,
+  "carousel"
+);
+var TabsCarouselCamera = withContext26(
+  TabsPrimitive2.CarouselCamera,
+  "carouselCamera"
+);
+
+// src/components/Tabs/Tabs.namespace.ts
+var Tabs_namespace_exports = {};
+__export(Tabs_namespace_exports, {
+  Carousel: () => TabsCarousel,
+  CarouselCamera: () => TabsCarouselCamera,
+  Content: () => TabsContent,
+  Indicator: () => TabsIndicator,
+  List: () => TabsList,
+  Root: () => TabsRoot,
+  Trigger: () => TabsTrigger,
+  TriggerLabel: () => TabsTriggerLabel,
+  TriggerNotification: () => TabsTriggerNotification
+});
+
+// src/components/Text/Text.tsx
+import { text } from "@seed-design/recipe/text";
+import {
+  vars as vars2
+} from "@seed-design/vars";
+import clsx9 from "clsx";
+import { useMemo as useMemo4 } from "react";
+import { jsx as jsx20 } from "react/jsx-runtime";
+function handleColor2(color) {
+  var _a;
+  if (!color) {
+    return void 0;
+  }
+  const [type, value] = color.split(".");
+  return (_a = vars2.$color[type][value]) != null ? _a : void 0;
+}
+function handleFontWeight(fontWeight) {
+  var _a;
+  if (!fontWeight) {
+    return void 0;
+  }
+  return (_a = vars2.$fontWeight[fontWeight]) != null ? _a : void 0;
+}
+function handleFontSize(size) {
+  var _a;
+  if (!size) {
+    return void 0;
+  }
+  return (_a = vars2.$fontSize[size]) != null ? _a : size;
+}
+function handleLineHeight(lineHeight) {
+  var _a;
+  if (!lineHeight) {
+    return void 0;
+  }
+  return (_a = vars2.$lineHeight[lineHeight]) != null ? _a : lineHeight;
+}
+function mapMaxLines(maxLines) {
+  if (maxLines === void 0) {
+    return "none";
+  }
+  if (maxLines === 1) {
+    return "single";
+  }
+  return "multi";
+}
+var Text = ({
+  as,
+  color,
+  textStyle,
+  fontSize,
+  lineHeight,
+  fontWeight,
+  maxLines,
+  children,
+  className,
+  style,
+  ...otherProps
+}) => {
+  const Comp = as || "span";
+  const classNames = useMemo4(
+    () => text({
+      textStyle,
+      maxLines: mapMaxLines(maxLines)
+    }),
+    [textStyle, maxLines]
+  );
+  return /* @__PURE__ */ jsx20(
+    Comp,
+    {
+      className: clsx9(classNames.root, className),
+      style: {
+        "--seed-max-lines": maxLines,
+        "--seed-text-color": handleColor2(color),
+        "--seed-font-size": handleFontSize(fontSize),
+        "--seed-line-height": handleLineHeight(lineHeight != null ? lineHeight : fontSize),
+        "--seed-font-weight": handleFontWeight(fontWeight),
+        "--seed-text-align": otherProps.align,
+        ...style
+      },
+      ...otherProps,
+      children
+    }
+  );
+};
+
+// src/components/TextButton/TextButton.tsx
+import { Primitive as Primitive27 } from "@seed-design/react-primitive";
+import { textButton } from "@seed-design/recipe/textButton";
+var { withProvider: withProvider21, withContext: withContext27 } = createStyleContext(textButton);
+var TextButtonRoot = withProvider21(
+  Primitive27.button,
+  "root"
+);
+var TextButtonLabel = withContext27(
+  Primitive27.span,
+  "label"
+);
+var TextButtonPrefixIcon = withContext27(
+  Icon,
+  "prefixIcon"
+);
+var TextButtonSuffixIcon = withContext27(
+  Icon,
+  "suffixIcon"
+);
+
+// src/components/TextButton/TextButton.namespace.ts
+var TextButton_namespace_exports = {};
+__export(TextButton_namespace_exports, {
+  Label: () => TextButtonLabel,
+  PrefixIcon: () => TextButtonPrefixIcon,
+  Root: () => TextButtonRoot,
+  SuffixIcon: () => TextButtonSuffixIcon
+});
+
+// src/components/TextField/TextField.tsx
+import { useLayoutEffect } from "@radix-ui/react-use-layout-effect";
+import { Primitive as Primitive28 } from "@seed-design/react-primitive";
+import { TextField, useTextFieldContext } from "@seed-design/react-text-field";
+import { textField } from "@seed-design/recipe/textField";
+import clsx10 from "clsx";
+import { forwardRef as forwardRef20, useCallback as useCallback2, useRef } from "react";
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import { Fragment as Fragment3, jsx as jsx21, jsxs as jsxs3 } from "react/jsx-runtime";
+var { withProvider: withProvider22, withContext: withContext28, useClassNames: useClassNames4 } = createStyleContext(textField);
+var withStateProps16 = createWithStateProps([useTextFieldContext]);
+var TextFieldRoot = withProvider22(
+  TextField.Root,
+  "root"
+);
+var TextFieldHeader = withContext28(
+  withStateProps16(Primitive28.div),
+  "header"
+);
+var TextFieldLabel = withContext28(
+  TextField.Label,
+  "label"
+);
+var TextFieldIndicator = forwardRef20(
+  (props, ref) => {
+    const { className, ...otherProps } = props;
+    const classNames = useClassNames4();
+    return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+      /* @__PURE__ */ jsx21(Primitive28.span, { children: " " }),
+      /* @__PURE__ */ jsx21(
+        Primitive28.span,
+        {
+          ref,
+          className: clsx10(classNames.indicator, className),
+          ...otherProps
+        }
+      )
+    ] });
+  }
+);
+var TextFieldField = withContext28(
+  withStateProps16(Primitive28.div),
+  "field"
+);
+var TextFieldPrefixIcon = withContext28(
+  withStateProps16(Icon),
+  "prefixIcon"
+);
+var TextFieldPrefixText = withContext28(
+  withStateProps16(Primitive28.span),
+  "prefixText"
+);
+var TextFieldSuffixIcon = withContext28(
+  withStateProps16(Icon),
+  "suffixIcon"
+);
+var TextFieldSuffixText = withContext28(
+  withStateProps16(Primitive28.span),
+  "suffixText"
+);
+var TextFieldInput = withContext28(
+  TextField.Input,
+  "value"
+);
+var TextFieldTextarea = forwardRef20(
+  (props, ref) => {
+    var _a;
+    const { className, autoresize = true, ...otherProps } = props;
+    const classNames = useClassNames4();
+    const { value } = useTextFieldContext();
+    const inputRef = useRef(null);
+    const onHeightChange = useCallback2(() => {
+      var _a2;
+      if (!inputRef.current) return;
+      if ((_a2 = otherProps.style) == null ? void 0 : _a2.height) return;
+      if (!autoresize) return;
+      const input = inputRef.current;
+      const prevAlignment = input.style.alignSelf;
+      const prevOverflow = input.style.overflow;
+      const isFirefox = "MozAppearance" in input.style;
+      if (!isFirefox) {
+        input.style.overflow = "hidden";
+      }
+      input.style.alignSelf = "start";
+      input.style.height = "auto";
+      input.style.height = `${input.scrollHeight + (input.offsetHeight - input.clientHeight)}px`;
+      input.style.overflow = prevOverflow;
+      input.style.alignSelf = prevAlignment;
+    }, [inputRef, (_a = otherProps.style) == null ? void 0 : _a.height, autoresize]);
+    useLayoutEffect(() => {
+      if (inputRef.current) {
+        onHeightChange();
+      }
+    }, [onHeightChange, value, inputRef]);
+    return /* @__PURE__ */ jsx21(
+      TextField.Textarea,
+      {
+        ref: composeRefs(inputRef, ref),
+        ...otherProps,
+        className: clsx10(classNames.value, className)
+      }
+    );
+  }
+);
+var TextFieldFooter = withContext28(
+  withStateProps16(Primitive28.div),
+  "footer"
+);
+var TextFieldDescription = withContext28(
+  TextField.Description,
+  "description"
+);
+var TextFieldErrorMessage = withContext28(
+  TextField.ErrorMessage,
+  "errorMessage"
+);
+var TextFieldErrorIcon = withContext28(
+  withStateProps16(Icon),
+  "errorIcon"
+);
+var TextFieldCharacterCountArea = withContext28(withStateProps16(Primitive28.div), "characterCountArea");
+var TextFieldCharacterCount = withContext28(
+  TextField.GraphemeCount,
+  "characterCount"
+);
+var TextFieldMaxCharacterCount = withContext28(withStateProps16(Primitive28.span), "maxCharacterCount");
+
+// src/components/TextField/TextField.namespace.tsx
+var TextField_namespace_exports = {};
+__export(TextField_namespace_exports, {
+  CharacterCount: () => TextFieldCharacterCount,
+  CharacterCountArea: () => TextFieldCharacterCountArea,
+  Description: () => TextFieldDescription,
+  ErrorIcon: () => TextFieldErrorIcon,
+  ErrorMessage: () => TextFieldErrorMessage,
+  Field: () => TextFieldField,
+  Footer: () => TextFieldFooter,
+  Header: () => TextFieldHeader,
+  Indicator: () => TextFieldIndicator,
+  Input: () => TextFieldInput,
+  Label: () => TextFieldLabel,
+  MaxCharacterCount: () => TextFieldMaxCharacterCount,
+  PrefixIcon: () => TextFieldPrefixIcon,
+  PrefixText: () => TextFieldPrefixText,
+  Root: () => TextFieldRoot,
+  SuffixIcon: () => TextFieldSuffixIcon,
+  SuffixText: () => TextFieldSuffixText,
+  Textarea: () => TextFieldTextarea
+});
+
+// src/components/ToggleButton/ToggleButton.tsx
+import { Primitive as Primitive29 } from "@seed-design/react-primitive";
+import { Toggle as TogglePrimitive2, useToggleContext as useToggleContext2 } from "@seed-design/react-toggle";
+import { toggleButton } from "@seed-design/recipe/toggleButton";
+import clsx11 from "clsx";
+import * as React13 from "react";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var { ClassNamesProvider: ClassNamesProvider3, withContext: withContext29 } = createStyleContext(toggleButton);
+var withStateProps17 = createWithStateProps([usePendingButtonContext, useToggleContext2]);
+var ToggleButtonRoot = React13.forwardRef(
+  ({ variant = "brandSolid", size = "small", loading = false, className, ...otherProps }, ref) => {
+    const classNames = toggleButton({ variant, size });
+    const api = usePendingButton({ loading, disabled: otherProps.disabled });
+    return /* @__PURE__ */ jsx22(ClassNamesProvider3, { value: classNames, children: /* @__PURE__ */ jsx22(PendingButtonProvider, { value: api, children: /* @__PURE__ */ jsx22(
+      TogglePrimitive2.Root,
+      {
+        ref,
+        className: clsx11(classNames.root, className),
+        ...api.stateProps,
+        ...otherProps
+      }
+    ) }) });
+  }
+);
+ToggleButtonRoot.displayName = "ToggleButton";
+var ToggleButtonLabel = withContext29(
+  withStateProps17(Primitive29.span),
+  "label"
+);
+var ToggleButtonPrefixIcon = withContext29(
+  withStateProps17(Icon),
+  "prefixIcon"
+);
+var ToggleButtonSuffixIcon = withContext29(
+  withStateProps17(Icon),
+  "suffixIcon"
+);
+var ToggleButtonProgressIndicator = withContext29(withStateProps17(Primitive29.div), "progressIndicator");
+
+// src/components/ToggleButton/ToggleButton.namespace.ts
+var ToggleButton_namespace_exports = {};
+__export(ToggleButton_namespace_exports, {
+  Label: () => ToggleButtonLabel,
+  PrefixIcon: () => ToggleButtonPrefixIcon,
+  ProgressIndicator: () => ToggleButtonProgressIndicator,
+  Root: () => ToggleButtonRoot,
+  SuffixIcon: () => ToggleButtonSuffixIcon
+});
+
+// src/components/VisuallyHidden/VisuallyHidden.tsx
+import { Primitive as Primitive30 } from "@seed-design/react-primitive";
+import { visuallyHidden as visuallyHidden2 } from "@seed-design/recipe/visuallyHidden";
+var { withProvider: withProvider23 } = createStyleContext(visuallyHidden2);
+var VisuallyHidden = withProvider23(
+  Primitive30.div,
+  "root"
+);
+export {
+  ActionButton_namespace_exports as ActionButton,
+  ActionButtonIcon,
+  ActionButtonLabel,
+  ActionButtonPrefixIcon,
+  ActionButtonProgressIndicator,
+  ActionButtonRoot,
+  ActionButtonSuffixIcon,
+  ActionChip_namespace_exports as ActionChip,
+  ActionChipCount,
+  ActionChipIcon,
+  ActionChipLabel,
+  ActionChipPrefixIcon,
+  ActionChipRoot,
+  ActionChipSuffixIcon,
+  ActionSheet_namespace_exports as ActionSheet,
+  ActionSheetBackdrop,
+  ActionSheetCloseButton,
+  ActionSheetCloseButtonLabel,
+  ActionSheetContent,
+  ActionSheetDescription,
+  ActionSheetHeader,
+  ActionSheetItem,
+  ActionSheetItemLabel,
+  ActionSheetList,
+  ActionSheetPositioner,
+  ActionSheetRoot,
+  ActionSheetTitle,
+  ActionSheetTrigger,
+  Avatar_namespace_exports as Avatar,
+  AvatarBadge,
+  AvatarFallback,
+  AvatarImage,
+  AvatarRoot,
+  AvatarStack,
+  Badge_namespace_exports as Badge,
+  BadgeLabel,
+  BadgeRoot,
+  BottomSheet_namespace_exports as BottomSheet,
+  BottomSheetBackdrop,
+  BottomSheetBody,
+  BottomSheetCloseButton,
+  BottomSheetCloseIcon,
+  BottomSheetContent,
+  BottomSheetDescription,
+  BottomSheetFooter,
+  BottomSheetHeader,
+  BottomSheetPositioner,
+  BottomSheetRoot,
+  BottomSheetTitle,
+  BottomSheetTrigger,
+  Box,
+  Callout_namespace_exports as Callout,
+  CalloutActionableIcon,
+  CalloutDescription,
+  CalloutDismissButton,
+  CalloutDismissIcon,
+  CalloutIcon,
+  CalloutLink,
+  CalloutRoot,
+  CalloutTextContent,
+  CalloutTitle,
+  Celcius,
+  CheckSelectBox_namespace_exports as CheckSelectBox,
+  CheckSelectBoxContent,
+  CheckSelectBoxControl,
+  CheckSelectBoxDescription,
+  CheckSelectBoxGroup,
+  CheckSelectBoxHiddenInput,
+  CheckSelectBoxIcon,
+  CheckSelectBoxLabel,
+  CheckSelectBoxRoot,
+  Checkbox_namespace_exports as Checkbox,
+  CheckboxControl,
+  CheckboxHiddenInput,
+  CheckboxIndicator,
+  CheckboxLabel,
+  CheckboxRoot,
+  ChipTabs_namespace_exports as ChipTabs,
+  ChipTabsCarousel,
+  ChipTabsCarouselCamera,
+  ChipTabsContent,
+  ChipTabsList,
+  ChipTabsRoot,
+  ChipTabsTrigger,
+  ChipTabsTriggerLabel,
+  Column,
+  Columns,
+  ControlChip_namespace_exports as ControlChip,
+  ControlChipCount,
+  ControlChipIcon,
+  ControlChipLabel,
+  ControlChipPrefixIcon,
+  ControlChipRoot,
+  ControlChipSuffixIcon,
+  Dialog_namespace_exports as Dialog,
+  DialogAction,
+  DialogBackdrop,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogPositioner,
+  DialogRoot,
+  DialogTitle,
+  DialogTrigger,
+  ExtendedActionSheet_namespace_exports as ExtendedActionSheet,
+  ExtendedActionSheetBackdrop,
+  ExtendedActionSheetCloseButton,
+  ExtendedActionSheetCloseButtonLabel,
+  ExtendedActionSheetContent,
+  ExtendedActionSheetFooter,
+  ExtendedActionSheetGroup,
+  ExtendedActionSheetHeader,
+  ExtendedActionSheetItem,
+  ExtendedActionSheetItemLabel,
+  ExtendedActionSheetItemPrefixIcon,
+  ExtendedActionSheetList,
+  ExtendedActionSheetPositioner,
+  ExtendedActionSheetRoot,
+  ExtendedActionSheetTitle,
+  ExtendedActionSheetTrigger,
+  ExtendedFab_namespace_exports as ExtendedFab,
+  ExtendedFabLabel,
+  ExtendedFabPrefixIcon,
+  ExtendedFabRoot,
+  Fab_namespace_exports as Fab,
+  FabIcon,
+  FabRoot,
+  Flex,
+  HelpBubble_namespace_exports as HelpBubble,
+  HelpBubbleAnchor,
+  HelpBubbleArrow,
+  HelpBubbleArrowTip,
+  HelpBubbleBackdrop,
+  HelpBubbleCloseButton,
+  HelpBubbleCloseIcon,
+  HelpBubbleContent,
+  HelpBubbleDescription,
+  HelpBubblePositioner,
+  HelpBubbleRoot,
+  HelpBubbleTitle,
+  HelpBubbleTrigger,
+  Inline,
+  InlineBanner_namespace_exports as InlineBanner,
+  InlineBannerActionableIcon,
+  InlineBannerContent,
+  InlineBannerDescription,
+  InlineBannerDismissButton,
+  InlineBannerDismissIcon,
+  InlineBannerIcon,
+  InlineBannerLink,
+  InlineBannerRoot,
+  InlineBannerTextContent,
+  InlineBannerTitle,
+  MannerTempBadge_namespace_exports as MannerTempBadge,
+  MannerTempBadgeLabel,
+  MannerTempBadgeRoot,
+  ProgressCircle_namespace_exports as ProgressCircle,
+  ProgressCircleRange,
+  ProgressCircleRoot,
+  ProgressCircleTrack,
+  PullToRefresh_namespace_exports as PullToRefresh,
+  PullToRefreshContent,
+  PullToRefreshIndicator,
+  PullToRefreshRoot,
+  RadioSelectBox_namespace_exports as RadioSelectBox,
+  RadioSelectBoxContent,
+  RadioSelectBoxControl,
+  RadioSelectBoxDescription,
+  RadioSelectBoxHiddenInput,
+  RadioSelectBoxIcon,
+  RadioSelectBoxItem,
+  RadioSelectBoxLabel,
+  RadioSelectBoxRoot,
+  ReactionButton_namespace_exports as ReactionButton,
+  ReactionButtonCount,
+  ReactionButtonLabel,
+  ReactionButtonPrefixIcon,
+  ReactionButtonProgressIndicator,
+  ReactionButtonRoot,
+  SegmentedControl_namespace_exports as SegmentedControl,
+  SegmentedControlIndicator,
+  SegmentedControlItem,
+  SegmentedControlItemHiddenInput,
+  SegmentedControlItemLabel,
+  SegmentedControlRoot,
+  Skeleton,
+  Snackbar_namespace_exports as Snackbar,
+  SnackbarActionButton,
+  SnackbarAvoidOverlap,
+  SnackbarCloseButton,
+  SnackbarMessage,
+  SnackbarPrefixIcon,
+  SnackbarRegion,
+  SnackbarRenderer,
+  SnackbarRoot,
+  SnackbarRootProvider,
+  Stack,
+  Switch_namespace_exports as Switch,
+  SwitchControl,
+  SwitchHiddenInput,
+  SwitchLabel,
+  SwitchRoot,
+  SwitchThumb,
+  Tabs_namespace_exports as Tabs,
+  TabsCarousel,
+  TabsCarouselCamera,
+  TabsContent,
+  TabsIndicator,
+  TabsList,
+  TabsRoot,
+  TabsTrigger,
+  TabsTriggerLabel,
+  TabsTriggerNotification,
+  Text,
+  TextButton_namespace_exports as TextButton,
+  TextButtonLabel,
+  TextButtonPrefixIcon,
+  TextButtonRoot,
+  TextButtonSuffixIcon,
+  TextField_namespace_exports as TextField,
+  TextFieldCharacterCount,
+  TextFieldCharacterCountArea,
+  TextFieldDescription,
+  TextFieldErrorIcon,
+  TextFieldErrorMessage,
+  TextFieldField,
+  TextFieldFooter,
+  TextFieldHeader,
+  TextFieldIndicator,
+  TextFieldInput,
+  TextFieldLabel,
+  TextFieldMaxCharacterCount,
+  TextFieldPrefixIcon,
+  TextFieldPrefixText,
+  TextFieldRoot,
+  TextFieldSuffixIcon,
+  TextFieldSuffixText,
+  TextFieldTextarea,
+  ToggleButton_namespace_exports as ToggleButton,
+  ToggleButtonLabel,
+  ToggleButtonPrefixIcon,
+  ToggleButtonProgressIndicator,
+  ToggleButtonRoot,
+  ToggleButtonSuffixIcon,
+  VisuallyHidden,
+  useSnackbarAdapter,
+  useSnackbarContext2 as useSnackbarContext
+};
+//# sourceMappingURL=index.mjs.map