@lwc/synthetic-shadow 2.12.1 → 2.13.2

package/dist/synthetic-shadow.js

@@ -146,7 +146,7 @@ const KEY__SYNTHETIC_MODE = '$$lwc-synthetic-mode';
 // We use this to detect symbol support in order to avoid the expensive symbol polyfill. Note that
 // we can't use typeof since it will fail when transpiling.
 const hasNativeSymbolSupport = /*@__PURE__*/ (() => Symbol('x').toString() === 'Symbol(x)')();
-/** version: 2.12.1 */
+/** version: 2.13.2 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -453,249 +453,6 @@ function arrayFromCollection(collection) {
 const eventTargetPrototype = typeof EventTarget !== 'undefined' ? EventTarget.prototype : _Node.prototype;
 const { addEventListener, dispatchEvent, removeEventListener } = eventTargetPrototype;
 
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const EventListenerMap = new WeakMap();
-const ComposedPathMap = new WeakMap();
-function isEventListenerOrEventListenerObject(fnOrObj) {
-    return (isFunction(fnOrObj) ||
-        (isObject(fnOrObj) &&
-            !isNull(fnOrObj) &&
-            isFunction(fnOrObj.handleEvent)));
-}
-function shouldInvokeListener(event, target, currentTarget) {
-    // Subsequent logic assumes that `currentTarget` must be contained in the composed path for the listener to be
-    // invoked, but this is not always the case. `composedPath()` will sometimes return an empty array, even when the
-    // listener should be invoked (e.g., a disconnected instance of EventTarget, an instance of XMLHttpRequest, etc).
-    if (target === currentTarget) {
-        return true;
-    }
-    let composedPath = ComposedPathMap.get(event);
-    if (isUndefined(composedPath)) {
-        composedPath = event.composedPath();
-        ComposedPathMap.set(event, composedPath);
-    }
-    return composedPath.includes(currentTarget);
-}
-function getEventListenerWrapper(fnOrObj) {
-    if (!isEventListenerOrEventListenerObject(fnOrObj)) {
-        return fnOrObj;
-    }
-    let wrapperFn = EventListenerMap.get(fnOrObj);
-    if (isUndefined(wrapperFn)) {
-        wrapperFn = function (event) {
-            // This function is invoked from an event listener and currentTarget is always defined.
-            const currentTarget = eventCurrentTargetGetter.call(event);
-            if (process.env.NODE_ENV !== 'production') {
-                assert.invariant(isFalse(isSyntheticShadowHost(currentTarget)), 'This routine should not be used to wrap event listeners for host elements and shadow roots.');
-            }
-            const actualTarget = getActualTarget(event);
-            if (!shouldInvokeListener(event, actualTarget, currentTarget)) {
-                return;
-            }
-            return isFunction(fnOrObj)
-                ? fnOrObj.call(this, event)
-                : fnOrObj.handleEvent && fnOrObj.handleEvent(event);
-        };
-        EventListenerMap.set(fnOrObj, wrapperFn);
-    }
-    return wrapperFn;
-}
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const eventToContextMap = new WeakMap();
-const customElementToWrappedListeners = new WeakMap();
-function getEventMap(elm) {
-    let listenerInfo = customElementToWrappedListeners.get(elm);
-    if (isUndefined(listenerInfo)) {
-        listenerInfo = create(null);
-        customElementToWrappedListeners.set(elm, listenerInfo);
-    }
-    return listenerInfo;
-}
-/**
- * Events dispatched on shadow roots actually end up being dispatched on their hosts. This means that the event.target
- * property of events dispatched on shadow roots always resolve to their host. This function understands this
- * abstraction and properly returns a reference to the shadow root when appropriate.
- */
-function getActualTarget(event) {
-    var _a;
-    return (_a = eventToShadowRootMap.get(event)) !== null && _a !== void 0 ? _a : eventTargetGetter.call(event);
-}
-const shadowRootEventListenerMap = new WeakMap();
-function getWrappedShadowRootListener(listener) {
-    if (!isFunction(listener)) {
-        throw new TypeError(); // avoiding problems with non-valid listeners
-    }
-    let shadowRootWrappedListener = shadowRootEventListenerMap.get(listener);
-    if (isUndefined(shadowRootWrappedListener)) {
-        shadowRootWrappedListener = function (event) {
-            // currentTarget is always defined inside an event listener
-            let currentTarget = eventCurrentTargetGetter.call(event);
-            // If currentTarget is not an instance of a native shadow root then we're dealing with a
-            // host element whose synthetic shadow root must be accessed via getShadowRoot().
-            if (!isInstanceOfNativeShadowRoot(currentTarget)) {
-                currentTarget = getShadowRoot(currentTarget);
-            }
-            const actualTarget = getActualTarget(event);
-            if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                listener.call(currentTarget, event);
-            }
-        };
-        shadowRootWrappedListener.placement = 1 /* SHADOW_ROOT_LISTENER */;
-        shadowRootEventListenerMap.set(listener, shadowRootWrappedListener);
-    }
-    return shadowRootWrappedListener;
-}
-const customElementEventListenerMap = new WeakMap();
-function getWrappedCustomElementListener(listener) {
-    if (!isFunction(listener)) {
-        throw new TypeError(); // avoiding problems with non-valid listeners
-    }
-    let customElementWrappedListener = customElementEventListenerMap.get(listener);
-    if (isUndefined(customElementWrappedListener)) {
-        customElementWrappedListener = function (event) {
-            // currentTarget is always defined inside an event listener
-            const currentTarget = eventCurrentTargetGetter.call(event);
-            const actualTarget = getActualTarget(event);
-            if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                listener.call(currentTarget, event);
-            }
-        };
-        customElementWrappedListener.placement = 0 /* CUSTOM_ELEMENT_LISTENER */;
-        customElementEventListenerMap.set(listener, customElementWrappedListener);
-    }
-    return customElementWrappedListener;
-}
-function domListener(evt) {
-    let immediatePropagationStopped = false;
-    let propagationStopped = false;
-    const { type, stopImmediatePropagation, stopPropagation } = evt;
-    // currentTarget is always defined
-    const currentTarget = eventCurrentTargetGetter.call(evt);
-    const listenerMap = getEventMap(currentTarget);
-    const listeners = listenerMap[type]; // it must have listeners at this point
-    defineProperty(evt, 'stopImmediatePropagation', {
-        value() {
-            immediatePropagationStopped = true;
-            stopImmediatePropagation.call(evt);
-        },
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    });
-    defineProperty(evt, 'stopPropagation', {
-        value() {
-            propagationStopped = true;
-            stopPropagation.call(evt);
-        },
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    });
-    // in case a listener adds or removes other listeners during invocation
-    const bookkeeping = ArraySlice.call(listeners);
-    function invokeListenersByPlacement(placement) {
-        forEach.call(bookkeeping, (listener) => {
-            if (isFalse(immediatePropagationStopped) && listener.placement === placement) {
-                // making sure that the listener was not removed from the original listener queue
-                if (ArrayIndexOf.call(listeners, listener) !== -1) {
-                    // all handlers on the custom element should be called with undefined 'this'
-                    listener.call(undefined, evt);
-                }
-            }
-        });
-    }
-    eventToContextMap.set(evt, 1 /* SHADOW_ROOT_LISTENER */);
-    invokeListenersByPlacement(1 /* SHADOW_ROOT_LISTENER */);
-    if (isFalse(immediatePropagationStopped) && isFalse(propagationStopped)) {
-        // doing the second iteration only if the first one didn't interrupt the event propagation
-        eventToContextMap.set(evt, 0 /* CUSTOM_ELEMENT_LISTENER */);
-        invokeListenersByPlacement(0 /* CUSTOM_ELEMENT_LISTENER */);
-    }
-    eventToContextMap.set(evt, 2 /* UNKNOWN_LISTENER */);
-}
-function attachDOMListener(elm, type, wrappedListener) {
-    const listenerMap = getEventMap(elm);
-    let cmpEventHandlers = listenerMap[type];
-    if (isUndefined(cmpEventHandlers)) {
-        cmpEventHandlers = listenerMap[type] = [];
-    }
-    // Prevent identical listeners from subscribing to the same event type.
-    // TODO [#1824]: Options will also play a factor when we introduce support for them (#1824).
-    if (ArrayIndexOf.call(cmpEventHandlers, wrappedListener) !== -1) {
-        return;
-    }
-    // only add to DOM if there is no other listener on the same placement yet
-    if (cmpEventHandlers.length === 0) {
-        // super.addEventListener() - this will not work on
-        addEventListener.call(elm, type, domListener);
-    }
-    ArrayPush.call(cmpEventHandlers, wrappedListener);
-}
-function detachDOMListener(elm, type, wrappedListener) {
-    const listenerMap = getEventMap(elm);
-    let p;
-    let listeners;
-    if (!isUndefined((listeners = listenerMap[type])) &&
-        (p = ArrayIndexOf.call(listeners, wrappedListener)) !== -1) {
-        ArraySplice.call(listeners, p, 1);
-        // only remove from DOM if there is no other listener on the same placement
-        if (listeners.length === 0) {
-            removeEventListener.call(elm, type, domListener);
-        }
-    }
-}
-function addCustomElementEventListener(type, listener, _options) {
-    if (process.env.NODE_ENV !== 'production') {
-        if (!isFunction(listener)) {
-            throw new TypeError(`Invalid second argument for Element.addEventListener() in ${toString(this)} for event "${type}". Expected an EventListener but received ${listener}.`);
-        }
-    }
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
-        const wrappedListener = getWrappedCustomElementListener(listener);
-        attachDOMListener(this, type, wrappedListener);
-    }
-}
-function removeCustomElementEventListener(type, listener, _options) {
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
-        const wrappedListener = getWrappedCustomElementListener(listener);
-        detachDOMListener(this, type, wrappedListener);
-    }
-}
-function addShadowRootEventListener(sr, type, listener, _options) {
-    if (process.env.NODE_ENV !== 'production') {
-        if (!isFunction(listener)) {
-            throw new TypeError(`Invalid second argument for ShadowRoot.addEventListener() in ${toString(sr)} for event "${type}". Expected an EventListener but received ${listener}.`);
-        }
-    }
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
-        const elm = getHost(sr);
-        const wrappedListener = getWrappedShadowRootListener(listener);
-        attachDOMListener(elm, type, wrappedListener);
-    }
-}
-function removeShadowRootEventListener(sr, type, listener, _options) {
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
-        const elm = getHost(sr);
-        const wrappedListener = getWrappedShadowRootListener(listener);
-        detachDOMListener(elm, type, wrappedListener);
-    }
-}
-
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -959,19 +716,136 @@ function getFilteredSlotAssignedNodes(slot) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-function getTextContent(node) {
-    switch (node.nodeType) {
-        case ELEMENT_NODE: {
-            const childNodes = getFilteredChildNodes(node);
-            let content = '';
-            for (let i = 0, len = childNodes.length; i < len; i += 1) {
-                const currentNode = childNodes[i];
-                if (currentNode.nodeType !== COMMENT_NODE) {
-                    content += getTextContent(currentNode);
-                }
-            }
-            return content;
-        }
+function getInnerHTML(node) {
+    let s = '';
+    const childNodes = getFilteredChildNodes(node);
+    for (let i = 0, len = childNodes.length; i < len; i += 1) {
+        s += getOuterHTML(childNodes[i]);
+    }
+    return s;
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
+const escapeAttrRegExp = /[&\u00A0"]/g;
+const escapeDataRegExp = /[&\u00A0<>]/g;
+const { replace, toLowerCase } = String.prototype;
+function escapeReplace(c) {
+    switch (c) {
+        case '&':
+            return '&amp;';
+        case '<':
+            return '&lt;';
+        case '>':
+            return '&gt;';
+        case '"':
+            return '&quot;';
+        case '\u00A0':
+            return '&nbsp;';
+        default:
+            return '';
+    }
+}
+function escapeAttr(s) {
+    return replace.call(s, escapeAttrRegExp, escapeReplace);
+}
+function escapeData(s) {
+    return replace.call(s, escapeDataRegExp, escapeReplace);
+}
+// http://www.whatwg.org/specs/web-apps/current-work/#void-elements
+const voidElements = new Set([
+    'AREA',
+    'BASE',
+    'BR',
+    'COL',
+    'COMMAND',
+    'EMBED',
+    'HR',
+    'IMG',
+    'INPUT',
+    'KEYGEN',
+    'LINK',
+    'META',
+    'PARAM',
+    'SOURCE',
+    'TRACK',
+    'WBR',
+]);
+const plaintextParents = new Set([
+    'STYLE',
+    'SCRIPT',
+    'XMP',
+    'IFRAME',
+    'NOEMBED',
+    'NOFRAMES',
+    'PLAINTEXT',
+    'NOSCRIPT',
+]);
+function getOuterHTML(node) {
+    switch (node.nodeType) {
+        case ELEMENT_NODE: {
+            const { attributes: attrs } = node;
+            const tagName = tagNameGetter.call(node);
+            let s = '<' + toLowerCase.call(tagName);
+            for (let i = 0, attr; (attr = attrs[i]); i++) {
+                s += ' ' + attr.name + '="' + escapeAttr(attr.value) + '"';
+            }
+            s += '>';
+            if (voidElements.has(tagName)) {
+                return s;
+            }
+            return s + getInnerHTML(node) + '</' + toLowerCase.call(tagName) + '>';
+        }
+        case TEXT_NODE: {
+            const { data, parentNode } = node;
+            if (parentNode instanceof Element &&
+                plaintextParents.has(tagNameGetter.call(parentNode))) {
+                return data;
+            }
+            return escapeData(data);
+        }
+        case CDATA_SECTION_NODE: {
+            return `<!CDATA[[${node.data}]]>`;
+        }
+        case PROCESSING_INSTRUCTION_NODE: {
+            return `<?${node.target} ${node.data}?>`;
+        }
+        case COMMENT_NODE: {
+            return `<!--${node.data}-->`;
+        }
+        default: {
+            // intentionally ignoring unknown node types
+            // Note: since this routine is always invoked for childNodes
+            // we can safety ignore type 9, 10 and 99 (document, fragment and doctype)
+            return '';
+        }
+    }
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+function getTextContent(node) {
+    switch (node.nodeType) {
+        case ELEMENT_NODE: {
+            const childNodes = getFilteredChildNodes(node);
+            let content = '';
+            for (let i = 0, len = childNodes.length; i < len; i += 1) {
+                const currentNode = childNodes[i];
+                if (currentNode.nodeType !== COMMENT_NODE) {
+                    content += getTextContent(currentNode);
+                }
+            }
+            return content;
+        }
         default:
             return node.nodeValue;
     }
@@ -1093,6 +967,71 @@ function createStaticNodeList(items) {
     return nodeList;
 }
 
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// Walk up the DOM tree, collecting all shadow roots plus the document root
+function getAllRootNodes(node) {
+    var _a;
+    const rootNodes = [];
+    let currentRootNode = node.getRootNode();
+    while (!isUndefined(currentRootNode)) {
+        rootNodes.push(currentRootNode);
+        currentRootNode = (_a = currentRootNode.host) === null || _a === void 0 ? void 0 : _a.getRootNode();
+    }
+    return rootNodes;
+}
+// Keep searching up the host tree until we find an element that is within the immediate shadow root
+const findAncestorHostInImmediateShadowRoot = (rootNode, targetRootNode) => {
+    let host;
+    while (!isUndefined((host = rootNode.host))) {
+        const thisRootNode = host.getRootNode();
+        if (thisRootNode === targetRootNode) {
+            return host;
+        }
+        rootNode = thisRootNode;
+    }
+};
+function fauxElementsFromPoint(context, doc, left, top) {
+    const elements = elementsFromPoint.call(doc, left, top);
+    const result = [];
+    const rootNodes = getAllRootNodes(context);
+    // Filter the elements array to only include those elements that are in this shadow root or in one of its
+    // ancestor roots. This matches Chrome and Safari's implementation (but not Firefox's, which only includes
+    // elements in the immediate shadow root: https://crbug.com/1207863#c4).
+    if (!isNull(elements)) {
+        // can be null in IE https://developer.mozilla.org/en-US/docs/Web/API/Document/elementsFromPoint#browser_compatibility
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            if (isSyntheticSlotElement(element)) {
+                continue;
+            }
+            const elementRootNode = element.getRootNode();
+            if (ArrayIndexOf.call(rootNodes, elementRootNode) !== -1) {
+                ArrayPush.call(result, element);
+                continue;
+            }
+            // In cases where the host element is not visible but its shadow descendants are, then
+            // we may get the shadow descendant instead of the host element here. (The
+            // browser doesn't know the difference in synthetic shadow DOM.)
+            // In native shadow DOM, however, elementsFromPoint would return the host but not
+            // the child. So we need to detect if this shadow element's host is accessible from
+            // the context's shadow root. Note we also need to be careful not to add the host
+            // multiple times.
+            const ancestorHost = findAncestorHostInImmediateShadowRoot(elementRootNode, rootNodes[0]);
+            if (!isUndefined(ancestorHost) &&
+                ArrayIndexOf.call(elements, ancestorHost) === -1 &&
+                ArrayIndexOf.call(result, ancestorHost) === -1) {
+                ArrayPush.call(result, ancestorHost);
+            }
+        }
+    }
+    return result;
+}
+
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -1130,167 +1069,50 @@ StaticHTMLCollection.prototype = create(HTMLCollection.prototype, {
         enumerable: true,
         configurable: true,
         value(name) {
-            if (name === '') {
-                return null;
-            }
-            const items = Items.get(this);
-            for (let i = 0, len = items.length; i < len; i++) {
-                const item = items[len];
-                if (name === getAttribute.call(item, 'id') ||
-                    name === getAttribute.call(item, 'name')) {
-                    return item;
-                }
-            }
-            return null;
-        },
-    },
-    [Symbol.toStringTag]: {
-        configurable: true,
-        get() {
-            return 'HTMLCollection';
-        },
-    },
-    // IE11 doesn't support Symbol.toStringTag, in which case we
-    // provide the regular toString method.
-    toString: {
-        writable: true,
-        configurable: true,
-        value() {
-            return '[object HTMLCollection]';
-        },
-    },
-});
-// prototype inheritance dance
-setPrototypeOf(StaticHTMLCollection, HTMLCollection);
-function createStaticHTMLCollection(items) {
-    const collection = create(StaticHTMLCollection.prototype);
-    Items.set(collection, items);
-    // setting static indexes
-    forEach.call(items, (item, index) => {
-        defineProperty(collection, index, {
-            value: item,
-            enumerable: true,
-            configurable: true,
-        });
-    });
-    return collection;
-}
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-function getInnerHTML(node) {
-    let s = '';
-    const childNodes = getFilteredChildNodes(node);
-    for (let i = 0, len = childNodes.length; i < len; i += 1) {
-        s += getOuterHTML(childNodes[i]);
-    }
-    return s;
-}
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
-const escapeAttrRegExp = /[&\u00A0"]/g;
-const escapeDataRegExp = /[&\u00A0<>]/g;
-const { replace, toLowerCase } = String.prototype;
-function escapeReplace(c) {
-    switch (c) {
-        case '&':
-            return '&amp;';
-        case '<':
-            return '&lt;';
-        case '>':
-            return '&gt;';
-        case '"':
-            return '&quot;';
-        case '\u00A0':
-            return '&nbsp;';
-        default:
-            return '';
-    }
-}
-function escapeAttr(s) {
-    return replace.call(s, escapeAttrRegExp, escapeReplace);
-}
-function escapeData(s) {
-    return replace.call(s, escapeDataRegExp, escapeReplace);
-}
-// http://www.whatwg.org/specs/web-apps/current-work/#void-elements
-const voidElements = new Set([
-    'AREA',
-    'BASE',
-    'BR',
-    'COL',
-    'COMMAND',
-    'EMBED',
-    'HR',
-    'IMG',
-    'INPUT',
-    'KEYGEN',
-    'LINK',
-    'META',
-    'PARAM',
-    'SOURCE',
-    'TRACK',
-    'WBR',
-]);
-const plaintextParents = new Set([
-    'STYLE',
-    'SCRIPT',
-    'XMP',
-    'IFRAME',
-    'NOEMBED',
-    'NOFRAMES',
-    'PLAINTEXT',
-    'NOSCRIPT',
-]);
-function getOuterHTML(node) {
-    switch (node.nodeType) {
-        case ELEMENT_NODE: {
-            const { attributes: attrs } = node;
-            const tagName = tagNameGetter.call(node);
-            let s = '<' + toLowerCase.call(tagName);
-            for (let i = 0, attr; (attr = attrs[i]); i++) {
-                s += ' ' + attr.name + '="' + escapeAttr(attr.value) + '"';
-            }
-            s += '>';
-            if (voidElements.has(tagName)) {
-                return s;
-            }
-            return s + getInnerHTML(node) + '</' + toLowerCase.call(tagName) + '>';
-        }
-        case TEXT_NODE: {
-            const { data, parentNode } = node;
-            if (parentNode instanceof Element &&
-                plaintextParents.has(tagNameGetter.call(parentNode))) {
-                return data;
-            }
-            return escapeData(data);
-        }
-        case CDATA_SECTION_NODE: {
-            return `<!CDATA[[${node.data}]]>`;
-        }
-        case PROCESSING_INSTRUCTION_NODE: {
-            return `<?${node.target} ${node.data}?>`;
-        }
-        case COMMENT_NODE: {
-            return `<!--${node.data}-->`;
-        }
-        default: {
-            // intentionally ignoring unknown node types
-            // Note: since this routine is always invoked for childNodes
-            // we can safety ignore type 9, 10 and 99 (document, fragment and doctype)
-            return '';
-        }
-    }
+            if (name === '') {
+                return null;
+            }
+            const items = Items.get(this);
+            for (let i = 0, len = items.length; i < len; i++) {
+                const item = items[len];
+                if (name === getAttribute.call(item, 'id') ||
+                    name === getAttribute.call(item, 'name')) {
+                    return item;
+                }
+            }
+            return null;
+        },
+    },
+    [Symbol.toStringTag]: {
+        configurable: true,
+        get() {
+            return 'HTMLCollection';
+        },
+    },
+    // IE11 doesn't support Symbol.toStringTag, in which case we
+    // provide the regular toString method.
+    toString: {
+        writable: true,
+        configurable: true,
+        value() {
+            return '[object HTMLCollection]';
+        },
+    },
+});
+// prototype inheritance dance
+setPrototypeOf(StaticHTMLCollection, HTMLCollection);
+function createStaticHTMLCollection(items) {
+    const collection = create(StaticHTMLCollection.prototype);
+    Items.set(collection, items);
+    // setting static indexes
+    forEach.call(items, (item, index) => {
+        defineProperty(collection, index, {
+            value: item,
+            enumerable: true,
+            configurable: true,
+        });
+    });
+    return collection;
 }
 
 /**
@@ -1300,7 +1122,7 @@ if (!_globalThis.lwcRuntimeFlags) {
     Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
 }
 const runtimeFlags = _globalThis.lwcRuntimeFlags;
-/** version: 2.12.1 */
+/** version: 2.13.2 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1773,63 +1595,241 @@ if (hasOwnProperty.call(HTMLElement.prototype, 'parentElement')) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-// Walk up the DOM tree, collecting all shadow roots plus the document root
-function getAllRootNodes(node) {
+const EventListenerMap = new WeakMap();
+const ComposedPathMap = new WeakMap();
+function isEventListenerOrEventListenerObject(fnOrObj) {
+    return (isFunction(fnOrObj) ||
+        (isObject(fnOrObj) &&
+            !isNull(fnOrObj) &&
+            isFunction(fnOrObj.handleEvent)));
+}
+function shouldInvokeListener(event, target, currentTarget) {
+    // Subsequent logic assumes that `currentTarget` must be contained in the composed path for the listener to be
+    // invoked, but this is not always the case. `composedPath()` will sometimes return an empty array, even when the
+    // listener should be invoked (e.g., a disconnected instance of EventTarget, an instance of XMLHttpRequest, etc).
+    if (target === currentTarget) {
+        return true;
+    }
+    let composedPath = ComposedPathMap.get(event);
+    if (isUndefined(composedPath)) {
+        composedPath = event.composedPath();
+        ComposedPathMap.set(event, composedPath);
+    }
+    return composedPath.includes(currentTarget);
+}
+function getEventListenerWrapper(fnOrObj) {
+    if (!isEventListenerOrEventListenerObject(fnOrObj)) {
+        return fnOrObj;
+    }
+    let wrapperFn = EventListenerMap.get(fnOrObj);
+    if (isUndefined(wrapperFn)) {
+        wrapperFn = function (event) {
+            // This function is invoked from an event listener and currentTarget is always defined.
+            const currentTarget = eventCurrentTargetGetter.call(event);
+            if (process.env.NODE_ENV !== 'production') {
+                assert.invariant(isFalse(isSyntheticShadowHost(currentTarget)), 'This routine should not be used to wrap event listeners for host elements and shadow roots.');
+            }
+            const actualTarget = getActualTarget(event);
+            if (!shouldInvokeListener(event, actualTarget, currentTarget)) {
+                return;
+            }
+            return isFunction(fnOrObj)
+                ? fnOrObj.call(this, event)
+                : fnOrObj.handleEvent && fnOrObj.handleEvent(event);
+        };
+        EventListenerMap.set(fnOrObj, wrapperFn);
+    }
+    return wrapperFn;
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const eventToContextMap = new WeakMap();
+const customElementToWrappedListeners = new WeakMap();
+function getEventMap(elm) {
+    let listenerInfo = customElementToWrappedListeners.get(elm);
+    if (isUndefined(listenerInfo)) {
+        listenerInfo = create(null);
+        customElementToWrappedListeners.set(elm, listenerInfo);
+    }
+    return listenerInfo;
+}
+/**
+ * Events dispatched on shadow roots actually end up being dispatched on their hosts. This means that the event.target
+ * property of events dispatched on shadow roots always resolve to their host. This function understands this
+ * abstraction and properly returns a reference to the shadow root when appropriate.
+ */
+function getActualTarget(event) {
     var _a;
-    const rootNodes = [];
-    let currentRootNode = node.getRootNode();
-    while (!isUndefined(currentRootNode)) {
-        rootNodes.push(currentRootNode);
-        currentRootNode = (_a = currentRootNode.host) === null || _a === void 0 ? void 0 : _a.getRootNode();
+    return (_a = eventToShadowRootMap.get(event)) !== null && _a !== void 0 ? _a : eventTargetGetter.call(event);
+}
+const shadowRootEventListenerMap = new WeakMap();
+function getWrappedShadowRootListener(listener) {
+    if (!isFunction(listener)) {
+        throw new TypeError(); // avoiding problems with non-valid listeners
+    }
+    let shadowRootWrappedListener = shadowRootEventListenerMap.get(listener);
+    if (isUndefined(shadowRootWrappedListener)) {
+        shadowRootWrappedListener = function (event) {
+            // currentTarget is always defined inside an event listener
+            let currentTarget = eventCurrentTargetGetter.call(event);
+            // If currentTarget is not an instance of a native shadow root then we're dealing with a
+            // host element whose synthetic shadow root must be accessed via getShadowRoot().
+            if (!isInstanceOfNativeShadowRoot(currentTarget)) {
+                currentTarget = getShadowRoot(currentTarget);
+            }
+            const actualTarget = getActualTarget(event);
+            if (shouldInvokeListener(event, actualTarget, currentTarget)) {
+                listener.call(currentTarget, event);
+            }
+        };
+        shadowRootWrappedListener.placement = 1 /* SHADOW_ROOT_LISTENER */;
+        shadowRootEventListenerMap.set(listener, shadowRootWrappedListener);
+    }
+    return shadowRootWrappedListener;
+}
+const customElementEventListenerMap = new WeakMap();
+function getWrappedCustomElementListener(listener) {
+    if (!isFunction(listener)) {
+        throw new TypeError(); // avoiding problems with non-valid listeners
+    }
+    let customElementWrappedListener = customElementEventListenerMap.get(listener);
+    if (isUndefined(customElementWrappedListener)) {
+        customElementWrappedListener = function (event) {
+            // currentTarget is always defined inside an event listener
+            const currentTarget = eventCurrentTargetGetter.call(event);
+            const actualTarget = getActualTarget(event);
+            if (shouldInvokeListener(event, actualTarget, currentTarget)) {
+                listener.call(currentTarget, event);
+            }
+        };
+        customElementWrappedListener.placement = 0 /* CUSTOM_ELEMENT_LISTENER */;
+        customElementEventListenerMap.set(listener, customElementWrappedListener);
+    }
+    return customElementWrappedListener;
+}
+function domListener(evt) {
+    let immediatePropagationStopped = false;
+    let propagationStopped = false;
+    const { type, stopImmediatePropagation, stopPropagation } = evt;
+    // currentTarget is always defined
+    const currentTarget = eventCurrentTargetGetter.call(evt);
+    const listenerMap = getEventMap(currentTarget);
+    const listeners = listenerMap[type]; // it must have listeners at this point
+    defineProperty(evt, 'stopImmediatePropagation', {
+        value() {
+            immediatePropagationStopped = true;
+            stopImmediatePropagation.call(evt);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    defineProperty(evt, 'stopPropagation', {
+        value() {
+            propagationStopped = true;
+            stopPropagation.call(evt);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    // in case a listener adds or removes other listeners during invocation
+    const bookkeeping = ArraySlice.call(listeners);
+    function invokeListenersByPlacement(placement) {
+        forEach.call(bookkeeping, (listener) => {
+            if (isFalse(immediatePropagationStopped) && listener.placement === placement) {
+                // making sure that the listener was not removed from the original listener queue
+                if (ArrayIndexOf.call(listeners, listener) !== -1) {
+                    // all handlers on the custom element should be called with undefined 'this'
+                    listener.call(undefined, evt);
+                }
+            }
+        });
+    }
+    eventToContextMap.set(evt, 1 /* SHADOW_ROOT_LISTENER */);
+    invokeListenersByPlacement(1 /* SHADOW_ROOT_LISTENER */);
+    if (isFalse(immediatePropagationStopped) && isFalse(propagationStopped)) {
+        // doing the second iteration only if the first one didn't interrupt the event propagation
+        eventToContextMap.set(evt, 0 /* CUSTOM_ELEMENT_LISTENER */);
+        invokeListenersByPlacement(0 /* CUSTOM_ELEMENT_LISTENER */);
+    }
+    eventToContextMap.set(evt, 2 /* UNKNOWN_LISTENER */);
+}
+function attachDOMListener(elm, type, wrappedListener) {
+    const listenerMap = getEventMap(elm);
+    let cmpEventHandlers = listenerMap[type];
+    if (isUndefined(cmpEventHandlers)) {
+        cmpEventHandlers = listenerMap[type] = [];
+    }
+    // Prevent identical listeners from subscribing to the same event type.
+    // TODO [#1824]: Options will also play a factor when we introduce support for them (#1824).
+    if (ArrayIndexOf.call(cmpEventHandlers, wrappedListener) !== -1) {
+        return;
+    }
+    // only add to DOM if there is no other listener on the same placement yet
+    if (cmpEventHandlers.length === 0) {
+        // super.addEventListener() - this will not work on
+        addEventListener.call(elm, type, domListener);
+    }
+    ArrayPush.call(cmpEventHandlers, wrappedListener);
+}
+function detachDOMListener(elm, type, wrappedListener) {
+    const listenerMap = getEventMap(elm);
+    let p;
+    let listeners;
+    if (!isUndefined((listeners = listenerMap[type])) &&
+        (p = ArrayIndexOf.call(listeners, wrappedListener)) !== -1) {
+        ArraySplice.call(listeners, p, 1);
+        // only remove from DOM if there is no other listener on the same placement
+        if (listeners.length === 0) {
+            removeEventListener.call(elm, type, domListener);
+        }
+    }
+}
+function addCustomElementEventListener(type, listener, _options) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (!isFunction(listener)) {
+            throw new TypeError(`Invalid second argument for Element.addEventListener() in ${toString(this)} for event "${type}". Expected an EventListener but received ${listener}.`);
+        }
+    }
+    // TODO [#1824]: Lift this restriction on the option parameter
+    if (isFunction(listener)) {
+        const wrappedListener = getWrappedCustomElementListener(listener);
+        attachDOMListener(this, type, wrappedListener);
     }
-    return rootNodes;
 }
-// Keep searching up the host tree until we find an element that is within the immediate shadow root
-const findAncestorHostInImmediateShadowRoot = (rootNode, targetRootNode) => {
-    let host;
-    while (!isUndefined((host = rootNode.host))) {
-        const thisRootNode = host.getRootNode();
-        if (thisRootNode === targetRootNode) {
-            return host;
-        }
-        rootNode = thisRootNode;
+function removeCustomElementEventListener(type, listener, _options) {
+    // TODO [#1824]: Lift this restriction on the option parameter
+    if (isFunction(listener)) {
+        const wrappedListener = getWrappedCustomElementListener(listener);
+        detachDOMListener(this, type, wrappedListener);
     }
-};
-function fauxElementsFromPoint(context, doc, left, top) {
-    const elements = elementsFromPoint.call(doc, left, top);
-    const result = [];
-    const rootNodes = getAllRootNodes(context);
-    // Filter the elements array to only include those elements that are in this shadow root or in one of its
-    // ancestor roots. This matches Chrome and Safari's implementation (but not Firefox's, which only includes
-    // elements in the immediate shadow root: https://crbug.com/1207863#c4).
-    if (!isNull(elements)) {
-        // can be null in IE https://developer.mozilla.org/en-US/docs/Web/API/Document/elementsFromPoint#browser_compatibility
-        for (let i = 0; i < elements.length; i++) {
-            const element = elements[i];
-            if (isSyntheticSlotElement(element)) {
-                continue;
-            }
-            const elementRootNode = element.getRootNode();
-            if (ArrayIndexOf.call(rootNodes, elementRootNode) !== -1) {
-                ArrayPush.call(result, element);
-                continue;
-            }
-            // In cases where the host element is not visible but its shadow descendants are, then
-            // we may get the shadow descendant instead of the host element here. (The
-            // browser doesn't know the difference in synthetic shadow DOM.)
-            // In native shadow DOM, however, elementsFromPoint would return the host but not
-            // the child. So we need to detect if this shadow element's host is accessible from
-            // the context's shadow root. Note we also need to be careful not to add the host
-            // multiple times.
-            const ancestorHost = findAncestorHostInImmediateShadowRoot(elementRootNode, rootNodes[0]);
-            if (!isUndefined(ancestorHost) &&
-                ArrayIndexOf.call(elements, ancestorHost) === -1 &&
-                ArrayIndexOf.call(result, ancestorHost) === -1) {
-                ArrayPush.call(result, ancestorHost);
-            }
+}
+function addShadowRootEventListener(sr, type, listener, _options) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (!isFunction(listener)) {
+            throw new TypeError(`Invalid second argument for ShadowRoot.addEventListener() in ${toString(sr)} for event "${type}". Expected an EventListener but received ${listener}.`);
         }
     }
-    return result;
+    // TODO [#1824]: Lift this restriction on the option parameter
+    if (isFunction(listener)) {
+        const elm = getHost(sr);
+        const wrappedListener = getWrappedShadowRootListener(listener);
+        attachDOMListener(elm, type, wrappedListener);
+    }
+}
+function removeShadowRootEventListener(sr, type, listener, _options) {
+    // TODO [#1824]: Lift this restriction on the option parameter
+    if (isFunction(listener)) {
+        const elm = getHost(sr);
+        const wrappedListener = getWrappedShadowRootListener(listener);
+        detachDOMListener(elm, type, wrappedListener);
+    }
 }
 
 /*
@@ -4099,41 +4099,230 @@ if (process.env.NODE_ENV !== 'test') {
         if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
           return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
         }
-
-        const filteredResults = getFilteredArrayOfNodes(this, elements, 1
-        /* Enabled */
-        );
-        return createStaticHTMLCollection(filteredResults);
-      },
-
-      writable: true,
-      enumerable: true,
-      configurable: true
-    },
-    getElementsByTagNameNS: {
-      value() {
-        const elements = arrayFromCollection(getElementsByTagNameNS$1.apply(this, ArraySlice.call(arguments)));
-
-        if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
-          return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
+
+        const filteredResults = getFilteredArrayOfNodes(this, elements, 1
+        /* Enabled */
+        );
+        return createStaticHTMLCollection(filteredResults);
+      },
+
+      writable: true,
+      enumerable: true,
+      configurable: true
+    },
+    getElementsByTagNameNS: {
+      value() {
+        const elements = arrayFromCollection(getElementsByTagNameNS$1.apply(this, ArraySlice.call(arguments)));
+
+        if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
+          return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
+        }
+
+        const filteredResults = getFilteredArrayOfNodes(this, elements, 1
+        /* Enabled */
+        );
+        return createStaticHTMLCollection(filteredResults);
+      },
+
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }
+  });
+} // IE11 extra patches for wrong prototypes
+
+
+if (hasOwnProperty.call(HTMLElement.prototype, 'getElementsByClassName')) {
+  defineProperty(HTMLElement.prototype, 'getElementsByClassName', getOwnPropertyDescriptor(Element.prototype, 'getElementsByClassName'));
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+function getElementComputedStyle(element) {
+    const win = getOwnerWindow(element);
+    return windowGetComputedStyle.call(win, element);
+}
+function getWindowSelection(node) {
+    const win = getOwnerWindow(node);
+    return windowGetSelection.call(win);
+}
+function nodeIsBeingRendered(nodeComputedStyle) {
+    return nodeComputedStyle.visibility === 'visible' && nodeComputedStyle.display !== 'none';
+}
+function getSelectionState(element) {
+    const win = getOwnerWindow(element);
+    const selection = getWindowSelection(element);
+    if (selection === null) {
+        return null;
+    }
+    const ranges = [];
+    for (let i = 0; i < selection.rangeCount; i++) {
+        ranges.push(selection.getRangeAt(i));
+    }
+    const state = {
+        element,
+        onselect: win.onselect,
+        onselectstart: win.onselectstart,
+        onselectionchange: win.onselectionchange,
+        ranges,
+    };
+    win.onselect = null;
+    win.onselectstart = null;
+    win.onselectionchange = null;
+    return state;
+}
+function restoreSelectionState(state) {
+    if (state === null) {
+        return;
+    }
+    const { element, onselect, onselectstart, onselectionchange, ranges } = state;
+    const win = getOwnerWindow(element);
+    const selection = getWindowSelection(element);
+    selection.removeAllRanges();
+    for (let i = 0; i < ranges.length; i++) {
+        selection.addRange(ranges[i]);
+    }
+    win.onselect = onselect;
+    win.onselectstart = onselectstart;
+    win.onselectionchange = onselectionchange;
+}
+/**
+ * Gets the "innerText" of a text node using the Selection API
+ *
+ * NOTE: For performance reasons, since this function will be called multiple times while calculating the innerText of
+ *       an element, it does not restore the current selection.
+ */
+function getTextNodeInnerText(textNode) {
+    const selection = getWindowSelection(textNode);
+    if (selection === null) {
+        return textNode.textContent || '';
+    }
+    const range = document.createRange();
+    range.selectNodeContents(textNode);
+    const domRect = range.getBoundingClientRect();
+    if (domRect.height <= 0 || domRect.width <= 0) {
+        // the text node is not rendered
+        return '';
+    }
+    // Needed to remove non rendered characters from the text node.
+    selection.removeAllRanges();
+    selection.addRange(range);
+    const selectionText = selection.toString();
+    // The textNode is visible, but it may not be selectable. When the text is not selectable,
+    // textContent is the nearest approximation to innerText.
+    return selectionText ? selectionText : textNode.textContent || '';
+}
+const nodeIsElement = (node) => node.nodeType === ELEMENT_NODE;
+const nodeIsText = (node) => node.nodeType === TEXT_NODE;
+/**
+ * Spec: https://html.spec.whatwg.org/multipage/dom.html#inner-text-collection-steps
+ * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1132
+ */
+function innerTextCollectionSteps(node) {
+    const items = [];
+    if (nodeIsElement(node)) {
+        const { tagName } = node;
+        const computedStyle = getElementComputedStyle(node);
+        if (tagName === 'OPTION') {
+            // For options, is hard to get the "rendered" text, let's use the original getter.
+            return [1, innerTextGetter.call(node), 1];
+        }
+        else if (tagName === 'TEXTAREA') {
+            return [];
+        }
+        else {
+            const childNodes = node.childNodes;
+            for (let i = 0, n = childNodes.length; i < n; i++) {
+                ArrayPush.apply(items, innerTextCollectionSteps(childNodes[i]));
+            }
+        }
+        if (!nodeIsBeingRendered(computedStyle)) {
+            if (tagName === 'SELECT' || tagName === 'DATALIST') {
+                // the select is either: .visibility != 'visible' or .display === hidden, therefore this select should
+                // not display any value.
+                return [];
+            }
+            return items;
+        }
+        if (tagName === 'BR') {
+            items.push('\u{000A}' /* line feed */);
+        }
+        const { display } = computedStyle;
+        if (display === 'table-cell') {
+            // omitting case: and node's CSS box is not the last 'table-cell' box of its enclosing 'table-row' box
+            items.push('\u{0009}' /* tab */);
+        }
+        if (display === 'table-row') {
+            // omitting case: and node's CSS box is not the last 'table-row' box of the nearest ancestor 'table' box
+            items.push('\u{000A}' /* line feed */);
+        }
+        if (tagName === 'P') {
+            items.unshift(2);
+            items.push(2);
+        }
+        if (display === 'block' ||
+            display === 'table-caption' ||
+            display === 'flex' ||
+            display === 'table') {
+            items.unshift(1);
+            items.push(1);
+        }
+    }
+    else if (nodeIsText(node)) {
+        items.push(getTextNodeInnerText(node));
+    }
+    return items;
+}
+/**
+ * InnerText getter spec: https://html.spec.whatwg.org/multipage/dom.html#the-innertext-idl-attribute
+ *
+ * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1087
+ */
+function getInnerText(element) {
+    const thisComputedStyle = getElementComputedStyle(element);
+    if (!nodeIsBeingRendered(thisComputedStyle)) {
+        return getTextContent(element) || '';
+    }
+    const selectionState = getSelectionState(element);
+    const results = [];
+    const childNodes = element.childNodes;
+    for (let i = 0, n = childNodes.length; i < n; i++) {
+        ArrayPush.apply(results, innerTextCollectionSteps(childNodes[i]));
+    }
+    restoreSelectionState(selectionState);
+    let elementInnerText = '';
+    let maxReqLineBreakCount = 0;
+    for (let i = 0, n = results.length; i < n; i++) {
+        const item = results[i];
+        if (typeof item === 'string') {
+            if (maxReqLineBreakCount > 0) {
+                for (let j = 0; j < maxReqLineBreakCount; j++) {
+                    elementInnerText += '\u{000A}';
+                }
+                maxReqLineBreakCount = 0;
+            }
+            if (item.length > 0) {
+                elementInnerText += item;
+            }
+        }
+        else {
+            if (elementInnerText.length == 0) {
+                // Remove required line break count at the start.
+                continue;
+            }
+            // Store the count if it's the max of this run,
+            // but it may be ignored if no text item is found afterwards,
+            // which means that these are consecutive line breaks at the end.
+            if (item > maxReqLineBreakCount) {
+                maxReqLineBreakCount = item;
+            }
         }
-
-        const filteredResults = getFilteredArrayOfNodes(this, elements, 1
-        /* Enabled */
-        );
-        return createStaticHTMLCollection(filteredResults);
-      },
-
-      writable: true,
-      enumerable: true,
-      configurable: true
     }
-  });
-} // IE11 extra patches for wrong prototypes
-
-
-if (hasOwnProperty.call(HTMLElement.prototype, 'getElementsByClassName')) {
-  defineProperty(HTMLElement.prototype, 'getElementsByClassName', getOwnPropertyDescriptor(Element.prototype, 'getElementsByClassName'));
+    return elementInnerText;
 }
 
 /*
@@ -4477,195 +4666,6 @@ function ignoreFocusIn(elm) {
     removeEventListener.call(elm, 'focusin', skipShadowHandler, true);
 }
 
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-function getElementComputedStyle(element) {
-    const win = getOwnerWindow(element);
-    return windowGetComputedStyle.call(win, element);
-}
-function getWindowSelection(node) {
-    const win = getOwnerWindow(node);
-    return windowGetSelection.call(win);
-}
-function nodeIsBeingRendered(nodeComputedStyle) {
-    return nodeComputedStyle.visibility === 'visible' && nodeComputedStyle.display !== 'none';
-}
-function getSelectionState(element) {
-    const win = getOwnerWindow(element);
-    const selection = getWindowSelection(element);
-    if (selection === null) {
-        return null;
-    }
-    const ranges = [];
-    for (let i = 0; i < selection.rangeCount; i++) {
-        ranges.push(selection.getRangeAt(i));
-    }
-    const state = {
-        element,
-        onselect: win.onselect,
-        onselectstart: win.onselectstart,
-        onselectionchange: win.onselectionchange,
-        ranges,
-    };
-    win.onselect = null;
-    win.onselectstart = null;
-    win.onselectionchange = null;
-    return state;
-}
-function restoreSelectionState(state) {
-    if (state === null) {
-        return;
-    }
-    const { element, onselect, onselectstart, onselectionchange, ranges } = state;
-    const win = getOwnerWindow(element);
-    const selection = getWindowSelection(element);
-    selection.removeAllRanges();
-    for (let i = 0; i < ranges.length; i++) {
-        selection.addRange(ranges[i]);
-    }
-    win.onselect = onselect;
-    win.onselectstart = onselectstart;
-    win.onselectionchange = onselectionchange;
-}
-/**
- * Gets the "innerText" of a text node using the Selection API
- *
- * NOTE: For performance reasons, since this function will be called multiple times while calculating the innerText of
- *       an element, it does not restore the current selection.
- */
-function getTextNodeInnerText(textNode) {
-    const selection = getWindowSelection(textNode);
-    if (selection === null) {
-        return textNode.textContent || '';
-    }
-    const range = document.createRange();
-    range.selectNodeContents(textNode);
-    const domRect = range.getBoundingClientRect();
-    if (domRect.height <= 0 || domRect.width <= 0) {
-        // the text node is not rendered
-        return '';
-    }
-    // Needed to remove non rendered characters from the text node.
-    selection.removeAllRanges();
-    selection.addRange(range);
-    const selectionText = selection.toString();
-    // The textNode is visible, but it may not be selectable. When the text is not selectable,
-    // textContent is the nearest approximation to innerText.
-    return selectionText ? selectionText : textNode.textContent || '';
-}
-const nodeIsElement = (node) => node.nodeType === ELEMENT_NODE;
-const nodeIsText = (node) => node.nodeType === TEXT_NODE;
-/**
- * Spec: https://html.spec.whatwg.org/multipage/dom.html#inner-text-collection-steps
- * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1132
- */
-function innerTextCollectionSteps(node) {
-    const items = [];
-    if (nodeIsElement(node)) {
-        const { tagName } = node;
-        const computedStyle = getElementComputedStyle(node);
-        if (tagName === 'OPTION') {
-            // For options, is hard to get the "rendered" text, let's use the original getter.
-            return [1, innerTextGetter.call(node), 1];
-        }
-        else if (tagName === 'TEXTAREA') {
-            return [];
-        }
-        else {
-            const childNodes = node.childNodes;
-            for (let i = 0, n = childNodes.length; i < n; i++) {
-                ArrayPush.apply(items, innerTextCollectionSteps(childNodes[i]));
-            }
-        }
-        if (!nodeIsBeingRendered(computedStyle)) {
-            if (tagName === 'SELECT' || tagName === 'DATALIST') {
-                // the select is either: .visibility != 'visible' or .display === hidden, therefore this select should
-                // not display any value.
-                return [];
-            }
-            return items;
-        }
-        if (tagName === 'BR') {
-            items.push('\u{000A}' /* line feed */);
-        }
-        const { display } = computedStyle;
-        if (display === 'table-cell') {
-            // omitting case: and node's CSS box is not the last 'table-cell' box of its enclosing 'table-row' box
-            items.push('\u{0009}' /* tab */);
-        }
-        if (display === 'table-row') {
-            // omitting case: and node's CSS box is not the last 'table-row' box of the nearest ancestor 'table' box
-            items.push('\u{000A}' /* line feed */);
-        }
-        if (tagName === 'P') {
-            items.unshift(2);
-            items.push(2);
-        }
-        if (display === 'block' ||
-            display === 'table-caption' ||
-            display === 'flex' ||
-            display === 'table') {
-            items.unshift(1);
-            items.push(1);
-        }
-    }
-    else if (nodeIsText(node)) {
-        items.push(getTextNodeInnerText(node));
-    }
-    return items;
-}
-/**
- * InnerText getter spec: https://html.spec.whatwg.org/multipage/dom.html#the-innertext-idl-attribute
- *
- * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1087
- */
-function getInnerText(element) {
-    const thisComputedStyle = getElementComputedStyle(element);
-    if (!nodeIsBeingRendered(thisComputedStyle)) {
-        return getTextContent(element) || '';
-    }
-    const selectionState = getSelectionState(element);
-    const results = [];
-    const childNodes = element.childNodes;
-    for (let i = 0, n = childNodes.length; i < n; i++) {
-        ArrayPush.apply(results, innerTextCollectionSteps(childNodes[i]));
-    }
-    restoreSelectionState(selectionState);
-    let elementInnerText = '';
-    let maxReqLineBreakCount = 0;
-    for (let i = 0, n = results.length; i < n; i++) {
-        const item = results[i];
-        if (typeof item === 'string') {
-            if (maxReqLineBreakCount > 0) {
-                for (let j = 0; j < maxReqLineBreakCount; j++) {
-                    elementInnerText += '\u{000A}';
-                }
-                maxReqLineBreakCount = 0;
-            }
-            if (item.length > 0) {
-                elementInnerText += item;
-            }
-        }
-        else {
-            if (elementInnerText.length == 0) {
-                // Remove required line break count at the start.
-                continue;
-            }
-            // Store the count if it's the max of this run,
-            // but it may be ignored if no text item is found afterwards,
-            // which means that these are consecutive line breaks at the end.
-            if (item > maxReqLineBreakCount) {
-                maxReqLineBreakCount = item;
-            }
-        }
-    }
-    return elementInnerText;
-}
-
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -5066,4 +5066,4 @@ defineProperty(Element.prototype, '$domManual$', {
     },
     configurable: true,
 });
-/** version: 2.12.1 */
+/** version: 2.13.2 */