lithesome 0.14.3 → 0.15.2

package/dist/components/Accordion/Accordion.svelte

@@ -7,15 +7,22 @@
 		children,
 		use = [],
 		class: klass,
-		value = $bindable(),
+		value = $bindable([]),
 		self = $bindable(),
 		single = $bindable(false),
+		onChange,
 		...props
 	}: AccordionProps = $props();
 
 	const ctx = createAccordionRootContext({
 		single: stateValue(() => single),
-		value: stateValue(() => value)
+		value: stateValue(
+			() => value,
+			(v) => {
+				value = v;
+				onChange?.(v);
+			}
+		)
 	});
 </script>
 

package/dist/components/Accordion/Accordion.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { AccordionProps } from './types.js';
-declare const __propDef: {
-    props: AccordionProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type AccordionProps_ = typeof __propDef.props;
-export { AccordionProps_ as AccordionProps };
-export type AccordionEvents = typeof __propDef.events;
-export type AccordionSlots = typeof __propDef.slots;
-export default class Accordion extends SvelteComponent<AccordionProps_, AccordionEvents, AccordionSlots> {
-}
+declare const Accordion: import("svelte").Component<AccordionProps, {}, "self" | "value" | "single">;
+type Accordion = ReturnType<typeof Accordion>;
+export default Accordion;

package/dist/components/Accordion/AccordionButton.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { AccordionButtonProps } from './types.js';
-declare const __propDef: {
-    props: AccordionButtonProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type AccordionButtonProps_ = typeof __propDef.props;
-export { AccordionButtonProps_ as AccordionButtonProps };
-export type AccordionButtonEvents = typeof __propDef.events;
-export type AccordionButtonSlots = typeof __propDef.slots;
-export default class AccordionButton extends SvelteComponent<AccordionButtonProps_, AccordionButtonEvents, AccordionButtonSlots> {
-}
+declare const AccordionButton: import("svelte").Component<AccordionButtonProps, {}, "self">;
+type AccordionButton = ReturnType<typeof AccordionButton>;
+export default AccordionButton;

package/dist/components/Accordion/AccordionContent.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { AccordionContentProps } from './types.js';
-declare const __propDef: {
-    props: AccordionContentProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type AccordionContentProps_ = typeof __propDef.props;
-export { AccordionContentProps_ as AccordionContentProps };
-export type AccordionContentEvents = typeof __propDef.events;
-export type AccordionContentSlots = typeof __propDef.slots;
-export default class AccordionContent extends SvelteComponent<AccordionContentProps_, AccordionContentEvents, AccordionContentSlots> {
-}
+declare const AccordionContent: import("svelte").Component<AccordionContentProps, {}, "self">;
+type AccordionContent = ReturnType<typeof AccordionContent>;
+export default AccordionContent;

package/dist/components/Accordion/AccordionHeading.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { AccordionHeadingProps } from './types.js';
-declare const __propDef: {
-    props: AccordionHeadingProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type AccordionHeadingProps_ = typeof __propDef.props;
-export { AccordionHeadingProps_ as AccordionHeadingProps };
-export type AccordionHeadingEvents = typeof __propDef.events;
-export type AccordionHeadingSlots = typeof __propDef.slots;
-export default class AccordionHeading extends SvelteComponent<AccordionHeadingProps_, AccordionHeadingEvents, AccordionHeadingSlots> {
-}
+declare const AccordionHeading: import("svelte").Component<AccordionHeadingProps, {}, "self">;
+type AccordionHeading = ReturnType<typeof AccordionHeading>;
+export default AccordionHeading;

package/dist/components/Accordion/AccordionItem.svelte

@@ -10,10 +10,12 @@
 		use = [],
 		self = $bindable(),
 		disabled = $bindable(false),
+		value,
 		...props
 	}: AccordionItemProps = $props();
 
 	const ctx = createAccordionItemContext({
+		value: stateValue(() => value),
 		disabled: stateValue(() => disabled)
 	});
 </script>

package/dist/components/Accordion/AccordionItem.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { AccordionItemProps } from './types.js';
-declare const __propDef: {
-    props: AccordionItemProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type AccordionItemProps_ = typeof __propDef.props;
-export { AccordionItemProps_ as AccordionItemProps };
-export type AccordionItemEvents = typeof __propDef.events;
-export type AccordionItemSlots = typeof __propDef.slots;
-export default class AccordionItem extends SvelteComponent<AccordionItemProps_, AccordionItemEvents, AccordionItemSlots> {
-}
+declare const AccordionItem: import("svelte").Component<AccordionItemProps, {}, "self" | "disabled">;
+type AccordionItem = ReturnType<typeof AccordionItem>;
+export default AccordionItem;

package/dist/components/Accordion/main.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type Handler, type StateValues } from '../../internal/index.js';
+import { type StateValues } from '../../internal/index.js';
 import type { AccordionButtonEvents } from './types.js';
 interface Item {
     id: string;
@@ -6,7 +6,7 @@ interface Item {
 }
 type AccordionRootProps = StateValues<{
     single: boolean;
-    value?: string;
+    value: string[];
 }>;
 declare class AccordionRoot {
     uid: (component?: string) => string;
@@ -15,25 +15,30 @@ declare class AccordionRoot {
     items: Item[];
     activeItems: string[];
     constructor(props: AccordionRootProps);
-    toggleActiveItem: (itemId: string) => void;
+    toggleActiveItem: (itemValueOrId: string) => void;
     attrs: {
         readonly id: string;
+        readonly 'data-value': string[] | undefined;
         readonly 'data-accordion': "";
     };
 }
 type AccordionItemProps = StateValues<{
     disabled: boolean;
+    value?: string;
 }>;
 declare class AccordionItem {
     uid: (component?: string) => string;
     root: AccordionRoot;
     $disabled: AccordionItemProps['disabled'];
+    $value: AccordionItemProps['value'];
     Active: boolean;
     constructor(root: AccordionRoot, props: AccordionItemProps);
     attrs: {
+        readonly id: string;
         readonly 'data-accordionitem': "";
         readonly 'data-disabled': boolean;
         readonly 'data-state': "opened" | "closed";
+        readonly 'data-value': string | undefined;
     };
     state: {
         active: boolean;
@@ -65,7 +70,7 @@ declare class AccordionButton {
         readonly tabindex: 0 | -1;
         readonly 'data-accordionbutton': "";
         readonly 'data-active': true | undefined;
-        readonly onclick: Handler<MouseEvent, HTMLButtonElement> | undefined;
+        readonly onclick: import("../../internal/index.js").Handler<MouseEvent, HTMLButtonElement> | undefined;
     };
     state: {
         active: boolean;

package/dist/components/Accordion/main.svelte.js

@@ -8,20 +8,29 @@ class AccordionRoot {
     constructor(props) {
         this.$single = props.single;
         this.$value = props.value;
+        if (this.$value.val.length > 0)
+            this.activeItems = this.$value.val;
+        $effect(() => {
+            if (this.$value.val.length) {
+                this.activeItems = this.$value.val;
+            }
+        });
     }
-    toggleActiveItem = (itemId) => {
+    toggleActiveItem = (itemValueOrId) => {
         if (this.$single.val) {
-            this.activeItems = this.activeItems[0] === itemId ? [] : [itemId];
+            this.activeItems = this.activeItems[0] === itemValueOrId ? [] : [itemValueOrId];
         }
         else {
-            if (this.activeItems.includes(itemId))
-                this.activeItems = this.activeItems.filter((el) => el !== itemId);
+            if (this.activeItems.includes(itemValueOrId))
+                this.activeItems = this.activeItems.filter((el) => el !== itemValueOrId);
             else
-                this.activeItems.push(itemId);
+                this.activeItems.push(itemValueOrId);
         }
+        this.$value.val = this.activeItems;
     };
     attrs = $derived.by(() => ({
         id: this.uid(),
+        'data-value': this.$value.val.length > 0 ? this.$value.val : undefined,
         'data-accordion': ''
     }));
 }
@@ -29,15 +38,19 @@ class AccordionItem {
     uid = createUID('item');
     root;
     $disabled;
-    Active = $derived.by(() => this.root.activeItems.includes(this.uid()) || false);
+    $value;
+    Active = $derived.by(() => this.root.activeItems.includes(this.$value?.val || this.uid()) || false);
     constructor(root, props) {
         this.root = root;
         this.$disabled = props.disabled;
+        this.$value = props.value;
     }
     attrs = $derived.by(() => ({
+        id: this.uid(),
         'data-accordionitem': '',
         'data-disabled': this.$disabled.val,
-        'data-state': this.Active ? 'opened' : 'closed'
+        'data-state': this.Active ? 'opened' : 'closed',
+        'data-value': this.$value?.val || undefined
     }));
     state = $derived.by(() => ({
         active: this.Active,
@@ -73,12 +86,12 @@ class AccordionButton {
         if (this.item.$disabled.val)
             return;
         this.#events.onClick?.(e);
-        this.root.toggleActiveItem(this.item.uid());
+        this.root.toggleActiveItem(this.item.$value?.val || this.item.uid());
     };
     attrs = $derived.by(() => ({
         'aria-expanded': this.item.Active,
         'aria-disabled': this.item.$disabled.val,
-        'aria-controls': this.item.Active ? this.root.uid('content') : undefined,
+        'aria-controls': this.item.Active ? this.item.uid('content') : undefined,
         tabindex: this.item.$disabled.val ? -1 : 0,
         'data-accordionbutton': '',
         'data-active': this.item.Active || undefined,
@@ -101,7 +114,7 @@ class AccordionContent {
     }
     attrs = $derived.by(() => this.item && this.root
         ? {
-            id: this.root.uid('content'),
+            id: this.item.uid('content'),
             'data-accordioncontent': '',
             'data-active': this.item.Active
         }

package/dist/components/Accordion/types.d.ts

@@ -1,9 +1,18 @@
 import type { Props, Handler, Transition } from '../../internal/index.js';
 export interface AccordionProps extends Props<HTMLDivElement> {
-    /** The value of the active item. */
-    value?: string;
+    /**
+     * The value of the active item.\
+     *
+     * If items have no value set, the unique ID will be used.
+     */
+    value?: string[];
     /** Allow only a singluar `AccordionItem` to be opened at once. */
     single?: boolean;
+    /**
+     * An event that fires everytime the Accordion `value` prop changes.
+     * @param values The current values of the Accordion.
+     */
+    onChange?: (values: string[]) => void;
 }
 export interface AccordionContentProps extends Props<HTMLDivElement> {
     /**
@@ -41,6 +50,12 @@ interface AccordionItemState {
     disabled: boolean;
 }
 export interface AccordionItemProps extends Props<HTMLDivElement, AccordionItemState> {
+    /**
+     * The value of the accordion item.\
+     *
+     * If no value is set, unique ID is used.
+     */
+    value?: string;
     /** Disables the items, disallowing clicking and keyboard navigation. */
     disabled?: boolean;
 }

package/dist/components/Checkbox/Checkbox.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { CheckboxProps } from './types.js';
-declare const __propDef: {
-    props: CheckboxProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type CheckboxProps_ = typeof __propDef.props;
-export { CheckboxProps_ as CheckboxProps };
-export type CheckboxEvents = typeof __propDef.events;
-export type CheckboxSlots = typeof __propDef.slots;
-export default class Checkbox extends SvelteComponent<CheckboxProps_, CheckboxEvents, CheckboxSlots> {
-}
+declare const Checkbox: import("svelte").Component<CheckboxProps, {}, "self" | "disabled" | "checked">;
+type Checkbox = ReturnType<typeof Checkbox>;
+export default Checkbox;

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

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { ComboboxProps } from './types.js';
-declare const __propDef: {
-    props: ComboboxProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type ComboboxProps_ = typeof __propDef.props;
-export { ComboboxProps_ as ComboboxProps };
-export type ComboboxEvents = typeof __propDef.events;
-export type ComboboxSlots = typeof __propDef.slots;
-export default class Combobox extends SvelteComponent<ComboboxProps_, ComboboxEvents, ComboboxSlots> {
-}
+declare const Combobox: import("svelte").Component<ComboboxProps, {}, "self" | "value" | "label" | "disabled" | "visible" | "touched">;
+type Combobox = ReturnType<typeof Combobox>;
+export default Combobox;

package/dist/components/Combobox/ComboboxArrow.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { ComboboxArrowProps } from './types.js';
-declare const __propDef: {
-    props: ComboboxArrowProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type ComboboxArrowProps_ = typeof __propDef.props;
-export { ComboboxArrowProps_ as ComboboxArrowProps };
-export type ComboboxArrowEvents = typeof __propDef.events;
-export type ComboboxArrowSlots = typeof __propDef.slots;
-export default class ComboboxArrow extends SvelteComponent<ComboboxArrowProps_, ComboboxArrowEvents, ComboboxArrowSlots> {
-}
+declare const ComboboxArrow: import("svelte").Component<ComboboxArrowProps, {}, "self">;
+type ComboboxArrow = ReturnType<typeof ComboboxArrow>;
+export default ComboboxArrow;

package/dist/components/Combobox/ComboboxContent.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { ComboboxContentProps } from './types.js';
-declare const __propDef: {
-    props: ComboboxContentProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type ComboboxContentProps_ = typeof __propDef.props;
-export { ComboboxContentProps_ as ComboboxContentProps };
-export type ComboboxContentEvents = typeof __propDef.events;
-export type ComboboxContentSlots = typeof __propDef.slots;
-export default class ComboboxContent extends SvelteComponent<ComboboxContentProps_, ComboboxContentEvents, ComboboxContentSlots> {
-}
+declare const ComboboxContent: import("svelte").Component<ComboboxContentProps, {}, "self">;
+type ComboboxContent = ReturnType<typeof ComboboxContent>;
+export default ComboboxContent;

package/dist/components/Combobox/ComboboxInput.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { ComboboxInputProps } from './types.js';
-declare const __propDef: {
-    props: ComboboxInputProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type ComboboxInputProps_ = typeof __propDef.props;
-export { ComboboxInputProps_ as ComboboxInputProps };
-export type ComboboxInputEvents = typeof __propDef.events;
-export type ComboboxInputSlots = typeof __propDef.slots;
-export default class ComboboxInput extends SvelteComponent<ComboboxInputProps_, ComboboxInputEvents, ComboboxInputSlots> {
-}
+declare const ComboboxInput: import("svelte").Component<ComboboxInputProps, {}, "self" | "value">;
+type ComboboxInput = ReturnType<typeof ComboboxInput>;
+export default ComboboxInput;

package/dist/components/Combobox/ComboboxOption.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { ComboboxOptionProps } from './types.js';
-declare const __propDef: {
-    props: ComboboxOptionProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type ComboboxOptionProps_ = typeof __propDef.props;
-export { ComboboxOptionProps_ as ComboboxOptionProps };
-export type ComboboxOptionEvents = typeof __propDef.events;
-export type ComboboxOptionSlots = typeof __propDef.slots;
-export default class ComboboxOption extends SvelteComponent<ComboboxOptionProps_, ComboboxOptionEvents, ComboboxOptionSlots> {
-}
+declare const ComboboxOption: import("svelte").Component<ComboboxOptionProps, {}, "self" | "disabled">;
+type ComboboxOption = ReturnType<typeof ComboboxOption>;
+export default ComboboxOption;

package/dist/components/Hovercard/Hovercard.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { HovercardProps } from './types.js';
-declare const __propDef: {
-    props: HovercardProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type HovercardProps_ = typeof __propDef.props;
-export { HovercardProps_ as HovercardProps };
-export type HovercardEvents = typeof __propDef.events;
-export type HovercardSlots = typeof __propDef.slots;
-export default class Hovercard extends SvelteComponent<HovercardProps_, HovercardEvents, HovercardSlots> {
-}
+declare const Hovercard: import("svelte").Component<HovercardProps, {}, "self" | "visible">;
+type Hovercard = ReturnType<typeof Hovercard>;
+export default Hovercard;

package/dist/components/Hovercard/HovercardArrow.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { HovercardArrowProps } from './types.js';
-declare const __propDef: {
-    props: HovercardArrowProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type HovercardArrowProps_ = typeof __propDef.props;
-export { HovercardArrowProps_ as HovercardArrowProps };
-export type HovercardArrowEvents = typeof __propDef.events;
-export type HovercardArrowSlots = typeof __propDef.slots;
-export default class HovercardArrow extends SvelteComponent<HovercardArrowProps_, HovercardArrowEvents, HovercardArrowSlots> {
-}
+declare const HovercardArrow: import("svelte").Component<HovercardArrowProps, {}, "self">;
+type HovercardArrow = ReturnType<typeof HovercardArrow>;
+export default HovercardArrow;

package/dist/components/Hovercard/HovercardContent.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { HovercardContentProps } from './types.js';
-declare const __propDef: {
-    props: HovercardContentProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type HovercardContentProps_ = typeof __propDef.props;
-export { HovercardContentProps_ as HovercardContentProps };
-export type HovercardContentEvents = typeof __propDef.events;
-export type HovercardContentSlots = typeof __propDef.slots;
-export default class HovercardContent extends SvelteComponent<HovercardContentProps_, HovercardContentEvents, HovercardContentSlots> {
-}
+declare const HovercardContent: import("svelte").Component<HovercardContentProps, {}, "self">;
+type HovercardContent = ReturnType<typeof HovercardContent>;
+export default HovercardContent;

package/dist/components/Hovercard/HovercardTrigger.svelte

@@ -13,5 +13,5 @@
 </script>
 
 <div bind:this={self} use:useActions={use} class={classProp(klass, ctx.state)} {...ctx.attrs} {...props}>
-	{@render children(ctx.state)}
+	{@render children?.(ctx.state)}
 </div>

package/dist/components/Hovercard/HovercardTrigger.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { HovercardTriggerProps } from './types.js';
-declare const __propDef: {
-    props: HovercardTriggerProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type HovercardTriggerProps_ = typeof __propDef.props;
-export { HovercardTriggerProps_ as HovercardTriggerProps };
-export type HovercardTriggerEvents = typeof __propDef.events;
-export type HovercardTriggerSlots = typeof __propDef.slots;
-export default class HovercardTrigger extends SvelteComponent<HovercardTriggerProps_, HovercardTriggerEvents, HovercardTriggerSlots> {
-}
+declare const HovercardTrigger: import("svelte").Component<HovercardTriggerProps, {}, "self">;
+type HovercardTrigger = ReturnType<typeof HovercardTrigger>;
+export default HovercardTrigger;

package/dist/components/Menu/Menu.svelte

@@ -21,5 +21,5 @@
 </script>
 
 <div bind:this={self} use:useActions={use} class={classProp(klass, ctx.state)} {...ctx.attrs} {...props}>
-	{@render children(ctx.state)}
+	{@render children?.(ctx.state)}
 </div>

package/dist/components/Menu/Menu.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { MenuProps } from './types.js';
-declare const __propDef: {
-    props: MenuProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type MenuProps_ = typeof __propDef.props;
-export { MenuProps_ as MenuProps };
-export type MenuEvents = typeof __propDef.events;
-export type MenuSlots = typeof __propDef.slots;
-export default class Menu extends SvelteComponent<MenuProps_, MenuEvents, MenuSlots> {
-}
+declare const Menu: import("svelte").Component<MenuProps, {}, "self" | "visible">;
+type Menu = ReturnType<typeof Menu>;
+export default Menu;

package/dist/components/Menu/MenuArrow.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { MenuArrowProps } from './types.js';
-declare const __propDef: {
-    props: MenuArrowProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type MenuArrowProps_ = typeof __propDef.props;
-export { MenuArrowProps_ as MenuArrowProps };
-export type MenuArrowEvents = typeof __propDef.events;
-export type MenuArrowSlots = typeof __propDef.slots;
-export default class MenuArrow extends SvelteComponent<MenuArrowProps_, MenuArrowEvents, MenuArrowSlots> {
-}
+declare const MenuArrow: import("svelte").Component<MenuArrowProps, {}, "self">;
+type MenuArrow = ReturnType<typeof MenuArrow>;
+export default MenuArrow;

package/dist/components/Menu/MenuContent.svelte

@@ -23,7 +23,6 @@
 	{children}
 	componentName="Menu"
 	visible={ctx.root.$visible.val}
-	state={ctx.state}
 	{ctx}
 	{transition}
 	{use}

package/dist/components/Menu/MenuContent.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { MenuContentProps } from './types.js';
-declare const __propDef: {
-    props: MenuContentProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type MenuContentProps_ = typeof __propDef.props;
-export { MenuContentProps_ as MenuContentProps };
-export type MenuContentEvents = typeof __propDef.events;
-export type MenuContentSlots = typeof __propDef.slots;
-export default class MenuContent extends SvelteComponent<MenuContentProps_, MenuContentEvents, MenuContentSlots> {
-}
+declare const MenuContent: import("svelte").Component<MenuContentProps, {}, "self">;
+type MenuContent = ReturnType<typeof MenuContent>;
+export default MenuContent;

package/dist/components/Menu/MenuItem.svelte

@@ -34,5 +34,5 @@
 	{...ctx.attrs}
 	{...props}
 >
-	{@render children(ctx.state)}
+	{@render children?.(ctx.state)}
 </svelte:element>

package/dist/components/Menu/MenuItem.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { MenuItemProps } from './types.js';
-declare const __propDef: {
-    props: MenuItemProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type MenuItemProps_ = typeof __propDef.props;
-export { MenuItemProps_ as MenuItemProps };
-export type MenuItemEvents = typeof __propDef.events;
-export type MenuItemSlots = typeof __propDef.slots;
-export default class MenuItem extends SvelteComponent<MenuItemProps_, MenuItemEvents, MenuItemSlots> {
-}
+declare const MenuItem: import("svelte").Component<MenuItemProps, {}, "self" | "disabled">;
+type MenuItem = ReturnType<typeof MenuItem>;
+export default MenuItem;

package/dist/components/Menu/MenuTrigger.svelte

@@ -13,5 +13,5 @@
 </script>
 
 <div bind:this={self} use:useActions={use} class={classProp(klass, ctx.state)} data-menutrigger="" {...props}>
-	{@render children(ctx.state)}
+	{@render children?.(ctx.state)}
 </div>

package/dist/components/Menu/MenuTrigger.svelte.d.ts

@@ -1,15 +1,4 @@
-import { SvelteComponent } from "svelte";
 import type { MenuTriggerProps } from './types.js';
-declare const __propDef: {
-    props: MenuTriggerProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-type MenuTriggerProps_ = typeof __propDef.props;
-export { MenuTriggerProps_ as MenuTriggerProps };
-export type MenuTriggerEvents = typeof __propDef.events;
-export type MenuTriggerSlots = typeof __propDef.slots;
-export default class MenuTrigger extends SvelteComponent<MenuTriggerProps_, MenuTriggerEvents, MenuTriggerSlots> {
-}
+declare const MenuTrigger: import("svelte").Component<MenuTriggerProps, {}, "self">;
+type MenuTrigger = ReturnType<typeof MenuTrigger>;
+export default MenuTrigger;