@inkami/blx 0.17.3

package/dist/search/index.d.ts

@@ -0,0 +1,4 @@
+export { SearchEngine } from "./search-engine";
+export type { SearchMatch, SearchOptions, ReplaceResult } from "./search-engine";
+export { SearchUI } from "./search-ui";
+export type { SearchUICallbacks } from "./search-ui";

package/dist/search/search-engine.d.ts

@@ -0,0 +1,39 @@
+import type { Block } from "../types";
+export interface SearchOptions {
+    caseSensitive?: boolean;
+    regex?: boolean;
+    blockTypes?: string[];
+}
+export interface SearchMatch {
+    blockId: string;
+    blockType: string;
+    /** Character offset within the block's text content */
+    start: number;
+    /** Character offset (exclusive) within the block's text content */
+    end: number;
+    /** The matched text */
+    matchText: string;
+    /** Surrounding context text */
+    context: string;
+}
+export interface ReplaceResult {
+    blockId: string;
+    /** Number of replacements made in this block */
+    count: number;
+}
+/**
+ * Search engine that operates on the block model (not the DOM).
+ * Stateless — takes blocks as input and returns matches.
+ */
+export declare class SearchEngine {
+    /**
+     * Search all blocks for a query string or regex pattern.
+     */
+    search(blocks: ReadonlyArray<Block>, query: string, options?: SearchOptions): SearchMatch[];
+    /**
+     * Count total matches across all blocks.
+     */
+    count(blocks: ReadonlyArray<Block>, query: string, options?: SearchOptions): number;
+    private buildPattern;
+    private extractContext;
+}

package/dist/search/search-ui.d.ts

@@ -0,0 +1,59 @@
+import type { SearchMatch, SearchOptions } from "./search-engine";
+export interface SearchUICallbacks {
+    /** Called when the query, options, or navigation changes. */
+    onSearch: (query: string, options: SearchOptions) => SearchMatch[];
+    /** Called to navigate to (highlight & scroll to) a specific match. */
+    onNavigate: (match: SearchMatch) => void;
+    /** Called to replace a single match with replacement text. */
+    onReplace: (match: SearchMatch, replacement: string) => void;
+    /** Called to replace all matches. */
+    onReplaceAll: (matches: SearchMatch[], replacement: string) => void;
+    /** Called when the panel is closed. */
+    onClose: () => void;
+}
+/**
+ * Search & Replace panel UI.
+ * Renders a fixed panel at the top-right of the editor.
+ * Replace row is collapsed by default with a toggle button.
+ */
+export declare class SearchUI {
+    readonly element: HTMLElement;
+    private searchInput;
+    private replaceInput;
+    private countLabel;
+    private caseSensitiveBtn;
+    private regexBtn;
+    private replaceRow;
+    private expandBtn;
+    private replaceExpanded;
+    private callbacks;
+    private matches;
+    private currentIndex;
+    private caseSensitive;
+    private useRegex;
+    private debounceTimer;
+    constructor(callbacks: SearchUICallbacks);
+    show(): void;
+    hide(): void;
+    get visible(): boolean;
+    /** Focus the search input (e.g. when re-opening). */
+    focus(): void;
+    /** Navigate to the next search match. */
+    next(): void;
+    /** Navigate to the previous search match. */
+    prev(): void;
+    /** Handle keydown events. Returns true if consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    destroy(): void;
+    /** Position the panel at the top-right of the nearest scrollable ancestor. */
+    private positionPanel;
+    private toggleReplace;
+    private build;
+    private onQueryChange;
+    private runSearch;
+    private navigateNext;
+    private navigatePrev;
+    private replaceCurrent;
+    private replaceAll;
+    private updateCount;
+}

package/dist/selection/index.d.ts

@@ -0,0 +1,3 @@
+export { SelectionManager } from "./selection-manager";
+export type { InlineSelection, MultiBlockSelection, SelectionState } from "./types";
+export { isMultiBlockSelection, isInlineSelection } from "./types";

package/dist/selection/selection-manager.d.ts

@@ -0,0 +1,41 @@
+import type { Editor } from "../editor";
+import type { MultiBlockSelection, SelectionState } from "./types";
+import type { Attributes } from "../attributed-string";
+/**
+ * Tracks the native browser selection and maps it to block-level selection state.
+ * Provides cross-block operations: deleteSelection(), formatSelection().
+ */
+export declare class SelectionManager {
+    private editor;
+    private bus;
+    private current;
+    private blockSelectionActive;
+    private handleSelectionChange;
+    constructor(editor: Editor);
+    /** Whether the current selection is a programmatic block selection */
+    isBlockSelection(): boolean;
+    /** Set a programmatic block selection state */
+    setBlockSelection(state: MultiBlockSelection): void;
+    /** Clear the programmatic block selection */
+    clearBlockSelection(): void;
+    /** Get the current selection state */
+    getSelection(): SelectionState;
+    /**
+     * Delete the current selection.
+     * For multi-block: trim first block, remove middle blocks, trim last block,
+     * then merge first and last.
+     */
+    deleteSelection(): void;
+    /**
+     * Apply formatting attributes to the current selection.
+     */
+    formatSelection(attrs: Attributes): void;
+    /** Manually set selection (used by tests or programmatic control) */
+    setSelection(sel: SelectionState): void;
+    /** Clean up event listeners */
+    destroy(): void;
+    private syncFromDOM;
+    private findBlockFromNode;
+    private getOffsetInBlock;
+    private applyToBlock;
+}

package/dist/selection/types.d.ts

@@ -0,0 +1,20 @@
+/** Selection within a single block */
+export interface InlineSelection {
+    blockId: string;
+    start: number;
+    end: number;
+}
+/** Selection spanning multiple blocks */
+export interface MultiBlockSelection {
+    anchorBlockId: string;
+    anchorOffset: number;
+    focusBlockId: string;
+    focusOffset: number;
+    selectedBlockIds: string[];
+}
+/** Current selection state — either inline, multi-block, or null */
+export type SelectionState = InlineSelection | MultiBlockSelection | null;
+/** Type guard for MultiBlockSelection */
+export declare function isMultiBlockSelection(sel: SelectionState): sel is MultiBlockSelection;
+/** Type guard for InlineSelection */
+export declare function isInlineSelection(sel: SelectionState): sel is InlineSelection;

package/dist/slash-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { SlashMenu, SLASH_MENU_ITEMS } from "./slash-menu";
+export type { SlashMenuItem } from "./slash-menu";

package/dist/slash-menu/slash-menu.d.ts

@@ -0,0 +1,27 @@
+export interface SlashMenuItem {
+    type: string;
+    label: string;
+    description: string;
+    metadata?: Record<string, unknown>;
+}
+export declare const SLASH_MENU_ITEMS: SlashMenuItem[];
+export declare class SlashMenu {
+    private menu;
+    private allItems;
+    private filteredItems;
+    private onSelectCb;
+    constructor(items: SlashMenuItem[], onSelect: (item: SlashMenuItem) => void, onClose: () => void);
+    get element(): HTMLElement;
+    get hasItems(): boolean;
+    show(anchorRect: DOMRect): void;
+    /** Reposition the menu relative to a new anchor rect (e.g. on scroll) */
+    reposition(anchorRect: DOMRect): void;
+    hide(): void;
+    get visible(): boolean;
+    /** Update the filter query. Filters allItems, resets selection, re-renders. */
+    updateFilter(query: string): void;
+    /** Handle keyboard events. Returns true if the event was consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    destroy(): void;
+    private toMenuItems;
+}

package/dist/table-of-contents/index.d.ts

@@ -0,0 +1 @@
+export { TableOfContents } from "./table-of-contents";

package/dist/table-of-contents/table-of-contents.d.ts

@@ -0,0 +1,74 @@
+import type { Block } from "../types";
+/**
+ * Table of Contents widget — a minimap-style navigation rail on the right
+ * side of the editor. Shows tiny right-aligned lines at rest. On hover,
+ * entries expand into labeled pills with genie magnification that pops
+ * the entry nearest to the cursor.
+ */
+export declare class TableOfContents {
+    private readonly container;
+    private readonly track;
+    private readonly editorRoot;
+    private readonly getBlocks;
+    private readonly onNavigate;
+    private activeBlockId;
+    private entries;
+    private entryEls;
+    private updateTimer;
+    private scrollRaf;
+    private scrollParent;
+    private scrollHandler;
+    private moveRaf;
+    private lastMouseY;
+    /** Timestamp until which scroll-based active tracking is suppressed (after click nav) */
+    private scrollLockUntil;
+    /** Whether the mouse is currently over the TOC container */
+    private isHovered;
+    constructor(editorRoot: HTMLElement, getBlocks: () => ReadonlyArray<Block>, onNavigate: (blockId: string) => void);
+    /**
+     * Scan blocks for headings and rebuild the ToC entries.
+     * Debounced when called repeatedly (e.g. rapid typing).
+     */
+    update(): void;
+    /**
+     * Highlight a specific entry as the active heading.
+     */
+    setActiveHeading(blockId: string | null): void;
+    /**
+     * Hide the widget.
+     */
+    hide(): void;
+    /**
+     * Show the widget.
+     */
+    show(): void;
+    /**
+     * Clean up DOM and listeners.
+     */
+    destroy(): void;
+    private rebuild;
+    private applyActiveClass;
+    private handleClick;
+    /**
+     * Briefly pulse the background of a heading block to confirm navigation.
+     */
+    private pulseBlock;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleMouseMove;
+    private applyMagnification;
+    /**
+     * Set up scroll-based active heading tracking.
+     * Find the scroll parent and listen for scroll events.
+     */
+    private setupScrollTracking;
+    /**
+     * Find the nearest scrollable ancestor, or fall back to window.
+     */
+    private findScrollParent;
+    /**
+     * Determine which heading is currently "active" based on scroll position.
+     * Skipped briefly after click-navigation so the clicked heading stays active.
+     */
+    private computeActiveHeading;
+}

package/dist/transaction/index.d.ts

@@ -0,0 +1,2 @@
+export { Transaction } from "./transaction";
+export type { Operation, InsertTextOp, DeleteRangeOp, ApplyAttributesOp, RemoveAttributesOp, SetMetadataOp, ReplaceContentOp, TransactionResult, } from "./types";

package/dist/transaction/transaction.d.ts

@@ -0,0 +1,29 @@
+import type { AttributedString, Attributes } from "../attributed-string";
+import type { BlockMetadata } from "../schema";
+import type { Operation, TransactionResult } from "./types";
+/**
+ * Transaction builder — accumulates operations via a builder pattern,
+ * then applies them all in order to produce new content and metadata.
+ *
+ * A transaction can only be applied once.
+ */
+export declare class Transaction {
+    readonly blockId: string;
+    private ops;
+    private committed;
+    constructor(blockId: string);
+    get operations(): ReadonlyArray<Operation>;
+    get isEmpty(): boolean;
+    insertText(offset: number, text: string, attributes?: Attributes): this;
+    deleteRange(start: number, end: number): this;
+    applyAttributes(start: number, end: number, attributes: Attributes): this;
+    removeAttributes(start: number, end: number, keys: string[]): this;
+    setMetadata(key: string, value: unknown): this;
+    replaceContent(content: AttributedString): this;
+    /**
+     * Apply all operations in order. Returns new content and metadata.
+     * Marks the transaction as committed — cannot be applied again.
+     */
+    apply(content: AttributedString, metadata: BlockMetadata): TransactionResult;
+    private guardCommitted;
+}

package/dist/transaction/types.d.ts

@@ -0,0 +1,40 @@
+import type { Attributes } from "../attributed-string";
+import type { BlockMetadata } from "../schema";
+import type { AttributedString } from "../attributed-string";
+export interface InsertTextOp {
+    type: "insertText";
+    offset: number;
+    text: string;
+    attributes?: Attributes;
+}
+export interface DeleteRangeOp {
+    type: "deleteRange";
+    start: number;
+    end: number;
+}
+export interface ApplyAttributesOp {
+    type: "applyAttributes";
+    start: number;
+    end: number;
+    attributes: Attributes;
+}
+export interface RemoveAttributesOp {
+    type: "removeAttributes";
+    start: number;
+    end: number;
+    keys: string[];
+}
+export interface SetMetadataOp {
+    type: "setMetadata";
+    key: string;
+    value: unknown;
+}
+export interface ReplaceContentOp {
+    type: "replaceContent";
+    content: AttributedString;
+}
+export type Operation = InsertTextOp | DeleteRangeOp | ApplyAttributesOp | RemoveAttributesOp | SetMetadataOp | ReplaceContentOp;
+export interface TransactionResult {
+    content: AttributedString;
+    metadata: BlockMetadata;
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import { AttributedString } from "./attributed-string";
+import type { AttributedStringJSON } from "./attributed-string";
+import type { BlockMetadata } from "./schema";
+/** A block of content in the editor */
+export interface Block {
+    id: string;
+    type: string;
+    content: AttributedString;
+    metadata: BlockMetadata;
+}
+/** JSON-serializable representation of a Block */
+export interface BlockJSON {
+    id: string;
+    type: string;
+    content: AttributedStringJSON;
+    metadata: BlockMetadata;
+}
+/** Convert a Block to its JSON representation */
+export declare function blockToJSON(block: Block): BlockJSON;
+/** Restore a Block from its JSON representation */
+export declare function blockFromJSON(json: BlockJSON): Block;

package/dist/ui/context-menu.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Reusable floating context menu component.
+ * Renders a list of selectable items with keyboard navigation,
+ * mouse interaction, sections, disabled/danger states, and viewport-aware positioning.
+ *
+ * Used internally by SlashMenu, AutoCompleteMenu, BlockActionMenu, and table context menu.
+ */
+/** A single item in a {@link ContextMenu}. */
+export interface MenuItem {
+    /** Unique identifier for this item — returned in {@link ContextMenu.onSelect}. */
+    id: string;
+    /** Human-readable display name. */
+    label: string;
+    /** Optional secondary description displayed below the label. */
+    description?: string;
+    /**
+     * Optional icon: either an HTML string or a render function.
+     * Render functions receive the icon container element and may append
+     * arbitrary DOM nodes (e.g. SVGs).
+     */
+    icon?: string | ((container: HTMLElement) => void);
+    /** Group key — separator inserted between different sections */
+    section?: string;
+    /** When true, the item is rendered dimmed and cannot be selected. */
+    disabled?: boolean;
+    /** When true, the label is rendered in danger (red) color. */
+    danger?: boolean;
+    /** Keyboard shortcut hint displayed right-aligned, e.g. "⌫" or "Del" */
+    hint?: string;
+    /** Arbitrary payload passed back in onSelect */
+    data?: unknown;
+}
+/** Construction options for {@link ContextMenu}. */
+export interface ContextMenuOptions {
+    /** Additional CSS class on the container (e.g. "blx-slash-menu") */
+    className?: string;
+    /** If set, shows empty state when items is empty */
+    emptyText?: string;
+    /** Arrow nav skips disabled items (default: true) */
+    skipDisabled?: boolean;
+    /**
+     * ARIA role for the container and its items.
+     * - "menu" (default): container gets role="menu", items get implicit button role
+     * - "listbox": container gets role="listbox", items get role="option"
+     * Used by Dropdown widget for accessible select-like behavior.
+     */
+    role?: "menu" | "listbox";
+}
+export declare class ContextMenu {
+    /** The root DOM element of the menu. Append to the document before calling {@link show}. */
+    readonly el: HTMLElement;
+    private items;
+    private selectedIndex;
+    private _visible;
+    private opts;
+    /** Remembered placement so reposition() doesn't flicker */
+    private placement;
+    /** Stored anchor rect for repositioning after content changes */
+    private anchorRect;
+    /** Called when the user selects an item (click, Enter, or Tab). */
+    onSelect: ((item: MenuItem) => void) | null;
+    /** Called when Escape is pressed while the menu is visible. */
+    onClose: (() => void) | null;
+    constructor(options?: ContextMenuOptions);
+    /** Whether the menu is currently visible. */
+    get visible(): boolean;
+    /** Whether the menu has at least one item. */
+    get hasItems(): boolean;
+    /** The currently highlighted {@link MenuItem}, or `undefined` if empty. */
+    get selectedItem(): MenuItem | undefined;
+    /**
+     * Show the menu anchored to `anchorRect` and populate it with `items`.
+     * The menu is positioned below the anchor by default and flips above if
+     * it would overflow the viewport bottom.
+     * @param anchorRect - Bounding rect of the element to anchor to.
+     * @param items - List of items to render.
+     */
+    show(anchorRect: DOMRect, items: MenuItem[]): void;
+    /** Hide the menu. Does not remove it from the DOM. */
+    hide(): void;
+    /** Hide the menu and remove its element from the DOM. */
+    destroy(): void;
+    /** Replace items and reanchor when placed above (used for filter-as-you-type) */
+    setItems(items: MenuItem[]): void;
+    /** Reposition relative to a new anchor rect (e.g. caret moved or content resized) */
+    reposition(anchorRect: DOMRect): void;
+    /**
+     * Handle keyboard events for menu navigation.
+     * @param e - The keyboard event to process.
+     * @returns `true` if the event was consumed (ArrowUp, ArrowDown, Enter, Tab, Escape),
+     *          `false` otherwise. When `true`, callers should stop further event processing.
+     */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    /**
+     * Programmatically select item by index.
+     * Used by Dropdown type-ahead to highlight the matching item.
+     */
+    selectIndex(index: number): void;
+    private moveSelection;
+    private findFirstEnabled;
+    private renderItems;
+    private updateSelection;
+}

package/dist/ui/dismiss.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared dismiss utility: click-outside + optional Escape key.
+ * Used internally by Popover, and directly by BlockActionMenu.
+ */
+/**
+ * Handle returned by {@link dismissOnClickOutside}.
+ * Call {@link remove} to cancel all installed listeners.
+ */
+export interface DismissHandle {
+    /** Cancel all event listeners installed by {@link dismissOnClickOutside}. */
+    remove(): void;
+}
+/**
+ * Install click-outside and optional Escape-key dismiss handlers for a floating element.
+ *
+ * The click-outside listener is installed via a capture-phase `mousedown` + `touchstart`
+ * on `document`, so it fires before the element's own handlers. Use `defer: true`
+ * (the default) to skip the listener installation for one tick, preventing the same
+ * click that opened the element from immediately closing it.
+ *
+ * @param el - The floating element. Clicks inside it will NOT trigger dismiss.
+ * @param onDismiss - Callback invoked when a dismiss condition is met.
+ * @param options - Configuration options.
+ * @returns A {@link DismissHandle} whose {@link DismissHandle.remove} cancels all listeners.
+ */
+export declare function dismissOnClickOutside(el: HTMLElement, onDismiss: () => void, options?: {
+    /** Listen for Escape key (default: true) */
+    escapeKey?: boolean;
+    /** setTimeout(0) guard to avoid instant dismiss from triggering click (default: true) */
+    defer?: boolean;
+    /** Extra elements that should not trigger dismiss */
+    ignoreElements?: HTMLElement[];
+}): DismissHandle;

package/dist/ui/dropdown.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Dropdown widget — a select-like component composing ContextMenu.
+ *
+ * Features:
+ * - Keyboard navigation (Enter/Space/ArrowDown opens; ArrowUp/Down navigates; Enter selects; Escape closes)
+ * - Type-ahead filtering with 500ms buffer reset
+ * - ARIA: role="listbox" on menu, role="option" on items, aria-haspopup/aria-expanded on trigger
+ * - Programmatic value get/set
+ * - dismissOnClickOutside for click-outside handling
+ */
+/** A single item in a {@link Dropdown}. */
+export interface DropdownItem {
+    /** Unique identifier for this item. */
+    id: string;
+    /** Human-readable display name shown in trigger and menu. */
+    label: string;
+    /** Optional secondary description shown below the label. */
+    description?: string;
+    /**
+     * Optional icon: either an HTML string or a render function.
+     * Render functions receive the icon container element.
+     */
+    icon?: string | ((container: HTMLElement) => void);
+    /** Group key — separator inserted between different sections. */
+    section?: string;
+    /** When true, the item is rendered dimmed and cannot be selected. */
+    disabled?: boolean;
+}
+/** Construction options for {@link Dropdown}. */
+export interface DropdownOptions {
+    /** Available items. */
+    items: DropdownItem[];
+    /** Called when an item is selected. */
+    onSelect?: (item: DropdownItem) => void;
+    /** Initially selected item id. */
+    value?: string;
+    /** Placeholder text when nothing selected (default: "Select..."). */
+    placeholder?: string;
+    /** Additional CSS class on the trigger button. */
+    className?: string;
+}
+export declare class Dropdown {
+    private triggerEl;
+    private menu;
+    private currentItems;
+    private selectedId;
+    private onSelectCallback;
+    private placeholder;
+    private dismissHandle;
+    private docKeyHandler;
+    /** Type-ahead state */
+    private typeAheadBuffer;
+    private typeAheadTimer;
+    constructor(options: DropdownOptions);
+    /**
+     * Append trigger button and menu to the given container.
+     * The menu element is appended to the nearest `.blx-editor` ancestor (for
+     * CSS variable inheritance) or document.body as a fallback.
+     * Call before interacting with the dropdown.
+     */
+    attachTo(container: HTMLElement): void;
+    /** Currently selected item id, or null if nothing is selected. */
+    get value(): string | null;
+    /**
+     * Programmatically set the selected item.
+     * Updates trigger label. Does not call onSelect.
+     */
+    setValue(id: string): void;
+    /** Open the dropdown menu. */
+    open(): void;
+    /** Close the dropdown menu and return focus to trigger. */
+    close(): void;
+    /**
+     * Clean up the dropdown: remove trigger from DOM, destroy menu, remove all listeners.
+     */
+    destroy(): void;
+    private updateTriggerLabel;
+    private readonly handleTriggerClick;
+    private readonly handleTriggerKeyDown;
+    private handleTypeAhead;
+}

package/dist/ui/floating-scroll-manager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Manages scroll-aware positioning for all floating UI elements.
+ *
+ * Each floating UI registers when it opens and unregisters when it
+ * closes. A single capture-phase scroll listener handles repositioning,
+ * hiding when the anchor scrolls off-screen, and re-showing when it
+ * scrolls back.
+ */
+/**
+ * Registration record for a floating element managed by {@link FloatingScrollManager}.
+ *
+ * Register when the floating element becomes visible; unregister when it hides.
+ */
+export interface FloatingRegistration {
+    /** Unique key (e.g. "inline-toolbar", "slash-menu") */
+    key: string;
+    /** Element whose viewport visibility determines show/hide */
+    anchorEl: HTMLElement;
+    /** Called on scroll when anchor is in viewport — receives fresh anchor rect */
+    onReposition: (anchorRect: DOMRect) => void;
+    /** Called when anchor scrolls out of viewport */
+    onScrollOut: () => void;
+    /** Called when anchor scrolls back into viewport */
+    onScrollIn: () => void;
+}
+export declare class FloatingScrollManager {
+    private registrations;
+    private scrollHandler;
+    /**
+     * Register a floating element for scroll-aware management.
+     * The element's visibility state is captured immediately; callbacks will fire
+     * on subsequent scroll events.
+     * @param reg - The registration record describing the floating element and its callbacks.
+     */
+    register(reg: FloatingRegistration): void;
+    /**
+     * Unregister a floating element by key.
+     * Removes the global scroll listener when no registrations remain.
+     * @param key - The key used when calling {@link register}.
+     */
+    unregister(key: string): void;
+    /**
+     * Unregister all floating elements and remove the scroll listener.
+     * Call when the editor or owning component is destroyed.
+     */
+    destroy(): void;
+    private ensureScrollListener;
+    private removeScrollListener;
+    private handleScroll;
+}

package/dist/ui/index.d.ts

@@ -0,0 +1,18 @@
+export { positionFixed } from "./position-fixed";
+export type { PositionFixedOptions } from "./position-fixed";
+export { dismissOnClickOutside } from "./dismiss";
+export type { DismissHandle } from "./dismiss";
+export { ContextMenu } from "./context-menu";
+export type { MenuItem, ContextMenuOptions } from "./context-menu";
+export { Popover } from "./popover";
+export type { PopoverOptions } from "./popover";
+export { FloatingScrollManager } from "./floating-scroll-manager";
+export type { FloatingRegistration } from "./floating-scroll-manager";
+export { Tooltip } from "./tooltip";
+export type { TooltipOptions } from "./tooltip";
+export { Toast } from "./toast";
+export type { ToastShowOptions, ToastType } from "./toast";
+export { Modal } from "./modal";
+export type { ModalOptions } from "./modal";
+export { Dropdown } from "./dropdown";
+export type { DropdownOptions, DropdownItem } from "./dropdown";