@rcarls/rc-textarea 0.1.0

package/dist/types/packages/rc-textarea/src/blots.d.ts

@@ -0,0 +1,39 @@
+import { Registry, ScrollBlot, BlockBlot, InlineBlot, EmbedBlot } from 'parchment';
+import { MarkDecoration } from './types.ts';
+export { Registry };
+export declare class V2ScrollBlot extends ScrollBlot {
+    static blotName: string;
+    constructor(registry: Registry, domNode: HTMLDivElement);
+    update(_mutations: MutationRecord[], _context: Record<string, unknown>): void;
+    optimize(context: {
+        [key: string]: unknown;
+    }): void;
+    optimize(mutations: MutationRecord[], context: {
+        [key: string]: unknown;
+    }): void;
+}
+export declare class V2BlockBlot extends BlockBlot {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+}
+type InlineFormats = Pick<MarkDecoration, 'className' | 'bold' | 'italic' | 'color' | 'background' | 'underline' | 'underlineColor'>;
+export declare class V2InlineBlot extends InlineBlot {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    static create(formats?: InlineFormats): HTMLElement;
+}
+/**
+ * Apply `MarkDecoration` style properties to a `.v2-mark` span element as
+ * inline styles and extra CSS classes. Called by `V2InlineBlot.create()` and
+ * by external code that needs to style a span to match a decoration.
+ */
+export declare function applyInlineFormats(el: HTMLSpanElement, formats: InlineFormats): void;
+export declare class V2WidgetBlot extends EmbedBlot {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    static create(): HTMLElement;
+}
+export declare function createRegistry(): Registry;

package/dist/types/packages/rc-textarea/src/decoration.d.ts

@@ -0,0 +1,65 @@
+import { Decoration, MarkDecoration, LineDecoration, DecorationInput } from './types.ts';
+export { generateId } from './types.ts';
+/**
+ * The minimal description of a single contiguous edit:
+ * a deletion of `removed` characters at `start`, followed by an insertion of
+ * `inserted` characters at that same position.
+ */
+interface Edit {
+    /** Character offset where the edit begins (inclusive). */
+    start: number;
+    /** Number of characters removed. */
+    removed: number;
+    /** Number of characters inserted. */
+    inserted: number;
+}
+/**
+ * Find the single contiguous edit region that transforms `oldValue` into
+ * `newValue` by trimming equal prefix and suffix.
+ *
+ * This is a heuristic ("longest common prefix/suffix"), not a full LCS diff.
+ * It assumes the browser makes one contiguous edit per input event, which holds
+ * true for normal typing, deletion, and paste.
+ */
+export declare function findEdit(oldValue: string, newValue: string): Edit;
+/**
+ * Remap all decorations in `decorations` from positions in `oldValue` to
+ * positions in `newValue`, assuming a single contiguous edit.
+ *
+ * - `MarkDecoration`: remapped via `remapMarkRange`; dropped if collapsed.
+ * - `LineDecoration`: dropped if its line falls within the deleted region;
+ *   otherwise shifted by the line delta.
+ * - `WidgetDecoration`: treated like a zero-width mark at its offset.
+ *
+ * Returns a new array. The input array and its elements are not mutated.
+ */
+export declare function mapDecorationsThroughChange(decorations: Decoration[], oldValue: string, newValue: string): Decoration[];
+/**
+ * Heuristic: returns `true` when an edit is large enough that remapping
+ * decorations would likely produce incorrect results and it's better to
+ * clear them entirely.
+ *
+ * Threshold: the change affects > 50 characters **and** > 50% of the document.
+ * This covers paste of large blocks, select-all + type, and programmatic value
+ * sets with substantially different content. It deliberately ignores inserts
+ * into an empty document (no existing decorations to preserve).
+ */
+export declare function isLargeChange(oldValue: string, edit: Edit): boolean;
+/**
+ * Map decorations through a text change, or clear them entirely if the change
+ * is classified as "large" (see `isLargeChange`).
+ *
+ * This is the primary entry point used by the component on each input event.
+ */
+export declare function mapOrClear(decorations: Decoration[], oldValue: string, newValue: string): Decoration[];
+/**
+ * Add a single decoration to `map`, assigning it a fresh UUID as its `id`.
+ * Returns the assigned ID.
+ */
+export declare function addDecoration(map: Map<string, Decoration>, input: DecorationInput): string;
+/**
+ * Replace all decorations in `map` with a new set derived from `inputs`.
+ * Each input is assigned a fresh UUID.
+ */
+export declare function setDecorations(map: Map<string, Decoration>, inputs: DecorationInput[]): void;
+export type { MarkDecoration, LineDecoration };

package/dist/types/packages/rc-textarea/src/decoration.test.d.ts

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

package/dist/types/packages/rc-textarea/src/define.d.ts

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/types/packages/rc-textarea/src/document.d.ts

@@ -0,0 +1,19 @@
+import { Decoration } from './types.ts';
+export declare class V2Document {
+    private readonly scroll;
+    constructor(editorEl: HTMLDivElement);
+    /**
+     * Rebuild the document tree from `value` + `decorations`.
+     * Reuses existing `.v2-line` elements in place to preserve DOM identity
+     * across renders (fixes DevTools node tracking and mouse gesture continuity).
+     * Only the children of each line are replaced; the line element itself survives.
+     */
+    build(value: string, decorations: Decoration[]): void;
+    destroy(): void;
+}
+/**
+ * Extracts plain text directly from the editor's contenteditable DOM.
+ * Handles our structured .v2-line divs as well as browser-inserted markup
+ * from edits that happen between render frames.
+ */
+export declare function extractEditorText(editorEl: HTMLElement): string;

package/dist/types/packages/rc-textarea/src/index.d.ts

@@ -0,0 +1,7 @@
+export { RCTextarea } from './rc-textarea.ts';
+export type { Decoration, DecorationInput, MarkDecoration, MarkDecorationStyle, LineDecoration, WidgetDecoration, RCTextareaPlugin, RCTextareaPluginAPI, TextPattern, LineDecoratorPlugin, Token, } from './types.ts';
+export { matchPatternResults } from './pattern-matcher.ts';
+export { createLineDecoratorPlugin } from './line-decorator.ts';
+export type { LineDecoratorPluginOptions } from './line-decorator.ts';
+export { LineActionsController } from './line-actions-controller.ts';
+export type { LineAction, LineActionsOptions } from './line-actions-controller.ts';

package/dist/types/packages/rc-textarea/src/line-actions-controller.d.ts

@@ -0,0 +1,91 @@
+import { RCTextareaPluginAPI, DecorationInput } from './types.ts';
+export interface LineAction {
+    id: string;
+    label: string;
+    /** data-icon attribute — host renders via iconify or similar */
+    icon?: string;
+    onClick: () => void;
+}
+export interface LineActionsOptions {
+    /** Where to place the inline widget. Default: 'append'. */
+    position?: 'append';
+    /**
+     * Create and return a DOM element for the given icon name (e.g. 'mdi-lock-outline').
+     * Called when `action.icon` is set. Return `null` to fall back to text label.
+     *
+     * @example — iconify web component
+     * ```ts
+     * createIcon: (name) => {
+     *   const el = document.createElement('iconify-icon');
+     *   el.setAttribute('icon', name);
+     *   return el;
+     * }
+     * ```
+     */
+    createIcon?: (iconName: string) => HTMLElement | null;
+    /**
+     * Full control over button content. Called instead of the default icon/label
+     * logic. Use `createIcon` when you only need to swap the icon renderer —
+     * `renderButton` is for cases that require full button customisation.
+     */
+    renderButton?: (action: LineAction, btn: HTMLButtonElement) => void;
+}
+/**
+ * Helper class for plugins that need to show inline action buttons next to a
+ * line, or a floating popover panel anchored to the active line.
+ *
+ * Instantiate in `mount()`, call `getDecorations()` / `getDecorationsForLines()`
+ * from `update()`, and call `destroy()` from the plugin's `destroy()`.
+ *
+ * @example
+ * ```ts
+ * editor.usePlugin({
+ *   mount(api) {
+ *     this._controller = new LineActionsController(api);
+ *   },
+ *   update(value, api) {
+ *     const lineIndex = LineActionsController.getActiveLineIndex(value, api.selectionStart);
+ *     const decs = this._controller.getDecorations(lineIndex, myActions, value, 'inline');
+ *     api.setDecorations(decs);
+ *   },
+ *   destroy() { this._controller.destroy(); },
+ * });
+ * ```
+ */
+export declare class LineActionsController {
+    private readonly _api;
+    private readonly _options;
+    private _popover;
+    private _lastActionsKey;
+    private readonly _blurHandler;
+    constructor(api: RCTextareaPluginAPI, options?: LineActionsOptions);
+    /**
+     * Call from plugin's `update()`. Pass the line index, its actions, the full
+     * value, and the current render mode.
+     *
+     * - `'inline'`: returns a `WidgetDecoration[]` to merge into `setDecorations()`.
+     * - `'popover'`: returns `[]` and manages a floating panel as a side effect.
+     *
+     * Passing an empty actions array hides the popover and returns `[]`.
+     */
+    getDecorations(lineIndex: number, actions: LineAction[], value: string, renderMode: 'inline' | 'popover'): DecorationInput[];
+    /**
+     * Variant for `showOn: 'always'` — one entry per line with actions.
+     *
+     * In popover mode only the `activeLineIndex` line is shown; in inline mode
+     * every line with non-empty actions gets a widget.
+     */
+    getDecorationsForLines(lineActions: Map<number, LineAction[]>, value: string, renderMode: 'inline' | 'popover', activeLineIndex?: number): DecorationInput[];
+    /** Remove the floating panel and detach all listeners. Call from plugin `destroy()`. */
+    destroy(): void;
+    /** Derive the 0-based line index from a plain-text character offset. */
+    static getActiveLineIndex(value: string, selectionStart: number): number;
+    /**
+     * Character offset of the end of the given 0-based line (points at the
+     * newline character, or end-of-string for the last line).
+     */
+    private static _lineEndOffset;
+    private _showPopover;
+    private _positionPopover;
+    private _hidePopover;
+}

package/dist/types/packages/rc-textarea/src/line-decorator.d.ts

@@ -0,0 +1,57 @@
+import { DecorationInput, LineDecoratorPlugin, RCTextareaPlugin } from './types.ts';
+/**
+ * Options for `createLineDecoratorPlugin`.
+ */
+export interface LineDecoratorPluginOptions {
+    /**
+     * An array of subscriber setup functions. Each function receives a callback
+     * and should call it whenever an external value changes (e.g. a reactive
+     * signal). It may return an optional cleanup/unsubscribe function called on
+     * plugin destroy.
+     *
+     * This is intentionally framework-agnostic. For Solid.js signals:
+     * ```ts
+     * watch: [
+     *   (cb) => createEffect(on(mySignal, cb, { defer: true })),
+     * ]
+     * ```
+     */
+    watch?: Array<(onChange: () => void) => (() => void) | void>;
+    /**
+     * Called once per update pass **after** all per-line decorations are built.
+     * Use this to merge in decorations that require the full document value
+     * (e.g. diagnostics from a whole-document parser).
+     */
+    extraDecorations?: (value: string) => DecorationInput[];
+}
+/**
+ * Factory that wraps a `LineDecoratorPlugin` in a full `RCTextareaPlugin`.
+ *
+ * Handles the boilerplate that every per-line decorator needs:
+ * - CSS injection via `api.adoptStyleSheet` on mount
+ * - `lineStart` offset bookkeeping when converting line-relative offsets to
+ *   absolute document offsets
+ * - Subscribing to external change signals and calling `api.scheduleUpdate()`
+ * - Cleanup of subscribers on destroy
+ *
+ * @example
+ * ```ts
+ * const plugin = createLineDecoratorPlugin(
+ *   {
+ *     styles: '.kw { font-weight: bold; }',
+ *     decorateLine(line) {
+ *       const results: ReturnType<LineDecoratorPlugin['decorateLine']> = [];
+ *       for (const m of line.matchAll(/\bfunction\b/g)) {
+ *         results.push({ type: 'mark', from: m.index!, to: m.index! + m[0].length, className: 'kw' });
+ *       }
+ *       return results;
+ *     },
+ *   },
+ *   {
+ *     extraDecorations: (value) => getDiagnosticDecorations(value),
+ *   },
+ * );
+ * editor.usePlugin(plugin);
+ * ```
+ */
+export declare function createLineDecoratorPlugin(decorator: LineDecoratorPlugin, options?: LineDecoratorPluginOptions): RCTextareaPlugin;

package/dist/types/packages/rc-textarea/src/line-decorator.test.d.ts

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

package/dist/types/packages/rc-textarea/src/pattern-matcher.d.ts

@@ -0,0 +1,23 @@
+import { TextPattern, MarkDecoration, LineDecoration } from './types.ts';
+export type { TextPattern };
+/**
+ * Run all `patterns` against `value` and collect every match as decorations.
+ *
+ * For each pattern:
+ * - If `captureGroups` is set, one `MarkDecoration` is emitted **per named
+ *   capture group** instead of one for the whole match. Unmatched optional
+ *   groups are silently skipped. The `d` flag (match indices) is added to
+ *   the regex automatically.
+ * - Otherwise, one `MarkDecoration` covering the entire match is emitted,
+ *   using the styling fields copied directly from the pattern.
+ * - If `createLineDecoration` is provided, it is called for every match
+ *   (regardless of `captureGroups`) and may produce a paired `LineDecoration`.
+ *
+ * The global flag is added automatically if missing to ensure all occurrences
+ * are found and to avoid stateful `lastIndex` bugs on the caller's regex.
+ * Zero-length matches are skipped to prevent infinite loops.
+ */
+export declare function matchPatternResults(value: string, patterns: TextPattern[]): {
+    markDecorations: Omit<MarkDecoration, 'id'>[];
+    lineDecorations: Omit<LineDecoration, 'id'>[];
+};

package/dist/types/packages/rc-textarea/src/pattern-matcher.test.d.ts

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

package/dist/types/packages/rc-textarea/src/rc-textarea.d.ts

@@ -0,0 +1,194 @@
+import { LitElement, CSSResultGroup } from 'lit';
+import { SavedSelection } from './selection.ts';
+import { Decoration, DecorationInput, RCTextareaPlugin, RCTextareaPluginAPI, TextPattern } from './types.ts';
+/**
+ * Enhanced textarea with line decorations, gutter, and plugin API.
+ *
+ * @slot - Accepts a native `<textarea>` element for form wiring and progressive enhancement.
+ * @fires rc-textarea-change - Fired when the editor value changes
+ * @fires rc-textarea-blur - Fired when the editor loses focus
+ * @cssprop [--rc-textarea-border=1px solid ButtonBorder] - Border around the editor
+ * @cssprop [--rc-textarea-border-radius=2px] - Border radius of the editor
+ * @cssprop [--rc-textarea-background=Field] - Background color of the editor
+ * @cssprop [--rc-textarea-color=FieldText] - Text color; falls back through --rc-text
+ * @cssprop [--rc-textarea-font-family=monospace] - Font family
+ * @cssprop [--rc-textarea-font-size=1em] - Font size
+ * @cssprop [--rc-textarea-line-height=1.5] - Line height
+ * @cssprop [--rc-textarea-padding=0.5em] - Padding inside the editor area
+ * @cssprop [--rc-textarea-focus-outline=2px solid Highlight] - Focus ring outline
+ * @cssprop [--rc-textarea-caret-color=FieldText] - Caret color
+ * @cssprop [--rc-textarea-active-line-bg=transparent] - Active line highlight color
+ * @cssprop [--rc-textarea-gutter-bg=Canvas] - Gutter background color
+ * @cssprop [--rc-textarea-gutter-color=GrayText] - Gutter text color
+ * @cssprop [--rc-textarea-gutter-border=1px solid ButtonBorder] - Gutter right border
+ */
+export declare class RCTextarea extends LitElement {
+    static styles: CSSResultGroup;
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    lineNumbers: boolean;
+    listNumbers: boolean;
+    gutter: boolean;
+    wordWrap: boolean;
+    autoGrow: boolean;
+    readOnly: boolean;
+    label: string | null;
+    /** Declarative plugin hook for framework integrations. */
+    get plugin(): RCTextareaPlugin | null;
+    /** Declarative plugin hook for framework integrations. */
+    set plugin(plugin: RCTextareaPlugin | null);
+    /**
+     * Reactive decorations — set from outside the component without registering a plugin.
+     * Ideal for reactive frameworks (Solid, React 19+, Vue 3) where decorations are
+     * computed as reactive state and passed directly as a property:
+     *
+     * ```tsx
+     * // Solid
+     * <rc-textarea decorations={decorations()} />
+     *
+     * // React 19+
+     * <rc-textarea decorations={decorations} />
+     * ```
+     *
+     * Merges with plugin decorations and pattern decorations on every render.
+     * Setting this property triggers a new render; setting it to `undefined` or `[]`
+     * clears any previously set external decorations.
+     */
+    get decorations(): DecorationInput[];
+    set decorations(value: DecorationInput[] | undefined);
+    private _value;
+    private _defaultValue;
+    private _initialValueResolved;
+    private _valueSetByHost;
+    private _document;
+    private _textareaRef;
+    /** Plugin-owned decorations (set via PluginAPI.setDecorations / addDecoration). */
+    protected _pluginDecorations: Map<string, Decoration>;
+    /** Pattern-generated decorations (rebuilt on each value change). */
+    private _patternDecorations;
+    /** Decorations set directly via the `decorations` property (reactive-framework-friendly). */
+    private _externalDecorations;
+    /** Registered patterns. */
+    private _patterns;
+    protected _plugin: RCTextareaPlugin | null;
+    private _pluginProperty;
+    protected _pluginApi: RCTextareaPluginAPI | null;
+    /** Sequence counter for async plugin safety (discard stale results). */
+    private _pluginSeq;
+    /** Stylesheets adopted into the shadow root by the active plugin. */
+    private _pluginSheets;
+    protected _savedSelection: SavedSelection | null;
+    private _rafHandle;
+    private _composing;
+    private _isRendering;
+    /** The currently highlighted `.v2-line` element (active line). */
+    private _activeLine;
+    /** Callbacks registered via PluginAPI.onCursorMove(). */
+    private _cursorCallbacks;
+    private _docSelectionChangeHandler;
+    /** Undo/redo stack — necessary because DOM rebuilds invalidate browser's native undo. */
+    private _undoStack;
+    private _undoIndex;
+    private _resizeObserver;
+    /** Cached per-line gutter labels from the last render — reused by ResizeObserver. */
+    private _gutterLabels;
+    get value(): string;
+    set value(v: string);
+    /** Initial uncontrolled editor value. */
+    get defaultValue(): string | undefined;
+    /** Initial uncontrolled editor value. */
+    set defaultValue(v: string | undefined);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    updated(changed: Map<string, unknown>): void;
+    render(): import('lit').TemplateResult<1>;
+    private _onSlotChange;
+    private _bindEditorEvents;
+    private _onInputEvent;
+    private _onInput;
+    private _onSelectionChange;
+    private _updateActiveLine;
+    private _updateActiveGutterCell;
+    private _onKeyDown;
+    protected _insertText(text: string): void;
+    /**
+     * Wrap the current selection with `prefix` and `suffix`.
+     * No-op when the selection is collapsed (no text selected).
+     *
+     * Uses the model path directly (not `execCommand`) because callers such as
+     * toolbar buttons move focus away from the editor before this fires, which
+     * clears the DOM selection. `_savedSelection` retains the last model-level
+     * anchor/focus offsets.
+     */
+    wrapSelection(prefix: string, suffix: string): void;
+    /**
+     * Replace the current selection with `text`.
+     * When the selection is collapsed this is equivalent to `insertText`.
+     */
+    replaceSelection(text: string): void;
+    private _onPaste;
+    /** Reset the undo/redo history. Call when the editor receives entirely new content. */
+    clearHistory(): void;
+    protected _pushUndo(sel: SavedSelection | null): void;
+    private _undo;
+    private _redo;
+    private _applyUndoEntry;
+    usePlugin(plugin: RCTextareaPlugin): void;
+    removePlugin(): void;
+    /**
+     * Build the `RCTextareaPluginAPI` object passed to the active plugin's
+     * `mount()` call. Each getter delegates to the component's live state so the
+     * API stays accurate across render frames without needing to be rebuilt.
+     */
+    private _buildPluginApi;
+    private _clearPluginSheets;
+    addPattern(pattern: Omit<TextPattern, 'id'>): string;
+    removePattern(id: string): void;
+    clearPatterns(): void;
+    protected _scheduleRender(): void;
+    private _performRender;
+    /**
+     * Compute the label string for each gutter cell based on the current gutter
+     * mode (`lineNumbers`, `listNumbers`, `gutter`) and any
+     * `LineDecoration.gutterContent` overrides in `allDecorations`.
+     *
+     * Returns one entry per line (same length as `value.split('\n')`):
+     * - `string` — the label to display
+     * - `null`   — render an empty cell
+     */
+    private _computeGutterLabels;
+    /**
+     * Synchronize the pixel height of each gutter cell to match the
+     * corresponding `.v2-line` element in the editor.
+     *
+     * In non-word-wrap mode the gutter uses a uniform `line-height` mirrored
+     * from the editor's first line. In word-wrap mode each cell gets an explicit
+     * `height` so wrapped lines stay vertically aligned with their gutter label.
+     * Also copies the editor's computed `paddingTop`/`paddingBottom` to the
+     * gutter to compensate for browser UA overrides on contenteditable.
+     */
+    private _syncGutterHeights;
+    /**
+     * Add, remove, or update `.gutter-cell` spans so their count and text
+     * content match `labels`. When `labels` is provided the cached
+     * `_gutterLabels` is updated first; otherwise the cached labels are reused
+     * (called by the `ResizeObserver` without a new render pass).
+     */
+    private _syncGutter;
+    private _syncTypography;
+    protected _syncTextareaValue(fromUser?: boolean): void;
+    protected _dispatchChange(value: string): void;
+    private _getEditorEl;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'rc-textarea': RCTextarea;
+    }
+}

package/dist/types/packages/rc-textarea/src/rc-textarea.styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import('lit').CSSResult;

package/dist/types/packages/rc-textarea/src/selection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cursor save/restore for rc-textarea's contenteditable editor.
+ *
+ * The text model is a plain string with \n line separators.
+ * WidgetDecoration spans (.v2-widget) are skipped — they are zero-width in
+ * the text model (not part of the value string).
+ * <br> elements (used to make empty lines editable) count as 0 characters.
+ */
+export interface SavedSelection {
+    /** Anchor position as a character offset into the plain text value. */
+    anchorOffset: number;
+    /** Focus position as a character offset into the plain text value. */
+    focusOffset: number;
+}
+/**
+ * Converts a DOM (node, nodeOffset) pair inside `root` to a plain-text offset.
+ * Returns -1 if the target was not found inside root.
+ */
+export declare function domToTextOffset(root: Element, targetNode: Node, targetNodeOffset: number): number;
+interface DomPosition {
+    node: Node;
+    offset: number;
+}
+/**
+ * Converts a plain-text offset to a (node, nodeOffset) DOM position inside `root`.
+ * Returns null if offset is out of range.
+ */
+export declare function textOffsetToDom(root: Element, targetOffset: number): DomPosition | null;
+/**
+ * Captures the current browser selection as plain-text offsets relative to `root`.
+ * Returns null if there is no selection or the selection is outside `root`.
+ */
+export declare function saveSelection(root: Element): SavedSelection | null;
+/**
+ * Restores a previously saved selection inside `root`.
+ * Silently does nothing if the saved offsets are out of range.
+ */
+export declare function restoreSelection(root: Element, saved: SavedSelection): void;
+export {};

package/dist/types/packages/rc-textarea/src/test-helpers.d.ts

@@ -0,0 +1,18 @@
+import { RCTextarea } from './rc-textarea.ts';
+export declare function getEditor(host: RCTextarea): HTMLDivElement;
+export declare function getGutterCells(host: RCTextarea): HTMLDivElement;
+export declare function getSlottedTextarea(host: RCTextarea): HTMLTextAreaElement;
+/**
+ * Wait one animation frame for _performRender to start, then flush one microtask
+ * tick so that synchronous plugin `update()` calls complete before the test asserts.
+ */
+export declare function waitRender(): Promise<void>;
+/**
+ * Dispatches a synthetic paste event carrying plain text onto `editor`.
+ *
+ * Using a plain Event + manual clipboardData override because `new ClipboardEvent`
+ * with a DataTransfer in the init dict is not reliable across browsers (Firefox
+ * ignores the init's clipboardData). The paste handler only calls
+ * `e.clipboardData?.getData('text/plain')`, so a minimal duck-typed mock is enough.
+ */
+export declare function simulatePaste(editor: HTMLElement, text: string): void;