@lwc/synthetic-shadow 2.50.0 → 3.0.1

package/dist/synthetic-shadow.js

@@ -1,4757 +0,0 @@
-/* proxy-compat-disable */
-/**
- * Copyright (C) 2023 salesforce.com, inc.
- */
-/* proxy-compat-disable */
-/**
- * Copyright (C) 2023 salesforce.com, inc.
- */
-/*
- * 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 invariant(value, msg) {
-    if (!value) {
-        throw new Error(`Invariant Violation: ${msg}`);
-    }
-}
-function isTrue$1(value, msg) {
-    if (!value) {
-        throw new Error(`Assert Violation: ${msg}`);
-    }
-}
-function isFalse$1(value, msg) {
-    if (value) {
-        throw new Error(`Assert Violation: ${msg}`);
-    }
-}
-function fail(msg) {
-    throw new Error(msg);
-}
-
-var assert = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    fail: fail,
-    invariant: invariant,
-    isFalse: isFalse$1,
-    isTrue: isTrue$1
-});
-
-/*
- * 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 { assign, create, defineProperties, defineProperty, freeze, getOwnPropertyDescriptor, getOwnPropertyNames, getPrototypeOf, hasOwnProperty, isFrozen, keys, seal, setPrototypeOf, } = Object;
-const { isArray } = Array;
-const { concat: ArrayConcat, copyWithin: ArrayCopyWithin, every: ArrayEvery, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, findIndex: ArrayFindIndex, includes: ArrayIncludes, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, } = Array.prototype;
-const { charCodeAt: StringCharCodeAt, replace: StringReplace, split: StringSplit, slice: StringSlice, toLowerCase: StringToLowerCase, } = String.prototype;
-function isUndefined(obj) {
-    return obj === undefined;
-}
-function isNull(obj) {
-    return obj === null;
-}
-function isTrue(obj) {
-    return obj === true;
-}
-function isFalse(obj) {
-    return obj === false;
-}
-function isFunction(obj) {
-    return typeof obj === 'function';
-}
-function isObject(obj) {
-    return typeof obj === 'object';
-}
-const OtS = {}.toString;
-function toString(obj) {
-    if (obj && obj.toString) {
-        // Arrays might hold objects with "null" prototype So using
-        // Array.prototype.toString directly will cause an error Iterate through
-        // all the items and handle individually.
-        if (isArray(obj)) {
-            return ArrayJoin.call(ArrayMap.call(obj, toString), ',');
-        }
-        return obj.toString();
-    }
-    else if (typeof obj === 'object') {
-        return OtS.call(obj);
-    }
-    else {
-        return obj + '';
-    }
-}
-
-/*
- * 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
- */
-// See browser support for globalThis:
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
-/* istanbul ignore next */
-// @ts-ignore
-const _globalThis = typeof globalThis === 'object' ? globalThis : window;
-
-/*
- * 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 KEY__IS_NATIVE_SHADOW_ROOT_DEFINED = '$isNativeShadowRootDefined$';
-const KEY__SHADOW_RESOLVER = '$shadowResolver$';
-const KEY__SHADOW_RESOLVER_PRIVATE = '$$ShadowResolverKey$$';
-const KEY__SHADOW_STATIC = '$shadowStaticNode$';
-const KEY__SHADOW_STATIC_PRIVATE = '$shadowStaticNodeKey$';
-const KEY__SHADOW_TOKEN = '$shadowToken$';
-const KEY__SHADOW_TOKEN_PRIVATE = '$$ShadowTokenKey$$';
-const KEY__SYNTHETIC_MODE = '$$lwc-synthetic-mode';
-const KEY__NATIVE_GET_ELEMENT_BY_ID = '$nativeGetElementById$';
-const KEY__NATIVE_QUERY_SELECTOR_ALL = '$nativeQuerySelectorAll$';
-
-/*
- * 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
- */
-// 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.50.0 */
-
-/* proxy-compat-disable */
-/**
- * Copyright (C) 2023 salesforce.com, inc.
- */
-// eslint-disable-next-line no-restricted-properties
-if (!_globalThis.lwcRuntimeFlags) {
-    Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
-}
-/** version: 2.50.0 */
-
-/*
- * 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
- */
-// TODO [#2472]: Remove this workaround when appropriate.
-// eslint-disable-next-line @lwc/lwc-internal/no-global-node
-const _Node = Node;
-const nodePrototype = _Node.prototype;
-const { DOCUMENT_POSITION_CONTAINED_BY, DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_PRECEDING, DOCUMENT_POSITION_FOLLOWING, ELEMENT_NODE, TEXT_NODE, CDATA_SECTION_NODE, PROCESSING_INSTRUCTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, } = _Node;
-const { appendChild, cloneNode, compareDocumentPosition, insertBefore, removeChild, replaceChild, hasChildNodes, } = nodePrototype;
-const { contains } = HTMLElement.prototype;
-const firstChildGetter = getOwnPropertyDescriptor(nodePrototype, 'firstChild').get;
-const lastChildGetter = getOwnPropertyDescriptor(nodePrototype, 'lastChild').get;
-const textContentGetter = getOwnPropertyDescriptor(nodePrototype, 'textContent').get;
-const parentNodeGetter = getOwnPropertyDescriptor(nodePrototype, 'parentNode').get;
-const ownerDocumentGetter = getOwnPropertyDescriptor(nodePrototype, 'ownerDocument').get;
-const parentElementGetter = hasOwnProperty.call(nodePrototype, 'parentElement')
-    ? getOwnPropertyDescriptor(nodePrototype, 'parentElement').get
-    : getOwnPropertyDescriptor(HTMLElement.prototype, 'parentElement').get; // IE11
-const textContextSetter = getOwnPropertyDescriptor(nodePrototype, 'textContent').set;
-const childNodesGetter = hasOwnProperty.call(nodePrototype, 'childNodes')
-    ? getOwnPropertyDescriptor(nodePrototype, 'childNodes').get
-    : getOwnPropertyDescriptor(HTMLElement.prototype, 'childNodes').get; // IE11
-const isConnected = hasOwnProperty.call(nodePrototype, 'isConnected')
-    ? getOwnPropertyDescriptor(nodePrototype, 'isConnected').get
-    : function () {
-        const doc = ownerDocumentGetter.call(this);
-        // IE11
-        return (
-        // if doc is null, it means `this` is actually a document instance which
-        // is always connected
-        doc === null ||
-            (compareDocumentPosition.call(doc, this) & DOCUMENT_POSITION_CONTAINED_BY) !== 0);
-    };
-
-/*
- * 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 { getAttribute, getBoundingClientRect, getElementsByTagName: getElementsByTagName$1, getElementsByTagNameNS: getElementsByTagNameNS$1, hasAttribute, querySelector, querySelectorAll: querySelectorAll$1, removeAttribute, setAttribute, } = Element.prototype;
-const attachShadow$1 = hasOwnProperty.call(Element.prototype, 'attachShadow')
-    ? Element.prototype.attachShadow
-    : () => {
-        throw new TypeError('attachShadow() is not supported in current browser. Load the @lwc/synthetic-shadow polyfill and use Lightning Web Components');
-    };
-const childElementCountGetter = getOwnPropertyDescriptor(Element.prototype, 'childElementCount').get;
-const firstElementChildGetter = getOwnPropertyDescriptor(Element.prototype, 'firstElementChild').get;
-const lastElementChildGetter = getOwnPropertyDescriptor(Element.prototype, 'lastElementChild').get;
-const innerTextDescriptor = getOwnPropertyDescriptor(HTMLElement.prototype, 'innerText');
-const innerTextGetter = innerTextDescriptor
-    ? innerTextDescriptor.get
-    : null;
-const innerTextSetter = innerTextDescriptor
-    ? innerTextDescriptor.set
-    : null;
-// Note: Firefox does not have outerText, https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/outerText
-const outerTextDescriptor = getOwnPropertyDescriptor(HTMLElement.prototype, 'outerText');
-const outerTextGetter = outerTextDescriptor
-    ? outerTextDescriptor.get
-    : null;
-const outerTextSetter = outerTextDescriptor
-    ? outerTextDescriptor.set
-    : null;
-const innerHTMLDescriptor = hasOwnProperty.call(Element.prototype, 'innerHTML')
-    ? getOwnPropertyDescriptor(Element.prototype, 'innerHTML')
-    : getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML'); // IE11
-const innerHTMLGetter = innerHTMLDescriptor.get;
-const innerHTMLSetter = innerHTMLDescriptor.set;
-const outerHTMLDescriptor = hasOwnProperty.call(Element.prototype, 'outerHTML')
-    ? getOwnPropertyDescriptor(Element.prototype, 'outerHTML')
-    : getOwnPropertyDescriptor(HTMLElement.prototype, 'outerHTML'); // IE11
-const outerHTMLGetter = outerHTMLDescriptor.get;
-const outerHTMLSetter = outerHTMLDescriptor.set;
-const tagNameGetter = getOwnPropertyDescriptor(Element.prototype, 'tagName').get;
-const tabIndexDescriptor = getOwnPropertyDescriptor(HTMLElement.prototype, 'tabIndex');
-const tabIndexGetter = tabIndexDescriptor.get;
-const tabIndexSetter = tabIndexDescriptor.set;
-const matches = hasOwnProperty.call(Element.prototype, 'matches')
-    ? Element.prototype.matches
-    : Element.prototype.msMatchesSelector; // IE11
-const childrenGetter = hasOwnProperty.call(Element.prototype, 'children')
-    ? getOwnPropertyDescriptor(Element.prototype, 'children').get
-    : getOwnPropertyDescriptor(HTMLElement.prototype, 'children').get; // IE11
-// for IE11, access from HTMLElement
-// for all other browsers access the method from the parent Element interface
-const { getElementsByClassName: getElementsByClassName$1 } = HTMLElement.prototype;
-const shadowRootGetter = hasOwnProperty.call(Element.prototype, 'shadowRoot')
-    ? getOwnPropertyDescriptor(Element.prototype, 'shadowRoot').get
-    : () => null;
-const assignedSlotGetter$1 = hasOwnProperty.call(Element.prototype, 'assignedSlot')
-    ? getOwnPropertyDescriptor(Element.prototype, 'assignedSlot').get
-    : () => null;
-
-/*
- * 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
- */
-let assignedNodes, assignedElements;
-if (typeof HTMLSlotElement !== 'undefined') {
-    assignedNodes = HTMLSlotElement.prototype.assignedNodes;
-    assignedElements = HTMLSlotElement.prototype.assignedElements;
-}
-else {
-    assignedNodes = () => {
-        throw new TypeError("assignedNodes() is not supported in current browser. Load the @lwc/synthetic-shadow polyfill to start using <slot> elements in your Lightning Web Component's template");
-    };
-    assignedElements = () => {
-        throw new TypeError("assignedElements() is not supported in current browser. Load the @lwc/synthetic-shadow polyfill to start using <slot> elements in your Lightning Web Component's template");
-    };
-}
-
-/*
- * 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 eventTargetGetter = getOwnPropertyDescriptor(Event.prototype, 'target').get;
-const eventCurrentTargetGetter = getOwnPropertyDescriptor(Event.prototype, 'currentTarget').get;
-const focusEventRelatedTargetGetter = getOwnPropertyDescriptor(FocusEvent.prototype, 'relatedTarget').get;
-// IE does not implement composedPath() but that's ok because we only use this instead of our
-// composedPath() polyfill when dealing with native shadow DOM components in mixed mode. Defaulting
-// to a NOOP just to be safe, even though this is almost guaranteed to be defined such a scenario.
-const composedPath = hasOwnProperty.call(Event.prototype, 'composedPath')
-    ? Event.prototype.composedPath
-    : () => [];
-
-/*
- * 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 DocumentPrototypeActiveElement = getOwnPropertyDescriptor(Document.prototype, 'activeElement').get;
-const elementFromPoint = hasOwnProperty.call(Document.prototype, 'elementFromPoint')
-    ? Document.prototype.elementFromPoint
-    : Document.prototype.msElementFromPoint; // IE11
-const elementsFromPoint = hasOwnProperty.call(Document.prototype, 'elementsFromPoint')
-    ? Document.prototype.elementsFromPoint
-    : Document.prototype.msElementsFromPoint; // IE11
-// defaultView can be null when a document has no browsing context. For example, the owner document
-// of a node in a template doesn't have a default view: https://jsfiddle.net/hv9z0q5a/
-const defaultViewGetter = getOwnPropertyDescriptor(Document.prototype, 'defaultView').get;
-const { createComment, querySelectorAll, getElementById, getElementsByClassName, getElementsByTagName, getElementsByTagNameNS, } = Document.prototype;
-// In Firefox v57 and lower, getElementsByName is defined on HTMLDocument.prototype
-// In all other browsers have the method on Document.prototype
-const { getElementsByName } = HTMLDocument.prototype;
-
-/*
- * 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 { addEventListener: windowAddEventListener, removeEventListener: windowRemoveEventListener, getComputedStyle: windowGetComputedStyle, getSelection: windowGetSelection, } = window;
-
-/*
- * 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
- */
-// There is code in the polyfills that requires access to the unpatched
-// Mutation Observer constructor, this the code for that.
-// Eventually, the polyfill should uses the patched version, and this file can be removed.
-const MO = MutationObserver;
-const MutationObserverObserve = MO.prototype.observe;
-
-/*
- * 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
- */
-let NativeShadowRoot = null;
-if (typeof ShadowRoot !== 'undefined') {
-    NativeShadowRoot = ShadowRoot;
-}
-const isNativeShadowRootDefined = !isNull(NativeShadowRoot);
-const isInstanceOfNativeShadowRoot = isNull(NativeShadowRoot)
-    ? () => false
-    : (node) => node instanceof NativeShadowRoot;
-
-/*
- * 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 detect$4 () {
-    return typeof HTMLSlotElement === 'undefined';
-}
-
-/*
- * 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 { createElement } = Document.prototype;
-const CHAR_S = 115;
-const CHAR_L = 108;
-const CHAR_O = 111;
-const CHAR_T = 116;
-function apply$4() {
-    // IE11 does not have this element definition
-    // we don't care much about the construction phase, just the prototype
-    class HTMLSlotElement {
-    }
-    // prototype inheritance dance
-    setPrototypeOf(HTMLSlotElement, HTMLElement.constructor);
-    setPrototypeOf(HTMLSlotElement.prototype, HTMLElement.prototype);
-    Window.prototype.HTMLSlotElement = HTMLSlotElement;
-    // IE11 doesn't have HTMLSlotElement, in which case we
-    // need to patch Document.prototype.createElement to remap `slot`
-    // elements to the right prototype
-    defineProperty(Document.prototype, 'createElement', {
-        value: function (tagName, _options) {
-            const elm = createElement.apply(this, ArraySlice.call(arguments));
-            if (tagName.length === 4 &&
-                StringCharCodeAt.call(tagName, 0) === CHAR_S &&
-                StringCharCodeAt.call(tagName, 1) === CHAR_L &&
-                StringCharCodeAt.call(tagName, 2) === CHAR_O &&
-                StringCharCodeAt.call(tagName, 3) === CHAR_T) {
-                // the new element is the `slot`, resetting the proto chain
-                // the new newly created global HTMLSlotElement.prototype
-                setPrototypeOf(elm, HTMLSlotElement.prototype);
-            }
-            return elm;
-        },
-    });
-}
-
-/*
- * 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
- */
-if (detect$4()) {
-    apply$4();
-}
-
-/*
- * 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
- */
-// Helpful for tests running with jsdom
-function getOwnerDocument(node) {
-    const doc = ownerDocumentGetter.call(node);
-    // if doc is null, it means `this` is actually a document instance
-    return doc === null ? node : doc;
-}
-function getOwnerWindow(node) {
-    const doc = getOwnerDocument(node);
-    const win = defaultViewGetter.call(doc);
-    if (win === null) {
-        // this method should never be called with a node that is not part
-        // of a qualifying connected node.
-        throw new TypeError();
-    }
-    return win;
-}
-let skipGlobalPatching;
-// Note: we deviate from native shadow here, but are not fixing
-// due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-function isGlobalPatchingSkipped(node) {
-    // we lazily compute this value instead of doing it during evaluation, this helps
-    // for apps that are setting this after the engine code is evaluated.
-    if (isUndefined(skipGlobalPatching)) {
-        const ownerDocument = getOwnerDocument(node);
-        skipGlobalPatching =
-            ownerDocument.body &&
-                getAttribute.call(ownerDocument.body, 'data-global-patching-bypass') ===
-                    'temporary-bypass';
-    }
-    return isTrue(skipGlobalPatching);
-}
-function arrayFromCollection(collection) {
-    const size = collection.length;
-    const cloned = [];
-    if (size > 0) {
-        for (let i = 0; i < size; i++) {
-            cloned[i] = collection[i];
-        }
-    }
-    return cloned;
-}
-
-/*
- * 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 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
- */
-// Used as a back reference to identify the host element
-const HostElementKey = '$$HostElementKey$$';
-const ShadowedNodeKey = '$$ShadowedNodeKey$$';
-function fastDefineProperty(node, propName, config) {
-    const shadowedNode = node;
-    if (process.env.NODE_ENV !== 'production') {
-        // in dev, we are more restrictive
-        defineProperty(shadowedNode, propName, config);
-    }
-    else {
-        const { value } = config;
-        // in prod, we prioritize performance
-        shadowedNode[propName] = value;
-    }
-}
-function setNodeOwnerKey(node, value) {
-    fastDefineProperty(node, HostElementKey, { value, configurable: true });
-}
-function setNodeKey(node, value) {
-    fastDefineProperty(node, ShadowedNodeKey, { value });
-}
-function getNodeOwnerKey(node) {
-    return node[HostElementKey];
-}
-function getNodeNearestOwnerKey(node) {
-    let host = node;
-    let hostKey;
-    // search for the first element with owner identity
-    // in case of manually inserted elements and elements slotted from Light DOM
-    while (!isNull(host)) {
-        hostKey = getNodeOwnerKey(host);
-        if (!isUndefined(hostKey)) {
-            return hostKey;
-        }
-        host = parentNodeGetter.call(host);
-        if (!isNull(host) && isSyntheticSlotElement(host)) {
-            return undefined;
-        }
-    }
-}
-function getNodeKey(node) {
-    return node[ShadowedNodeKey];
-}
-/**
- * This function does not traverse up for performance reasons, but is sufficient for most use
- * cases. If we need to traverse up and verify those nodes that don't have owner key, use
- * isNodeDeepShadowed instead.
- */
-function isNodeShadowed(node) {
-    return !isUndefined(getNodeOwnerKey(node));
-}
-
-/*
- * 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
- */
-// when finding a slot in the DOM, we can fold it if it is contained
-// inside another slot.
-function foldSlotElement(slot) {
-    let parent = parentElementGetter.call(slot);
-    while (!isNull(parent) && isSlotElement(parent)) {
-        slot = parent;
-        parent = parentElementGetter.call(slot);
-    }
-    return slot;
-}
-function isNodeSlotted(host, node) {
-    if (process.env.NODE_ENV !== 'production') {
-        if (!(host instanceof HTMLElement)) {
-            // eslint-disable-next-line no-console
-            console.error(`isNodeSlotted() should be called with a host as the first argument`);
-        }
-        if (!(node instanceof _Node)) {
-            // eslint-disable-next-line no-console
-            console.error(`isNodeSlotted() should be called with a node as the second argument`);
-        }
-        if (!(compareDocumentPosition.call(node, host) & DOCUMENT_POSITION_CONTAINS)) {
-            // eslint-disable-next-line no-console
-            console.error(`isNodeSlotted() should never be called with a node that is not a child node of the given host`);
-        }
-    }
-    const hostKey = getNodeKey(host);
-    // this routine assumes that the node is coming from a different shadow (it is not owned by the host)
-    // just in case the provided node is not an element
-    let currentElement = node instanceof Element ? node : parentElementGetter.call(node);
-    while (!isNull(currentElement) && currentElement !== host) {
-        const elmOwnerKey = getNodeNearestOwnerKey(currentElement);
-        const parent = parentElementGetter.call(currentElement);
-        if (elmOwnerKey === hostKey) {
-            // we have reached an element inside the host's template, and only if
-            // that element is an slot, then the node is considered slotted
-            return isSlotElement(currentElement);
-        }
-        else if (parent === host) {
-            return false;
-        }
-        else if (!isNull(parent) && getNodeNearestOwnerKey(parent) !== elmOwnerKey) {
-            // we are crossing a boundary of some sort since the elm and its parent
-            // have different owner key. for slotted elements, this is possible
-            // if the parent happens to be a slot.
-            if (isSlotElement(parent)) {
-                /**
-                 * the slot parent might be allocated inside another slot, think of:
-                 * <x-root> (<--- root element)
-                 *    <x-parent> (<--- own by x-root)
-                 *       <x-child> (<--- own by x-root)
-                 *           <slot> (<--- own by x-child)
-                 *               <slot> (<--- own by x-parent)
-                 *                  <div> (<--- own by x-root)
-                 *
-                 * while checking if x-parent has the div slotted, we need to traverse
-                 * up, but when finding the first slot, we skip that one in favor of the
-                 * most outer slot parent before jumping into its corresponding host.
-                 */
-                currentElement = getNodeOwner(foldSlotElement(parent));
-                if (!isNull(currentElement)) {
-                    if (currentElement === host) {
-                        // the slot element is a top level element inside the shadow
-                        // of a host that was allocated into host in question
-                        return true;
-                    }
-                    else if (getNodeNearestOwnerKey(currentElement) === hostKey) {
-                        // the slot element is an element inside the shadow
-                        // of a host that was allocated into host in question
-                        return true;
-                    }
-                }
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            currentElement = parent;
-        }
-    }
-    return false;
-}
-function getNodeOwner(node) {
-    if (!(node instanceof _Node)) {
-        return null;
-    }
-    const ownerKey = getNodeNearestOwnerKey(node);
-    if (isUndefined(ownerKey)) {
-        return null;
-    }
-    let nodeOwner = node;
-    // At this point, node is a valid node with owner identity, now we need to find the owner node
-    // search for a custom element with a VM that owns the first element with owner identity attached to it
-    while (!isNull(nodeOwner) && getNodeKey(nodeOwner) !== ownerKey) {
-        nodeOwner = parentNodeGetter.call(nodeOwner);
-    }
-    if (isNull(nodeOwner)) {
-        return null;
-    }
-    return nodeOwner;
-}
-function isSyntheticSlotElement(node) {
-    return isSlotElement(node) && isNodeShadowed(node);
-}
-function isSlotElement(node) {
-    return node instanceof HTMLSlotElement;
-}
-function isNodeOwnedBy(owner, node) {
-    if (process.env.NODE_ENV !== 'production') {
-        if (!(owner instanceof HTMLElement)) {
-            // eslint-disable-next-line no-console
-            console.error(`isNodeOwnedBy() should be called with an element as the first argument`);
-        }
-        if (!(node instanceof _Node)) {
-            // eslint-disable-next-line no-console
-            console.error(`isNodeOwnedBy() should be called with a node as the second argument`);
-        }
-        if (!(compareDocumentPosition.call(node, owner) & DOCUMENT_POSITION_CONTAINS)) {
-            // eslint-disable-next-line no-console
-            console.error(`isNodeOwnedBy() should never be called with a node that is not a child node of of the given owner`);
-        }
-    }
-    const ownerKey = getNodeNearestOwnerKey(node);
-    if (isUndefined(ownerKey)) {
-        // in case of root level light DOM element slotting into a synthetic shadow
-        const host = parentNodeGetter.call(node);
-        if (!isNull(host) && isSyntheticSlotElement(host)) {
-            return false;
-        }
-        // in case of manually inserted elements
-        return true;
-    }
-    return getNodeKey(owner) === ownerKey;
-}
-function shadowRootChildNodes(root) {
-    const elm = getHost(root);
-    return getAllMatches(elm, arrayFromCollection(childNodesGetter.call(elm)));
-}
-function getAllSlottedMatches(host, nodeList) {
-    const filteredAndPatched = [];
-    for (let i = 0, len = nodeList.length; i < len; i += 1) {
-        const node = nodeList[i];
-        if (!isNodeOwnedBy(host, node) && isNodeSlotted(host, node)) {
-            ArrayPush.call(filteredAndPatched, node);
-        }
-    }
-    return filteredAndPatched;
-}
-function getFirstSlottedMatch(host, nodeList) {
-    for (let i = 0, len = nodeList.length; i < len; i += 1) {
-        const node = nodeList[i];
-        if (!isNodeOwnedBy(host, node) && isNodeSlotted(host, node)) {
-            return node;
-        }
-    }
-    return null;
-}
-function getAllMatches(owner, nodeList) {
-    const filteredAndPatched = [];
-    for (let i = 0, len = nodeList.length; i < len; i += 1) {
-        const node = nodeList[i];
-        const isOwned = isNodeOwnedBy(owner, node);
-        if (isOwned) {
-            // Patch querySelector, querySelectorAll, etc
-            // if element is owned by VM
-            ArrayPush.call(filteredAndPatched, node);
-        }
-    }
-    return filteredAndPatched;
-}
-function getFirstMatch(owner, nodeList) {
-    for (let i = 0, len = nodeList.length; i < len; i += 1) {
-        if (isNodeOwnedBy(owner, nodeList[i])) {
-            return nodeList[i];
-        }
-    }
-    return null;
-}
-function shadowRootQuerySelector(root, selector) {
-    const elm = getHost(root);
-    const nodeList = arrayFromCollection(querySelectorAll$1.call(elm, selector));
-    return getFirstMatch(elm, nodeList);
-}
-function shadowRootQuerySelectorAll(root, selector) {
-    const elm = getHost(root);
-    const nodeList = querySelectorAll$1.call(elm, selector);
-    return getAllMatches(elm, arrayFromCollection(nodeList));
-}
-function getFilteredChildNodes(node) {
-    if (!isSyntheticShadowHost(node) && !isSlotElement(node)) {
-        // regular element - fast path
-        const children = childNodesGetter.call(node);
-        return arrayFromCollection(children);
-    }
-    if (isSyntheticShadowHost(node)) {
-        // we need to get only the nodes that were slotted
-        const slots = arrayFromCollection(querySelectorAll$1.call(node, 'slot'));
-        const resolver = getShadowRootResolver(getShadowRoot(node));
-        // Typescript is inferring the wrong function type for this particular
-        // overloaded method: https://github.com/Microsoft/TypeScript/issues/27972
-        // @ts-ignore type-mismatch
-        return ArrayReduce.call(slots, (seed, slot) => {
-            if (resolver === getShadowRootResolver(slot)) {
-                ArrayPush.apply(seed, getFilteredSlotAssignedNodes(slot));
-            }
-            return seed;
-        }, []);
-    }
-    else {
-        // slot element
-        const children = arrayFromCollection(childNodesGetter.call(node));
-        const resolver = getShadowRootResolver(node);
-        return ArrayFilter.call(children, (child) => resolver === getShadowRootResolver(child));
-    }
-}
-function getFilteredSlotAssignedNodes(slot) {
-    const owner = getNodeOwner(slot);
-    if (isNull(owner)) {
-        return [];
-    }
-    const childNodes = arrayFromCollection(childNodesGetter.call(slot));
-    return ArrayFilter.call(childNodes, (child) => !isNodeShadowed(child) || !isNodeOwnedBy(owner, child));
-}
-
-/*
- * 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
- */
-/**
-@license
-Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-*/
-// This code is inspired by Polymer ShadyDOM Polyfill
-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
- */
-/**
-@license
-Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-*/
-// This code is inspired by Polymer ShadyDOM Polyfill
-// 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
- */
-/**
-@license
-Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-*/
-// This code is inspired by Polymer ShadyDOM Polyfill
-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;
-    }
-}
-
-/*
- * 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 Items$1 = new WeakMap();
-function StaticNodeList() {
-    throw new TypeError('Illegal constructor');
-}
-StaticNodeList.prototype = create(NodeList.prototype, {
-    constructor: {
-        writable: true,
-        configurable: true,
-        value: StaticNodeList,
-    },
-    item: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(index) {
-            return this[index];
-        },
-    },
-    length: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return Items$1.get(this).length;
-        },
-    },
-    // Iterator protocol
-    forEach: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(cb, thisArg) {
-            forEach.call(Items$1.get(this), cb, thisArg);
-        },
-    },
-    entries: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            return ArrayMap.call(Items$1.get(this), (v, i) => [i, v]);
-        },
-    },
-    keys: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            return ArrayMap.call(Items$1.get(this), (_v, i) => i);
-        },
-    },
-    values: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            return Items$1.get(this);
-        },
-    },
-    [Symbol.iterator]: {
-        writable: true,
-        configurable: true,
-        value() {
-            let nextIndex = 0;
-            return {
-                next: () => {
-                    const items = Items$1.get(this);
-                    return nextIndex < items.length
-                        ? {
-                            value: items[nextIndex++],
-                            done: false,
-                        }
-                        : {
-                            done: true,
-                        };
-                },
-            };
-        },
-    },
-    [Symbol.toStringTag]: {
-        configurable: true,
-        get() {
-            return 'NodeList';
-        },
-    },
-    // IE11 doesn't support Symbol.toStringTag, in which case we
-    // provide the regular toString method.
-    toString: {
-        writable: true,
-        configurable: true,
-        value() {
-            return '[object NodeList]';
-        },
-    },
-});
-// prototype inheritance dance
-setPrototypeOf(StaticNodeList, NodeList);
-function createStaticNodeList(items) {
-    const nodeList = create(StaticNodeList.prototype);
-    Items$1.set(nodeList, items);
-    // setting static indexes
-    forEach.call(items, (item, index) => {
-        defineProperty(nodeList, index, {
-            value: item,
-            enumerable: true,
-            configurable: true,
-        });
-    });
-    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.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const Items = new WeakMap();
-function StaticHTMLCollection() {
-    throw new TypeError('Illegal constructor');
-}
-StaticHTMLCollection.prototype = create(HTMLCollection.prototype, {
-    constructor: {
-        writable: true,
-        configurable: true,
-        value: StaticHTMLCollection,
-    },
-    item: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(index) {
-            return this[index];
-        },
-    },
-    length: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return Items.get(this).length;
-        },
-    },
-    // https://dom.spec.whatwg.org/#dom-htmlcollection-nameditem-key
-    namedItem: {
-        writable: true,
-        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
- */
-/**
- * This method checks whether or not the content of the node is computed
- * based on the light-dom slotting mechanism. This applies to synthetic slot elements
- * and elements with shadow dom attached to them. It doesn't apply to native slot elements
- * because we don't want to patch the children getters for those elements.
- */
-function hasMountedChildren(node) {
-    return isSyntheticSlotElement(node) || isSyntheticShadowHost(node);
-}
-function getShadowParent(node, value) {
-    const owner = getNodeOwner(node);
-    if (value === owner) {
-        // walking up via parent chain might end up in the shadow root element
-        return getShadowRoot(owner);
-    }
-    else if (value instanceof Element) {
-        if (getNodeNearestOwnerKey(node) === getNodeNearestOwnerKey(value)) {
-            // the element and its parent node belong to the same shadow root
-            return value;
-        }
-        else if (!isNull(owner) && isSlotElement(value)) {
-            // slotted elements must be top level childNodes of the slot element
-            // where they slotted into, but its shadowed parent is always the
-            // owner of the slot.
-            const slotOwner = getNodeOwner(value);
-            if (!isNull(slotOwner) && isNodeOwnedBy(owner, slotOwner)) {
-                // it is a slotted element, and therefore its parent is always going to be the host of the slot
-                return slotOwner;
-            }
-        }
-    }
-    return null;
-}
-function hasChildNodesPatched() {
-    return getInternalChildNodes(this).length > 0;
-}
-function firstChildGetterPatched() {
-    const childNodes = getInternalChildNodes(this);
-    return childNodes[0] || null;
-}
-function lastChildGetterPatched() {
-    const childNodes = getInternalChildNodes(this);
-    return childNodes[childNodes.length - 1] || null;
-}
-function textContentGetterPatched() {
-    return getTextContent(this);
-}
-function textContentSetterPatched(value) {
-    textContextSetter.call(this, value);
-}
-function parentNodeGetterPatched() {
-    const value = parentNodeGetter.call(this);
-    if (isNull(value)) {
-        return value;
-    }
-    // TODO [#1635]: this needs optimization, maybe implementing it based on this.assignedSlot
-    return getShadowParent(this, value);
-}
-function parentElementGetterPatched() {
-    const value = parentNodeGetter.call(this);
-    if (isNull(value)) {
-        return null;
-    }
-    const parentNode = getShadowParent(this, value);
-    // it could be that the parentNode is the shadowRoot, in which case
-    // we need to return null.
-    // TODO [#1635]: this needs optimization, maybe implementing it based on this.assignedSlot
-    return parentNode instanceof Element ? parentNode : null;
-}
-function compareDocumentPositionPatched(otherNode) {
-    if (this === otherNode) {
-        return 0;
-    }
-    else if (this.getRootNode() === otherNode) {
-        // "this" is in a shadow tree where the shadow root is the "otherNode".
-        return 10; // Node.DOCUMENT_POSITION_CONTAINS | Node.DOCUMENT_POSITION_PRECEDING
-    }
-    else if (getNodeOwnerKey(this) !== getNodeOwnerKey(otherNode)) {
-        // "this" and "otherNode" belongs to 2 different shadow tree.
-        return 35; // Node.DOCUMENT_POSITION_DISCONNECTED | Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | Node.DOCUMENT_POSITION_PRECEDING
-    }
-    // Since "this" and "otherNode" are part of the same shadow tree we can safely rely to the native
-    // Node.compareDocumentPosition implementation.
-    return compareDocumentPosition.call(this, otherNode);
-}
-function containsPatched(otherNode) {
-    if (otherNode == null || getNodeOwnerKey(this) !== getNodeOwnerKey(otherNode)) {
-        // it is from another shadow
-        return false;
-    }
-    return (compareDocumentPosition.call(this, otherNode) & DOCUMENT_POSITION_CONTAINED_BY) !== 0;
-}
-function cloneNodePatched(deep) {
-    const clone = cloneNode.call(this, false);
-    // Per spec, browsers only care about truthy values
-    // Not strict true or false
-    if (!deep) {
-        return clone;
-    }
-    const childNodes = getInternalChildNodes(this);
-    for (let i = 0, len = childNodes.length; i < len; i += 1) {
-        clone.appendChild(childNodes[i].cloneNode(true));
-    }
-    return clone;
-}
-/**
- * This method only applies to elements with a shadow or slots
- */
-function childNodesGetterPatched() {
-    if (isSyntheticShadowHost(this)) {
-        const owner = getNodeOwner(this);
-        const childNodes = isNull(owner) ? [] : getAllMatches(owner, getFilteredChildNodes(this));
-        if (process.env.NODE_ENV !== 'production' &&
-            isFalse(hasNativeSymbolSupport) &&
-            isExternalChildNodeAccessorFlagOn()) {
-            // inserting a comment node as the first childNode to trick the IE11
-            // DevTool to show the content of the shadowRoot, this should only happen
-            // in dev-mode and in IE11 (which we detect by looking at the symbol).
-            // Plus it should only be in place if we know it is an external invoker.
-            ArrayUnshift.call(childNodes, getIE11FakeShadowRootPlaceholder(this));
-        }
-        return createStaticNodeList(childNodes);
-    }
-    // nothing to do here since this does not have a synthetic shadow attached to it
-    // TODO [#1636]: what about slot elements?
-    return childNodesGetter.call(this);
-}
-const nativeGetRootNode = _Node.prototype.getRootNode;
-/**
- * Get the root by climbing up the dom tree, beyond the shadow root
- * If Node.prototype.getRootNode is supported, use it
- * else, assume we are working in non-native shadow mode and climb using parentNode
- */
-const getDocumentOrRootNode = !isUndefined(nativeGetRootNode)
-    ? nativeGetRootNode
-    : function () {
-        let node = this;
-        let nodeParent;
-        while (!isNull((nodeParent = parentNodeGetter.call(node)))) {
-            node = nodeParent;
-        }
-        return node;
-    };
-/**
- * Get the shadow root
- * getNodeOwner() returns the host element that owns the given node
- * Note: getNodeOwner() returns null when running in native-shadow mode.
- *  Fallback to using the native getRootNode() to discover the root node.
- *  This is because, it is not possible to inspect the node and decide if it is part
- *  of a native shadow or the synthetic shadow.
- * @param {Node} node
- */
-function getNearestRoot(node) {
-    const ownerNode = getNodeOwner(node);
-    if (isNull(ownerNode)) {
-        // we hit a wall, either we are in native shadow mode or the node is not in lwc boundary.
-        return getDocumentOrRootNode.call(node);
-    }
-    return getShadowRoot(ownerNode);
-}
-/**
- * If looking for a root node beyond shadow root by calling `node.getRootNode({composed: true})`, use the original `Node.prototype.getRootNode` method
- * to return the root of the dom tree. In IE11 and Edge, Node.prototype.getRootNode is
- * [not supported](https://developer.mozilla.org/en-US/docs/Web/API/Node/getRootNode#Browser_compatibility). The root node is discovered by manually
- * climbing up the dom tree.
- *
- * If looking for a shadow root of a node by calling `node.getRootNode({composed: false})` or `node.getRootNode()`,
- *
- *  1. Try to identify the host element that owns the give node.
- *     i. Identify the shadow tree that the node belongs to
- *     ii. If the node belongs to a shadow tree created by engine, return the shadowRoot of the host element that owns the shadow tree
- *  2. The host identification logic returns null in two cases:
- *     i. The node does not belong to a shadow tree created by engine
- *     ii. The engine is running in native shadow dom mode
- *     If so, use the original Node.prototype.getRootNode to fetch the root node(or manually climb up the dom tree where getRootNode() is unsupported)
- *
- * _Spec_: https://dom.spec.whatwg.org/#dom-node-getrootnode
- *
- **/
-function getRootNodePatched(options) {
-    const composed = isUndefined(options) ? false : !!options.composed;
-    return isTrue(composed) ? getDocumentOrRootNode.call(this, options) : getNearestRoot(this);
-}
-// Non-deep-traversing patches: this descriptor map includes all descriptors that
-// do not give access to nodes beyond the immediate children.
-defineProperties(_Node.prototype, {
-    firstChild: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return firstChildGetterPatched.call(this);
-            }
-            return firstChildGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    lastChild: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return lastChildGetterPatched.call(this);
-            }
-            return lastChildGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    textContent: {
-        get() {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
-                return textContentGetterPatched.call(this);
-            }
-            return textContentGetter.call(this);
-        },
-        set: textContentSetterPatched,
-        enumerable: true,
-        configurable: true,
-    },
-    parentNode: {
-        get() {
-            if (isNodeShadowed(this)) {
-                return parentNodeGetterPatched.call(this);
-            }
-            const parentNode = parentNodeGetter.call(this);
-            // Handle the case where a top level light DOM element is slotted into a synthetic
-            // shadow slot.
-            if (!isNull(parentNode) && isSyntheticSlotElement(parentNode)) {
-                return getNodeOwner(parentNode);
-            }
-            return parentNode;
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    parentElement: {
-        get() {
-            if (isNodeShadowed(this)) {
-                return parentElementGetterPatched.call(this);
-            }
-            const parentElement = parentElementGetter.call(this);
-            // Handle the case where a top level light DOM element is slotted into a synthetic
-            // shadow slot.
-            if (!isNull(parentElement) && isSyntheticSlotElement(parentElement)) {
-                return getNodeOwner(parentElement);
-            }
-            return parentElement;
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    childNodes: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return childNodesGetterPatched.call(this);
-            }
-            return childNodesGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    hasChildNodes: {
-        value() {
-            if (hasMountedChildren(this)) {
-                return hasChildNodesPatched.call(this);
-            }
-            return hasChildNodes.call(this);
-        },
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    compareDocumentPosition: {
-        value(otherNode) {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            if (isGlobalPatchingSkipped(this)) {
-                return compareDocumentPosition.call(this, otherNode);
-            }
-            return compareDocumentPositionPatched.call(this, otherNode);
-        },
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    contains: {
-        value(otherNode) {
-            // 1. Node.prototype.contains() returns true if otherNode is an inclusive descendant
-            //    spec: https://dom.spec.whatwg.org/#dom-node-contains
-            // 2. This normalizes the behavior of this api across all browsers.
-            //    In IE11, a disconnected dom element without children invoking contains() on self, returns false
-            if (this === otherNode) {
-                return true;
-            }
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            if (otherNode == null) {
-                return false;
-            }
-            if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
-                return containsPatched.call(this, otherNode);
-            }
-            return contains.call(this, otherNode);
-        },
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    cloneNode: {
-        value(deep) {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
-                return cloneNodePatched.call(this, deep);
-            }
-            return cloneNode.call(this, deep);
-        },
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    getRootNode: {
-        value: getRootNodePatched,
-        enumerable: true,
-        configurable: true,
-        writable: true,
-    },
-    isConnected: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return isConnected.call(this);
-        },
-    },
-});
-let internalChildNodeAccessorFlag = false;
-/**
- * These 2 methods are providing a machinery to understand who is accessing the
- * .childNodes member property of a node. If it is used from inside the synthetic shadow
- * or from an external invoker. This helps to produce the right output in one very peculiar
- * case, the IE11 debugging comment for shadowRoot representation on the devtool.
- */
-function isExternalChildNodeAccessorFlagOn() {
-    return !internalChildNodeAccessorFlag;
-}
-const getInternalChildNodes = process.env.NODE_ENV !== 'production' && isFalse(hasNativeSymbolSupport)
-    ? function (node) {
-        internalChildNodeAccessorFlag = true;
-        let childNodes;
-        let error = null;
-        try {
-            childNodes = node.childNodes;
-        }
-        catch (e) {
-            // childNodes accessor should never throw, but just in case!
-            error = e;
-        }
-        finally {
-            internalChildNodeAccessorFlag = false;
-            if (!isNull(error)) {
-                // re-throwing after restoring the state machinery for setInternalChildNodeAccessorFlag
-                throw error; // eslint-disable-line no-unsafe-finally
-            }
-        }
-        return childNodes;
-    }
-    : function (node) {
-        return node.childNodes;
-    };
-// IE11 extra patches for wrong prototypes
-if (hasOwnProperty.call(HTMLElement.prototype, 'contains')) {
-    defineProperty(HTMLElement.prototype, 'contains', getOwnPropertyDescriptor(_Node.prototype, 'contains'));
-}
-if (hasOwnProperty.call(HTMLElement.prototype, 'parentElement')) {
-    defineProperty(HTMLElement.prototype, 'parentElement', getOwnPropertyDescriptor(_Node.prototype, 'parentElement'));
-}
-
-/*
- * 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$1(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$1(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();
-function getEventHandler(listener) {
-    if (isFunction(listener)) {
-        return listener;
-    }
-    else {
-        return listener.handleEvent;
-    }
-}
-function isEventListenerOrEventListenerObject(listener) {
-    return isFunction(listener) || isFunction(listener === null || listener === void 0 ? void 0 : listener.handleEvent);
-}
-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 getManagedShadowRootListener(listener) {
-    if (!isEventListenerOrEventListenerObject(listener)) {
-        throw new TypeError(); // avoiding problems with non-valid listeners
-    }
-    let managedListener = shadowRootEventListenerMap.get(listener);
-    if (isUndefined(managedListener)) {
-        managedListener = {
-            identity: listener,
-            placement: 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */,
-            handleEvent(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)) {
-                    getEventHandler(listener).call(currentTarget, event);
-                }
-            },
-        };
-        shadowRootEventListenerMap.set(listener, managedListener);
-    }
-    return managedListener;
-}
-const customElementEventListenerMap = new WeakMap();
-function getManagedCustomElementListener(listener) {
-    if (!isEventListenerOrEventListenerObject(listener)) {
-        throw new TypeError(); // avoiding problems with non-valid listeners
-    }
-    let managedListener = customElementEventListenerMap.get(listener);
-    if (isUndefined(managedListener)) {
-        managedListener = {
-            identity: listener,
-            placement: 0 /* EventListenerContext.CUSTOM_ELEMENT_LISTENER */,
-            handleEvent(event) {
-                // currentTarget is always defined inside an event listener
-                const currentTarget = eventCurrentTargetGetter.call(event);
-                const actualTarget = getActualTarget(event);
-                if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                    getEventHandler(listener).call(currentTarget, event);
-                }
-            },
-        };
-        customElementEventListenerMap.set(listener, managedListener);
-    }
-    return managedListener;
-}
-function indexOfManagedListener(listeners, listener) {
-    return ArrayFindIndex.call(listeners, (l) => l.identity === listener.identity);
-}
-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 (indexOfManagedListener(listeners, listener) !== -1) {
-                    // all handlers on the custom element should be called with undefined 'this'
-                    listener.handleEvent.call(undefined, evt);
-                }
-            }
-        });
-    }
-    eventToContextMap.set(evt, 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */);
-    invokeListenersByPlacement(1 /* EventListenerContext.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 /* EventListenerContext.CUSTOM_ELEMENT_LISTENER */);
-        invokeListenersByPlacement(0 /* EventListenerContext.CUSTOM_ELEMENT_LISTENER */);
-    }
-    eventToContextMap.set(evt, 2 /* EventListenerContext.UNKNOWN_LISTENER */);
-}
-function attachDOMListener(elm, type, managedListener) {
-    const listenerMap = getEventMap(elm);
-    let listeners = listenerMap[type];
-    if (isUndefined(listeners)) {
-        listeners = listenerMap[type] = [];
-    }
-    // Prevent identical listeners from subscribing to the same event type.
-    // TODO [#1824]: Options will also play a factor in deduping if we introduce options support
-    if (indexOfManagedListener(listeners, managedListener) !== -1) {
-        return;
-    }
-    // only add to DOM if there is no other listener on the same placement yet
-    if (listeners.length === 0) {
-        addEventListener.call(elm, type, domListener);
-    }
-    ArrayPush.call(listeners, managedListener);
-}
-function detachDOMListener(elm, type, managedListener) {
-    const listenerMap = getEventMap(elm);
-    let index;
-    let listeners;
-    if (!isUndefined((listeners = listenerMap[type])) &&
-        (index = indexOfManagedListener(listeners, managedListener)) !== -1) {
-        ArraySplice.call(listeners, index, 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 (!isEventListenerOrEventListenerObject(listener)) {
-            throw new TypeError(`Invalid second argument for Element.addEventListener() in ${toString(this)} for event "${type}". Expected EventListener or EventListenerObject but received ${listener}.`);
-        }
-    }
-    if (isEventListenerOrEventListenerObject(listener)) {
-        const managedListener = getManagedCustomElementListener(listener);
-        attachDOMListener(this, type, managedListener);
-    }
-}
-function removeCustomElementEventListener(type, listener, _options) {
-    if (isEventListenerOrEventListenerObject(listener)) {
-        const managedListener = getManagedCustomElementListener(listener);
-        detachDOMListener(this, type, managedListener);
-    }
-}
-function addShadowRootEventListener(sr, type, listener, _options) {
-    if (process.env.NODE_ENV !== 'production') {
-        if (!isEventListenerOrEventListenerObject(listener)) {
-            throw new TypeError(`Invalid second argument for ShadowRoot.addEventListener() in ${toString(sr)} for event "${type}". Expected EventListener or EventListenerObject but received ${listener}.`);
-        }
-    }
-    if (isEventListenerOrEventListenerObject(listener)) {
-        const elm = getHost(sr);
-        const managedListener = getManagedShadowRootListener(listener);
-        attachDOMListener(elm, type, managedListener);
-    }
-}
-function removeShadowRootEventListener(sr, type, listener, _options) {
-    if (isEventListenerOrEventListenerObject(listener)) {
-        const elm = getHost(sr);
-        const managedListener = getManagedShadowRootListener(listener);
-        detachDOMListener(elm, type, managedListener);
-    }
-}
-
-/*
- * 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 InternalSlot = new WeakMap();
-const { createDocumentFragment } = document;
-function hasInternalSlot(root) {
-    return InternalSlot.has(root);
-}
-function getInternalSlot(root) {
-    const record = InternalSlot.get(root);
-    if (isUndefined(record)) {
-        throw new TypeError();
-    }
-    return record;
-}
-defineProperty(_Node.prototype, KEY__SHADOW_RESOLVER, {
-    set(fn) {
-        if (isUndefined(fn))
-            return;
-        this[KEY__SHADOW_RESOLVER_PRIVATE] = fn;
-        // TODO [#1164]: temporary propagation of the key
-        setNodeOwnerKey(this, fn.nodeKey);
-    },
-    get() {
-        return this[KEY__SHADOW_RESOLVER_PRIVATE];
-    },
-    configurable: true,
-    enumerable: true,
-});
-defineProperty(_globalThis, KEY__IS_NATIVE_SHADOW_ROOT_DEFINED, {
-    value: isNativeShadowRootDefined,
-});
-// The isUndefined check is because two copies of synthetic shadow may be loaded on the same page, and this
-// would throw an error if we tried to redefine it. Plus the whole point is to expose the native method.
-if (isUndefined(_globalThis[KEY__NATIVE_GET_ELEMENT_BY_ID])) {
-    defineProperty(_globalThis, KEY__NATIVE_GET_ELEMENT_BY_ID, {
-        value: getElementById,
-        configurable: true,
-    });
-}
-// See note above.
-if (isUndefined(_globalThis[KEY__NATIVE_QUERY_SELECTOR_ALL])) {
-    defineProperty(_globalThis, KEY__NATIVE_QUERY_SELECTOR_ALL, {
-        value: querySelectorAll,
-        configurable: true,
-    });
-}
-function getShadowRootResolver(node) {
-    return node[KEY__SHADOW_RESOLVER];
-}
-function setShadowRootResolver(node, fn) {
-    node[KEY__SHADOW_RESOLVER] = fn;
-}
-function isDelegatingFocus(host) {
-    return getInternalSlot(host).delegatesFocus;
-}
-function getHost(root) {
-    return getInternalSlot(root).host;
-}
-function getShadowRoot(elm) {
-    return getInternalSlot(elm).shadowRoot;
-}
-// Intentionally adding `Node` here in addition to `Element` since this check is harmless for nodes
-// and we can avoid having to cast the type before calling this method in a few places.
-function isSyntheticShadowHost(node) {
-    const shadowRootRecord = InternalSlot.get(node);
-    return !isUndefined(shadowRootRecord) && node === shadowRootRecord.host;
-}
-function isSyntheticShadowRoot(node) {
-    const shadowRootRecord = InternalSlot.get(node);
-    return !isUndefined(shadowRootRecord) && node === shadowRootRecord.shadowRoot;
-}
-let uid = 0;
-function attachShadow(elm, options) {
-    if (InternalSlot.has(elm)) {
-        throw new Error(`Failed to execute 'attachShadow' on 'Element': Shadow root cannot be created on a host which already hosts a shadow tree.`);
-    }
-    const { mode, delegatesFocus } = options;
-    // creating a real fragment for shadowRoot instance
-    const doc = getOwnerDocument(elm);
-    const sr = createDocumentFragment.call(doc);
-    // creating shadow internal record
-    const record = {
-        mode,
-        delegatesFocus: !!delegatesFocus,
-        host: elm,
-        shadowRoot: sr,
-    };
-    InternalSlot.set(sr, record);
-    InternalSlot.set(elm, record);
-    const shadowResolver = () => sr;
-    const x = (shadowResolver.nodeKey = uid++);
-    setNodeKey(elm, x);
-    setShadowRootResolver(sr, shadowResolver);
-    // correcting the proto chain
-    setPrototypeOf(sr, SyntheticShadowRoot.prototype);
-    return sr;
-}
-const SyntheticShadowRootDescriptors = {
-    constructor: {
-        writable: true,
-        configurable: true,
-        value: SyntheticShadowRoot,
-    },
-    toString: {
-        writable: true,
-        configurable: true,
-        value() {
-            return `[object ShadowRoot]`;
-        },
-    },
-    synthetic: {
-        writable: false,
-        enumerable: false,
-        configurable: false,
-        value: true,
-    },
-};
-const ShadowRootDescriptors = {
-    activeElement: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const host = getHost(this);
-            const doc = getOwnerDocument(host);
-            const activeElement = DocumentPrototypeActiveElement.call(doc);
-            if (isNull(activeElement)) {
-                return activeElement;
-            }
-            if ((compareDocumentPosition.call(host, activeElement) &
-                DOCUMENT_POSITION_CONTAINED_BY) ===
-                0) {
-                return null;
-            }
-            // activeElement must be child of the host and owned by it
-            let node = activeElement;
-            while (!isNodeOwnedBy(host, node)) {
-                // parentElement is always an element because we are talking up the tree knowing
-                // that it is a child of the host.
-                node = parentElementGetter.call(node);
-            }
-            // If we have a slot element here that means that we were dealing
-            // with an element that was passed to one of our slots. In this
-            // case, activeElement returns null.
-            if (isSlotElement(node)) {
-                return null;
-            }
-            return node;
-        },
-    },
-    delegatesFocus: {
-        configurable: true,
-        get() {
-            return getInternalSlot(this).delegatesFocus;
-        },
-    },
-    elementFromPoint: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(left, top) {
-            const host = getHost(this);
-            const doc = getOwnerDocument(host);
-            return fauxElementFromPoint(this, doc, left, top);
-        },
-    },
-    elementsFromPoint: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(left, top) {
-            const host = getHost(this);
-            const doc = getOwnerDocument(host);
-            return fauxElementsFromPoint(this, doc, left, top);
-        },
-    },
-    getSelection: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            throw new Error('Disallowed method "getSelection" on ShadowRoot.');
-        },
-    },
-    host: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return getHost(this);
-        },
-    },
-    mode: {
-        configurable: true,
-        get() {
-            return getInternalSlot(this).mode;
-        },
-    },
-    styleSheets: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            throw new Error();
-        },
-    },
-};
-const eventToShadowRootMap = new WeakMap();
-const NodePatchDescriptors = {
-    insertBefore: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(newChild, refChild) {
-            insertBefore.call(getHost(this), newChild, refChild);
-            return newChild;
-        },
-    },
-    removeChild: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(oldChild) {
-            removeChild.call(getHost(this), oldChild);
-            return oldChild;
-        },
-    },
-    appendChild: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(newChild) {
-            appendChild.call(getHost(this), newChild);
-            return newChild;
-        },
-    },
-    replaceChild: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(newChild, oldChild) {
-            replaceChild.call(getHost(this), newChild, oldChild);
-            return oldChild;
-        },
-    },
-    addEventListener: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(type, listener, options) {
-            addShadowRootEventListener(this, type, listener);
-        },
-    },
-    dispatchEvent: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(evt) {
-            eventToShadowRootMap.set(evt, this);
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return dispatchEvent.apply(getHost(this), arguments);
-        },
-    },
-    removeEventListener: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(type, listener, options) {
-            removeShadowRootEventListener(this, type, listener);
-        },
-    },
-    baseURI: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return getHost(this).baseURI;
-        },
-    },
-    childNodes: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return createStaticNodeList(shadowRootChildNodes(this));
-        },
-    },
-    cloneNode: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            throw new Error('Disallowed method "cloneNode" on ShadowRoot.');
-        },
-    },
-    compareDocumentPosition: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(otherNode) {
-            const host = getHost(this);
-            if (this === otherNode) {
-                // "this" and "otherNode" are the same shadow root.
-                return 0;
-            }
-            else if (this.contains(otherNode)) {
-                // "otherNode" belongs to the shadow tree where "this" is the shadow root.
-                return 20; // Node.DOCUMENT_POSITION_CONTAINED_BY | Node.DOCUMENT_POSITION_FOLLOWING
-            }
-            else if (compareDocumentPosition.call(host, otherNode) & DOCUMENT_POSITION_CONTAINED_BY) {
-                // "otherNode" is in a different shadow tree contained by the shadow tree where "this" is the shadow root.
-                return 37; // Node.DOCUMENT_POSITION_DISCONNECTED | Node.DOCUMENT_POSITION_FOLLOWING | Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
-            }
-            else {
-                // "otherNode" is in a different shadow tree that is not contained by the shadow tree where "this" is the shadow root.
-                return 35; // Node.DOCUMENT_POSITION_DISCONNECTED | Node.DOCUMENT_POSITION_PRECEDING | Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
-            }
-        },
-    },
-    contains: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(otherNode) {
-            if (this === otherNode) {
-                return true;
-            }
-            const host = getHost(this);
-            // must be child of the host and owned by it.
-            return ((compareDocumentPosition.call(host, otherNode) & DOCUMENT_POSITION_CONTAINED_BY) !==
-                0 && isNodeOwnedBy(host, otherNode));
-        },
-    },
-    firstChild: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const childNodes = getInternalChildNodes(this);
-            return childNodes[0] || null;
-        },
-    },
-    lastChild: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const childNodes = getInternalChildNodes(this);
-            return childNodes[childNodes.length - 1] || null;
-        },
-    },
-    hasChildNodes: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            const childNodes = getInternalChildNodes(this);
-            return childNodes.length > 0;
-        },
-    },
-    isConnected: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return isConnected.call(getHost(this));
-        },
-    },
-    nextSibling: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return null;
-        },
-    },
-    previousSibling: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return null;
-        },
-    },
-    nodeName: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return '#document-fragment';
-        },
-    },
-    nodeType: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return 11; // Node.DOCUMENT_FRAGMENT_NODE
-        },
-    },
-    nodeValue: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return null;
-        },
-    },
-    ownerDocument: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return getHost(this).ownerDocument;
-        },
-    },
-    parentElement: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return null;
-        },
-    },
-    parentNode: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return null;
-        },
-    },
-    textContent: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const childNodes = getInternalChildNodes(this);
-            let textContent = '';
-            for (let i = 0, len = childNodes.length; i < len; i += 1) {
-                const currentNode = childNodes[i];
-                if (currentNode.nodeType !== COMMENT_NODE) {
-                    textContent += getTextContent(currentNode);
-                }
-            }
-            return textContent;
-        },
-        set(v) {
-            const host = getHost(this);
-            textContextSetter.call(host, v);
-        },
-    },
-    // Since the synthetic shadow root is a detached DocumentFragment, short-circuit the getRootNode behavior
-    getRootNode: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(options) {
-            return !isUndefined(options) && isTrue(options.composed)
-                ? getHost(this).getRootNode(options)
-                : this;
-        },
-    },
-};
-const ElementPatchDescriptors = {
-    innerHTML: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const childNodes = getInternalChildNodes(this);
-            let innerHTML = '';
-            for (let i = 0, len = childNodes.length; i < len; i += 1) {
-                innerHTML += getOuterHTML(childNodes[i]);
-            }
-            return innerHTML;
-        },
-        set(v) {
-            const host = getHost(this);
-            innerHTMLSetter.call(host, v);
-        },
-    },
-};
-const ParentNodePatchDescriptors = {
-    childElementCount: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return this.children.length;
-        },
-    },
-    children: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return createStaticHTMLCollection(ArrayFilter.call(shadowRootChildNodes(this), (elm) => elm instanceof Element));
-        },
-    },
-    firstElementChild: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            return this.children[0] || null;
-        },
-    },
-    lastElementChild: {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const { children } = this;
-            return children.item(children.length - 1) || null;
-        },
-    },
-    getElementById: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value() {
-            throw new Error('Disallowed method "getElementById" on ShadowRoot.');
-        },
-    },
-    querySelector: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(selectors) {
-            return shadowRootQuerySelector(this, selectors);
-        },
-    },
-    querySelectorAll: {
-        writable: true,
-        enumerable: true,
-        configurable: true,
-        value(selectors) {
-            return createStaticNodeList(shadowRootQuerySelectorAll(this, selectors));
-        },
-    },
-};
-assign(SyntheticShadowRootDescriptors, NodePatchDescriptors, ParentNodePatchDescriptors, ElementPatchDescriptors, ShadowRootDescriptors);
-function SyntheticShadowRoot() {
-    throw new TypeError('Illegal constructor');
-}
-SyntheticShadowRoot.prototype = create(DocumentFragment.prototype, SyntheticShadowRootDescriptors);
-// `this.shadowRoot instanceof ShadowRoot` should evaluate to true even for synthetic shadow
-defineProperty(SyntheticShadowRoot, Symbol.hasInstance, {
-    value: function (object) {
-        // Technically we should walk up the entire prototype chain, but with SyntheticShadowRoot
-        // it's reasonable to assume that no one is doing any deep subclasses here.
-        return (isObject(object) &&
-            !isNull(object) &&
-            (isInstanceOfNativeShadowRoot(object) ||
-                getPrototypeOf(object) === SyntheticShadowRoot.prototype));
-    },
-});
-/**
- * This method is only intended to be used in non-production mode in IE11
- * and its role is to produce a 1-1 mapping between a shadowRoot instance
- * and a comment node that is intended to use to trick the IE11 DevTools
- * to show the content of the shadowRoot in the DOM Explorer.
- */
-function getIE11FakeShadowRootPlaceholder(host) {
-    const shadowRoot = getShadowRoot(host);
-    // @ts-ignore this $$placeholder$$ is not a security issue because you must
-    // have access to the shadowRoot in order to extract the fake node, which give
-    // you access to the same childNodes of the shadowRoot, so, who cares.
-    let c = shadowRoot.$$placeholder$$;
-    if (!isUndefined(c)) {
-        return c;
-    }
-    const doc = getOwnerDocument(host);
-    // @ts-ignore $$placeholder$$ is fine, read the node above.
-    c = shadowRoot.$$placeholder$$ = createComment.call(doc, '');
-    defineProperties(c, {
-        childNodes: {
-            get() {
-                return shadowRoot.childNodes;
-            },
-            enumerable: true,
-            configurable: true,
-        },
-        tagName: {
-            get() {
-                return `#shadow-root (${shadowRoot.mode})`;
-            },
-            enumerable: true,
-            configurable: true,
-        },
-    });
-    return c;
-}
-
-/*
- * 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
- */
-/**
-@license
-Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-*/
-function pathComposer(startNode, composed) {
-    const composedPath = [];
-    let startRoot;
-    if (startNode instanceof Window) {
-        startRoot = startNode;
-    }
-    else if (startNode instanceof _Node) {
-        startRoot = startNode.getRootNode();
-    }
-    else {
-        return composedPath;
-    }
-    let current = startNode;
-    while (!isNull(current)) {
-        composedPath.push(current);
-        if (current instanceof Element || current instanceof Text) {
-            const assignedSlot = current.assignedSlot;
-            if (!isNull(assignedSlot)) {
-                current = assignedSlot;
-            }
-            else {
-                current = current.parentNode;
-            }
-        }
-        else if ((isSyntheticShadowRoot(current) || isInstanceOfNativeShadowRoot(current)) &&
-            (composed || current !== startRoot)) {
-            current = current.host;
-        }
-        else if (current instanceof _Node) {
-            current = current.parentNode;
-        }
-        else {
-            // could be Window
-            current = null;
-        }
-    }
-    let doc;
-    if (startNode instanceof Window) {
-        doc = startNode.document;
-    }
-    else {
-        doc = getOwnerDocument(startNode);
-    }
-    // event composedPath includes window when startNode's ownerRoot is document
-    if (composedPath[composedPath.length - 1] === doc) {
-        composedPath.push(window);
-    }
-    return composedPath;
-}
-
-/*
- * 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
- */
-/**
-@license
-Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-*/
-function retarget(refNode, path) {
-    if (isNull(refNode)) {
-        return null;
-    }
-    // If ANCESTOR's root is not a shadow root or ANCESTOR's root is BASE's
-    // shadow-including inclusive ancestor, return ANCESTOR.
-    const refNodePath = pathComposer(refNode, true);
-    const p$ = path;
-    for (let i = 0, ancestor, lastRoot, root, rootIdx; i < p$.length; i++) {
-        ancestor = p$[i];
-        root = ancestor instanceof Window ? ancestor : ancestor.getRootNode();
-        if (root !== lastRoot) {
-            rootIdx = refNodePath.indexOf(root);
-            lastRoot = root;
-        }
-        if (!isSyntheticShadowRoot(root) || (!isUndefined(rootIdx) && rootIdx > -1)) {
-            return ancestor;
-        }
-    }
-    return null;
-}
-
-/*
- * 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 fauxElementFromPoint(context, doc, left, top) {
-    const element = elementFromPoint.call(doc, left, top);
-    if (isNull(element)) {
-        return element;
-    }
-    return retarget(context, pathComposer(element, 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 elemFromPoint(left, top) {
-    return fauxElementFromPoint(this, this, left, top);
-}
-Document.prototype.elementFromPoint = elemFromPoint;
-function elemsFromPoint(left, top) {
-    return fauxElementsFromPoint(this, this, left, top);
-}
-Document.prototype.elementsFromPoint = elemsFromPoint;
-// Go until we reach to top of the LWC tree
-defineProperty(Document.prototype, 'activeElement', {
-    get() {
-        let node = DocumentPrototypeActiveElement.call(this);
-        if (isNull(node)) {
-            return node;
-        }
-        while (!isUndefined(getNodeOwnerKey(node))) {
-            node = parentElementGetter.call(node);
-            if (isNull(node)) {
-                return null;
-            }
-        }
-        if (node.tagName === 'HTML') {
-            // IE 11. Active element should never be html element
-            node = this.body;
-        }
-        return node;
-    },
-    enumerable: true,
-    configurable: true,
-});
-// The following patched methods hide shadowed elements from global
-// traversing mechanisms. They are simplified for performance reasons to
-// filter by ownership and do not account for slotted elements. This
-// compromise is fine for our synthetic shadow dom because root elements
-// cannot have slotted elements.
-// Another compromise here is that all these traversing methods will return
-// static HTMLCollection or static NodeList. We decided that this compromise
-// is not a big problem considering the amount of code that is relying on
-// the liveliness of these results are rare.
-defineProperty(Document.prototype, 'getElementById', {
-    value() {
-        const elm = getElementById.apply(this, ArraySlice.call(arguments));
-        if (isNull(elm)) {
-            return null;
-        }
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        return isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm) ? elm : null;
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true,
-});
-defineProperty(Document.prototype, 'querySelector', {
-    value() {
-        const elements = arrayFromCollection(querySelectorAll.apply(this, ArraySlice.call(arguments)));
-        const filtered = ArrayFind.call(elements, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm));
-        return !isUndefined(filtered) ? filtered : null;
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true,
-});
-defineProperty(Document.prototype, 'querySelectorAll', {
-    value() {
-        const elements = arrayFromCollection(querySelectorAll.apply(this, ArraySlice.call(arguments)));
-        const filtered = ArrayFilter.call(elements, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm));
-        return createStaticNodeList(filtered);
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true,
-});
-defineProperty(Document.prototype, 'getElementsByClassName', {
-    value() {
-        const elements = arrayFromCollection(getElementsByClassName.apply(this, ArraySlice.call(arguments)));
-        const filtered = ArrayFilter.call(elements, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm));
-        return createStaticHTMLCollection(filtered);
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true,
-});
-defineProperty(Document.prototype, 'getElementsByTagName', {
-    value() {
-        const elements = arrayFromCollection(getElementsByTagName.apply(this, ArraySlice.call(arguments)));
-        const filtered = ArrayFilter.call(elements, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm));
-        return createStaticHTMLCollection(filtered);
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true,
-});
-defineProperty(Document.prototype, 'getElementsByTagNameNS', {
-    value() {
-        const elements = arrayFromCollection(getElementsByTagNameNS.apply(this, ArraySlice.call(arguments)));
-        const filtered = ArrayFilter.call(elements, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm));
-        return createStaticHTMLCollection(filtered);
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true,
-});
-defineProperty(
-// In Firefox v57 and lower, getElementsByName is defined on HTMLDocument.prototype
-getOwnPropertyDescriptor(HTMLDocument.prototype, 'getElementsByName')
-    ? HTMLDocument.prototype
-    : Document.prototype, 'getElementsByName', {
-    value() {
-        const elements = arrayFromCollection(getElementsByName.apply(this, ArraySlice.call(arguments)));
-        const filtered = ArrayFilter.call(elements, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(elm));
-        return createStaticNodeList(filtered);
-    },
-    writable: true,
-    enumerable: true,
-    configurable: 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
- */
-Object.defineProperty(window, 'ShadowRoot', {
-    value: SyntheticShadowRoot,
-    configurable: true,
-    writable: 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
- */
-const composedDescriptor = Object.getOwnPropertyDescriptor(Event.prototype, 'composed');
-function detect$3() {
-    if (!composedDescriptor) {
-        // No need to apply this polyfill if this client completely lacks
-        // support for the composed property.
-        return false;
-    }
-    // Assigning a throwaway click event here to suppress a ts error when we
-    // pass clickEvent into the composed getter below. The error is:
-    // [ts] Variable 'clickEvent' is used before being assigned.
-    let clickEvent = new Event('click');
-    const button = document.createElement('button');
-    button.addEventListener('click', (event) => (clickEvent = event));
-    button.click();
-    return !composedDescriptor.get.call(clickEvent);
-}
-
-/*
- * 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 originalClickDescriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'click');
-function handleClick(event) {
-    Object.defineProperty(event, 'composed', {
-        configurable: true,
-        enumerable: true,
-        get() {
-            return true;
-        },
-    });
-}
-function apply$3() {
-    HTMLElement.prototype.click = function () {
-        addEventListener.call(this, 'click', handleClick);
-        try {
-            originalClickDescriptor.value.call(this);
-        }
-        finally {
-            removeEventListener.call(this, 'click', handleClick);
-        }
-    };
-}
-
-/*
- * 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
- */
-if (detect$3()) {
-    apply$3();
-}
-
-/*
- * 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 detect$2() {
-    return new Event('test', { composed: true }).composed !== 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 apply$2() {
-    // https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937
-    const composedEvents = assign(create(null), {
-        beforeinput: 1,
-        blur: 1,
-        click: 1,
-        compositionend: 1,
-        compositionstart: 1,
-        compositionupdate: 1,
-        copy: 1,
-        cut: 1,
-        dblclick: 1,
-        DOMActivate: 1,
-        DOMFocusIn: 1,
-        DOMFocusOut: 1,
-        drag: 1,
-        dragend: 1,
-        dragenter: 1,
-        dragleave: 1,
-        dragover: 1,
-        dragstart: 1,
-        drop: 1,
-        focus: 1,
-        focusin: 1,
-        focusout: 1,
-        gotpointercapture: 1,
-        input: 1,
-        keydown: 1,
-        keypress: 1,
-        keyup: 1,
-        lostpointercapture: 1,
-        mousedown: 1,
-        mouseenter: 1,
-        mouseleave: 1,
-        mousemove: 1,
-        mouseout: 1,
-        mouseover: 1,
-        mouseup: 1,
-        paste: 1,
-        pointercancel: 1,
-        pointerdown: 1,
-        pointerenter: 1,
-        pointerleave: 1,
-        pointermove: 1,
-        pointerout: 1,
-        pointerover: 1,
-        pointerup: 1,
-        touchcancel: 1,
-        touchend: 1,
-        touchmove: 1,
-        touchstart: 1,
-        wheel: 1,
-    });
-    const EventConstructor = Event;
-    // Patch Event constructor to add the composed property on events created via new Event.
-    function PatchedEvent(type, eventInitDict) {
-        const event = new EventConstructor(type, eventInitDict);
-        const isComposed = !!(eventInitDict && eventInitDict.composed);
-        Object.defineProperties(event, {
-            composed: {
-                get() {
-                    return isComposed;
-                },
-                configurable: true,
-                enumerable: true,
-            },
-        });
-        return event;
-    }
-    PatchedEvent.prototype = EventConstructor.prototype;
-    PatchedEvent.AT_TARGET = EventConstructor.AT_TARGET;
-    PatchedEvent.BUBBLING_PHASE = EventConstructor.BUBBLING_PHASE;
-    PatchedEvent.CAPTURING_PHASE = EventConstructor.CAPTURING_PHASE;
-    PatchedEvent.NONE = EventConstructor.NONE;
-    window.Event = PatchedEvent;
-    // Patch the Event prototype to add the composed property on user agent dispatched event.
-    Object.defineProperties(Event.prototype, {
-        composed: {
-            get() {
-                const { type } = this;
-                return composedEvents[type] === 1;
-            },
-            configurable: true,
-            enumerable: 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
- */
-if (detect$2()) {
-    apply$2();
-}
-
-/*
- * 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 CustomEventConstructor = CustomEvent;
-function PatchedCustomEvent(type, eventInitDict) {
-    const event = new CustomEventConstructor(type, eventInitDict);
-    const isComposed = !!(eventInitDict && eventInitDict.composed);
-    Object.defineProperties(event, {
-        composed: {
-            get() {
-                return isComposed;
-            },
-            configurable: true,
-            enumerable: true,
-        },
-    });
-    return event;
-}
-PatchedCustomEvent.prototype = CustomEventConstructor.prototype;
-window.CustomEvent = PatchedCustomEvent;
-
-/*
- * 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
- */
-if (typeof ClipboardEvent !== 'undefined') {
-    const isComposedType = assign(create(null), {
-        copy: 1,
-        cut: 1,
-        paste: 1,
-    });
-    // Patch the prototype to override the composed property on user-agent dispatched events
-    defineProperties(ClipboardEvent.prototype, {
-        composed: {
-            get() {
-                const { type } = this;
-                return isComposedType[type] === 1;
-            },
-            configurable: true,
-            enumerable: 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 detect$1() {
-    // Note: when using this in mobile apps, we might have a DOM that does not support iframes.
-    const hasIframe = typeof HTMLIFrameElement !== 'undefined';
-    // This polyfill should only apply in compat mode; see https://github.com/salesforce/lwc/issues/1513
-    const isCompat = typeof Proxy !== 'undefined' && isTrue(Proxy.isCompat);
-    return hasIframe && isCompat;
-}
-
-/*
- * 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 apply$1() {
-    // the iframe property descriptor for `contentWindow` should always be available, otherwise this method should never be called
-    const desc = getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'contentWindow');
-    const { get: originalGetter } = desc;
-    desc.get = function () {
-        const original = originalGetter.call(this);
-        // If the original iframe element is not a keyed node, then do not wrap it
-        if (isNull(original) || isUndefined(getNodeOwnerKey(this))) {
-            return original;
-        }
-        // only if the element is an iframe inside a shadowRoot, we care about this problem
-        // because in that case, the code that is accessing the iframe, is very likely code
-        // compiled with proxy-compat transformation. It is true that other code without those
-        // transformations might also access an iframe from within a shadowRoot, but in that,
-        // case, which is more rare, we still return the wrapper, and it should work the same,
-        // this part is just an optimization.
-        return wrapIframeWindow(original);
-    };
-    defineProperty(HTMLIFrameElement.prototype, 'contentWindow', desc);
-}
-function wrapIframeWindow(win) {
-    return {
-        addEventListener() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return win.addEventListener.apply(win, arguments);
-        },
-        blur() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return win.blur.apply(win, arguments);
-        },
-        close() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return win.close.apply(win, arguments);
-        },
-        focus() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return win.focus.apply(win, arguments);
-        },
-        postMessage() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return win.postMessage.apply(win, arguments);
-        },
-        removeEventListener() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            return win.removeEventListener.apply(win, arguments);
-        },
-        get closed() {
-            return win.closed;
-        },
-        get frames() {
-            return win.frames;
-        },
-        get length() {
-            return win.length;
-        },
-        get location() {
-            return win.location;
-        },
-        set location(value) {
-            win.location = value;
-        },
-        get opener() {
-            return win.opener;
-        },
-        get parent() {
-            return win.parent;
-        },
-        get self() {
-            return win.self;
-        },
-        get top() {
-            return win.top;
-        },
-        get window() {
-            return win.window;
-        },
-    }; // this is limited
-}
-
-/*
- * 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
- */
-if (detect$1()) {
-    apply$1();
-}
-
-/*
- * 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 OriginalMutationObserver = MutationObserver;
-const { disconnect: originalDisconnect, observe: originalObserve, takeRecords: originalTakeRecords, } = OriginalMutationObserver.prototype;
-// Internal fields to maintain relationships
-const wrapperLookupField = '$$lwcObserverCallbackWrapper$$';
-const observerLookupField = '$$lwcNodeObservers$$';
-const observerToNodesMap = new WeakMap();
-function getNodeObservers(node) {
-    return node[observerLookupField];
-}
-function setNodeObservers(node, observers) {
-    node[observerLookupField] = observers;
-}
-/**
- * Retarget the mutation record's target value to its shadowRoot
- * @param {MutationRecord} originalRecord
- */
-function retargetMutationRecord(originalRecord) {
-    const { addedNodes, removedNodes, target, type } = originalRecord;
-    const retargetedRecord = create(MutationRecord.prototype);
-    defineProperties(retargetedRecord, {
-        addedNodes: {
-            get() {
-                return addedNodes;
-            },
-            enumerable: true,
-            configurable: true,
-        },
-        removedNodes: {
-            get() {
-                return removedNodes;
-            },
-            enumerable: true,
-            configurable: true,
-        },
-        type: {
-            get() {
-                return type;
-            },
-            enumerable: true,
-            configurable: true,
-        },
-        target: {
-            get() {
-                return target.shadowRoot;
-            },
-            enumerable: true,
-            configurable: true,
-        },
-    });
-    return retargetedRecord;
-}
-/**
- * Utility to identify if a target node is being observed by the given observer
- * Start at the current node, if the observer is registered to observe the current node, the mutation qualifies
- * @param {MutationObserver} observer
- * @param {Node} target
- */
-function isQualifiedObserver(observer, target) {
-    let parentNode = target;
-    while (!isNull(parentNode)) {
-        const parentNodeObservers = getNodeObservers(parentNode);
-        if (!isUndefined(parentNodeObservers) &&
-            (parentNodeObservers[0] === observer || // perf optimization to check for the first item is a match
-                ArrayIndexOf.call(parentNodeObservers, observer) !== -1)) {
-            return true;
-        }
-        parentNode = parentNode.parentNode;
-    }
-    return false;
-}
-/**
- * This function provides a shadow dom compliant filtered view of mutation records for a given observer.
- *
- * The key logic here is to determine if a given observer has been registered to observe any nodes
- * between the target node of a mutation record to the target's root node.
- * This function also retargets records when mutations occur directly under the shadow root
- * @param {MutationRecords[]} mutations
- * @param {MutationObserver} observer
- */
-function filterMutationRecords(mutations, observer) {
-    return ArrayReduce.call(mutations, (filteredSet, record) => {
-        const { target, addedNodes, removedNodes, type } = record;
-        // If target is an lwc host,
-        // Determine if the mutations affected the host or the shadowRoot
-        // Mutations affecting host: changes to slot content
-        // Mutations affecting shadowRoot: changes to template content
-        if (type === 'childList' && !isUndefined(getNodeKey(target))) {
-            // In case of added nodes, we can climb up the tree and determine eligibility
-            if (addedNodes.length > 0) {
-                // Optimization: Peek in and test one node to decide if the MutationRecord qualifies
-                // The remaining nodes in this MutationRecord will have the same ownerKey
-                const sampleNode = addedNodes[0];
-                if (isQualifiedObserver(observer, sampleNode)) {
-                    // If the target was being observed, then return record as-is
-                    // this will be the case for slot content
-                    const nodeObservers = getNodeObservers(target);
-                    if (nodeObservers &&
-                        (nodeObservers[0] === observer ||
-                            ArrayIndexOf.call(nodeObservers, observer) !== -1)) {
-                        ArrayPush.call(filteredSet, record);
-                    }
-                    else {
-                        // else, must be observing the shadowRoot
-                        ArrayPush.call(filteredSet, retargetMutationRecord(record));
-                    }
-                }
-            }
-            else {
-                // In the case of removed nodes, climbing the tree is not an option as the nodes are disconnected
-                // We can only check if either the host or shadow root was observed and qualify the record
-                const shadowRoot = target.shadowRoot;
-                const sampleNode = removedNodes[0];
-                if (getNodeNearestOwnerKey(target) === getNodeNearestOwnerKey(sampleNode) && // trickery: sampleNode is slot content
-                    isQualifiedObserver(observer, target) // use target as a close enough reference to climb up
-                ) {
-                    ArrayPush.call(filteredSet, record);
-                }
-                else if (shadowRoot) {
-                    const shadowRootObservers = getNodeObservers(shadowRoot);
-                    if (shadowRootObservers &&
-                        (shadowRootObservers[0] === observer ||
-                            ArrayIndexOf.call(shadowRootObservers, observer) !== -1)) {
-                        ArrayPush.call(filteredSet, retargetMutationRecord(record));
-                    }
-                }
-            }
-        }
-        else {
-            // Mutation happened under a root node(shadow root or document) and the decision is straighforward
-            // Ascend the tree starting from target and check if observer is qualified
-            if (isQualifiedObserver(observer, target)) {
-                ArrayPush.call(filteredSet, record);
-            }
-        }
-        return filteredSet;
-    }, []);
-}
-function getWrappedCallback(callback) {
-    let wrappedCallback = callback[wrapperLookupField];
-    if (isUndefined(wrappedCallback)) {
-        wrappedCallback = callback[wrapperLookupField] = (mutations, observer) => {
-            // Filter mutation records
-            const filteredRecords = filterMutationRecords(mutations, observer);
-            // If not records are eligible for the observer, do not invoke callback
-            if (filteredRecords.length === 0) {
-                return;
-            }
-            callback.call(observer, filteredRecords, observer);
-        };
-    }
-    return wrappedCallback;
-}
-/**
- * Patched MutationObserver constructor.
- * 1. Wrap the callback to filter out MutationRecords based on dom ownership
- * 2. Add a property field to track all observed targets of the observer instance
- * @param {MutationCallback} callback
- */
-function PatchedMutationObserver(callback) {
-    const wrappedCallback = getWrappedCallback(callback);
-    const observer = new OriginalMutationObserver(wrappedCallback);
-    return observer;
-}
-function patchedDisconnect() {
-    originalDisconnect.call(this);
-    // Clear the node to observer reference which is a strong references
-    const observedNodes = observerToNodesMap.get(this);
-    if (!isUndefined(observedNodes)) {
-        forEach.call(observedNodes, (observedNode) => {
-            const observers = observedNode[observerLookupField];
-            if (!isUndefined(observers)) {
-                const index = ArrayIndexOf.call(observers, this);
-                if (index !== -1) {
-                    ArraySplice.call(observers, index, 1);
-                }
-            }
-        });
-        observedNodes.length = 0;
-    }
-}
-/**
- * A single mutation observer can observe multiple nodes(target).
- * Maintain a list of all targets that the observer chooses to observe
- * @param {Node} target
- * @param {Object} options
- */
-function patchedObserve(target, options) {
-    let targetObservers = getNodeObservers(target);
-    // Maintain a list of all observers that want to observe a node
-    if (isUndefined(targetObservers)) {
-        targetObservers = [];
-        setNodeObservers(target, targetObservers);
-    }
-    // Same observer trying to observe the same node
-    if (ArrayIndexOf.call(targetObservers, this) === -1) {
-        ArrayPush.call(targetObservers, this);
-    } // else There is more bookkeeping to do here https://dom.spec.whatwg.org/#dom-mutationobserver-observe Step #7
-    // SyntheticShadowRoot instances are not actually a part of the DOM so observe the host instead.
-    if (isSyntheticShadowRoot(target)) {
-        target = target.host;
-    }
-    // maintain a list of all nodes observed by this observer
-    if (observerToNodesMap.has(this)) {
-        const observedNodes = observerToNodesMap.get(this);
-        if (ArrayIndexOf.call(observedNodes, target) === -1) {
-            ArrayPush.call(observedNodes, target);
-        }
-    }
-    else {
-        observerToNodesMap.set(this, [target]);
-    }
-    return originalObserve.call(this, target, options);
-}
-/**
- * Patch the takeRecords() api to filter MutationRecords based on the observed targets
- */
-function patchedTakeRecords() {
-    return filterMutationRecords(originalTakeRecords.call(this), this);
-}
-PatchedMutationObserver.prototype = OriginalMutationObserver.prototype;
-PatchedMutationObserver.prototype.disconnect = patchedDisconnect;
-PatchedMutationObserver.prototype.observe = patchedObserve;
-PatchedMutationObserver.prototype.takeRecords = patchedTakeRecords;
-defineProperty(window, 'MutationObserver', {
-    value: PatchedMutationObserver,
-    configurable: true,
-    writable: 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 patchedAddEventListener$1(type, listener, optionsOrCapture) {
-    if (isSyntheticShadowHost(this)) {
-        // Typescript does not like it when you treat the `arguments` object as an array
-        // @ts-ignore type-mismatch
-        return addCustomElementEventListener.apply(this, arguments);
-    }
-    if (arguments.length < 2) {
-        // Slow path, unlikely to be called frequently. We expect modern browsers to throw:
-        // https://googlechrome.github.io/samples/event-listeners-mandatory-arguments/
-        const args = ArraySlice.call(arguments);
-        if (args.length > 1) {
-            args[1] = getEventListenerWrapper(args[1]);
-        }
-        // Ignore types because we're passing through to native method
-        // @ts-ignore type-mismatch
-        return addEventListener.apply(this, args);
-    }
-    // Fast path. This function is optimized to avoid ArraySlice because addEventListener is called
-    // very frequently, and it provides a measurable perf boost to avoid so much array cloning.
-    const wrappedListener = getEventListenerWrapper(listener);
-    // The third argument is optional, so passing in `undefined` for `optionsOrCapture` gives capture=false
-    return addEventListener.call(this, type, wrappedListener, optionsOrCapture);
-}
-function patchedRemoveEventListener$1(_type, _listener, _optionsOrCapture) {
-    if (isSyntheticShadowHost(this)) {
-        // Typescript does not like it when you treat the `arguments` object as an array
-        // @ts-ignore type-mismatch
-        return removeCustomElementEventListener.apply(this, arguments);
-    }
-    const args = ArraySlice.call(arguments);
-    if (arguments.length > 1) {
-        args[1] = getEventListenerWrapper(args[1]);
-    }
-    // Ignore types because we're passing through to native method
-    // @ts-ignore type-mismatch
-    removeEventListener.apply(this, args);
-    // Account for listeners that were added before this polyfill was applied
-    // Typescript does not like it when you treat the `arguments` object as an array
-    // @ts-ignore type-mismatch
-    removeEventListener.apply(this, arguments);
-}
-defineProperties(eventTargetPrototype, {
-    addEventListener: {
-        value: patchedAddEventListener$1,
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    removeEventListener: {
-        value: patchedRemoveEventListener$1,
-        enumerable: true,
-        writable: true,
-        configurable: 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 detect() {
-    return typeof EventTarget === 'undefined';
-}
-
-/*
- * 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 patchedAddEventListener(_type, _listener, _options) {
-    if (arguments.length > 1) {
-        const args = ArraySlice.call(arguments);
-        args[1] = getEventListenerWrapper(args[1]);
-        // Ignore types because we're passing through to native method
-        // @ts-ignore type-mismatch
-        return windowAddEventListener.apply(this, args);
-    }
-    // Typescript does not like it when you treat the `arguments` object as an array
-    // @ts-ignore type-mismatch
-    return windowAddEventListener.apply(this, arguments);
-}
-function patchedRemoveEventListener(_type, _listener, _options) {
-    if (arguments.length > 1) {
-        const args = ArraySlice.call(arguments);
-        args[1] = getEventListenerWrapper(args[1]);
-        // Ignore types because we're passing through to native method
-        // @ts-ignore type-mismatch
-        windowRemoveEventListener.apply(this, args);
-    }
-    // Account for listeners that were added before this polyfill was applied
-    // Typescript does not like it when you treat the `arguments` object as an array
-    // @ts-ignore type-mismatch
-    windowRemoveEventListener.apply(this, arguments);
-}
-function apply() {
-    defineProperties(Window.prototype, {
-        addEventListener: {
-            value: patchedAddEventListener,
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        removeEventListener: {
-            value: patchedRemoveEventListener,
-            enumerable: true,
-            writable: true,
-            configurable: 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
- */
-if (detect()) {
-    apply();
-}
-
-/*
- * 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 patchedCurrentTargetGetter() {
-    const currentTarget = eventCurrentTargetGetter.call(this);
-    if (isNull(currentTarget)) {
-        return null;
-    }
-    if (eventToContextMap.get(this) === 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */) {
-        return getShadowRoot(currentTarget);
-    }
-    return currentTarget;
-}
-function patchedTargetGetter() {
-    const originalTarget = eventTargetGetter.call(this);
-    if (!(originalTarget instanceof _Node)) {
-        return originalTarget;
-    }
-    const doc = getOwnerDocument(originalTarget);
-    const composedPath = pathComposer(originalTarget, this.composed);
-    const originalCurrentTarget = eventCurrentTargetGetter.call(this);
-    // Handle cases where the currentTarget is null (for async events), and when an event has been
-    // added to Window
-    if (!(originalCurrentTarget instanceof _Node)) {
-        // TODO [#1511]: Special escape hatch to support legacy behavior. Should be fixed.
-        // If the event's target is being accessed async and originalTarget is not a keyed element, do not retarget
-        if (isNull(originalCurrentTarget) && isUndefined(getNodeOwnerKey(originalTarget))) {
-            return originalTarget;
-        }
-        return retarget(doc, composedPath);
-    }
-    else if (originalCurrentTarget === doc || originalCurrentTarget === doc.body) {
-        // TODO [#1530]: If currentTarget is document or document.body (Third party libraries that have global event listeners)
-        // and the originalTarget is not a keyed element, do not retarget
-        if (isUndefined(getNodeOwnerKey(originalTarget))) {
-            return originalTarget;
-        }
-        return retarget(doc, composedPath);
-    }
-    let actualCurrentTarget = originalCurrentTarget;
-    let actualPath = composedPath;
-    // Address the possibility that `currentTarget` is a shadow root
-    if (isSyntheticShadowHost(originalCurrentTarget)) {
-        const context = eventToContextMap.get(this);
-        if (context === 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */) {
-            actualCurrentTarget = getShadowRoot(originalCurrentTarget);
-        }
-    }
-    // Address the possibility that `target` is a shadow root
-    if (isSyntheticShadowHost(originalTarget) && eventToShadowRootMap.has(this)) {
-        actualPath = pathComposer(getShadowRoot(originalTarget), this.composed);
-    }
-    return retarget(actualCurrentTarget, actualPath);
-}
-function patchedComposedPathValue() {
-    const originalTarget = eventTargetGetter.call(this);
-    // Account for events with targets that are not instances of Node (e.g., when a readystatechange
-    // handler is listening on an instance of XMLHttpRequest).
-    if (!(originalTarget instanceof _Node)) {
-        return [];
-    }
-    // If the original target is inside a native shadow root, then just call the native
-    // composePath() method. The event is already retargeted and this causes our composedPath()
-    // polyfill to compute the wrong value. This is only an issue when you have a native web
-    // component inside an LWC component (see test in same commit) but this scenario is unlikely
-    // because we don't yet support that. Workaround specifically for W-9846457. Mixed mode solution
-    // will likely be more involved.
-    const hasShadowRoot = Boolean(originalTarget.shadowRoot);
-    const hasSyntheticShadowRootAttached = hasInternalSlot(originalTarget);
-    if (hasShadowRoot && !hasSyntheticShadowRootAttached) {
-        return composedPath.call(this);
-    }
-    const originalCurrentTarget = eventCurrentTargetGetter.call(this);
-    // If the event has completed propagation, the composedPath should be an empty array.
-    if (isNull(originalCurrentTarget)) {
-        return [];
-    }
-    // Address the possibility that `target` is a shadow root
-    let actualTarget = originalTarget;
-    if (isSyntheticShadowHost(originalTarget) && eventToShadowRootMap.has(this)) {
-        actualTarget = getShadowRoot(originalTarget);
-    }
-    return pathComposer(actualTarget, this.composed);
-}
-defineProperties(Event.prototype, {
-    target: {
-        get: patchedTargetGetter,
-        enumerable: true,
-        configurable: true,
-    },
-    currentTarget: {
-        get: patchedCurrentTargetGetter,
-        enumerable: true,
-        configurable: true,
-    },
-    composedPath: {
-        value: patchedComposedPathValue,
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    },
-    // Non-standard but widely supported for backwards-compatibility
-    srcElement: {
-        get: patchedTargetGetter,
-        enumerable: true,
-        configurable: true,
-    },
-    // Non-standard but implemented in Chrome and continues to exist for backwards-compatibility
-    // https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/dom/events/event.idl;l=58?q=event.idl&ss=chromium
-    path: {
-        get: patchedComposedPathValue,
-        enumerable: true,
-        configurable: 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 retargetRelatedTarget(Ctor) {
-    const relatedTargetGetter = getOwnPropertyDescriptor(Ctor.prototype, 'relatedTarget')
-        .get;
-    defineProperty(Ctor.prototype, 'relatedTarget', {
-        get() {
-            const relatedTarget = relatedTargetGetter.call(this);
-            if (isNull(relatedTarget)) {
-                return null;
-            }
-            if (!(relatedTarget instanceof _Node) || !isNodeShadowed(relatedTarget)) {
-                return relatedTarget;
-            }
-            let pointOfReference = eventCurrentTargetGetter.call(this);
-            if (isNull(pointOfReference)) {
-                pointOfReference = getOwnerDocument(relatedTarget);
-            }
-            return retarget(pointOfReference, pathComposer(relatedTarget, true));
-        },
-        enumerable: true,
-        configurable: 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
- */
-retargetRelatedTarget(FocusEvent);
-
-/*
- * 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
- */
-retargetRelatedTarget(MouseEvent);
-
-/*
- * Copyright (c) 2021, 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 assignedSlotGetter = hasOwnProperty.call(Text.prototype, 'assignedSlot')
-    ? getOwnPropertyDescriptor(Text.prototype, 'assignedSlot').get
-    : () => null;
-
-/*
- * 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
- */
-// We can use a single observer without having to worry about leaking because
-// "Registered observers in a node’s registered observer list have a weak
-// reference to the node."
-// https://dom.spec.whatwg.org/#garbage-collection
-let observer;
-const observerConfig = { childList: true };
-const SlotChangeKey = new WeakMap();
-function initSlotObserver() {
-    return new MO((mutations) => {
-        const slots = [];
-        forEach.call(mutations, (mutation) => {
-            if (process.env.NODE_ENV !== 'production') {
-                assert.invariant(mutation.type === 'childList', `Invalid mutation type: ${mutation.type}. This mutation handler for slots should only handle "childList" mutations.`);
-            }
-            const { target: slot } = mutation;
-            if (ArrayIndexOf.call(slots, slot) === -1) {
-                ArrayPush.call(slots, slot);
-                dispatchEvent.call(slot, new CustomEvent('slotchange'));
-            }
-        });
-    });
-}
-function getFilteredSlotFlattenNodes(slot) {
-    const childNodes = arrayFromCollection(childNodesGetter.call(slot));
-    // Typescript is inferring the wrong function type for this particular
-    // overloaded method: https://github.com/Microsoft/TypeScript/issues/27972
-    // @ts-ignore type-mismatch
-    return ArrayReduce.call(childNodes, (seed, child) => {
-        if (child instanceof Element && isSlotElement(child)) {
-            ArrayPush.apply(seed, getFilteredSlotFlattenNodes(child));
-        }
-        else {
-            ArrayPush.call(seed, child);
-        }
-        return seed;
-    }, []);
-}
-function assignedSlotGetterPatched() {
-    const parentNode = parentNodeGetter.call(this);
-    // use original assignedSlot if parent has a native shdow root
-    if (parentNode instanceof Element) {
-        const sr = shadowRootGetter.call(parentNode);
-        if (isInstanceOfNativeShadowRoot(sr)) {
-            if (this instanceof Text) {
-                return assignedSlotGetter.call(this);
-            }
-            return assignedSlotGetter$1.call(this);
-        }
-    }
-    /**
-     * The node is assigned to a slot if:
-     *  - it has a parent and its parent is a slot element
-     *  - and if the slot owner key is different than the node owner key.
-     *
-     * When the slot and the slotted node are 2 different shadow trees, the owner keys will be
-     * different. When the slot is in a shadow tree and the slotted content is a light DOM node,
-     * the light DOM node doesn't have an owner key and therefor the slot owner key will be
-     * different than the node owner key (always `undefined`).
-     */
-    if (!isNull(parentNode) &&
-        isSlotElement(parentNode) &&
-        getNodeOwnerKey(parentNode) !== getNodeOwnerKey(this)) {
-        return parentNode;
-    }
-    return null;
-}
-defineProperties(HTMLSlotElement.prototype, {
-    addEventListener: {
-        value(type, listener, options) {
-            // super.addEventListener - but that doesn't work with typescript
-            HTMLElement.prototype.addEventListener.call(this, type, listener, options);
-            if (type === 'slotchange' && !SlotChangeKey.get(this)) {
-                SlotChangeKey.set(this, true);
-                if (!observer) {
-                    observer = initSlotObserver();
-                }
-                MutationObserverObserve.call(observer, this, observerConfig);
-            }
-        },
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    },
-    assignedElements: {
-        value(options) {
-            if (isNodeShadowed(this)) {
-                const flatten = !isUndefined(options) && isTrue(options.flatten);
-                const nodes = flatten
-                    ? getFilteredSlotFlattenNodes(this)
-                    : getFilteredSlotAssignedNodes(this);
-                return ArrayFilter.call(nodes, (node) => node instanceof Element);
-            }
-            else {
-                return assignedElements.apply(this, ArraySlice.call(arguments));
-            }
-        },
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    },
-    assignedNodes: {
-        value(options) {
-            if (isNodeShadowed(this)) {
-                const flatten = !isUndefined(options) && isTrue(options.flatten);
-                return flatten
-                    ? getFilteredSlotFlattenNodes(this)
-                    : getFilteredSlotAssignedNodes(this);
-            }
-            else {
-                return assignedNodes.apply(this, ArraySlice.call(arguments));
-            }
-        },
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    },
-    name: {
-        get() {
-            const name = getAttribute.call(this, 'name');
-            return isNull(name) ? '' : name;
-        },
-        set(value) {
-            setAttribute.call(this, 'name', value);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    childNodes: {
-        get() {
-            if (isNodeShadowed(this)) {
-                const owner = getNodeOwner(this);
-                const childNodes = isNull(owner)
-                    ? []
-                    : getAllMatches(owner, getFilteredChildNodes(this));
-                return createStaticNodeList(childNodes);
-            }
-            return childNodesGetter.call(this);
-        },
-        enumerable: true,
-        configurable: 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
- */
-// Non-deep-traversing patches: this descriptor map includes all descriptors that
-// do not five access to nodes beyond the immediate children.
-defineProperties(Text.prototype, {
-    assignedSlot: {
-        get: assignedSlotGetterPatched,
-        enumerable: true,
-        configurable: 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
- */
-/**
- * This methods filters out elements that are not in the same shadow root of context.
- * It does not enforce shadow dom semantics if $context is not managed by LWC
- */
-function getNonPatchedFilteredArrayOfNodes(context, unfilteredNodes) {
-    let filtered;
-    const ownerKey = getNodeOwnerKey(context);
-    // a node inside a shadow.
-    if (!isUndefined(ownerKey)) {
-        if (isSyntheticShadowHost(context)) {
-            // element with shadowRoot attached
-            const owner = getNodeOwner(context);
-            if (isNull(owner)) {
-                filtered = [];
-            }
-            else if (getNodeKey(context)) {
-                // it is a custom element, and we should then filter by slotted elements
-                filtered = getAllSlottedMatches(context, unfilteredNodes);
-            }
-            else {
-                // regular element, we should then filter by ownership
-                filtered = getAllMatches(owner, unfilteredNodes);
-            }
-        }
-        else {
-            // context is handled by lwc, using getNodeNearestOwnerKey to include manually inserted elements in the same shadow.
-            filtered = ArrayFilter.call(unfilteredNodes, (elm) => getNodeNearestOwnerKey(elm) === ownerKey);
-        }
-    }
-    else if (context instanceof HTMLBodyElement) {
-        // `context` is document.body which is already patched.
-        filtered = ArrayFilter.call(unfilteredNodes, 
-        // Note: we deviate from native shadow here, but are not fixing
-        // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-        (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(context));
-    }
-    else {
-        // `context` is outside the lwc boundary, return unfiltered list.
-        filtered = ArraySlice.call(unfilteredNodes);
-    }
-    return filtered;
-}
-
-/*
- * 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 innerHTMLGetterPatched() {
-    const childNodes = getInternalChildNodes(this);
-    let innerHTML = '';
-    for (let i = 0, len = childNodes.length; i < len; i += 1) {
-        innerHTML += getOuterHTML(childNodes[i]);
-    }
-    return innerHTML;
-}
-function outerHTMLGetterPatched() {
-    return getOuterHTML(this);
-}
-function attachShadowPatched(options) {
-    // To retain native behavior of the API, provide synthetic shadowRoot only when specified
-    if (options[KEY__SYNTHETIC_MODE]) {
-        return attachShadow(this, options);
-    }
-    return attachShadow$1.call(this, options);
-}
-function shadowRootGetterPatched() {
-    if (isSyntheticShadowHost(this)) {
-        const shadow = getShadowRoot(this);
-        if (shadow.mode === 'open') {
-            return shadow;
-        }
-    }
-    return shadowRootGetter.call(this);
-}
-function childrenGetterPatched() {
-    const owner = getNodeOwner(this);
-    const childNodes = isNull(owner) ? [] : getAllMatches(owner, getFilteredChildNodes(this));
-    return createStaticHTMLCollection(ArrayFilter.call(childNodes, (node) => node instanceof Element));
-}
-function childElementCountGetterPatched() {
-    return this.children.length;
-}
-function firstElementChildGetterPatched() {
-    return this.children[0] || null;
-}
-function lastElementChildGetterPatched() {
-    const { children } = this;
-    return children.item(children.length - 1) || null;
-}
-// Non-deep-traversing patches: this descriptor map includes all descriptors that
-// do not five access to nodes beyond the immediate children.
-defineProperties(Element.prototype, {
-    innerHTML: {
-        get() {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
-                return innerHTMLGetterPatched.call(this);
-            }
-            return innerHTMLGetter.call(this);
-        },
-        set(v) {
-            innerHTMLSetter.call(this, v);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    outerHTML: {
-        get() {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
-                return outerHTMLGetterPatched.call(this);
-            }
-            return outerHTMLGetter.call(this);
-        },
-        set(v) {
-            outerHTMLSetter.call(this, v);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    attachShadow: {
-        value: attachShadowPatched,
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    shadowRoot: {
-        get: shadowRootGetterPatched,
-        enumerable: true,
-        configurable: true,
-    },
-    // patched in HTMLElement if exists (IE11 is the one off here)
-    children: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return childrenGetterPatched.call(this);
-            }
-            return childrenGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    childElementCount: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return childElementCountGetterPatched.call(this);
-            }
-            return childElementCountGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    firstElementChild: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return firstElementChildGetterPatched.call(this);
-            }
-            return firstElementChildGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    lastElementChild: {
-        get() {
-            if (hasMountedChildren(this)) {
-                return lastElementChildGetterPatched.call(this);
-            }
-            return lastElementChildGetter.call(this);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    assignedSlot: {
-        get: assignedSlotGetterPatched,
-        enumerable: true,
-        configurable: true,
-    },
-});
-// IE11 extra patches for wrong prototypes
-if (hasOwnProperty.call(HTMLElement.prototype, 'innerHTML')) {
-    defineProperty(HTMLElement.prototype, 'innerHTML', getOwnPropertyDescriptor(Element.prototype, 'innerHTML'));
-}
-if (hasOwnProperty.call(HTMLElement.prototype, 'outerHTML')) {
-    defineProperty(HTMLElement.prototype, 'outerHTML', getOwnPropertyDescriptor(Element.prototype, 'outerHTML'));
-}
-if (hasOwnProperty.call(HTMLElement.prototype, 'children')) {
-    defineProperty(HTMLElement.prototype, 'children', getOwnPropertyDescriptor(Element.prototype, 'children'));
-}
-// Deep-traversing patches from this point on:
-function querySelectorPatched() {
-    const nodeList = arrayFromCollection(querySelectorAll$1.apply(this, ArraySlice.call(arguments)));
-    if (isSyntheticShadowHost(this)) {
-        // element with shadowRoot attached
-        const owner = getNodeOwner(this);
-        if (!isUndefined(getNodeKey(this))) {
-            // it is a custom element, and we should then filter by slotted elements
-            return getFirstSlottedMatch(this, nodeList);
-        }
-        else if (isNull(owner)) {
-            return null;
-        }
-        else {
-            // regular element, we should then filter by ownership
-            return getFirstMatch(owner, nodeList);
-        }
-    }
-    else if (isNodeShadowed(this)) {
-        // element inside a shadowRoot
-        const ownerKey = getNodeOwnerKey(this);
-        if (!isUndefined(ownerKey)) {
-            // `this` is handled by lwc, using getNodeNearestOwnerKey to include manually inserted elements in the same shadow.
-            const elm = ArrayFind.call(nodeList, (elm) => getNodeNearestOwnerKey(elm) === ownerKey);
-            return isUndefined(elm) ? null : elm;
-        }
-        else {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            // `this` is a manually inserted element inside a shadowRoot, return the first element.
-            return nodeList.length === 0 ? null : nodeList[0];
-        }
-    }
-    else {
-        if (!(this instanceof HTMLBodyElement)) {
-            const elm = nodeList[0];
-            return isUndefined(elm) ? null : elm;
-        }
-        // element belonging to the document
-        const elm = ArrayFind.call(nodeList, (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(this));
-        return isUndefined(elm) ? null : elm;
-    }
-}
-function getFilteredArrayOfNodes(context, unfilteredNodes) {
-    let filtered;
-    if (isSyntheticShadowHost(context)) {
-        // element with shadowRoot attached
-        const owner = getNodeOwner(context);
-        if (!isUndefined(getNodeKey(context))) {
-            // it is a custom element, and we should then filter by slotted elements
-            filtered = getAllSlottedMatches(context, unfilteredNodes);
-        }
-        else if (isNull(owner)) {
-            filtered = [];
-        }
-        else {
-            // regular element, we should then filter by ownership
-            filtered = getAllMatches(owner, unfilteredNodes);
-        }
-    }
-    else if (isNodeShadowed(context)) {
-        // element inside a shadowRoot
-        const ownerKey = getNodeOwnerKey(context);
-        if (!isUndefined(ownerKey)) {
-            // context is handled by lwc, using getNodeNearestOwnerKey to include manually inserted elements in the same shadow.
-            filtered = ArrayFilter.call(unfilteredNodes, (elm) => getNodeNearestOwnerKey(elm) === ownerKey);
-        }
-        else {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            // context is manually inserted without lwc:dom-manual, return everything
-            filtered = ArraySlice.call(unfilteredNodes);
-        }
-    }
-    else {
-        if (context instanceof HTMLBodyElement) {
-            // `context` is document.body or element belonging to the document with the patch enabled
-            filtered = ArrayFilter.call(unfilteredNodes, (elm) => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(context));
-        }
-        else {
-            // `context` is outside the lwc boundary and patch is not enabled.
-            filtered = ArraySlice.call(unfilteredNodes);
-        }
-    }
-    return filtered;
-}
-// The following patched methods hide shadowed elements from global
-// traversing mechanisms. They are simplified for performance reasons to
-// filter by ownership and do not account for slotted elements. This
-// compromise is fine for our synthetic shadow dom because root elements
-// cannot have slotted elements.
-// Another compromise here is that all these traversing methods will return
-// static HTMLCollection or static NodeList. We decided that this compromise
-// is not a big problem considering the amount of code that is relying on
-// the liveliness of these results are rare.
-defineProperties(Element.prototype, {
-    querySelector: {
-        value: querySelectorPatched,
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    },
-    querySelectorAll: {
-        value() {
-            const nodeList = arrayFromCollection(querySelectorAll$1.apply(this, ArraySlice.call(arguments)));
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            const filteredResults = getFilteredArrayOfNodes(this, nodeList);
-            return createStaticNodeList(filteredResults);
-        },
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    },
-});
-// The following APIs are used directly by Jest internally so we avoid patching them during testing.
-if (process.env.NODE_ENV !== 'test') {
-    defineProperties(Element.prototype, {
-        getElementsByClassName: {
-            value() {
-                const elements = arrayFromCollection(getElementsByClassName$1.apply(this, ArraySlice.call(arguments)));
-                // Note: we deviate from native shadow here, but are not fixing
-                // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-                return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
-            },
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        },
-        getElementsByTagName: {
-            value() {
-                const elements = arrayFromCollection(getElementsByTagName$1.apply(this, ArraySlice.call(arguments)));
-                // Note: we deviate from native shadow here, but are not fixing
-                // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-                return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
-            },
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        },
-        getElementsByTagNameNS: {
-            value() {
-                const elements = arrayFromCollection(getElementsByTagNameNS$1.apply(this, ArraySlice.call(arguments)));
-                // Note: we deviate from native shadow here, but are not fixing
-                // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-                return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
-            },
-            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
- */
-const FocusableSelector = `
-    [contenteditable],
-    [tabindex],
-    a[href],
-    area[href],
-    audio[controls],
-    button,
-    iframe,
-    input,
-    select,
-    textarea,
-    video[controls]
-`;
-const formElementTagNames = new Set(['BUTTON', 'INPUT', 'SELECT', 'TEXTAREA']);
-function filterSequentiallyFocusableElements(elements) {
-    return elements.filter((element) => {
-        if (hasAttribute.call(element, 'tabindex')) {
-            // Even though LWC only supports tabindex values of 0 or -1,
-            // passing through elements with tabindex="0" is a tighter criteria
-            // than filtering out elements based on tabindex="-1".
-            return getAttribute.call(element, 'tabindex') === '0';
-        }
-        if (formElementTagNames.has(tagNameGetter.call(element))) {
-            return !hasAttribute.call(element, 'disabled');
-        }
-        return true;
-    });
-}
-const DidAddMouseEventListeners = new WeakMap();
-// Due to browser differences, it is impossible to know what is focusable until
-// we actually try to focus it. We need to refactor our focus delegation logic
-// to verify whether or not the target was actually focused instead of trying
-// to predict focusability like we do here.
-function isVisible(element) {
-    const { width, height } = getBoundingClientRect.call(element);
-    const noZeroSize = width > 0 || height > 0;
-    // The area element can be 0x0 and focusable. Hardcoding this is not ideal
-    // but it will minimize changes in the current behavior.
-    const isAreaElement = element.tagName === 'AREA';
-    return (noZeroSize || isAreaElement) && getComputedStyle(element).visibility !== 'hidden';
-}
-// This function based on https://allyjs.io/data-tables/focusable.html
-// It won't catch everything, but should be good enough
-// There are a lot of edge cases here that we can't realistically handle
-// Determines if a particular element is tabbable, as opposed to simply focusable
-function isTabbable(element) {
-    if (isSyntheticShadowHost(element) && isDelegatingFocus(element)) {
-        return false;
-    }
-    return matches.call(element, FocusableSelector) && isVisible(element);
-}
-function hostElementFocus() {
-    const _rootNode = this.getRootNode();
-    if (_rootNode === this) {
-        // We invoke the focus() method even if the host is disconnected in order to eliminate
-        // observable differences for component authors between synthetic and native.
-        const focusable = querySelector.call(this, FocusableSelector);
-        if (!isNull(focusable)) {
-            // @ts-ignore type-mismatch
-            focusable.focus.apply(focusable, arguments);
-        }
-        return;
-    }
-    // If the root node is not the host element then it's either the document or a shadow root.
-    const rootNode = _rootNode;
-    if (rootNode.activeElement === this) {
-        // The focused element should not change if the focus method is invoked
-        // on the shadow-including ancestor of the currently focused element.
-        return;
-    }
-    const focusables = arrayFromCollection(querySelectorAll$1.call(this, FocusableSelector));
-    let didFocus = false;
-    while (!didFocus && focusables.length !== 0) {
-        const focusable = focusables.shift();
-        // @ts-ignore type-mismatch
-        focusable.focus.apply(focusable, arguments);
-        // Get the root node of the current focusable in case it was slotted.
-        const currentRootNode = focusable.getRootNode();
-        didFocus = currentRootNode.activeElement === focusable;
-    }
-}
-function getTabbableSegments(host) {
-    const doc = getOwnerDocument(host);
-    const all = filterSequentiallyFocusableElements(arrayFromCollection(querySelectorAll.call(doc, FocusableSelector)));
-    const inner = filterSequentiallyFocusableElements(arrayFromCollection(querySelectorAll$1.call(host, FocusableSelector)));
-    if (process.env.NODE_ENV !== 'production') {
-        assert.invariant(getAttribute.call(host, 'tabindex') === '-1' || isDelegatingFocus(host), `The focusin event is only relevant when the tabIndex property is -1 on the host.`);
-    }
-    const firstChild = inner[0];
-    const lastChild = inner[inner.length - 1];
-    const hostIndex = ArrayIndexOf.call(all, host);
-    // Host element can show up in our "previous" section if its tabindex is 0
-    // We want to filter that out here
-    const firstChildIndex = hostIndex > -1 ? hostIndex : ArrayIndexOf.call(all, firstChild);
-    // Account for an empty inner list
-    const lastChildIndex = inner.length === 0 ? firstChildIndex + 1 : ArrayIndexOf.call(all, lastChild) + 1;
-    const prev = ArraySlice.call(all, 0, firstChildIndex);
-    const next = ArraySlice.call(all, lastChildIndex);
-    return {
-        prev,
-        inner,
-        next,
-    };
-}
-function getActiveElement(host) {
-    const doc = getOwnerDocument(host);
-    const activeElement = DocumentPrototypeActiveElement.call(doc);
-    if (isNull(activeElement)) {
-        return activeElement;
-    }
-    // activeElement must be child of the host and owned by it
-    return (compareDocumentPosition.call(host, activeElement) & DOCUMENT_POSITION_CONTAINED_BY) !==
-        0
-        ? activeElement
-        : null;
-}
-function relatedTargetPosition(host, relatedTarget) {
-    // assert: target must be child of host
-    const pos = compareDocumentPosition.call(host, relatedTarget);
-    if (pos & DOCUMENT_POSITION_CONTAINED_BY) {
-        // focus remains inside the host
-        return 0;
-    }
-    else if (pos & DOCUMENT_POSITION_PRECEDING) {
-        // focus is coming from above
-        return 1;
-    }
-    else if (pos & DOCUMENT_POSITION_FOLLOWING) {
-        // focus is coming from below
-        return 2;
-    }
-    // we don't know what's going on.
-    return -1;
-}
-function muteEvent(event) {
-    event.preventDefault();
-    event.stopPropagation();
-}
-function muteFocusEventsDuringExecution(win, func) {
-    windowAddEventListener.call(win, 'focusin', muteEvent, true);
-    windowAddEventListener.call(win, 'focusout', muteEvent, true);
-    func();
-    windowRemoveEventListener.call(win, 'focusin', muteEvent, true);
-    windowRemoveEventListener.call(win, 'focusout', muteEvent, true);
-}
-function focusOnNextOrBlur(segment, target, relatedTarget) {
-    const win = getOwnerWindow(relatedTarget);
-    const next = getNextTabbable(segment, relatedTarget);
-    if (isNull(next)) {
-        // nothing to focus on, blur to invalidate the operation
-        muteFocusEventsDuringExecution(win, () => {
-            target.blur();
-        });
-    }
-    else {
-        muteFocusEventsDuringExecution(win, () => {
-            next.focus();
-        });
-    }
-}
-let letBrowserHandleFocus = false;
-function disableKeyboardFocusNavigationRoutines() {
-    letBrowserHandleFocus = true;
-}
-function enableKeyboardFocusNavigationRoutines() {
-    letBrowserHandleFocus = false;
-}
-function isKeyboardFocusNavigationRoutineEnabled() {
-    return !letBrowserHandleFocus;
-}
-function skipHostHandler(event) {
-    if (letBrowserHandleFocus) {
-        return;
-    }
-    const host = eventCurrentTargetGetter.call(event);
-    const target = eventTargetGetter.call(event);
-    // If the host delegating focus with tabindex=0 is not the target, we know
-    // that the event was dispatched on a descendant node of the host. This
-    // means the focus is coming from below and we don't need to do anything.
-    if (host !== target) {
-        // Focus is coming from above
-        return;
-    }
-    const relatedTarget = focusEventRelatedTargetGetter.call(event);
-    if (isNull(relatedTarget)) {
-        // If relatedTarget is null, the user is most likely tabbing into the document from the
-        // browser chrome. We could probably deduce whether focus is coming in from the top or the
-        // bottom by comparing the position of the target to all tabbable elements. This is an edge
-        // case and only comes up if the custom element is the first or last tabbable element in the
-        // document.
-        return;
-    }
-    const segments = getTabbableSegments(host);
-    const position = relatedTargetPosition(host, relatedTarget);
-    if (position === 1) {
-        // Focus is coming from above
-        const findTabbableElms = isTabbableFrom.bind(null, host.getRootNode());
-        const first = ArrayFind.call(segments.inner, findTabbableElms);
-        if (!isUndefined(first)) {
-            const win = getOwnerWindow(first);
-            muteFocusEventsDuringExecution(win, () => {
-                first.focus();
-            });
-        }
-        else {
-            focusOnNextOrBlur(segments.next, target, relatedTarget);
-        }
-    }
-    else if (host === target) {
-        // Host is receiving focus from below, either from its shadow or from a sibling
-        focusOnNextOrBlur(ArrayReverse.call(segments.prev), target, relatedTarget);
-    }
-}
-function skipShadowHandler(event) {
-    if (letBrowserHandleFocus) {
-        return;
-    }
-    const relatedTarget = focusEventRelatedTargetGetter.call(event);
-    if (isNull(relatedTarget)) {
-        // If relatedTarget is null, the user is most likely tabbing into the document from the
-        // browser chrome. We could probably deduce whether focus is coming in from the top or the
-        // bottom by comparing the position of the target to all tabbable elements. This is an edge
-        // case and only comes up if the custom element is the first or last tabbable element in the
-        // document.
-        return;
-    }
-    const host = eventCurrentTargetGetter.call(event);
-    const segments = getTabbableSegments(host);
-    if (ArrayIndexOf.call(segments.inner, relatedTarget) !== -1) {
-        // If relatedTarget is contained by the host's subtree we can assume that the user is
-        // tabbing between elements inside of the shadow. Do nothing.
-        return;
-    }
-    const target = eventTargetGetter.call(event);
-    // Determine where the focus is coming from (Tab or Shift+Tab)
-    const position = relatedTargetPosition(host, relatedTarget);
-    if (position === 1) {
-        // Focus is coming from above
-        focusOnNextOrBlur(segments.next, target, relatedTarget);
-    }
-    if (position === 2) {
-        // Focus is coming from below
-        focusOnNextOrBlur(ArrayReverse.call(segments.prev), target, relatedTarget);
-    }
-}
-// Use this function to determine whether you can start from one root and end up
-// at another element via tabbing.
-function isTabbableFrom(fromRoot, toElm) {
-    if (!isTabbable(toElm)) {
-        return false;
-    }
-    const ownerDocument = getOwnerDocument(toElm);
-    let root = toElm.getRootNode();
-    while (root !== ownerDocument && root !== fromRoot) {
-        const sr = root;
-        const host = sr.host;
-        if (getAttribute.call(host, 'tabindex') === '-1') {
-            return false;
-        }
-        root = host && host.getRootNode();
-    }
-    return true;
-}
-function getNextTabbable(tabbables, relatedTarget) {
-    const len = tabbables.length;
-    if (len > 0) {
-        for (let i = 0; i < len; i += 1) {
-            const next = tabbables[i];
-            if (isTabbableFrom(relatedTarget.getRootNode(), next)) {
-                return next;
-            }
-        }
-    }
-    return null;
-}
-// Skips the host element
-function handleFocus(elm) {
-    if (process.env.NODE_ENV !== 'production') {
-        assert.invariant(isDelegatingFocus(elm), `Invalid attempt to handle focus event for ${toString(elm)}. ${toString(elm)} should have delegates focus true, but is not delegating focus`);
-    }
-    bindDocumentMousedownMouseupHandlers(elm);
-    // Unbind any focusin listeners we may have going on
-    ignoreFocusIn(elm);
-    addEventListener.call(elm, 'focusin', skipHostHandler, true);
-}
-function ignoreFocus(elm) {
-    removeEventListener.call(elm, 'focusin', skipHostHandler, true);
-}
-function bindDocumentMousedownMouseupHandlers(elm) {
-    const ownerDocument = getOwnerDocument(elm);
-    if (!DidAddMouseEventListeners.get(ownerDocument)) {
-        DidAddMouseEventListeners.set(ownerDocument, true);
-        addEventListener.call(ownerDocument, 'mousedown', disableKeyboardFocusNavigationRoutines, true);
-        addEventListener.call(ownerDocument, 'mouseup', () => {
-            // We schedule this as an async task in the mouseup handler (as
-            // opposed to the mousedown handler) because we want to guarantee
-            // that it will never run before the focusin handler:
-            //
-            // Click form element   | Click form element label
-            // ==================================================
-            // mousedown            | mousedown
-            // FOCUSIN              | mousedown-setTimeout
-            // mousedown-setTimeout | mouseup
-            // mouseup              | FOCUSIN
-            // mouseup-setTimeout   | mouseup-setTimeout
-            setTimeout(enableKeyboardFocusNavigationRoutines);
-        }, true);
-        // [W-7824445] If the element is draggable, the mousedown event is dispatched before the
-        // element is starting to be dragged, which disable the keyboard focus navigation routine.
-        // But by specification, the mouseup event is never dispatched once the element is dropped.
-        //
-        // For all draggable element, we need to add an event listener to re-enable the keyboard
-        // navigation routine after dragging starts.
-        addEventListener.call(ownerDocument, 'dragstart', enableKeyboardFocusNavigationRoutines, true);
-    }
-}
-// Skips the shadow tree
-function handleFocusIn(elm) {
-    if (process.env.NODE_ENV !== 'production') {
-        assert.invariant(tabIndexGetter.call(elm) === -1, `Invalid attempt to handle focus in  ${toString(elm)}. ${toString(elm)} should have tabIndex -1, but has tabIndex ${tabIndexGetter.call(elm)}`);
-    }
-    bindDocumentMousedownMouseupHandlers(elm);
-    // Unbind any focus listeners we may have going on
-    ignoreFocus(elm);
-    // This focusin listener is to catch focusin events from keyboard interactions
-    // A better solution would perhaps be to listen for keydown events, but
-    // the keydown event happens on whatever element already has focus (or no element
-    // at all in the case of the location bar. So, instead we have to assume that focusin
-    // without a mousedown means keyboard navigation
-    addEventListener.call(elm, 'focusin', skipShadowHandler, true);
-}
-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
- */
-const { blur, focus } = HTMLElement.prototype;
-/**
- * This method only applies to elements with a shadow attached to them
- */
-function tabIndexGetterPatched() {
-    if (isDelegatingFocus(this) && isFalse(hasAttribute.call(this, 'tabindex'))) {
-        // this covers the case where the default tabindex should be 0 because the
-        // custom element is delegating its focus
-        return 0;
-    }
-    return tabIndexGetter.call(this);
-}
-/**
- * This method only applies to elements with a shadow attached to them
- */
-function tabIndexSetterPatched(value) {
-    // This tabIndex setter might be confusing unless it is understood that HTML
-    // elements have default tabIndex property values. Natively focusable elements have
-    // a default tabIndex value of 0 and all other elements have a default tabIndex
-    // value of -1. For example, the tabIndex property value is -1 for both <x-foo> and
-    // <x-foo tabindex="-1">, but our delegatesFocus polyfill should only kick in for
-    // the latter case when the value of the tabindex attribute is -1.
-    const delegatesFocus = isDelegatingFocus(this);
-    // Record the state of things before invoking component setter.
-    const prevValue = tabIndexGetter.call(this);
-    const prevHasAttr = hasAttribute.call(this, 'tabindex');
-    tabIndexSetter.call(this, value);
-    // Record the state of things after invoking component setter.
-    const currValue = tabIndexGetter.call(this);
-    const currHasAttr = hasAttribute.call(this, 'tabindex');
-    const didValueChange = prevValue !== currValue;
-    // If the tabindex attribute is initially rendered, we can assume that this setter has
-    // previously executed and a listener has been added. We must remove that listener if
-    // the tabIndex property value has changed or if the component no longer renders a
-    // tabindex attribute.
-    if (prevHasAttr && (didValueChange || isFalse(currHasAttr))) {
-        if (prevValue === -1) {
-            ignoreFocusIn(this);
-        }
-        if (prevValue === 0 && delegatesFocus) {
-            ignoreFocus(this);
-        }
-    }
-    // If a tabindex attribute was not rendered after invoking its setter, it means the
-    // component is taking control. Do nothing.
-    if (isFalse(currHasAttr)) {
-        return;
-    }
-    // If the tabindex attribute is initially rendered, we can assume that this setter has
-    // previously executed and a listener has been added. If the tabindex attribute is still
-    // rendered after invoking the setter AND the tabIndex property value has not changed,
-    // we don't need to do any work.
-    if (prevHasAttr && currHasAttr && isFalse(didValueChange)) {
-        return;
-    }
-    // At this point we know that a tabindex attribute was rendered after invoking the
-    // setter and that either:
-    // 1) This is the first time this setter is being invoked.
-    // 2) This is not the first time this setter is being invoked and the value is changing.
-    // We need to add the appropriate listeners in either case.
-    if (currValue === -1) {
-        // Add the magic to skip the shadow tree
-        handleFocusIn(this);
-    }
-    if (currValue === 0 && delegatesFocus) {
-        // Add the magic to skip the host element
-        handleFocus(this);
-    }
-}
-/**
- * This method only applies to elements with a shadow attached to them
- */
-function blurPatched() {
-    if (isDelegatingFocus(this)) {
-        const currentActiveElement = getActiveElement(this);
-        if (!isNull(currentActiveElement)) {
-            // if there is an active element, blur it (intentionally using the dot notation in case the user defines the blur routine)
-            currentActiveElement.blur();
-            return;
-        }
-    }
-    return blur.call(this);
-}
-function focusPatched() {
-    // Save enabled state
-    const originallyEnabled = isKeyboardFocusNavigationRoutineEnabled();
-    // Change state by disabling if originally enabled
-    if (originallyEnabled) {
-        disableKeyboardFocusNavigationRoutines();
-    }
-    if (isSyntheticShadowHost(this) && isDelegatingFocus(this)) {
-        hostElementFocus.call(this);
-        return;
-    }
-    // Typescript does not like it when you treat the `arguments` object as an array
-    // @ts-ignore type-mismatch
-    focus.apply(this, arguments);
-    // Restore state by enabling if originally enabled
-    if (originallyEnabled) {
-        enableKeyboardFocusNavigationRoutines();
-    }
-}
-// Non-deep-traversing patches: this descriptor map includes all descriptors that
-// do not five access to nodes beyond the immediate children.
-defineProperties(HTMLElement.prototype, {
-    tabIndex: {
-        get() {
-            if (isSyntheticShadowHost(this)) {
-                return tabIndexGetterPatched.call(this);
-            }
-            return tabIndexGetter.call(this);
-        },
-        set(v) {
-            if (isSyntheticShadowHost(this)) {
-                return tabIndexSetterPatched.call(this, v);
-            }
-            return tabIndexSetter.call(this, v);
-        },
-        enumerable: true,
-        configurable: true,
-    },
-    blur: {
-        value() {
-            if (isSyntheticShadowHost(this)) {
-                return blurPatched.call(this);
-            }
-            blur.call(this);
-        },
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-    focus: {
-        value() {
-            // Typescript does not like it when you treat the `arguments` object as an array
-            // @ts-ignore type-mismatch
-            focusPatched.apply(this, arguments);
-        },
-        enumerable: true,
-        writable: true,
-        configurable: true,
-    },
-});
-// Note: In JSDOM innerText is not implemented: https://github.com/jsdom/jsdom/issues/1245
-if (innerTextGetter !== null && innerTextSetter !== null) {
-    defineProperty(HTMLElement.prototype, 'innerText', {
-        get() {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            return innerTextGetter.call(this);
-        },
-        set(v) {
-            innerTextSetter.call(this, v);
-        },
-        enumerable: true,
-        configurable: true,
-    });
-}
-// Note: Firefox does not have outerText, https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/outerText
-if (outerTextGetter !== null && outerTextSetter !== null) {
-    // From https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/outerText :
-    // HTMLElement.outerText is a non-standard property. As a getter, it returns the same value as Node.innerText.
-    // As a setter, it removes the current node and replaces it with the given text.
-    defineProperty(HTMLElement.prototype, 'outerText', {
-        get() {
-            // Note: we deviate from native shadow here, but are not fixing
-            // due to backwards compat: https://github.com/salesforce/lwc/pull/3103
-            return outerTextGetter.call(this);
-        },
-        set(v) {
-            // Invoking the `outerText` setter on a host element should trigger its disconnection, but until we merge node reactions, it will not work.
-            // We could reimplement the outerText setter in JavaScript ([blink implementation](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/html/html_element.cc;l=841-879;drc=6e8b402a6231405b753919029c9027404325ea00;bpv=0;bpt=1))
-            // but the benefits don't worth the efforts.
-            outerTextSetter.call(this, v);
-        },
-        enumerable: true,
-        configurable: 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 getShadowToken(node) {
-    return node[KEY__SHADOW_TOKEN];
-}
-function setShadowToken(node, shadowToken) {
-    node[KEY__SHADOW_TOKEN] = shadowToken;
-}
-/**
- * Patching Element.prototype.$shadowToken$ to mark elements a portal:
- *
- *  - we use a property to allow engines to set a custom attribute that should be
- *    placed into the element to sandbox the css rules defined for the template.
- *
- *  - this custom attribute must be unique.
- *
- **/
-defineProperty(Element.prototype, KEY__SHADOW_TOKEN, {
-    set(shadowToken) {
-        const oldShadowToken = this[KEY__SHADOW_TOKEN_PRIVATE];
-        if (!isUndefined(oldShadowToken) && oldShadowToken !== shadowToken) {
-            removeAttribute.call(this, oldShadowToken);
-        }
-        if (!isUndefined(shadowToken)) {
-            setAttribute.call(this, shadowToken, '');
-        }
-        this[KEY__SHADOW_TOKEN_PRIVATE] = shadowToken;
-    },
-    get() {
-        return this[KEY__SHADOW_TOKEN_PRIVATE];
-    },
-    configurable: true,
-});
-function recursivelySetShadowResolver(node, fn) {
-    node[KEY__SHADOW_RESOLVER] = fn;
-    const childNodes = childNodesGetter.call(node);
-    for (let i = 0, n = childNodes.length; i < n; i++) {
-        recursivelySetShadowResolver(childNodes[i], fn);
-    }
-}
-defineProperty(Element.prototype, KEY__SHADOW_STATIC, {
-    set(v) {
-        // Marking an element as static will propagate the shadow resolver to the children.
-        if (v) {
-            const fn = this[KEY__SHADOW_RESOLVER];
-            recursivelySetShadowResolver(this, fn);
-        }
-        this[KEY__SHADOW_STATIC_PRIVATE] = v;
-    },
-    get() {
-        return this[KEY__SHADOW_STATIC_PRIVATE];
-    },
-    configurable: 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
- */
-const DomManualPrivateKey = '$$DomManualKey$$';
-// Resolver function used when a node is removed from within a portal
-const DocumentResolverFn = function () { };
-// We can use a single observer without having to worry about leaking because
-// "Registered observers in a node’s registered observer list have a weak
-// reference to the node."
-// https://dom.spec.whatwg.org/#garbage-collection
-let portalObserver;
-const portalObserverConfig = {
-    childList: true,
-};
-function adoptChildNode(node, fn, shadowToken) {
-    const previousNodeShadowResolver = getShadowRootResolver(node);
-    if (previousNodeShadowResolver === fn) {
-        return; // nothing to do here, it is already correctly patched
-    }
-    setShadowRootResolver(node, fn);
-    if (node instanceof Element) {
-        setShadowToken(node, shadowToken);
-        if (isSyntheticShadowHost(node)) {
-            // Root LWC elements can't get content slotted into them, therefore we don't observe their children.
-            return;
-        }
-        if (isUndefined(previousNodeShadowResolver)) {
-            // we only care about Element without shadowResolver (no MO.observe has been called)
-            MutationObserverObserve.call(portalObserver, node, portalObserverConfig);
-        }
-        // recursively patching all children as well
-        const childNodes = childNodesGetter.call(node);
-        for (let i = 0, len = childNodes.length; i < len; i += 1) {
-            adoptChildNode(childNodes[i], fn, shadowToken);
-        }
-    }
-}
-function initPortalObserver() {
-    return new MO((mutations) => {
-        forEach.call(mutations, (mutation) => {
-            /**
-             * This routine will process all nodes added or removed from elm (which is marked as a portal)
-             * When adding a node to the portal element, we should add the ownership.
-             * When removing a node from the portal element, this ownership should be removed.
-             *
-             * There is some special cases in which MutationObserver may call with stacked mutations (the same node
-             * will be in addedNodes and removedNodes) or with false positives (a node that is removed and re-appended
-             * in the same tick) for those cases, we cover by checking that the node is contained
-             * (or not in the case of removal) by the element.
-             */
-            const { target: elm, addedNodes, removedNodes } = mutation;
-            // the target of the mutation should always have a ShadowRootResolver attached to it
-            const fn = getShadowRootResolver(elm);
-            const shadowToken = getShadowToken(elm);
-            // Process removals first to handle the case where an element is removed and reinserted
-            for (let i = 0, len = removedNodes.length; i < len; i += 1) {
-                const node = removedNodes[i];
-                if (!(compareDocumentPosition.call(elm, node) & _Node.DOCUMENT_POSITION_CONTAINED_BY)) {
-                    adoptChildNode(node, DocumentResolverFn, undefined);
-                }
-            }
-            for (let i = 0, len = addedNodes.length; i < len; i += 1) {
-                const node = addedNodes[i];
-                if (compareDocumentPosition.call(elm, node) & _Node.DOCUMENT_POSITION_CONTAINED_BY) {
-                    adoptChildNode(node, fn, shadowToken);
-                }
-            }
-        });
-    });
-}
-function markElementAsPortal(elm) {
-    if (isUndefined(portalObserver)) {
-        portalObserver = initPortalObserver();
-    }
-    if (isUndefined(getShadowRootResolver(elm))) {
-        // only an element from a within a shadowRoot should be used here
-        throw new Error(`Invalid Element`);
-    }
-    // install mutation observer for portals
-    MutationObserverObserve.call(portalObserver, elm, portalObserverConfig);
-    // TODO [#1253]: optimization to synchronously adopt new child nodes added
-    // to this elm, we can do that by patching the most common operations
-    // on the node itself
-}
-/**
- * Patching Element.prototype.$domManual$ to mark elements as portal:
- *
- *  - we use a property to allow engines to signal that a particular element in
- *    a shadow supports manual insertion of child nodes.
- *
- *  - this signal comes as a boolean value, and we use it to install the MO instance
- *    onto the element, to propagate the $ownerKey$ and $shadowToken$ to all new
- *    child nodes.
- *
- *  - at the moment, there is no way to undo this operation, once the element is
- *    marked as $domManual$, setting it to false does nothing.
- *
- **/
-// TODO [#1306]: rename this to $observerConnection$
-defineProperty(Element.prototype, '$domManual$', {
-    set(v) {
-        this[DomManualPrivateKey] = v;
-        if (isTrue(v)) {
-            markElementAsPortal(this);
-        }
-    },
-    get() {
-        return this[DomManualPrivateKey];
-    },
-    configurable: true,
-});
-/** version: 2.50.0 */
-//# sourceMappingURL=index.js.map