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

package/dist/esm/event/selection/moveSelection.js

@@ -0,0 +1,36 @@
+import { getUISelection } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { getNextCursorPosition } from '../../utils/focus/cursor.js';
+import { hasOwnSelection } from '../../utils/focus/selection.js';
+import { setSelection } from './setSelection.js';
+
+/**
+ * Move the selection
+ */ function moveSelection(node, direction) {
+    // TODO: implement shift
+    if (hasOwnSelection(node)) {
+        const selection = getUISelection(node);
+        setSelection({
+            focusNode: node,
+            focusOffset: selection.startOffset === selection.endOffset ? selection.focusOffset + direction : direction < 0 ? selection.startOffset : selection.endOffset
+        });
+    } else {
+        const selection = node.ownerDocument.getSelection();
+        if (!(selection === null || selection === void 0 ? void 0 : selection.focusNode)) {
+            return;
+        }
+        if (selection.isCollapsed) {
+            const nextPosition = getNextCursorPosition(selection.focusNode, selection.focusOffset, direction);
+            if (nextPosition) {
+                setSelection({
+                    focusNode: nextPosition.node,
+                    focusOffset: nextPosition.offset
+                });
+            }
+        } else {
+            selection[direction < 0 ? 'collapseToStart' : 'collapseToEnd']();
+        }
+    }
+}
+
+export { moveSelection };

package/dist/esm/event/selection/resolveCaretPosition.js

@@ -0,0 +1,58 @@
+import { getUIValue } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { hasOwnSelection } from '../../utils/focus/selection.js';
+
+function resolveCaretPosition({ target, node, offset }) {
+    if (hasOwnSelection(target)) {
+        return {
+            node: target,
+            offset: offset !== null && offset !== void 0 ? offset : getUIValue(target).length
+        };
+    } else if (node) {
+        return {
+            node,
+            offset: offset !== null && offset !== void 0 ? offset : node.nodeType === 3 ? node.nodeValue.length : node.childNodes.length
+        };
+    }
+    return findNodeAtTextOffset(target, offset);
+}
+function findNodeAtTextOffset(node, offset, isRoot = true) {
+    // When clicking after the content the browser behavior can be complicated:
+    // 1. If there is textContent after the last element child,
+    // the cursor is moved there.
+    // 2. If there is textContent in the last element child,
+    // the browser moves the cursor to the last non-empty text node inside this element.
+    // 3. Otherwise the cursor is moved to the end of the target.
+    let i = offset === undefined ? node.childNodes.length - 1 : 0;
+    const step = offset === undefined ? -1 : 1;
+    while(offset === undefined ? i >= (isRoot ? Math.max(node.childNodes.length - 1, 0) : 0) : i <= node.childNodes.length){
+        if (offset && i === node.childNodes.length) {
+            throw new Error('The given offset is out of bounds.');
+        }
+        const c = node.childNodes.item(i);
+        const text = String(c.textContent);
+        if (text.length) {
+            if (offset !== undefined && text.length < offset) {
+                offset -= text.length;
+            } else if (c.nodeType === 1) {
+                return findNodeAtTextOffset(c, offset, false);
+            } else {
+                // The pre-commit hooks keeps changing this
+                // See https://github.com/kentcdodds/kcd-scripts/issues/218
+                /* istanbul ignore else */ if (c.nodeType === 3) {
+                    return {
+                        node: c,
+                        offset: offset !== null && offset !== void 0 ? offset : c.nodeValue.length
+                    };
+                }
+            }
+        }
+        i += step;
+    }
+    return {
+        node,
+        offset: node.childNodes.length
+    };
+}
+
+export { resolveCaretPosition };

package/dist/esm/event/selection/selectAll.js

@@ -0,0 +1,35 @@
+import { getUISelection, getUIValue } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { getContentEditable } from '../../utils/edit/isContentEditable.js';
+import { hasOwnSelection } from '../../utils/focus/selection.js';
+import { setSelection } from './setSelection.js';
+
+/**
+ * Expand a selection like the browser does when pressing Ctrl+A.
+ */ function selectAll(target) {
+    var _getContentEditable;
+    if (hasOwnSelection(target)) {
+        return setSelection({
+            focusNode: target,
+            anchorOffset: 0,
+            focusOffset: getUIValue(target).length
+        });
+    }
+    const focusNode = (_getContentEditable = getContentEditable(target)) !== null && _getContentEditable !== void 0 ? _getContentEditable : target.ownerDocument.body;
+    setSelection({
+        focusNode,
+        anchorOffset: 0,
+        focusOffset: focusNode.childNodes.length
+    });
+}
+function isAllSelected(target) {
+    var _getContentEditable;
+    if (hasOwnSelection(target)) {
+        return getUISelection(target).startOffset === 0 && getUISelection(target).endOffset === getUIValue(target).length;
+    }
+    const focusNode = (_getContentEditable = getContentEditable(target)) !== null && _getContentEditable !== void 0 ? _getContentEditable : target.ownerDocument.body;
+    const selection = target.ownerDocument.getSelection();
+    return (selection === null || selection === void 0 ? void 0 : selection.anchorNode) === focusNode && selection.focusNode === focusNode && selection.anchorOffset === 0 && selection.focusOffset === focusNode.childNodes.length;
+}
+
+export { isAllSelected, selectAll };

package/dist/esm/event/selection/setSelection.js

@@ -0,0 +1,19 @@
+import { setUISelection } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { getTargetTypeAndSelection } from './getTargetTypeAndSelection.js';
+
+/**
+ * Set the selection
+ */ function setSelection({ focusNode, focusOffset, anchorNode = focusNode, anchorOffset = focusOffset }) {
+    var _anchorNode_ownerDocument_getSelection, _anchorNode_ownerDocument;
+    const typeAndSelection = getTargetTypeAndSelection(focusNode);
+    if (typeAndSelection.type === 'input') {
+        return setUISelection(focusNode, {
+            anchorOffset,
+            focusOffset
+        });
+    }
+    (_anchorNode_ownerDocument = anchorNode.ownerDocument) === null || _anchorNode_ownerDocument === void 0 ? void 0 : (_anchorNode_ownerDocument_getSelection = _anchorNode_ownerDocument.getSelection()) === null || _anchorNode_ownerDocument_getSelection === void 0 ? void 0 : _anchorNode_ownerDocument_getSelection.setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset);
+}
+
+export { setSelection };

package/dist/esm/event/selection/setSelectionPerMouse.js

@@ -0,0 +1,77 @@
+import { getUIValue, setUISelection } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { hasNoSelection, hasOwnSelection } from '../../utils/focus/selection.js';
+import { resolveCaretPosition } from './resolveCaretPosition.js';
+
+function setSelectionPerMouseDown({ document, target, clickCount, node, offset }) {
+    if (hasNoSelection(target)) {
+        return;
+    }
+    const targetHasOwnSelection = hasOwnSelection(target);
+    // On non-input elements the text selection per multiple click
+    // can extend beyond the target boundaries.
+    // The exact mechanism what is considered in the same line is unclear.
+    // Looks it might be every inline element.
+    // TODO: Check what might be considered part of the same line of text.
+    const text = String(targetHasOwnSelection ? getUIValue(target) : target.textContent);
+    const [start, end] = node ? [
+        offset,
+        offset
+    ] : getTextRange(text, offset, clickCount);
+    // TODO: implement modifying selection per shift/ctrl+mouse
+    if (targetHasOwnSelection) {
+        setUISelection(target, {
+            anchorOffset: start !== null && start !== void 0 ? start : text.length,
+            focusOffset: end !== null && end !== void 0 ? end : text.length
+        });
+        return {
+            node: target,
+            start: start !== null && start !== void 0 ? start : 0,
+            end: end !== null && end !== void 0 ? end : text.length
+        };
+    } else {
+        const { node: startNode, offset: startOffset } = resolveCaretPosition({
+            target,
+            node,
+            offset: start
+        });
+        const { node: endNode, offset: endOffset } = resolveCaretPosition({
+            target,
+            node,
+            offset: end
+        });
+        const range = target.ownerDocument.createRange();
+        try {
+            range.setStart(startNode, startOffset);
+            range.setEnd(endNode, endOffset);
+        } catch  {
+            throw new Error('The given offset is out of bounds.');
+        }
+        const selection = document.getSelection();
+        selection === null || selection === void 0 ? void 0 : selection.removeAllRanges();
+        selection === null || selection === void 0 ? void 0 : selection.addRange(range.cloneRange());
+        return range;
+    }
+}
+function getTextRange(text, pos, clickCount) {
+    if (clickCount % 3 === 1 || text.length === 0) {
+        return [
+            pos,
+            pos
+        ];
+    }
+    const textPos = pos !== null && pos !== void 0 ? pos : text.length;
+    if (clickCount % 3 === 2) {
+        return [
+            textPos - text.substr(0, pos).match(/(\w+|\s+|\W)?$/)[0].length,
+            pos === undefined ? pos : pos + text.substr(pos).match(/^(\w+|\s+|\W)?/)[0].length
+        ];
+    }
+    // triple click
+    return [
+        textPos - text.substr(0, pos).match(/[^\r\n]*$/)[0].length,
+        pos === undefined ? pos : pos + text.substr(pos).match(/^[^\r\n]*/)[0].length
+    ];
+}
+
+export { setSelectionPerMouseDown };

package/dist/esm/event/selection/setSelectionRange.js

@@ -0,0 +1,29 @@
+import '../../utils/dataTransfer/Clipboard.js';
+import { isContentEditable } from '../../utils/edit/isContentEditable.js';
+import { hasOwnSelection } from '../../utils/focus/selection.js';
+import { setSelection } from './setSelection.js';
+
+/**
+ * Backward-compatible selection.
+ *
+ * Handles input elements and contenteditable if it only contains a single text node.
+ */ function setSelectionRange(element, anchorOffset, focusOffset) {
+    var _element_firstChild;
+    if (hasOwnSelection(element)) {
+        return setSelection({
+            focusNode: element,
+            anchorOffset,
+            focusOffset
+        });
+    }
+    /* istanbul ignore else */ if (isContentEditable(element) && ((_element_firstChild = element.firstChild) === null || _element_firstChild === void 0 ? void 0 : _element_firstChild.nodeType) === 3) {
+        return setSelection({
+            focusNode: element.firstChild,
+            anchorOffset,
+            focusOffset
+        });
+    }
+    /* istanbul ignore next */ throw new Error('Not implemented. The result of this interaction is unreliable.');
+}
+
+export { setSelectionRange };

package/dist/esm/event/selection/updateSelectionOnFocus.js

@@ -0,0 +1,38 @@
+import '../../utils/dataTransfer/Clipboard.js';
+import { getContentEditable } from '../../utils/edit/isContentEditable.js';
+import { hasOwnSelection } from '../../utils/focus/selection.js';
+
+// The browser implementation seems to have changed.
+// When focus is inside <input type="text"/>,
+// Chrome updates Selection to be collapsed at the position of the input element.
+// TODO: update implementation to match that of current browsers
+/**
+ * Reset the Document Selection when moving focus into an element
+ * with own selection implementation.
+ */ function updateSelectionOnFocus(element) {
+    const selection = element.ownerDocument.getSelection();
+    /* istanbul ignore if */ if (!(selection === null || selection === void 0 ? void 0 : selection.focusNode)) {
+        return;
+    }
+    // If the focus moves inside an element with own selection implementation,
+    // the document selection will be this element.
+    // But if the focused element is inside a contenteditable,
+    // 1) a collapsed selection will be retained.
+    // 2) other selections will be replaced by a cursor
+    //  2.a) at the start of the first child if it is a text node
+    //  2.b) at the start of the contenteditable.
+    if (hasOwnSelection(element)) {
+        const contenteditable = getContentEditable(selection.focusNode);
+        if (contenteditable) {
+            if (!selection.isCollapsed) {
+                var _contenteditable_firstChild;
+                const focusNode = ((_contenteditable_firstChild = contenteditable.firstChild) === null || _contenteditable_firstChild === void 0 ? void 0 : _contenteditable_firstChild.nodeType) === 3 ? contenteditable.firstChild : contenteditable;
+                selection.setBaseAndExtent(focusNode, 0, focusNode, 0);
+            }
+        } else {
+            selection.setBaseAndExtent(element, 0, element, 0);
+        }
+    }
+}
+
+export { updateSelectionOnFocus };

package/dist/esm/event/types.js

@@ -0,0 +1 @@
+

package/dist/esm/event/wrapEvent.js

@@ -0,0 +1,8 @@
+import { getConfig } from '@testing-library/dom';
+
+function wrapEvent(cb, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+_element) {
+    return getConfig().eventWrapper(cb);
+}
+
+export { wrapEvent };

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export { userEvent as default, userEvent } from './setup/index.js';
+export { PointerEventsCheckLevel } from './options.js';

package/dist/esm/keyboard/index.js

@@ -0,0 +1,37 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { wait } from '../utils/misc/wait.js';
+import { parseKeyDef } from './parseKeyDef.js';
+
+async function keyboard(text) {
+    const actions = parseKeyDef(this.config.keyboardMap, text);
+    for(let i = 0; i < actions.length; i++){
+        await wait(this.config);
+        await keyboardAction(this, actions[i]);
+    }
+}
+async function keyboardAction(instance, { keyDef, releasePrevious, releaseSelf, repeat }) {
+    const { system } = instance;
+    // Release the key automatically if it was pressed before.
+    if (system.keyboard.isKeyPressed(keyDef)) {
+        await system.keyboard.keyup(instance, keyDef);
+    }
+    if (!releasePrevious) {
+        for(let i = 1; i <= repeat; i++){
+            await system.keyboard.keydown(instance, keyDef);
+            if (i < repeat) {
+                await wait(instance.config);
+            }
+        }
+        // Release the key only on the last iteration on `state.repeatKey`.
+        if (releaseSelf) {
+            await system.keyboard.keyup(instance, keyDef);
+        }
+    }
+}
+async function releaseAllKeys(instance) {
+    for (const k of instance.system.keyboard.getPressedKeys()){
+        await instance.system.keyboard.keyup(instance, k);
+    }
+}
+
+export { keyboard, releaseAllKeys };

package/dist/esm/keyboard/keyMap.js

@@ -0,0 +1,176 @@
+import { DOM_KEY_LOCATION } from '../system/keyboard.js';
+
+/**
+ * Mapping for a default US-104-QWERTY keyboard
+ */ const defaultKeyMap = [
+    // alphanumeric block - writing system
+    ...'0123456789'.split('').map((c)=>({
+            code: `Digit${c}`,
+            key: c
+        })),
+    ...')!@#$%^&*('.split('').map((c, i)=>({
+            code: `Digit${i}`,
+            key: c,
+            shiftKey: true
+        })),
+    ...'abcdefghijklmnopqrstuvwxyz'.split('').map((c)=>({
+            code: `Key${c.toUpperCase()}`,
+            key: c
+        })),
+    ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map((c)=>({
+            code: `Key${c}`,
+            key: c,
+            shiftKey: true
+        })),
+    {
+        code: 'BracketLeft',
+        key: '['
+    },
+    {
+        code: 'BracketLeft',
+        key: '{',
+        shiftKey: true
+    },
+    {
+        code: 'BracketRight',
+        key: ']'
+    },
+    {
+        code: 'BracketRight',
+        key: '}',
+        shiftKey: true
+    },
+    // alphanumeric block - functional
+    {
+        code: 'Space',
+        key: ' '
+    },
+    {
+        code: 'AltLeft',
+        key: 'Alt',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'AltRight',
+        key: 'Alt',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ShiftLeft',
+        key: 'Shift',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'ShiftRight',
+        key: 'Shift',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ControlLeft',
+        key: 'Control',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'ControlRight',
+        key: 'Control',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'MetaLeft',
+        key: 'Meta',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'MetaRight',
+        key: 'Meta',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'OSLeft',
+        key: 'OS',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'OSRight',
+        key: 'OS',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ContextMenu',
+        key: 'ContextMenu'
+    },
+    {
+        code: 'Tab',
+        key: 'Tab'
+    },
+    {
+        code: 'CapsLock',
+        key: 'CapsLock'
+    },
+    {
+        code: 'Backspace',
+        key: 'Backspace'
+    },
+    {
+        code: 'Enter',
+        key: 'Enter'
+    },
+    // function
+    {
+        code: 'Escape',
+        key: 'Escape'
+    },
+    // arrows
+    {
+        code: 'ArrowUp',
+        key: 'ArrowUp'
+    },
+    {
+        code: 'ArrowDown',
+        key: 'ArrowDown'
+    },
+    {
+        code: 'ArrowLeft',
+        key: 'ArrowLeft'
+    },
+    {
+        code: 'ArrowRight',
+        key: 'ArrowRight'
+    },
+    // control pad
+    {
+        code: 'Home',
+        key: 'Home'
+    },
+    {
+        code: 'End',
+        key: 'End'
+    },
+    {
+        code: 'Delete',
+        key: 'Delete'
+    },
+    {
+        code: 'PageUp',
+        key: 'PageUp'
+    },
+    {
+        code: 'PageDown',
+        key: 'PageDown'
+    },
+    // Special keys that are not part of a default US-layout but included for specific behavior
+    {
+        code: 'Fn',
+        key: 'Fn'
+    },
+    {
+        code: 'Symbol',
+        key: 'Symbol'
+    },
+    {
+        code: 'AltRight',
+        key: 'AltGraph'
+    }
+];
+
+export { defaultKeyMap };

package/dist/esm/keyboard/parseKeyDef.js

@@ -0,0 +1,43 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { readNextDescriptor } from '../utils/keyDef/readNextDescriptor.js';
+
+/**
+ * Parse key definitions per `keyboardMap`
+ *
+ * Keys can be referenced by `{key}` or `{special}` as well as physical locations per `[code]`.
+ * Everything else will be interpreted as a typed character - e.g. `a`.
+ * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
+ * Keeping the key pressed can be written as `{key>}`.
+ * When keeping the key pressed you can choose how long (how many keydown and keypress) the key is pressed `{key>3}`.
+ * You can then release the key per `{key>3/}` or keep it pressed and continue with the next key.
+ */ function parseKeyDef(keyboardMap, text) {
+    const defs = [];
+    do {
+        var _keyboardMap_find;
+        const { type, descriptor, consumedLength, releasePrevious, releaseSelf = true, repeat } = readNextDescriptor(text, 'keyboard');
+        const keyDef = (_keyboardMap_find = keyboardMap.find((def)=>{
+            if (type === '[') {
+                var _def_code;
+                return ((_def_code = def.code) === null || _def_code === void 0 ? void 0 : _def_code.toLowerCase()) === descriptor.toLowerCase();
+            } else if (type === '{') {
+                var _def_key;
+                return ((_def_key = def.key) === null || _def_key === void 0 ? void 0 : _def_key.toLowerCase()) === descriptor.toLowerCase();
+            }
+            return def.key === descriptor;
+        })) !== null && _keyboardMap_find !== void 0 ? _keyboardMap_find : {
+            key: 'Unknown',
+            code: 'Unknown',
+            [type === '[' ? 'code' : 'key']: descriptor
+        };
+        defs.push({
+            keyDef,
+            releasePrevious,
+            releaseSelf,
+            repeat
+        });
+        text = text.slice(consumedLength);
+    }while (text)
+    return defs;
+}
+
+export { parseKeyDef };

package/dist/esm/options.js

@@ -0,0 +1,12 @@
+var PointerEventsCheckLevel = /*#__PURE__*/ function(PointerEventsCheckLevel) {
+    /**
+   * Check pointer events on every user interaction that triggers a bunch of events.
+   * E.g. once for releasing a mouse button even though this triggers `pointerup`, `mouseup`, `click`, etc...
+   */ PointerEventsCheckLevel[PointerEventsCheckLevel["EachTrigger"] = 4] = "EachTrigger";
+    /** Check each target once per call to pointer (related) API */ PointerEventsCheckLevel[PointerEventsCheckLevel["EachApiCall"] = 2] = "EachApiCall";
+    /** Check each event target once */ PointerEventsCheckLevel[PointerEventsCheckLevel["EachTarget"] = 1] = "EachTarget";
+    /** No pointer events check */ PointerEventsCheckLevel[PointerEventsCheckLevel["Never"] = 0] = "Never";
+    return PointerEventsCheckLevel;
+}({});
+
+export { PointerEventsCheckLevel };

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/pointer/index.js

@@ -0,0 +1,72 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { setLevelRef, ApiLevel } from '../utils/misc/level.js';
+import { wait } from '../utils/misc/wait.js';
+import { parseKeyDef } from './parseKeyDef.js';
+
+async function pointer(input) {
+    const { pointerMap } = this.config;
+    const actions = [];
+    (Array.isArray(input) ? input : [
+        input
+    ]).forEach((actionInput)=>{
+        if (typeof actionInput === 'string') {
+            actions.push(...parseKeyDef(pointerMap, actionInput));
+        } else if ('keys' in actionInput) {
+            actions.push(...parseKeyDef(pointerMap, actionInput.keys).map((i)=>({
+                    ...actionInput,
+                    ...i
+                })));
+        } else {
+            actions.push(actionInput);
+        }
+    });
+    for(let i = 0; i < actions.length; i++){
+        await wait(this.config);
+        await pointerAction(this, actions[i]);
+    }
+    this.system.pointer.resetClickCount();
+}
+async function pointerAction(instance, action) {
+    var _action_target, _action_coords, _action_node, _action_offset;
+    var _previousPosition_caret, _previousPosition_caret1;
+    const pointerName = 'pointerName' in action && action.pointerName ? action.pointerName : 'keyDef' in action ? instance.system.pointer.getPointerName(action.keyDef) : 'mouse';
+    const previousPosition = instance.system.pointer.getPreviousPosition(pointerName);
+    const position = {
+        target: (_action_target = action.target) !== null && _action_target !== void 0 ? _action_target : getPrevTarget(instance, previousPosition),
+        coords: (_action_coords = action.coords) !== null && _action_coords !== void 0 ? _action_coords : previousPosition === null || previousPosition === void 0 ? void 0 : previousPosition.coords,
+        caret: {
+            node: (_action_node = action.node) !== null && _action_node !== void 0 ? _action_node : hasCaretPosition(action) ? undefined : previousPosition === null || previousPosition === void 0 ? void 0 : (_previousPosition_caret = previousPosition.caret) === null || _previousPosition_caret === void 0 ? void 0 : _previousPosition_caret.node,
+            offset: (_action_offset = action.offset) !== null && _action_offset !== void 0 ? _action_offset : hasCaretPosition(action) ? undefined : previousPosition === null || previousPosition === void 0 ? void 0 : (_previousPosition_caret1 = previousPosition.caret) === null || _previousPosition_caret1 === void 0 ? void 0 : _previousPosition_caret1.offset
+        }
+    };
+    if ('keyDef' in action) {
+        if (instance.system.pointer.isKeyPressed(action.keyDef)) {
+            setLevelRef(instance, ApiLevel.Trigger);
+            await instance.system.pointer.release(instance, action.keyDef, position);
+        }
+        if (!action.releasePrevious) {
+            setLevelRef(instance, ApiLevel.Trigger);
+            await instance.system.pointer.press(instance, action.keyDef, position);
+            if (action.releaseSelf) {
+                setLevelRef(instance, ApiLevel.Trigger);
+                await instance.system.pointer.release(instance, action.keyDef, position);
+            }
+        }
+    } else {
+        setLevelRef(instance, ApiLevel.Trigger);
+        await instance.system.pointer.move(instance, pointerName, position);
+    }
+}
+function hasCaretPosition(action) {
+    var _ref, _action_target;
+    return !!((_ref = (_action_target = action.target) !== null && _action_target !== void 0 ? _action_target : action.node) !== null && _ref !== void 0 ? _ref : action.offset !== undefined);
+}
+function getPrevTarget(instance, position) {
+    var _position_target;
+    if (!position) {
+        throw new Error('This pointer has no previous position. Provide a target property!');
+    }
+    return (_position_target = position.target) !== null && _position_target !== void 0 ? _position_target : instance.config.document.body;
+}
+
+export { pointer };