lwc 2.29.0 → 2.30.0

package/dist/synthetic-shadow/umd/es2017/synthetic-shadow_debug.js

@@ -89,7 +89,7 @@
   const KEY__SHADOW_TOKEN = '$shadowToken$';
   const KEY__SHADOW_TOKEN_PRIVATE = '$$ShadowTokenKey$$';
   const KEY__SYNTHETIC_MODE = '$$lwc-synthetic-mode';
-  /** version: 2.29.0 */
+  /** version: 2.30.0 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -403,7 +403,7 @@
       Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
   }
   const lwcRuntimeFlags = _globalThis.lwcRuntimeFlags;
-  /** version: 2.29.0 */
+  /** version: 2.30.0 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -411,22 +411,19 @@
    * 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;
-
     {
       const {
         value
-      } = config; // in prod, we prioritize performance
-
+      } = config;
+      // in prod, we prioritize performance
       shadowedNode[propName] = value;
     }
   }
-
   function setNodeOwnerKey(node, value) {
     fastDefineProperty(node, HostElementKey, {
       value,
@@ -443,18 +440,15 @@
   }
   function getNodeNearestOwnerKey(node) {
     let host = node;
-    let hostKey; // search for the first element with owner identity
+    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 (lwcRuntimeFlags.ENABLE_LIGHT_GET_ROOT_NODE_PATCH) {
         if (!isNull(host) && isSyntheticSlotElement(host)) {
           return undefined;
@@ -470,7 +464,6 @@
    * 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));
   }
@@ -481,30 +474,24 @@
    * 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) {
-
-    const hostKey = getNodeKey(host); // this routine assumes that the node is coming from a different shadow (it is not owned by the 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
@@ -530,7 +517,6 @@
            * 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
@@ -549,32 +535,25 @@
         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
+    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) {
@@ -584,23 +563,18 @@
     return node instanceof HTMLSlotElement;
   }
   function isNodeOwnedBy(owner, node) {
-
     const ownerKey = getNodeNearestOwnerKey(node);
-
     if (isUndefined(ownerKey)) {
       if (lwcRuntimeFlags.ENABLE_LIGHT_GET_ROOT_NODE_PATCH) {
         // 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
-
-
+      }
+      // in case of manually inserted elements
       return true;
     }
-
     return getNodeKey(owner) === ownerKey;
   }
   function shadowRootChildNodes(root) {
@@ -609,42 +583,34 @@
   }
   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) {
@@ -653,7 +619,6 @@
         return nodeList[i];
       }
     }
-
     return null;
   }
   function shadowRootQuerySelector(root, selector) {
@@ -672,19 +637,17 @@
       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
+      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 {
@@ -696,11 +659,9 @@
   }
   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));
   }
@@ -1122,14 +1083,11 @@
    * 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);
@@ -1142,64 +1100,50 @@
         // 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
-
-
+    }
+    // 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
+    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;
@@ -1209,71 +1153,56 @@
     } 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
+    }
+    // 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
+    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));
-
       return createStaticNodeList(childNodes);
-    } // nothing to do here since this does not have a synthetic shadow attached to it
+    }
+    // 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;
   };
   /**
@@ -1285,15 +1214,12 @@
    *  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);
   }
   /**
@@ -1315,25 +1241,20 @@
    * _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
+  }
+  // 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
     },
@@ -1342,10 +1263,8 @@
         if (hasMountedChildren(this)) {
           return lastChildGetterPatched.call(this);
         }
-
         return lastChildGetter.call(this);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -1355,18 +1274,14 @@
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return textContentGetterPatched.call(this);
           }
-
           return textContentGetter.call(this);
-        } // TODO [#1222]: remove global bypass
-
-
+        }
+        // TODO [#1222]: remove global bypass
         if (isGlobalPatchingSkipped(this)) {
           return textContentGetter.call(this);
         }
-
         return textContentGetterPatched.call(this);
       },
-
       set: textContentSetterPatched,
       enumerable: true,
       configurable: true
@@ -1376,17 +1291,14 @@
         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
+        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
     },
@@ -1395,17 +1307,14 @@
         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
+        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
     },
@@ -1414,10 +1323,8 @@
         if (hasMountedChildren(this)) {
           return childNodesGetterPatched.call(this);
         }
-
         return childNodesGetter.call(this);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -1426,10 +1333,8 @@
         if (hasMountedChildren(this)) {
           return hasChildNodesPatched.call(this);
         }
-
         return hasChildNodes.call(this);
       },
-
       enumerable: true,
       writable: true,
       configurable: true
@@ -1440,10 +1345,8 @@
         if (isGlobalPatchingSkipped(this)) {
           return compareDocumentPosition.call(this, otherNode);
         }
-
         return compareDocumentPositionPatched.call(this, otherNode);
       },
-
       enumerable: true,
       writable: true,
       configurable: true
@@ -1457,27 +1360,21 @@
         if (this === otherNode) {
           return true;
         }
-
         if (!lwcRuntimeFlags.ENABLE_NODE_PATCH) {
           if (otherNode == null) {
             return false;
           }
-
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return containsPatched.call(this, otherNode);
           }
-
           return contains.call(this, otherNode);
-        } // TODO [#1222]: remove global bypass
-
-
+        }
+        // TODO [#1222]: remove global bypass
         if (isGlobalPatchingSkipped(this)) {
           return contains.call(this, otherNode);
         }
-
         return containsPatched.call(this, otherNode);
       },
-
       enumerable: true,
       writable: true,
       configurable: true
@@ -1488,22 +1385,17 @@
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return cloneNodePatched.call(this, deep);
           }
-
           return cloneNode.call(this, deep);
         }
-
         if (isTrue(deep)) {
           // TODO [#1222]: remove global bypass
           if (isGlobalPatchingSkipped(this)) {
             return cloneNode.call(this, deep);
           }
-
           return cloneNodePatched.call(this, deep);
         }
-
         return cloneNode.call(this, deep);
       },
-
       enumerable: true,
       writable: true,
       configurable: true
@@ -1517,21 +1409,18 @@
     isConnected: {
       enumerable: true,
       configurable: true,
-
       get() {
         return isConnected.call(this);
       }
-
     }
   });
   const getInternalChildNodes = function (node) {
     return node.childNodes;
-  }; // IE11 extra patches for wrong prototypes
-
+  };
+  // 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'));
   }
@@ -3638,66 +3527,52 @@
    * 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
+  }
+  // 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() {
@@ -3705,22 +3580,17 @@
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return innerHTMLGetterPatched.call(this);
           }
-
           return innerHTMLGetter.call(this);
-        } // TODO [#1222]: remove global bypass
-
-
+        }
+        // TODO [#1222]: remove global bypass
         if (isGlobalPatchingSkipped(this)) {
           return innerHTMLGetter.call(this);
         }
-
         return innerHTMLGetterPatched.call(this);
       },
-
       set(v) {
         innerHTMLSetter.call(this, v);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -3730,22 +3600,17 @@
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return outerHTMLGetterPatched.call(this);
           }
-
           return outerHTMLGetter.call(this);
-        } // TODO [#1222]: remove global bypass
-
-
+        }
+        // TODO [#1222]: remove global bypass
         if (isGlobalPatchingSkipped(this)) {
           return outerHTMLGetter.call(this);
         }
-
         return outerHTMLGetterPatched.call(this);
       },
-
       set(v) {
         outerHTMLSetter.call(this, v);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -3766,10 +3631,8 @@
         if (hasMountedChildren(this)) {
           return childrenGetterPatched.call(this);
         }
-
         return childrenGetter.call(this);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -3778,10 +3641,8 @@
         if (hasMountedChildren(this)) {
           return childElementCountGetterPatched.call(this);
         }
-
         return childElementCountGetter.call(this);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -3790,10 +3651,8 @@
         if (hasMountedChildren(this)) {
           return firstElementChildGetterPatched.call(this);
         }
-
         return firstElementChildGetter.call(this);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -3802,10 +3661,8 @@
         if (hasMountedChildren(this)) {
           return lastElementChildGetterPatched.call(this);
         }
-
         return lastElementChildGetter.call(this);
       },
-
       enumerable: true,
       configurable: true
     },
@@ -3814,28 +3671,23 @@
       enumerable: true,
       configurable: true
     }
-  }); // IE11 extra patches for wrong prototypes
-
+  });
+  // 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:
-
-
+  }
+  // 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);
@@ -3848,7 +3700,6 @@
     } 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);
@@ -3857,10 +3708,9 @@
         if (!lwcRuntimeFlags.ENABLE_NODE_LIST_PATCH) {
           // `this` is a manually inserted element inside a shadowRoot, return the first element.
           return nodeList.length === 0 ? null : nodeList[0];
-        } // Element is inside a shadow but we dont know which one. Use the
+        }
+        // Element is inside a shadow but we dont know which one. Use the
         // "nearest" owner key to filter by ownership.
-
-
         const contextNearestOwnerKey = getNodeNearestOwnerKey(this);
         const elm = ArrayFind.call(nodeList, elm => getNodeNearestOwnerKey(elm) === contextNearestOwnerKey);
         return isUndefined(elm) ? null : elm;
@@ -3871,22 +3721,19 @@
           const elm = nodeList[0];
           return isUndefined(elm) ? null : elm;
         }
-      } // element belonging to the document
-
-
-      const elm = ArrayFind.call(nodeList, // TODO [#1222]: remove global bypass
+      }
+      // element belonging to the document
+      const elm = ArrayFind.call(nodeList,
+      // TODO [#1222]: remove global bypass
       elm => isUndefined(getNodeOwnerKey(elm)) || isGlobalPatchingSkipped(this));
       return isUndefined(elm) ? null : elm;
     }
   }
-
   function getFilteredArrayOfNodes(context, unfilteredNodes, shadowDomSemantic) {
     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);
@@ -3899,13 +3746,10 @@
     } 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 if (shadowDomSemantic === 1
-      /* ShadowDomSemantic.Enabled */
-      ) {
+      } else if (shadowDomSemantic === 1 /* ShadowDomSemantic.Enabled */) {
         // context is inside a shadow, we dont know which one.
         const contextNearestOwnerKey = getNodeNearestOwnerKey(context);
         filtered = ArrayFilter.call(unfilteredNodes, elm => getNodeNearestOwnerKey(elm) === contextNearestOwnerKey);
@@ -3914,20 +3758,19 @@
         filtered = ArraySlice.call(unfilteredNodes);
       }
     } else {
-      if (context instanceof HTMLBodyElement || shadowDomSemantic === 1
-      /* ShadowDomSemantic.Enabled */
-      ) {
+      if (context instanceof HTMLBodyElement || shadowDomSemantic === 1 /* ShadowDomSemantic.Enabled */) {
         // `context` is document.body or element belonging to the document with the patch enabled
-        filtered = ArrayFilter.call(unfilteredNodes, // TODO [#1222]: remove global bypass
+        filtered = ArrayFilter.call(unfilteredNodes,
+        // TODO [#1222]: remove global bypass
         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
+  }
+  // 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
@@ -3936,8 +3779,6 @@
   // 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,
@@ -3948,41 +3789,30 @@
     querySelectorAll: {
       value() {
         const nodeList = arrayFromCollection(querySelectorAll$1.apply(this, ArraySlice.call(arguments)));
-
         if (!lwcRuntimeFlags.ENABLE_NODE_LIST_PATCH) {
-          const filteredResults = getFilteredArrayOfNodes(this, nodeList, 0
-          /* ShadowDomSemantic.Disabled */
-          );
+          const filteredResults = getFilteredArrayOfNodes(this, nodeList, 0 /* ShadowDomSemantic.Disabled */);
           return createStaticNodeList(filteredResults);
         }
-
-        return createStaticNodeList(getFilteredArrayOfNodes(this, nodeList, 1
-        /* ShadowDomSemantic.Enabled */
-        ));
+        return createStaticNodeList(getFilteredArrayOfNodes(this, nodeList, 1 /* ShadowDomSemantic.Enabled */));
       },
 
       writable: true,
       enumerable: true,
       configurable: true
     }
-  }); // The following APIs are used directly by Jest internally so we avoid patching them during testing.
-
+  });
+  // The following APIs are used directly by Jest internally so we avoid patching them during testing.
   {
     defineProperties(Element.prototype, {
       getElementsByClassName: {
         value() {
           const elements = arrayFromCollection(getElementsByClassName$1.apply(this, ArraySlice.call(arguments)));
-
           if (!lwcRuntimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
             return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
           }
-
-          const filteredResults = getFilteredArrayOfNodes(this, elements, 1
-          /* ShadowDomSemantic.Enabled */
-          );
+          const filteredResults = getFilteredArrayOfNodes(this, elements, 1 /* ShadowDomSemantic.Enabled */);
           return createStaticHTMLCollection(filteredResults);
         },
-
         writable: true,
         enumerable: true,
         configurable: true
@@ -3990,17 +3820,12 @@
       getElementsByTagName: {
         value() {
           const elements = arrayFromCollection(getElementsByTagName$1.apply(this, ArraySlice.call(arguments)));
-
           if (!lwcRuntimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
             return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
           }
-
-          const filteredResults = getFilteredArrayOfNodes(this, elements, 1
-          /* ShadowDomSemantic.Enabled */
-          );
+          const filteredResults = getFilteredArrayOfNodes(this, elements, 1 /* ShadowDomSemantic.Enabled */);
           return createStaticHTMLCollection(filteredResults);
         },
-
         writable: true,
         enumerable: true,
         configurable: true
@@ -4008,25 +3833,19 @@
       getElementsByTagNameNS: {
         value() {
           const elements = arrayFromCollection(getElementsByTagNameNS$1.apply(this, ArraySlice.call(arguments)));
-
           if (!lwcRuntimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
             return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
           }
-
-          const filteredResults = getFilteredArrayOfNodes(this, elements, 1
-          /* ShadowDomSemantic.Enabled */
-          );
+          const filteredResults = getFilteredArrayOfNodes(this, elements, 1 /* ShadowDomSemantic.Enabled */);
           return createStaticHTMLCollection(filteredResults);
         },
-
         writable: true,
         enumerable: true,
         configurable: true
       }
     });
-  } // IE11 extra patches for wrong prototypes
-
-
+  }
+  // IE11 extra patches for wrong prototypes
   if (hasOwnProperty.call(HTMLElement.prototype, 'getElementsByClassName')) {
     defineProperty(HTMLElement.prototype, 'getElementsByClassName', getOwnPropertyDescriptor(Element.prototype, 'getElementsByClassName'));
   }
@@ -4565,21 +4384,17 @@
   /**
    * 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
@@ -4587,53 +4402,48 @@
     // 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 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.
-
+    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
+    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
+    }
+    // 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
+    }
+    // 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
+    }
+    // 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);
@@ -4642,64 +4452,52 @@
   /**
    * 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
-
+    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
+    }
+    // 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
-
+    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
+  }
+  // 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
     },
@@ -4708,10 +4506,8 @@
         if (isSyntheticShadowHost(this)) {
           return blurPatched.call(this);
         }
-
         blur.call(this);
       },
-
       enumerable: true,
       writable: true,
       configurable: true
@@ -4722,46 +4518,38 @@
         // @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
-
+  });
+  // Note: In JSDOM innerText is not implemented: https://github.com/jsdom/jsdom/issues/1245
   if (innerTextGetter !== null && innerTextSetter !== null) {
     defineProperty(HTMLElement.prototype, 'innerText', {
       get() {
         if (!lwcRuntimeFlags.ENABLE_INNER_OUTER_TEXT_PATCH) {
           return innerTextGetter.call(this);
         }
-
         if (!lwcRuntimeFlags.ENABLE_ELEMENT_PATCH) {
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return getInnerText(this);
           }
-
           return innerTextGetter.call(this);
-        } // TODO [#1222]: remove global bypass
-
-
+        }
+        // TODO [#1222]: remove global bypass
         if (isGlobalPatchingSkipped(this)) {
           return innerTextGetter.call(this);
         }
-
         return getInnerText(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
-
-
+  }
+  // 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.
@@ -4771,30 +4559,24 @@
         if (!lwcRuntimeFlags.ENABLE_INNER_OUTER_TEXT_PATCH) {
           return outerTextGetter.call(this);
         }
-
         if (!lwcRuntimeFlags.ENABLE_ELEMENT_PATCH) {
           if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
             return getInnerText(this);
           }
-
           return outerTextGetter.call(this);
-        } // TODO [#1222]: remove global bypass
-
-
+        }
+        // TODO [#1222]: remove global bypass
         if (isGlobalPatchingSkipped(this)) {
           return outerTextGetter.call(this);
         }
-
         return getInnerText(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
     });
@@ -4973,6 +4755,6 @@
       },
       configurable: true,
   });
-  /** version: 2.29.0 */
+  /** version: 2.30.0 */
 
 }));