@bysages/svelte 0.2.2 → 0.3.0

package/dist/index-Bj2IsU9D.d.mts

@@ -0,0 +1,26 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/tree-select/props.d.ts
+interface TreeSelectNode {
+  label: string;
+  value: string;
+  children?: TreeSelectNode[];
+  disabled?: boolean;
+}
+interface TreeSelectProps extends HTMLAttributes<HTMLButtonElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the chosen leaf. */
+  value?: string;
+  data: TreeSelectNode[];
+  placeholder?: string;
+  /** Put a filter line at the top of the vessel; matches keep their
+   * ancestors and the branches fan open. */
+  filterable?: boolean;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/tree-select/index.d.ts
+/** A tree behind a field: the control reads like an input, the vessel
+ * below walks the hierarchy, and one leaf click closes the deal. */
+declare const TreeSelect: import("svelte").Component<TreeSelectProps, {}, "value">;
+//#endregion
+export { TreeSelectNode as n, TreeSelectProps as r, TreeSelect as t };

package/dist/index-BkK_8C_c.d.mts

@@ -0,0 +1,29 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes, HTMLButtonAttributes } from "svelte/elements";
+//#region src/components/banner/props.d.ts
+type BannerStatus = "ink" | "info" | "success" | "warning" | "danger";
+interface BannerProps extends HTMLAttributes<HTMLElement> {
+  status?: BannerStatus;
+  children?: Snippet;
+}
+interface BannerPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+interface BannerCloseProps extends HTMLButtonAttributes {}
+//#endregion
+//#region src/components/banner/index.d.ts
+/** A page-level notice, spoken across the full measure: a wash of the
+ * status pigment, one heavier hairline on the leading edge, and room
+ * for actions and a quiet close. Ink is the neutral register; the four
+ * semantic pigments are fixed. */
+declare const Banner: import("svelte").Component<BannerProps, {}, ""> & {
+  Root: import("svelte").Component<BannerProps, {}, "">;
+  Icon: import("svelte").Component<BannerPartProps, {}, "">;
+  Body: import("svelte").Component<BannerPartProps, {}, "">;
+  Title: import("svelte").Component<BannerPartProps, {}, "">;
+  Description: import("svelte").Component<BannerPartProps, {}, "">;
+  Actions: import("svelte").Component<BannerPartProps, {}, "">;
+  Close: import("svelte").Component<BannerCloseProps, {}, "">;
+};
+//#endregion
+export { BannerStatus as a, BannerProps as i, BannerCloseProps as n, BannerPartProps as r, Banner as t };

package/dist/index-BmFfkztS.d.mts

@@ -0,0 +1,14 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/block-ui/props.d.ts
+interface BlockUIProps extends HTMLAttributes<HTMLDivElement> {
+  /** Whether the curtain is drawn. */
+  blocked?: boolean;
+  children?: import("svelte").Snippet;
+}
+//#endregion
+//#region src/components/block-ui/index.d.ts
+/** A curtain over content that must wait: frosted paper and one
+ * quiet wheel. */
+declare const BlockUI: import("svelte").Component<BlockUIProps, {}, "">;
+//#endregion
+export { BlockUIProps as n, BlockUI as t };

package/dist/index-BoR_54C_.d.mts

@@ -0,0 +1,31 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/timeline/props.d.ts
+interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
+  /** The thread's direction: a vertical line of moments, or one
+   * running left to right. */
+  orientation?: "vertical" | "horizontal";
+  children?: Snippet;
+}
+interface TimelineItemProps extends HTMLAttributes<HTMLLIElement> {
+  children?: Snippet;
+}
+interface TimelineMarkerProps extends HTMLAttributes<HTMLSpanElement> {
+  children?: Snippet;
+}
+interface TimelineContentProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/timeline/index.d.ts
+/** A line of moments: Root is the ordered thread, Item one moment on it,
+ * Marker the point where the thread passes, Content what the moment
+ * holds. The hairline between markers is drawn by the stylesheet. */
+declare const Timeline: import("svelte").Component<TimelineProps, {}, ""> & {
+  Root: import("svelte").Component<TimelineProps, {}, "">;
+  Item: import("svelte").Component<TimelineItemProps, {}, "">;
+  Marker: import("svelte").Component<TimelineMarkerProps, {}, "">;
+  Content: import("svelte").Component<TimelineContentProps, {}, "">;
+};
+//#endregion
+export { TimelineProps as a, TimelineMarkerProps as i, TimelineContentProps as n, TimelineItemProps as r, Timeline as t };

package/dist/index-BolxaoaW.d.mts

@@ -0,0 +1,18 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/deferred-content/props.d.ts
+interface DeferredContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "placeholder"> {
+  /** How much of the placeholder must be visible before the content
+   * mounts, from 0 (any pixel) to 1 (the whole box). */
+  threshold?: number;
+  /** Drawn until the box approaches the viewport. */
+  placeholder?: Snippet;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/deferred-content/index.d.ts
+/** Content that waits to be worth rendering: the slot mounts when the
+ * placeholder approaches the viewport. */
+declare const DeferredContent: import("svelte").Component<DeferredContentProps, {}, "">;
+//#endregion
+export { DeferredContentProps as n, DeferredContent as t };

package/dist/index-BwFSueFx.d.mts

@@ -0,0 +1,20 @@
+import { Snippet } from "svelte";
+//#region src/components/popconfirm/props.d.ts
+interface PopconfirmProps {
+  /** The question the reader is answering. */
+  message: string;
+  confirmText?: string;
+  cancelText?: string;
+  onConfirm?: () => void;
+  onCancel?: () => void;
+  /** The trigger — give it a single element (wrap a group in a span
+   * otherwise). */
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/popconfirm/index.d.ts
+/** A question at the point of no return: the trigger opens a small
+ * anchored vessel carrying the message and two answers. */
+declare const Popconfirm: import("svelte").Component<PopconfirmProps, {}, "">;
+//#endregion
+export { PopconfirmProps as n, Popconfirm as t };

package/dist/index-C0aalhwd.d.mts

@@ -0,0 +1,43 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/list/props.d.ts
+interface ListProps extends HTMLAttributes<HTMLUListElement> {
+  /** One hairline between rows. */
+  bordered?: boolean;
+  /** Every row answers the pointer with a wash. */
+  hoverable?: boolean;
+  children?: Snippet;
+}
+interface ListItemProps extends HTMLAttributes<HTMLLIElement> {
+  children?: Snippet;
+}
+interface ListLeadingProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface ListActionsProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface ListContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+  /** The row's words. */
+  title?: Snippet;
+  /** The quiet echo beneath the title. */
+  description?: Snippet;
+  /** Anything else the row holds, after title and description. */
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/list/index.d.ts
+/** A ledger of rows: Root is the list, Item one row, Leading the mark
+ * before the words, Content the title and its quiet echo, Actions the
+ * way out. The bordered variant draws the hairlines; the hoverable
+ * variant gives every row the wash — and any row the caller makes
+ * clickable (role="button") answers the pointer on its own. */
+declare const List: import("svelte").Component<ListProps, {}, ""> & {
+  Root: import("svelte").Component<ListProps, {}, "">;
+  Item: import("svelte").Component<ListItemProps, {}, "">;
+  Leading: import("svelte").Component<ListLeadingProps, {}, "">;
+  Content: import("svelte").Component<ListContentProps, {}, "">;
+  Actions: import("svelte").Component<ListActionsProps, {}, "">;
+};
+//#endregion
+export { ListLeadingProps as a, ListItemProps as i, ListActionsProps as n, ListProps as o, ListContentProps as r, List as t };

package/dist/index-C84DUNp9.d.mts

@@ -0,0 +1,33 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/split-button/props.d.ts
+interface SplitButtonEntry {
+  label: string;
+  /** Handed back with `onSelect` when the entry is chosen. */
+  value: string;
+  danger?: boolean;
+  disabled?: boolean;
+}
+interface SplitButtonProps extends HTMLAttributes<HTMLDivElement> {
+  /** The main action's label. */
+  label: string;
+  /** The dropdown's entries. */
+  items?: SplitButtonEntry[];
+  /** How both halves rest; the arrow always reads as one control with
+   * the main button. */
+  variant?: "solid" | "outline" | "ghost" | "subtle";
+  tone?: "ink" | "info" | "success" | "warning" | "danger";
+  size?: "sm" | "md" | "lg";
+  disabled?: boolean;
+  /** The main button was pressed. */
+  onclick?: () => void;
+  /** An entry was chosen; carries its `value`. */
+  onSelect?: (value: string) => void;
+}
+//#endregion
+//#region src/components/split-button/index.d.ts
+/** A primary action with its alternatives one seam away: the main
+ * button fires, the fitted arrow opens a paper vessel whose entries
+ * hand back their value. */
+declare const SplitButton: import("svelte").Component<SplitButtonProps, {}, "">;
+//#endregion
+export { SplitButtonEntry as n, SplitButtonProps as r, SplitButton as t };

package/dist/index-C8WNp4wI.d.mts

@@ -0,0 +1,30 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/menubar/props.d.ts
+interface MenubarEntry {
+  label: string;
+  value: string;
+  danger?: boolean;
+  disabled?: boolean;
+}
+interface MenubarGroup {
+  label: string;
+  items: MenubarEntry[];
+}
+interface MenubarProps extends HTMLAttributes<HTMLDivElement> {
+  /** The menus across the bar, each with its entries. */
+  items?: MenubarGroup[];
+  /** Called with the entry's `value` when it is chosen. */
+  onSelect?: (value: string) => void;
+}
+//#endregion
+//#region src/components/menubar/index.d.ts
+/** A desktop-style menu bar: a row of quiet ghost triggers, each
+ * opening the same paper vessel as the menu family. The triggers are
+ * our own buttons grafted onto the menu machine's trigger via
+ * `asChild` — the machine keeps the trigger element (positioning,
+ * focus restore, `data-state`) while the element wears the menubar
+ * scope. The popups keep the menu parts untouched, so the menu
+ * stylesheet dresses them. */
+declare const Menubar: import("svelte").Component<MenubarProps, {}, "">;
+//#endregion
+export { MenubarProps as i, MenubarEntry as n, MenubarGroup as r, Menubar as t };

package/dist/index-CAb_-2Bn.d.mts

@@ -0,0 +1,21 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/order-list/props.d.ts
+interface OrderOption {
+  label: string;
+  value: string;
+}
+interface OrderListProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — the rows in their current order; the value is
+   * the order. */
+  value?: string[];
+  /** Every row the ledger knows, in no particular order. */
+  options: OrderOption[];
+  label?: string;
+}
+//#endregion
+//#region src/components/order-list/index.d.ts
+/** A ledger the reader may rewrite: rows move by grip or by the side
+ * arrows; the value is the order. */
+declare const OrderList: import("svelte").Component<OrderListProps, {}, "value">;
+//#endregion
+export { OrderListProps as n, OrderOption as r, OrderList as t };

package/dist/index-CJsLok79.d.mts

@@ -0,0 +1,29 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/empty/props.d.ts
+interface EmptyProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface EmptyTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+  children?: Snippet;
+}
+interface EmptyDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {
+  children?: Snippet;
+}
+interface EmptyPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/empty/index.d.ts
+/** An empty state: the page holds its breath. Root centers the column,
+ * Visual carries the mark, Title and Description carry the ink, Actions
+ * the way out. Any subset composes. */
+declare const Empty: import("svelte").Component<EmptyProps, {}, ""> & {
+  Root: import("svelte").Component<EmptyProps, {}, "">;
+  Visual: import("svelte").Component<EmptyPartProps, {}, "">;
+  Title: import("svelte").Component<EmptyTitleProps, {}, "">;
+  Description: import("svelte").Component<EmptyDescriptionProps, {}, "">;
+  Actions: import("svelte").Component<EmptyPartProps, {}, "">;
+};
+//#endregion
+export { EmptyTitleProps as a, EmptyProps as i, EmptyDescriptionProps as n, EmptyPartProps as r, Empty as t };

package/dist/index-CKFfSEBR.d.mts

@@ -0,0 +1,16 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/masonry/props.d.ts
+interface MasonryProps extends HTMLAttributes<HTMLDivElement> {
+  columns?: number;
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/masonry/index.d.ts
+/** A wall of uneven heights: items flow down each column before
+ * crossing to the next, so the order is column-first. A row-flow wall
+ * would need grid masonry, which browsers do not ship yet. */
+declare const Masonry: import("svelte").Component<MasonryProps, {}, "">;
+//#endregion
+export { MasonryProps as n, Masonry as t };

package/dist/index-CLoTtvcO.d.mts

@@ -0,0 +1,19 @@
+import { Snippet } from "svelte";
+import { DatePickerRootProps } from "@ark-ui/svelte/date-picker";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/calendar/props.d.ts
+interface CalendarProps extends HTMLAttributes<HTMLDivElement> {
+  /** Selected date(s) — an array, as the machine speaks in ranges. */
+  value?: DatePickerRootProps["value"];
+  min?: DatePickerRootProps["min"];
+  max?: DatePickerRootProps["max"];
+  onValueChange?: (value: NonNullable<DatePickerRootProps["value"]>) => void;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/calendar/index.d.ts
+/** The date-picker's month grid, standing on the page without its
+ * popup: always open, the trigger gone, the vessel a quiet card. */
+declare const Calendar: import("svelte").Component<CalendarProps, {}, "">;
+//#endregion
+export { CalendarProps as n, Calendar as t };

package/dist/index-CM6inLqu.d.mts

@@ -0,0 +1,28 @@
+import { Snippet } from "svelte";
+import { HTMLButtonAttributes } from "svelte/elements";
+//#region src/components/back-top/props.d.ts
+interface BackTopProps extends HTMLButtonAttributes {
+  /** How far the reader must have travelled (px) before the affordance
+   * appears. */
+  threshold?: number;
+  /** The accessible name; the control is icon-only by default. */
+  label?: string;
+  /** Ride a scrolling element of your own instead of the page: the
+   * control moors inside that element's corner and watches its
+   * scrollTop. The host supplies the positioning context. */
+  scrollEl?: () => HTMLElement | null;
+  /** The control's own content — the up-stroke glyph by default. */
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/back-top/index.d.ts
+/** A way home: after the page has scrolled past `threshold`, a small
+ * floating control rises at the page's corner and returns the reader to
+ * the top. The scroll itself stays native — `window.scrollTo` defers to
+ * the stylesheet's `scroll-behavior: smooth`, which reduced motion turns
+ * back into an instant jump. The control itself is the shared `Button`
+ * (outline, square) — the paper, hairline and halo are its; this family
+ * owns only the floating and the entrance. */
+declare const BackTop: import("svelte").Component<BackTopProps, {}, "">;
+//#endregion
+export { BackTopProps as n, BackTop as t };

package/dist/index-CRdyjHjx.d.mts

@@ -0,0 +1,23 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/stat/props.d.ts
+interface StatPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+interface StatDeltaProps extends HTMLAttributes<HTMLElement> {
+  direction?: "up" | "down" | "flat";
+}
+//#endregion
+//#region src/components/stat/index.d.ts
+/** One figure on the page: the label whispers what it is, the value
+ * states it plainly in tabular figures, the delta reads the direction
+ * in the fixed semantic pigments. */
+declare const Stat: import("svelte").Component<StatPartProps, {}, ""> & {
+  Root: import("svelte").Component<StatPartProps, {}, "">;
+  Label: import("svelte").Component<StatPartProps, {}, "">;
+  Value: import("svelte").Component<StatPartProps, {}, "">;
+  Delta: import("svelte").Component<StatDeltaProps, {}, "">;
+  Description: import("svelte").Component<StatPartProps, {}, "">;
+};
+//#endregion
+export { StatDeltaProps as n, StatPartProps as r, Stat as t };

package/dist/index-CV1LSzq5.d.mts

@@ -0,0 +1,25 @@
+import { Avatar } from "@ark-ui/svelte/avatar";
+//#region src/components/avatar/props.d.ts
+type AvatarSize = "sm" | "md" | "lg";
+interface AvatarProps {
+  /** Seal diameter: the small, medium, or large control rung. The
+   * default (large) stands as tall as the biggest control so an avatar
+   * rides a row without stretching it. */
+  size?: AvatarSize;
+  /** The corner: round by default; square cuts it sharp, a stamp
+   * beside a round portrait. */
+  shape?: "circle" | "square";
+  children?: import("svelte").Snippet;
+}
+//#endregion
+//#region src/components/avatar/index.d.ts
+/** Avatar, dressed in the paper-and-ink system: a circular seal on
+ * inset paper that holds initials until the image loads over them.
+ * `size` picks a control-height rung for the seal — the core styles
+ * re-point `--bs-avatar-size` per rung, and scenes can still retune the
+ * variable directly. */
+declare const Avatar$1: typeof Avatar & {
+  Root: import("svelte").Component<AvatarProps, {}, "">;
+};
+//#endregion
+export { Avatar$1 as t };

package/dist/index-CWNmeq0b.d.mts

@@ -0,0 +1,21 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/page-header/props.d.ts
+interface PageHeaderPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/page-header/index.d.ts
+/** The page's face: an eyebrow whisper, a serif title, one line of
+ * description, and the actions resting beside the title on the same
+ * baseline. Heading groups title and actions; the rest compose below. */
+declare const PageHeader: import("svelte").Component<PageHeaderPartProps, {}, ""> & {
+  Root: import("svelte").Component<PageHeaderPartProps, {}, "">;
+  Heading: import("svelte").Component<PageHeaderPartProps, {}, "">;
+  Eyebrow: import("svelte").Component<PageHeaderPartProps, {}, "">;
+  Title: import("svelte").Component<PageHeaderPartProps, {}, "">;
+  Description: import("svelte").Component<PageHeaderPartProps, {}, "">;
+  Actions: import("svelte").Component<PageHeaderPartProps, {}, "">;
+};
+//#endregion
+export { PageHeaderPartProps as n, PageHeader as t };

package/dist/index-CY4EuxyF.d.mts

@@ -0,0 +1,21 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/autocomplete/props.d.ts
+interface AutoCompleteProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the field; a pick and a custom value land here alike. */
+  value?: string;
+  /** Seeds the suggestion list once. */
+  items?: string[];
+  placeholder?: string;
+  /** Field text to match against; defaults to a case-insensitive
+   * substring. */
+  filter?: (item: string, input: string) => boolean;
+}
+//#endregion
+//#region src/components/autocomplete/index.d.ts
+/** Free text with suggestions: the reader types anything, the list
+ * narrows to help, and both a pick and a custom value end up in the
+ * same `value`. A preset of the combobox machinery. */
+declare const AutoComplete: import("svelte").Component<AutoCompleteProps, {}, "value">;
+//#endregion
+export { AutoCompleteProps as n, AutoComplete as t };

package/dist/index-CaVBzPln.d.mts

@@ -0,0 +1,12 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/kbd/props.d.ts
+interface KbdProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/kbd/index.d.ts
+/** A keycap in miniature, riding the type it annotates. */
+declare const Kbd: import("svelte").Component<KbdProps, {}, "">;
+//#endregion
+export { KbdProps as n, Kbd as t };

package/dist/index-Cd4UxWsz.d.mts

@@ -0,0 +1,24 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/transfer/props.d.ts
+interface TransferItem {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+interface TransferProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the bound list mirroring the
+   * target column. */
+  value?: string[];
+  data: TransferItem[];
+  titles?: string[];
+  searchable?: boolean;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/transfer/index.d.ts
+/** Two ledgers and a crossing: items sit in the source column until
+ * the reader checks them and walks them across — and back, the same
+ * way. */
+declare const Transfer: import("svelte").Component<TransferProps, {}, "value">;
+//#endregion
+export { TransferItem as n, TransferProps as r, Transfer as t };

package/dist/index-CeIQyZkc.d.mts

@@ -0,0 +1,21 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/typography/props.d.ts
+interface TypographyPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/typography/index.d.ts
+/** The typographic voices, named so prose can ask for one: display and
+ * heading ride the song-serif, the rest ride the hei. Nothing here is
+ * decorative — hierarchy is size, weight, and space. */
+declare const Typography: import("svelte").Component<TypographyPartProps, {}, ""> & {
+  Display: import("svelte").Component<TypographyPartProps, {}, "">;
+  Heading: import("svelte").Component<TypographyPartProps, {}, "">;
+  Lead: import("svelte").Component<TypographyPartProps, {}, "">;
+  Body: import("svelte").Component<TypographyPartProps, {}, "">;
+  Muted: import("svelte").Component<TypographyPartProps, {}, "">;
+  Label: import("svelte").Component<TypographyPartProps, {}, "">;
+};
+//#endregion
+export { TypographyPartProps as n, Typography as t };

package/dist/index-CiHanb4T.d.mts

@@ -0,0 +1,22 @@
+//#region src/components/image-viewer/props.d.ts
+interface ImageViewerProps {
+  src: string;
+  alt?: string;
+  /** Whether the lightbox is up. Bind it (`bind:open`) to control the
+   * viewer; left alone it keeps the state to itself. */
+  open?: boolean;
+  zoomable?: boolean;
+  /** The viewer's open state turned. */
+  onOpenChange?: (open: boolean) => void;
+}
+//#endregion
+//#region src/components/image-viewer/index.d.ts
+/** A lightbox: the picture over a dimmed page, with a small toolbar
+ * beneath it. Zoom is the reader's hand (half to three times,
+ * clamped), a quarter turn at a time rotates, Escape and the scrim
+ * close — the dialog machine carries the modal part. `open` may stay
+ * with the caller (`bind:open`); left alone the viewer keeps it to
+ * itself. */
+declare const ImageViewer: import("svelte").Component<ImageViewerProps, {}, "open">;
+//#endregion
+export { ImageViewerProps as n, ImageViewer as t };

package/dist/index-CjNUtqX_.d.mts

@@ -0,0 +1,19 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/watermark/props.d.ts
+interface WatermarkProps extends HTMLAttributes<HTMLDivElement> {
+  content: string;
+  opacity?: number;
+  rotate?: number;
+  fontSize?: string;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/watermark/index.d.ts
+/** The paper bears its seal beneath the content: a canvas draws the
+ * text once into a tile (rotated, faint, crisp at the screen's pixel
+ * density) and the marks layer repeats it over the children. The seal
+ * redraws itself when a prop turns — and it never takes a pointer. */
+declare const Watermark: import("svelte").Component<WatermarkProps, {}, "">;
+//#endregion
+export { WatermarkProps as n, Watermark as t };

package/dist/index-CkFXH_oG.d.mts

@@ -0,0 +1,31 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/cascade-select/props.d.ts
+interface CascadeSelectNode {
+  label: string;
+  value: string;
+  children?: CascadeSelectNode[];
+  disabled?: boolean;
+}
+interface CascadeSelectProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the selected path (or paths,
+   * when `multiple`) in the bound variable. */
+  value?: string[][];
+  data: CascadeSelectNode[];
+  placeholder?: string;
+  /** `"hover"` turns the classic cascading menu: pointing is enough to
+   * unfold. */
+  highlightTrigger?: "click" | "hover";
+  /** Flattens the corridor into matching routes while a query runs —
+   * each hit still reads as its full path. */
+  filterable?: boolean;
+  multiple?: boolean;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/cascade-select/index.d.ts
+/** A corridor of linked columns: pick a branch and the next column
+ * dissolves open beside it, until a leaf click settles the whole
+ * path. */
+declare const CascadeSelect: import("svelte").Component<CascadeSelectProps, {}, "value">;
+//#endregion
+export { CascadeSelectNode as n, CascadeSelectProps as r, CascadeSelect as t };

package/dist/index-Cl8v2k0X.d.mts

@@ -0,0 +1,36 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/breadcrumb/props.d.ts
+interface BreadcrumbProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+interface BreadcrumbListProps extends HTMLAttributes<HTMLOListElement> {
+  children?: Snippet;
+}
+interface BreadcrumbItemProps extends HTMLAttributes<HTMLLIElement> {
+  children?: Snippet;
+}
+interface BreadcrumbLinkProps extends HTMLAttributes<HTMLAnchorElement> {
+  children?: Snippet;
+}
+interface BreadcrumbCurrentProps extends HTMLAttributes<HTMLSpanElement> {
+  children?: Snippet;
+}
+interface BreadcrumbSeparatorProps extends HTMLAttributes<HTMLSpanElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/breadcrumb/index.d.ts
+/** A trail of waymarks: Root wraps the nav, List the ordered trail, and
+ * each Item carries a Link — or the Current page — parted by a quiet
+ * Separator. Links take href and the rest through attributes. */
+declare const Breadcrumb: import("svelte").Component<BreadcrumbProps, {}, ""> & {
+  Root: import("svelte").Component<BreadcrumbProps, {}, "">;
+  List: import("svelte").Component<BreadcrumbListProps, {}, "">;
+  Item: import("svelte").Component<BreadcrumbItemProps, {}, "">;
+  Link: import("svelte").Component<BreadcrumbLinkProps, {}, "">;
+  Current: import("svelte").Component<BreadcrumbCurrentProps, {}, "">;
+  Separator: import("svelte").Component<BreadcrumbSeparatorProps, {}, "">;
+};
+//#endregion
+export { BreadcrumbListProps as a, BreadcrumbLinkProps as i, BreadcrumbCurrentProps as n, BreadcrumbProps as o, BreadcrumbItemProps as r, BreadcrumbSeparatorProps as s, Breadcrumb as t };