@depup/testing-library__user-event 14.6.3-depup.0

package/dist/esm/utils/pointer/cssPointerEvents.js

@@ -0,0 +1,99 @@
+import { PointerEventsCheckLevel } from '../../options.js';
+import { getWindow } from '../misc/getWindow.js';
+import { isElementType } from '../misc/isElementType.js';
+import { ApiLevel, getLevelRef } from '../misc/level.js';
+
+function hasPointerEvents(instance, element) {
+    var _checkPointerEvents;
+    return ((_checkPointerEvents = checkPointerEvents(instance, element)) === null || _checkPointerEvents === void 0 ? void 0 : _checkPointerEvents.pointerEvents) !== 'none';
+}
+function closestPointerEventsDeclaration(element) {
+    const window = getWindow(element);
+    for(let el = element, tree = []; el === null || el === void 0 ? void 0 : el.ownerDocument; el = el.parentElement){
+        tree.push(el);
+        const pointerEvents = window.getComputedStyle(el).pointerEvents;
+        if (pointerEvents && ![
+            'inherit',
+            'unset'
+        ].includes(pointerEvents)) {
+            return {
+                pointerEvents,
+                tree
+            };
+        }
+    }
+    return undefined;
+}
+const PointerEventsCheck = Symbol('Last check for pointer-events');
+function checkPointerEvents(instance, element) {
+    const lastCheck = element[PointerEventsCheck];
+    const needsCheck = instance.config.pointerEventsCheck !== PointerEventsCheckLevel.Never && (!lastCheck || hasBitFlag(instance.config.pointerEventsCheck, PointerEventsCheckLevel.EachApiCall) && lastCheck[ApiLevel.Call] !== getLevelRef(instance, ApiLevel.Call) || hasBitFlag(instance.config.pointerEventsCheck, PointerEventsCheckLevel.EachTrigger) && lastCheck[ApiLevel.Trigger] !== getLevelRef(instance, ApiLevel.Trigger));
+    if (!needsCheck) {
+        return lastCheck === null || lastCheck === void 0 ? void 0 : lastCheck.result;
+    }
+    const declaration = closestPointerEventsDeclaration(element);
+    element[PointerEventsCheck] = {
+        [ApiLevel.Call]: getLevelRef(instance, ApiLevel.Call),
+        [ApiLevel.Trigger]: getLevelRef(instance, ApiLevel.Trigger),
+        result: declaration
+    };
+    return declaration;
+}
+function assertPointerEvents(instance, element) {
+    const declaration = checkPointerEvents(instance, element);
+    if ((declaration === null || declaration === void 0 ? void 0 : declaration.pointerEvents) === 'none') {
+        throw new Error([
+            `Unable to perform pointer interaction as the element ${declaration.tree.length > 1 ? 'inherits' : 'has'} \`pointer-events: none\`:`,
+            '',
+            printTree(declaration.tree)
+        ].join('\n'));
+    }
+}
+function printTree(tree) {
+    return tree.reverse().map((el, i)=>[
+            ''.padEnd(i),
+            el.tagName,
+            el.id && `#${el.id}`,
+            el.hasAttribute('data-testid') && `(testId=${el.getAttribute('data-testid')})`,
+            getLabelDescr(el),
+            tree.length > 1 && i === 0 && '  <-- This element declared `pointer-events: none`',
+            tree.length > 1 && i === tree.length - 1 && '  <-- Asserted pointer events here'
+        ].filter(Boolean).join('')).join('\n');
+}
+function getLabelDescr(element) {
+    var _element_labels;
+    let label;
+    if (element.hasAttribute('aria-label')) {
+        label = element.getAttribute('aria-label');
+    } else if (element.hasAttribute('aria-labelledby')) {
+        var _element_ownerDocument_getElementById_textContent, _element_ownerDocument_getElementById;
+        label = (_element_ownerDocument_getElementById = element.ownerDocument.getElementById(element.getAttribute('aria-labelledby'))) === null || _element_ownerDocument_getElementById === void 0 ? void 0 : (_element_ownerDocument_getElementById_textContent = _element_ownerDocument_getElementById.textContent) === null || _element_ownerDocument_getElementById_textContent === void 0 ? void 0 : _element_ownerDocument_getElementById_textContent.trim();
+    } else if (isElementType(element, [
+        'button',
+        'input',
+        'meter',
+        'output',
+        'progress',
+        'select',
+        'textarea'
+    ]) && ((_element_labels = element.labels) === null || _element_labels === void 0 ? void 0 : _element_labels.length)) {
+        label = Array.from(element.labels).map((el)=>{
+            var _el_textContent;
+            return (_el_textContent = el.textContent) === null || _el_textContent === void 0 ? void 0 : _el_textContent.trim();
+        }).join('|');
+    } else if (isElementType(element, 'button')) {
+        var _element_textContent;
+        label = (_element_textContent = element.textContent) === null || _element_textContent === void 0 ? void 0 : _element_textContent.trim();
+    }
+    label = label === null || label === void 0 ? void 0 : label.replace(/\n/g, '  ');
+    if (Number(label === null || label === void 0 ? void 0 : label.length) > 30) {
+        label = `${label === null || label === void 0 ? void 0 : label.substring(0, 29)}…`;
+    }
+    return label ? `(label=${label})` : '';
+}
+// With the eslint rule and prettier the bitwise operation isn't nice to read
+function hasBitFlag(conf, flag) {
+    return (conf & flag) > 0;
+}
+
+export { assertPointerEvents, hasPointerEvents };

package/dist/types/clipboard/copy.d.ts

@@ -0,0 +1,2 @@
+import { type Instance } from '../setup';
+export declare function copy(this: Instance): Promise<DataTransfer | undefined>;

package/dist/types/clipboard/cut.d.ts

@@ -0,0 +1,2 @@
+import { type Instance } from '../setup';
+export declare function cut(this: Instance): Promise<DataTransfer | undefined>;

package/dist/types/clipboard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './copy';
+export * from './cut';
+export * from './paste';

package/dist/types/clipboard/paste.d.ts

@@ -0,0 +1,2 @@
+import { type Instance } from '../setup';
+export declare function paste(this: Instance, clipboardData?: DataTransfer | string): Promise<void>;

package/dist/types/convenience/click.d.ts

@@ -0,0 +1,4 @@
+import { type Instance } from '../setup';
+export declare function click(this: Instance, element: Element): Promise<void>;
+export declare function dblClick(this: Instance, element: Element): Promise<void>;
+export declare function tripleClick(this: Instance, element: Element): Promise<void>;

package/dist/types/convenience/hover.d.ts

@@ -0,0 +1,3 @@
+import { type Instance } from '../setup';
+export declare function hover(this: Instance, element: Element): Promise<void>;
+export declare function unhover(this: Instance, element: Element): Promise<void>;

package/dist/types/convenience/index.d.ts

@@ -0,0 +1,3 @@
+export * from './click';
+export * from './hover';
+export * from './tab';

package/dist/types/convenience/tab.d.ts

@@ -0,0 +1,4 @@
+import { type Instance } from '../setup';
+export declare function tab(this: Instance, { shift, }?: {
+    shift?: boolean;
+}): Promise<void>;

package/dist/types/document/UI.d.ts

@@ -0,0 +1,42 @@
+declare const UIValue: unique symbol;
+declare const UISelection: unique symbol;
+declare const InitialValue: unique symbol;
+declare global {
+    interface Element {
+        [UIValue]?: string;
+        [InitialValue]?: string;
+        [UISelection]?: UISelection;
+    }
+}
+interface UISelection {
+    anchorOffset: number;
+    focusOffset: number;
+}
+export type UIValueString = string & {
+    [UIValue]: true;
+};
+export type UISelectionStart = number & {
+    [UISelection]: true;
+};
+export declare function isUIValue(value: string | UIValueString): value is UIValueString;
+export declare function isUISelectionStart(start: number | UISelectionStart | null): start is UISelectionStart;
+export declare function setUIValue(element: HTMLInputElement | HTMLTextAreaElement, value: string): void;
+export declare function getUIValue(element: HTMLInputElement | HTMLTextAreaElement): string;
+/** Flag the IDL value as clean. This does not change the value. */
+export declare function setUIValueClean(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function clearInitialValue(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function getInitialValue(element: HTMLInputElement | HTMLTextAreaElement): string | undefined;
+export declare function setUISelectionRaw(element: HTMLInputElement | HTMLTextAreaElement, selection: UISelection): void;
+export declare function setUISelection(element: HTMLInputElement | HTMLTextAreaElement, { focusOffset: focusOffsetParam, anchorOffset: anchorOffsetParam, }: {
+    anchorOffset?: number;
+    focusOffset: number;
+}, mode?: 'replace' | 'modify'): void;
+export type UISelectionRange = UISelection & {
+    startOffset: number;
+    endOffset: number;
+};
+export declare function getUISelection(element: HTMLInputElement | HTMLTextAreaElement): UISelectionRange;
+export declare function hasUISelection(element: HTMLInputElement | HTMLTextAreaElement): boolean;
+/** Flag the IDL selection as clean. This does not change the selection. */
+export declare function setUISelectionClean(element: HTMLInputElement | HTMLTextAreaElement): void;
+export {};

package/dist/types/document/copySelection.d.ts

@@ -0,0 +1 @@
+export declare function copySelection(target: Element): DataTransfer;

package/dist/types/document/getValueOrTextContent.d.ts

@@ -0,0 +1 @@
+export declare function getValueOrTextContent<T extends Element | null>(element: T): T extends HTMLInputElement | HTMLTextAreaElement ? string : string | null;

package/dist/types/document/index.d.ts

@@ -0,0 +1,5 @@
+export { getUISelection, getUIValue, setUISelection, setUIValue, clearInitialValue, } from './UI';
+export type { UISelectionRange } from './UI';
+export { getValueOrTextContent } from './getValueOrTextContent';
+export { copySelection } from './copySelection';
+export { commitValueAfterInput } from './trackValue';

package/dist/types/document/interceptor.d.ts

@@ -0,0 +1,19 @@
+type anyFunc = (...a: any[]) => any;
+type Params<Prop> = Prop extends anyFunc ? Parameters<Prop> : [Prop];
+type ImplReturn<Prop> = Prop extends anyFunc ? Parameters<Prop> : Prop;
+export declare function prepareInterceptor<ElementType extends Element, PropName extends keyof ElementType>(element: ElementType, propName: PropName, interceptorImpl: (this: ElementType, ...args: Params<ElementType[PropName]>) => {
+    /**
+     * React tracks the changes on element properties.
+     * This workaround tries to alter the DOM element without React noticing,
+     * so that it later picks up the change.
+     *
+     * @see https://github.com/facebook/react/blob/148f8e497c7d37a3c7ab99f01dec2692427272b1/packages/react-dom/src/client/inputValueTracking.js#L51-L104
+     */
+    applyNative?: boolean;
+    realArgs?: ImplReturn<ElementType[PropName]>;
+    then?: () => void;
+}): void;
+export declare function prepareValueInterceptor(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function prepareSelectionInterceptor(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function prepareRangeTextInterceptor(element: HTMLInputElement | HTMLTextAreaElement): void;
+export {};

package/dist/types/document/patchFocus.d.ts

@@ -0,0 +1,9 @@
+declare const patched: unique symbol;
+declare global {
+    interface HTMLElement {
+        readonly [patched]?: Pick<HTMLElement, 'focus' | 'blur'>;
+    }
+}
+export declare function patchFocus(HTMLElement: typeof globalThis['HTMLElement']): void;
+export declare function restoreFocus(HTMLElement: typeof globalThis['HTMLElement']): void;
+export {};

package/dist/types/document/prepareDocument.d.ts

@@ -0,0 +1,8 @@
+declare const isPrepared: unique symbol;
+declare global {
+    interface Node {
+        [isPrepared]?: typeof isPrepared;
+    }
+}
+export declare function prepareDocument(document: Document): void;
+export {};

package/dist/types/document/trackValue.d.ts

@@ -0,0 +1,17 @@
+declare const TrackChanges: unique symbol;
+declare global {
+    interface Window {
+        REACT_VERSION?: number;
+    }
+    interface Element {
+        [TrackChanges]?: {
+            previousValue?: string;
+            tracked?: string[];
+            nextValue?: string;
+        };
+    }
+}
+export declare function startTrackValue(element: HTMLInputElement | HTMLTextAreaElement): void;
+export declare function trackOrSetValue(element: HTMLInputElement | HTMLTextAreaElement, v: string): void;
+export declare function commitValueAfterInput(element: HTMLInputElement | HTMLTextAreaElement, cursorOffset: number): void;
+export {};

package/dist/types/event/behavior/click.d.ts

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

package/dist/types/event/behavior/cut.d.ts

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

package/dist/types/event/behavior/index.d.ts

@@ -0,0 +1,8 @@
+import './click';
+import './cut';
+import './keydown';
+import './keypress';
+import './keyup';
+import './paste';
+export { behavior } from './registry';
+export type { BehaviorPlugin } from './registry';

package/dist/types/event/behavior/keydown.d.ts

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

package/dist/types/event/behavior/keypress.d.ts

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

package/dist/types/event/behavior/keyup.d.ts

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

package/dist/types/event/behavior/paste.d.ts

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

package/dist/types/event/behavior/registry.d.ts

@@ -0,0 +1,8 @@
+import { type Instance } from '../../setup';
+import { EventType } from '../types';
+export interface BehaviorPlugin<Type extends EventType> {
+    (event: DocumentEventMap[Type], target: Element, instance: Instance): void | (() => void);
+}
+export declare const behavior: {
+    [Type in EventType]?: BehaviorPlugin<Type>;
+};

package/dist/types/event/createEvent.d.ts

@@ -0,0 +1,2 @@
+import { type EventType, type EventTypeInit, type FixedDocumentEventMap } from './types';
+export declare function createEvent<K extends EventType>(type: K, target: Element, init?: EventTypeInit<K>): FixedDocumentEventMap[K];

package/dist/types/event/dispatchEvent.d.ts

@@ -0,0 +1,5 @@
+import { type Instance } from '../setup';
+import { EventType, EventTypeInit } from './types';
+export declare function dispatchUIEvent<K extends EventType>(this: Instance, target: Element, type: K, init?: EventTypeInit<K>, preventDefault?: boolean): boolean;
+export declare function dispatchEvent(this: Instance, target: Element, event: Event, preventDefault?: boolean): boolean;
+export declare function dispatchDOMEvent<K extends EventType>(target: Element, type: K, init?: EventTypeInit<K>): void;

package/dist/types/event/eventMap.d.ts

@@ -0,0 +1,265 @@
+import { EventType } from './types';
+export declare const eventMap: {
+    readonly auxclick: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly beforeinput: {
+        readonly EventType: "InputEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly blur: {
+        readonly EventType: "FocusEvent";
+        readonly defaultInit: {
+            readonly bubbles: false;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly click: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly contextmenu: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly copy: {
+        readonly EventType: "ClipboardEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly change: {
+        readonly EventType: "Event";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: false;
+        };
+    };
+    readonly cut: {
+        readonly EventType: "ClipboardEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly dblclick: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly focus: {
+        readonly EventType: "FocusEvent";
+        readonly defaultInit: {
+            readonly bubbles: false;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly focusin: {
+        readonly EventType: "FocusEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly focusout: {
+        readonly EventType: "FocusEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly keydown: {
+        readonly EventType: "KeyboardEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly keypress: {
+        readonly EventType: "KeyboardEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly keyup: {
+        readonly EventType: "KeyboardEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly paste: {
+        readonly EventType: "ClipboardEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly input: {
+        readonly EventType: "InputEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly mousedown: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly mouseenter: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: false;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly mouseleave: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: false;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly mousemove: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly mouseout: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly mouseover: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly mouseup: {
+        readonly EventType: "MouseEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly pointerover: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly pointerenter: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: false;
+            readonly cancelable: false;
+        };
+    };
+    readonly pointerdown: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly pointermove: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly pointerup: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly pointercancel: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: false;
+            readonly composed: true;
+        };
+    };
+    readonly pointerout: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+            readonly composed: true;
+        };
+    };
+    readonly pointerleave: {
+        readonly EventType: "PointerEvent";
+        readonly defaultInit: {
+            readonly bubbles: false;
+            readonly cancelable: false;
+        };
+    };
+    readonly submit: {
+        readonly EventType: "Event";
+        readonly defaultInit: {
+            readonly bubbles: true;
+            readonly cancelable: true;
+        };
+    };
+};
+export declare function isMouseEvent(type: EventType): boolean;
+export declare function isKeyboardEvent(type: EventType): boolean;

package/dist/types/event/focus.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Focus closest focusable element.
+ */
+export declare function focusElement(element: Element): void;
+export declare function blurElement(element: Element): void;

package/dist/types/event/index.d.ts

@@ -0,0 +1,7 @@
+import { EventType, PointerCoords } from './types';
+export type { EventType, PointerCoords };
+export { dispatchEvent, dispatchUIEvent, dispatchDOMEvent } from './dispatchEvent';
+export { blurElement, focusElement } from './focus';
+export { input } from './input';
+export type { SelectionRange } from './selection';
+export { isAllSelected, modifySelectionPerMouseMove, setSelectionPerMouseDown, selectAll, } from './selection';

package/dist/types/event/input.d.ts

@@ -0,0 +1,2 @@
+import { type Instance } from '../setup';
+export declare function input(instance: Instance, element: Element, data: string, inputType?: string): void;

package/dist/types/event/radio.d.ts

@@ -0,0 +1,4 @@
+import { type Instance } from '../setup';
+export declare function walkRadio(instance: Instance, el: HTMLInputElement & {
+    type: 'radio';
+}, direction: -1 | 1): void;

package/dist/types/event/selection/getInputRange.d.ts

@@ -0,0 +1,5 @@
+import { UISelectionRange } from '../../document';
+/**
+ * Get the range that would be overwritten by input.
+ */
+export declare function getInputRange(focusNode: Node): UISelectionRange | Range | undefined;

package/dist/types/event/selection/getTargetTypeAndSelection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Determine which selection logic and selection ranges to consider.
+ */
+export declare function getTargetTypeAndSelection(node: Node): {
+    readonly type: "input";
+    readonly selection: import("../../document").UISelectionRange;
+} | {
+    readonly type: "contenteditable" | "default";
+    readonly selection: Selection | null | undefined;
+};

package/dist/types/event/selection/index.d.ts

@@ -0,0 +1,15 @@
+import { type EditableInputOrTextarea } from '../../utils';
+export { getInputRange } from './getInputRange';
+export { modifySelection } from './modifySelection';
+export { moveSelection } from './moveSelection';
+export { setSelectionPerMouseDown } from './setSelectionPerMouse';
+export { modifySelectionPerMouseMove } from './modifySelectionPerMouse';
+export { isAllSelected, selectAll } from './selectAll';
+export { setSelectionRange } from './setSelectionRange';
+export { setSelection } from './setSelection';
+export { updateSelectionOnFocus } from './updateSelectionOnFocus';
+export type SelectionRange = {
+    node: EditableInputOrTextarea;
+    start: number;
+    end: number;
+};

package/dist/types/event/selection/modifySelection.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extend/shrink the selection like with Shift+Arrows or Shift+Mouse
+ */
+export declare function modifySelection({ focusNode, focusOffset, }: {
+    focusNode: Node;
+    /** DOM Offset */
+    focusOffset: number;
+}): void;

package/dist/types/event/selection/modifySelectionPerMouse.d.ts

@@ -0,0 +1,7 @@
+import { type SelectionRange } from '.';
+export declare function modifySelectionPerMouseMove(selectionRange: Range | SelectionRange, { document, target, node, offset, }: {
+    document: Document;
+    target: Element;
+    node?: Node;
+    offset?: number;
+}): void;

package/dist/types/event/selection/moveSelection.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Move the selection
+ */
+export declare function moveSelection(node: Element, direction: -1 | 1): void;