@pzerelles/headlessui-svelte 2.1.2-next.2 → 2.1.2-next.20

package/dist/popover/PopoverPanel.svelte

@@ -0,0 +1,274 @@
+<script lang="ts" module>import { RenderFeatures } from "../utils/render.js";
+const DEFAULT_PANEL_TAG = "div";
+const PanelRenderFeatures = RenderFeatures.RenderStrategy | RenderFeatures.Static;
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_PANEL_TAG">import { useId } from "../hooks/use-id.js";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+import { mergeProps } from "../utils/render.js";
+import {
+  useFloatingPanel,
+  useFloatingPanelProps,
+  useResolvedAnchor
+} from "../internal/floating.svelte.js";
+import {
+  PopoverStates,
+  usePopoverAPIContext,
+  usePopoverContext
+} from "./context.svelte.js";
+import { getOwnerDocument } from "../utils/owner.js";
+import { clearOpenClosedContext, State, useOpenClosed } from "../internal/open-closed.js";
+import { transitionDataAttributes, useTransition } from "../hooks/use-transition.svelte.js";
+import { useOnDisappear } from "../hooks/use-on-disappear.svelte.js";
+import { useScrollLock } from "../hooks/use-scroll-lock.svelte.js";
+import { Focus, focusIn, FocusResult, getFocusableElements } from "../utils/focus-management.js";
+import { useElementSize } from "../hooks/use-element-size.svelte.js";
+import { useTabDirection, Direction as TabDirection } from "../hooks/use-tab-direction.svelte.js";
+import { match } from "../utils/match.js";
+import { microTask } from "../utils/microTask.js";
+import { setContext, untrack } from "svelte";
+import Portal from "../portal/Portal.svelte";
+import Hidden, { HiddenFeatures } from "../internal/Hidden.svelte";
+let internalId = useId();
+let {
+  ref = $bindable(),
+  id = `headlessui-popover-panel-${internalId}`,
+  focus = false,
+  anchor: rawAnchor,
+  portal: theirPortal = false,
+  modal = false,
+  transition = false,
+  ...theirProps
+} = $props();
+const context = usePopoverContext("PopoverPanel");
+const api = usePopoverAPIContext("PopoverPanel");
+const { close, isPortalled } = $derived(api);
+const beforePanelSentinelId = `headlessui-focus-sentinel-before-${internalId}`;
+const afterPanelSentinelId = `headlessui-focus-sentinel-after-${internalId}`;
+const resolvedAnchor = useResolvedAnchor({
+  get anchor() {
+    return rawAnchor;
+  }
+});
+const { anchor } = $derived(resolvedAnchor);
+const floatingPanel = useFloatingPanel({
+  get placement() {
+    return anchor;
+  }
+});
+const { setFloating, styles } = $derived(floatingPanel);
+const getFloatingPanelProps = useFloatingPanelProps();
+const portal = $derived(!!anchor || theirPortal);
+$effect(() => {
+  if (anchor) setFloating(ref ?? null);
+  untrack(() => context.setPanel(ref));
+});
+const ownerDocument = $derived(getOwnerDocument(ref));
+$effect(() => {
+  id;
+  return untrack(() => {
+    context.setPanelId(id);
+    return () => {
+      context.setPanelId(void 0);
+    };
+  });
+});
+const usesOpenClosedState = useOpenClosed();
+const _transition = useTransition({
+  get enabled() {
+    return transition;
+  },
+  get element() {
+    return ref;
+  },
+  get show() {
+    return usesOpenClosedState !== null ? (usesOpenClosedState.value & State.Open) === State.Open : context.popoverState === PopoverStates.Open;
+  }
+});
+const { visible, data: transitionData } = $derived(_transition);
+useOnDisappear({
+  get enabled() {
+    return visible;
+  },
+  get ref() {
+    return context.button;
+  },
+  ondisappear: () => {
+    context.closePopover();
+  }
+});
+const scrollLockEnabled = $derived(context.__demoMode ? false : modal && visible);
+useScrollLock({
+  get enabled() {
+    return scrollLockEnabled;
+  },
+  get ownerDocument() {
+    return ownerDocument;
+  }
+});
+const handleKeyDown = (event) => {
+  switch (event.key) {
+    case "Escape":
+      if (context.popoverState !== PopoverStates.Open) return;
+      if (!ref) return;
+      if (ownerDocument?.activeElement && !ref.contains(ownerDocument.activeElement)) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      context.closePopover();
+      context.button?.focus();
+      break;
+  }
+};
+$effect(() => {
+  if (theirProps.static) return;
+  if (context.popoverState === PopoverStates.Closed && (theirProps.unmount ?? true)) {
+    context.setPanel(void 0);
+  }
+});
+$effect(() => {
+  if (context.__demoMode) return;
+  if (!focus) return;
+  if (context.popoverState !== PopoverStates.Open) return;
+  if (!ref) return;
+  const activeElement = ownerDocument?.activeElement;
+  if (ref.contains(activeElement)) return;
+  focusIn(ref, Focus.First);
+});
+const slot = $derived({
+  open: context.popoverState === PopoverStates.Open,
+  close
+});
+const buttonSize = useElementSize({
+  get element() {
+    return context.button ?? null;
+  },
+  unit: true
+});
+const ourProps = $derived(
+  mergeProps(anchor ? getFloatingPanelProps() : {}, {
+    id,
+    onkeydown: handleKeyDown,
+    onblur: focus && context.popoverState === PopoverStates.Open ? (event) => {
+      let el = event.relatedTarget;
+      if (!el) return;
+      if (!ref) return;
+      if (ref.contains(el)) return;
+      context.closePopover();
+      if (context.beforePanelSentinel?.contains?.(el) || context.afterPanelSentinel?.contains?.(el)) {
+        el.focus({ preventScroll: true });
+      }
+    } : void 0,
+    tabIndex: -1,
+    style: [theirProps.style, styles, `--button-width: ${buttonSize.width}`].filter(Boolean).join("; "),
+    ...transitionDataAttributes(transitionData)
+  })
+);
+const direction = useTabDirection();
+const handleBeforeFocus = () => {
+  let el = ref;
+  if (!el) return;
+  function run() {
+    match(direction.current, {
+      [TabDirection.Forwards]: () => {
+        let result = focusIn(el, Focus.First);
+        if (result === FocusResult.Error) {
+          context.afterPanelSentinel?.focus();
+        }
+      },
+      [TabDirection.Backwards]: () => {
+        context.button?.focus({ preventScroll: true });
+      }
+    });
+  }
+  if (process.env.NODE_ENV === "test") {
+    microTask(run);
+  } else {
+    run();
+  }
+};
+const handleAfterFocus = () => {
+  let el = ref;
+  if (!el) return;
+  function run() {
+    match(direction.current, {
+      [TabDirection.Forwards]: () => {
+        if (!context.button) return;
+        const elements = getFocusableElements();
+        const idx = elements.indexOf(context.button);
+        const before = elements.slice(0, idx + 1);
+        const after = elements.slice(idx + 1);
+        const combined = [...after, ...before];
+        for (const element of combined.slice()) {
+          if (element.dataset.headlessuiFocusGuard === "true" || ref?.contains(element)) {
+            let idx2 = combined.indexOf(element);
+            if (idx2 !== -1) combined.splice(idx2, 1);
+          }
+        }
+        focusIn(combined, Focus.First, { sorted: false });
+      },
+      [TabDirection.Backwards]: () => {
+        let result = focusIn(el, Focus.Previous);
+        if (result === FocusResult.Error) {
+          context.button?.focus();
+        }
+      }
+    });
+  }
+  if (process.env.NODE_ENV === "test") {
+    microTask(run);
+  } else {
+    run();
+  }
+};
+clearOpenClosedContext();
+setContext("PopoverPanelContext", {
+  get value() {
+    return id;
+  }
+});
+setContext("PopoverAPIContext", {
+  get close() {
+    return close;
+  },
+  get isPortalled() {
+    return isPortalled;
+  }
+});
+</script>
+
+<Portal enabled={portal ? theirProps.static || visible : false}>
+  {#if visible && isPortalled}
+    <Hidden
+      id={beforePanelSentinelId}
+      bind:ref={context.beforePanelSentinel as HTMLElement}
+      features={HiddenFeatures.Focusable}
+      data-headlessui-focus-guard
+      as="button"
+      type="button"
+      onfocus={handleBeforeFocus}
+    />
+  {/if}
+  <ElementOrComponent
+    {ourProps}
+    {theirProps}
+    slots={slot}
+    defaultTag={DEFAULT_PANEL_TAG}
+    features={PanelRenderFeatures}
+    {visible}
+    name="PopoverPanel"
+    bind:ref
+  />
+  {#if visible && isPortalled}
+    <Hidden
+      id={afterPanelSentinelId}
+      bind:ref={context.afterPanelSentinel as HTMLElement}
+      features={HiddenFeatures.Focusable}
+      data-headlessui-focus-guard
+      as="button"
+      type="button"
+      onfocus={handleAfterFocus}
+    />
+  {/if}
+</Portal>

package/dist/popover/PopoverPanel.svelte.d.ts

@@ -0,0 +1,53 @@
+import type { ElementType, Props, PropsOf } from "../utils/types.js";
+declare const DEFAULT_PANEL_TAG: "div";
+type PanelRenderPropArg = {
+    open: boolean;
+    close: (focusableElement?: HTMLElement) => void;
+};
+type PanelPropsWeControl = "tabIndex";
+export type PopoverPanelProps<TTag extends ElementType = typeof DEFAULT_PANEL_TAG> = Props<TTag, PanelRenderPropArg, PanelPropsWeControl, {
+    focus?: boolean;
+    anchor?: AnchorProps;
+    portal?: boolean;
+    modal?: boolean;
+    transition?: boolean;
+    static?: boolean;
+    unmount?: boolean;
+}>;
+import { type AnchorProps } from "../internal/floating.svelte.js";
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_PANEL_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "focus" | "anchor" | "unmount" | "static" | "tabIndex" | "transition" | "portal" | "modal"> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[PanelRenderPropArg, Record<string, any>]> | 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: PanelRenderPropArg) => string) | undefined;
+    } : {}) & {
+        focus?: boolean;
+        anchor?: AnchorProps;
+        portal?: boolean;
+        modal?: boolean;
+        transition?: boolean;
+        static?: boolean;
+        unmount?: boolean;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_PANEL_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_PANEL_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 PopoverPanel: $$IsomorphicComponent;
+type PopoverPanel<TTag extends ElementType = typeof DEFAULT_PANEL_TAG> = InstanceType<typeof PopoverPanel<TTag>>;
+export default PopoverPanel;

package/dist/popover/context.svelte.d.ts

@@ -0,0 +1,51 @@
+import type { MouseEventHandler } from "svelte/elements";
+export type MouseEvent<T extends EventTarget> = Parameters<MouseEventHandler<T>>[0];
+export declare enum PopoverStates {
+    Open = 0,
+    Closed = 1
+}
+export interface StateDefinition {
+    popoverState: PopoverStates;
+    buttons: symbol[];
+    button?: HTMLElement;
+    buttonId?: string;
+    panel?: HTMLElement;
+    panelId?: string;
+    beforePanelSentinel?: HTMLButtonElement;
+    afterPanelSentinel?: HTMLButtonElement;
+    afterButtonSentinel?: HTMLButtonElement;
+    __demoMode: boolean;
+}
+interface ActionDefinition {
+    togglePopover(): void;
+    closePopover(): void;
+    setButton(button: HTMLElement): void;
+    setButtonId(buttonId: string | undefined): void;
+    setPanel(panel?: HTMLElement): void;
+    setPanelId(panelId?: string): void;
+}
+export type PopoverContext = StateDefinition & ActionDefinition;
+export declare const createPopoverContext: (initialState: StateDefinition) => PopoverContext;
+export declare function usePopoverContext(component: string): PopoverContext;
+export type PopoverAPIContext = {
+    close(focusableElement?: HTMLElement | MouseEvent<HTMLElement>): void;
+    isPortalled: boolean;
+};
+export declare function usePopoverAPIContext(component: string): PopoverAPIContext;
+export type PopoverGroupContext = {
+    registerPopover(registerBag: PopoverRegisterBag): void;
+    unregisterPopover(registerBag: PopoverRegisterBag): void;
+    isFocusWithinPopoverGroup(): boolean;
+    closeOthers(buttonId: string): void;
+};
+export declare function usePopoverGroupContext(): PopoverGroupContext | undefined;
+export type PopoverPanelContext = {
+    value: string;
+};
+export declare function usePopoverPanelContext(): PopoverPanelContext | undefined;
+export interface PopoverRegisterBag {
+    buttonId?: string;
+    panelId?: string;
+    close(): void;
+}
+export {};

package/dist/popover/context.svelte.js

@@ -0,0 +1,108 @@
+import { getContext, setContext } from "svelte";
+export var PopoverStates;
+(function (PopoverStates) {
+    PopoverStates[PopoverStates["Open"] = 0] = "Open";
+    PopoverStates[PopoverStates["Closed"] = 1] = "Closed";
+})(PopoverStates || (PopoverStates = {}));
+export const createPopoverContext = (initialState) => {
+    const _state = $state(initialState);
+    const context = {
+        get popoverState() {
+            return _state.popoverState;
+        },
+        get buttons() {
+            return _state.buttons;
+        },
+        get button() {
+            return _state.button;
+        },
+        get buttonId() {
+            return _state.buttonId;
+        },
+        get panel() {
+            return _state.panel;
+        },
+        get panelId() {
+            return _state.panelId;
+        },
+        get beforePanelSentinel() {
+            return _state.beforePanelSentinel;
+        },
+        set beforePanelSentinel(value) {
+            _state.beforePanelSentinel = value;
+        },
+        get afterPanelSentinel() {
+            return _state.afterPanelSentinel;
+        },
+        set afterPanelSentinel(value) {
+            _state.afterPanelSentinel = value;
+        },
+        get afterButtonSentinel() {
+            return _state.afterButtonSentinel;
+        },
+        set afterButtonSentinel(value) {
+            _state.afterButtonSentinel = value;
+        },
+        get __demoMode() {
+            return _state.__demoMode;
+        },
+        togglePopover() {
+            _state.__demoMode = false;
+            _state.popoverState = _state.popoverState === PopoverStates.Closed ? PopoverStates.Open : PopoverStates.Closed;
+        },
+        closePopover() {
+            if (_state.popoverState === PopoverStates.Closed)
+                return;
+            _state.__demoMode = false;
+            _state.popoverState = PopoverStates.Closed;
+        },
+        setButton(button) {
+            if (_state.button === button)
+                return;
+            _state.button = button;
+        },
+        setButtonId(buttonId) {
+            if (_state.buttonId === buttonId)
+                return;
+            _state.buttonId = buttonId;
+        },
+        setPanel(panel) {
+            if (_state.panel === panel)
+                return;
+            _state.panel = panel;
+        },
+        setPanelId(panelId) {
+            if (_state.panelId === panelId)
+                return;
+            _state.panelId = panelId;
+        },
+    };
+    setContext("PopoverContext", context);
+    return context;
+};
+export function usePopoverContext(component) {
+    const context = getContext("PopoverContext");
+    if (!context) {
+        const err = new Error(`<${component} /> is missing a parent <Popover /> component.`);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(err, usePopoverContext);
+        throw err;
+    }
+    return context;
+}
+export function usePopoverAPIContext(component) {
+    const context = getContext("PopoverAPIContext");
+    if (!context) {
+        const err = new Error(`<${component} /> is missing a parent <Popover /> component.`);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(err, usePopoverAPIContext);
+        throw err;
+    }
+    return context;
+}
+export function usePopoverGroupContext() {
+    return getContext("PopoverGroupContext");
+}
+export function usePopoverPanelContext() {
+    return getContext("PopoverPanelContext");
+}

package/dist/popover/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Popover, type PopoverProps } from "./Popover.svelte";
+export { default as PopoverBackdrop, type PopoverBackdropProps } from "./PopoverBackdrop.svelte";
+export { default as PopoverButton, type PopoverButtonProps } from "./PopoverButton.svelte";
+export { default as PopoverGroup, type PopoverGroupProps } from "./PopoverGroup.svelte";
+export { default as PopoverPanel, type PopoverPanelProps } from "./PopoverPanel.svelte";

package/dist/popover/index.js

@@ -0,0 +1,5 @@
+export { default as Popover } from "./Popover.svelte";
+export { default as PopoverBackdrop } from "./PopoverBackdrop.svelte";
+export { default as PopoverButton } from "./PopoverButton.svelte";
+export { default as PopoverGroup } from "./PopoverGroup.svelte";
+export { default as PopoverPanel } from "./PopoverPanel.svelte";

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

@@ -15,7 +15,7 @@ declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_PORTAL
     props(): {
         as?: TTag | undefined;
     } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "enabled"> 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<PortalRenderPropArg> | undefined;
+        children?: import("svelte").Snippet<[PortalRenderPropArg, Record<string, any>]> | 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: PortalRenderPropArg) => string) | undefined;

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

@@ -12,7 +12,7 @@ declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_GROUP_
     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;
+        children?: import("svelte").Snippet<[GroupRenderPropArg, Record<string, any>]> | 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;

package/dist/select/Select.svelte

@@ -0,0 +1,74 @@
+<script lang="ts" module>let DEFAULT_SELECT_TAG = "select";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_SELECT_TAG">import { useId } from "../hooks/use-id.js";
+import { useProvidedId } from "../utils/id.js";
+import { useDisabled } from "../hooks/use-disabled.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 { useLabelledBy } from "../label/context.svelte.js";
+import { useDescribedBy } from "../description/context.svelte.js";
+import { mergeProps } from "../utils/render.js";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+const internalId = useId();
+const providedId = useProvidedId();
+const providedDisabled = useDisabled();
+let {
+  ref = $bindable(),
+  id = providedId || `headlessui-select-${internalId}`,
+  disabled: theirDisabled = false,
+  invalid = false,
+  autofocus = false,
+  ...theirProps
+} = $props();
+const disabled = $derived(providedDisabled?.value ?? theirDisabled);
+const labelledBy = useLabelledBy();
+const 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 ourProps = $derived(
+  mergeProps(
+    {
+      id,
+      "aria-labelledby": labelledBy.value,
+      "aria-describedby": describedBy.value,
+      "aria-invalid": invalid ? "" : void 0,
+      disabled: disabled || void 0,
+      autofocus
+    },
+    focusProps,
+    hoverProps,
+    pressProps
+  )
+);
+const slot = $derived({
+  disabled,
+  invalid,
+  hover,
+  focus,
+  active,
+  autofocus
+});
+</script>
+
+<ElementOrComponent {ourProps} {theirProps} {slot} defaultTag={DEFAULT_SELECT_TAG} name="Select" bind:ref />

package/dist/select/Select.svelte.d.ts

@@ -0,0 +1,48 @@
+import type { ElementType, Props, PropsOf } from "../utils/types.js";
+declare let DEFAULT_SELECT_TAG: "select";
+type SelectRenderPropArg = {
+    disabled: boolean;
+    hover: boolean;
+    focus: boolean;
+    active: boolean;
+    autofocus: boolean;
+    invalid: boolean;
+};
+type SelectPropsWeControl = "aria-labelledby" | "aria-describedby";
+export type SelectProps<TTag extends ElementType = typeof DEFAULT_SELECT_TAG> = Props<TTag, SelectRenderPropArg, SelectPropsWeControl, {
+    disabled?: boolean;
+    invalid?: boolean;
+    autofocus?: boolean;
+}>;
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_SELECT_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "invalid" | "disabled" | "autofocus" | SelectPropsWeControl> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[SelectRenderPropArg, Record<string, any>]> | 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: SelectRenderPropArg) => string) | undefined;
+    } : {}) & {
+        disabled?: boolean;
+        invalid?: boolean;
+        autofocus?: boolean;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_SELECT_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_SELECT_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 Select: $$IsomorphicComponent;
+type Select<TTag extends ElementType = typeof DEFAULT_SELECT_TAG> = InstanceType<typeof Select<TTag>>;
+export default Select;

package/dist/select/index.d.ts

@@ -0,0 +1 @@
+export { default as Select, type SelectProps } from "./Select.svelte";

package/dist/select/index.js

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