@pzerelles/headlessui-svelte 2.1.2-next.32 → 2.1.2-next.33

package/dist/transition/context.svelte.js

@@ -16,7 +16,7 @@ export function useTransitionContext() {
     return context;
 }
 export function useParentNesting() {
-    let context = getContext("NestingContext");
+    const context = getContext("NestingContext");
     if (!context) {
         throw new Error("A <Transition.Child /> is used but it is missing a parent <Transition /> or <Transition.Root />.");
     }
@@ -29,7 +29,7 @@ export function hasChildren(bag) {
 }
 export function useNesting(options) {
     const { done, parent } = $derived(options);
-    let transitionableChildren = $state([]);
+    const transitionableChildren = $state([]);
     const mounted = useIsMounted();
     const d = useDisposables();
     const unregister = (container, strategy = RenderStrategy.Hidden) => {
@@ -60,13 +60,13 @@ export function useNesting(options) {
         }
         return () => unregister(container, RenderStrategy.Unmount);
     };
-    let todos = $state([]);
+    const todos = $state([]);
     let wait = $state(Promise.resolve());
-    let chains = $state({
+    const chains = $state({
         enter: [],
         leave: [],
     });
-    let onStart = (container, direction, cb) => {
+    const onStart = (container, direction, cb) => {
         // Clear out all existing todos
         todos.splice(0);
         // Remove all existing promises for the current container from the parent because we can
@@ -85,7 +85,7 @@ export function useNesting(options) {
         parent?.chains[direction].push([
             container,
             new Promise((resolve) => {
-                Promise.all(chains[direction].map(([_container, promise]) => promise)).then(() => resolve());
+                Promise.all(chains[direction].map(([, promise]) => promise)).then(() => resolve());
             }),
         ]);
         if (direction === "enter") {
@@ -96,7 +96,7 @@ export function useNesting(options) {
         }
     };
     const onStop = (_container, direction, cb) => {
-        Promise.all(chains[direction].splice(0).map(([_container, promise]) => promise)) // Wait for my children
+        Promise.all(chains[direction].splice(0).map(([, promise]) => promise)) // Wait for my children
             .then(() => {
             todos.shift()?.(); // I'm ready
         })

package/dist/utils/ElementOrComponent.svelte

@@ -1,10 +1,7 @@
-<script
-  lang="ts"
-  generics="TFeature extends RenderFeatures, TTag extends ElementType, TSlot extends Record<string, any>, TValue"
->
-  import type { ElementType, Props } from "./types.js"
+<script lang="ts" generics="TFeature extends RenderFeatures, TSlot extends Record<string, any>, TValue">
+  import type { Props } from "./types.js"
   import { mergePropsAdvanced, RenderFeatures, type PropsForFeatures } from "./render.js"
-  import Generic from "./Generic.svelte"
+  import { stateFromSlot } from "./state.js"
 
   let {
     ourProps,
@@ -15,35 +12,79 @@
     features,
     visible = true,
     name,
-    ref = $bindable(),
+    element = $bindable(),
     value = $bindable(),
     checked = $bindable(),
   }: {
     ourProps?: Expand<Props<any, TSlot> & PropsForFeatures<TFeature>>
-    theirProps: Expand<{ as?: TTag } & Props<any, TSlot, any>>
+    theirProps: Expand<Props<any, TSlot, any>>
     slot?: TSlot
     slots?: TSlot
-    defaultTag: ElementType
+    defaultTag?: string
     features?: TFeature
     visible?: boolean
     name: string
     ref?: HTMLElement
+    element?: HTMLElement
     value?: TValue
     checked?: boolean
   } = $props()
 
   const featureFlags = $derived(features ?? RenderFeatures.None)
-  const { static: isStatic = false, unmount = true, ...rest } = $derived(mergePropsAdvanced(theirProps, ourProps ?? {}))
+  let {
+    as,
+    static: isStatic = false,
+    unmount = true,
+    children,
+    asChild,
+    class: className,
+    ...rest
+  } = $derived(mergePropsAdvanced(theirProps, ourProps ?? {}))
   const render = $derived(
     visible ||
       (featureFlags & RenderFeatures.Static && isStatic) ||
       (featureFlags & RenderFeatures.RenderStrategy && !unmount)
   )
-  const hiddenProps = $derived(
-    !visible && !(featureFlags & RenderFeatures.Static) && featureFlags & RenderFeatures.RenderStrategy && !unmount
-      ? { hidden: true, style: "display: none;" }
-      : {}
+
+  const resolvedClass: string | undefined = $derived(
+    typeof className === "function" ? className(slot) : (className ?? undefined)
   )
+
+  const _props = $derived.by(() => {
+    // Allow for className to be a function with the slot as the contents
+    if ("class" in rest && rest.class && typeof rest.class === "function") {
+      rest.class = rest.className(slot)
+    }
+
+    // Drop `aria-labelledby` if it only references the current element. If the `aria-labelledby`
+    // references itself but also another element then we can keep it.
+    if (rest["aria-labelledby"] && rest["aria-labelledby"] === rest.id) {
+      rest["aria-labelledby"] = undefined
+    }
+
+    const hiddenProps =
+      !visible && !(featureFlags & RenderFeatures.Static) && featureFlags & RenderFeatures.RenderStrategy && !unmount
+        ? { hidden: true, style: "display: none;" }
+        : {}
+
+    return { ...rest, ...(resolvedClass ? { class: resolvedClass } : {}), ...hiddenProps, ...stateFromSlot(slot) }
+  })
 </script>
 
-{#if render}<Generic {...rest} {...hiddenProps} {slot} tag={defaultTag} bind:ref bind:value bind:checked />{/if}
+{#if render}
+  {#if asChild || !defaultTag}
+    {@render children?.({ ...slot, props: _props })}
+  {:else if defaultTag === "select"}
+    <select {..._props} bind:this={element} bind:value>{@render children?.(slot)}</select>
+  {:else if defaultTag === "input" && (_props as Record<string, any>).type === "checkbox"}
+    <input type="checkbox" {..._props} bind:this={element} bind:checked />
+  {:else if defaultTag === "input"}
+    <input {..._props} bind:this={element} bind:value />
+  {:else if defaultTag === "textarea"}
+    <textarea {..._props} bind:this={element} bind:value></textarea>
+  {:else if children}
+    <svelte:element this={defaultTag} {..._props} bind:this={element}>{@render children(slot)}</svelte:element>
+  {:else}
+    <svelte:element this={defaultTag} {..._props} bind:this={element} />
+  {/if}
+{/if}

package/dist/utils/ElementOrComponent.svelte.d.ts

@@ -1,16 +1,29 @@
-import type { ElementType } from "./types.js";
+import type { Props } from "./types.js";
 import { RenderFeatures } from "./render.js";
-declare class __sveltets_Render<TFeature extends RenderFeatures, TTag extends ElementType, TSlot extends Record<string, any>, TValue> {
+declare class __sveltets_Render<TFeature extends RenderFeatures, TSlot extends Record<string, any>, TValue> {
     props(): {
-        ourProps?: Expand<{
-            [x: string]: any;
-            [x: number]: any;
-        } & {
+        ourProps?: Expand<Omit<{
+            [name: string]: any;
+        }, "asChild" | "children" | "class"> & {
+            asChild: true;
             children?: import("svelte").Snippet<[TSlot & {
                 props?: Record<string, any>;
             }]> | undefined;
+            class?: never;
+        } & Expand<((TFeature extends RenderFeatures.Static ? {
+            static?: boolean;
+        } : {}) extends infer T ? T extends (TFeature extends RenderFeatures.Static ? {
+            static?: boolean;
+        } : {}) ? T extends any ? (x: T) => any : never : never : never) | ((TFeature extends RenderFeatures.RenderStrategy ? {
+            unmount?: boolean;
+        } : {}) extends infer T_1 ? T_1 extends (TFeature extends RenderFeatures.RenderStrategy ? {
+            unmount?: boolean;
+        } : {}) ? T_1 extends any ? (x: T_1) => any : never : never : never) extends (x: infer R) => any ? R : never>> | Expand<Omit<{
+            [name: string]: any;
+        }, "asChild" | "children" | "class"> & {
+            asChild?: never;
+            children?: import("svelte").Snippet<[TSlot]> | undefined;
             class?: string | ((bag: TSlot) => string) | null | undefined;
-            ref?: HTMLElement;
         } & Expand<((TFeature extends RenderFeatures.Static ? {
             static?: boolean;
         } : {}) extends infer T ? T extends (TFeature extends RenderFeatures.Static ? {
@@ -20,36 +33,30 @@ declare class __sveltets_Render<TFeature extends RenderFeatures, TTag extends El
         } : {}) extends infer T_1 ? T_1 extends (TFeature extends RenderFeatures.RenderStrategy ? {
             unmount?: boolean;
         } : {}) ? T_1 extends any ? (x: T_1) => any : never : never : never) extends (x: infer R) => any ? R : never>> | undefined;
-        theirProps: {
-            as?: TTag | undefined;
-            children?: import("svelte").Snippet<[TSlot & {
-                props?: Record<string, any>;
-            }]> | undefined;
-            class?: string | ((bag: TSlot) => string) | null | undefined;
-            ref?: HTMLElement | undefined;
-        };
+        theirProps: Expand<Props<any, TSlot_1, any>>;
         slot?: TSlot | undefined;
         slots?: TSlot | undefined;
-        defaultTag: ElementType;
+        defaultTag?: string;
         features?: TFeature | undefined;
         visible?: boolean;
         name: string;
         ref?: HTMLElement;
+        element?: HTMLElement;
         value?: TValue | undefined;
         checked?: boolean;
     };
     events(): {};
     slots(): {};
-    bindings(): "ref" | "value" | "checked";
+    bindings(): "element" | "value" | "checked";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TFeature extends RenderFeatures, TTag extends ElementType, TSlot extends Record<string, any>, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['bindings']>;
-    } & ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
-    <TFeature extends RenderFeatures, TTag extends ElementType, TSlot extends Record<string, any>, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']> & {}): ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any, any>['bindings']>;
+    new <TFeature extends RenderFeatures, TSlot extends Record<string, any>, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['exports']>;
+    <TFeature extends RenderFeatures, TSlot extends Record<string, any>, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['props']> & {}): ReturnType<__sveltets_Render<TFeature, TSlot, TValue>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
 }
 declare const ElementOrComponent: $$IsomorphicComponent;
-type ElementOrComponent<TFeature extends RenderFeatures, TTag extends ElementType, TSlot extends Record<string, any>, TValue> = InstanceType<typeof ElementOrComponent<TFeature, TTag, TSlot, TValue>>;
+type ElementOrComponent<TFeature extends RenderFeatures, TSlot extends Record<string, any>, TValue> = InstanceType<typeof ElementOrComponent<TFeature, TSlot, TValue>>;
 export default ElementOrComponent;

package/dist/utils/state.js

@@ -1,10 +1,10 @@
 export const stateFromSlot = (slot = {}) => {
     if (typeof slot !== "object")
         return {};
-    let dataAttributes = {};
+    const dataAttributes = {};
     let exposeState = false;
-    let states = [];
-    for (let [k, v] of Object.entries(slot)) {
+    const states = [];
+    for (const [k, v] of Object.entries(slot)) {
         if (typeof v === "boolean") {
             exposeState = true;
         }
@@ -14,7 +14,7 @@ export const stateFromSlot = (slot = {}) => {
     }
     if (!exposeState)
         return {};
-    for (let s of states) {
+    for (const s of states) {
         dataAttributes[`data-${s}`] = "";
     }
     return {

package/dist/utils/types.d.ts

@@ -1,19 +1,22 @@
 import type { Snippet } from "svelte";
 import type { SvelteHTMLElements } from "svelte/elements";
-export type ElementType = keyof SvelteHTMLElements;
 export type Expand<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;
-export type PropsOf<TTag extends ElementType> = SvelteHTMLElements[TTag];
-type PropsWeControl = "as" | "children" | "class" | "ref" | "slot";
-type CleanProps<TTag extends ElementType, TOmittableProps extends PropertyKey = never> = Omit<PropsOf<TTag>, TOmittableProps | PropsWeControl>;
-type OurProps<TSlot extends Record<string, any>> = {
+export type Props<TTag extends string, TSlot extends Record<string, any> = {}, Overrides = {}> = Omit<SvelteHTMLElements[TTag], "asChild" | "children" | "class" | keyof Overrides> & ({
+    asChild: true;
     children?: Snippet<[TSlot & {
         props?: Record<string, any>;
     }]>;
+    class?: never;
+} | {
+    asChild?: never;
+    children?: Snippet<[TSlot]>;
     class?: string | null | ((bag: TSlot) => string);
-    ref?: HTMLElement;
-};
-export type Props<TTag extends ElementType, TSlot extends Record<string, any> = {}, TOmittableProps extends PropertyKey = never, Overrides = {}> = CleanProps<TTag, TOmittableProps | keyof Overrides> & OurProps<TSlot> & Overrides;
+}) & Overrides;
+export type PropsAsChild<TSlot extends Record<string, any> = {}, Overrides = {}> = {
+    children?: Snippet<[TSlot & {
+        props?: Record<string, any>;
+    }]>;
+} & Overrides;
 export type EnsureArray<T> = T extends any[] ? T : Expand<T>[];
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pzerelles/headlessui-svelte",
-  "version": "2.1.2-next.32",
+  "version": "2.1.2-next.33",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -16,38 +16,38 @@
     "svelte": "^5.0.0-next.244"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.27.8",
+    "@changesets/cli": "^2.27.9",
     "@changesets/types": "^6.0.0",
-    "@playwright/test": "^1.47.2",
+    "@playwright/test": "^1.48.0",
     "@pzerelles/heroicons-svelte": "^2.1.5",
     "@sveltejs/adapter-auto": "^3.2.5",
-    "@sveltejs/kit": "^2.6.1",
+    "@sveltejs/kit": "^2.6.3",
     "@sveltejs/package": "^2.3.5",
     "@sveltejs/vite-plugin-svelte": "4.0.0-next.7",
     "@testing-library/jest-dom": "^6.5.0",
-    "@testing-library/svelte": "^5.2.1",
+    "@testing-library/svelte": "^5.2.3",
     "@types/eslint": "^9.6.1",
-    "@types/node": "^20.16.10",
+    "@types/node": "^20.16.11",
     "autoprefixer": "^10.4.20",
-    "eslint": "^9.11.1",
+    "eslint": "^9.12.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-svelte": "^2.44.1",
-    "globals": "^15.9.0",
-    "jsdom": "^24.1.3",
+    "globals": "^15.10.0",
+    "jsdom": "^25.0.1",
     "outdent": "^0.8.0",
     "postcss": "^8.4.47",
     "prettier": "^3.3.3",
     "prettier-plugin-svelte": "^3.2.7",
     "prettier-plugin-tailwindcss": "^0.6.8",
     "publint": "^0.2.11",
-    "svelte": "5.0.0-next.260",
+    "svelte": "5.0.0-next.262",
     "svelte-check": "^4.0.4",
     "tailwindcss": "^3.4.13",
     "tslib": "^2.7.0",
     "typescript": "^5.6.2",
-    "typescript-eslint": "^8.7.0",
+    "typescript-eslint": "^8.8.1",
     "vite": "^5.4.8",
-    "vitest": "^2.1.1"
+    "vitest": "^2.1.2"
   },
   "dependencies": {
     "@floating-ui/core": "^1.6.8",

package/dist/combobox/Combobox.svelte

@@ -1,53 +0,0 @@
-<script lang="ts" module>
-  import type { ElementType, EnsureArray, Props } from "../utils/types.js"
-  import type { ByComparator } from "../hooks/use-by-comparator.js"
-
-  const DEFAULT_COMBOBOX_TAG = "svelte:fragment" as const
-  type ComboboxRenderPropArg<TValue, TActive = TValue> = {
-    open: boolean
-    disabled: boolean
-    activeIndex: number | null
-    activeOption: TActive | null
-    value: TValue
-  }
-
-  export type CheckboxProps<
-    TValue,
-    TMultiple extends boolean | undefined,
-    TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG,
-  > = Props<
-    TTag,
-    ComboboxRenderPropArg<NoInfer<TValue>>,
-    "value" | "defaultValue" | "multiple" | "onChange" | "by",
-    {
-      value?: TMultiple extends true ? EnsureArray<TValue> : TValue
-      defaultValue?: TMultiple extends true ? EnsureArray<NoInfer<TValue>> : NoInfer<TValue>
-
-      onChange?(value: TMultiple extends true ? EnsureArray<NoInfer<TValue>> : NoInfer<TValue> | null): void
-      by?: ByComparator<TMultiple extends true ? EnsureArray<NoInfer<TValue>>[number] : NoInfer<TValue>>
-
-      /** @deprecated The `<Combobox />` is now nullable default */
-      nullable?: boolean
-
-      multiple?: TMultiple
-      disabled?: boolean
-      form?: string
-      name?: string
-      immediate?: boolean
-      virtual?: {
-        options: NoInfer<TValue>[]
-        disabled?: (value: NoInfer<TValue>) => boolean
-      } | null
-
-      onclose?(): void
-
-      __demoMode?: boolean
-    }
-  >
-</script>
-
-<script lang="ts" generics="TType, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG">
-  import { useDisabled } from "../hooks/use-disabled.js"
-
-  const providedDisabled = useDisabled()
-</script>

package/dist/combobox/Combobox.svelte.d.ts

@@ -1,50 +0,0 @@
-import type { ElementType, EnsureArray, Props } from "../utils/types.js";
-import type { ByComparator } from "../hooks/use-by-comparator.js";
-declare const DEFAULT_COMBOBOX_TAG: "svelte:fragment";
-type ComboboxRenderPropArg<TValue, TActive = TValue> = {
-    open: boolean;
-    disabled: boolean;
-    activeIndex: number | null;
-    activeOption: TActive | null;
-    value: TValue;
-};
-export type CheckboxProps<TValue, TMultiple extends boolean | undefined, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG> = Props<TTag, ComboboxRenderPropArg<NoInfer<TValue>>, "value" | "defaultValue" | "multiple" | "onChange" | "by", {
-    value?: TMultiple extends true ? EnsureArray<TValue> : TValue;
-    defaultValue?: TMultiple extends true ? EnsureArray<NoInfer<TValue>> : NoInfer<TValue>;
-    onChange?(value: TMultiple extends true ? EnsureArray<NoInfer<TValue>> : NoInfer<TValue> | null): void;
-    by?: ByComparator<TMultiple extends true ? EnsureArray<NoInfer<TValue>>[number] : NoInfer<TValue>>;
-    /** @deprecated The `<Combobox />` is now nullable default */
-    nullable?: boolean;
-    multiple?: TMultiple;
-    disabled?: boolean;
-    form?: string;
-    name?: string;
-    immediate?: boolean;
-    virtual?: {
-        options: NoInfer<TValue>[];
-        disabled?: (value: NoInfer<TValue>) => boolean;
-    } | null;
-    onclose?(): void;
-    __demoMode?: boolean;
-}>;
-declare class __sveltets_Render<TType, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG> {
-    props(): Record<string, never>;
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): string;
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TType, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TType, TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TType, TTag>['props']>, ReturnType<__sveltets_Render<TType, TTag>['events']>, ReturnType<__sveltets_Render<TType, TTag>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TType, TTag>['bindings']>;
-    } & ReturnType<__sveltets_Render<TType, TTag>['exports']>;
-    <TType, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(internal: unknown, props: {
-        $$events?: ReturnType<__sveltets_Render<TType, TTag>['events']>;
-    }): ReturnType<__sveltets_Render<TType, TTag>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
-}
-declare const Combobox: $$IsomorphicComponent;
-type Combobox<TType, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG> = InstanceType<typeof Combobox<TType, TTag>>;
-export default Combobox;

package/dist/utils/Generic.svelte

@@ -1,57 +0,0 @@
-<script lang="ts" generics="TTag extends ElementType, TSlot extends Record<string, any>, TValue">
-  import { stateFromSlot } from "./state.js"
-  import type { ElementType, Props } from "./types.js"
-
-  let {
-    slot = {} as TSlot,
-    tag,
-    ref = $bindable(),
-    value = $bindable(),
-    checked = $bindable(),
-    children,
-    as = tag as TTag,
-    unmount,
-    static: isStatic,
-    ...props
-  }: {
-    as?: TTag
-    slot: TSlot
-    tag: ElementType
-    ref?: HTMLElement
-    value?: TValue
-    checked?: boolean
-  } & Props<TTag, TSlot> = $props()
-
-  const resolvedClass = $derived(
-    typeof props.class === "function" ? props.class(slot) : (props.class as string | undefined)
-  )
-</script>
-
-{#if as === "svelte:fragment"}
-  {#if children}{@render children({
-      ...slot,
-      props: {
-        ...props,
-        ...(resolvedClass ? { class: resolvedClass } : {}),
-        ...stateFromSlot(slot),
-      },
-    })}{/if}
-{:else if children}
-  {#if as === "select"}
-    <select bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value>
-      {@render children(slot)}
-    </select>
-  {:else}
-    <svelte:element this={as} bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)}>
-      {@render children(slot)}
-    </svelte:element>
-  {/if}
-{:else if as === "input" && props.type === "checkbox"}
-  <input type="checkbox" bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:checked />
-{:else if as === "input"}
-  <input bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value />
-{:else if as === "textarea"}
-  <textarea bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value></textarea>
-{:else}
-  <svelte:element this={as} bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} />
-{/if}

package/dist/utils/Generic.svelte.d.ts

@@ -1,31 +0,0 @@
-import type { ElementType } from "./types.js";
-declare class __sveltets_Render<TTag extends ElementType, TSlot extends Record<string, any>, TValue> {
-    props(): {
-        as?: TTag | undefined;
-        slot: TSlot;
-        tag: ElementType;
-        ref?: HTMLElement;
-        value?: TValue | undefined;
-        checked?: boolean;
-    } & (Exclude<keyof import("./types.js").PropsOf<TTag>, "slot" | "as" | "children" | "class" | "ref"> extends infer T extends keyof import("./types.js").PropsOf<TTag> ? { [P in T]: import("./types.js").PropsOf<TTag>[P]; } : never) & {
-        children?: import("svelte").Snippet<[TSlot & {
-            props?: Record<string, any>;
-        }]> | undefined;
-        class?: string | ((bag: TSlot) => string) | null | undefined;
-        ref?: HTMLElement;
-    };
-    events(): {};
-    slots(): {};
-    bindings(): "ref" | "value" | "checked";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TTag extends ElementType, TSlot extends Record<string, any>, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['bindings']>;
-    } & ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
-    <TTag extends ElementType, TSlot extends Record<string, any>, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']> & {}): ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
-}
-declare const Generic: $$IsomorphicComponent;
-type Generic<TTag extends ElementType, TSlot extends Record<string, any>, TValue> = InstanceType<typeof Generic<TTag, TSlot, TValue>>;
-export default Generic;

package/dist/utils/alternative-types.d.ts

@@ -1,20 +0,0 @@
-import type { Snippet } from "svelte";
-import type { SvelteHTMLElements } from "svelte/elements";
-export interface SvelteHTMLProps extends SvelteHTMLElements {
-    "svelte:fragment": {};
-}
-export type ElementType = keyof SvelteHTMLProps;
-export type Expand<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-type OurProps<TSlot> = {
-    children?: Snippet<[TSlot, Record<string, any>]>;
-    ref?: HTMLElement;
-    class?: string | null | ((bag: TSlot) => string);
-};
-type MergeProps3<T, U, V> = {
-    [K in keyof T | keyof U | keyof V]?: K extends keyof V ? V[K] : K extends keyof U ? U[K] : K extends keyof T ? T[K] : never;
-};
-export type Props<TTag extends ElementType, TSlot = {}, TOmittableProps extends PropertyKey = never, Overrides = {}> = MergeProps3<SvelteHTMLProps[TTag], OurProps<TSlot>, Overrides>;
-export type EnsureArray<T> = T extends any[] ? T : Expand<T>[];
-export {};

package/dist/utils/alternative-types.js

@@ -1 +0,0 @@
-export {};