@dotss/ui 1.0.1 → 1.0.3

package/node_modules/@testing-library/user-event/dist/cjs/document/copySelection.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var DataTransfer = require('../utils/dataTransfer/DataTransfer.js');
+require('../utils/dataTransfer/Clipboard.js');
+var getWindow = require('../utils/misc/getWindow.js');
+var selection = require('../utils/focus/selection.js');
+var UI = require('./UI.js');
+
+function copySelection(target) {
+    const data = selection.hasOwnSelection(target) ? {
+        'text/plain': readSelectedValueFromInput(target)
+    } : {
+        'text/plain': String(target.ownerDocument.getSelection())
+    };
+    const dt = DataTransfer.createDataTransfer(getWindow.getWindow(target));
+    for(const type in data){
+        if (data[type]) {
+            dt.setData(type, data[type]);
+        }
+    }
+    return dt;
+}
+function readSelectedValueFromInput(target) {
+    const sel = UI.getUISelection(target);
+    const val = UI.getUIValue(target);
+    return val.substring(sel.startOffset, sel.endOffset);
+}
+
+exports.copySelection = copySelection;

package/node_modules/@testing-library/user-event/dist/cjs/document/getValueOrTextContent.js

@@ -0,0 +1,18 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../utils/edit/isContentEditable.js');
+var UI = require('./UI.js');
+
+function getValueOrTextContent(element) {
+    // istanbul ignore if
+    if (!element) {
+        return null;
+    }
+    if (isContentEditable.isContentEditable(element)) {
+        return element.textContent;
+    }
+    return UI.getUIValue(element);
+}
+
+exports.getValueOrTextContent = getValueOrTextContent;

package/node_modules/@testing-library/user-event/dist/cjs/document/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var UI = require('./UI.js');
+var getValueOrTextContent = require('./getValueOrTextContent.js');
+var copySelection = require('./copySelection.js');
+var trackValue = require('./trackValue.js');
+
+
+
+exports.clearInitialValue = UI.clearInitialValue;
+exports.getUISelection = UI.getUISelection;
+exports.getUIValue = UI.getUIValue;
+exports.setUISelection = UI.setUISelection;
+exports.setUIValue = UI.setUIValue;
+exports.getValueOrTextContent = getValueOrTextContent.getValueOrTextContent;
+exports.copySelection = copySelection.copySelection;
+exports.commitValueAfterInput = trackValue.commitValueAfterInput;

package/node_modules/@testing-library/user-event/dist/cjs/document/interceptor.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var isElementType = require('../utils/misc/isElementType.js');
+require('../utils/dataTransfer/Clipboard.js');
+var trackValue = require('./trackValue.js');
+var UI = require('./UI.js');
+
+const Interceptor = Symbol('Interceptor for programmatical calls');
+function prepareInterceptor(element, propName, interceptorImpl) {
+    const prototypeDescriptor = Object.getOwnPropertyDescriptor(element.constructor.prototype, propName);
+    const objectDescriptor = Object.getOwnPropertyDescriptor(element, propName);
+    const target = (prototypeDescriptor === null || prototypeDescriptor === undefined ? undefined : prototypeDescriptor.set) ? 'set' : 'value';
+    /* istanbul ignore if */ if (typeof (prototypeDescriptor === null || prototypeDescriptor === undefined ? undefined : prototypeDescriptor[target]) !== 'function' || prototypeDescriptor[target][Interceptor]) {
+        throw new Error(`Element ${element.tagName} does not implement "${String(propName)}".`);
+    }
+    function intercept(...args) {
+        const { applyNative = false, realArgs, then } = interceptorImpl.call(this, ...args);
+        const realFunc = (!applyNative && objectDescriptor || prototypeDescriptor)[target];
+        if (target === 'set') {
+            realFunc.call(this, realArgs);
+        } else {
+            realFunc.call(this, ...realArgs);
+        }
+        then === null || then === undefined ? undefined : then();
+    }
+    intercept[Interceptor] = Interceptor;
+    Object.defineProperty(element, propName, {
+        ...objectDescriptor !== null && objectDescriptor !== undefined ? objectDescriptor : prototypeDescriptor,
+        [target]: intercept
+    });
+}
+function prepareValueInterceptor(element) {
+    prepareInterceptor(element, 'value', function interceptorImpl(v) {
+        const isUI = UI.isUIValue(v);
+        if (isUI) {
+            trackValue.startTrackValue(this);
+        }
+        return {
+            applyNative: !!isUI,
+            realArgs: sanitizeValue(this, v),
+            then: isUI ? undefined : ()=>trackValue.trackOrSetValue(this, String(v))
+        };
+    });
+}
+function sanitizeValue(element, v) {
+    // Workaround for JSDOM
+    if (isElementType.isElementType(element, 'input', {
+        type: 'number'
+    }) && String(v) !== '' && !Number.isNaN(Number(v))) {
+        // Setting value to "1." results in `null` in JSDOM
+        return String(Number(v));
+    }
+    return String(v);
+}
+function prepareSelectionInterceptor(element) {
+    prepareInterceptor(element, 'setSelectionRange', function interceptorImpl(start, ...others) {
+        const isUI = UI.isUISelectionStart(start);
+        return {
+            applyNative: !!isUI,
+            realArgs: [
+                Number(start),
+                ...others
+            ],
+            then: ()=>isUI ? undefined : UI.setUISelectionClean(element)
+        };
+    });
+    prepareInterceptor(element, 'selectionStart', function interceptorImpl(v) {
+        return {
+            realArgs: v,
+            then: ()=>UI.setUISelectionClean(element)
+        };
+    });
+    prepareInterceptor(element, 'selectionEnd', function interceptorImpl(v) {
+        return {
+            realArgs: v,
+            then: ()=>UI.setUISelectionClean(element)
+        };
+    });
+    prepareInterceptor(element, 'select', function interceptorImpl() {
+        return {
+            realArgs: [],
+            then: ()=>UI.setUISelectionRaw(element, {
+                    anchorOffset: 0,
+                    focusOffset: UI.getUIValue(element).length
+                })
+        };
+    });
+}
+function prepareRangeTextInterceptor(element) {
+    prepareInterceptor(element, 'setRangeText', function interceptorImpl(...realArgs) {
+        return {
+            realArgs,
+            then: ()=>{
+                UI.setUIValueClean(element);
+                UI.setUISelectionClean(element);
+            }
+        };
+    });
+}
+
+exports.prepareInterceptor = prepareInterceptor;
+exports.prepareRangeTextInterceptor = prepareRangeTextInterceptor;
+exports.prepareSelectionInterceptor = prepareSelectionInterceptor;
+exports.prepareValueInterceptor = prepareValueInterceptor;

package/node_modules/@testing-library/user-event/dist/cjs/document/patchFocus.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var dispatchEvent = require('../event/dispatchEvent.js');
+require('../utils/dataTransfer/Clipboard.js');
+var getActiveElement = require('../utils/focus/getActiveElement.js');
+require('@testing-library/dom');
+
+const patched = Symbol('patched focus/blur methods');
+function patchFocus(HTMLElement) {
+    if (HTMLElement.prototype[patched]) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const { focus, blur } = HTMLElement.prototype;
+    Object.defineProperties(HTMLElement.prototype, {
+        focus: {
+            configurable: true,
+            get: ()=>patchedFocus
+        },
+        blur: {
+            configurable: true,
+            get: ()=>patchedBlur
+        },
+        [patched]: {
+            configurable: true,
+            get: ()=>({
+                    focus,
+                    blur
+                })
+        }
+    });
+    let activeCall;
+    function patchedFocus(options) {
+        if (this.ownerDocument.visibilityState !== 'hidden') {
+            return focus.call(this, options);
+        }
+        const blurred = getActiveTarget(this.ownerDocument);
+        if (blurred === this) {
+            return;
+        }
+        const thisCall = Symbol('focus call');
+        activeCall = thisCall;
+        if (blurred) {
+            blur.call(blurred);
+            dispatchEvent.dispatchDOMEvent(blurred, 'blur', {
+                relatedTarget: this
+            });
+            dispatchEvent.dispatchDOMEvent(blurred, 'focusout', {
+                relatedTarget: activeCall === thisCall ? this : null
+            });
+        }
+        if (activeCall === thisCall) {
+            focus.call(this, options);
+            dispatchEvent.dispatchDOMEvent(this, 'focus', {
+                relatedTarget: blurred
+            });
+        }
+        if (activeCall === thisCall) {
+            dispatchEvent.dispatchDOMEvent(this, 'focusin', {
+                relatedTarget: blurred
+            });
+        }
+    }
+    function patchedBlur() {
+        if (this.ownerDocument.visibilityState !== 'hidden') {
+            return blur.call(this);
+        }
+        const blurred = getActiveTarget(this.ownerDocument);
+        if (blurred !== this) {
+            return;
+        }
+        const thisCall = Symbol('blur call');
+        activeCall = thisCall;
+        blur.call(this);
+        dispatchEvent.dispatchDOMEvent(blurred, 'blur', {
+            relatedTarget: null
+        });
+        dispatchEvent.dispatchDOMEvent(blurred, 'focusout', {
+            relatedTarget: null
+        });
+    }
+}
+function getActiveTarget(document) {
+    const active = getActiveElement.getActiveElement(document);
+    return (active === null || active === undefined ? undefined : active.tagName) === 'BODY' ? null : active;
+}
+function restoreFocus(HTMLElement) {
+    if (HTMLElement.prototype[patched]) {
+        const { focus, blur } = HTMLElement.prototype[patched];
+        Object.defineProperties(HTMLElement.prototype, {
+            focus: {
+                configurable: true,
+                get: ()=>focus
+            },
+            blur: {
+                configurable: true,
+                get: ()=>blur
+            }
+        });
+    }
+}
+
+exports.patchFocus = patchFocus;
+exports.restoreFocus = restoreFocus;

package/node_modules/@testing-library/user-event/dist/cjs/document/prepareDocument.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var dispatchEvent = require('../event/dispatchEvent.js');
+var isElementType = require('../utils/misc/isElementType.js');
+require('../utils/dataTransfer/Clipboard.js');
+var UI = require('./UI.js');
+require('@testing-library/dom');
+var interceptor = require('./interceptor.js');
+
+const isPrepared = Symbol('Node prepared with document state workarounds');
+function prepareDocument(document) {
+    if (document[isPrepared]) {
+        return;
+    }
+    document.addEventListener('focus', (e)=>{
+        const el = e.target;
+        prepareElement(el);
+    }, {
+        capture: true,
+        passive: true
+    });
+    // Our test environment defaults to `document.body` as `activeElement`.
+    // In other environments this might be `null` when preparing.
+    // istanbul ignore else
+    if (document.activeElement) {
+        prepareElement(document.activeElement);
+    }
+    document.addEventListener('blur', (e)=>{
+        const el = e.target;
+        const initialValue = UI.getInitialValue(el);
+        if (initialValue !== undefined) {
+            if (el.value !== initialValue) {
+                dispatchEvent.dispatchDOMEvent(el, 'change');
+            }
+            UI.clearInitialValue(el);
+        }
+    }, {
+        capture: true,
+        passive: true
+    });
+    document[isPrepared] = isPrepared;
+}
+function prepareElement(el) {
+    if (el[isPrepared]) {
+        return;
+    }
+    if (isElementType.isElementType(el, [
+        'input',
+        'textarea'
+    ])) {
+        interceptor.prepareValueInterceptor(el);
+        interceptor.prepareSelectionInterceptor(el);
+        interceptor.prepareRangeTextInterceptor(el);
+    }
+    el[isPrepared] = isPrepared;
+}
+
+exports.prepareDocument = prepareDocument;

package/node_modules/@testing-library/user-event/dist/cjs/document/trackValue.js

@@ -0,0 +1,57 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var getWindow = require('../utils/misc/getWindow.js');
+var UI = require('./UI.js');
+
+const TrackChanges = Symbol('Track programmatic changes for React workaround');
+// When the input event happens in the browser, React executes all event handlers
+// and if they change state of a controlled value, nothing happens.
+// But when we trigger the event handlers in test environment with React@17,
+// the changes are rolled back before the state update is applied.
+// This results in a reset cursor.
+// There might be a better way to work around if we figure out
+// why the batched update is executed differently in our test environment.
+function isReact17Element(element) {
+    return Object.getOwnPropertyNames(element).some((k)=>k.startsWith('__react')) && getWindow.getWindow(element).REACT_VERSION === 17;
+}
+function startTrackValue(element) {
+    if (!isReact17Element(element)) {
+        return;
+    }
+    element[TrackChanges] = {
+        previousValue: String(element.value),
+        tracked: []
+    };
+}
+function trackOrSetValue(element, v) {
+    var _element_TrackChanges_tracked, _element_TrackChanges;
+    (_element_TrackChanges = element[TrackChanges]) === null || _element_TrackChanges === undefined ? undefined : (_element_TrackChanges_tracked = _element_TrackChanges.tracked) === null || _element_TrackChanges_tracked === undefined ? undefined : _element_TrackChanges_tracked.push(v);
+    if (!element[TrackChanges]) {
+        UI.setUIValueClean(element);
+        UI.setUISelection(element, {
+            focusOffset: v.length
+        });
+    }
+}
+function commitValueAfterInput(element, cursorOffset) {
+    var _changes_tracked;
+    const changes = element[TrackChanges];
+    element[TrackChanges] = undefined;
+    if (!(changes === null || changes === undefined ? undefined : (_changes_tracked = changes.tracked) === null || _changes_tracked === undefined ? undefined : _changes_tracked.length)) {
+        return;
+    }
+    const isJustReactStateUpdate = changes.tracked.length === 2 && changes.tracked[0] === changes.previousValue && changes.tracked[1] === element.value;
+    if (!isJustReactStateUpdate) {
+        UI.setUIValueClean(element);
+    }
+    if (UI.hasUISelection(element)) {
+        UI.setUISelection(element, {
+            focusOffset: isJustReactStateUpdate ? cursorOffset : element.value.length
+        });
+    }
+}
+
+exports.commitValueAfterInput = commitValueAfterInput;
+exports.startTrackValue = startTrackValue;
+exports.trackOrSetValue = trackOrSetValue;

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/click.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var isElementType = require('../../utils/misc/isElementType.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var getWindow = require('../../utils/misc/getWindow.js');
+var isFocusable = require('../../utils/focus/isFocusable.js');
+var cloneEvent = require('../../utils/misc/cloneEvent.js');
+var focus = require('../focus.js');
+var registry = require('./registry.js');
+
+registry.behavior.click = (event, target, instance)=>{
+    const context = target.closest('button,input,label,select,textarea');
+    const control = context && isElementType.isElementType(context, 'label') && context.control;
+    if (control && control !== target) {
+        return ()=>{
+            if (isFocusable.isFocusable(control)) {
+                focus.focusElement(control);
+                instance.dispatchEvent(control, cloneEvent.cloneEvent(event));
+            }
+        };
+    } else if (isElementType.isElementType(target, 'input', {
+        type: 'file'
+    })) {
+        return ()=>{
+            // blur fires when the file selector pops up
+            focus.blurElement(target);
+            target.dispatchEvent(new (getWindow.getWindow(target)).Event('fileDialog'));
+            // focus fires after the file selector has been closed
+            focus.focusElement(target);
+        };
+    }
+};

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/cut.js

@@ -0,0 +1,14 @@
+'use strict';
+
+require('../../utils/dataTransfer/Clipboard.js');
+var isEditable = require('../../utils/edit/isEditable.js');
+var input = require('../input.js');
+var registry = require('./registry.js');
+
+registry.behavior.cut = (event, target, instance)=>{
+    return ()=>{
+        if (isEditable.isEditable(target)) {
+            input.input(instance, target, '', 'deleteByCut');
+        }
+    };
+};

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+require('./click.js');
+require('./cut.js');
+require('./keydown.js');
+require('./keypress.js');
+require('./keyup.js');
+require('./paste.js');
+var registry = require('./registry.js');
+
+
+
+exports.behavior = registry.behavior;

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/keydown.js

@@ -0,0 +1,128 @@
+'use strict';
+
+var UI = require('../../document/UI.js');
+var getValueOrTextContent = require('../../document/getValueOrTextContent.js');
+var isElementType = require('../../utils/misc/isElementType.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../../utils/edit/isContentEditable.js');
+var isEditable = require('../../utils/edit/isEditable.js');
+var getTabDestination = require('../../utils/focus/getTabDestination.js');
+var selection = require('../../utils/focus/selection.js');
+var focus = require('../focus.js');
+var input = require('../input.js');
+var moveSelection = require('../selection/moveSelection.js');
+var selectAll = require('../selection/selectAll.js');
+var setSelectionRange = require('../selection/setSelectionRange.js');
+var radio = require('../radio.js');
+var registry = require('./registry.js');
+
+registry.behavior.keydown = (event, target, instance)=>{
+    var _keydownBehavior_event_key;
+    var _keydownBehavior_event_key1;
+    return (_keydownBehavior_event_key1 = (_keydownBehavior_event_key = keydownBehavior[event.key]) === null || _keydownBehavior_event_key === undefined ? undefined : _keydownBehavior_event_key.call(keydownBehavior, event, target, instance)) !== null && _keydownBehavior_event_key1 !== undefined ? _keydownBehavior_event_key1 : combinationBehavior(event, target, instance);
+};
+const keydownBehavior = {
+    ArrowDown: (event, target, instance)=>{
+        /* istanbul ignore else */ if (isElementType.isElementType(target, 'input', {
+            type: 'radio'
+        })) {
+            return ()=>radio.walkRadio(instance, target, 1);
+        }
+    },
+    ArrowLeft: (event, target, instance)=>{
+        if (isElementType.isElementType(target, 'input', {
+            type: 'radio'
+        })) {
+            return ()=>radio.walkRadio(instance, target, -1);
+        }
+        return ()=>moveSelection.moveSelection(target, -1);
+    },
+    ArrowRight: (event, target, instance)=>{
+        if (isElementType.isElementType(target, 'input', {
+            type: 'radio'
+        })) {
+            return ()=>radio.walkRadio(instance, target, 1);
+        }
+        return ()=>moveSelection.moveSelection(target, 1);
+    },
+    ArrowUp: (event, target, instance)=>{
+        /* istanbul ignore else */ if (isElementType.isElementType(target, 'input', {
+            type: 'radio'
+        })) {
+            return ()=>radio.walkRadio(instance, target, -1);
+        }
+    },
+    Backspace: (event, target, instance)=>{
+        if (isEditable.isEditable(target)) {
+            return ()=>{
+                input.input(instance, target, '', 'deleteContentBackward');
+            };
+        }
+    },
+    Delete: (event, target, instance)=>{
+        if (isEditable.isEditable(target)) {
+            return ()=>{
+                input.input(instance, target, '', 'deleteContentForward');
+            };
+        }
+    },
+    End: (event, target)=>{
+        if (isElementType.isElementType(target, [
+            'input',
+            'textarea'
+        ]) || isContentEditable.isContentEditable(target)) {
+            return ()=>{
+                var _getValueOrTextContent;
+                var _getValueOrTextContent_length;
+                const newPos = (_getValueOrTextContent_length = (_getValueOrTextContent = getValueOrTextContent.getValueOrTextContent(target)) === null || _getValueOrTextContent === undefined ? undefined : _getValueOrTextContent.length) !== null && _getValueOrTextContent_length !== undefined ? _getValueOrTextContent_length : /* istanbul ignore next */ 0;
+                setSelectionRange.setSelectionRange(target, newPos, newPos);
+            };
+        }
+    },
+    Home: (event, target)=>{
+        if (isElementType.isElementType(target, [
+            'input',
+            'textarea'
+        ]) || isContentEditable.isContentEditable(target)) {
+            return ()=>{
+                setSelectionRange.setSelectionRange(target, 0, 0);
+            };
+        }
+    },
+    PageDown: (event, target)=>{
+        if (isElementType.isElementType(target, [
+            'input'
+        ])) {
+            return ()=>{
+                const newPos = UI.getUIValue(target).length;
+                setSelectionRange.setSelectionRange(target, newPos, newPos);
+            };
+        }
+    },
+    PageUp: (event, target)=>{
+        if (isElementType.isElementType(target, [
+            'input'
+        ])) {
+            return ()=>{
+                setSelectionRange.setSelectionRange(target, 0, 0);
+            };
+        }
+    },
+    Tab: (event, target, instance)=>{
+        return ()=>{
+            const dest = getTabDestination.getTabDestination(target, instance.system.keyboard.modifiers.Shift);
+            focus.focusElement(dest);
+            if (selection.hasOwnSelection(dest)) {
+                UI.setUISelection(dest, {
+                    anchorOffset: 0,
+                    focusOffset: dest.value.length
+                });
+            }
+        };
+    }
+};
+const combinationBehavior = (event, target, instance)=>{
+    if (event.code === 'KeyA' && instance.system.keyboard.modifiers.Control) {
+        return ()=>selectAll.selectAll(target);
+    }
+};

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/keypress.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var isElementType = require('../../utils/misc/isElementType.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../../utils/edit/isContentEditable.js');
+var isEditable = require('../../utils/edit/isEditable.js');
+var input = require('../input.js');
+var registry = require('./registry.js');
+
+registry.behavior.keypress = (event, target, instance)=>{
+    if (event.key === 'Enter') {
+        if (isElementType.isElementType(target, 'button') || isElementType.isElementType(target, 'input') && ClickInputOnEnter.includes(target.type) || isElementType.isElementType(target, 'a') && Boolean(target.href)) {
+            return ()=>{
+                instance.dispatchUIEvent(target, 'click');
+            };
+        } else if (isElementType.isElementType(target, 'input')) {
+            const form = target.form;
+            const submit = form === null || form === undefined ? undefined : form.querySelector('input[type="submit"], button:not([type]), button[type="submit"]');
+            if (submit) {
+                return ()=>instance.dispatchUIEvent(submit, 'click');
+            } else if (form && SubmitSingleInputOnEnter.includes(target.type) && form.querySelectorAll('input').length === 1) {
+                return ()=>instance.dispatchUIEvent(form, 'submit');
+            } else {
+                return;
+            }
+        }
+    }
+    if (isEditable.isEditable(target)) {
+        const inputType = event.key === 'Enter' ? isContentEditable.isContentEditable(target) && !instance.system.keyboard.modifiers.Shift ? 'insertParagraph' : 'insertLineBreak' : 'insertText';
+        const inputData = event.key === 'Enter' ? '\n' : event.key;
+        return ()=>input.input(instance, target, inputData, inputType);
+    }
+};
+const ClickInputOnEnter = [
+    'button',
+    'color',
+    'file',
+    'image',
+    'reset',
+    'submit'
+];
+const SubmitSingleInputOnEnter = [
+    'email',
+    'month',
+    'password',
+    'search',
+    'tel',
+    'text',
+    'url',
+    'week'
+];

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/keyup.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var isClickableInput = require('../../utils/click/isClickableInput.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var registry = require('./registry.js');
+
+registry.behavior.keyup = (event, target, instance)=>{
+    var _keyupBehavior_event_key;
+    return (_keyupBehavior_event_key = keyupBehavior[event.key]) === null || _keyupBehavior_event_key === undefined ? undefined : _keyupBehavior_event_key.call(keyupBehavior, event, target, instance);
+};
+const keyupBehavior = {
+    ' ': (event, target, instance)=>{
+        if (isClickableInput.isClickableInput(target)) {
+            return ()=>instance.dispatchUIEvent(target, 'click');
+        }
+    }
+};

package/node_modules/@testing-library/user-event/dist/cjs/event/behavior/paste.js

@@ -0,0 +1,18 @@
+'use strict';
+
+require('../../utils/dataTransfer/Clipboard.js');
+var isEditable = require('../../utils/edit/isEditable.js');
+var input = require('../input.js');
+var registry = require('./registry.js');
+
+registry.behavior.paste = (event, target, instance)=>{
+    if (isEditable.isEditable(target)) {
+        return ()=>{
+            var _event_clipboardData;
+            const insertData = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === undefined ? undefined : _event_clipboardData.getData('text');
+            if (insertData) {
+                input.input(instance, target, insertData, 'insertFromPaste');
+            }
+        };
+    }
+};