@tuidom/core 0.1.0

package/dist/dom/compositeElement.d.ts

@@ -0,0 +1,20 @@
+import { BoxConstraints, Size } from "../common/geometryPromitives.js";
+import { TUIElement } from "./tuiElement.js";
+/**
+ * Base class for composite elements that own a single root child built
+ * imperatively in the subclass constructor via {@link setRootChild}.
+ *
+ * The composite fills its constraints, lays the child out tight to the
+ * resulting size and proxies intrinsic dimensions to the child.
+ */
+export declare abstract class CompositeElement extends TUIElement {
+    private rootChild;
+    /** Replace the root child; called once from the subclass constructor. */
+    protected setRootChild(child: TUIElement): void;
+    getRootChild(): TUIElement | null;
+    getMinIntrinsicWidth(height: number): number;
+    getMaxIntrinsicWidth(height: number): number;
+    getMinIntrinsicHeight(width: number): number;
+    getMaxIntrinsicHeight(width: number): number;
+    protected performLayout(constraints: BoxConstraints): Size;
+}

package/dist/dom/compositeElement.js

@@ -0,0 +1,44 @@
+import { BoxConstraints, Size } from "../common/geometryPromitives.js";
+import { TUIElement } from "./tuiElement.js";
+/**
+ * Base class for composite elements that own a single root child built
+ * imperatively in the subclass constructor via {@link setRootChild}.
+ *
+ * The composite fills its constraints, lays the child out tight to the
+ * resulting size and proxies intrinsic dimensions to the child.
+ */
+export class CompositeElement extends TUIElement {
+    rootChild = null;
+    /** Replace the root child; called once from the subclass constructor. */
+    setRootChild(child) {
+        if (this.rootChild) {
+            this.removeChild(this.rootChild);
+        }
+        this.rootChild = child;
+        this.appendChild(child);
+        this.markDirty();
+    }
+    getRootChild() {
+        return this.rootChild;
+    }
+    // ─── Proxy to rootChild ───
+    getMinIntrinsicWidth(height) {
+        return this.rootChild?.getMinIntrinsicWidth(height) ?? 0;
+    }
+    getMaxIntrinsicWidth(height) {
+        return this.rootChild?.getMaxIntrinsicWidth(height) ?? 0;
+    }
+    getMinIntrinsicHeight(width) {
+        return this.rootChild?.getMinIntrinsicHeight(width) ?? 0;
+    }
+    getMaxIntrinsicHeight(width) {
+        return this.rootChild?.getMaxIntrinsicHeight(width) ?? 0;
+    }
+    performLayout(constraints) {
+        const resultSize = super.performLayout(constraints);
+        if (this.rootChild) {
+            this.layoutChild(this.rootChild, 0, 0, BoxConstraints.tight(resultSize));
+        }
+        return resultSize;
+    }
+}

package/dist/dom/events/contextMenuEventSource.d.ts

@@ -0,0 +1,17 @@
+import type { TUIElement } from "../tuiElement.js";
+import type { TUIKeyboardEvent } from "./tuiKeyboardEvent.js";
+import type { TUIMouseEvent } from "./tuiMouseEvent.js";
+import { TUIContextMenuEvent } from "./tuiMouseEvent.js";
+/**
+ * Единственное место, знающее, какой ввод означает «открой контекстное меню»:
+ * правый клик, клавиша ContextMenu (Kitty 57363) и Shift+F10 сливаются в одно
+ * событие "contextmenu" с нормализованным якорем — потребитель не различает,
+ * откуда меню пришло.
+ */
+/** Правый click → contextmenu с якорем-точкой; прочие кнопки — null. */
+export declare function contextMenuEventFromClick(click: TUIMouseEvent): TUIContextMenuEvent | null;
+/**
+ * Keydown ContextMenu / Shift+F10 → contextmenu с якорем-элементом; прочие
+ * клавиши — null. Координаты — глобальная позиция target как fallback.
+ */
+export declare function contextMenuEventFromKeydown(event: TUIKeyboardEvent, target: TUIElement): TUIContextMenuEvent | null;

package/dist/dom/events/contextMenuEventSource.js

@@ -0,0 +1,44 @@
+import { TUIContextMenuEvent } from "./tuiMouseEvent.js";
+/**
+ * Единственное место, знающее, какой ввод означает «открой контекстное меню»:
+ * правый клик, клавиша ContextMenu (Kitty 57363) и Shift+F10 сливаются в одно
+ * событие "contextmenu" с нормализованным якорем — потребитель не различает,
+ * откуда меню пришло.
+ */
+/** Правый click → contextmenu с якорем-точкой; прочие кнопки — null. */
+export function contextMenuEventFromClick(click) {
+    if (click.button !== "right")
+        return null;
+    return new TUIContextMenuEvent({
+        trigger: "mouse",
+        button: click.button,
+        screenX: click.screenX,
+        screenY: click.screenY,
+        localX: click.localX,
+        localY: click.localY,
+        shiftKey: click.shiftKey,
+        altKey: click.altKey,
+        ctrlKey: click.ctrlKey,
+    });
+}
+/**
+ * Keydown ContextMenu / Shift+F10 → contextmenu с якорем-элементом; прочие
+ * клавиши — null. Координаты — глобальная позиция target как fallback.
+ */
+export function contextMenuEventFromKeydown(event, target) {
+    if (event.ctrlKey || event.altKey || event.metaKey)
+        return null;
+    const isContextMenuKey = event.key === "ContextMenu";
+    const isShiftF10 = event.key === "F10" && event.shiftKey;
+    if (!isContextMenuKey && !isShiftF10)
+        return null;
+    return new TUIContextMenuEvent({
+        trigger: "keyboard",
+        button: "none",
+        screenX: target.globalPosition.x,
+        screenY: target.globalPosition.y,
+        localX: 0,
+        localY: 0,
+        shiftKey: event.shiftKey,
+    });
+}

package/dist/dom/events/focusManager.d.ts

@@ -0,0 +1,13 @@
+import type { TUIElement } from "../tuiElement.js";
+export declare class FocusManager {
+    activeElement: TUIElement | null;
+    private rootElement;
+    private focusScopeStack;
+    constructor(rootElement: TUIElement);
+    /** Ограничить Tab-навигацию поддеревом `element` (модальные оверлеи). */
+    pushFocusScope(element: TUIElement): void;
+    /** Снять ранее установленный focus-scope. Удаляет по идентичности — устойчиво к не-LIFO снятию. */
+    popFocusScope(element: TUIElement): void;
+    setFocus(element: TUIElement | null): void;
+    cycleFocus(direction: "forward" | "backward"): void;
+}

package/dist/dom/events/focusManager.js

@@ -0,0 +1,56 @@
+import { TUIFocusEvent } from "./tuiFocusEvent.js";
+export class FocusManager {
+    activeElement = null;
+    rootElement;
+    focusScopeStack = [];
+    constructor(rootElement) {
+        this.rootElement = rootElement;
+    }
+    /** Ограничить Tab-навигацию поддеревом `element` (модальные оверлеи). */
+    pushFocusScope(element) {
+        this.focusScopeStack.push(element);
+    }
+    /** Снять ранее установленный focus-scope. Удаляет по идентичности — устойчиво к не-LIFO снятию. */
+    popFocusScope(element) {
+        const index = this.focusScopeStack.lastIndexOf(element);
+        if (index !== -1) {
+            this.focusScopeStack.splice(index, 1);
+        }
+    }
+    setFocus(element) {
+        if (element === this.activeElement)
+            return;
+        const oldElement = this.activeElement;
+        if (oldElement) {
+            // Состояние стиля — ДО события: blur-слушатели видят его снятым.
+            oldElement.setStyleState("focus", false);
+            const blurEvent = new TUIFocusEvent("blur", element);
+            this.activeElement = null;
+            oldElement.dispatchEvent(blurEvent);
+        }
+        this.activeElement = element;
+        if (element) {
+            // Только target (как :focus в CSS); потомкам доступен селектор
+            // "in:focus", предок при нужде слушает focus/blur в bubble-фазе.
+            element.setStyleState("focus", true);
+            const focusEvent = new TUIFocusEvent("focus", oldElement);
+            element.dispatchEvent(focusEvent);
+        }
+    }
+    cycleFocus(direction) {
+        const scope = this.focusScopeStack[this.focusScopeStack.length - 1] ?? this.rootElement;
+        const focusable = scope.getDepthFirstFocusableOrder();
+        if (focusable.length === 0)
+            return;
+        const currentIndex = this.activeElement ? focusable.indexOf(this.activeElement) : -1;
+        let nextIndex;
+        if (direction === "forward") {
+            nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % focusable.length;
+        }
+        else {
+            nextIndex =
+                currentIndex === -1 ? focusable.length - 1 : (currentIndex - 1 + focusable.length) % focusable.length;
+        }
+        this.setFocus(focusable[nextIndex]);
+    }
+}

package/dist/dom/events/mouseEventDispatcher.d.ts

@@ -0,0 +1,24 @@
+import type { MouseToken } from "../../input/rawTerminalToken.js";
+import type { TUIElement } from "../tuiElement.js";
+export declare class MouseEventDispatcher {
+    private hoveredElement;
+    private pressedElement;
+    private pressedButton;
+    private lastClickTime;
+    private lastClickTarget;
+    private lastClickPosition;
+    private lastPosition;
+    private now;
+    constructor(now?: () => number);
+    handleMouseToken(token: MouseToken, root: TUIElement): void;
+    private handlePress;
+    private isCapturing;
+    private handleRelease;
+    private handleMove;
+    private handleScroll;
+    private dispatchEnterLeave;
+    private getAncestorList;
+    private getAncestorSet;
+    private dispatchOn;
+    private buildInit;
+}

package/dist/dom/events/mouseEventDispatcher.js

@@ -0,0 +1,177 @@
+import { Point } from "../../common/geometryPromitives.js";
+import { contextMenuEventFromClick } from "./contextMenuEventSource.js";
+import { TUIMouseEvent } from "./tuiMouseEvent.js";
+const DOUBLE_CLICK_THRESHOLD = 300;
+export class MouseEventDispatcher {
+    hoveredElement = null;
+    pressedElement = null;
+    pressedButton = null;
+    lastClickTime = 0;
+    lastClickTarget = null;
+    lastClickPosition = null;
+    lastPosition = null;
+    now;
+    constructor(now) {
+        this.now = now ?? (() => Date.now());
+    }
+    handleMouseToken(token, root) {
+        const screenX = token.x - 1;
+        const screenY = token.y - 1;
+        const point = new Point(screenX, screenY);
+        const target = root.elementFromPoint(point);
+        switch (token.action) {
+            case "press":
+                this.handlePress(target, token, screenX, screenY);
+                break;
+            case "release":
+                this.handleRelease(target, token, screenX, screenY);
+                break;
+            case "move":
+                this.handleMove(target, token, screenX, screenY);
+                break;
+            case "scroll-up":
+            case "scroll-down":
+            case "scroll-left":
+            case "scroll-right":
+                this.handleScroll(target, token, screenX, screenY);
+                break;
+        }
+        this.lastPosition = point;
+    }
+    handlePress(target, token, screenX, screenY) {
+        if (!target)
+            return;
+        this.pressedElement = target;
+        this.pressedButton = token.button;
+        this.dispatchOn(target, "mousedown", token, screenX, screenY);
+    }
+    // True while a button is held on an element that opted into pointer capture.
+    isCapturing() {
+        return (this.pressedElement?.capturesPointer === true &&
+            this.pressedButton !== null &&
+            this.pressedButton !== "none");
+    }
+    handleRelease(target, token, screenX, screenY) {
+        // While capturing, the release belongs to the captor regardless of what's under the cursor.
+        const effectiveTarget = this.isCapturing() ? this.pressedElement : target;
+        if (!effectiveTarget)
+            return;
+        this.dispatchOn(effectiveTarget, "mouseup", token, screenX, screenY);
+        if (this.pressedElement === effectiveTarget && this.pressedButton === token.button) {
+            const clickEvent = new TUIMouseEvent("click", this.buildInit(effectiveTarget, token, screenX, screenY));
+            effectiveTarget.dispatchEvent(clickEvent);
+            const contextMenuEvent = contextMenuEventFromClick(clickEvent);
+            if (contextMenuEvent) {
+                effectiveTarget.dispatchEvent(contextMenuEvent);
+            }
+            // A double click is two clicks on the same cell, not merely on the same
+            // element: clicking two different words of one editor in quick succession
+            // must stay two single clicks.
+            const now = this.now();
+            const samePosition = this.lastClickPosition !== null &&
+                this.lastClickPosition.x === screenX &&
+                this.lastClickPosition.y === screenY;
+            if (this.lastClickTarget === effectiveTarget &&
+                samePosition &&
+                now - this.lastClickTime < DOUBLE_CLICK_THRESHOLD) {
+                this.dispatchOn(effectiveTarget, "dblclick", token, screenX, screenY);
+                this.lastClickTarget = null;
+                this.lastClickPosition = null;
+                this.lastClickTime = 0;
+            }
+            else {
+                this.lastClickTarget = effectiveTarget;
+                this.lastClickPosition = new Point(screenX, screenY);
+                this.lastClickTime = now;
+            }
+        }
+        this.pressedElement = null;
+        this.pressedButton = null;
+    }
+    handleMove(target, token, screenX, screenY) {
+        // While capturing, route moves straight to the captor and suppress enter/leave so
+        // elements under the cursor (editor, tree rows) don't flicker hover state mid-drag.
+        if (this.isCapturing() && this.pressedElement) {
+            this.dispatchOn(this.pressedElement, "mousemove", token, screenX, screenY);
+            return;
+        }
+        const oldHovered = this.hoveredElement;
+        const newHovered = target;
+        if (oldHovered !== newHovered) {
+            this.dispatchEnterLeave(oldHovered, newHovered, token, screenX, screenY);
+            this.hoveredElement = newHovered;
+        }
+        if (newHovered) {
+            this.dispatchOn(newHovered, "mousemove", token, screenX, screenY);
+        }
+    }
+    handleScroll(target, token, screenX, screenY) {
+        if (!target)
+            return;
+        const directionMap = {
+            "scroll-up": "up",
+            "scroll-down": "down",
+            "scroll-left": "left",
+            "scroll-right": "right",
+        };
+        const init = this.buildInit(target, token, screenX, screenY);
+        init.wheelDirection = directionMap[token.action];
+        const event = new TUIMouseEvent("wheel", init);
+        target.dispatchEvent(event);
+    }
+    dispatchEnterLeave(oldElement, newElement, token, screenX, screenY) {
+        const oldPath = oldElement ? this.getAncestorSet(oldElement) : new Set();
+        const newPath = newElement ? this.getAncestorSet(newElement) : new Set();
+        // mouseleave: from old element up to (but not including) common ancestors
+        if (oldElement) {
+            const leaveElements = this.getAncestorList(oldElement).filter((el) => !newPath.has(el));
+            for (const el of leaveElements) {
+                // hover-состояние — ДО события: слушатели mouseleave видят его
+                // снятым (как в DOM). Общий предок в diff не входит — не мигает.
+                el.setStyleState("hover", false);
+                this.dispatchOn(el, "mouseleave", token, screenX, screenY);
+            }
+        }
+        // mouseenter: from common ancestor down to new element
+        if (newElement) {
+            const enterElements = this.getAncestorList(newElement)
+                .filter((el) => !oldPath.has(el))
+                .reverse();
+            for (const el of enterElements) {
+                // hover стоит на всей цепочке target→root, как :hover в CSS.
+                el.setStyleState("hover", true);
+                this.dispatchOn(el, "mouseenter", token, screenX, screenY);
+            }
+        }
+    }
+    getAncestorList(element) {
+        // Returns path from element up to root (element first, root last)
+        const path = [];
+        let current = element;
+        while (current !== null) {
+            path.push(current);
+            current = current.getParent();
+        }
+        return path;
+    }
+    getAncestorSet(element) {
+        return new Set(this.getAncestorList(element));
+    }
+    dispatchOn(target, type, token, screenX, screenY) {
+        const init = this.buildInit(target, token, screenX, screenY);
+        const event = new TUIMouseEvent(type, init);
+        target.dispatchEvent(event);
+    }
+    buildInit(target, token, screenX, screenY) {
+        return {
+            button: token.button,
+            screenX,
+            screenY,
+            localX: screenX - target.globalPosition.x,
+            localY: screenY - target.globalPosition.y,
+            shiftKey: token.shiftKey,
+            altKey: token.altKey,
+            ctrlKey: token.ctrlKey,
+        };
+    }
+}

package/dist/dom/events/tuiEventBase.d.ts

@@ -0,0 +1,25 @@
+import type { TUIElement } from "../tuiElement.js";
+export declare const EventPhase: {
+    readonly NONE: 0;
+    readonly CAPTURING: 1;
+    readonly AT_TARGET: 2;
+    readonly BUBBLING: 3;
+};
+export type EventPhase = (typeof EventPhase)[keyof typeof EventPhase];
+export declare class TUIEventBase {
+    readonly type: string;
+    readonly bubbles: boolean;
+    target: TUIElement | null;
+    currentTarget: TUIElement | null;
+    eventPhase: EventPhase;
+    private _propagationStopped;
+    private _immediatePropagationStopped;
+    private _defaultPrevented;
+    constructor(type: string, bubbles?: boolean);
+    stopPropagation(): void;
+    get propagationStopped(): boolean;
+    stopImmediatePropagation(): void;
+    get immediatePropagationStopped(): boolean;
+    preventDefault(): void;
+    get defaultPrevented(): boolean;
+}

package/dist/dom/events/tuiEventBase.js

@@ -0,0 +1,39 @@
+export const EventPhase = {
+    NONE: 0,
+    CAPTURING: 1,
+    AT_TARGET: 2,
+    BUBBLING: 3,
+};
+export class TUIEventBase {
+    type;
+    bubbles;
+    target = null;
+    currentTarget = null;
+    eventPhase = EventPhase.NONE;
+    _propagationStopped = false;
+    _immediatePropagationStopped = false;
+    _defaultPrevented = false;
+    constructor(type, bubbles = true) {
+        this.type = type;
+        this.bubbles = bubbles;
+    }
+    stopPropagation() {
+        this._propagationStopped = true;
+    }
+    get propagationStopped() {
+        return this._propagationStopped;
+    }
+    stopImmediatePropagation() {
+        this._propagationStopped = true;
+        this._immediatePropagationStopped = true;
+    }
+    get immediatePropagationStopped() {
+        return this._immediatePropagationStopped;
+    }
+    preventDefault() {
+        this._defaultPrevented = true;
+    }
+    get defaultPrevented() {
+        return this._defaultPrevented;
+    }
+}

package/dist/dom/events/tuiFocusEvent.d.ts

@@ -0,0 +1,6 @@
+import type { TUIElement } from "../tuiElement.js";
+import { TUIEventBase } from "./tuiEventBase.js";
+export declare class TUIFocusEvent extends TUIEventBase {
+    readonly relatedTarget: TUIElement | null;
+    constructor(type: "focus" | "blur", relatedTarget?: TUIElement | null);
+}

package/dist/dom/events/tuiFocusEvent.js

@@ -0,0 +1,8 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+export class TUIFocusEvent extends TUIEventBase {
+    relatedTarget;
+    constructor(type, relatedTarget = null) {
+        super(type, true);
+        this.relatedTarget = relatedTarget;
+    }
+}

package/dist/dom/events/tuiKeyboardEvent.d.ts

@@ -0,0 +1,21 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+export interface TUIKeyboardEventInit {
+    key: string;
+    code?: string;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    raw?: string;
+    bubbles?: boolean;
+}
+export declare class TUIKeyboardEvent extends TUIEventBase {
+    readonly key: string;
+    readonly code: string;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly metaKey: boolean;
+    readonly raw: string;
+    constructor(type: "keypress" | "keydown" | "keyup", init: TUIKeyboardEventInit);
+}

package/dist/dom/events/tuiKeyboardEvent.js

@@ -0,0 +1,20 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+export class TUIKeyboardEvent extends TUIEventBase {
+    key;
+    code;
+    ctrlKey;
+    shiftKey;
+    altKey;
+    metaKey;
+    raw;
+    constructor(type, init) {
+        super(type, init.bubbles ?? true);
+        this.key = init.key;
+        this.code = init.code ?? "";
+        this.ctrlKey = init.ctrlKey ?? false;
+        this.shiftKey = init.shiftKey ?? false;
+        this.altKey = init.altKey ?? false;
+        this.metaKey = init.metaKey ?? false;
+        this.raw = init.raw ?? "";
+    }
+}

package/dist/dom/events/tuiMouseEvent.d.ts

@@ -0,0 +1,40 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+export type TUIMouseEventType = "mousedown" | "mouseup" | "mousemove" | "click" | "dblclick" | "mouseenter" | "mouseleave" | "wheel" | "contextmenu";
+export type WheelDirection = "up" | "down" | "left" | "right";
+export interface TUIMouseEventInit {
+    button: "left" | "middle" | "right" | "none";
+    screenX: number;
+    screenY: number;
+    localX: number;
+    localY: number;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    wheelDirection?: WheelDirection;
+}
+export declare class TUIMouseEvent extends TUIEventBase {
+    readonly button: "left" | "middle" | "right" | "none";
+    readonly screenX: number;
+    readonly screenY: number;
+    readonly localX: number;
+    readonly localY: number;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly wheelDirection: WheelDirection | undefined;
+    constructor(type: TUIMouseEventType, init: TUIMouseEventInit);
+}
+/**
+ * Откуда пришёл запрос контекстного меню. Определяет трактовку якоря:
+ * "mouse" — точка клика (screenX/screenY), "keyboard" — сам target
+ * (координаты заполнены его глобальной позицией как fallback; потребитель
+ * уточняет якорь — каретка, выделенная строка).
+ */
+export type ContextMenuTrigger = "mouse" | "keyboard";
+export interface TUIContextMenuEventInit extends TUIMouseEventInit {
+    trigger: ContextMenuTrigger;
+}
+export declare class TUIContextMenuEvent extends TUIMouseEvent {
+    readonly trigger: ContextMenuTrigger;
+    constructor(init: TUIContextMenuEventInit);
+}

package/dist/dom/events/tuiMouseEvent.js

@@ -0,0 +1,32 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+const NON_BUBBLING_TYPES = new Set(["mouseenter", "mouseleave"]);
+export class TUIMouseEvent extends TUIEventBase {
+    button;
+    screenX;
+    screenY;
+    localX;
+    localY;
+    shiftKey;
+    altKey;
+    ctrlKey;
+    wheelDirection;
+    constructor(type, init) {
+        super(type, !NON_BUBBLING_TYPES.has(type));
+        this.button = init.button;
+        this.screenX = init.screenX;
+        this.screenY = init.screenY;
+        this.localX = init.localX;
+        this.localY = init.localY;
+        this.shiftKey = init.shiftKey ?? false;
+        this.altKey = init.altKey ?? false;
+        this.ctrlKey = init.ctrlKey ?? false;
+        this.wheelDirection = init.wheelDirection;
+    }
+}
+export class TUIContextMenuEvent extends TUIMouseEvent {
+    trigger;
+    constructor(init) {
+        super("contextmenu", init);
+        this.trigger = init.trigger;
+    }
+}

package/dist/dom/events/tuiPasteEvent.d.ts

@@ -0,0 +1,10 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+/**
+ * Bracketed-paste event: the terminal delivered a clipboard paste as one literal
+ * text block. Dispatched to the focused element so it can insert the whole text in
+ * a single edit (newlines preserved), instead of replaying it as keystrokes.
+ */
+export declare class TUIPasteEvent extends TUIEventBase {
+    readonly text: string;
+    constructor(text: string, bubbles?: boolean);
+}

package/dist/dom/events/tuiPasteEvent.js

@@ -0,0 +1,13 @@
+import { TUIEventBase } from "./tuiEventBase.js";
+/**
+ * Bracketed-paste event: the terminal delivered a clipboard paste as one literal
+ * text block. Dispatched to the focused element so it can insert the whole text in
+ * a single edit (newlines preserved), instead of replaying it as keystrokes.
+ */
+export class TUIPasteEvent extends TUIEventBase {
+    text;
+    constructor(text, bubbles = true) {
+        super("paste", bubbles);
+        this.text = text;
+    }
+}