@pzerelles/headlessui-svelte 2.0.0-next.1 → 2.1.1-next.1

package/dist/hooks/use-scroll-lock.svelte.js

@@ -0,0 +1,24 @@
+import { useDocumentOverflowLockedEffect } from "./document-overflow/use-document-overflow.svelte.js";
+import { useIsTopLayer } from "./use-is-top-layer.svelte.js";
+export function useScrollLock(options) {
+    const { enabled, ownerDocument, resolveAllowedContainers = () => [document.body] } = $derived(options);
+    const isTopLayer = useIsTopLayer({
+        get enabled() {
+            return enabled;
+        },
+        scope: "scroll-lock",
+    });
+    useDocumentOverflowLockedEffect({
+        get shouldBeLocked() {
+            return isTopLayer.value;
+        },
+        get doc() {
+            return ownerDocument;
+        },
+        get meta() {
+            return (meta) => ({
+                containers: [...(meta.containers ?? []), resolveAllowedContainers()],
+            });
+        },
+    });
+}

package/dist/hooks/use-sync-refs.d.ts

@@ -0,0 +1,7 @@
+import { type MutableRefObject } from "../utils/ref.svelte.js";
+declare const Optional: unique symbol;
+export declare function optionalRef<T>(cb: (ref: T) => void, isOptional?: boolean): ((ref: T) => void) & {
+    [Optional]: boolean;
+};
+export declare function useSyncRefs<TType>(...refs: (MutableRefObject<TType | null> | ((instance: TType) => void) | null)[]): ((value: TType) => void) | undefined;
+export {};

package/dist/hooks/use-sync-refs.js

@@ -0,0 +1,22 @@
+import { useRef } from "../utils/ref.svelte.js";
+const Optional = Symbol();
+export function optionalRef(cb, isOptional = true) {
+    return Object.assign(cb, { [Optional]: isOptional });
+}
+export function useSyncRefs(...refs) {
+    let syncRefs = (value) => {
+        for (let ref of refs) {
+            if (ref == null)
+                continue;
+            if (typeof ref === "function")
+                ref(value);
+            else
+                ref.current = value;
+        }
+    };
+    return refs.every((ref) => ref == null ||
+        // @ts-expect-error
+        ref?.[Optional])
+        ? undefined
+        : syncRefs;
+}

package/dist/hooks/use-text-value.svelte.d.ts

@@ -0,0 +1,3 @@
+export declare function useTextValue(options: {
+    element: HTMLElement | null;
+}): () => string;

package/dist/hooks/use-text-value.svelte.js

@@ -0,0 +1,20 @@
+import { getTextValue } from "../utils/get-text-value.js";
+export function useTextValue(options) {
+    const { element } = $derived(options);
+    let cacheKey = $state("");
+    let cacheValue = $state("");
+    return () => {
+        if (!element)
+            return "";
+        // Check for a cached version
+        let currentKey = element.innerText;
+        if (cacheKey === currentKey) {
+            return cacheValue;
+        }
+        // Calculate the value
+        let value = getTextValue(element).trim().toLowerCase();
+        cacheKey = currentKey;
+        cacheValue = value;
+        return value;
+    };
+}

package/dist/hooks/use-tracked-pointer.d.ts

@@ -0,0 +1,4 @@
+export declare function useTrackedPointer(): {
+    wasMoved(evt: PointerEvent): boolean;
+    update(evt: PointerEvent): void;
+};

package/dist/hooks/use-tracked-pointer.js

@@ -0,0 +1,26 @@
+import { BROWSER } from "esm-env";
+function eventToPosition(evt) {
+    return [evt.screenX, evt.screenY];
+}
+export function useTrackedPointer() {
+    let lastPos = [-1, -1];
+    return {
+        wasMoved(evt) {
+            // FIXME: Remove this once we use browser testing in all the relevant places.
+            // NOTE: This is replaced with a compile-time define during the build process
+            // This hack exists to work around a few failing tests caused by our inability to "move" the virtual pointer in JSDOM pointer events.
+            if (!BROWSER && process.env.TEST_BYPASS_TRACKED_POINTER) {
+                return true;
+            }
+            let newPos = eventToPosition(evt);
+            if (lastPos[0] === newPos[0] && lastPos[1] === newPos[1]) {
+                return false;
+            }
+            lastPos = newPos;
+            return true;
+        },
+        update(evt) {
+            lastPos = eventToPosition(evt);
+        },
+    };
+}

package/dist/hooks/use-transition.svelte.d.ts

@@ -0,0 +1,20 @@
+type TransitionData = {
+    closed?: boolean;
+    enter?: boolean;
+    leave?: boolean;
+    transition?: boolean;
+};
+export declare function transitionDataAttributes(data: TransitionData): Record<string, string>;
+export declare function useTransition(options: {
+    enabled: boolean;
+    element: HTMLElement | null | undefined;
+    show: boolean;
+    events?: {
+        start?(show: boolean): void;
+        end?(show: boolean): void;
+    };
+}): {
+    readonly visible: boolean;
+    readonly data: TransitionData;
+};
+export {};

package/dist/hooks/use-transition.svelte.js

@@ -0,0 +1,252 @@
+import { disposables, useDisposables } from "../utils/disposables.js";
+import { once } from "../utils/once.js";
+import { untrack } from "svelte";
+import { useFlags } from "./use-flags.svelte.js";
+/**
+ * ```
+ * ┌──────┐                │        ┌──────────────┐
+ * │Closed│                │        │Closed        │
+ * └──────┘                │        └──────────────┘
+ * ┌──────┐┌──────┐┌──────┐│┌──────┐┌──────┐┌──────┐
+ * │Frame ││Frame ││Frame │││Frame ││Frame ││Frame │
+ * └──────┘└──────┘└──────┘│└──────┘└──────┘└──────┘
+ * ┌──────────────────────┐│┌──────────────────────┐
+ * │Enter                 │││Leave                 │
+ * └──────────────────────┘│└──────────────────────┘
+ * ┌──────────────────────┐│┌──────────────────────┐
+ * │Transition            │││Transition            │
+ * ├──────────────────────┘│└──────────────────────┘
+ * │
+ * └─ Applied when `Enter` or `Leave` is applied.
+ * ```
+ */
+var TransitionState;
+(function (TransitionState) {
+    TransitionState[TransitionState["None"] = 0] = "None";
+    TransitionState[TransitionState["Closed"] = 1] = "Closed";
+    TransitionState[TransitionState["Enter"] = 2] = "Enter";
+    TransitionState[TransitionState["Leave"] = 4] = "Leave";
+})(TransitionState || (TransitionState = {}));
+export function transitionDataAttributes(data) {
+    let attributes = {};
+    for (let key in data) {
+        if (data[key] === true) {
+            attributes[`data-${key}`] = "";
+        }
+    }
+    return attributes;
+}
+export function useTransition(options) {
+    const { enabled, element, show, events } = $derived(options);
+    let visible = $state(show);
+    let flags = $state(enabled && visible ? TransitionState.Enter | TransitionState.Closed : TransitionState.None);
+    let inFlight = $state(false);
+    let cancelled = $state(false);
+    const d = useDisposables();
+    function retry(enabled, show, node, d) {
+        if (!enabled)
+            return;
+        if (show) {
+            visible = true;
+        }
+        if (!node) {
+            // Retry if the DOM node isn't available yet
+            if (show) {
+                flags |= TransitionState.Enter | TransitionState.Closed;
+                return d.nextFrame(() => retry(enabled, show, node, d));
+            }
+            return;
+        }
+        events?.start?.(show);
+        return transition(node, {
+            inFlight,
+            prepare() {
+                if (cancelled) {
+                    // Cancelled a cancellation, we're back to the original state.
+                    cancelled = false;
+                }
+                else {
+                    // If we were already in-flight, then we want to cancel the current
+                    // transition.
+                    cancelled = inFlight;
+                }
+                inFlight = true;
+                if (cancelled)
+                    return;
+                if (show) {
+                    flags = TransitionState.Enter | TransitionState.Closed;
+                }
+                else {
+                    flags = TransitionState.Leave | (flags & TransitionState.Closed);
+                }
+            },
+            run() {
+                if (cancelled) {
+                    // If we cancelled a transition, then the `show` state is going to
+                    // be inverted already, but that doesn't mean we have to go to that
+                    // new state.
+                    //
+                    // What we actually want is to revert to the "idle" state (the
+                    // stable state where an `Enter` transitions to, and a `Leave`
+                    // transitions from.)
+                    //
+                    // Because of this, it might look like we are swapping the flags in
+                    // the following branches, but that's not the case.
+                    if (!show) {
+                        flags = TransitionState.Leave | TransitionState.Closed;
+                    }
+                    else {
+                        flags = TransitionState.Enter | TransitionState.Closed;
+                    }
+                }
+                else {
+                    if (show) {
+                        flags = flags & ~TransitionState.Closed;
+                    }
+                    else {
+                        flags |= TransitionState.Closed;
+                    }
+                }
+            },
+            done() {
+                if (cancelled) {
+                    if (typeof node.getAnimations === "function" && node.getAnimations().length > 0) {
+                        return;
+                    }
+                }
+                inFlight = false;
+                flags = 0;
+                if (!show) {
+                    visible = false;
+                }
+                events?.end?.(show);
+            },
+        });
+    }
+    $effect(() => {
+        ;
+        [enabled, show, element, d];
+        return untrack(() => retry(enabled, show, element, d));
+    });
+    const data = $derived({
+        closed: enabled ? !!(flags & TransitionState.Closed) : undefined,
+        enter: enabled ? !!(flags & TransitionState.Enter) : undefined,
+        leave: enabled ? !!(flags & TransitionState.Leave) : undefined,
+        transition: enabled ? !!(flags & (TransitionState.Enter | TransitionState.Leave)) : undefined,
+    });
+    return {
+        get visible() {
+            return enabled ? visible : show;
+        },
+        get data() {
+            return data;
+        },
+    };
+}
+function transition(node, { prepare, run, done, inFlight, }) {
+    const d = disposables();
+    // Prepare the transitions by ensuring that all the "before" classes are
+    // applied and flushed to the DOM.
+    prepareTransition(node, {
+        prepare,
+        inFlight,
+    });
+    // This is a workaround for a bug in all major browsers.
+    //
+    // 1. When an element is just mounted
+    // 2. And you apply a transition to it (e.g.: via a class)
+    // 3. And you're using `getComputedStyle` and read any returned value
+    // 4. Then the `transition` immediately jumps to the end state
+    //
+    // This means that no transition happens at all. To fix this, we delay the
+    // actual transition by one frame.
+    d.nextFrame(() => {
+        // Wait for the transition, once the transition is complete we can cleanup.
+        // This is registered first to prevent race conditions, otherwise it could
+        // happen that the transition is already done before we start waiting for
+        // the actual event.
+        d.add(waitForTransition(node, done));
+        // Initiate the transition by applying the new classes.
+        run();
+    });
+    return d.dispose;
+}
+function waitForTransition(node, _done) {
+    let done = once(_done);
+    let d = disposables();
+    if (!node)
+        return d.dispose;
+    // Safari returns a comma separated list of values, so let's sort them and take the highest value.
+    let { transitionDuration, transitionDelay } = getComputedStyle(node);
+    let [durationMs, delayMs] = [transitionDuration, transitionDelay].map((value) => {
+        let [resolvedValue = 0] = value
+            .split(",")
+            // Remove falsy we can't work with
+            .filter(Boolean)
+            // Values are returned as `0.3s` or `75ms`
+            .map((v) => (v.includes("ms") ? parseFloat(v) : parseFloat(v) * 1000))
+            .sort((a, z) => z - a);
+        return resolvedValue;
+    });
+    let totalDuration = durationMs + delayMs;
+    if (totalDuration !== 0) {
+        if (process.env.NODE_ENV === "test") {
+            let dispose = d.setTimeout(() => {
+                done();
+                dispose();
+            }, totalDuration);
+        }
+        else {
+            let disposeGroup = d.group((d) => {
+                // Mark the transition as done when the timeout is reached. This is a fallback in case the
+                // transitionrun event is not fired.
+                let cancelTimeout = d.setTimeout(() => {
+                    done();
+                    d.dispose();
+                }, totalDuration);
+                // The moment the transitionrun event fires, we should cleanup the timeout fallback, because
+                // then we know that we can use the native transition events because something is
+                // transitioning.
+                d.addEventListener(node, "transitionrun", (event) => {
+                    if (event.target !== event.currentTarget)
+                        return;
+                    cancelTimeout();
+                    d.addEventListener(node, "transitioncancel", (event) => {
+                        if (event.target !== event.currentTarget)
+                            return;
+                        done();
+                        disposeGroup();
+                    });
+                });
+            });
+            d.addEventListener(node, "transitionend", (event) => {
+                if (event.target !== event.currentTarget)
+                    return;
+                done();
+                d.dispose();
+            });
+        }
+    }
+    else {
+        // No transition is happening, so we should cleanup already. Otherwise we have to wait until we
+        // get disposed.
+        done();
+    }
+    return d.dispose;
+}
+function prepareTransition(node, { inFlight, prepare }) {
+    // If we are already transitioning, then we don't need to force cancel the
+    // current transition (by triggering a reflow).
+    if (inFlight) {
+        prepare();
+        return;
+    }
+    let previous = node.style.transition;
+    // Force cancel current transition
+    node.style.transition = "none";
+    prepare();
+    // Trigger a reflow, flushing the CSS changes
+    node.offsetHeight;
+    // Reset the transition to what it was before
+    node.style.transition = previous;
+}

package/dist/index.d.ts

@@ -1,6 +1,10 @@
+export * from "./button/index.js";
 export * from "./checkbox/index.js";
 export * from "./description/index.js";
 export * from "./field/index.js";
 export * from "./fieldset/index.js";
 export * from "./label/index.js";
 export * from "./legend/index.js";
+export * from "./listbox/index.js";
+export * from "./switch/index.js";
+export * from "./tabs/index.js";

package/dist/index.js

@@ -1,6 +1,10 @@
+export * from "./button/index.js";
 export * from "./checkbox/index.js";
 export * from "./description/index.js";
 export * from "./field/index.js";
 export * from "./fieldset/index.js";
 export * from "./label/index.js";
 export * from "./legend/index.js";
+export * from "./listbox/index.js";
+export * from "./switch/index.js";
+export * from "./tabs/index.js";

package/dist/internal/FocusSentinel.svelte

@@ -0,0 +1,45 @@
+<script lang="ts">import { onMount } from "svelte";
+import Hidden, { HiddenFeatures } from "./Hidden.svelte";
+let { onfocus } = $props();
+let enabled = $state(true);
+let mounted = $state(false);
+onMount(() => {
+  mounted = true;
+});
+</script>
+
+{#if enabled}
+  <Hidden
+    as="button"
+    type="button"
+    features={HiddenFeatures.Focusable}
+    onfocus={(event: FocusEvent) => {
+      event.preventDefault()
+      let frame: ReturnType<typeof requestAnimationFrame>
+
+      let tries = 50
+      function forwardFocus() {
+        // Prevent infinite loops
+        if (tries-- <= 0) {
+          if (frame) cancelAnimationFrame(frame)
+          return
+        }
+
+        // Try to move focus to the correct element. This depends on the implementation
+        // of `onFocus` of course since it would be different for each place we use it in.
+        if (onfocus?.()) {
+          cancelAnimationFrame(frame)
+          if (!mounted) return
+
+          enabled = false
+          return
+        }
+
+        // Retry
+        frame = requestAnimationFrame(forwardFocus)
+      }
+
+      frame = requestAnimationFrame(forwardFocus)
+    }}
+  />
+{/if}

package/dist/internal/FocusSentinel.svelte.d.ts

@@ -0,0 +1,17 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports;
+    z_$$bindings?: Bindings;
+}
+declare const FocusSentinel: $$__sveltets_2_IsomorphicComponent<{
+    onfocus: () => boolean;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type FocusSentinel = InstanceType<typeof FocusSentinel>;
+export default FocusSentinel;

package/dist/internal/FormFields.svelte

@@ -14,10 +14,8 @@ let {
 let form = $state(null);
 const d = disposables();
 $effect(() => {
-  if (!onReset)
-    return;
-  if (!form)
-    return;
+  if (!onReset) return;
+  if (!form) return;
   return d.addEventListener(form, "reset", onReset);
 });
 </script>

package/dist/internal/FormFields.svelte.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
     new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
         $$bindings?: Bindings;
@@ -11,12 +10,12 @@ interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> =
 }
 declare const FormFields: $$__sveltets_2_IsomorphicComponent<{
     data: Record<string, any>;
-    overrides?: Record<string, any> | undefined;
-    form?: string | undefined;
-    disabled?: boolean | undefined;
-    onReset?: ((e: Event) => void) | undefined;
+    overrides?: Record<string, any>;
+    form?: string;
+    disabled?: boolean;
+    onReset?: (e: Event) => void;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type FormFields = InstanceType<typeof FormFields>;
 export default FormFields;

package/dist/internal/FormResolver.svelte

@@ -1,25 +1,20 @@
-<script lang="ts">import Hidden, { HiddenFeatures } from "./Hidden.svelte";
+<script lang="ts">import { onMount } from "svelte";
+import Hidden, { HiddenFeatures } from "./Hidden.svelte";
 let { setForm, formId } = $props();
 $effect(() => {
   if (formId) {
-    let resolvedForm = document.getElementById(formId);
-    if (resolvedForm)
-      setForm(resolvedForm);
+    const resolvedForm = document.getElementById(formId);
+    if (resolvedForm) setForm(resolvedForm);
   }
 });
+let element = $state();
+onMount(() => {
+  if (!element) return;
+  const resolvedForm = element.closest("form");
+  if (resolvedForm) setForm(resolvedForm);
+});
 </script>
 
 {#if !formId}
-  <Hidden
-    features={HiddenFeatures.Hidden}
-    as="input"
-    type="hidden"
-    hidden
-    readonly
-    ref={(el) => {
-      if (!el) return
-      let resolvedForm = el.closest("form")
-      if (resolvedForm) setForm(resolvedForm)
-    }}
-  />
+  <Hidden features={HiddenFeatures.Hidden} as="input" type="hidden" hidden readonly bind:ref={element} />
 {/if}

package/dist/internal/FormResolver.svelte.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
     new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
         $$bindings?: Bindings;
@@ -11,9 +10,9 @@ interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> =
 }
 declare const FormResolver: $$__sveltets_2_IsomorphicComponent<{
     setForm: (form: HTMLFormElement) => void;
-    formId?: string | undefined;
+    formId?: string;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type FormResolver = InstanceType<typeof FormResolver>;
 export default FormResolver;

package/dist/internal/Hidden.svelte

@@ -4,15 +4,15 @@
   HiddenFeatures2[HiddenFeatures2["Hidden"] = 4] = "Hidden";
   return HiddenFeatures2;
 })(HiddenFeatures || {});
+const DEFAULT_VISUALLY_HIDDEN_TAG = "div";
 </script>
 
-<script lang="ts">import { onMount } from "svelte";
-const DEFAULT_VISUALLY_HIDDEN_TAG = "div";
-let { as = "div", features = HiddenFeatures.None, ref: applyRef, ...theirProps } = $props();
-let ref = $state();
-onMount(() => {
-  applyRef?.(ref);
-});
+<script lang="ts" generics="TTag extends keyof SvelteHTMLElements">let {
+  as = DEFAULT_VISUALLY_HIDDEN_TAG,
+  ref = $bindable(),
+  features = HiddenFeatures.None,
+  ...theirProps
+} = $props();
 let ourProps = {
   "aria-hidden": (features & HiddenFeatures.Focusable) === HiddenFeatures.Focusable ? true : theirProps["aria-hidden"] ?? void 0,
   hidden: (features & HiddenFeatures.Hidden) === HiddenFeatures.Hidden ? true : void 0,
@@ -33,4 +33,4 @@ let ourProps = {
 };
 </script>
 
-<svelte:element this={as} {...theirProps} {...ourProps} bind:this={ref} />
+<svelte:element this={as} bind:this={ref} {...ourProps} {...theirProps} />

package/dist/internal/Hidden.svelte.d.ts

@@ -1,26 +1,35 @@
-/// <reference types="svelte" />
+import type { HTMLElementType, Props } from "../utils/types.js";
+import type { SvelteHTMLElements } from "svelte/elements";
 export declare enum HiddenFeatures {
     None = 1,
     Focusable = 2,
     Hidden = 4
 }
-import type { HTMLInputAttributes } from "svelte/elements";
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports;
-    z_$$bindings?: Bindings;
+declare const DEFAULT_VISUALLY_HIDDEN_TAG: "div";
+type HiddenRenderPropArg = {};
+type HiddenPropsWeControl = never;
+export type HiddenProps<TTag extends keyof SvelteHTMLElements = typeof DEFAULT_VISUALLY_HIDDEN_TAG> = Props<TTag, HiddenRenderPropArg, HiddenPropsWeControl, {
+    features?: HiddenFeatures;
+    ref?: HTMLElementType<TTag> | null;
+}>;
+declare class __sveltets_Render<TTag extends keyof SvelteHTMLElements> {
+    props(): HiddenProps<TTag>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
 }
-declare const Hidden: $$__sveltets_2_IsomorphicComponent<Omit<HTMLInputAttributes, "style"> & {
-    as?: string | undefined;
-    features?: HiddenFeatures | undefined;
-    ref?: ((el: HTMLElement) => void) | undefined;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
-type Hidden = InstanceType<typeof Hidden>;
+interface $$IsomorphicComponent {
+    new <TTag extends keyof SvelteHTMLElements>(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 keyof SvelteHTMLElements>(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 Hidden: $$IsomorphicComponent;
+type Hidden<TTag extends keyof SvelteHTMLElements> = InstanceType<typeof Hidden<TTag>>;
 export default Hidden;

package/dist/internal/HoistFormFields.svelte.d.ts

@@ -13,6 +13,6 @@ declare const HoistFormFields: $$__sveltets_2_IsomorphicComponent<{
     children: Snippet;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type HoistFormFields = InstanceType<typeof HoistFormFields>;
 export default HoistFormFields;