@enigmax/primitives 0.17.0 → 0.19.0

package/dist/react/palette.d.ts

@@ -0,0 +1,231 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+import { b as SearchMatch, c as SearchOptions } from '../search-DXxY8SEH.js';
+import { R as RecentEntry } from '../palette-D7iuQh_T.js';
+
+/** One line in the palette, whatever it came from. */
+interface PaletteRow<Item> {
+    /** Stable within a render. Used for React keys and for `aria-activedescendant`. */
+    id: string;
+    /** Which group it appears under. */
+    group: string;
+    /** `item` for a result, `recent` for a memory, `action` for a row the app declared. */
+    kind: "item" | "recent" | "action";
+    item?: Item;
+    recent?: RecentEntry;
+    /** Set for a result that came from the engine, so a renderer can show the score. */
+    match?: SearchMatch<Item>;
+    /** What running this row does. The palette closes afterwards unless this returns false. */
+    onSelect?: () => void | boolean;
+    label: string;
+    description?: string;
+}
+interface PaletteContextValue<Item = unknown> {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    query: string;
+    setQuery: (query: string) => void;
+    rows: PaletteRow<Item>[];
+    active: number;
+    setActive: (index: number) => void;
+    /** Run a row: its own action, or the palette's `onSelect`, then remember it. */
+    select: (row: PaletteRow<Item> | undefined) => void;
+    /** Wipe the remembered searches. */
+    clearRecents: () => void;
+    forgetRecent: (entry: RecentEntry) => void;
+    /** True while the engine is loading or an async source is in flight. */
+    busy: boolean;
+    /** ids the parts need to point at each other. */
+    ids: {
+        field: string;
+        list: string;
+        title: string;
+    };
+    /** `Ctrl K` or `⌘ K`, whichever this platform uses. */
+    shortcutLabel: string;
+    triggerRef: {
+        current: HTMLElement | null;
+    };
+    fieldRef: {
+        current: HTMLInputElement | null;
+    };
+    rowId: (row: PaletteRow<Item>) => string;
+}
+declare function usePaletteContext<Item = unknown>(part: string): PaletteContextValue<Item>;
+
+/**
+ * The command palette: the panel that opens on Ctrl/Cmd+K, searches as you type, remembers
+ * what was searched before, and is driven entirely from the keyboard.
+ *
+ * It is a DIALOG, which is why it is its own component rather than a prop on `<Input>`: a
+ * palette is a trigger, an overlay, a focus trap, a listbox and a footer, and the thing that
+ * makes those usable together is composition. Radix draws the line in the same place, and
+ * for the same reason - one `<input>` is a component, a widget made of parts is an anatomy:
+ *
+ * ```tsx
+ * <SearchPalette.Root items={docs} keys={["title"]} onSelect={open}>
+ *     <SearchPalette.Trigger />
+ *     <SearchPalette.Content>
+ *         <SearchPalette.Field placeholder="Search the docs" />
+ *         <SearchPalette.List />
+ *         <SearchPalette.Footer />
+ *     </SearchPalette.Content>
+ * </SearchPalette.Root>
+ * ```
+ *
+ * `<SearchPalette>` on its own renders exactly that, for the case that needs no arguing
+ * with. Every part takes `asChild`, so any of them can be your own element instead.
+ *
+ * The keyboard sequence is ONE flat list across every group - a group boundary is invisible
+ * to the arrow keys - and the highlight wraps, because in a short list the row after the
+ * last one is the first, and a key that does nothing at the end reads as a frozen panel.
+ */
+interface PaletteSection<Item> {
+    label: string;
+    items: Item[];
+    /** Shown whatever the query, e.g. a list of commands. Off by default. */
+    always?: boolean;
+}
+interface PaletteRootProps<Item> {
+    /** What to search. */
+    items?: Item[];
+    /** Fields to read. Dotted paths work. */
+    keys?: SearchOptions<Item>["keys"];
+    /** Fuse.js's constructor, for fuzzy matching. Without it, a substring matcher runs. */
+    fuse?: SearchOptions<Item>["fuse"];
+    fuseOptions?: SearchOptions<Item>["fuseOptions"];
+    /** Replaces the engine outright. */
+    matcher?: SearchOptions<Item>["matcher"];
+    /** ms after the last keystroke. Default 120: a palette should feel immediate. */
+    delay?: number;
+    limit?: number;
+    /** Which group a result belongs under. One group when this is left out. */
+    groupBy?: (item: Item) => string;
+    /** The row's text. Falls back to the first string field. */
+    labelOf?: (item: Item) => string;
+    descriptionOf?: (item: Item) => string | undefined;
+    /** Rows the app always offers - commands, shortcuts, "create new". */
+    sections?: PaletteSection<Item>[];
+    /** What running a row does. Closing afterwards is the default; return false to stay. */
+    onSelect?: (item: Item) => void | boolean;
+    /** Remember what was searched, in this browser. On by default. */
+    recents?: boolean;
+    recentsKey?: string;
+    recentsLimit?: number;
+    /** The key that opens it, with Ctrl or Cmd. `null` binds nothing. Default "k". */
+    shortcut?: string | null;
+    /** Controlled open state. Leave both out for an uncontrolled palette. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+    /** Wording for the empty group heading of ungrouped results. Default "Results". */
+    resultsLabel?: string;
+    recentsLabel?: string;
+    children?: ReactNode;
+}
+declare function PaletteRoot<Item>({ items, keys, fuse, fuseOptions, matcher, delay, limit, groupBy, labelOf, descriptionOf, sections, onSelect, recents, recentsKey, recentsLimit, shortcut, open: openProp, onOpenChange, defaultOpen, resultsLabel, recentsLabel, children }: PaletteRootProps<Item>): ReactNode;
+interface PaletteTriggerProps extends ComponentPropsWithoutRef<"button"> {
+    asChild?: boolean;
+}
+/** Opens the palette. Carries the shortcut in `aria-keyshortcuts`, so it is announced. */
+declare function PaletteTrigger({ asChild, children, onClick, ...props }: PaletteTriggerProps): ReactNode;
+interface PaletteContentProps extends ComponentPropsWithoutRef<"div"> {
+    /** Accessible name for the dialog. Rendered for screen readers only. */
+    title?: string;
+    /** Render into `document.body`. On by default: a palette inside a clipped or
+     *  transformed ancestor is a panel nobody can see. */
+    portal?: boolean;
+    /** Rendered behind the panel. Pass null for no overlay of ours. */
+    overlayProps?: ComponentPropsWithoutRef<"div"> | null;
+    /**
+     * How long the closing animation is given before the panel leaves the DOM, in ms.
+     *
+     * It exists because a component that unmounts on close can only ever animate IN: the
+     * element is gone before a leaving animation has a frame to run. `data-state="closed"`
+     * is set first, the stylesheet animates it, and only then does it unmount. 0 removes it
+     * immediately, which is also what a reader with reduced motion gets.
+     */
+    closeDuration?: number;
+}
+/**
+ * The panel: overlay, focus trap, Escape, scroll lock, and focus handed back to the trigger.
+ *
+ * Mounted only while open, so nothing of the palette is in the document (or in the tab
+ * order) the rest of the time.
+ */
+declare function PaletteContent({ title, portal, overlayProps, closeDuration, children, ...props }: PaletteContentProps): ReactNode;
+interface PaletteFieldProps extends Omit<ComponentPropsWithoutRef<"input">, "value" | "onChange"> {
+    asChild?: boolean;
+}
+/**
+ * The query field.
+ *
+ * A `combobox` that keeps the caret while the arrows move a highlight somewhere else -
+ * which is exactly what `aria-activedescendant` is for. Without it a screen reader hears
+ * nothing move, because focus never leaves the field.
+ */
+declare function PaletteField({ asChild, onKeyDown, ...props }: PaletteFieldProps): ReactNode;
+interface PaletteListProps<Item> extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    /** Render one row. The default prints its label, which is enough to be usable. */
+    children?: (row: PaletteRow<Item>, state: {
+        active: boolean;
+        index: number;
+    }) => ReactNode;
+    /** Rendered when there is nothing to show. */
+    empty?: ReactNode;
+    /** The group heading. Pass null for a flat list with no headings. */
+    heading?: ((label: string) => ReactNode) | null;
+}
+/** The results, grouped, with one flat keyboard sequence running through them. */
+declare function PaletteList<Item>({ children, empty, heading, ...props }: PaletteListProps<Item>): ReactNode;
+interface PaletteItemProps<Item> extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    row: PaletteRow<Item>;
+    index: number;
+    children?: ReactNode;
+}
+/**
+ * One row.
+ *
+ * The pointer MOVES the highlight rather than running a second one of its own: two
+ * highlights on screen is the thing that makes a palette feel unpredictable, because Enter
+ * then opens the row the mouse is not on.
+ */
+declare function PaletteItem<Item>({ row, index, children, ...props }: PaletteItemProps<Item>): ReactNode;
+interface PaletteFooterProps extends ComponentPropsWithoutRef<"div"> {
+    /** Replace the hints. The default names the three keys that actually matter. */
+    hints?: ReactNode;
+}
+/** The strip along the bottom that says which keys do what. */
+declare function PaletteFooter({ hints, children, ...props }: PaletteFooterProps): ReactNode;
+
+interface SearchPaletteProps<Item> extends PaletteRootProps<Item> {
+    placeholder?: string;
+    /** The trigger's own content. Pass null for a palette that only opens on the shortcut. */
+    trigger?: ReactNode | null;
+    /** Render one row, same signature as `SearchPalette.List`. */
+    renderItem?: PaletteListProps<Item>["children"];
+    empty?: ReactNode;
+    footer?: ReactNode;
+}
+/**
+ * The palette, assembled.
+ *
+ * ```tsx
+ * <SearchPalette items={docs} keys={["title", "body"]} onSelect={(doc) => go(doc.href)} />
+ * ```
+ *
+ * Everything it renders is a part you can render yourself instead - see `SearchPalette.Root`
+ * for the anatomy. This is the composition that covers the common case, not a different
+ * component: it is those parts, in the order they belong in.
+ */
+declare function SearchPalette<Item>({ placeholder, trigger, renderItem, empty, footer, children, ...root }: SearchPaletteProps<Item>): ReactNode;
+declare namespace SearchPalette {
+    var Root: typeof PaletteRoot;
+    var Trigger: typeof PaletteTrigger;
+    var Content: typeof PaletteContent;
+    var Field: typeof PaletteField;
+    var List: typeof PaletteList;
+    var Item: typeof PaletteItem;
+    var Footer: typeof PaletteFooter;
+}
+
+export { PaletteContent, type PaletteContextValue, PaletteField, PaletteFooter, PaletteItem, PaletteList, type PaletteListProps, PaletteRoot, type PaletteRootProps, type PaletteRow, type PaletteSection, PaletteTrigger, SearchPalette, type SearchPaletteProps, type PaletteRow as SearchPaletteRow, usePaletteContext };

package/dist/react/palette.js

@@ -0,0 +1,5 @@
+"use client";
+export { PaletteContent, PaletteField, PaletteFooter, PaletteItem, PaletteList, PaletteRoot, PaletteTrigger, SearchPalette, usePaletteContext } from '../chunk-FWVWX67R.js';
+import '../chunk-DTWZDONY.js';
+import '../chunk-D5A2ZMAG.js';
+import '../chunk-HS3X3XCW.js';

package/dist/react/relative-time.d.ts

@@ -0,0 +1,21 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { a as RelativeTimeOptions } from '../relative-time-YpRTG7YH.js';
+
+interface RelativeTimeProps extends RelativeTimeOptions, Omit<HTMLAttributes<HTMLElement>, "prefix" | "children"> {
+    /** ISO string, epoch milliseconds, or a Date. A string with no zone is read as UTC. */
+    date: string | number | Date | null | undefined;
+    /** Rendered when the date cannot be parsed. Nothing, by default. */
+    fallback?: ReactNode;
+    /** Title Case The Whole Phrase. Rarely what you want; `capitalizeFirst` usually is. */
+    capitalize?: boolean;
+    /** Uppercase the first letter, so a standalone "yesterday" reads as "Yesterday". */
+    capitalizeFirst?: boolean;
+    /**
+     * Pin the instant the age is measured from. Pass the request's timestamp to make a
+     * server render and its hydration agree exactly.
+     */
+    now?: Date;
+}
+declare function RelativeTime({ date, fallback, capitalize, capitalizeFirst, now, format, tense, precision, threshold, prefix, formatStyle, locale, timeZone, second, minute, hour, weekday, day, month, year, timeZoneName, noTitle, numericBeyondThreshold, ...rest }: RelativeTimeProps): ReactNode;
+
+export { RelativeTime, type RelativeTimeProps };

package/dist/react/relative-time.js

@@ -0,0 +1,3 @@
+"use client";
+export { RelativeTime } from '../chunk-OCMI7R6H.js';
+import '../chunk-IXVMRVD4.js';

package/dist/react/search.d.ts

@@ -0,0 +1,30 @@
+import { RefObject } from 'react';
+import { b as SearchMatch, c as SearchOptions } from '../search-DXxY8SEH.js';
+
+interface UseSearchResult<T> {
+    /** Attach to the search field, or drive it yourself with `search`. */
+    inputRef: RefObject<HTMLInputElement | null>;
+    query: string;
+    results: SearchMatch<T>[];
+    /** Debounced. */
+    search: (query: string) => void;
+    /** Skips the debounce. */
+    searchNow: (query: string) => void;
+    clear: () => void;
+}
+/**
+ * Search-as-you-type over a list.
+ *
+ * Pass `fuse` (Fuse.js's constructor) for fuzzy matching, `matcher` to replace the
+ * engine, or neither for the built-in accent-insensitive substring search.
+ *
+ * ```tsx
+ * import Fuse from "fuse.js";
+ *
+ * const { inputRef, results } = useSearch({ items: docs, keys: ["title", "body"], fuse: Fuse });
+ * return <input ref={inputRef} type="search" placeholder="Search" />;
+ * ```
+ */
+declare function useSearch<T>(options?: SearchOptions<T>): UseSearchResult<T>;
+
+export { type UseSearchResult, useSearch };

package/dist/react/search.js

@@ -0,0 +1,3 @@
+"use client";
+export { useSearch } from '../chunk-QQFNAKMY.js';
+import '../chunk-D5A2ZMAG.js';

package/dist/react/slot.d.ts

@@ -0,0 +1,47 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * `asChild`: render the behaviour onto YOUR element instead of ours.
+ *
+ * This is the escape hatch that decides whether a headless package is usable at scale. A
+ * component that always renders its own `<button>` forces every consumer who needs a link,
+ * a `motion.button`, a router's `Link` or their own design-system button to reimplement the
+ * behaviour - and that is the moment a team stops using the package. With `asChild` the
+ * component contributes props, refs and handlers, and the consumer owns the element:
+ *
+ * ```tsx
+ * <Button asChild shortcut="s">
+ *     <motion.a href="/save" whileTap={{ scale: 0.98 }}>Save</motion.a>
+ * </Button>
+ * ```
+ *
+ * Radix's Slot, deliberately: the semantics are the ones a React developer already knows.
+ * Its rules, and why each is the way round it is:
+ *
+ * - The CHILD's props win, because the child is what the author wrote by hand at this call
+ *   site, while ours are the defaults a component supplied.
+ * - EVENT HANDLERS are chained rather than replaced, ours first: dropping ours would take
+ *   the behaviour with it silently, which is the failure `onClick` on the Button already
+ *   cost once. The child's handler still runs even if ours called `preventDefault`, so a
+ *   handler that wants to bail checks `event.defaultPrevented` itself.
+ * - `className` and `style` are MERGED, child last, because both are additive by nature and
+ *   an overwritten className is the single most confusing thing a wrapper can do.
+ * - Refs are composed, so both sides keep the node.
+ */
+type Props = Record<string, unknown>;
+/** Merge the slot's props into the child's, by the rules above. */
+declare function mergeSlotProps(slotProps: Props, childProps: Props): Props;
+interface SlotProps extends Props {
+    children?: ReactNode;
+}
+/**
+ * Clones its single child with the props it was given.
+ *
+ * A child that is not a single element is a mistake worth failing on rather than
+ * papering over: `asChild` with two children has no answer to "which one gets the
+ * behaviour", and rendering nothing would be a blank space nobody can debug.
+ */
+declare const Slot: react.ForwardRefExoticComponent<Omit<SlotProps, "ref"> & react.RefAttributes<HTMLElement>>;
+
+export { Slot, type SlotProps, mergeSlotProps };

package/dist/react/slot.js

@@ -0,0 +1,2 @@
+"use client";
+export { Slot, mergeSlotProps } from '../chunk-HS3X3XCW.js';

package/dist/react/toast.d.ts

@@ -0,0 +1,40 @@
+import { d as Notifications, N as Notification } from '../notifications-BpVV6sel.js';
+import { ReactNode, CSSProperties } from 'react';
+
+/**
+ * `<Toaster />` - the stack, the movement and the gestures. No colours.
+ *
+ * The queue underneath already owns ordering, dedupe by key, sticky errors and timers that
+ * HOLD while the tab is hidden. What this adds is everything you cannot express in a queue:
+ * a toast that is on its way out is still on screen, a pointer resting on the stack must
+ * stop the clock, and a swipe has to follow the finger before it decides anything.
+ *
+ * Every part carries a data attribute, so the theme is a stylesheet you own. `enigma add
+ * toast --copy` writes one.
+ */
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToasterProps {
+    /** Which queue to render. The shared one by default. */
+    queue?: Notifications;
+    position?: ToastPosition;
+    /**
+     * How long the exit animation lasts, in ms. The node stays mounted for exactly this
+     * long after it leaves the queue - a toast that vanishes the instant it is dismissed
+     * cannot animate out, and that is the only reason this component keeps its own list.
+     */
+    exitDuration?: number;
+    /** Px a toast must travel before the release dismisses it. */
+    swipeThreshold?: number;
+    /** Render a toast yourself. The default renders title, body and the action. */
+    children?: (notification: Notification, controls: ToastControls) => ReactNode;
+    /** Accessible name for the region. */
+    label?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+interface ToastControls {
+    dismiss: () => void;
+}
+declare function Toaster({ queue, position, exitDuration, swipeThreshold, children, label, className, style }: ToasterProps): ReactNode;
+
+export { type ToastControls, type ToastPosition, Toaster, type ToasterProps };

package/dist/react/toast.js

@@ -0,0 +1,4 @@
+"use client";
+export { Toaster } from '../chunk-ZCUFYBPB.js';
+import '../chunk-QYMUIW5I.js';
+import '../chunk-SNYUBXWQ.js';

package/dist/react-router/index.d.ts

@@ -1,8 +1,26 @@
 import * as react from 'react';
-import { ButtonProps } from '../react/index.js';
-export { BreachChecker, BreachState, BreachStatus, FieldAction, Flag, FlagProps, Input, InputProps, PasswordStrength, PasswordStrengthProps, RelativeTime, RelativeTimeProps, ToastControls, ToastPosition, Toaster, ToasterProps, UseButtonResult, UseInputResult, UseMarqueeResult, UseNotificationsResult, UseSearchResult, createNotificationQueue, defaultQueue, getLinkComponent, setLinkComponent, useButton, useInput, useMarquee, useNetworkState, useNotifications, useSearch } from '../react/index.js';
-export { ButtonOptions, ButtonState, EstimateOptions, FlagFormat, FlagOptions, FlagShape, FlagSource, GeneratePasswordOptions, InputAction, InputIcon, InputOptions, MarqueeHover, MarqueeInstance, MarqueeOptions, NetworkState, PasswordScore, PasswordStrengthReport, configureFlags, estimatePasswordStrength, flagAttributes, flagSrc, flagView, generatePassword, normalizeFlagCode } from '../index.js';
-export { F as FuseConstructor, b as SearchMatch, c as SearchOptions } from '../search-CsO3L1Lw.js';
+import { ButtonProps } from '../react/button.js';
+export { UseMarqueeResult, useMarquee } from '../react/marquee.js';
+export { M as MarqueeHover, a as MarqueeInstance, b as MarqueeOptions } from '../marquee-CJ3Uwy3E.js';
+export { PasswordStrength, PasswordStrengthProps, UseButtonResult, UseInputResult, getLinkComponent, setLinkComponent, useButton, useInput } from '../react/index.js';
+export { UseSearchResult, useSearch } from '../react/search.js';
+export { I as InputAction, b as InputIcon, d as InputOptions } from '../input-BwXjFenq.js';
+export { F as FuseConstructor, a as FuseLike, S as SearchInstance, b as SearchMatch, c as SearchOptions } from '../search-DXxY8SEH.js';
+export { c as ButtonOptions, d as ButtonState } from '../button-CaXaqG_K.js';
+export { B as BreachChecker, a as BreachState, b as BreachStatus, F as FieldAction, I as Input, c as InputBaseProps, d as InputProps, e as InputType, P as PasswordOnlyProps, g as PlainOnlyProps, S as SearchOnlyProps } from '../index-dTdAbOWl.js';
+export { Slot, SlotProps, mergeSlotProps } from '../react/slot.js';
+export { E as EstimateOptions, G as GeneratePasswordOptions, a as PasswordScore, b as PasswordStrengthReport, e as estimatePasswordStrength, g as generatePassword } from '../password-C8lG4Zm9.js';
+export { UseNotificationsResult, createNotificationQueue, defaultQueue, useNotifications } from '../react/notifications.js';
+export { ToastControls, ToastPosition, Toaster, ToasterProps } from '../react/toast.js';
+export { useNetworkState } from '../react/network.js';
+export { a as NetworkState } from '../network-D2LsBG_k.js';
+export { RelativeTime, RelativeTimeProps } from '../react/relative-time.js';
+export { R as RelativeTimeFormat, a as RelativeTimeOptions, b as RelativeTimePrecision, c as RelativeTimeStyle, d as RelativeTimeTense } from '../relative-time-YpRTG7YH.js';
+export { N as Notification, a as NotificationAction, b as NotificationInput, c as NotificationTone, e as NotificationsOptions } from '../notifications-BpVV6sel.js';
+export { Flag, FlagProps } from '../react/flag.js';
+export { c as FlagFormat, d as FlagOptions, e as FlagShape, f as FlagSource, h as configureFlags, i as flagAttributes, k as flagName, l as flagSrc, m as flagView, n as normalizeFlagCode } from '../flags-BBJc9unY.js';
+export { PaletteContent, PaletteContextValue, PaletteField, PaletteFooter, PaletteItem, PaletteList, PaletteListProps, PaletteRoot, PaletteRootProps, PaletteRow, PaletteSection, PaletteTrigger, SearchPalette, SearchPaletteProps, usePaletteContext } from '../react/palette.js';
+export { R as RecentEntry, b as RecentStore, e as createRecentStore, g as groupRows, i as isPaletteShortcut, m as moveActive, r as recentKey, s as shortcutLabel } from '../palette-D7iuQh_T.js';
 
 declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLElement>>;
 

package/dist/react-router/index.js

@@ -1,8 +1,29 @@
 "use client";
-import { Button } from '../chunk-JFNND6P4.js';
-export { Flag, Input, PasswordStrength, RelativeTime, Toaster, createNotificationQueue, defaultQueue, getLinkComponent, setLinkComponent, useButton, useInput, useMarquee, useNetworkState, useNotifications, useSearch } from '../chunk-JFNND6P4.js';
-export { configureFlags, estimatePasswordStrength, flagAttributes, flagSrc, flagView, generatePassword, normalizeFlagCode } from '../chunk-4GLYRF4B.js';
-import '../chunk-UZFEEFMF.js';
+export { useInput } from '../chunk-U3V4EHOB.js';
+export { PasswordStrength } from '../chunk-XQHCZAPJ.js';
+export { Flag } from '../chunk-XNNQRA35.js';
+export { Toaster } from '../chunk-ZCUFYBPB.js';
+export { useMarquee } from '../chunk-ZWR2EXHQ.js';
+export { useSearch } from '../chunk-QQFNAKMY.js';
+export { useNetworkState } from '../chunk-S653GLSF.js';
+export { createNotificationQueue, defaultQueue, useNotifications } from '../chunk-QYMUIW5I.js';
+export { RelativeTime } from '../chunk-OCMI7R6H.js';
+import '../chunk-KJINGUQN.js';
+export { estimatePasswordStrength, generatePassword } from '../chunk-HC2ME5PU.js';
+export { configureFlags, flagAttributes, flagName, flagSrc, flagView, normalizeFlagCode } from '../chunk-AU3H5WIY.js';
+import '../chunk-UOSSNUSC.js';
+import '../chunk-2QFTRNAZ.js';
+import '../chunk-SNYUBXWQ.js';
+import '../chunk-IXVMRVD4.js';
+export { Input } from '../chunk-R4ZAEE7V.js';
+import '../chunk-F25CGNQC.js';
+export { PaletteContent, PaletteField, PaletteFooter, PaletteItem, PaletteList, PaletteRoot, PaletteTrigger, SearchPalette, usePaletteContext } from '../chunk-FWVWX67R.js';
+export { createRecentStore, groupRows, isPaletteShortcut, moveActive, recentKey, shortcutLabel } from '../chunk-DTWZDONY.js';
+import '../chunk-D5A2ZMAG.js';
+import { Button } from '../chunk-6BGBYUSZ.js';
+export { getLinkComponent, setLinkComponent, useButton } from '../chunk-6BGBYUSZ.js';
+import '../chunk-MMQPZGSU.js';
+export { Slot, mergeSlotProps } from '../chunk-HS3X3XCW.js';
 import { Link } from 'react-router';
 import { forwardRef, createElement } from 'react';
 

package/dist/relative-time-YpRTG7YH.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Relative time: "3 hours ago", and everything that has to be right around it.
+ *
+ * The rendering itself is `<relative-time>` (@github/relative-time-element), which already
+ * owns the hard parts - Intl.RelativeTimeFormat per locale, and re-rendering on a schedule
+ * that gets slower as the date gets older. What is here is the part every wrapper
+ * re-implements and usually gets wrong: parsing a timestamp that does not declare its zone,
+ * knowing when the date has aged past the relative threshold, and producing an absolute
+ * label to show while the element is still loading, or forever if scripting is off.
+ *
+ * Nothing in this file touches the DOM, so it renders on a server.
+ */
+/** How the element should phrase it. `auto` is relative until the threshold, then a date. */
+type RelativeTimeFormat = "auto" | "relative" | "duration" | "datetime" | "micro" | "elapsed";
+type RelativeTimeTense = "auto" | "past" | "future";
+type RelativeTimePrecision = "year" | "month" | "day" | "hour" | "minute" | "second";
+type RelativeTimeStyle = "long" | "short" | "narrow";
+type NumericStyle = "numeric" | "2-digit";
+interface RelativeTimeOptions {
+    format?: RelativeTimeFormat;
+    tense?: RelativeTimeTense;
+    precision?: RelativeTimePrecision;
+    /** ISO 8601 duration. Past this age `auto` stops being relative. Default `P30D`. */
+    threshold?: string;
+    /** Word before an absolute date, e.g. "on 5 May". Empty string removes it. */
+    prefix?: string;
+    formatStyle?: RelativeTimeStyle;
+    /**
+     * BCP 47 tag. Left undefined the element reads the closest `lang` in the document,
+     * which is what a translated page wants - hardcoding one is how a Spanish page ends
+     * up saying "3 hours ago".
+     */
+    locale?: string;
+    /** IANA zone for the absolute rendering. Undefined means the reader's own. */
+    timeZone?: string;
+    second?: NumericStyle;
+    minute?: NumericStyle;
+    hour?: NumericStyle;
+    weekday?: RelativeTimeStyle;
+    day?: NumericStyle;
+    month?: NumericStyle | "short" | "long" | "narrow";
+    year?: NumericStyle;
+    timeZoneName?: "long" | "short" | "shortOffset" | "longOffset" | "shortGeneric" | "longGeneric";
+    /** Drop the exact timestamp the element otherwise puts in `title`. */
+    noTitle?: boolean;
+    /**
+     * Once the date is older than `threshold`, render it as digits (05/05/2026) instead of
+     * a prefixed month name. The cutoff is the threshold itself, not a guess at it.
+     */
+    numericBeyondThreshold?: boolean;
+}
+/** Everything derived from a date, in one pass, for whichever adapter is rendering it. */
+interface RelativeTimeView {
+    /** Null when the input could not be parsed - nothing else here is meaningful then. */
+    date: Date | null;
+    /** `datetime` attribute value: always UTC, always ISO. */
+    iso: string;
+    /** Absolute text. Shown until the element upgrades, and forever without scripting. */
+    label: string;
+    /** Full timestamp for `title` / `aria-label`. */
+    exact: string;
+    /** The date is older (or further ahead) than `threshold`. */
+    beyondThreshold: boolean;
+    /** Render `label` in a plain `<time>` and skip the element entirely. */
+    absoluteOnly: boolean;
+}
+/**
+ * A timestamp with no zone is UTC.
+ *
+ * This is the single most common defect in a date column: `2026-08-13 22:41:00` comes back
+ * from the database with no offset, `new Date()` reads it as LOCAL time, and every reader
+ * east or west of the server sees a time that is hours out - silently, because the wrong
+ * time is still a valid one.
+ *
+ * A date with no clock is left exactly as it is. The spec already reads a bare `YYYY-MM-DD`
+ * as UTC, so there is nothing to add - and `YYYY-MM-DDZ` is not in the spec's grammar at
+ * all, which drops it into each engine's own legacy parser. That is a portability coin
+ * flip on a value that was already correct.
+ */
+declare function ensureZone(text: string): string;
+/** Parse anything a date column or an API hands over. Null rather than an Invalid Date. */
+declare function normalizeDate(value: string | number | Date | null | undefined): Date | null;
+/**
+ * ISO 8601 duration to milliseconds, for comparing an age against `threshold`.
+ *
+ * Years and months are approximated the way the element approximates them, because the
+ * threshold is a rough "old enough to stop counting", not an anniversary.
+ */
+declare function parseDuration(value: string): number;
+/**
+ * Everything an adapter needs to render one date.
+ *
+ * `now` is a parameter so a test can pin it, and so a server render can pass the same
+ * instant it used elsewhere on the page.
+ */
+declare function relativeTimeView(value: string | number | Date | null | undefined, options?: RelativeTimeOptions, now?: Date): RelativeTimeView;
+/**
+ * The element's attributes, kebab-cased, with anything undefined left out.
+ *
+ * Written as attributes rather than properties because that is the half of a custom
+ * element's API that works before it is defined - the markup is already correct when the
+ * definition arrives late, or never.
+ */
+declare function relativeTimeAttributes(view: RelativeTimeView, options?: RelativeTimeOptions): Record<string, string>;
+
+export { type RelativeTimeFormat as R, type RelativeTimeOptions as a, type RelativeTimePrecision as b, type RelativeTimeStyle as c, type RelativeTimeTense as d, type RelativeTimeView as e, ensureZone as f, relativeTimeView as g, normalizeDate as n, parseDuration as p, relativeTimeAttributes as r };

package/dist/search/index.d.ts

@@ -1,5 +1,5 @@
-import { c as SearchOptions, S as SearchInstance } from '../search-CsO3L1Lw.js';
-export { b as SearchMatch } from '../search-CsO3L1Lw.js';
+import { c as SearchOptions, S as SearchInstance } from '../search-DXxY8SEH.js';
+export { b as SearchMatch } from '../search-DXxY8SEH.js';
 
 /**
  * Search with Fuse.js already wired: the batteries-included entry point.

package/dist/search/index.js

@@ -1,4 +1,4 @@
-import { createSearch } from '../chunk-UZFEEFMF.js';
+import { createSearch } from '../chunk-D5A2ZMAG.js';
 import Fuse from 'fuse.js';
 
 function createSearch2(options = {}) {

package/dist/{search-CsO3L1Lw.d.ts → search-DXxY8SEH.d.ts}

@@ -63,6 +63,20 @@ interface SearchInstance<T> {
     subscribe(listener: (results: SearchMatch<T>[], query: string) => void): () => void;
     destroy(): void;
 }
+/**
+ * Subsequence ranking: every letter of the query, in order, anywhere in the text.
+ *
+ * This is what a COMMAND palette wants and a substring filter cannot do: "qgate" finds
+ * "Quality gate" and "plyg" finds "Playground", because the letters only have to appear in
+ * order. The score rewards consecutive runs and word starts and penalises gaps, so the
+ * closest thing to what was typed comes first rather than the first thing that happened to
+ * contain the letters.
+ *
+ * Pass it as `matcher`, or take it as the default from the palette. The substring matcher
+ * stays the default for a plain search FIELD, where a typo should fail rather than quietly
+ * match something four words away.
+ */
+declare function subsequenceMatcher<T>(keys?: string[]): NonNullable<SearchOptions<T>["matcher"]>;
 declare function createSearch<T>(options?: SearchOptions<T>): SearchInstance<T>;
 
-export { type FuseConstructor as F, type SearchInstance as S, type FuseLike as a, type SearchMatch as b, type SearchOptions as c, createSearch as d };
+export { type FuseConstructor as F, type SearchInstance as S, type FuseLike as a, type SearchMatch as b, type SearchOptions as c, createSearch as d, subsequenceMatcher as s };