@pathscale/ui 1.3.0 → 1.4.0

package/dist/components/toggle/Toggle.classes.d.ts

@@ -1,26 +0,0 @@
-export declare const CLASSES: {
-    readonly base: "toggle";
-    readonly slot: {
-        readonly input: "toggle__input";
-        readonly control: "toggle__control";
-        readonly thumb: "toggle__thumb";
-        readonly icon: "toggle__icon";
-        readonly content: "toggle__content";
-        readonly description: "toggle__description";
-    };
-    readonly color: {
-        readonly default: "toggle--default";
-        readonly accent: "toggle--accent";
-        readonly success: "toggle--success";
-        readonly warning: "toggle--warning";
-        readonly danger: "toggle--danger";
-    };
-    readonly size: {
-        readonly sm: "toggle--sm";
-        readonly md: "toggle--md";
-        readonly lg: "toggle--lg";
-    };
-    readonly flag: {
-        readonly disabled: "toggle--disabled";
-    };
-};

package/dist/components/toggle/Toggle.classes.js

@@ -1,27 +0,0 @@
-const CLASSES = {
-    base: "toggle",
-    slot: {
-        input: "toggle__input",
-        control: "toggle__control",
-        thumb: "toggle__thumb",
-        icon: "toggle__icon",
-        content: "toggle__content",
-        description: "toggle__description"
-    },
-    color: {
-        default: "toggle--default",
-        accent: "toggle--accent",
-        success: "toggle--success",
-        warning: "toggle--warning",
-        danger: "toggle--danger"
-    },
-    size: {
-        sm: "toggle--sm",
-        md: "toggle--md",
-        lg: "toggle--lg"
-    },
-    flag: {
-        disabled: "toggle--disabled"
-    }
-};
-export { CLASSES };

package/dist/components/toggle/Toggle.d.ts

@@ -1,16 +0,0 @@
-import "./Toggle.css";
-import { type Component, type JSX } from "solid-js";
-import type { IComponentBaseProps } from "../types";
-export type ToggleColor = "default" | "accent" | "success" | "warning" | "danger";
-export type ToggleSize = "sm" | "md" | "lg";
-export type ToggleProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "type" | "children" | "color"> & IComponentBaseProps & {
-    defaultChecked?: boolean;
-    children?: JSX.Element;
-    description?: JSX.Element;
-    icon?: JSX.Element;
-    isDisabled?: boolean;
-    color?: ToggleColor;
-    size?: ToggleSize;
-};
-declare const Toggle: Component<ToggleProps>;
-export default Toggle;

package/dist/components/toggle/Toggle.js

@@ -1,143 +0,0 @@
-import { createComponent, insert, mergeProps, spread, template } from "solid-js/web";
-import "./Toggle.css";
-import { Show, createSignal, splitProps } from "solid-js";
-import { twMerge } from "tailwind-merge";
-import { CLASSES } from "./Toggle.classes.js";
-var _tmpl$ = /*#__PURE__*/ template("<span>"), _tmpl$2 = /*#__PURE__*/ template("<span data-slot=label>"), _tmpl$3 = /*#__PURE__*/ template("<label><input><span><span>");
-const invokeEventHandler = (handler, event)=>{
-    if ("function" == typeof handler) return void handler(event);
-    if (Array.isArray(handler) && "function" == typeof handler[0]) handler[0](handler[1], event);
-};
-const Toggle = (props)=>{
-    const [local, others] = splitProps(props, [
-        "class",
-        "className",
-        "children",
-        "description",
-        "icon",
-        "isDisabled",
-        "color",
-        "size",
-        "checked",
-        "defaultChecked",
-        "disabled",
-        "onChange",
-        "dataTheme"
-    ]);
-    const [internalSelected, setInternalSelected] = createSignal(Boolean(local.defaultChecked));
-    const isControlled = ()=>void 0 !== local.checked;
-    const isSelected = ()=>isControlled() ? Boolean(local.checked) : internalSelected();
-    const isDisabled = ()=>Boolean(local.isDisabled) || Boolean(local.disabled);
-    const color = ()=>local.color ?? "accent";
-    const size = ()=>local.size ?? "md";
-    const hasContent = ()=>null != local.children || null != local.description;
-    const handleChange = (event)=>{
-        invokeEventHandler(local.onChange, event);
-        if (event.defaultPrevented) return;
-        if (isDisabled()) return;
-        if (!isControlled()) setInternalSelected(event.currentTarget.checked);
-    };
-    return (()=>{
-        var _el$ = _tmpl$3(), _el$2 = _el$.firstChild, _el$3 = _el$2.nextSibling, _el$4 = _el$3.firstChild;
-        spread(_el$, mergeProps(()=>({
-                class: twMerge(CLASSES.base, CLASSES.size[size()], CLASSES.color[color()], isDisabled() && CLASSES.flag.disabled, local.class, local.className)
-            }), {
-            get ["data-theme"] () {
-                return local.dataTheme;
-            },
-            "data-slot": "toggle",
-            get ["data-selected"] () {
-                return isSelected() ? "true" : "false";
-            },
-            get ["data-disabled"] () {
-                return isDisabled() ? "true" : "false";
-            },
-            get ["aria-disabled"] () {
-                return isDisabled() ? "true" : "false";
-            }
-        }), false, true);
-        spread(_el$2, mergeProps(others, {
-            type: "checkbox",
-            role: "switch"
-        }, ()=>({
-                class: CLASSES.slot.input
-            }), {
-            "data-slot": "toggle-input",
-            get checked () {
-                return isSelected();
-            },
-            get disabled () {
-                return isDisabled();
-            },
-            onChange: handleChange
-        }), false, false);
-        spread(_el$3, mergeProps(()=>({
-                class: CLASSES.slot.control
-            }), {
-            "data-slot": "toggle-control",
-            "aria-hidden": "true"
-        }), false, true);
-        spread(_el$4, mergeProps(()=>({
-                class: CLASSES.slot.thumb
-            }), {
-            "data-slot": "toggle-thumb"
-        }), false, true);
-        insert(_el$4, createComponent(Show, {
-            get when () {
-                return local.icon;
-            },
-            get children () {
-                var _el$5 = _tmpl$();
-                spread(_el$5, mergeProps(()=>({
-                        class: CLASSES.slot.icon
-                    }), {
-                    "data-slot": "toggle-icon"
-                }), false, true);
-                insert(_el$5, ()=>local.icon);
-                return _el$5;
-            }
-        }));
-        insert(_el$, createComponent(Show, {
-            get when () {
-                return hasContent();
-            },
-            get children () {
-                var _el$6 = _tmpl$();
-                spread(_el$6, mergeProps(()=>({
-                        class: CLASSES.slot.content
-                    }), {
-                    "data-slot": "toggle-content"
-                }), false, true);
-                insert(_el$6, createComponent(Show, {
-                    get when () {
-                        return local.children;
-                    },
-                    get children () {
-                        var _el$7 = _tmpl$2();
-                        insert(_el$7, ()=>local.children);
-                        return _el$7;
-                    }
-                }), null);
-                insert(_el$6, createComponent(Show, {
-                    get when () {
-                        return local.description;
-                    },
-                    get children () {
-                        var _el$8 = _tmpl$();
-                        spread(_el$8, mergeProps(()=>({
-                                class: CLASSES.slot.description
-                            }), {
-                            "data-slot": "description"
-                        }), false, true);
-                        insert(_el$8, ()=>local.description);
-                        return _el$8;
-                    }
-                }), null);
-                return _el$6;
-            }
-        }), null);
-        return _el$;
-    })();
-};
-const toggle_Toggle = Toggle;
-export default toggle_Toggle;

package/dist/components/toolbar/Toolbar.classes.d.ts

@@ -1,10 +0,0 @@
-export declare const CLASSES: {
-    readonly base: "toolbar";
-    readonly orientation: {
-        readonly horizontal: "toolbar--horizontal";
-        readonly vertical: "toolbar--vertical";
-    };
-    readonly flag: {
-        readonly attached: "toolbar--attached";
-    };
-};

package/dist/components/toolbar/Toolbar.classes.js

@@ -1,11 +0,0 @@
-const CLASSES = {
-    base: "toolbar",
-    orientation: {
-        horizontal: "toolbar--horizontal",
-        vertical: "toolbar--vertical"
-    },
-    flag: {
-        attached: "toolbar--attached"
-    }
-};
-export { CLASSES };

package/dist/components/toolbar/Toolbar.d.ts

@@ -1,15 +0,0 @@
-import "./Toolbar.css";
-import { type Component, type JSX } from "solid-js";
-import type { IComponentBaseProps } from "../types";
-export type ToolbarOrientation = "horizontal" | "vertical";
-export type ToolbarRootProps = IComponentBaseProps & JSX.HTMLAttributes<HTMLDivElement> & {
-    orientation?: ToolbarOrientation;
-    isAttached?: boolean;
-};
-declare const ToolbarRoot: Component<ToolbarRootProps>;
-declare const Toolbar: Component<ToolbarRootProps> & {
-    Root: Component<ToolbarRootProps>;
-};
-export default Toolbar;
-export { Toolbar, ToolbarRoot };
-export type { ToolbarRootProps as ToolbarProps };

package/dist/components/toolbar/Toolbar.js

@@ -1,97 +0,0 @@
-import { insert, mergeProps, spread, template, use } from "solid-js/web";
-import "./Toolbar.css";
-import { splitProps } from "solid-js";
-import { twMerge } from "tailwind-merge";
-import { CLASSES } from "./Toolbar.classes.js";
-var _tmpl$ = /*#__PURE__*/ template("<div>");
-const FOCUSABLE_SELECTOR = 'button:not([disabled]), a[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"]), [contenteditable="true"]';
-const isFocusableElement = (element)=>{
-    if ("true" === element.getAttribute("aria-disabled")) return false;
-    return !element.hasAttribute("disabled");
-};
-const isTypingContext = (target)=>{
-    if (!(target instanceof HTMLElement)) return false;
-    const tag = target.tagName.toLowerCase();
-    if ("input" === tag || "textarea" === tag || "select" === tag) return true;
-    return "true" === target.getAttribute("contenteditable");
-};
-const getFocusableElements = (root)=>Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter(isFocusableElement);
-const ToolbarRoot = (props)=>{
-    const [local, others] = splitProps(props, [
-        "children",
-        "class",
-        "className",
-        "dataTheme",
-        "style",
-        "orientation",
-        "isAttached",
-        "onKeyDown",
-        "role",
-        "ref"
-    ]);
-    let rootRef;
-    const orientation = ()=>local.orientation ?? "horizontal";
-    const handleKeyDown = (event)=>{
-        if ("function" == typeof local.onKeyDown) local.onKeyDown(event);
-        if (event.defaultPrevented) return;
-        if (isTypingContext(event.target)) return;
-        const currentRoot = rootRef;
-        if (!currentRoot) return;
-        const isVertical = "vertical" === orientation();
-        const nextKey = isVertical ? "ArrowDown" : "ArrowRight";
-        const prevKey = isVertical ? "ArrowUp" : "ArrowLeft";
-        const isMoveKey = event.key === nextKey || event.key === prevKey;
-        const isHomeEndKey = "Home" === event.key || "End" === event.key;
-        if (!isMoveKey && !isHomeEndKey) return;
-        const focusable = getFocusableElements(currentRoot);
-        if (0 === focusable.length) return;
-        const activeElement = document.activeElement;
-        const currentIndex = activeElement ? focusable.indexOf(activeElement) : -1;
-        let nextIndex = currentIndex;
-        if ("Home" === event.key) nextIndex = 0;
-        else if ("End" === event.key) nextIndex = focusable.length - 1;
-        else if (-1 === currentIndex) nextIndex = event.key === prevKey ? focusable.length - 1 : 0;
-        else {
-            const step = event.key === nextKey ? 1 : -1;
-            nextIndex = (currentIndex + step + focusable.length) % focusable.length;
-        }
-        event.preventDefault();
-        focusable[nextIndex]?.focus();
-    };
-    return (()=>{
-        var _el$ = _tmpl$();
-        use((el)=>{
-            rootRef = el;
-            if ("function" == typeof local.ref) local.ref(el);
-        }, _el$);
-        spread(_el$, mergeProps(others, {
-            get role () {
-                return local.role ?? "toolbar";
-            },
-            get ["aria-orientation"] () {
-                return orientation();
-            },
-            "data-slot": "toolbar",
-            get ["data-orientation"] () {
-                return orientation();
-            },
-            get ["data-theme"] () {
-                return local.dataTheme;
-            },
-            get style () {
-                return local.style;
-            },
-            onKeyDown: handleKeyDown
-        }, ()=>({
-                class: twMerge(CLASSES.base, CLASSES.orientation[orientation()], local.isAttached && CLASSES.flag.attached, local.class, local.className)
-            })), false, true);
-        insert(_el$, ()=>local.children);
-        return _el$;
-    })();
-};
-const Toolbar = Object.assign(ToolbarRoot, {
-    Root: ToolbarRoot
-});
-const toolbar_Toolbar = Toolbar;
-export default toolbar_Toolbar;
-export { Toolbar, ToolbarRoot };

package/dist/components/tooltip/Tooltip.classes.d.ts

@@ -1,8 +0,0 @@
-export declare const CLASSES: {
-    readonly base: "tooltip";
-    readonly slot: {
-        readonly trigger: "tooltip__trigger";
-        readonly content: "tooltip__content";
-        readonly arrow: "tooltip__arrow";
-    };
-};

package/dist/components/tooltip/Tooltip.classes.js

@@ -1,9 +0,0 @@
-const CLASSES = {
-    base: "tooltip",
-    slot: {
-        trigger: "tooltip__trigger",
-        content: "tooltip__content",
-        arrow: "tooltip__arrow"
-    }
-};
-export { CLASSES };

package/dist/components/tooltip/Tooltip.d.ts

@@ -1,38 +0,0 @@
-import "./Tooltip.css";
-import { type Component, type JSX, type ParentComponent } from "solid-js";
-import { type OverlayPlacement } from "../_shared/overlayPosition";
-import type { IComponentBaseProps } from "../types";
-export type TooltipPlacement = OverlayPlacement;
-export type TooltipRootProps = IComponentBaseProps & {
-    children: JSX.Element;
-    placement?: TooltipPlacement;
-    autoFlip?: boolean;
-    sideOffset?: number;
-    showArrow?: boolean;
-    delay?: number;
-    closeDelay?: number;
-    isOpen?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (isOpen: boolean) => void;
-};
-export type TooltipTriggerProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
-    children: JSX.Element;
-};
-export type TooltipContentProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
-    children: JSX.Element;
-};
-export type TooltipArrowProps = JSX.HTMLAttributes<HTMLSpanElement> & IComponentBaseProps & {
-    children?: JSX.Element;
-};
-declare const TooltipRoot: ParentComponent<TooltipRootProps>;
-declare const TooltipTrigger: Component<TooltipTriggerProps>;
-declare const TooltipContent: Component<TooltipContentProps>;
-declare const TooltipArrow: Component<TooltipArrowProps>;
-declare const Tooltip: ParentComponent<TooltipRootProps> & {
-    Root: ParentComponent<TooltipRootProps>;
-    Trigger: Component<TooltipTriggerProps>;
-    Content: Component<TooltipContentProps>;
-    Arrow: Component<TooltipArrowProps>;
-};
-export default Tooltip;
-export { TooltipRoot, TooltipTrigger, TooltipContent, TooltipArrow };

package/dist/components/tooltip/Tooltip.js

@@ -1,271 +0,0 @@
-import { Portal, createComponent, insert, mergeProps, spread, template, use } from "solid-js/web";
-import "./Tooltip.css";
-import { Show, createContext, createEffect, createSignal, onCleanup, splitProps, useContext } from "solid-js";
-import { twMerge } from "tailwind-merge";
-import { createOverlayPosition } from "../_shared/overlayPosition.js";
-import { CLASSES } from "./Tooltip.classes.js";
-var _tmpl$ = /*#__PURE__*/ template("<span>"), _tmpl$2 = /*#__PURE__*/ template("<div>"), _tmpl$3 = /*#__PURE__*/ template('<svg aria-hidden=true data-slot=tooltip-arrow-svg height=12 viewBox="0 0 12 12"width=12 xmlns=http://www.w3.org/2000/svg><path d="M0 0C5.48483 8 6.5 8 12 0Z"fill=currentColor>');
-const TooltipContext = createContext();
-const useTooltipContext = ()=>{
-    const ctx = useContext(TooltipContext);
-    if (!ctx) throw new Error("Tooltip compound components must be used within <Tooltip>");
-    return ctx;
-};
-const TooltipRoot = (props)=>{
-    const [local, _others] = splitProps(props, [
-        "children",
-        "placement",
-        "autoFlip",
-        "sideOffset",
-        "showArrow",
-        "delay",
-        "closeDelay",
-        "isOpen",
-        "defaultOpen",
-        "onOpenChange",
-        "dataTheme",
-        "class",
-        "className",
-        "style"
-    ]);
-    const [internalOpen, setInternalOpen] = createSignal(Boolean(local.defaultOpen));
-    const [triggerRef, setTriggerRef] = createSignal();
-    const [contentRef, setContentRef] = createSignal();
-    const [resolvedPlacement, setResolvedPlacement] = createSignal(local.placement ?? "top");
-    let delayTimer;
-    let closeTimer;
-    const isControlled = ()=>void 0 !== local.isOpen;
-    const isOpen = ()=>isControlled() ? Boolean(local.isOpen) : internalOpen();
-    const setIsOpen = (v)=>{
-        if (!isControlled()) setInternalOpen(v);
-        local.onOpenChange?.(v);
-    };
-    const openTooltip = ()=>{
-        clearTimeout(closeTimer);
-        clearTimeout(delayTimer);
-        delayTimer = setTimeout(()=>setIsOpen(true), local.delay ?? 0);
-    };
-    const closeTooltip = ()=>{
-        clearTimeout(delayTimer);
-        clearTimeout(closeTimer);
-        closeTimer = setTimeout(()=>setIsOpen(false), local.closeDelay ?? 100);
-    };
-    onCleanup(()=>{
-        clearTimeout(delayTimer);
-        clearTimeout(closeTimer);
-    });
-    const ctx = {
-        isOpen,
-        setIsOpen,
-        openTooltip,
-        closeTooltip,
-        preferredPlacement: ()=>local.placement ?? "top",
-        placement: ()=>resolvedPlacement(),
-        setPlacement: setResolvedPlacement,
-        autoFlip: ()=>local.autoFlip ?? true,
-        sideOffset: ()=>local.sideOffset ?? 12,
-        showArrow: ()=>Boolean(local.showArrow),
-        triggerRef,
-        setTriggerRef,
-        contentRef,
-        setContentRef,
-        dataTheme: ()=>local.dataTheme
-    };
-    return createComponent(TooltipContext.Provider, {
-        value: ctx,
-        get children () {
-            var _el$ = _tmpl$();
-            spread(_el$, mergeProps(()=>({
-                    class: twMerge(CLASSES.base, local.class, local.className)
-                }), {
-                "data-slot": "tooltip-root",
-                get ["data-theme"] () {
-                    return local.dataTheme;
-                },
-                get style () {
-                    return local.style;
-                }
-            }), false, true);
-            insert(_el$, ()=>local.children);
-            return _el$;
-        }
-    });
-};
-const TooltipTrigger = (props)=>{
-    const [local, others] = splitProps(props, [
-        "children",
-        "class",
-        "className",
-        "dataTheme",
-        "style",
-        "onMouseEnter",
-        "onMouseLeave",
-        "onFocusIn",
-        "onFocusOut"
-    ]);
-    const ctx = useTooltipContext();
-    const handleMouseEnter = (e)=>{
-        ctx.openTooltip();
-        if ("function" == typeof local.onMouseEnter) local.onMouseEnter(e);
-    };
-    const handleMouseLeave = (e)=>{
-        ctx.closeTooltip();
-        if ("function" == typeof local.onMouseLeave) local.onMouseLeave(e);
-    };
-    const handleFocusIn = (e)=>{
-        ctx.openTooltip();
-        if ("function" == typeof local.onFocusIn) local.onFocusIn(e);
-    };
-    const handleFocusOut = (e)=>{
-        ctx.setIsOpen(false);
-        if ("function" == typeof local.onFocusOut) local.onFocusOut(e);
-    };
-    return (()=>{
-        var _el$2 = _tmpl$2();
-        use((el)=>ctx.setTriggerRef(el), _el$2);
-        spread(_el$2, mergeProps(others, ()=>({
-                class: twMerge(CLASSES.slot.trigger, local.class, local.className)
-            }), {
-            "data-slot": "tooltip-trigger",
-            get ["data-theme"] () {
-                return local.dataTheme;
-            },
-            get style () {
-                return local.style;
-            },
-            onMouseEnter: handleMouseEnter,
-            onMouseLeave: handleMouseLeave,
-            onFocusIn: handleFocusIn,
-            onFocusOut: handleFocusOut
-        }), false, true);
-        insert(_el$2, ()=>local.children);
-        return _el$2;
-    })();
-};
-const TooltipContent = (props)=>{
-    const [local, others] = splitProps(props, [
-        "children",
-        "class",
-        "className",
-        "dataTheme",
-        "style",
-        "onMouseEnter",
-        "onMouseLeave"
-    ]);
-    const ctx = useTooltipContext();
-    const overlayPosition = createOverlayPosition({
-        open: ctx.isOpen,
-        triggerRef: ctx.triggerRef,
-        overlayRef: ctx.contentRef,
-        placement: ctx.preferredPlacement,
-        offset: ctx.sideOffset,
-        autoFlip: ctx.autoFlip,
-        align: ()=>"center"
-    });
-    createEffect(()=>{
-        ctx.setPlacement(overlayPosition.placement());
-    });
-    const style = ()=>{
-        const overlayStyle = overlayPosition.style();
-        if ("string" == typeof local.style) return [
-            local.style,
-            Object.entries(overlayStyle).map(([key, value])=>`${key}: ${String(value)}`).join("; ")
-        ].filter(Boolean).join("; ");
-        return {
-            ...local.style ?? {},
-            ...overlayStyle
-        };
-    };
-    const handleMouseEnter = (event)=>{
-        ctx.openTooltip();
-        if ("function" == typeof local.onMouseEnter) local.onMouseEnter(event);
-    };
-    const handleMouseLeave = (event)=>{
-        ctx.closeTooltip();
-        if ("function" == typeof local.onMouseLeave) local.onMouseLeave(event);
-    };
-    return createComponent(Show, {
-        get when () {
-            return ctx.isOpen();
-        },
-        get children () {
-            return createComponent(Portal, {
-                get children () {
-                    var _el$3 = _tmpl$2();
-                    use((el)=>ctx.setContentRef(el), _el$3);
-                    spread(_el$3, mergeProps(others, {
-                        role: "tooltip"
-                    }, ()=>({
-                            class: twMerge(CLASSES.slot.content, local.class, local.className)
-                        }), {
-                        "data-slot": "tooltip-content",
-                        get ["data-placement"] () {
-                            return ctx.placement();
-                        },
-                        get ["data-open"] () {
-                            return ctx.isOpen() ? "true" : "false";
-                        },
-                        get ["data-theme"] () {
-                            return local.dataTheme ?? ctx.dataTheme();
-                        },
-                        get style () {
-                            return style();
-                        },
-                        onMouseEnter: handleMouseEnter,
-                        onMouseLeave: handleMouseLeave
-                    }), false, true);
-                    insert(_el$3, ()=>local.children);
-                    return _el$3;
-                }
-            });
-        }
-    });
-};
-const TooltipArrow = (props)=>{
-    const [local, others] = splitProps(props, [
-        "children",
-        "class",
-        "className",
-        "dataTheme",
-        "style"
-    ]);
-    const ctx = useTooltipContext();
-    const defaultArrow = _tmpl$3();
-    return (()=>{
-        var _el$5 = _tmpl$();
-        spread(_el$5, mergeProps(others, ()=>({
-                class: twMerge(CLASSES.slot.arrow, local.class, local.className)
-            }), {
-            "data-slot": "tooltip-arrow",
-            get ["data-placement"] () {
-                return ctx.placement();
-            },
-            get ["data-theme"] () {
-                return local.dataTheme;
-            },
-            get style () {
-                return local.style;
-            },
-            "aria-hidden": "true"
-        }), false, true);
-        insert(_el$5, createComponent(Show, {
-            get when () {
-                return local.children;
-            },
-            fallback: defaultArrow,
-            get children () {
-                return local.children;
-            }
-        }));
-        return _el$5;
-    })();
-};
-const Tooltip = Object.assign(TooltipRoot, {
-    Root: TooltipRoot,
-    Trigger: TooltipTrigger,
-    Content: TooltipContent,
-    Arrow: TooltipArrow
-});
-const tooltip_Tooltip = Tooltip;
-export default tooltip_Tooltip;
-export { TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger };