@johly/bits-ui 2.18.1

package/dist/bits/utilities/presence-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PresenceLayer } from "./presence-layer.svelte";
+export type { PresenceLayerProps } from "./types.js";

package/dist/bits/utilities/presence-layer/index.js

@@ -0,0 +1 @@
+export { default as PresenceLayer } from "./presence-layer.svelte";

package/dist/bits/utilities/presence-layer/presence-layer.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	import { boxWith } from "svelte-toolbelt";
+	import type { PresenceLayerImplProps } from "./types.js";
+	import { Presence } from "./presence.svelte.js";
+
+	let { open, forceMount, presence, ref }: PresenceLayerImplProps = $props();
+
+	const presenceState = new Presence({
+		open: boxWith(() => open),
+		ref,
+	});
+</script>
+
+{#if forceMount || open || presenceState.isPresent}
+	{@render presence?.({
+		present: presenceState.isPresent,
+		transitionStatus: presenceState.transitionStatus,
+	})}
+{/if}

package/dist/bits/utilities/presence-layer/presence-layer.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { PresenceLayerImplProps } from "./types.js";
+declare const PresenceLayer: import("svelte").Component<PresenceLayerImplProps, {}, "">;
+type PresenceLayer = ReturnType<typeof PresenceLayer>;
+export default PresenceLayer;

package/dist/bits/utilities/presence-layer/presence.svelte.d.ts

@@ -0,0 +1,15 @@
+import { type ReadableBox, type ReadableBoxedValues } from "svelte-toolbelt";
+import type { TransitionState } from "../../../internal/attrs.js";
+export interface PresenceOptions extends ReadableBoxedValues<{
+    open: boolean;
+    ref: HTMLElement | null;
+}> {
+}
+export declare class Presence {
+    #private;
+    readonly opts: PresenceOptions;
+    present: ReadableBox<boolean>;
+    constructor(opts: PresenceOptions);
+    isPresent: boolean;
+    get transitionStatus(): TransitionState;
+}

package/dist/bits/utilities/presence-layer/presence.svelte.js

@@ -0,0 +1,61 @@
+import { onDestroyEffect } from "svelte-toolbelt";
+import { watch } from "runed";
+import { AnimationsComplete } from "../../../internal/animations-complete.js";
+export class Presence {
+    opts;
+    present;
+    #afterAnimations;
+    #isPresent = $state(false);
+    #hasMounted = false;
+    #transitionStatus = $state(undefined);
+    #transitionFrame = null;
+    constructor(opts) {
+        this.opts = opts;
+        this.present = this.opts.open;
+        this.#isPresent = opts.open.current;
+        this.#afterAnimations = new AnimationsComplete({
+            ref: this.opts.ref,
+            afterTick: this.opts.open,
+        });
+        onDestroyEffect(() => this.#clearTransitionFrame());
+        watch(() => this.present.current, (isOpen) => {
+            if (!this.#hasMounted) {
+                this.#hasMounted = true;
+                return;
+            }
+            this.#clearTransitionFrame();
+            if (isOpen) {
+                this.#isPresent = true;
+            }
+            this.#transitionStatus = isOpen ? "starting" : "ending";
+            if (isOpen) {
+                this.#transitionFrame = window.requestAnimationFrame(() => {
+                    this.#transitionFrame = null;
+                    if (this.present.current) {
+                        this.#transitionStatus = undefined;
+                    }
+                });
+            }
+            this.#afterAnimations.run(() => {
+                if (isOpen !== this.present.current)
+                    return;
+                if (!isOpen) {
+                    this.#isPresent = false;
+                }
+                this.#transitionStatus = undefined;
+            });
+        });
+    }
+    isPresent = $derived.by(() => {
+        return this.#isPresent;
+    });
+    get transitionStatus() {
+        return this.#transitionStatus;
+    }
+    #clearTransitionFrame() {
+        if (this.#transitionFrame === null)
+            return;
+        window.cancelAnimationFrame(this.#transitionFrame);
+        this.#transitionFrame = null;
+    }
+}

package/dist/bits/utilities/presence-layer/types.d.ts

@@ -0,0 +1,22 @@
+import type { Snippet } from "svelte";
+import type { ReadableBox } from "svelte-toolbelt";
+import type { TransitionState } from "../../../internal/attrs.js";
+export type PresenceLayerProps = {
+    /**
+     * Whether to force mount the component.
+     */
+    forceMount?: boolean;
+};
+export type PresenceLayerImplProps = PresenceLayerProps & {
+    /**
+     * The open state of the component.
+     */
+    open: boolean;
+    presence?: Snippet<[
+        {
+            present: boolean;
+            transitionStatus: TransitionState;
+        }
+    ]>;
+    ref: ReadableBox<HTMLElement | null>;
+};

package/dist/bits/utilities/presence-layer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bits/utilities/scroll-lock/index.d.ts

@@ -0,0 +1,18 @@
+export type ScrollLockProps = {
+    /**
+     * Whether to prevent body scrolling when the content is open.
+     *
+     * @default true
+     */
+    preventScroll?: boolean;
+    /**
+     * The delay in milliseconds before the scrollbar is restored after closing the
+     * dialog. This is only applicable when using the `child` snippet for custom
+     * transitions and `preventScroll` is `true`. You should set this to a value
+     * greater than the transition duration to prevent content from shifting during
+     * the transition.
+     *
+     * @default null
+     */
+    restoreScrollDelay?: number | null;
+};

package/dist/bits/utilities/scroll-lock/index.js

@@ -0,0 +1 @@
+export {};

package/dist/bits/utilities/scroll-lock/scroll-lock.svelte

@@ -0,0 +1,10 @@
+<script lang="ts">
+	import type { ScrollLockProps } from "./index.js";
+	import { BodyScrollLock } from "../../../internal/body-scroll-lock.svelte.js";
+
+	let { preventScroll = true, restoreScrollDelay = null }: ScrollLockProps = $props();
+
+	if (preventScroll) {
+		new BodyScrollLock(preventScroll, () => restoreScrollDelay);
+	}
+</script>

package/dist/bits/utilities/scroll-lock/scroll-lock.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ScrollLockProps } from "./index.js";
+declare const ScrollLock: import("svelte").Component<ScrollLockProps, {}, "">;
+type ScrollLock = ReturnType<typeof ScrollLock>;
+export default ScrollLock;

package/dist/bits/utilities/text-selection-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TextSelectionLayer } from "./text-selection-layer.svelte";
+export type { TextSelectionLayerProps } from "./types.js";

package/dist/bits/utilities/text-selection-layer/index.js

@@ -0,0 +1 @@
+export { default as TextSelectionLayer } from "./text-selection-layer.svelte";

package/dist/bits/utilities/text-selection-layer/text-selection-layer.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+	import { boxWith } from "svelte-toolbelt";
+	import type { TextSelectionLayerImplProps } from "./types.js";
+	import { TextSelectionLayerState } from "./use-text-selection-layer.svelte.js";
+	import { noop } from "../../../internal/noop.js";
+
+	let {
+		preventOverflowTextSelection = true,
+		onPointerDown = noop,
+		onPointerUp = noop,
+		id,
+		children,
+		enabled,
+		ref,
+	}: TextSelectionLayerImplProps = $props();
+
+	TextSelectionLayerState.create({
+		id: boxWith(() => id),
+		onPointerDown: boxWith(() => onPointerDown),
+		onPointerUp: boxWith(() => onPointerUp),
+		enabled: boxWith(() => enabled && preventOverflowTextSelection),
+		ref,
+	});
+</script>
+
+{@render children?.()}

package/dist/bits/utilities/text-selection-layer/text-selection-layer.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { TextSelectionLayerImplProps } from "./types.js";
+declare const TextSelectionLayer: import("svelte").Component<TextSelectionLayerImplProps, {}, "">;
+type TextSelectionLayer = ReturnType<typeof TextSelectionLayer>;
+export default TextSelectionLayer;

package/dist/bits/utilities/text-selection-layer/types.d.ts

@@ -0,0 +1,33 @@
+import type { Snippet } from "svelte";
+import type { ReadableBox } from "svelte-toolbelt";
+export type PointerHandler = (e: PointerEvent) => void;
+export type TextSelectionLayerProps = {
+    /**
+     * Passing `true` will prevent the overflow of text selection
+     * outside the element, provided the element is the top layer.
+     * @defaultValue `true`
+     */
+    preventOverflowTextSelection?: boolean;
+};
+export type TextSelectionLayerImplProps = {
+    /**
+     * Whether the layer is enabled. Currently, we determine this with the
+     * `presence` returned from the `presence` layer.
+     */
+    enabled: boolean;
+    /**
+     * DOM ID of the node.
+     */
+    id: string;
+    children?: Snippet;
+    /**
+     * Callback fired when pointerdown event triggers. Call `preventDefault()`
+     * to disable the prevention of text-selection overflow.
+     */
+    onPointerDown?: PointerHandler;
+    /**
+     * Callback fired when pointerup event triggers.
+     */
+    onPointerUp?: PointerHandler;
+    ref: ReadableBox<HTMLElement | null>;
+} & TextSelectionLayerProps;

package/dist/bits/utilities/text-selection-layer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bits/utilities/text-selection-layer/use-text-selection-layer.svelte.d.ts

@@ -0,0 +1,14 @@
+import { DOMContext, type ReadableBoxedValues } from "svelte-toolbelt";
+import type { TextSelectionLayerImplProps } from "./types.js";
+interface TextSelectionLayerStateOpts extends ReadableBoxedValues<Required<Omit<TextSelectionLayerImplProps, "children" | "preventOverflowTextSelection" | "ref">> & {
+    ref: HTMLElement | null;
+}> {
+}
+export declare class TextSelectionLayerState {
+    #private;
+    static create(opts: TextSelectionLayerStateOpts): TextSelectionLayerState;
+    readonly opts: TextSelectionLayerStateOpts;
+    readonly domContext: DOMContext;
+    constructor(opts: TextSelectionLayerStateOpts);
+}
+export {};

package/dist/bits/utilities/text-selection-layer/use-text-selection-layer.svelte.js

@@ -0,0 +1,94 @@
+import { DOMContext, composeHandlers, contains, executeCallbacks, } from "svelte-toolbelt";
+import { watch } from "runed";
+import { on } from "svelte/events";
+import { noop } from "../../../internal/noop.js";
+import { isHTMLElement } from "../../../internal/is.js";
+const noopPointer = () => { };
+globalThis.bitsTextSelectionLayers ??= new Map();
+export class TextSelectionLayerState {
+    static create(opts) {
+        return new TextSelectionLayerState(opts);
+    }
+    opts;
+    domContext;
+    #unsubSelectionLock = noop;
+    #enabledSnapshot = false;
+    #onPointerDownSnapshot = noopPointer;
+    #onPointerUpSnapshot = noopPointer;
+    constructor(opts) {
+        this.opts = opts;
+        this.domContext = new DOMContext(opts.ref);
+        let unsubEvents = noop;
+        watch(() => [
+            this.opts.enabled.current,
+            this.opts.onPointerDown.current,
+            this.opts.onPointerUp.current,
+        ], ([enabled, onPointerDown, onPointerUp]) => {
+            this.#enabledSnapshot = enabled;
+            this.#onPointerDownSnapshot = onPointerDown;
+            this.#onPointerUpSnapshot = onPointerUp;
+            if (enabled) {
+                globalThis.bitsTextSelectionLayers.set(this, this.opts.enabled);
+                unsubEvents();
+                unsubEvents = this.#addEventListeners();
+            }
+            return () => {
+                this.#enabledSnapshot = false;
+                unsubEvents();
+                this.#resetSelectionLock();
+                globalThis.bitsTextSelectionLayers.delete(this);
+            };
+        });
+    }
+    #addEventListeners() {
+        return executeCallbacks(on(this.domContext.getDocument(), "pointerdown", this.#pointerdown), on(this.domContext.getDocument(), "pointerup", composeHandlers(this.#resetSelectionLock, this.#pointerupUserHandler)));
+    }
+    #pointerupUserHandler = (e) => {
+        this.#onPointerUpSnapshot(e);
+    };
+    #pointerdown = (e) => {
+        const node = this.opts.ref.current;
+        const target = e.target;
+        if (!isHTMLElement(node) || !isHTMLElement(target) || !this.#enabledSnapshot)
+            return;
+        /**
+         * We only lock user-selection overflow if layer is the top most layer and
+         * pointerdown occurred inside the node. You are still allowed to select text
+         * outside the node provided pointerdown occurs outside the node.
+         */
+        if (!isHighestLayer(this) || !contains(node, target))
+            return;
+        this.#onPointerDownSnapshot(e);
+        if (e.defaultPrevented)
+            return;
+        this.#unsubSelectionLock = preventTextSelectionOverflow(node, this.domContext.getDocument().body);
+    };
+    #resetSelectionLock = () => {
+        this.#unsubSelectionLock();
+        this.#unsubSelectionLock = noop;
+    };
+}
+const getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
+function preventTextSelectionOverflow(node, body) {
+    const originalBodyUserSelect = getUserSelect(body);
+    const originalNodeUserSelect = getUserSelect(node);
+    setUserSelect(body, "none");
+    setUserSelect(node, "text");
+    return () => {
+        setUserSelect(body, originalBodyUserSelect);
+        setUserSelect(node, originalNodeUserSelect);
+    };
+}
+function setUserSelect(node, value) {
+    node.style.userSelect = value;
+    node.style.webkitUserSelect = value;
+}
+function isHighestLayer(instance) {
+    const layersArr = [...globalThis.bitsTextSelectionLayers];
+    if (!layersArr.length)
+        return false;
+    const highestLayer = layersArr.at(-1);
+    if (!highestLayer)
+        return false;
+    return highestLayer[0] === instance;
+}

package/dist/bits/utilities/visually-hidden/index.d.ts

@@ -0,0 +1,2 @@
+export { default as VisuallyHidden } from "./visually-hidden.svelte";
+export type * from "./types.js";

package/dist/bits/utilities/visually-hidden/index.js

@@ -0,0 +1 @@
+export { default as VisuallyHidden } from "./visually-hidden.svelte";

package/dist/bits/utilities/visually-hidden/types.d.ts

@@ -0,0 +1,3 @@
+import type { WithChild } from "../../../internal/types.js";
+import type { BitsPrimitiveSpanAttributes } from "../../../shared/attributes.js";
+export type VisuallyHiddenProps = WithChild<BitsPrimitiveSpanAttributes>;

package/dist/bits/utilities/visually-hidden/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bits/utilities/visually-hidden/visually-hidden.svelte

@@ -0,0 +1,31 @@
+<script lang="ts">
+	import { mergeProps } from "svelte-toolbelt";
+	import type { VisuallyHiddenProps } from "./types.js";
+	import type { StyleProperties } from "../../../shared/index.js";
+
+	let { children, child, ...restProps }: VisuallyHiddenProps = $props();
+
+	const style: StyleProperties = {
+		position: "absolute",
+		border: 0,
+		width: "1px",
+		display: "inline-block",
+		height: "1px",
+		padding: 0,
+		margin: "-1px",
+		overflow: "hidden",
+		clip: "rect(0 0 0 0)",
+		whiteSpace: "nowrap",
+		wordWrap: "normal",
+	};
+
+	const mergedProps = $derived(mergeProps(restProps, { style }));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps })}
+{:else}
+	<span {...mergedProps}>
+		{@render children?.()}
+	</span>
+{/if}

package/dist/bits/utilities/visually-hidden/visually-hidden.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { VisuallyHiddenProps } from "./types.js";
+declare const VisuallyHidden: import("svelte").Component<VisuallyHiddenProps, {}, "">;
+type VisuallyHidden = ReturnType<typeof VisuallyHidden>;
+export default VisuallyHidden;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Accordion, AlertDialog, AspectRatio, Avatar, BitsConfig, Button, Calendar, Checkbox, Collapsible, Combobox, Command, ContextMenu, DateField, DatePicker, DateRangeField, DateRangePicker, Dialog, DropdownMenu, Filter, Label, LinkPreview, Menubar, Meter, NavigationMenu, Pagination, PinInput, Popover, Progress, RadioGroup, RangeCalendar, RatingGroup, ScrollArea, Select, Separator, Slider, Switch, Tabs, TimeField, TimeRangeField, Toggle, ToggleGroup, Toolbar, Tooltip, Portal, IsUsingKeyboard, computeCommandScore, createTypedDataTableFilters, filterFns, getBitsConfig, useDataTableFilters, } from "./bits/index.js";
+export * from "./shared/index.js";
+export type * from "./shared/index.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Accordion, AlertDialog, AspectRatio, Avatar, BitsConfig, Button, Calendar, Checkbox, Collapsible, Combobox, Command, ContextMenu, DateField, DatePicker, DateRangeField, DateRangePicker, Dialog, DropdownMenu, Filter, Label, LinkPreview, Menubar, Meter, NavigationMenu, Pagination, PinInput, Popover, Progress, RadioGroup, RangeCalendar, RatingGroup, ScrollArea, Select, Separator, Slider, Switch, Tabs, TimeField, TimeRangeField, Toggle, ToggleGroup, Toolbar, Tooltip, Portal, IsUsingKeyboard, computeCommandScore, createTypedDataTableFilters, filterFns, getBitsConfig, useDataTableFilters, } from "./bits/index.js";
+export * from "./shared/index.js";
+export * from "./types.js";

package/dist/internal/animations-complete.d.ts

@@ -0,0 +1,12 @@
+import { type ReadableBoxedValues } from "svelte-toolbelt";
+interface AnimationsCompleteOpts extends ReadableBoxedValues<{
+    ref: HTMLElement | null;
+    afterTick: boolean;
+}> {
+}
+export declare class AnimationsComplete {
+    #private;
+    constructor(opts: AnimationsCompleteOpts);
+    run(fn: () => void | Promise<void>): void;
+}
+export {};

package/dist/internal/animations-complete.js

@@ -0,0 +1,102 @@
+import { afterTick, onDestroyEffect } from "svelte-toolbelt";
+export class AnimationsComplete {
+    #opts;
+    #currentFrame = null;
+    #observer = null;
+    #runId = 0;
+    constructor(opts) {
+        this.#opts = opts;
+        onDestroyEffect(() => this.#cleanup());
+    }
+    #cleanup() {
+        if (this.#currentFrame !== null) {
+            window.cancelAnimationFrame(this.#currentFrame);
+            this.#currentFrame = null;
+        }
+        this.#observer?.disconnect();
+        this.#observer = null;
+        this.#runId++;
+    }
+    run(fn) {
+        this.#cleanup();
+        const node = this.#opts.ref.current;
+        if (!node)
+            return;
+        if (typeof node.getAnimations !== "function") {
+            this.#executeCallback(fn);
+            return;
+        }
+        const runId = this.#runId;
+        const executeIfCurrent = () => {
+            if (runId !== this.#runId)
+                return;
+            this.#executeCallback(fn);
+        };
+        const waitForAnimations = () => {
+            if (runId !== this.#runId)
+                return;
+            const animations = node.getAnimations();
+            if (animations.length === 0) {
+                executeIfCurrent();
+                return;
+            }
+            Promise.all(animations.map((animation) => animation.finished))
+                .then(() => {
+                executeIfCurrent();
+            })
+                .catch(() => {
+                if (runId !== this.#runId)
+                    return;
+                const currentAnimations = node.getAnimations();
+                const hasRunningAnimations = currentAnimations.some((animation) => animation.pending || animation.playState !== "finished");
+                if (hasRunningAnimations) {
+                    waitForAnimations();
+                    return;
+                }
+                executeIfCurrent();
+            });
+        };
+        const requestWaitForAnimations = () => {
+            this.#currentFrame = window.requestAnimationFrame(() => {
+                this.#currentFrame = null;
+                waitForAnimations();
+            });
+        };
+        if (!this.#opts.afterTick.current) {
+            requestWaitForAnimations();
+            return;
+        }
+        this.#currentFrame = window.requestAnimationFrame(() => {
+            this.#currentFrame = null;
+            const startingStyleAttr = "data-starting-style";
+            if (!node.hasAttribute(startingStyleAttr)) {
+                requestWaitForAnimations();
+                return;
+            }
+            this.#observer = new MutationObserver(() => {
+                if (runId !== this.#runId)
+                    return;
+                if (node.hasAttribute(startingStyleAttr))
+                    return;
+                this.#observer?.disconnect();
+                this.#observer = null;
+                requestWaitForAnimations();
+            });
+            this.#observer.observe(node, {
+                attributes: true,
+                attributeFilter: [startingStyleAttr],
+            });
+        });
+    }
+    #executeCallback(fn) {
+        const execute = () => {
+            fn();
+        };
+        if (this.#opts.afterTick) {
+            afterTick(execute);
+        }
+        else {
+            execute();
+        }
+    }
+}

package/dist/internal/arrays.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Checks if two arrays are equal by comparing their values.
+ */
+export declare function arraysAreEqual<T extends Array<unknown>>(arr1: T, arr2: T): boolean;
+/**
+ * Splits an array into chunks of a given size.
+ * @param arr The array to split.
+ * @param size The size of each chunk.
+ * @returns An array of arrays, where each sub-array has `size` elements from the original array.
+ * @example ```ts
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8];
+ * const chunks = chunk(arr, 3);
+ * // chunks = [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * ```
+ */
+export declare function chunk<T>(arr: T[], size: number): T[][];
+/**
+ * Checks if the given index is valid for the given array.
+ *
+ * @param index - The index to check
+ * @param arr - The array to check
+ */
+export declare function isValidIndex(index: number, arr: unknown[]): boolean;
+/**
+ * Returns the array element after the given index, or undefined for out-of-bounds or empty arrays.
+ * @param array the array.
+ * @param index the index of the current element.
+ * @param loop loop to the beginning of the array if the next index is out of bounds?
+ */
+/**
+ * Returns the array element after the given index, or undefined for out-of-bounds or empty arrays.
+ * For single-element arrays, returns the element if the index is 0.
+ * @param array the array.
+ * @param index the index of the current element.
+ * @param loop loop to the beginning of the array if the next index is out of bounds?
+ */
+export declare function next<T>(array: T[], index: number, loop?: boolean): T | undefined;
+/**
+ * Returns the array element prior to the given index, or undefined for out-of-bounds or empty arrays.
+ * For single-element arrays, returns the element if the index is 0.
+ * @param array the array.
+ * @param index the index of the current element.
+ * @param loop loop to the end of the array if the previous index is out of bounds?
+ */
+export declare function prev<T>(array: T[], index: number, loop?: boolean): T | undefined;
+/**
+ * Returns the element some number after the given index. If the target index is out of bounds:
+ *   - If looping is disabled, the first or last element will be returned.
+ *   - If looping is enabled, it will wrap around the array.
+ * Returns undefined for empty arrays or out-of-bounds initial indices.
+ * @param array the array.
+ * @param index the index of the current element.
+ * @param increment the number of elements to move forward (can be negative).
+ * @param loop loop around the array if the target index is out of bounds?
+ */
+export declare function forward<T>(array: T[], index: number, increment: number, loop?: boolean): T | undefined;
+/**
+ * Returns the element some number before the given index. If the target index is out of bounds:
+ *   - If looping is disabled, the first or last element will be returned.
+ *   - If looping is enabled, it will wrap around the array.
+ * Returns undefined for empty arrays or out-of-bounds initial indices.
+ * @param array the array.
+ * @param index the index of the current element.
+ * @param decrement the number of elements to move backward (can be negative).
+ * @param loop loop around the array if the target index is out of bounds?
+ */
+export declare function backward<T>(array: T[], index: number, decrement: number, loop?: boolean): T | undefined;
+/**
+ * Finds the next matching item from a list of values based on a search string.
+ *
+ * This function handles several special cases in typeahead behavior:
+ *
+ * 1. Space handling: When a search string ends with a space, it handles it specially:
+ *    - If there's only one match for the text before the space, it ignores the space
+ *    - If there are multiple matches and the current match already starts with the search prefix
+ *      followed by a space, it keeps the current match (doesn't change selection on space)
+ *    - Only after typing characters beyond the space will it move to a more specific match
+ *
+ * 2. Repeated character handling: If a search consists of repeated characters (e.g., "aaa"),
+ *    it treats it as a single character for matching purposes
+ *
+ * 3. Cycling behavior: The function wraps around the values array starting from the current match
+ *    to find the next appropriate match, creating a cycling selection behavior
+ *
+ * @param values - Array of string values to search through (e.g., the text content of menu items)
+ * @param search - The current search string typed by the user
+ * @param currentMatch - The currently selected/matched item, if any
+ * @returns The next matching value that should be selected, or undefined if no match is found
+ */
+export declare function getNextMatch(values: string[], search: string, currentMatch?: string): string | undefined;
+/**
+ * Wraps an array around itself at a given start index
+ * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
+ */
+export declare function wrapArray<T>(array: T[], startIndex: number): T[];