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

package/dist/cjs/utils/edit/setFiles.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// It is not possible to create a real FileList programmatically.
+// Therefore assigning `files` property with a programmatically created FileList results in an error.
+// Just assigning the property (as per fireEvent) breaks the interweaving with the `value` property.
+const fakeFiles = Symbol('files and value properties are mocked');
+function restoreProperty(obj, prop, descriptor) {
+    if (descriptor) {
+        Object.defineProperty(obj, prop, descriptor);
+    } else {
+        delete obj[prop];
+    }
+}
+function setFiles(el, files) {
+    var _el_fakeFiles;
+    (_el_fakeFiles = el[fakeFiles]) === null || _el_fakeFiles === void 0 ? void 0 : _el_fakeFiles.restore();
+    const typeDescr = Object.getOwnPropertyDescriptor(el, 'type');
+    const valueDescr = Object.getOwnPropertyDescriptor(el, 'value');
+    const filesDescr = Object.getOwnPropertyDescriptor(el, 'files');
+    function restore() {
+        restoreProperty(el, 'type', typeDescr);
+        restoreProperty(el, 'value', valueDescr);
+        restoreProperty(el, 'files', filesDescr);
+    }
+    el[fakeFiles] = {
+        restore
+    };
+    Object.defineProperties(el, {
+        files: {
+            configurable: true,
+            get: ()=>files
+        },
+        value: {
+            configurable: true,
+            get: ()=>files.length ? `C:\\fakepath\\${files[0].name}` : '',
+            set (v) {
+                if (v === '') {
+                    restore();
+                } else {
+                    var _valueDescr_set;
+                    valueDescr === null || valueDescr === void 0 ? void 0 : (_valueDescr_set = valueDescr.set) === null || _valueDescr_set === void 0 ? void 0 : _valueDescr_set.call(el, v);
+                }
+            }
+        },
+        type: {
+            configurable: true,
+            get: ()=>'file',
+            set (v) {
+                if (v !== 'file') {
+                    restore();
+                    el.type = v;
+                }
+            }
+        }
+    });
+}
+
+exports.setFiles = setFiles;

package/dist/cjs/utils/edit/timeValue.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const parseInt = globalThis.parseInt;
+function buildTimeValue(value) {
+    const onlyDigitsValue = value.replace(/\D/g, '');
+    if (onlyDigitsValue.length < 2) {
+        return value;
+    }
+    const firstDigit = parseInt(onlyDigitsValue[0], 10);
+    const secondDigit = parseInt(onlyDigitsValue[1], 10);
+    if (firstDigit >= 3 || firstDigit === 2 && secondDigit >= 4) {
+        let index;
+        if (firstDigit >= 3) {
+            index = 1;
+        } else {
+            index = 2;
+        }
+        return build(onlyDigitsValue, index);
+    }
+    if (value.length === 2) {
+        return value;
+    }
+    return build(onlyDigitsValue, 2);
+}
+function build(onlyDigitsValue, index) {
+    const hours = onlyDigitsValue.slice(0, index);
+    const validHours = Math.min(parseInt(hours, 10), 23);
+    const minuteCharacters = onlyDigitsValue.slice(index);
+    const parsedMinutes = parseInt(minuteCharacters, 10);
+    const validMinutes = Math.min(parsedMinutes, 59);
+    return `${validHours.toString().padStart(2, '0')}:${validMinutes.toString().padStart(2, '0')}`;
+}
+function isValidDateOrTimeValue(element, value) {
+    const clone = element.cloneNode();
+    clone.value = value;
+    return clone.value === value;
+}
+
+exports.buildTimeValue = buildTimeValue;
+exports.isValidDateOrTimeValue = isValidDateOrTimeValue;

package/dist/cjs/utils/focus/cursor.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var isContentEditable = require('../edit/isContentEditable.js');
+var isElementType = require('../misc/isElementType.js');
+
+function getNextCursorPosition(node, offset, direction, inputType) {
+    // The behavior at text node zero offset is inconsistent.
+    // When walking backwards:
+    // Firefox always moves to zero offset and jumps over last offset.
+    // Chrome jumps over zero offset per default but over last offset when Shift is pressed.
+    // The cursor always moves to zero offset if the focus area (contenteditable or body) ends there.
+    // When walking forward both ignore zero offset.
+    // When walking over input elements the cursor moves before or after that element.
+    // When walking over line breaks the cursor moves inside any following text node.
+    if (isTextNode(node) && offset + direction >= 0 && offset + direction <= node.nodeValue.length) {
+        return {
+            node,
+            offset: offset + direction
+        };
+    }
+    const nextNode = getNextCharacterContentNode(node, offset, direction);
+    if (nextNode) {
+        if (isTextNode(nextNode)) {
+            return {
+                node: nextNode,
+                offset: direction > 0 ? Math.min(1, nextNode.nodeValue.length) : Math.max(nextNode.nodeValue.length - 1, 0)
+            };
+        } else if (isElementType.isElementType(nextNode, 'br')) {
+            const nextPlusOne = getNextCharacterContentNode(nextNode, undefined, direction);
+            if (!nextPlusOne) {
+                // The behavior when there is no possible cursor position beyond the line break is inconsistent.
+                // In Chrome outside of contenteditable moving before a leading line break is possible.
+                // A leading line break can still be removed per deleteContentBackward.
+                // A trailing line break on the other hand is not removed by deleteContentForward.
+                if (direction < 0 && inputType === 'deleteContentBackward') {
+                    return {
+                        node: nextNode.parentNode,
+                        offset: getOffset(nextNode)
+                    };
+                }
+                return undefined;
+            } else if (isTextNode(nextPlusOne)) {
+                return {
+                    node: nextPlusOne,
+                    offset: direction > 0 ? 0 : nextPlusOne.nodeValue.length
+                };
+            } else if (direction < 0 && isElementType.isElementType(nextPlusOne, 'br')) {
+                return {
+                    node: nextNode.parentNode,
+                    offset: getOffset(nextNode)
+                };
+            } else {
+                return {
+                    node: nextPlusOne.parentNode,
+                    offset: getOffset(nextPlusOne) + (direction > 0 ? 0 : 1)
+                };
+            }
+        } else {
+            return {
+                node: nextNode.parentNode,
+                offset: getOffset(nextNode) + (direction > 0 ? 1 : 0)
+            };
+        }
+    }
+}
+function getNextCharacterContentNode(node, offset, direction) {
+    const nextOffset = Number(offset) + (direction < 0 ? -1 : 0);
+    if (offset !== undefined && isElement(node) && nextOffset >= 0 && nextOffset < node.children.length) {
+        node = node.children[nextOffset];
+    }
+    return walkNodes(node, direction === 1 ? 'next' : 'previous', isTreatedAsCharacterContent);
+}
+function isTreatedAsCharacterContent(node) {
+    if (isTextNode(node)) {
+        return true;
+    }
+    if (isElement(node)) {
+        if (isElementType.isElementType(node, [
+            'input',
+            'textarea'
+        ])) {
+            return node.type !== 'hidden';
+        } else if (isElementType.isElementType(node, 'br')) {
+            return true;
+        }
+    }
+    return false;
+}
+function getOffset(node) {
+    let i = 0;
+    while(node.previousSibling){
+        i++;
+        node = node.previousSibling;
+    }
+    return i;
+}
+function isElement(node) {
+    return node.nodeType === 1;
+}
+function isTextNode(node) {
+    return node.nodeType === 3;
+}
+function walkNodes(node, direction, callback) {
+    for(;;){
+        var _node_ownerDocument;
+        const sibling = node[`${direction}Sibling`];
+        if (sibling) {
+            node = getDescendant(sibling, direction === 'next' ? 'first' : 'last');
+            if (callback(node)) {
+                return node;
+            }
+        } else if (node.parentNode && (!isElement(node.parentNode) || !isContentEditable.isContentEditable(node.parentNode) && node.parentNode !== ((_node_ownerDocument = node.ownerDocument) === null || _node_ownerDocument === void 0 ? void 0 : _node_ownerDocument.body))) {
+            node = node.parentNode;
+        } else {
+            break;
+        }
+    }
+}
+function getDescendant(node, direction) {
+    while(node.hasChildNodes()){
+        node = node[`${direction}Child`];
+    }
+    return node;
+}
+
+exports.getNextCursorPosition = getNextCursorPosition;

package/dist/cjs/utils/focus/getActiveElement.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var isDisabled = require('../misc/isDisabled.js');
+
+function getActiveElement(document) {
+    const activeElement = document.activeElement;
+    if (activeElement === null || activeElement === void 0 ? void 0 : activeElement.shadowRoot) {
+        const activeElementInShadowTree = getActiveElement(activeElement.shadowRoot);
+        if (activeElementInShadowTree) {
+            return activeElementInShadowTree;
+        }
+    }
+    // Browser does not yield disabled elements as document.activeElement - jsdom does
+    if (isDisabled.isDisabled(activeElement)) {
+        return document.ownerDocument ? /* istanbul ignore next */ document.ownerDocument.body : document.body;
+    }
+    return activeElement;
+}
+function getActiveElementOrBody(document) {
+    var _getActiveElement;
+    return (_getActiveElement = getActiveElement(document)) !== null && _getActiveElement !== void 0 ? _getActiveElement : /* istanbul ignore next */ document.body;
+}
+
+exports.getActiveElement = getActiveElement;
+exports.getActiveElementOrBody = getActiveElementOrBody;

package/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/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/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/dist/cjs/utils/focus/selector.js

@@ -0,0 +1,15 @@
+'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])',
+    'details > summary'
+].join(', ');
+
+exports.FOCUSABLE_SELECTOR = FOCUSABLE_SELECTOR;

package/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/dist/cjs/utils/keyDef/readNextDescriptor.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const 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 _ref;
+    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 === void 0 ? void 0 : _text_slice_match[0];
+    assertDescriptor(descriptor, text, pos, context);
+    pos += descriptor.length;
+    const repeatModifier = (_ref = (_text_slice_match1 = text.slice(pos).match(/^>\d+/)) === null || _text_slice_match1 === void 0 ? void 0 : _text_slice_match1[0]) !== null && _ref !== void 0 ? _ref : '';
+    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 !== void 0 ? 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/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/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/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/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/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 === void 0 ? void 0 : _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/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;