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

package/dist/esm/document/patchFocus.js

@@ -0,0 +1,103 @@
+import { dispatchDOMEvent } from '../event/dispatchEvent.js';
+import '../utils/dataTransfer/Clipboard.js';
+import { getActiveElement } from '../utils/focus/getActiveElement.js';
+import '@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,
+            value: patchedFocus,
+            writable: true
+        },
+        blur: {
+            configurable: true,
+            value: patchedBlur,
+            writable: true
+        },
+        [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);
+            dispatchDOMEvent(blurred, 'blur', {
+                relatedTarget: this
+            });
+            dispatchDOMEvent(blurred, 'focusout', {
+                relatedTarget: activeCall === thisCall ? this : null
+            });
+        }
+        if (activeCall === thisCall) {
+            focus.call(this, options);
+            dispatchDOMEvent(this, 'focus', {
+                relatedTarget: blurred
+            });
+        }
+        if (activeCall === thisCall) {
+            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);
+        dispatchDOMEvent(blurred, 'blur', {
+            relatedTarget: null
+        });
+        dispatchDOMEvent(blurred, 'focusout', {
+            relatedTarget: null
+        });
+    }
+}
+function getActiveTarget(document) {
+    const active = getActiveElement(document);
+    return (active === null || active === void 0 ? void 0 : 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
+            }
+        });
+    }
+}
+
+export { patchFocus, restoreFocus };

package/dist/esm/document/prepareDocument.js

@@ -0,0 +1,56 @@
+import { dispatchDOMEvent } from '../event/dispatchEvent.js';
+import { isElementType } from '../utils/misc/isElementType.js';
+import '../utils/dataTransfer/Clipboard.js';
+import { getInitialValue, clearInitialValue } from './UI.js';
+import '@testing-library/dom';
+import { prepareValueInterceptor, prepareSelectionInterceptor, prepareRangeTextInterceptor } from './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 = getInitialValue(el);
+        if (initialValue !== undefined) {
+            if (el.value !== initialValue) {
+                dispatchDOMEvent(el, 'change');
+            }
+            clearInitialValue(el);
+        }
+    }, {
+        capture: true,
+        passive: true
+    });
+    document[isPrepared] = isPrepared;
+}
+function prepareElement(el) {
+    if (el[isPrepared]) {
+        return;
+    }
+    if (isElementType(el, [
+        'input',
+        'textarea'
+    ])) {
+        prepareValueInterceptor(el);
+        prepareSelectionInterceptor(el);
+        prepareRangeTextInterceptor(el);
+    }
+    el[isPrepared] = isPrepared;
+}
+
+export { prepareDocument };

package/dist/esm/document/trackValue.js

@@ -0,0 +1,53 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { getWindow } from '../utils/misc/getWindow.js';
+import { setUIValueClean, hasUISelection, setUISelection } from './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(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 === void 0 ? void 0 : (_element_TrackChanges_tracked = _element_TrackChanges.tracked) === null || _element_TrackChanges_tracked === void 0 ? void 0 : _element_TrackChanges_tracked.push(v);
+    if (!element[TrackChanges]) {
+        setUIValueClean(element);
+        setUISelection(element, {
+            focusOffset: v.length
+        });
+    }
+}
+function commitValueAfterInput(element, cursorOffset) {
+    var _changes_tracked;
+    const changes = element[TrackChanges];
+    element[TrackChanges] = undefined;
+    if (!(changes === null || changes === void 0 ? void 0 : (_changes_tracked = changes.tracked) === null || _changes_tracked === void 0 ? void 0 : _changes_tracked.length)) {
+        return;
+    }
+    const isJustReactStateUpdate = changes.tracked.length === 2 && changes.tracked[0] === changes.previousValue && changes.tracked[1] === element.value;
+    if (!isJustReactStateUpdate) {
+        setUIValueClean(element);
+    }
+    if (hasUISelection(element)) {
+        setUISelection(element, {
+            focusOffset: isJustReactStateUpdate ? cursorOffset : element.value.length
+        });
+    }
+}
+
+export { commitValueAfterInput, startTrackValue, trackOrSetValue };

package/dist/esm/event/behavior/click.js

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

package/dist/esm/event/behavior/cut.js

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

package/dist/esm/event/behavior/index.js

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

package/dist/esm/event/behavior/keydown.js

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

package/dist/esm/event/behavior/keypress.js

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

package/dist/esm/event/behavior/keyup.js

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

package/dist/esm/event/behavior/paste.js

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

package/dist/esm/event/behavior/registry.js

@@ -0,0 +1,3 @@
+const behavior = {};
+
+export { behavior };

package/dist/esm/event/createEvent.js

@@ -0,0 +1,191 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { getWindow } from '../utils/misc/getWindow.js';
+import { eventMap } from './eventMap.js';
+
+const eventInitializer = {
+    ClipboardEvent: [
+        initClipboardEvent
+    ],
+    Event: [],
+    FocusEvent: [
+        initUIEvent,
+        initFocusEvent
+    ],
+    InputEvent: [
+        initUIEvent,
+        initInputEvent
+    ],
+    MouseEvent: [
+        initUIEvent,
+        initUIEventModifiers,
+        initMouseEvent
+    ],
+    PointerEvent: [
+        initUIEvent,
+        initUIEventModifiers,
+        initMouseEvent,
+        initPointerEvent
+    ],
+    KeyboardEvent: [
+        initUIEvent,
+        initUIEventModifiers,
+        initKeyboardEvent
+    ]
+};
+function createEvent(type, target, init) {
+    const window = getWindow(target);
+    const { EventType, defaultInit } = eventMap[type];
+    const event = new (getEventConstructors(window))[EventType](type, defaultInit);
+    eventInitializer[EventType].forEach((f)=>f(event, init !== null && init !== void 0 ? init : {}));
+    return event;
+}
+/* istanbul ignore next */ function getEventConstructors(window) {
+    var _window_Event, _window_AnimationEvent, _window_ClipboardEvent, _window_PopStateEvent, _window_ProgressEvent, _window_TransitionEvent, _window_UIEvent, _window_CompositionEvent, _window_FocusEvent, _window_InputEvent, _window_KeyboardEvent, _window_MouseEvent, _window_DragEvent, _window_PointerEvent, _window_TouchEvent;
+    const Event = (_window_Event = window.Event) !== null && _window_Event !== void 0 ? _window_Event : class Event {
+    };
+    const AnimationEvent = (_window_AnimationEvent = window.AnimationEvent) !== null && _window_AnimationEvent !== void 0 ? _window_AnimationEvent : class AnimationEvent extends Event {
+    };
+    const ClipboardEvent = (_window_ClipboardEvent = window.ClipboardEvent) !== null && _window_ClipboardEvent !== void 0 ? _window_ClipboardEvent : class ClipboardEvent extends Event {
+    };
+    const PopStateEvent = (_window_PopStateEvent = window.PopStateEvent) !== null && _window_PopStateEvent !== void 0 ? _window_PopStateEvent : class PopStateEvent extends Event {
+    };
+    const ProgressEvent = (_window_ProgressEvent = window.ProgressEvent) !== null && _window_ProgressEvent !== void 0 ? _window_ProgressEvent : class ProgressEvent extends Event {
+    };
+    const TransitionEvent = (_window_TransitionEvent = window.TransitionEvent) !== null && _window_TransitionEvent !== void 0 ? _window_TransitionEvent : class TransitionEvent extends Event {
+    };
+    const UIEvent = (_window_UIEvent = window.UIEvent) !== null && _window_UIEvent !== void 0 ? _window_UIEvent : class UIEvent extends Event {
+    };
+    const CompositionEvent = (_window_CompositionEvent = window.CompositionEvent) !== null && _window_CompositionEvent !== void 0 ? _window_CompositionEvent : class CompositionEvent extends UIEvent {
+    };
+    const FocusEvent = (_window_FocusEvent = window.FocusEvent) !== null && _window_FocusEvent !== void 0 ? _window_FocusEvent : class FocusEvent extends UIEvent {
+    };
+    const InputEvent = (_window_InputEvent = window.InputEvent) !== null && _window_InputEvent !== void 0 ? _window_InputEvent : class InputEvent extends UIEvent {
+    };
+    const KeyboardEvent = (_window_KeyboardEvent = window.KeyboardEvent) !== null && _window_KeyboardEvent !== void 0 ? _window_KeyboardEvent : class KeyboardEvent extends UIEvent {
+    };
+    const MouseEvent = (_window_MouseEvent = window.MouseEvent) !== null && _window_MouseEvent !== void 0 ? _window_MouseEvent : class MouseEvent extends UIEvent {
+    };
+    const DragEvent = (_window_DragEvent = window.DragEvent) !== null && _window_DragEvent !== void 0 ? _window_DragEvent : class DragEvent extends MouseEvent {
+    };
+    const PointerEvent = (_window_PointerEvent = window.PointerEvent) !== null && _window_PointerEvent !== void 0 ? _window_PointerEvent : class PointerEvent extends MouseEvent {
+    };
+    const TouchEvent = (_window_TouchEvent = window.TouchEvent) !== null && _window_TouchEvent !== void 0 ? _window_TouchEvent : class TouchEvent extends UIEvent {
+    };
+    return {
+        Event,
+        AnimationEvent,
+        ClipboardEvent,
+        PopStateEvent,
+        ProgressEvent,
+        TransitionEvent,
+        UIEvent,
+        CompositionEvent,
+        FocusEvent,
+        InputEvent,
+        KeyboardEvent,
+        MouseEvent,
+        DragEvent,
+        PointerEvent,
+        TouchEvent
+    };
+}
+function assignProps(obj, props) {
+    for (const [key, value] of Object.entries(props)){
+        Object.defineProperty(obj, key, {
+            get: ()=>value !== null && value !== void 0 ? value : null
+        });
+    }
+}
+function sanitizeNumber(n) {
+    return Number(n !== null && n !== void 0 ? n : 0);
+}
+function initClipboardEvent(event, { clipboardData }) {
+    assignProps(event, {
+        clipboardData
+    });
+}
+function initFocusEvent(event, { relatedTarget }) {
+    assignProps(event, {
+        relatedTarget
+    });
+}
+function initInputEvent(event, { data, inputType, isComposing }) {
+    assignProps(event, {
+        data,
+        isComposing: Boolean(isComposing),
+        inputType: String(inputType)
+    });
+}
+function initUIEvent(event, { view, detail }) {
+    assignProps(event, {
+        view,
+        detail: sanitizeNumber(detail !== null && detail !== void 0 ? detail : 0)
+    });
+}
+function initUIEventModifiers(event, { altKey, ctrlKey, metaKey, shiftKey, modifierAltGraph, modifierCapsLock, modifierFn, modifierFnLock, modifierNumLock, modifierScrollLock, modifierSymbol, modifierSymbolLock }) {
+    assignProps(event, {
+        altKey: Boolean(altKey),
+        ctrlKey: Boolean(ctrlKey),
+        metaKey: Boolean(metaKey),
+        shiftKey: Boolean(shiftKey),
+        getModifierState (k) {
+            return Boolean({
+                Alt: altKey,
+                AltGraph: modifierAltGraph,
+                CapsLock: modifierCapsLock,
+                Control: ctrlKey,
+                Fn: modifierFn,
+                FnLock: modifierFnLock,
+                Meta: metaKey,
+                NumLock: modifierNumLock,
+                ScrollLock: modifierScrollLock,
+                Shift: shiftKey,
+                Symbol: modifierSymbol,
+                SymbolLock: modifierSymbolLock
+            }[k]);
+        }
+    });
+}
+function initKeyboardEvent(event, { key, code, location, repeat, isComposing, charCode }) {
+    assignProps(event, {
+        key: String(key),
+        code: String(code),
+        location: sanitizeNumber(location),
+        repeat: Boolean(repeat),
+        isComposing: Boolean(isComposing),
+        charCode
+    });
+}
+function initMouseEvent(event, { x, y, screenX, screenY, clientX = x, clientY = y, button, buttons, relatedTarget, offsetX, offsetY, pageX, pageY }) {
+    assignProps(event, {
+        screenX: sanitizeNumber(screenX),
+        screenY: sanitizeNumber(screenY),
+        clientX: sanitizeNumber(clientX),
+        x: sanitizeNumber(clientX),
+        clientY: sanitizeNumber(clientY),
+        y: sanitizeNumber(clientY),
+        button: sanitizeNumber(button),
+        buttons: sanitizeNumber(buttons),
+        relatedTarget,
+        offsetX: sanitizeNumber(offsetX),
+        offsetY: sanitizeNumber(offsetY),
+        pageX: sanitizeNumber(pageX),
+        pageY: sanitizeNumber(pageY)
+    });
+}
+function initPointerEvent(event, { pointerId, width, height, pressure, tangentialPressure, tiltX, tiltY, twist, pointerType, isPrimary, buttons }) {
+    assignProps(event, {
+        pointerId: sanitizeNumber(pointerId),
+        width: sanitizeNumber(width !== null && width !== void 0 ? width : 1),
+        height: sanitizeNumber(height !== null && height !== void 0 ? height : 1),
+        pressure: sanitizeNumber(pressure !== null && pressure !== void 0 ? pressure : buttons ? 0.5 : 0),
+        tangentialPressure: sanitizeNumber(tangentialPressure),
+        tiltX: sanitizeNumber(tiltX),
+        tiltY: sanitizeNumber(tiltY),
+        twist: sanitizeNumber(twist),
+        pointerType: String(pointerType),
+        isPrimary: Boolean(isPrimary)
+    });
+}
+
+export { createEvent };