lutra 0.0.17 → 0.0.19

package/dist/data/Stat.svelte.d.ts

@@ -3,21 +3,15 @@ import type { ComponentType } from "svelte";
 import { type StatusColorOrString } from "../utils/color.js";
 declare const __propDef: {
     props: {
-        /** The title of the stat. */
         title?: string | undefined;
-        /** The value to display. */
         value?: string | number | Date | undefined;
-        /** The prefix to display before the value. Can be a string, a URL, a Snippet, or a Svelte component. */
         prefix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
             _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
         }) | ComponentType | undefined;
-        /** The suffix to display after the value. Can be a string, a URL, a Snippet, or a Svelte component. */
         suffix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
             _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
         }) | ComponentType | undefined;
-        /** The color of the stat. */
         color?: StatusColorOrString | undefined;
-        /** A function to format the value. Can be an [Intl.NumberFormat object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat), an [Intl.DateTimeFormat object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat), or a function that takes in a value and returns a string. */
         formatter?: Intl.NumberFormat | Intl.DateTimeFormat | ((value: number | string | Date | undefined) => string) | undefined;
     };
     events: {
@@ -29,5 +23,17 @@ export type StatProps = typeof __propDef.props;
 export type StatEvents = typeof __propDef.events;
 export type StatSlots = typeof __propDef.slots;
 export default class Stat extends SvelteComponent<StatProps, StatEvents, StatSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        title?: string | undefined;
+        value?: string | number | Date | undefined;
+        prefix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        }) | ComponentType | undefined;
+        suffix?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        }) | ComponentType | undefined;
+        color?: StatusColorOrString | undefined;
+        formatter?: Intl.NumberFormat | Intl.DateTimeFormat | ((value: string | number | Date | undefined) => string) | undefined;
+    }>);
 }
 export {};

package/dist/display/Avatar.svelte.d.ts

@@ -14,5 +14,10 @@ export type AvatarProps = typeof __propDef.props;
 export type AvatarEvents = typeof __propDef.events;
 export type AvatarSlots = typeof __propDef.slots;
 export default class Avatar extends SvelteComponent<AvatarProps, AvatarEvents, AvatarSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        src?: string | undefined;
+        name?: string | undefined;
+        shape?: "circle" | "square" | "rounded" | undefined;
+    }>);
 }
 export {};

package/dist/display/Badge.svelte.d.ts

@@ -2,17 +2,11 @@ import { SvelteComponent } from "svelte";
 import type { StatusColorOrString } from "../utils/color.js";
 declare const __propDef: {
     props: {
-        /** Count to display in the badge. */
         count?: number | undefined;
-        /** The maximum count to display. */
         max?: number | undefined;
-        /** The color of the tag. */
         color?: StatusColorOrString | undefined;
-        /** Whether to add a glow to the badge. */
         glow?: boolean | undefined;
-        /** Whether to add an outline to the badge. */
         outline?: boolean | undefined;
-        /** The content to display inside the badge. */
         children?: ((this: void) => typeof import("svelte").SnippetReturn & {
             _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
         }) | undefined;
@@ -26,5 +20,15 @@ export type BadgeProps = typeof __propDef.props;
 export type BadgeEvents = typeof __propDef.events;
 export type BadgeSlots = typeof __propDef.slots;
 export default class Badge extends SvelteComponent<BadgeProps, BadgeEvents, BadgeSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        count?: number | undefined;
+        max?: number | undefined;
+        color?: StatusColorOrString | undefined;
+        glow?: boolean | undefined;
+        outline?: boolean | undefined;
+        children?: ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        }) | undefined;
+    }>);
 }
 export {};

package/dist/display/Callout.svelte

@@ -37,14 +37,12 @@ if (!icon) {
 }
 </script>
 
-<div class="Callout {type}" class:hasIcon={!!icon} class:contained class:rounded class:dismissable>
+<div class="Callout {type}" class:hasIcon={!!icon} class:contained class:rounded class:dismissable style="--margin-scale: 0.5;">
     {#if icon}
         <Icon {icon} --icon-width="1.5rem" --icon-height="1.5rem" />
     {/if}
     <div class="CalloutText">
-        <PageContent>
-            <slot />
-        </PageContent>
+        <slot />
     </div>
     {#if dismissable}
         <div class="Dismiss">
@@ -67,6 +65,10 @@ if (!icon) {
         display: grid;
         gap: var(--gap, 1rem);
         align-items: var(--align-items, start);
+        --text-heading: hsla(240, 10%, 98%);
+        --text: hsla(240, 10%, 95%);
+        --text-subtle: hsla(240, 10%, 90%);
+        color: var(--text-heading);
     }
     .Callout.contained {
         border: var(--border);
@@ -102,4 +104,6 @@ if (!icon) {
         padding: 0.75rem;
         cursor: pointer;
     }
+    .CalloutText {
+    }
 </style>

package/dist/display/Callout.svelte.d.ts

@@ -2,22 +2,13 @@ import { SvelteComponent } from "svelte";
 import type { ComponentType } from "svelte";
 declare const __propDef: {
     props: {
-        /** The icon to display. If not specified, it will default to the type. */
         icon?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
             _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
         }) | ComponentType | undefined;
-        /** The type of callout. If not specified and no icon is provided, no icon will be displayed. */
         type?: "ok" | "alert" | "warn" | "info" | "task" | undefined;
-        /** Whether to contain the element in a box. */
         contained?: boolean | undefined;
-        /** Whether to round the corners of the element. */
         rounded?: boolean | undefined;
-        /** Whether the callout is dismissable. */
         dismissable?: boolean | undefined;
-    } & {
-        children?: ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
     };
     events: {
         [evt: string]: CustomEvent<any>;
@@ -30,5 +21,16 @@ export type CalloutProps = typeof __propDef.props;
 export type CalloutEvents = typeof __propDef.events;
 export type CalloutSlots = typeof __propDef.slots;
 export default class Callout extends SvelteComponent<CalloutProps, CalloutEvents, CalloutSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<__sveltets_2_PropsWithChildren<{
+        icon?: string | ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        }) | ComponentType | undefined;
+        type?: "ok" | "alert" | "warn" | "info" | "task" | undefined;
+        contained?: boolean | undefined;
+        rounded?: boolean | undefined;
+        dismissable?: boolean | undefined;
+    }, {
+        default: {};
+    }>>);
 }
 export {};

package/dist/display/Close.svelte

@@ -0,0 +1,58 @@
+<script lang="ts">let {
+  onclick,
+  position
+} = $props();
+</script>
+
+<button class="Close {position}" {onclick}>
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <line x1="18" y1="6" x2="6" y2="18"></line>
+        <line x1="6" y1="6" x2="18" y2="18"></line>
+    </svg>
+</button>
+
+<style>
+    .Close {
+        cursor: pointer;
+        padding: var(--close-padding, 0.5rem);
+        border-radius: 50%;
+        color: var(--text);
+        cursor: pointer;
+        pointer-events: auto;
+    }
+
+    svg {
+        width: max(1.5rem, 16px);
+        height: max(1.5rem, 16px);
+    }
+
+    .Close:hover {
+        color: var(--text-subtle);
+    }
+
+    .Close.top {
+        position: absolute;
+        top: 0;
+        right: 0;
+        z-index: 100;
+    }
+
+    .Close.bottom {
+        position: absolute;
+        bottom: 0;
+        right: 0;
+    }
+
+    .Close.left {
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: auto;
+    }
+
+    .Close.right {
+        position: absolute;
+        top: 0;
+        right: 0;
+    }
+</style>

package/dist/display/Close.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        onclick?: ((e: MouseEvent) => void) | undefined;
+        position?: "top left" | "top right" | "bottom left" | "bottom right" | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type CloseProps = typeof __propDef.props;
+export type CloseEvents = typeof __propDef.events;
+export type CloseSlots = typeof __propDef.slots;
+export default class Close extends SvelteComponent<CloseProps, CloseEvents, CloseSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        onclick?: ((e: MouseEvent) => void) | undefined;
+        position?: "top left" | "top right" | "bottom left" | "bottom right" | undefined;
+    }>);
+}
+export {};

package/dist/display/Code.svelte.d.ts

@@ -1,19 +1,12 @@
 import { SvelteComponent } from "svelte";
 declare const __propDef: {
     props: {
-        /** The code to display. */
-        code: string;
-        /** A function to highlight parts of the code. */
+        code: import("svelte").Bindable<string>;
         highlight?: ((code: string) => string) | undefined;
-        /** Whether the code is copyable. */
         copyable?: boolean | undefined;
-        /** Whether to contain the element in a box. */
         contained?: boolean | undefined;
-        /** Whether to round the corners of the element. */
         rounded?: boolean | undefined;
-        /** Whether to show line numbers. */
         lineNumbers?: boolean | undefined;
-        /** Whether the code is readonly. */
         readonly?: boolean | undefined;
     };
     events: {
@@ -25,5 +18,14 @@ export type CodeProps = typeof __propDef.props;
 export type CodeEvents = typeof __propDef.events;
 export type CodeSlots = typeof __propDef.slots;
 export default class Code extends SvelteComponent<CodeProps, CodeEvents, CodeSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        code: import("svelte").Bindable<string>;
+        highlight?: ((code: string) => string) | undefined;
+        copyable?: boolean | undefined;
+        contained?: boolean | undefined;
+        rounded?: boolean | undefined;
+        lineNumbers?: boolean | undefined;
+        readonly?: boolean | undefined;
+    }>);
 }
 export {};

package/dist/display/ContextTip.svelte

@@ -8,7 +8,7 @@ let {
 
 <Tooltip {tip}>
     <a href="#foo" onclick={(e) => { e.preventDefault(); e.stopPropagation(); }}>
-        <Icon icon={Help} --icon-width="16px" --icon-height="16px" --cursor="help" />
+        <Icon icon={Help} --icon-width="16px" --icon-height="16px" --cursor="help" --vertical-align="baseline" />
     </a>
 </Tooltip>
 
@@ -22,6 +22,5 @@ let {
     }
     a:focus,
     a:active {
-        outline-offset: -2px;
     }
 </style>

package/dist/display/ContextTip.svelte.d.ts

@@ -13,5 +13,10 @@ export type ContextTipProps = typeof __propDef.props;
 export type ContextTipEvents = typeof __propDef.events;
 export type ContextTipSlots = typeof __propDef.slots;
 export default class ContextTip extends SvelteComponent<ContextTipProps, ContextTipEvents, ContextTipSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        tip: string | ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        });
+    }>);
 }
 export {};

package/dist/display/Details.svelte.d.ts

@@ -2,15 +2,10 @@ import { SvelteComponent } from "svelte";
 import type { Snippet } from "svelte";
 declare const __propDef: {
     props: {
-        /** The summary of the element. Can be a string or a snippet. */
         summary: string | Snippet;
-        /** Contain the element in a box. */
         contained?: boolean | undefined;
-        /** Round the corners of the element if contained. */
         rounded?: boolean | undefined;
-        /** Whether the details are open. */
         open?: boolean | undefined;
-        /** The content of the element. */
         children: Snippet;
     };
     events: {
@@ -22,5 +17,16 @@ export type DetailsProps = typeof __propDef.props;
 export type DetailsEvents = typeof __propDef.events;
 export type DetailsSlots = typeof __propDef.slots;
 export default class Details extends SvelteComponent<DetailsProps, DetailsEvents, DetailsSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        summary: string | ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        });
+        contained?: boolean | undefined;
+        rounded?: boolean | undefined;
+        open?: boolean | undefined;
+        children: (this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        };
+    }>);
 }
 export {};

package/dist/display/Hero.svelte.d.ts

@@ -3,13 +3,9 @@ import { type Snippet } from "svelte";
 declare const __propDef: {
     props: {
         children: Snippet;
-        /** Add padding to the container. Pass in either a boolean or an array of booleans to specify padding on the block and inline axes. */
         pad?: string | boolean | [boolean, boolean] | [boolean, boolean, boolean] | [boolean, boolean, boolean, boolean] | [string, string] | [string, string, string] | [string, string, string, string] | undefined;
-        /** Center the content. */
         center?: boolean | undefined;
-        /** Make the hero full width to the container (nearest element with `container-type: inline-size;`) */
         fullWidth?: boolean | undefined;
-        /** Contain the hero to the container (nearest element with `container-type: inline-size;`) */
         contained?: boolean | undefined;
     };
     events: {
@@ -21,5 +17,14 @@ export type HeroProps = typeof __propDef.props;
 export type HeroEvents = typeof __propDef.events;
 export type HeroSlots = typeof __propDef.slots;
 export default class Hero extends SvelteComponent<HeroProps, HeroEvents, HeroSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        children: (this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        };
+        pad?: string | boolean | [boolean, boolean] | [boolean, boolean, boolean] | [boolean, boolean, boolean, boolean] | [string, string] | [string, string, string] | [string, string, string, string] | undefined;
+        center?: boolean | undefined;
+        fullWidth?: boolean | undefined;
+        contained?: boolean | undefined;
+    }>);
 }
 export {};

package/dist/display/Icon.svelte

@@ -17,18 +17,16 @@ let {
 
 <style>
     .Icon {
-        display: flex;
+        display: inline-flex;
         align-items: center;
         justify-content: center;
         font-size: 1em;
+        line-height: inherit;
         width: max(
             var(--icon-width,
                 var(--icon-height, 1rem)
             ), 16px);
-        height: max(
-            var(--icon-height,
-                var(--icon-width, 1rem)
-            ), 16px);
+        height: max(var(--icon-height, auto), 16px);
         overflow: clip;
         vertical-align: var(--vertical-align, text-bottom);
         cursor: var(--cursor, default);
@@ -36,7 +34,7 @@ let {
     img,
     .Icon :global(svg) {
         width: 100%;
-        height: 100%;
+        height: auto;
         display: block;
     }
 </style>

package/dist/display/Icon.svelte.d.ts

@@ -14,5 +14,11 @@ export type IconProps = typeof __propDef.props;
 export type IconEvents = typeof __propDef.events;
 export type IconSlots = typeof __propDef.slots;
 export default class Icon extends SvelteComponent<IconProps, IconEvents, IconSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        icon: string | ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        }) | ComponentType;
+        alt?: string | undefined;
+    }>);
 }
 export {};

package/dist/display/IconButton.svelte

@@ -1,7 +1,6 @@
 <script lang="ts">import Icon from "./Icon.svelte";
-import { fade, fly, slide } from "svelte/transition";
+import { fly } from "svelte/transition";
 import { popBezier, popBezierInverse } from "../utils/transitions.js";
-import { cubicIn, cubicOut } from "svelte/easing";
 let {
   icon,
   disabled,
@@ -70,7 +69,7 @@ let {
         grid-area: icon;
         display: inline-flex;
     }
-    @media(max-width: 640px) {
+    @media(max-width: 960px) {
         .IconMask {
             padding-inline: calc(var(--padding, 0.75em) * 0.75);
             padding-block: calc(var(--padding, 0.75em) * 0.75);

package/dist/display/IconButton.svelte.d.ts

@@ -2,15 +2,11 @@ import { SvelteComponent } from "svelte";
 import type { ComponentType } from "svelte";
 declare const __propDef: {
     props: {
-        /** The icon to display. */
         icon: string | ComponentType;
-        /** The children to display. */
         children?: ((this: void) => typeof import("svelte").SnippetReturn & {
             _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
         }) | undefined;
-        /** The onclick event. */
         onclick?: ((event: MouseEvent) => void) | undefined;
-        /** Whether the button is disabled. */
         disabled?: boolean | undefined;
     };
     events: {
@@ -22,5 +18,13 @@ export type IconButtonProps = typeof __propDef.props;
 export type IconButtonEvents = typeof __propDef.events;
 export type IconButtonSlots = typeof __propDef.slots;
 export default class IconButton extends SvelteComponent<IconButtonProps, IconButtonEvents, IconButtonSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        icon: string | ComponentType;
+        children?: ((this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        }) | undefined;
+        onclick?: ((event: MouseEvent) => void) | undefined;
+        disabled?: boolean | undefined;
+    }>);
 }
 export {};

package/dist/display/Image.svelte

@@ -1,16 +1,23 @@
-<script lang="ts">let {
+<script lang="ts">import { decode } from "blurhash";
+import { fade } from "svelte/transition";
+let {
+  hash,
+  width,
+  height,
   aspectRatio,
   fit,
   src,
   srcset,
   alt,
-  width,
-  height,
   style,
   class: className
 } = $props();
+let canvas = $state(null);
+let el = $state(null);
+let elWidth = $state(32);
+let elHeight = $state(32);
 if (!src && srcset) {
-  const [src1, src2] = srcset.split(", ");
+  const [src1] = srcset.split(", ");
   src = src1.split(" ")[0];
 }
 if (!style) {
@@ -18,20 +25,63 @@ if (!style) {
 } else {
   style += ` aspect-ratio: ${aspectRatio};`;
 }
+let decoded = $state(false);
+let loaded = $state(false);
+const onload = () => {
+  loaded = true;
+};
+$effect(() => {
+  if (hash) {
+    setTimeout(() => {
+      const pixels = decode(hash, elWidth, elHeight);
+      const ctx = canvas.getContext("2d");
+      const imageData = ctx.createImageData(elWidth, elHeight);
+      imageData.data.set(pixels);
+      ctx.putImageData(imageData, 0, 0);
+      decoded = true;
+    }, 0);
+  }
+});
 </script>
 
-<img
-    src={src}
-    srcset={srcset}
-    alt={alt}
-    width={width}
-    height={height}
-    style={style}
-    class="{className} {fit}"
-/>
+<div class="BlurHashImage" class:loaded>
+    <img
+        bind:this={el}
+        bind:clientWidth={elWidth}
+        bind:clientHeight={elHeight}
+        onload={onload}
+        src={src}
+        srcset={srcset}
+        alt={alt}
+        width={width}
+        height={height}
+        style={style}
+        class="{className} {fit}"
+    />
+    {#if !loaded && hash}
+        <canvas class:decoded out:fade={{ duration: 100 }} width={elWidth} height={elHeight} bind:this={canvas}></canvas>
+    {/if}
+</div>
 
 <style>
+    .BlurHashImage {
+        position: relative;
+        display: grid;
+        grid-template-areas: "img";
+    }
+    canvas {
+        z-index: 2;
+        opacity: 0;
+        width: 100%;
+        grid-area: img;
+        transition: opacity 200ms;
+    }
+    canvas.decoded {
+        opacity: 1;
+    }
     img {
+        z-index: 1;
+        grid-area: img;
         display: inline-block;
         vertical-align: middle;
     }

package/dist/display/Image.svelte.d.ts

@@ -1,13 +1,14 @@
 import { SvelteComponent } from "svelte";
 declare const __propDef: {
     props: {
+        hash?: string | undefined;
         aspectRatio?: string | undefined;
         fit?: "cover" | "contain" | "scale-down" | undefined;
         src?: string | undefined;
         srcset?: string | undefined;
         alt?: string | undefined;
-        width?: string | undefined;
-        height?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
         style?: string | undefined;
         class?: string | undefined;
     };
@@ -20,5 +21,17 @@ export type ImageProps = typeof __propDef.props;
 export type ImageEvents = typeof __propDef.events;
 export type ImageSlots = typeof __propDef.slots;
 export default class Image extends SvelteComponent<ImageProps, ImageEvents, ImageSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        hash?: string | undefined;
+        aspectRatio?: string | undefined;
+        fit?: "cover" | "contain" | "scale-down" | undefined;
+        src?: string | undefined;
+        srcset?: string | undefined;
+        alt?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        style?: string | undefined;
+        class?: string | undefined;
+    }>);
 }
 export {};

package/dist/display/Indicator.svelte.d.ts

@@ -2,11 +2,8 @@ import { SvelteComponent } from "svelte";
 import { type StatusColorOrString } from "../utils/color.js";
 declare const __propDef: {
     props: {
-        /** The color of the tag. Select from default status colors or provide a CSS Color value. */
         color?: StatusColorOrString | undefined;
-        /** Possible motion to apply to the indicator. */
         motion?: "highlight" | "pulse" | "spin" | "blink" | "bulge" | "tunnel" | "typing" | undefined;
-        /** ARIA label to use when a custom color is applied */
         label?: string | undefined;
     };
     events: {
@@ -18,5 +15,10 @@ export type IndicatorProps = typeof __propDef.props;
 export type IndicatorEvents = typeof __propDef.events;
 export type IndicatorSlots = typeof __propDef.slots;
 export default class Indicator extends SvelteComponent<IndicatorProps, IndicatorEvents, IndicatorSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        color?: StatusColorOrString | undefined;
+        motion?: "highlight" | "pulse" | "spin" | "blink" | "bulge" | "tunnel" | "typing" | undefined;
+        label?: string | undefined;
+    }>);
 }
 export {};

package/dist/display/Inset.svelte.d.ts

@@ -13,5 +13,10 @@ export type InsetProps = typeof __propDef.props;
 export type InsetEvents = typeof __propDef.events;
 export type InsetSlots = typeof __propDef.slots;
 export default class Inset extends SvelteComponent<InsetProps, InsetEvents, InsetSlots> {
+    constructor(options?: import("svelte").ComponentConstructorOptions<{
+        children: (this: void) => typeof import("svelte").SnippetReturn & {
+            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
+        };
+    }>);
 }
 export {};