@dotss/ui 1.0.1 → 1.0.3

package/node_modules/@testing-library/user-event/dist/cjs/utils/focus/getTabDestination.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var isDisabled = require('../misc/isDisabled.js');
+var isElementType = require('../misc/isElementType.js');
+var isVisible = require('../misc/isVisible.js');
+var selector = require('./selector.js');
+
+function getTabDestination(activeElement, shift) {
+    const document = activeElement.ownerDocument;
+    const focusableElements = document.querySelectorAll(selector.FOCUSABLE_SELECTOR);
+    const enabledElements = Array.from(focusableElements).filter((el)=>el === activeElement || !(Number(el.getAttribute('tabindex')) < 0 || isDisabled.isDisabled(el)));
+    // tabindex has no effect if the active element has negative tabindex
+    if (Number(activeElement.getAttribute('tabindex')) >= 0) {
+        enabledElements.sort((a, b)=>{
+            const i = Number(a.getAttribute('tabindex'));
+            const j = Number(b.getAttribute('tabindex'));
+            if (i === j) {
+                return 0;
+            } else if (i === 0) {
+                return 1;
+            } else if (j === 0) {
+                return -1;
+            }
+            return i - j;
+        });
+    }
+    const checkedRadio = {};
+    let prunedElements = [
+        document.body
+    ];
+    const activeRadioGroup = isElementType.isElementType(activeElement, 'input', {
+        type: 'radio'
+    }) ? activeElement.name : undefined;
+    enabledElements.forEach((currentElement)=>{
+        const el = currentElement;
+        // For radio groups keep only the active radio
+        // If there is no active radio, keep only the checked radio
+        // If there is no checked radio, treat like everything else
+        if (isElementType.isElementType(el, 'input', {
+            type: 'radio'
+        }) && el.name) {
+            // If the active element is part of the group, add only that
+            if (el === activeElement) {
+                prunedElements.push(el);
+                return;
+            } else if (el.name === activeRadioGroup) {
+                return;
+            }
+            // If we stumble upon a checked radio, remove the others
+            if (el.checked) {
+                prunedElements = prunedElements.filter((e)=>!isElementType.isElementType(e, 'input', {
+                        type: 'radio',
+                        name: el.name
+                    }));
+                prunedElements.push(el);
+                checkedRadio[el.name] = el;
+                return;
+            }
+            // If we already found the checked one, skip
+            if (typeof checkedRadio[el.name] !== 'undefined') {
+                return;
+            }
+        }
+        prunedElements.push(el);
+    });
+    for(let index = prunedElements.findIndex((el)=>el === activeElement);;){
+        index += shift ? -1 : 1;
+        // loop at overflow
+        if (index === prunedElements.length) {
+            index = 0;
+        } else if (index === -1) {
+            index = prunedElements.length - 1;
+        }
+        if (prunedElements[index] === activeElement || prunedElements[index] === document.body || isVisible.isVisible(prunedElements[index])) {
+            return prunedElements[index];
+        }
+    }
+}
+
+exports.getTabDestination = getTabDestination;

package/node_modules/@testing-library/user-event/dist/cjs/utils/focus/isFocusable.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var selector = require('./selector.js');
+
+function isFocusable(element) {
+    return element.matches(selector.FOCUSABLE_SELECTOR);
+}
+
+exports.isFocusable = isFocusable;

package/node_modules/@testing-library/user-event/dist/cjs/utils/focus/selection.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var isClickableInput = require('../click/isClickableInput.js');
+var isEditable = require('../edit/isEditable.js');
+
+/**
+ * Determine if the element has its own selection implementation
+ * and does not interact with the Document Selection API.
+ */ function hasOwnSelection(node) {
+    return isElement(node) && isEditable.isEditableInputOrTextArea(node);
+}
+function hasNoSelection(node) {
+    return isElement(node) && isClickableInput.isClickableInput(node);
+}
+function isElement(node) {
+    return node.nodeType === 1;
+}
+
+exports.hasNoSelection = hasNoSelection;
+exports.hasOwnSelection = hasOwnSelection;

package/node_modules/@testing-library/user-event/dist/cjs/utils/focus/selector.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const FOCUSABLE_SELECTOR = [
+    'input:not([type=hidden]):not([disabled])',
+    'button:not([disabled])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    '[contenteditable=""]',
+    '[contenteditable="true"]',
+    'a[href]',
+    '[tabindex]:not([disabled])'
+].join(', ');
+
+exports.FOCUSABLE_SELECTOR = FOCUSABLE_SELECTOR;

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

@@ -0,0 +1,78 @@
+'use strict';
+
+var isClickableInput = require('./click/isClickableInput.js');
+var Blob = require('./dataTransfer/Blob.js');
+var DataTransfer = require('./dataTransfer/DataTransfer.js');
+var FileList = require('./dataTransfer/FileList.js');
+var Clipboard = require('./dataTransfer/Clipboard.js');
+var timeValue = require('./edit/timeValue.js');
+var isContentEditable = require('./edit/isContentEditable.js');
+var isEditable = require('./edit/isEditable.js');
+var maxLength = require('./edit/maxLength.js');
+var setFiles = require('./edit/setFiles.js');
+var cursor = require('./focus/cursor.js');
+var getActiveElement = require('./focus/getActiveElement.js');
+var getTabDestination = require('./focus/getTabDestination.js');
+var isFocusable = require('./focus/isFocusable.js');
+var selection = require('./focus/selection.js');
+var selector = require('./focus/selector.js');
+var readNextDescriptor = require('./keyDef/readNextDescriptor.js');
+var cloneEvent = require('./misc/cloneEvent.js');
+var findClosest = require('./misc/findClosest.js');
+var getDocumentFromNode = require('./misc/getDocumentFromNode.js');
+var getTreeDiff = require('./misc/getTreeDiff.js');
+var getWindow = require('./misc/getWindow.js');
+var isDescendantOrSelf = require('./misc/isDescendantOrSelf.js');
+var isElementType = require('./misc/isElementType.js');
+var isVisible = require('./misc/isVisible.js');
+var isDisabled = require('./misc/isDisabled.js');
+var level = require('./misc/level.js');
+var wait = require('./misc/wait.js');
+var cssPointerEvents = require('./pointer/cssPointerEvents.js');
+
+
+
+exports.isClickableInput = isClickableInput.isClickableInput;
+exports.readBlobText = Blob.readBlobText;
+exports.createDataTransfer = DataTransfer.createDataTransfer;
+exports.getBlobFromDataTransferItem = DataTransfer.getBlobFromDataTransferItem;
+exports.createFileList = FileList.createFileList;
+exports.attachClipboardStubToView = Clipboard.attachClipboardStubToView;
+exports.createClipboardItem = Clipboard.createClipboardItem;
+exports.detachClipboardStubFromView = Clipboard.detachClipboardStubFromView;
+exports.readDataTransferFromClipboard = Clipboard.readDataTransferFromClipboard;
+exports.resetClipboardStubOnView = Clipboard.resetClipboardStubOnView;
+exports.writeDataTransferToClipboard = Clipboard.writeDataTransferToClipboard;
+exports.buildTimeValue = timeValue.buildTimeValue;
+exports.isValidDateOrTimeValue = timeValue.isValidDateOrTimeValue;
+exports.getContentEditable = isContentEditable.getContentEditable;
+exports.isContentEditable = isContentEditable.isContentEditable;
+exports.isEditable = isEditable.isEditable;
+exports.isEditableInputOrTextArea = isEditable.isEditableInputOrTextArea;
+exports.getMaxLength = maxLength.getMaxLength;
+exports.supportsMaxLength = maxLength.supportsMaxLength;
+exports.setFiles = setFiles.setFiles;
+exports.getNextCursorPosition = cursor.getNextCursorPosition;
+exports.getActiveElement = getActiveElement.getActiveElement;
+exports.getActiveElementOrBody = getActiveElement.getActiveElementOrBody;
+exports.getTabDestination = getTabDestination.getTabDestination;
+exports.isFocusable = isFocusable.isFocusable;
+exports.hasNoSelection = selection.hasNoSelection;
+exports.hasOwnSelection = selection.hasOwnSelection;
+exports.FOCUSABLE_SELECTOR = selector.FOCUSABLE_SELECTOR;
+exports.readNextDescriptor = readNextDescriptor.readNextDescriptor;
+exports.cloneEvent = cloneEvent.cloneEvent;
+exports.findClosest = findClosest.findClosest;
+exports.getDocumentFromNode = getDocumentFromNode.getDocumentFromNode;
+exports.getTreeDiff = getTreeDiff.getTreeDiff;
+exports.getWindow = getWindow.getWindow;
+exports.isDescendantOrSelf = isDescendantOrSelf.isDescendantOrSelf;
+exports.isElementType = isElementType.isElementType;
+exports.isVisible = isVisible.isVisible;
+exports.isDisabled = isDisabled.isDisabled;
+exports.ApiLevel = level.ApiLevel;
+exports.getLevelRef = level.getLevelRef;
+exports.setLevelRef = level.setLevelRef;
+exports.wait = wait.wait;
+exports.assertPointerEvents = cssPointerEvents.assertPointerEvents;
+exports.hasPointerEvents = cssPointerEvents.hasPointerEvents;

package/node_modules/@testing-library/user-event/dist/cjs/utils/keyDef/readNextDescriptor.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var bracketDict = /*#__PURE__*/ function(bracketDict) {
+    bracketDict["{"] = "}";
+    bracketDict["["] = "]";
+    return bracketDict;
+}(bracketDict || {});
+/**
+ * Read the next key definition from user input
+ *
+ * Describe key per `{descriptor}` or `[descriptor]`.
+ * Everything else will be interpreted as a single character as descriptor - e.g. `a`.
+ * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
+ * A previously pressed key can be released per `{/descriptor}`.
+ * Keeping the key pressed can be written as `{descriptor>}`.
+ * When keeping the key pressed you can choose how long the key is pressed `{descriptor>3}`.
+ * You can then release the key per `{descriptor>3/}` or keep it pressed and continue with the next key.
+ */ function readNextDescriptor(text, context) {
+    let pos = 0;
+    const startBracket = text[pos] in bracketDict ? text[pos] : '';
+    pos += startBracket.length;
+    const isEscapedChar = new RegExp(`^\\${startBracket}{2}`).test(text);
+    const type = isEscapedChar ? '' : startBracket;
+    return {
+        type,
+        ...type === '' ? readPrintableChar(text, pos, context) : readTag(text, pos, type, context)
+    };
+}
+function readPrintableChar(text, pos, context) {
+    const descriptor = text[pos];
+    assertDescriptor(descriptor, text, pos, context);
+    pos += descriptor.length;
+    return {
+        consumedLength: pos,
+        descriptor,
+        releasePrevious: false,
+        releaseSelf: true,
+        repeat: 1
+    };
+}
+function readTag(text, pos, startBracket, context) {
+    var _text_slice_match, _text_slice_match1;
+    const releasePreviousModifier = text[pos] === '/' ? '/' : '';
+    pos += releasePreviousModifier.length;
+    const escapedDescriptor = startBracket === '{' && text[pos] === '\\';
+    pos += Number(escapedDescriptor);
+    const descriptor = escapedDescriptor ? text[pos] : (_text_slice_match = text.slice(pos).match(startBracket === '{' ? /^\w+|^[^}>/]/ : /^\w+/)) === null || _text_slice_match === undefined ? undefined : _text_slice_match[0];
+    assertDescriptor(descriptor, text, pos, context);
+    pos += descriptor.length;
+    var _text_slice_match_;
+    const repeatModifier = (_text_slice_match_ = (_text_slice_match1 = text.slice(pos).match(/^>\d+/)) === null || _text_slice_match1 === undefined ? undefined : _text_slice_match1[0]) !== null && _text_slice_match_ !== undefined ? _text_slice_match_ : '';
+    pos += repeatModifier.length;
+    const releaseSelfModifier = text[pos] === '/' || !repeatModifier && text[pos] === '>' ? text[pos] : '';
+    pos += releaseSelfModifier.length;
+    const expectedEndBracket = bracketDict[startBracket];
+    const endBracket = text[pos] === expectedEndBracket ? expectedEndBracket : '';
+    if (!endBracket) {
+        throw new Error(getErrorMessage([
+            !repeatModifier && 'repeat modifier',
+            !releaseSelfModifier && 'release modifier',
+            `"${expectedEndBracket}"`
+        ].filter(Boolean).join(' or '), text[pos], text, context));
+    }
+    pos += endBracket.length;
+    return {
+        consumedLength: pos,
+        descriptor,
+        releasePrevious: !!releasePreviousModifier,
+        repeat: repeatModifier ? Math.max(Number(repeatModifier.substr(1)), 1) : 1,
+        releaseSelf: hasReleaseSelf(releaseSelfModifier, repeatModifier)
+    };
+}
+function assertDescriptor(descriptor, text, pos, context) {
+    if (!descriptor) {
+        throw new Error(getErrorMessage('key descriptor', text[pos], text, context));
+    }
+}
+function hasReleaseSelf(releaseSelfModifier, repeatModifier) {
+    if (releaseSelfModifier) {
+        return releaseSelfModifier === '/';
+    }
+    if (repeatModifier) {
+        return false;
+    }
+}
+function getErrorMessage(expected, found, text, context) {
+    return `Expected ${expected} but found "${found !== null && found !== undefined ? found : ''}" in "${text}"
+    See ${context === 'pointer' ? `https://testing-library.com/docs/user-event/pointer#pressing-a-button-or-touching-the-screen` : `https://testing-library.com/docs/user-event/keyboard`}
+    for more information about how userEvent parses your input.`;
+}
+
+exports.readNextDescriptor = readNextDescriptor;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/cloneEvent.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function cloneEvent(event) {
+    return new event.constructor(event.type, event);
+}
+
+exports.cloneEvent = cloneEvent;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/findClosest.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function findClosest(element, callback) {
+    let el = element;
+    do {
+        if (callback(el)) {
+            return el;
+        }
+        el = el.parentElement;
+    }while (el && el !== element.ownerDocument.body)
+    return undefined;
+}
+
+exports.findClosest = findClosest;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/getDocumentFromNode.js

@@ -0,0 +1,10 @@
+'use strict';
+
+function getDocumentFromNode(el) {
+    return isDocument(el) ? el : el.ownerDocument;
+}
+function isDocument(node) {
+    return node.nodeType === 9;
+}
+
+exports.getDocumentFromNode = getDocumentFromNode;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/getTreeDiff.js

@@ -0,0 +1,25 @@
+'use strict';
+
+function getTreeDiff(a, b) {
+    const treeA = [];
+    for(let el = a; el; el = el.parentElement){
+        treeA.push(el);
+    }
+    const treeB = [];
+    for(let el = b; el; el = el.parentElement){
+        treeB.push(el);
+    }
+    let i = 0;
+    for(;; i++){
+        if (i >= treeA.length || i >= treeB.length || treeA[treeA.length - 1 - i] !== treeB[treeB.length - 1 - i]) {
+            break;
+        }
+    }
+    return [
+        treeA.slice(0, treeA.length - i),
+        treeB.slice(0, treeB.length - i),
+        treeB.slice(treeB.length - i)
+    ];
+}
+
+exports.getTreeDiff = getTreeDiff;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/getWindow.js

@@ -0,0 +1,19 @@
+'use strict';
+
+function getWindow(node) {
+    var _node_ownerDocument;
+    if (isDocument(node) && node.defaultView) {
+        return node.defaultView;
+    } else if ((_node_ownerDocument = node.ownerDocument) === null || _node_ownerDocument === undefined ? undefined : _node_ownerDocument.defaultView) {
+        return node.ownerDocument.defaultView;
+    }
+    throw new Error(`Could not determine window of node. Node was ${describe(node)}`);
+}
+function isDocument(node) {
+    return node.nodeType === 9;
+}
+function describe(val) {
+    return typeof val === 'function' ? `function ${val.name}` : val === null ? 'null' : String(val);
+}
+
+exports.getWindow = getWindow;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/isDescendantOrSelf.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function isDescendantOrSelf(potentialDescendant, potentialAncestor) {
+    let el = potentialDescendant;
+    do {
+        if (el === potentialAncestor) {
+            return true;
+        }
+        el = el.parentElement;
+    }while (el)
+    return false;
+}
+
+exports.isDescendantOrSelf = isDescendantOrSelf;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/isDisabled.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var isElementType = require('./isElementType.js');
+
+// This should probably just rely on the :disabled pseudo-class, but JSDOM doesn't implement it properly.
+function isDisabled(element) {
+    for(let el = element; el; el = el.parentElement){
+        if (isElementType.isElementType(el, [
+            'button',
+            'input',
+            'select',
+            'textarea',
+            'optgroup',
+            'option'
+        ])) {
+            if (el.hasAttribute('disabled')) {
+                return true;
+            }
+        } else if (isElementType.isElementType(el, 'fieldset')) {
+            var _el_querySelector;
+            if (el.hasAttribute('disabled') && !((_el_querySelector = el.querySelector(':scope > legend')) === null || _el_querySelector === undefined ? undefined : _el_querySelector.contains(element))) {
+                return true;
+            }
+        } else if (el.tagName.includes('-')) {
+            if (el.constructor.formAssociated && el.hasAttribute('disabled')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+exports.isDisabled = isDisabled;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/isElementType.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function isElementType(element, tag, props) {
+    if (element.namespaceURI && element.namespaceURI !== 'http://www.w3.org/1999/xhtml') {
+        return false;
+    }
+    tag = Array.isArray(tag) ? tag : [
+        tag
+    ];
+    // tagName is uppercase in HTMLDocument and lowercase in XMLDocument
+    if (!tag.includes(element.tagName.toLowerCase())) {
+        return false;
+    }
+    if (props) {
+        return Object.entries(props).every(([k, v])=>element[k] === v);
+    }
+    return true;
+}
+
+exports.isElementType = isElementType;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/isVisible.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var getWindow = require('./getWindow.js');
+
+function isVisible(element) {
+    const window = getWindow.getWindow(element);
+    for(let el = element; el === null || el === undefined ? undefined : el.ownerDocument; el = el.parentElement){
+        const { display, visibility } = window.getComputedStyle(el);
+        if (display === 'none') {
+            return false;
+        }
+        if (visibility === 'hidden') {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.isVisible = isVisible;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/level.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var ApiLevel = /*#__PURE__*/ function(ApiLevel) {
+    ApiLevel[ApiLevel["Trigger"] = 2] = "Trigger";
+    ApiLevel[ApiLevel["Call"] = 1] = "Call";
+    return ApiLevel;
+}({});
+function setLevelRef(instance, level) {
+    instance.levelRefs[level] = {};
+}
+function getLevelRef(instance, level) {
+    return instance.levelRefs[level];
+}
+
+exports.ApiLevel = ApiLevel;
+exports.getLevelRef = getLevelRef;
+exports.setLevelRef = setLevelRef;

package/node_modules/@testing-library/user-event/dist/cjs/utils/misc/wait.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function wait(config) {
+    const delay = config.delay;
+    if (typeof delay !== 'number') {
+        return;
+    }
+    return Promise.all([
+        new Promise((resolve)=>globalThis.setTimeout(()=>resolve(), delay)),
+        config.advanceTimers(delay)
+    ]);
+}
+
+exports.wait = wait;

package/node_modules/@testing-library/user-event/dist/cjs/utils/pointer/cssPointerEvents.js

@@ -0,0 +1,103 @@
+'use strict';
+
+var options = require('../../options.js');
+var getWindow = require('../misc/getWindow.js');
+var isElementType = require('../misc/isElementType.js');
+var level = require('../misc/level.js');
+
+function hasPointerEvents(instance, element) {
+    var _checkPointerEvents;
+    return ((_checkPointerEvents = checkPointerEvents(instance, element)) === null || _checkPointerEvents === undefined ? undefined : _checkPointerEvents.pointerEvents) !== 'none';
+}
+function closestPointerEventsDeclaration(element) {
+    const window = getWindow.getWindow(element);
+    for(let el = element, tree = []; el === null || el === undefined ? undefined : 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 !== options.PointerEventsCheckLevel.Never && (!lastCheck || hasBitFlag(instance.config.pointerEventsCheck, options.PointerEventsCheckLevel.EachApiCall) && lastCheck[level.ApiLevel.Call] !== level.getLevelRef(instance, level.ApiLevel.Call) || hasBitFlag(instance.config.pointerEventsCheck, options.PointerEventsCheckLevel.EachTrigger) && lastCheck[level.ApiLevel.Trigger] !== level.getLevelRef(instance, level.ApiLevel.Trigger));
+    if (!needsCheck) {
+        return lastCheck === null || lastCheck === undefined ? undefined : lastCheck.result;
+    }
+    const declaration = closestPointerEventsDeclaration(element);
+    element[PointerEventsCheck] = {
+        [level.ApiLevel.Call]: level.getLevelRef(instance, level.ApiLevel.Call),
+        [level.ApiLevel.Trigger]: level.getLevelRef(instance, level.ApiLevel.Trigger),
+        result: declaration
+    };
+    return declaration;
+}
+function assertPointerEvents(instance, element) {
+    const declaration = checkPointerEvents(instance, element);
+    if ((declaration === null || declaration === undefined ? undefined : 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 === undefined ? undefined : (_element_ownerDocument_getElementById_textContent = _element_ownerDocument_getElementById.textContent) === null || _element_ownerDocument_getElementById_textContent === undefined ? undefined : _element_ownerDocument_getElementById_textContent.trim();
+    } else if (isElementType.isElementType(element, [
+        'button',
+        'input',
+        'meter',
+        'output',
+        'progress',
+        'select',
+        'textarea'
+    ]) && ((_element_labels = element.labels) === null || _element_labels === undefined ? undefined : _element_labels.length)) {
+        label = Array.from(element.labels).map((el)=>{
+            var _el_textContent;
+            return (_el_textContent = el.textContent) === null || _el_textContent === undefined ? undefined : _el_textContent.trim();
+        }).join('|');
+    } else if (isElementType.isElementType(element, 'button')) {
+        var _element_textContent;
+        label = (_element_textContent = element.textContent) === null || _element_textContent === undefined ? undefined : _element_textContent.trim();
+    }
+    label = label === null || label === undefined ? undefined : label.replace(/\n/g, '  ');
+    if (Number(label === null || label === undefined ? undefined : label.length) > 30) {
+        label = `${label === null || label === undefined ? undefined : 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) {
+    // eslint-disable-next-line no-bitwise
+    return (conf & flag) > 0;
+}
+
+exports.assertPointerEvents = assertPointerEvents;
+exports.hasPointerEvents = hasPointerEvents;

package/node_modules/@testing-library/user-event/dist/esm/clipboard/copy.js

@@ -0,0 +1,20 @@
+import { writeDataTransferToClipboard } from '../utils/dataTransfer/Clipboard.js';
+import { copySelection } from '../document/copySelection.js';
+
+async function copy() {
+    const doc = this.config.document;
+    var _doc_activeElement;
+    const target = (_doc_activeElement = doc.activeElement) !== null && _doc_activeElement !== undefined ? _doc_activeElement : /* istanbul ignore next */ doc.body;
+    const clipboardData = copySelection(target);
+    if (clipboardData.items.length === 0) {
+        return;
+    }
+    if (this.dispatchUIEvent(target, 'copy', {
+        clipboardData
+    }) && this.config.writeToClipboard) {
+        await writeDataTransferToClipboard(doc, clipboardData);
+    }
+    return clipboardData;
+}
+
+export { copy };

package/node_modules/@testing-library/user-event/dist/esm/clipboard/cut.js

@@ -0,0 +1,20 @@
+import { writeDataTransferToClipboard } from '../utils/dataTransfer/Clipboard.js';
+import { copySelection } from '../document/copySelection.js';
+
+async function cut() {
+    const doc = this.config.document;
+    var _doc_activeElement;
+    const target = (_doc_activeElement = doc.activeElement) !== null && _doc_activeElement !== undefined ? _doc_activeElement : /* istanbul ignore next */ doc.body;
+    const clipboardData = copySelection(target);
+    if (clipboardData.items.length === 0) {
+        return;
+    }
+    if (this.dispatchUIEvent(target, 'cut', {
+        clipboardData
+    }) && this.config.writeToClipboard) {
+        await writeDataTransferToClipboard(target.ownerDocument, clipboardData);
+    }
+    return clipboardData;
+}
+
+export { cut };

package/node_modules/@testing-library/user-event/dist/esm/clipboard/index.js

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