@pzerelles/headlessui-svelte 2.0.0-next.1 → 2.1.2-next.10

package/dist/portal/PortalGroup.svelte

@@ -0,0 +1,14 @@
+<script lang="ts" module>const DEFAULT_GROUP_TAG = "svelte:fragment";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_GROUP_TAG">import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+import { setContext } from "svelte";
+let { ref = $bindable(), target, ...theirProps } = $props();
+setContext("PortalGroupContext", {
+  get target() {
+    return target;
+  }
+});
+</script>
+
+<ElementOrComponent {theirProps} defaultTag={DEFAULT_GROUP_TAG} name="PortalGroup" bind:ref />

package/dist/portal/PortalGroup.svelte.d.ts

@@ -0,0 +1,40 @@
+import type { ElementType, Props } from "../utils/types.js";
+declare const DEFAULT_GROUP_TAG = "svelte:fragment";
+type GroupRenderPropArg = {};
+type GroupPropsWeControl = never;
+export type PortalGroupContext = {
+    readonly target: HTMLElement | null;
+};
+export type PortalGroupProps<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = Props<TTag, GroupRenderPropArg, GroupPropsWeControl, {
+    target: HTMLElement | null;
+}>;
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "target"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<GroupRenderPropArg> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: import("../utils/types.js").PropsOf<TTag>["class"] | ((bag: GroupRenderPropArg) => string) | undefined;
+    } : {}) & {
+        target: HTMLElement | null;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const PortalGroup: $$IsomorphicComponent;
+type PortalGroup<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = InstanceType<typeof PortalGroup<TTag>>;
+export default PortalGroup;

package/dist/switch/Switch.svelte

@@ -0,0 +1,153 @@
+<script lang="ts" module>const DEFAULT_SWITCH_TAG = "button";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_SWITCH_TAG">import { useId } from "../hooks/use-id.js";
+import { useDisabled } from "../hooks/use-disabled.js";
+import { useProvidedId } from "../utils/id.js";
+import { getContext, tick } from "svelte";
+import { attemptSubmit } from "../utils/form.js";
+import { useLabelledBy } from "../label/context.svelte.js";
+import { useDescribedBy } from "../description/context.svelte.js";
+import { mergeProps } from "../utils/render.js";
+import { useResolveButtonType } from "../hooks/use-resolve-button-type.svelte.js";
+import { useFocusRing } from "../hooks/use-focus-ring.svelte.js";
+import { useHover } from "../hooks/use-hover.svelte.js";
+import { useActivePress } from "../hooks/use-active-press.svelte.js";
+import { useControllable } from "../hooks/use-controllable.svelte.js";
+import FormFields from "../internal/FormFields.svelte";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+const internalId = useId();
+const providedId = useProvidedId();
+const providedDisabled = useDisabled();
+let {
+  ref = $bindable(),
+  id = providedId || `headlessui-switch-${internalId}`,
+  disabled: theirDisabled = false,
+  checked: controlledChecked = $bindable(),
+  defaultChecked: _defaultChecked,
+  onchange: controlledOnChange,
+  name,
+  value,
+  form,
+  autofocus = false,
+  tabIndex,
+  ...theirProps
+} = $props();
+const disabled = $derived(providedDisabled?.value ?? theirDisabled);
+const groupContext = getContext("GroupContext");
+$effect(() => {
+  if (groupContext) groupContext.switchElement = ref ?? null;
+});
+const defaultChecked = _defaultChecked;
+const controllable = useControllable(
+  {
+    get controlledValue() {
+      return controlledChecked;
+    },
+    set controlledValue(checked2) {
+      controlledChecked = checked2;
+    }
+  },
+  controlledOnChange,
+  defaultChecked ?? false
+);
+const { value: checked, onchange } = $derived(controllable);
+let changing = $state(false);
+const toggle = () => {
+  changing = true;
+  onchange?.(!checked);
+  tick().then(() => {
+    changing = false;
+  });
+};
+const handleClick = (event) => {
+  event.preventDefault();
+  toggle();
+};
+const handleKeyUp = (event) => {
+  if (event.key === " ") {
+    event.preventDefault();
+    toggle();
+  } else if (event.key === "Enter") {
+    attemptSubmit(event.currentTarget);
+  }
+};
+const handleKeyPress = (event) => event.preventDefault();
+let labelledBy = useLabelledBy();
+let describedBy = useDescribedBy();
+const { isFocusVisible: focus, focusProps } = $derived(
+  useFocusRing({
+    get autofocus() {
+      return autofocus;
+    }
+  })
+);
+const { isHovered: hover, hoverProps } = $derived(
+  useHover({
+    get disabled() {
+      return disabled;
+    }
+  })
+);
+const { pressed: active, pressProps } = $derived(
+  useActivePress({
+    get disabled() {
+      return disabled;
+    }
+  })
+);
+const slot = $derived({
+  checked,
+  disabled,
+  hover,
+  focus,
+  active,
+  autofocus,
+  changing
+});
+const buttonType = useResolveButtonType({
+  get props() {
+    return { type: theirProps.type, as: theirProps.as };
+  },
+  get ref() {
+    return { current: ref };
+  }
+});
+const ourProps = $derived(
+  mergeProps(
+    {
+      id,
+      role: "switch",
+      type: buttonType.type,
+      tabIndex: tabIndex === -1 ? 0 : tabIndex ?? 0,
+      "aria-checked": checked,
+      "aria-labelledby": labelledBy.value,
+      "aria-describedby": describedBy.value,
+      disabled: disabled || void 0,
+      autofocus,
+      onclick: handleClick,
+      onkeyup: handleKeyUp,
+      onkeypress: handleKeyPress
+    },
+    focusProps,
+    hoverProps,
+    pressProps
+  )
+);
+const reset = $derived(() => {
+  if (defaultChecked === void 0) return;
+  return onchange?.(defaultChecked);
+});
+</script>
+
+{#if name}
+  <FormFields
+    {disabled}
+    data={{ [name]: value || "on" }}
+    overrides={{ type: "checkbox", checked }}
+    {form}
+    onReset={reset}
+  />
+{/if}
+
+<ElementOrComponent {ourProps} {theirProps} {slot} defaultTag={DEFAULT_SWITCH_TAG} name="Switch" bind:ref />

package/dist/switch/Switch.svelte.d.ts

@@ -0,0 +1,61 @@
+import type { ElementType, Props, PropsOf } from "../utils/types.js";
+declare const DEFAULT_SWITCH_TAG: "button";
+type SwitchRenderPropArg = {
+    checked: boolean;
+    hover: boolean;
+    focus: boolean;
+    active: boolean;
+    autofocus: boolean;
+    changing: boolean;
+    disabled: boolean;
+};
+type SwitchPropsWeControl = "aria-checked" | "aria-describedby" | "aria-labelledby" | "role";
+export type SwitchProps<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> = Props<TTag, SwitchRenderPropArg, SwitchPropsWeControl, {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onchange?(checked: boolean): void;
+    name?: string;
+    value?: string;
+    form?: string;
+    autofocus?: boolean;
+    disabled?: boolean;
+    tabIndex?: number;
+}>;
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof PropsOf<TTag>, "form" | ("as" | "children" | "refName" | "class") | "disabled" | "autofocus" | "name" | "value" | "checked" | "onchange" | "tabIndex" | "defaultChecked" | SwitchPropsWeControl> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<SwitchRenderPropArg> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (PropsOf<TTag> extends infer T_1 ? T_1 extends PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: PropsOf<TTag>["class"] | ((bag: SwitchRenderPropArg) => string) | undefined;
+    } : {}) & {
+        checked?: boolean;
+        defaultChecked?: boolean;
+        onchange?(checked: boolean): void;
+        name?: string;
+        value?: string;
+        form?: string;
+        autofocus?: boolean;
+        disabled?: boolean;
+        tabIndex?: number;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref" | "checked";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_SWITCH_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_SWITCH_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Switch: $$IsomorphicComponent;
+type Switch<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> = InstanceType<typeof Switch<TTag>>;
+export default Switch;

package/dist/switch/SwitchGroup.svelte

@@ -0,0 +1,37 @@
+<script lang="ts" module>const DEFAULT_GROUP_TAG = "svelte:fragment";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_GROUP_TAG">import { setContext } from "svelte";
+import { useLabels } from "../label/context.svelte.js";
+import { useDescriptions } from "../description/context.svelte.js";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+let switchElement = $state(null);
+useLabels({
+  name: "SwitchGroup",
+  props: {
+    get htmlFor() {
+      return switchElement?.id;
+    },
+    onclick: (event) => {
+      if (!switchElement) return;
+      if (event.currentTarget instanceof HTMLLabelElement) {
+        event.preventDefault();
+      }
+      switchElement.click();
+      switchElement.focus({ preventScroll: true });
+    }
+  }
+});
+useDescriptions();
+setContext("GroupContext", {
+  get switchElement() {
+    return switchElement;
+  },
+  set switchElement(element) {
+    switchElement = element;
+  }
+});
+let { ref = $bindable(), ...theirProps } = $props();
+</script>
+
+<ElementOrComponent {theirProps} defaultTag={DEFAULT_GROUP_TAG} name="SwitchGroup" bind:ref />

package/dist/switch/SwitchGroup.svelte.d.ts

@@ -0,0 +1,34 @@
+import type { ElementType, Props } from "../utils/types.js";
+declare const DEFAULT_GROUP_TAG = "svelte:fragment";
+export type SwitchGroupProps<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = Props<TTag>;
+export type GroupContext = {
+    switchElement: HTMLElement | null;
+};
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, "as" | "children" | "refName" | "class"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<{}> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: import("../utils/types.js").PropsOf<TTag>["class"] | ((bag: {}) => string) | undefined;
+    } : {});
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const SwitchGroup: $$IsomorphicComponent;
+type SwitchGroup<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = InstanceType<typeof SwitchGroup<TTag>>;
+export default SwitchGroup;

package/dist/switch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Switch, type SwitchProps } from "./Switch.svelte";
+export { default as SwitchGroup, type SwitchGroupProps } from "./SwitchGroup.svelte";

package/dist/switch/index.js

@@ -0,0 +1,2 @@
+export { default as Switch } from "./Switch.svelte";
+export { default as SwitchGroup } from "./SwitchGroup.svelte";

package/dist/tabs/Tab.svelte

@@ -0,0 +1,156 @@
+<script lang="ts" module>const DEFAULT_TAB_TAG = "button";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_TAB_TAG">import { useId } from "../hooks/use-id.js";
+import { useActions, useData } from "./TabGroup.svelte";
+import { useStableCollectionIndex } from "../utils/StableCollection.svelte";
+import { Focus, focusIn, FocusResult } from "../utils/focus-management.js";
+import { getOwnerDocument } from "../utils/owner.js";
+import { match } from "../utils/match.js";
+import { microTask } from "../utils/microTask.js";
+import { useActivePress } from "../hooks/use-active-press.svelte.js";
+import { useFocusRing } from "../hooks/use-focus-ring.svelte.js";
+import { useResolveButtonType } from "../hooks/use-resolve-button-type.svelte.js";
+import { onMount } from "svelte";
+import { useHover } from "../hooks/use-hover.svelte.js";
+import { mergeProps } from "../utils/render.js";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+const internalId = useId();
+let {
+  ref = $bindable(),
+  id = `headlessui-tabs-tab-${internalId}`,
+  disabled = false,
+  autofocus = false,
+  ...theirProps
+} = $props();
+const data = useData("Tab");
+const { orientation, activation, selectedIndex, tabs, panels } = $derived(data);
+const actions = useActions("Tab");
+const tabRef = $derived({ current: ref });
+onMount(() => actions.registerTab(tabRef));
+const mySSRIndex = useStableCollectionIndex("tabs");
+const myIndex = $derived.by(() => {
+  const index = tabs.findIndex((tab) => tab === tabRef);
+  return index === -1 ? mySSRIndex : index;
+});
+const selected = $derived(myIndex === selectedIndex);
+const activateUsing = $derived((cb) => {
+  let result = cb();
+  if (result === FocusResult.Success && activation === "auto") {
+    let newTab = getOwnerDocument(ref)?.activeElement;
+    let idx = data.tabs.findIndex((tab) => tab.current === newTab);
+    if (idx !== -1) actions.change(idx);
+  }
+  return result;
+});
+const handleKeyDown = (event) => {
+  let list = tabs.map((tab) => tab.current).filter(Boolean);
+  if (event.key === " " || event.key === "Enter") {
+    event.preventDefault();
+    event.stopPropagation();
+    actions.change(myIndex);
+    return;
+  }
+  switch (event.key) {
+    case "Home":
+    case "PageUp":
+      event.preventDefault();
+      event.stopPropagation();
+      return activateUsing(() => focusIn(list, Focus.First));
+    case "End":
+    case "PageDown":
+      event.preventDefault();
+      event.stopPropagation();
+      return activateUsing(() => focusIn(list, Focus.Last));
+  }
+  let result = activateUsing(() => {
+    return match(orientation, {
+      vertical() {
+        if (event.key === "ArrowUp") return focusIn(list, Focus.Previous | Focus.WrapAround);
+        if (event.key === "ArrowDown") return focusIn(list, Focus.Next | Focus.WrapAround);
+        return FocusResult.Error;
+      },
+      horizontal() {
+        if (event.key === "ArrowLeft") return focusIn(list, Focus.Previous | Focus.WrapAround);
+        if (event.key === "ArrowRight") return focusIn(list, Focus.Next | Focus.WrapAround);
+        return FocusResult.Error;
+      }
+    });
+  });
+  if (result === FocusResult.Success) {
+    return event.preventDefault();
+  }
+};
+let ready = $state(false);
+const handleSelection = () => {
+  if (ready) return;
+  ready = true;
+  ref?.focus({ preventScroll: true });
+  actions.change(myIndex);
+  microTask(() => {
+    ready = false;
+  });
+};
+const handleMouseDown = (event) => {
+  event.preventDefault();
+};
+const { isHovered: hover, hoverProps } = $derived(
+  useHover({
+    get disabled() {
+      return disabled;
+    }
+  })
+);
+const { pressed: active, pressProps } = $derived(
+  useActivePress({
+    get disabled() {
+      return disabled;
+    }
+  })
+);
+const { isFocusVisible: focus, focusProps } = $derived(
+  useFocusRing({
+    get autofocus() {
+      return autofocus;
+    }
+  })
+);
+const slot = $derived({
+  selected,
+  hover,
+  active,
+  focus,
+  autofocus,
+  disabled
+});
+const resolvedType = useResolveButtonType({
+  get props() {
+    return { type: theirProps.type, as: theirProps.as };
+  },
+  get ref() {
+    return tabRef;
+  }
+});
+const ourProps = $derived(
+  mergeProps(
+    {
+      onkeydown: handleKeyDown,
+      onmousedown: handleMouseDown,
+      onclick: handleSelection,
+      id,
+      role: "tab",
+      type: resolvedType.type,
+      "aria-controls": panels[myIndex]?.current?.id,
+      "aria-selected": selected,
+      tabIndex: selected ? 0 : -1,
+      disabled: disabled || void 0,
+      autofocus
+    },
+    focusProps,
+    hoverProps,
+    pressProps
+  )
+);
+</script>
+
+<ElementOrComponent {ourProps} {theirProps} {slot} defaultTag={DEFAULT_TAB_TAG} name="Tab" bind:ref />

package/dist/tabs/Tab.svelte.d.ts

@@ -0,0 +1,48 @@
+import type { ElementType, Props } from "../utils/types.js";
+declare const DEFAULT_TAB_TAG: "button";
+type TabRenderPropArg = {
+    hover: boolean;
+    focus: boolean;
+    active: boolean;
+    autofocus: boolean;
+    selected: boolean;
+    disabled: boolean;
+};
+type TabPropsWeControl = "aria-controls" | "aria-selected" | "role" | "tabIndex";
+export type TabProps<TTag extends ElementType = typeof DEFAULT_TAB_TAG> = Props<TTag, TabRenderPropArg, TabPropsWeControl, {
+    id?: string;
+    autofocus?: boolean;
+    disabled?: boolean;
+}>;
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TAB_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "disabled" | "autofocus" | "id" | TabPropsWeControl> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<TabRenderPropArg> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: import("../utils/types.js").PropsOf<TTag>["class"] | ((bag: TabRenderPropArg) => string) | undefined;
+    } : {}) & {
+        id?: string;
+        autofocus?: boolean;
+        disabled?: boolean;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_TAB_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_TAB_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Tab: $$IsomorphicComponent;
+type Tab<TTag extends ElementType = typeof DEFAULT_TAB_TAG> = InstanceType<typeof Tab<TTag>>;
+export default Tab;