@enigmax/primitives 0.17.0 → 0.19.0

package/dist/input-BwXjFenq.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Input affordances: the buttons that live inside a field, with no styling of their own.
+ *
+ * A password field gets its reveal toggle automatically, because a field the visitor
+ * cannot read back is the single most common cause of a failed sign-in. Everything about
+ * it is replaceable - the icon, the label, the position, the container, whether it exists
+ * at all - and the same mechanism takes any other action you want in there.
+ *
+ * The details below are the ones the hand-rolled version gets wrong; each is commented
+ * with the failure it prevents.
+ */
+/** What an action renders. A string is parsed as HTML, so an inline SVG works. */
+type InputIcon = string | Node;
+interface InputActionState {
+    /** The field the action belongs to. */
+    input: HTMLInputElement;
+    /** True while the password is readable. Always false for a non-password field. */
+    revealed: boolean;
+    /** The field cannot be acted on: disabled or read-only. */
+    locked: boolean;
+}
+interface InputAction {
+    /** Stable id. Used for `data-action` and to replace a built-in (e.g. "reveal"). */
+    name: string;
+    /** Accessible name. Becomes both `aria-label` and `title`. */
+    label: string | ((state: InputActionState) => string);
+    icon: InputIcon | ((state: InputActionState) => InputIcon);
+    /** Runs on click and on Enter/Space, because it is a real button. */
+    onSelect: (state: InputActionState) => void;
+    /** Renders `aria-pressed`. Omit for actions that are not a toggle. */
+    pressed?: (state: InputActionState) => boolean;
+    /** Hide the action without removing it, e.g. a clear button on an empty field. */
+    visible?: (state: InputActionState) => boolean;
+}
+interface InputOptions {
+    /**
+     * The password reveal. `false` removes it. An object overrides parts of it - the
+     * icons, the labels - without giving up the caret and focus handling.
+     */
+    reveal?: boolean | {
+        /** Shown while the password is hidden; selecting it reveals. */
+        showIcon?: InputIcon;
+        /** Shown while the password is readable. */
+        hideIcon?: InputIcon;
+        showLabel?: string;
+        hideLabel?: string;
+    };
+    /** Extra actions, or a replacement for a built-in when `name` matches. */
+    actions?: InputAction[];
+    /** Which side the actions mount on. Position them yourself with CSS. */
+    position?: "start" | "end";
+    /**
+     * Mount the actions here instead of in a container created next to the input.
+     * Use it when your markup already has a slot for them.
+     */
+    container?: HTMLElement;
+    /** Called whenever the password's visibility changes. */
+    onRevealChange?: (revealed: boolean) => void;
+}
+interface InputInstance {
+    readonly revealed: boolean;
+    /** Show or hide the password. Toggles when the argument is omitted. */
+    reveal(next?: boolean): void;
+    /** Re-read the field and re-render the actions. Call after changing it yourself. */
+    refresh(): void;
+    update(options: Partial<InputOptions>): void;
+    destroy(): void;
+}
+
+/**
+ * Wire a field's in-field actions.
+ *
+ * @param input The field itself. A `type="password"` field gets the reveal for free.
+ */
+declare function createInput(input: HTMLInputElement, options?: InputOptions): InputInstance;
+
+export { type InputAction as I, type InputActionState as a, type InputIcon as b, type InputInstance as c, type InputOptions as d, createInput as e };

package/dist/marquee-CJ3Uwy3E.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Draggable infinite marquee: the behaviour engine, with no styling of its own.
+ *
+ * The contract is a SPEED in pixels per second, never a duration. A lap of a
+ * looping row is as long as its content, so a duration makes the row run faster
+ * every time an item is added to it. See the package README.
+ *
+ * Every rule encoded here was measured in a browser, not reasoned about. The
+ * comments marked "non-negotiable" name the bug that the obvious implementation
+ * shipped with.
+ */
+/**
+ * What a MOUSE resting on the row does to its speed. One option covers every case, so
+ * there is no pile of booleans to reconcile:
+ *
+ * - `"off"`   ignore hover entirely (the default)
+ * - `"pause"` stop while the pointer is on it
+ * - a number  multiply the cruise speed: `0.15` crawls, `1` changes nothing, `2` doubles
+ * - `{ speed }` an ABSOLUTE speed in px/s, whatever the cruise is; direction still
+ *   follows `reverse`, so you give a magnitude and not a sign
+ *
+ * Touch never triggers any of it - see the pointerType note on the hover handler.
+ */
+type MarqueeHover = number | "off" | "pause" | {
+    speed: number;
+};
+interface MarqueeOptions {
+    /**
+     * Pixels per second. NOT a duration: a duration ties the speed to the item
+     * count and the row silently accelerates as content grows.
+     */
+    speed?: number;
+    /** Scroll towards the start instead of the end. */
+    reverse?: boolean;
+    /** Scroll on the Y axis instead of the X axis. */
+    vertical?: boolean;
+    /** Allow grabbing and throwing the row. */
+    draggable?: boolean;
+    /** What a mouse resting on the row does to its speed. See {@link MarqueeHover}. */
+    hover?: MarqueeHover;
+    /** Fraction of the remaining velocity gap left after one second. */
+    decay?: number;
+    /**
+     * Apply the styles the behaviour needs (overflow, touch-action, user-select,
+     * will-change, transform). Never theme styles. Turn off to own them yourself.
+     */
+    manageStyles?: boolean;
+    /**
+     * How the repeated copies get into the DOM.
+     * - "clone": the engine clones the first child of the track (vanilla, Astro).
+     * - "external": the consumer renders them and is told the count (React, Vue).
+     */
+    copies?: "clone" | "external";
+    /** Called when the required copy count changes. Required for "external". */
+    onCopyCountChange?: (count: number) => void;
+    /** Called on a click that was not the end of a drag. */
+    onItemClick?: (event: MouseEvent) => void;
+    /** Called whenever the measured lap period changes. */
+    onMeasure?: (period: number, copyCount: number) => void;
+}
+interface MarqueeInstance {
+    /** Current offset in px, normalized to [0, period). */
+    readonly offset: number;
+    /** Measured distance between two copies of the content, in px. */
+    readonly period: number;
+    /** Copies currently required to cover the lane plus one whole period. */
+    readonly copyCount: number;
+    /** True between pointerdown and pointerup while the row is being grabbed. */
+    readonly dragging: boolean;
+    /** True while the OS asks for reduced motion. Autoplay stops, drag does not. */
+    readonly reducedMotion: boolean;
+    update(options: Partial<MarqueeOptions>): void;
+    /** Re-read the lap from the DOM. Called for you on resize and on font load. */
+    measure(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}
+declare function createMarquee(lane: HTMLElement, track: HTMLElement, options?: MarqueeOptions): MarqueeInstance;
+
+export { type MarqueeHover as M, type MarqueeInstance as a, type MarqueeOptions as b, createMarquee as c };

package/dist/network-D2LsBG_k.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Connection state: online/offline plus whatever the Network Information API will say.
+ *
+ * The part worth not rewriting is the TRANSITION. "You are back online" needs to know the
+ * connection had dropped, and every implementation of that ends up as a stray `wasOffline`
+ * boolean next to the effect, re-derived per screen and wrong the first time the page
+ * loads offline. It is tracked here instead.
+ */
+interface NetworkState {
+    online: boolean;
+    /** Estimated downlink in Mbps. Null where the browser does not report it. */
+    downlink: number | null;
+    downlinkMax: number | null;
+    /** "slow-2g" | "2g" | "3g" | "4g", or null. */
+    effectiveType: string | null;
+    /** Estimated round-trip time in ms. */
+    rtt: number | null;
+    /** The visitor asked for reduced data use. */
+    saveData: boolean | null;
+    /** "wifi" | "cellular" | "ethernet" | ..., or null. */
+    type: string | null;
+    /**
+     * The connection dropped earlier and is back. False on a first load, so a page that
+     * opens online never announces a recovery that did not happen.
+     */
+    recovered: boolean;
+    /** On a connection worth degrading for: 2g or slower, or data saver on. */
+    slow: boolean;
+}
+interface NetworkMonitor {
+    readonly state: NetworkState;
+    subscribe(listener: (state: NetworkState) => void): () => void;
+    destroy(): void;
+}
+/** What a server render sees. Assuming offline would flash a warning on every page. */
+declare const SERVER_NETWORK_STATE: NetworkState;
+declare function createNetworkMonitor(): NetworkMonitor;
+
+export { type NetworkMonitor as N, SERVER_NETWORK_STATE as S, type NetworkState as a, createNetworkMonitor as c };

package/dist/next/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';
 
 /**
  * The Next.js entry. Same components, wired to `next/link`.

package/dist/next/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 'next/link';
 import { forwardRef, createElement } from 'react';
 

package/dist/notifications-BpVV6sel.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Notification queue: ordering, timers, dedupe and pause. No rendering, no styles.
+ *
+ * The timer is the part that is always wrong when hand-rolled. A dismiss timer
+ * that keeps counting while the tab is hidden fires the moment the visitor comes
+ * back and they never see the message, so the remaining time is held, not run.
+ */
+type NotificationTone = "info" | "success" | "warning" | "error" | "loading";
+/** One button on a notification. Anything more belongs on the page, not in a toast. */
+interface NotificationAction {
+    label: string;
+    onSelect: () => void;
+    /** Dismiss once it has been pressed. On by default. */
+    dismiss?: boolean;
+}
+interface NotificationInput {
+    /** Reuses the slot of a live notification with the same key instead of stacking. */
+    key?: string;
+    title: string;
+    body?: string;
+    tone?: NotificationTone;
+    /** ms before it dismisses itself. 0 or Infinity keeps it until dismissed. */
+    duration?: number;
+    action?: NotificationAction;
+    /** Arbitrary payload for the renderer: an href, an icon name. */
+    data?: unknown;
+}
+interface Notification extends Required<Omit<NotificationInput, "body" | "data" | "key" | "action">> {
+    id: string;
+    key?: string;
+    body?: string;
+    action?: NotificationAction;
+    data?: unknown;
+    createdAt: number;
+}
+/** What `promise()` shows at each stage. A function receives the resolved value or the error. */
+interface PromiseMessages<T> {
+    loading: string | NotificationInput;
+    success: string | ((value: T) => string | NotificationInput);
+    error: string | ((error: unknown) => string | NotificationInput);
+}
+interface NotificationsOptions {
+    /** Live notifications kept at once. The oldest dismissable one makes room. */
+    max?: number;
+    /** Default ms before self-dismissal. */
+    duration?: number;
+    /** Errors default to staying until dismissed. */
+    stickyTones?: NotificationTone[];
+}
+interface Notifications {
+    readonly items: readonly Notification[];
+    notify(input: NotificationInput): string;
+    /** Change a live notification in place, keeping its slot and restarting its timer. */
+    update(id: string, patch: Partial<NotificationInput>): void;
+    /**
+     * One notification that follows an async operation from loading to its outcome, in the
+     * same slot. The alternative is three toasts stacking up for one action.
+     */
+    promise<T>(work: Promise<T>, messages: PromiseMessages<T>): Promise<T>;
+    dismiss(id: string): void;
+    dismissAll(): void;
+    /** Hold every timer, e.g. while a pointer rests on the stack. */
+    pause(): void;
+    resume(): void;
+    subscribe(listener: (items: readonly Notification[]) => void): () => void;
+    destroy(): void;
+}
+declare function createNotifications(options?: NotificationsOptions): Notifications;
+
+export { type Notification as N, type PromiseMessages as P, type NotificationAction as a, type NotificationInput as b, type NotificationTone as c, type Notifications as d, type NotificationsOptions as e, createNotifications as f };

package/dist/palette-D7iuQh_T.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The parts of a command palette that are not rendering: what was searched before, how a
+ * flat list becomes groups, and where the highlight goes when a key is pressed.
+ *
+ * Pure functions and one storage wrapper, so all three are testable without a browser and
+ * reusable by a renderer that is not React. The palette's React parts are a thin layer over
+ * this file.
+ */
+interface RecentEntry {
+    /** What was typed. The palette puts it back in the field when the row is chosen. */
+    term: string;
+    /** A result that was opened, rather than a query that was run. */
+    label?: string;
+    /** Where that result was. */
+    href?: string;
+    /** Which scope it was searched in, when the palette has scopes. */
+    scope?: string | null;
+    /** Epoch ms. Used only for ordering. */
+    at: number;
+}
+interface RecentStoreOptions {
+    /** Storage key. One per palette, so two palettes on a site do not share a history. */
+    key?: string;
+    /** How many entries to keep. */
+    limit?: number;
+    /** `local` outlives the tab, `session` does not. Default local. */
+    storage?: "local" | "session";
+}
+interface RecentStore {
+    list(): RecentEntry[];
+    remember(entry: Omit<RecentEntry, "at"> & {
+        at?: number;
+    }): RecentEntry[];
+    forget(entry: RecentEntry): RecentEntry[];
+    clear(): void;
+}
+/** Two entries are the same memory when they point at the same thing in the same scope. */
+declare function recentKey(entry: Pick<RecentEntry, "term" | "href" | "scope">): string;
+/**
+ * What was searched before, in this browser.
+ *
+ * Every read and write is guarded: storage throws in a private window, when the quota is
+ * full, and whenever a page is opened from a file URL - and a palette that cannot remember
+ * is still a working palette, so none of that is allowed to reach the renderer. Reads also
+ * survive a corrupted value, because the key is shared with whatever else the site stores.
+ */
+declare function createRecentStore(options?: RecentStoreOptions): RecentStore;
+/** A row after grouping: its own index in the FLAT list is what the keyboard moves through. */
+interface PositionedRow<Row> {
+    row: Row;
+    position: number;
+}
+interface RowGroup<Row> {
+    label: string;
+    rows: PositionedRow<Row>[];
+}
+/**
+ * Group a flat list while keeping every row's flat position.
+ *
+ * The flat position is the whole point: the highlight moves through ONE sequence, so a
+ * group boundary is invisible to the arrow keys - and a renderer that grouped rows into
+ * separate arrays would have to reconstruct that sequence, which is where an off-by-one
+ * makes Enter open the row above the highlighted one. Groups keep first-seen order.
+ */
+declare function groupRows<Row>(rows: Row[], labelOf: (row: Row) => string): RowGroup<Row>[];
+/** Keys the list responds to. Anything else belongs to the field. */
+type PaletteKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "PageDown" | "PageUp";
+/**
+ * Where the highlight lands.
+ *
+ * It WRAPS, because a palette is a short list and the row after the last one is the first:
+ * clamping instead leaves the arrow key doing nothing at the end, which reads as the panel
+ * having frozen. An empty list stays at 0 rather than going negative.
+ */
+declare function moveActive(current: number, length: number, key: PaletteKey, page?: number): number;
+/**
+ * The shortcut label for this platform: `Cmd K` on a Mac, `Ctrl K` everywhere else.
+ *
+ * Read from the platform rather than hardcoded, because the wrong modifier in the trigger
+ * is a hint that actively misleads - and it is the first thing anyone tries.
+ */
+declare function shortcutLabel(key?: string): string;
+/** Whether an event is the palette's open shortcut. Meta on a Mac, Control elsewhere. */
+declare function isPaletteShortcut(event: KeyboardEvent, key?: string): boolean;
+
+export { type PaletteKey as P, type RecentEntry as R, type PositionedRow as a, type RecentStore as b, type RecentStoreOptions as c, type RowGroup as d, createRecentStore as e, groupRows as g, isPaletteShortcut as i, moveActive as m, recentKey as r, shortcutLabel as s };

package/dist/password-3DRQYAYQ.js

@@ -0,0 +1,2 @@
+export { PasswordExtras, PasswordStrength } from './chunk-XQHCZAPJ.js';
+import './chunk-HC2ME5PU.js';

package/dist/password-C8lG4Zm9.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Making a password, and judging one.
+ *
+ * Both are opt-in. A sign-in form wants neither: offering to generate a password where one
+ * already exists is noise, and scoring one the visitor cannot change is worse. They belong
+ * on a registration form and a change-password form, which is where an agent should switch
+ * them on.
+ */
+/** Character classes a generated password can draw from. */
+interface PasswordAlphabet {
+    lowercase?: boolean;
+    uppercase?: boolean;
+    digits?: boolean;
+    symbols?: boolean;
+}
+interface GeneratePasswordOptions extends PasswordAlphabet {
+    /** Default 20. Long beats clever: length is the only term that scales. */
+    length?: number;
+    /**
+     * Drop the characters that are read wrong off a screen or off paper - I l 1 O 0.
+     * Worth it when the password will be typed by hand, not worth the entropy otherwise.
+     */
+    excludeAmbiguous?: boolean;
+    /** Characters to remove from every class, e.g. ones your backend rejects. */
+    exclude?: string;
+    /**
+     * Guarantee at least one character from every class asked for. Most password policies
+     * demand it; it costs a little entropy, because it removes every password that happens
+     * to lack one.
+     */
+    requireEachClass?: boolean;
+}
+/**
+ * A random password from the classes asked for.
+ *
+ * @throws when the runtime has no CSPRNG, or when the options ask for something impossible
+ *         (every class excluded, or a length too short to hold one of each).
+ */
+declare function generatePassword(options?: GeneratePasswordOptions): string;
+type PasswordScore = 0 | 1 | 2 | 3 | 4;
+interface PasswordStrengthReport {
+    /** 0 worst, 4 best. What the bars under the field render. */
+    score: PasswordScore;
+    /** Estimated bits of entropy after the penalties below. */
+    bits: number;
+    /**
+     * Why it scored what it scored, worst first. Show the first one; showing all of them
+     * turns a hint into a lecture.
+     */
+    warnings: string[];
+    /** Empty field. Render nothing rather than a zero score, which reads as a failure. */
+    empty: boolean;
+}
+interface EstimateOptions {
+    /**
+     * Values the visitor has already typed elsewhere - email, name, company. A password
+     * containing one of them is guessable by anyone who has the sign-up form in front of
+     * them, and no character-class rule catches it.
+     */
+    userInputs?: string[];
+}
+/**
+ * Score a password.
+ *
+ * The bits are an estimate and the bands are a convention, not a measurement - they exist
+ * to move a bar, not to certify anything. Swap this out for zxcvbn where the number has to
+ * mean something, and check the breach corpus for the cases no estimator can see.
+ */
+declare function estimatePasswordStrength(password: string, options?: EstimateOptions): PasswordStrengthReport;
+
+export { type EstimateOptions as E, type GeneratePasswordOptions as G, type PasswordAlphabet as P, type PasswordScore as a, type PasswordStrengthReport as b, estimatePasswordStrength as e, generatePassword as g };

package/dist/password-FB2CUEKJ.js

@@ -0,0 +1 @@
+export { estimatePasswordStrength, generatePassword } from './chunk-HC2ME5PU.js';

package/dist/react/button.d.ts

@@ -0,0 +1,75 @@
+import * as react from 'react';
+import { ComponentPropsWithoutRef, ElementType, ReactNode } from 'react';
+import { c as ButtonOptions, d as ButtonState } from '../button-CaXaqG_K.js';
+
+/**
+ * `<Button>` - the component, for the ninety percent.
+ *
+ * ```tsx
+ * <Button onPress={save}>Save</Button>
+ * ```
+ *
+ * That is the whole thing: disabled while the work runs, `aria-busy`, `data-loading`, and a
+ * cooldown afterwards if you asked for one. `useButton` is still there for a button whose
+ * markup is nothing like a button - a card, a table row - but reaching for it to render an
+ * ordinary one means writing the same six lines at every call site, which is how they drift.
+ */
+interface ButtonProps extends ButtonOptions, Omit<ComponentPropsWithoutRef<"button">, "onClick" | "onChange" | "children" | "type"> {
+    /**
+     * What to run when it is pressed. The same thing as `onPress`, under the name React
+     * already uses - write whichever reads better.
+     *
+     * It is an ALIAS, not a second handler: the component owns the element's real onClick,
+     * because that is where a press is refused while the button is loading, disabled or
+     * cooling down. Passing one through would replace that and silently take the behaviour
+     * with it. Returning a promise drives `loading` for its duration, same as `onPress`.
+     */
+    onClick?: ButtonOptions["onPress"];
+    /**
+     * Override what to render. You rarely need it: an href already renders whatever
+     * `setLinkComponent` registered - your router's Link - and a button otherwise.
+     */
+    as?: ElementType;
+    /**
+     * The label, or a function of the state for one that changes with it.
+     *
+     * ```tsx
+     * <Button onPress={send} cooldown={30_000}>
+     *     {({ loading, cooldown }) => loading ? "Sending" : cooldown ? `Wait ${Math.ceil(cooldown / 1000)}s` : "Resend"}
+     * </Button>
+     * ```
+     */
+    children?: ReactNode | ((state: ButtonState) => ReactNode);
+    /** Replaces the label while async work runs - a spinner, or just different words. */
+    pending?: ReactNode;
+    /** `type` on a real button. Ignored on a link, which has none. */
+    type?: "button" | "submit" | "reset";
+    /**
+     * Show the shortcut as a key badge after the label, the way Stripe writes
+     * "Create invoice n".
+     *
+     * `"auto"` (the default) shows it when there is a shortcut AND the label renders text:
+     * beside a lone glyph on an icon-only button the badge is noise, and it would double the
+     * width of the smallest control on the screen. `true` and `false` decide it outright.
+     */
+    shortcutHint?: boolean | "auto";
+    /** Render the badge yourself. Return null to drop it for one button. */
+    renderShortcut?: (key: string) => ReactNode;
+    /**
+     * Put the behaviour on YOUR element instead of ours - a `motion.button`, your design
+     * system's button, a router Link, anything.
+     *
+     * ```tsx
+     * <Button asChild cooldown={30_000} onPress={resend}>
+     *     <motion.button whileTap={{ scale: 0.98 }}>Resend</motion.button>
+     * </Button>
+     * ```
+     *
+     * The child owns its own markup, so the shortcut badge is not injected - the child is
+     * rendered exactly as written. Read `state.shortcut` from `useButton` to place your own.
+     */
+    asChild?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLElement>>;
+
+export { Button, type ButtonProps };

package/dist/react/button.js

@@ -0,0 +1,4 @@
+"use client";
+export { Button } from '../chunk-6BGBYUSZ.js';
+import '../chunk-MMQPZGSU.js';
+import '../chunk-HS3X3XCW.js';

package/dist/react/flag.d.ts

@@ -0,0 +1,37 @@
+import { ImgHTMLAttributes, ReactNode } from 'react';
+import { e as FlagShape, c as FlagFormat, f as FlagSource } from '../flags-BBJc9unY.js';
+
+interface FlagProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src" | "alt" | "width" | "height"> {
+    /** `es`, `ES`, `en-GB`, `gb-eng`, or the emoji flag you are replacing. */
+    code: string | null | undefined;
+    /**
+     * Your own accessible name. Left out, the country's own name is used, in the reader's
+     * language - so a flag standing on its own is never a silent image.
+     */
+    label?: string;
+    /**
+     * Beside a country name that is already on screen the flag is decoration, and repeating
+     * the name only makes a screen reader say it twice.
+     */
+    decorative?: boolean;
+    /** Language the automatic name is written in. Follows the document's `lang` otherwise. */
+    locale?: string;
+    shape?: FlagShape;
+    format?: FlagFormat;
+    source?: FlagSource;
+    basePath?: string;
+    /** Rendered height in px. The width follows the shape. Default 16. */
+    size?: number;
+    /** Rendered when the code resolves to nothing. Nothing, by default. */
+    fallback?: ReactNode;
+}
+/**
+ * `<Flag code="es" />` - a country flag as an image, at the size you asked for, from the
+ * source the app configured once.
+ *
+ * The defaults come from `configureFlags`, so moving the whole application from the CDN to
+ * a downloaded set is one line at startup and no change at any call site.
+ */
+declare function Flag({ code, label, decorative, locale, shape, format, source, basePath, size, fallback, ...rest }: FlagProps): ReactNode;
+
+export { Flag, type FlagProps };

package/dist/react/flag.js

@@ -0,0 +1,3 @@
+"use client";
+export { Flag } from '../chunk-XNNQRA35.js';
+import '../chunk-AU3H5WIY.js';