lwc 2.13.0 → 2.13.1

package/dist/synthetic-shadow/iife/es5/synthetic-shadow.js

@@ -160,7 +160,7 @@
   var hasNativeSymbolSupport = /*@__PURE__*/ function() {
       return Symbol("x").toString() === "Symbol(x)";
   }();
-  /** version: 2.13.0 */ /*
+  /** version: 2.13.1 */ /*
    * Copyright (c) 2018, salesforce.com, inc.
    * All rights reserved.
    * SPDX-License-Identifier: MIT
@@ -404,238 +404,6 @@
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */ var eventTargetPrototype = typeof EventTarget !== "undefined" ? EventTarget.prototype : _Node.prototype;
   var addEventListener = eventTargetPrototype.addEventListener, dispatchEvent = eventTargetPrototype.dispatchEvent, removeEventListener = eventTargetPrototype.removeEventListener;
-  /*
-   * 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
-   */ var EventListenerMap = new WeakMap();
-  var ComposedPathMap = new WeakMap();
-  function isEventListenerOrEventListenerObject(fnOrObj) {
-      return isFunction(fnOrObj) || isObject(fnOrObj) && !isNull(fnOrObj) && isFunction(fnOrObj.handleEvent);
-  }
-  function shouldInvokeListener(event, target, currentTarget) {
-      // Subsequent logic assumes that `currentTarget` must be contained in the composed path for the listener to be
-      // invoked, but this is not always the case. `composedPath()` will sometimes return an empty array, even when the
-      // listener should be invoked (e.g., a disconnected instance of EventTarget, an instance of XMLHttpRequest, etc).
-      if (target === currentTarget) {
-          return true;
-      }
-      var composedPath1 = ComposedPathMap.get(event);
-      if (isUndefined(composedPath1)) {
-          composedPath1 = event.composedPath();
-          ComposedPathMap.set(event, composedPath1);
-      }
-      return composedPath1.includes(currentTarget);
-  }
-  function getEventListenerWrapper(fnOrObj) {
-      if (!isEventListenerOrEventListenerObject(fnOrObj)) {
-          return fnOrObj;
-      }
-      var wrapperFn = EventListenerMap.get(fnOrObj);
-      if (isUndefined(wrapperFn)) {
-          wrapperFn = function wrapperFn(event) {
-              // This function is invoked from an event listener and currentTarget is always defined.
-              var 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.");
-              }
-              var 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
-   */ var eventToContextMap = new WeakMap();
-  var customElementToWrappedListeners = new WeakMap();
-  function getEventMap(elm) {
-      var 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);
-  }
-  var shadowRootEventListenerMap = new WeakMap();
-  function getWrappedShadowRootListener(listener) {
-      if (!isFunction(listener)) {
-          throw new TypeError(); // avoiding problems with non-valid listeners
-      }
-      var shadowRootWrappedListener = shadowRootEventListenerMap.get(listener);
-      if (isUndefined(shadowRootWrappedListener)) {
-          shadowRootWrappedListener = function shadowRootWrappedListener(event) {
-              // currentTarget is always defined inside an event listener
-              var 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);
-              }
-              var actualTarget = getActualTarget(event);
-              if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                  listener.call(currentTarget, event);
-              }
-          };
-          shadowRootWrappedListener.placement = 1 /* SHADOW_ROOT_LISTENER */ ;
-          shadowRootEventListenerMap.set(listener, shadowRootWrappedListener);
-      }
-      return shadowRootWrappedListener;
-  }
-  var customElementEventListenerMap = new WeakMap();
-  function getWrappedCustomElementListener(listener) {
-      if (!isFunction(listener)) {
-          throw new TypeError(); // avoiding problems with non-valid listeners
-      }
-      var customElementWrappedListener = customElementEventListenerMap.get(listener);
-      if (isUndefined(customElementWrappedListener)) {
-          customElementWrappedListener = function customElementWrappedListener(event) {
-              // currentTarget is always defined inside an event listener
-              var currentTarget = eventCurrentTargetGetter.call(event);
-              var actualTarget = getActualTarget(event);
-              if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                  listener.call(currentTarget, event);
-              }
-          };
-          customElementWrappedListener.placement = 0 /* CUSTOM_ELEMENT_LISTENER */ ;
-          customElementEventListenerMap.set(listener, customElementWrappedListener);
-      }
-      return customElementWrappedListener;
-  }
-  function domListener(evt) {
-      var invokeListenersByPlacement = function invokeListenersByPlacement(placement) {
-          forEach.call(bookkeeping, function(listener) {
-              if (isFalse(immediatePropagationStopped) && listener.placement === placement) {
-                  // making sure that the listener was not removed from the original listener queue
-                  if (ArrayIndexOf.call(listeners, listener) !== -1) {
-                      // all handlers on the custom element should be called with undefined 'this'
-                      listener.call(undefined, evt);
-                  }
-              }
-          });
-      };
-      var immediatePropagationStopped = false;
-      var propagationStopped = false;
-      var type = evt.type, stopImmediatePropagation = evt.stopImmediatePropagation, stopPropagation = evt.stopPropagation;
-      // currentTarget is always defined
-      var currentTarget = eventCurrentTargetGetter.call(evt);
-      var listenerMap = getEventMap(currentTarget);
-      var listeners = listenerMap[type]; // it must have listeners at this point
-      defineProperty(evt, "stopImmediatePropagation", {
-          value: function value() {
-              immediatePropagationStopped = true;
-              stopImmediatePropagation.call(evt);
-          },
-          writable: true,
-          enumerable: true,
-          configurable: true
-      });
-      defineProperty(evt, "stopPropagation", {
-          value: function value() {
-              propagationStopped = true;
-              stopPropagation.call(evt);
-          },
-          writable: true,
-          enumerable: true,
-          configurable: true
-      });
-      // in case a listener adds or removes other listeners during invocation
-      var bookkeeping = ArraySlice.call(listeners);
-      eventToContextMap.set(evt, 1 /* SHADOW_ROOT_LISTENER */ );
-      invokeListenersByPlacement(1 /* SHADOW_ROOT_LISTENER */ );
-      if (isFalse(immediatePropagationStopped) && isFalse(propagationStopped)) {
-          // doing the second iteration only if the first one didn't interrupt the event propagation
-          eventToContextMap.set(evt, 0 /* CUSTOM_ELEMENT_LISTENER */ );
-          invokeListenersByPlacement(0 /* CUSTOM_ELEMENT_LISTENER */ );
-      }
-      eventToContextMap.set(evt, 2 /* UNKNOWN_LISTENER */ );
-  }
-  function attachDOMListener(elm, type, wrappedListener) {
-      var listenerMap = getEventMap(elm);
-      var cmpEventHandlers = listenerMap[type];
-      if (isUndefined(cmpEventHandlers)) {
-          cmpEventHandlers = listenerMap[type] = [];
-      }
-      // Prevent identical listeners from subscribing to the same event type.
-      // TODO [#1824]: Options will also play a factor when we introduce support for them (#1824).
-      if (ArrayIndexOf.call(cmpEventHandlers, wrappedListener) !== -1) {
-          return;
-      }
-      // only add to DOM if there is no other listener on the same placement yet
-      if (cmpEventHandlers.length === 0) {
-          // super.addEventListener() - this will not work on
-          addEventListener.call(elm, type, domListener);
-      }
-      ArrayPush.call(cmpEventHandlers, wrappedListener);
-  }
-  function detachDOMListener(elm, type, wrappedListener) {
-      var listenerMap = getEventMap(elm);
-      var p;
-      var listeners;
-      if (!isUndefined(listeners = listenerMap[type]) && (p = ArrayIndexOf.call(listeners, wrappedListener)) !== -1) {
-          ArraySplice.call(listeners, p, 1);
-          // only remove from DOM if there is no other listener on the same placement
-          if (listeners.length === 0) {
-              removeEventListener.call(elm, type, domListener);
-          }
-      }
-  }
-  function addCustomElementEventListener(type, listener, _options) {
-      if (process.env.NODE_ENV !== "production") {
-          if (!isFunction(listener)) {
-              throw new TypeError("Invalid second argument for Element.addEventListener() in ".concat(toString(this), ' for event "').concat(type, '". Expected an EventListener but received ').concat(listener, "."));
-          }
-      }
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
-          var wrappedListener = getWrappedCustomElementListener(listener);
-          attachDOMListener(this, type, wrappedListener);
-      }
-  }
-  function removeCustomElementEventListener(type, listener, _options) {
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
-          var wrappedListener = getWrappedCustomElementListener(listener);
-          detachDOMListener(this, type, wrappedListener);
-      }
-  }
-  function addShadowRootEventListener(sr, type, listener, _options) {
-      if (process.env.NODE_ENV !== "production") {
-          if (!isFunction(listener)) {
-              throw new TypeError("Invalid second argument for ShadowRoot.addEventListener() in ".concat(toString(sr), ' for event "').concat(type, '". Expected an EventListener but received ').concat(listener, "."));
-          }
-      }
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
-          var elm = getHost(sr);
-          var wrappedListener = getWrappedShadowRootListener(listener);
-          attachDOMListener(elm, type, wrappedListener);
-      }
-  }
-  function removeShadowRootEventListener(sr, type, listener, _options) {
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
-          var elm = getHost(sr);
-          var wrappedListener = getWrappedShadowRootListener(listener);
-          detachDOMListener(elm, type, wrappedListener);
-      }
-  }
   /*
    * Copyright (c) 2018, salesforce.com, inc.
    * All rights reserved.
@@ -894,31 +662,149 @@
    * All rights reserved.
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
-   */ function getTextContent(node) {
-      switch(node.nodeType){
-          case ELEMENT_NODE:
-              {
-                  var childNodes = getFilteredChildNodes(node);
-                  var content = "";
-                  for(var i = 0, len = childNodes.length; i < len; i += 1){
-                      var currentNode = childNodes[i];
-                      if (currentNode.nodeType !== COMMENT_NODE) {
-                          content += getTextContent(currentNode);
-                      }
-                  }
-                  return content;
-              }
-          default:
-              return node.nodeValue;
+   */ function getInnerHTML(node) {
+      var s = "";
+      var childNodes = getFilteredChildNodes(node);
+      for(var 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
-   */ var Items$1 = new WeakMap();
-  function StaticNodeList() {
+   */ // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
+  var escapeAttrRegExp = /[&\u00A0"]/g;
+  var escapeDataRegExp = /[&\u00A0<>]/g;
+  var _prototype5 = String.prototype, replace = _prototype5.replace, toLowerCase = _prototype5.toLowerCase;
+  function escapeReplace(c) {
+      switch(c){
+          case "&":
+              return "&amp;";
+          case "<":
+              return "&lt;";
+          case ">":
+              return "&gt;";
+          case '"':
+              return "&quot;";
+          case "\xa0":
+              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
+  var voidElements = new Set([
+      "AREA",
+      "BASE",
+      "BR",
+      "COL",
+      "COMMAND",
+      "EMBED",
+      "HR",
+      "IMG",
+      "INPUT",
+      "KEYGEN",
+      "LINK",
+      "META",
+      "PARAM",
+      "SOURCE",
+      "TRACK",
+      "WBR", 
+  ]);
+  var plaintextParents = new Set([
+      "STYLE",
+      "SCRIPT",
+      "XMP",
+      "IFRAME",
+      "NOEMBED",
+      "NOFRAMES",
+      "PLAINTEXT",
+      "NOSCRIPT", 
+  ]);
+  function getOuterHTML(node) {
+      switch(node.nodeType){
+          case ELEMENT_NODE:
+              {
+                  var attrs = node.attributes;
+                  var tagName = tagNameGetter.call(node);
+                  var s = "<" + toLowerCase.call(tagName);
+                  for(var 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:
+              {
+                  var data = node.data, parentNode = node.parentNode;
+                  if (_instanceof(parentNode, Element) && plaintextParents.has(tagNameGetter.call(parentNode))) {
+                      return data;
+                  }
+                  return escapeData(data);
+              }
+          case CDATA_SECTION_NODE:
+              {
+                  return "<!CDATA[[".concat(node.data, "]]>");
+              }
+          case PROCESSING_INSTRUCTION_NODE:
+              {
+                  return "<?".concat(node.target, " ").concat(node.data, "?>");
+              }
+          case COMMENT_NODE:
+              {
+                  return "<!--".concat(node.data, "-->");
+              }
+          default:
+              {
+                  // intentionally ignoring unknown node types
+                  // Note: since this routine is always invoked for childNodes
+                  // we can safety ignore type 9, 10 and 99 (document, fragment and doctype)
+                  return "";
+              }
+      }
+  }
+  /*
+   * Copyright (c) 2018, salesforce.com, inc.
+   * All rights reserved.
+   * SPDX-License-Identifier: MIT
+   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+   */ function getTextContent(node) {
+      switch(node.nodeType){
+          case ELEMENT_NODE:
+              {
+                  var childNodes = getFilteredChildNodes(node);
+                  var content = "";
+                  for(var i = 0, len = childNodes.length; i < len; i += 1){
+                      var 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
+   */ var Items$1 = new WeakMap();
+  function StaticNodeList() {
       throw new TypeError("Illegal constructor");
   }
   var _obj;
@@ -1030,6 +916,67 @@
       });
       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;
+      var rootNodes = [];
+      var 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
+  var findAncestorHostInImmediateShadowRoot = function(rootNode, targetRootNode) {
+      var host;
+      while(!isUndefined(host = rootNode.host)){
+          var thisRootNode = host.getRootNode();
+          if (thisRootNode === targetRootNode) {
+              return host;
+          }
+          rootNode = thisRootNode;
+      }
+  };
+  function fauxElementsFromPoint(context, doc, left, top) {
+      var elements = elementsFromPoint.call(doc, left, top);
+      var result = [];
+      var 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(var i = 0; i < elements.length; i++){
+              var element = elements[i];
+              if (isSyntheticSlotElement(element)) {
+                  continue;
+              }
+              var 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.
+              var 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.
@@ -1066,166 +1013,48 @@
           writable: true,
           enumerable: true,
           configurable: true,
-          value: function value(name) {
-              if (name === "") {
-                  return null;
-              }
-              var items = Items.get(this);
-              for(var i = 0, len = items.length; i < len; i++){
-                  var item = items[len];
-                  if (name === getAttribute.call(item, "id") || name === getAttribute.call(item, "name")) {
-                      return item;
-                  }
-              }
-              return null;
-          }
-      }
-  }, _defineProperty(_obj1, Symbol.toStringTag, {
-      configurable: true,
-      get: function get() {
-          return "HTMLCollection";
-      }
-  }), // IE11 doesn't support Symbol.toStringTag, in which case we
-  // provide the regular toString method.
-  _defineProperty(_obj1, "toString", {
-      writable: true,
-      configurable: true,
-      value: function value() {
-          return "[object HTMLCollection]";
-      }
-  }), _obj1));
-  // prototype inheritance dance
-  setPrototypeOf(StaticHTMLCollection, HTMLCollection);
-  function createStaticHTMLCollection(items) {
-      var collection = create(StaticHTMLCollection.prototype);
-      Items.set(collection, items);
-      // setting static indexes
-      forEach.call(items, function(item, index) {
-          defineProperty(collection, index, {
-              value: item,
-              enumerable: true,
-              configurable: true
-          });
-      });
-      return collection;
-  }
-  /*
-   * Copyright (c) 2018, salesforce.com, inc.
-   * All rights reserved.
-   * SPDX-License-Identifier: MIT
-   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
-   */ function getInnerHTML(node) {
-      var s = "";
-      var childNodes = getFilteredChildNodes(node);
-      for(var i = 0, len = childNodes.length; i < len; i += 1){
-          s += getOuterHTML(childNodes[i]);
-      }
-      return s;
-  }
-  /*
-   * Copyright (c) 2018, salesforce.com, inc.
-   * All rights reserved.
-   * SPDX-License-Identifier: MIT
-   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
-   */ // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
-  var escapeAttrRegExp = /[&\u00A0"]/g;
-  var escapeDataRegExp = /[&\u00A0<>]/g;
-  var _prototype5 = String.prototype, replace = _prototype5.replace, toLowerCase = _prototype5.toLowerCase;
-  function escapeReplace(c) {
-      switch(c){
-          case "&":
-              return "&amp;";
-          case "<":
-              return "&lt;";
-          case ">":
-              return "&gt;";
-          case '"':
-              return "&quot;";
-          case "\xa0":
-              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
-  var voidElements = new Set([
-      "AREA",
-      "BASE",
-      "BR",
-      "COL",
-      "COMMAND",
-      "EMBED",
-      "HR",
-      "IMG",
-      "INPUT",
-      "KEYGEN",
-      "LINK",
-      "META",
-      "PARAM",
-      "SOURCE",
-      "TRACK",
-      "WBR", 
-  ]);
-  var plaintextParents = new Set([
-      "STYLE",
-      "SCRIPT",
-      "XMP",
-      "IFRAME",
-      "NOEMBED",
-      "NOFRAMES",
-      "PLAINTEXT",
-      "NOSCRIPT", 
-  ]);
-  function getOuterHTML(node) {
-      switch(node.nodeType){
-          case ELEMENT_NODE:
-              {
-                  var attrs = node.attributes;
-                  var tagName = tagNameGetter.call(node);
-                  var s = "<" + toLowerCase.call(tagName);
-                  for(var 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:
-              {
-                  var data = node.data, parentNode = node.parentNode;
-                  if (_instanceof(parentNode, Element) && plaintextParents.has(tagNameGetter.call(parentNode))) {
-                      return data;
-                  }
-                  return escapeData(data);
-              }
-          case CDATA_SECTION_NODE:
-              {
-                  return "<!CDATA[[".concat(node.data, "]]>");
-              }
-          case PROCESSING_INSTRUCTION_NODE:
-              {
-                  return "<?".concat(node.target, " ").concat(node.data, "?>");
-              }
-          case COMMENT_NODE:
-              {
-                  return "<!--".concat(node.data, "-->");
+          value: function value(name) {
+              if (name === "") {
+                  return null;
               }
-          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 "";
+              var items = Items.get(this);
+              for(var i = 0, len = items.length; i < len; i++){
+                  var item = items[len];
+                  if (name === getAttribute.call(item, "id") || name === getAttribute.call(item, "name")) {
+                      return item;
+                  }
               }
+              return null;
+          }
+      }
+  }, _defineProperty(_obj1, Symbol.toStringTag, {
+      configurable: true,
+      get: function get() {
+          return "HTMLCollection";
+      }
+  }), // IE11 doesn't support Symbol.toStringTag, in which case we
+  // provide the regular toString method.
+  _defineProperty(_obj1, "toString", {
+      writable: true,
+      configurable: true,
+      value: function value() {
+          return "[object HTMLCollection]";
       }
+  }), _obj1));
+  // prototype inheritance dance
+  setPrototypeOf(StaticHTMLCollection, HTMLCollection);
+  function createStaticHTMLCollection(items) {
+      var collection = create(StaticHTMLCollection.prototype);
+      Items.set(collection, items);
+      // setting static indexes
+      forEach.call(items, function(item, index) {
+          defineProperty(collection, index, {
+              value: item,
+              enumerable: true,
+              configurable: true
+          });
+      });
+      return collection;
   }
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -1235,7 +1064,7 @@
       });
   }
   var runtimeFlags = _globalThis.lwcRuntimeFlags;
-  /** version: 2.13.0 */ /*
+  /** version: 2.13.1 */ /*
    * Copyright (c) 2018, salesforce.com, inc.
    * All rights reserved.
    * SPDX-License-Identifier: MIT
@@ -1609,61 +1438,232 @@
    * 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 EventListenerMap = new WeakMap();
+  var ComposedPathMap = new WeakMap();
+  function isEventListenerOrEventListenerObject(fnOrObj) {
+      return isFunction(fnOrObj) || isObject(fnOrObj) && !isNull(fnOrObj) && isFunction(fnOrObj.handleEvent);
+  }
+  function shouldInvokeListener(event, target, currentTarget) {
+      // Subsequent logic assumes that `currentTarget` must be contained in the composed path for the listener to be
+      // invoked, but this is not always the case. `composedPath()` will sometimes return an empty array, even when the
+      // listener should be invoked (e.g., a disconnected instance of EventTarget, an instance of XMLHttpRequest, etc).
+      if (target === currentTarget) {
+          return true;
+      }
+      var composedPath1 = ComposedPathMap.get(event);
+      if (isUndefined(composedPath1)) {
+          composedPath1 = event.composedPath();
+          ComposedPathMap.set(event, composedPath1);
+      }
+      return composedPath1.includes(currentTarget);
+  }
+  function getEventListenerWrapper(fnOrObj) {
+      if (!isEventListenerOrEventListenerObject(fnOrObj)) {
+          return fnOrObj;
+      }
+      var wrapperFn = EventListenerMap.get(fnOrObj);
+      if (isUndefined(wrapperFn)) {
+          wrapperFn = function wrapperFn(event) {
+              // This function is invoked from an event listener and currentTarget is always defined.
+              var 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.");
+              }
+              var 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
+   */ var eventToContextMap = new WeakMap();
+  var customElementToWrappedListeners = new WeakMap();
+  function getEventMap(elm) {
+      var 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;
-      var rootNodes = [];
-      var currentRootNode = node.getRootNode();
-      while(!isUndefined(currentRootNode)){
-          rootNodes.push(currentRootNode);
-          currentRootNode = (_a = currentRootNode.host) === null || _a === void 0 ? void 0 : _a.getRootNode();
+      return (_a = eventToShadowRootMap.get(event)) !== null && _a !== void 0 ? _a : eventTargetGetter.call(event);
+  }
+  var shadowRootEventListenerMap = new WeakMap();
+  function getWrappedShadowRootListener(listener) {
+      if (!isFunction(listener)) {
+          throw new TypeError(); // avoiding problems with non-valid listeners
       }
-      return rootNodes;
+      var shadowRootWrappedListener = shadowRootEventListenerMap.get(listener);
+      if (isUndefined(shadowRootWrappedListener)) {
+          shadowRootWrappedListener = function shadowRootWrappedListener(event) {
+              // currentTarget is always defined inside an event listener
+              var 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);
+              }
+              var actualTarget = getActualTarget(event);
+              if (shouldInvokeListener(event, actualTarget, currentTarget)) {
+                  listener.call(currentTarget, event);
+              }
+          };
+          shadowRootWrappedListener.placement = 1 /* SHADOW_ROOT_LISTENER */ ;
+          shadowRootEventListenerMap.set(listener, shadowRootWrappedListener);
+      }
+      return shadowRootWrappedListener;
   }
-  // Keep searching up the host tree until we find an element that is within the immediate shadow root
-  var findAncestorHostInImmediateShadowRoot = function(rootNode, targetRootNode) {
-      var host;
-      while(!isUndefined(host = rootNode.host)){
-          var thisRootNode = host.getRootNode();
-          if (thisRootNode === targetRootNode) {
-              return host;
+  var customElementEventListenerMap = new WeakMap();
+  function getWrappedCustomElementListener(listener) {
+      if (!isFunction(listener)) {
+          throw new TypeError(); // avoiding problems with non-valid listeners
+      }
+      var customElementWrappedListener = customElementEventListenerMap.get(listener);
+      if (isUndefined(customElementWrappedListener)) {
+          customElementWrappedListener = function customElementWrappedListener(event) {
+              // currentTarget is always defined inside an event listener
+              var currentTarget = eventCurrentTargetGetter.call(event);
+              var actualTarget = getActualTarget(event);
+              if (shouldInvokeListener(event, actualTarget, currentTarget)) {
+                  listener.call(currentTarget, event);
+              }
+          };
+          customElementWrappedListener.placement = 0 /* CUSTOM_ELEMENT_LISTENER */ ;
+          customElementEventListenerMap.set(listener, customElementWrappedListener);
+      }
+      return customElementWrappedListener;
+  }
+  function domListener(evt) {
+      var invokeListenersByPlacement = function invokeListenersByPlacement(placement) {
+          forEach.call(bookkeeping, function(listener) {
+              if (isFalse(immediatePropagationStopped) && listener.placement === placement) {
+                  // making sure that the listener was not removed from the original listener queue
+                  if (ArrayIndexOf.call(listeners, listener) !== -1) {
+                      // all handlers on the custom element should be called with undefined 'this'
+                      listener.call(undefined, evt);
+                  }
+              }
+          });
+      };
+      var immediatePropagationStopped = false;
+      var propagationStopped = false;
+      var type = evt.type, stopImmediatePropagation = evt.stopImmediatePropagation, stopPropagation = evt.stopPropagation;
+      // currentTarget is always defined
+      var currentTarget = eventCurrentTargetGetter.call(evt);
+      var listenerMap = getEventMap(currentTarget);
+      var listeners = listenerMap[type]; // it must have listeners at this point
+      defineProperty(evt, "stopImmediatePropagation", {
+          value: function value() {
+              immediatePropagationStopped = true;
+              stopImmediatePropagation.call(evt);
+          },
+          writable: true,
+          enumerable: true,
+          configurable: true
+      });
+      defineProperty(evt, "stopPropagation", {
+          value: function value() {
+              propagationStopped = true;
+              stopPropagation.call(evt);
+          },
+          writable: true,
+          enumerable: true,
+          configurable: true
+      });
+      // in case a listener adds or removes other listeners during invocation
+      var bookkeeping = ArraySlice.call(listeners);
+      eventToContextMap.set(evt, 1 /* SHADOW_ROOT_LISTENER */ );
+      invokeListenersByPlacement(1 /* SHADOW_ROOT_LISTENER */ );
+      if (isFalse(immediatePropagationStopped) && isFalse(propagationStopped)) {
+          // doing the second iteration only if the first one didn't interrupt the event propagation
+          eventToContextMap.set(evt, 0 /* CUSTOM_ELEMENT_LISTENER */ );
+          invokeListenersByPlacement(0 /* CUSTOM_ELEMENT_LISTENER */ );
+      }
+      eventToContextMap.set(evt, 2 /* UNKNOWN_LISTENER */ );
+  }
+  function attachDOMListener(elm, type, wrappedListener) {
+      var listenerMap = getEventMap(elm);
+      var cmpEventHandlers = listenerMap[type];
+      if (isUndefined(cmpEventHandlers)) {
+          cmpEventHandlers = listenerMap[type] = [];
+      }
+      // Prevent identical listeners from subscribing to the same event type.
+      // TODO [#1824]: Options will also play a factor when we introduce support for them (#1824).
+      if (ArrayIndexOf.call(cmpEventHandlers, wrappedListener) !== -1) {
+          return;
+      }
+      // only add to DOM if there is no other listener on the same placement yet
+      if (cmpEventHandlers.length === 0) {
+          // super.addEventListener() - this will not work on
+          addEventListener.call(elm, type, domListener);
+      }
+      ArrayPush.call(cmpEventHandlers, wrappedListener);
+  }
+  function detachDOMListener(elm, type, wrappedListener) {
+      var listenerMap = getEventMap(elm);
+      var p;
+      var listeners;
+      if (!isUndefined(listeners = listenerMap[type]) && (p = ArrayIndexOf.call(listeners, wrappedListener)) !== -1) {
+          ArraySplice.call(listeners, p, 1);
+          // only remove from DOM if there is no other listener on the same placement
+          if (listeners.length === 0) {
+              removeEventListener.call(elm, type, domListener);
           }
-          rootNode = thisRootNode;
       }
-  };
-  function fauxElementsFromPoint(context, doc, left, top) {
-      var elements = elementsFromPoint.call(doc, left, top);
-      var result = [];
-      var 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(var i = 0; i < elements.length; i++){
-              var element = elements[i];
-              if (isSyntheticSlotElement(element)) {
-                  continue;
-              }
-              var 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.
-              var ancestorHost = findAncestorHostInImmediateShadowRoot(elementRootNode, rootNodes[0]);
-              if (!isUndefined(ancestorHost) && ArrayIndexOf.call(elements, ancestorHost) === -1 && ArrayIndexOf.call(result, ancestorHost) === -1) {
-                  ArrayPush.call(result, ancestorHost);
-              }
+  }
+  function addCustomElementEventListener(type, listener, _options) {
+      if (process.env.NODE_ENV !== "production") {
+          if (!isFunction(listener)) {
+              throw new TypeError("Invalid second argument for Element.addEventListener() in ".concat(toString(this), ' for event "').concat(type, '". Expected an EventListener but received ').concat(listener, "."));
+          }
+      }
+      // TODO [#1824]: Lift this restriction on the option parameter
+      if (isFunction(listener)) {
+          var wrappedListener = getWrappedCustomElementListener(listener);
+          attachDOMListener(this, type, wrappedListener);
+      }
+  }
+  function removeCustomElementEventListener(type, listener, _options) {
+      // TODO [#1824]: Lift this restriction on the option parameter
+      if (isFunction(listener)) {
+          var wrappedListener = getWrappedCustomElementListener(listener);
+          detachDOMListener(this, type, wrappedListener);
+      }
+  }
+  function addShadowRootEventListener(sr, type, listener, _options) {
+      if (process.env.NODE_ENV !== "production") {
+          if (!isFunction(listener)) {
+              throw new TypeError("Invalid second argument for ShadowRoot.addEventListener() in ".concat(toString(sr), ' for event "').concat(type, '". Expected an EventListener but received ').concat(listener, "."));
           }
       }
-      return result;
+      // TODO [#1824]: Lift this restriction on the option parameter
+      if (isFunction(listener)) {
+          var elm = getHost(sr);
+          var wrappedListener = getWrappedShadowRootListener(listener);
+          attachDOMListener(elm, type, wrappedListener);
+      }
+  }
+  function removeShadowRootEventListener(sr, type, listener, _options) {
+      // TODO [#1824]: Lift this restriction on the option parameter
+      if (isFunction(listener)) {
+          var elm = getHost(sr);
+          var wrappedListener = getWrappedShadowRootListener(listener);
+          detachDOMListener(elm, type, wrappedListener);
+      }
   }
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -3748,52 +3748,236 @@
           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: function value() {
-                  var elements = arrayFromCollection(getElementsByClassName$1.apply(this, ArraySlice.call(arguments)));
-                  if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
-                      return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
-                  }
-                  var filteredResults = getFilteredArrayOfNodes(this, elements, 1);
-                  return createStaticHTMLCollection(filteredResults);
-              },
-              writable: true,
-              enumerable: true,
-              configurable: true
-          },
-          getElementsByTagName: {
-              value: function value() {
-                  var elements = arrayFromCollection(getElementsByTagName$1.apply(this, ArraySlice.call(arguments)));
-                  if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
-                      return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
-                  }
-                  var filteredResults = getFilteredArrayOfNodes(this, elements, 1);
-                  return createStaticHTMLCollection(filteredResults);
-              },
-              writable: true,
-              enumerable: true,
-              configurable: true
-          },
-          getElementsByTagNameNS: {
-              value: function value() {
-                  var elements = arrayFromCollection(getElementsByTagNameNS$1.apply(this, ArraySlice.call(arguments)));
-                  if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
-                      return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
+  }); // 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: function value() {
+                  var elements = arrayFromCollection(getElementsByClassName$1.apply(this, ArraySlice.call(arguments)));
+                  if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
+                      return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
+                  }
+                  var filteredResults = getFilteredArrayOfNodes(this, elements, 1);
+                  return createStaticHTMLCollection(filteredResults);
+              },
+              writable: true,
+              enumerable: true,
+              configurable: true
+          },
+          getElementsByTagName: {
+              value: function value() {
+                  var elements = arrayFromCollection(getElementsByTagName$1.apply(this, ArraySlice.call(arguments)));
+                  if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
+                      return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
+                  }
+                  var filteredResults = getFilteredArrayOfNodes(this, elements, 1);
+                  return createStaticHTMLCollection(filteredResults);
+              },
+              writable: true,
+              enumerable: true,
+              configurable: true
+          },
+          getElementsByTagNameNS: {
+              value: function value() {
+                  var elements = arrayFromCollection(getElementsByTagNameNS$1.apply(this, ArraySlice.call(arguments)));
+                  if (!runtimeFlags.ENABLE_HTML_COLLECTIONS_PATCH) {
+                      return createStaticHTMLCollection(getNonPatchedFilteredArrayOfNodes(this, elements));
+                  }
+                  var filteredResults = getFilteredArrayOfNodes(this, elements, 1);
+                  return createStaticHTMLCollection(filteredResults);
+              },
+              writable: true,
+              enumerable: true,
+              configurable: true
+          }
+      });
+  } // IE11 extra patches for wrong prototypes
+  if (hasOwnProperty.call(HTMLElement.prototype, "getElementsByClassName")) {
+      defineProperty(HTMLElement.prototype, "getElementsByClassName", getOwnPropertyDescriptor(Element.prototype, "getElementsByClassName"));
+  }
+  /*
+   * Copyright (c) 2018, salesforce.com, inc.
+   * All rights reserved.
+   * SPDX-License-Identifier: MIT
+   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+   */ function getElementComputedStyle(element) {
+      var win = getOwnerWindow(element);
+      return windowGetComputedStyle.call(win, element);
+  }
+  function getWindowSelection(node) {
+      var win = getOwnerWindow(node);
+      return windowGetSelection.call(win);
+  }
+  function nodeIsBeingRendered(nodeComputedStyle) {
+      return nodeComputedStyle.visibility === "visible" && nodeComputedStyle.display !== "none";
+  }
+  function getSelectionState(element) {
+      var win = getOwnerWindow(element);
+      var selection = getWindowSelection(element);
+      if (selection === null) {
+          return null;
+      }
+      var ranges = [];
+      for(var i = 0; i < selection.rangeCount; i++){
+          ranges.push(selection.getRangeAt(i));
+      }
+      var state = {
+          element: element,
+          onselect: win.onselect,
+          onselectstart: win.onselectstart,
+          onselectionchange: win.onselectionchange,
+          ranges: ranges
+      };
+      win.onselect = null;
+      win.onselectstart = null;
+      win.onselectionchange = null;
+      return state;
+  }
+  function restoreSelectionState(state) {
+      if (state === null) {
+          return;
+      }
+      var element = state.element, onselect = state.onselect, onselectstart = state.onselectstart, onselectionchange = state.onselectionchange, ranges = state.ranges;
+      var win = getOwnerWindow(element);
+      var selection = getWindowSelection(element);
+      selection.removeAllRanges();
+      for(var i = 0; i < ranges.length; i++){
+          selection.addRange(ranges[i]);
+      }
+      win.onselect = onselect;
+      win.onselectstart = onselectstart;
+      win.onselectionchange = onselectionchange;
+  }
+  /**
+   * Gets the "innerText" of a text node using the Selection API
+   *
+   * NOTE: For performance reasons, since this function will be called multiple times while calculating the innerText of
+   *       an element, it does not restore the current selection.
+   */ function getTextNodeInnerText(textNode) {
+      var selection = getWindowSelection(textNode);
+      if (selection === null) {
+          return textNode.textContent || "";
+      }
+      var range = document.createRange();
+      range.selectNodeContents(textNode);
+      var domRect = range.getBoundingClientRect();
+      if (domRect.height <= 0 || domRect.width <= 0) {
+          // the text node is not rendered
+          return "";
+      }
+      // Needed to remove non rendered characters from the text node.
+      selection.removeAllRanges();
+      selection.addRange(range);
+      var selectionText = selection.toString();
+      // The textNode is visible, but it may not be selectable. When the text is not selectable,
+      // textContent is the nearest approximation to innerText.
+      return selectionText ? selectionText : textNode.textContent || "";
+  }
+  var nodeIsElement = function(node) {
+      return node.nodeType === ELEMENT_NODE;
+  };
+  var nodeIsText = function(node) {
+      return node.nodeType === TEXT_NODE;
+  };
+  /**
+   * Spec: https://html.spec.whatwg.org/multipage/dom.html#inner-text-collection-steps
+   * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1132
+   */ function innerTextCollectionSteps(node) {
+      var items = [];
+      if (nodeIsElement(node)) {
+          var tagName = node.tagName;
+          var computedStyle = getElementComputedStyle(node);
+          if (tagName === "OPTION") {
+              // For options, is hard to get the "rendered" text, let's use the original getter.
+              return [
+                  1,
+                  innerTextGetter.call(node),
+                  1
+              ];
+          } else if (tagName === "TEXTAREA") {
+              return [];
+          } else {
+              var childNodes = node.childNodes;
+              for(var i = 0, n = childNodes.length; i < n; i++){
+                  ArrayPush.apply(items, innerTextCollectionSteps(childNodes[i]));
+              }
+          }
+          if (!nodeIsBeingRendered(computedStyle)) {
+              if (tagName === "SELECT" || tagName === "DATALIST") {
+                  // the select is either: .visibility != 'visible' or .display === hidden, therefore this select should
+                  // not display any value.
+                  return [];
+              }
+              return items;
+          }
+          if (tagName === "BR") {
+              items.push("\n" /* line feed */ );
+          }
+          var display = computedStyle.display;
+          if (display === "table-cell") {
+              // omitting case: and node's CSS box is not the last 'table-cell' box of its enclosing 'table-row' box
+              items.push("	" /* tab */ );
+          }
+          if (display === "table-row") {
+              // omitting case: and node's CSS box is not the last 'table-row' box of the nearest ancestor 'table' box
+              items.push("\n" /* line feed */ );
+          }
+          if (tagName === "P") {
+              items.unshift(2);
+              items.push(2);
+          }
+          if (display === "block" || display === "table-caption" || display === "flex" || display === "table") {
+              items.unshift(1);
+              items.push(1);
+          }
+      } else if (nodeIsText(node)) {
+          items.push(getTextNodeInnerText(node));
+      }
+      return items;
+  }
+  /**
+   * InnerText getter spec: https://html.spec.whatwg.org/multipage/dom.html#the-innertext-idl-attribute
+   *
+   * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1087
+   */ function getInnerText(element) {
+      var thisComputedStyle = getElementComputedStyle(element);
+      if (!nodeIsBeingRendered(thisComputedStyle)) {
+          return getTextContent(element) || "";
+      }
+      var selectionState = getSelectionState(element);
+      var results = [];
+      var childNodes = element.childNodes;
+      for(var i = 0, n = childNodes.length; i < n; i++){
+          ArrayPush.apply(results, innerTextCollectionSteps(childNodes[i]));
+      }
+      restoreSelectionState(selectionState);
+      var elementInnerText = "";
+      var maxReqLineBreakCount = 0;
+      for(var i1 = 0, n1 = results.length; i1 < n1; i1++){
+          var item = results[i1];
+          if (typeof item === "string") {
+              if (maxReqLineBreakCount > 0) {
+                  for(var j = 0; j < maxReqLineBreakCount; j++){
+                      elementInnerText += "\n";
                   }
-                  var filteredResults = getFilteredArrayOfNodes(this, elements, 1);
-                  return createStaticHTMLCollection(filteredResults);
-              },
-              writable: true,
-              enumerable: true,
-              configurable: true
+                  maxReqLineBreakCount = 0;
+              }
+              if (item.length > 0) {
+                  elementInnerText += item;
+              }
+          } else {
+              if (elementInnerText.length == 0) {
+                  continue;
+              }
+              // Store the count if it's the max of this run,
+              // but it may be ignored if no text item is found afterwards,
+              // which means that these are consecutive line breaks at the end.
+              if (item > maxReqLineBreakCount) {
+                  maxReqLineBreakCount = item;
+              }
           }
-      });
-  } // IE11 extra patches for wrong prototypes
-  if (hasOwnProperty.call(HTMLElement.prototype, "getElementsByClassName")) {
-      defineProperty(HTMLElement.prototype, "getElementsByClassName", getOwnPropertyDescriptor(Element.prototype, "getElementsByClassName"));
+      }
+      return elementInnerText;
   }
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -4119,190 +4303,6 @@
   function ignoreFocusIn(elm) {
       removeEventListener.call(elm, "focusin", skipShadowHandler, true);
   }
-  /*
-   * Copyright (c) 2018, salesforce.com, inc.
-   * All rights reserved.
-   * SPDX-License-Identifier: MIT
-   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
-   */ function getElementComputedStyle(element) {
-      var win = getOwnerWindow(element);
-      return windowGetComputedStyle.call(win, element);
-  }
-  function getWindowSelection(node) {
-      var win = getOwnerWindow(node);
-      return windowGetSelection.call(win);
-  }
-  function nodeIsBeingRendered(nodeComputedStyle) {
-      return nodeComputedStyle.visibility === "visible" && nodeComputedStyle.display !== "none";
-  }
-  function getSelectionState(element) {
-      var win = getOwnerWindow(element);
-      var selection = getWindowSelection(element);
-      if (selection === null) {
-          return null;
-      }
-      var ranges = [];
-      for(var i = 0; i < selection.rangeCount; i++){
-          ranges.push(selection.getRangeAt(i));
-      }
-      var state = {
-          element: element,
-          onselect: win.onselect,
-          onselectstart: win.onselectstart,
-          onselectionchange: win.onselectionchange,
-          ranges: ranges
-      };
-      win.onselect = null;
-      win.onselectstart = null;
-      win.onselectionchange = null;
-      return state;
-  }
-  function restoreSelectionState(state) {
-      if (state === null) {
-          return;
-      }
-      var element = state.element, onselect = state.onselect, onselectstart = state.onselectstart, onselectionchange = state.onselectionchange, ranges = state.ranges;
-      var win = getOwnerWindow(element);
-      var selection = getWindowSelection(element);
-      selection.removeAllRanges();
-      for(var i = 0; i < ranges.length; i++){
-          selection.addRange(ranges[i]);
-      }
-      win.onselect = onselect;
-      win.onselectstart = onselectstart;
-      win.onselectionchange = onselectionchange;
-  }
-  /**
-   * Gets the "innerText" of a text node using the Selection API
-   *
-   * NOTE: For performance reasons, since this function will be called multiple times while calculating the innerText of
-   *       an element, it does not restore the current selection.
-   */ function getTextNodeInnerText(textNode) {
-      var selection = getWindowSelection(textNode);
-      if (selection === null) {
-          return textNode.textContent || "";
-      }
-      var range = document.createRange();
-      range.selectNodeContents(textNode);
-      var domRect = range.getBoundingClientRect();
-      if (domRect.height <= 0 || domRect.width <= 0) {
-          // the text node is not rendered
-          return "";
-      }
-      // Needed to remove non rendered characters from the text node.
-      selection.removeAllRanges();
-      selection.addRange(range);
-      var selectionText = selection.toString();
-      // The textNode is visible, but it may not be selectable. When the text is not selectable,
-      // textContent is the nearest approximation to innerText.
-      return selectionText ? selectionText : textNode.textContent || "";
-  }
-  var nodeIsElement = function(node) {
-      return node.nodeType === ELEMENT_NODE;
-  };
-  var nodeIsText = function(node) {
-      return node.nodeType === TEXT_NODE;
-  };
-  /**
-   * Spec: https://html.spec.whatwg.org/multipage/dom.html#inner-text-collection-steps
-   * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1132
-   */ function innerTextCollectionSteps(node) {
-      var items = [];
-      if (nodeIsElement(node)) {
-          var tagName = node.tagName;
-          var computedStyle = getElementComputedStyle(node);
-          if (tagName === "OPTION") {
-              // For options, is hard to get the "rendered" text, let's use the original getter.
-              return [
-                  1,
-                  innerTextGetter.call(node),
-                  1
-              ];
-          } else if (tagName === "TEXTAREA") {
-              return [];
-          } else {
-              var childNodes = node.childNodes;
-              for(var i = 0, n = childNodes.length; i < n; i++){
-                  ArrayPush.apply(items, innerTextCollectionSteps(childNodes[i]));
-              }
-          }
-          if (!nodeIsBeingRendered(computedStyle)) {
-              if (tagName === "SELECT" || tagName === "DATALIST") {
-                  // the select is either: .visibility != 'visible' or .display === hidden, therefore this select should
-                  // not display any value.
-                  return [];
-              }
-              return items;
-          }
-          if (tagName === "BR") {
-              items.push("\n" /* line feed */ );
-          }
-          var display = computedStyle.display;
-          if (display === "table-cell") {
-              // omitting case: and node's CSS box is not the last 'table-cell' box of its enclosing 'table-row' box
-              items.push("	" /* tab */ );
-          }
-          if (display === "table-row") {
-              // omitting case: and node's CSS box is not the last 'table-row' box of the nearest ancestor 'table' box
-              items.push("\n" /* line feed */ );
-          }
-          if (tagName === "P") {
-              items.unshift(2);
-              items.push(2);
-          }
-          if (display === "block" || display === "table-caption" || display === "flex" || display === "table") {
-              items.unshift(1);
-              items.push(1);
-          }
-      } else if (nodeIsText(node)) {
-          items.push(getTextNodeInnerText(node));
-      }
-      return items;
-  }
-  /**
-   * InnerText getter spec: https://html.spec.whatwg.org/multipage/dom.html#the-innertext-idl-attribute
-   *
-   * One spec implementation: https://github.com/servo/servo/blob/721271dcd3c20db5ca8cf146e2b5907647afb4d6/components/layout/query.rs#L1087
-   */ function getInnerText(element) {
-      var thisComputedStyle = getElementComputedStyle(element);
-      if (!nodeIsBeingRendered(thisComputedStyle)) {
-          return getTextContent(element) || "";
-      }
-      var selectionState = getSelectionState(element);
-      var results = [];
-      var childNodes = element.childNodes;
-      for(var i = 0, n = childNodes.length; i < n; i++){
-          ArrayPush.apply(results, innerTextCollectionSteps(childNodes[i]));
-      }
-      restoreSelectionState(selectionState);
-      var elementInnerText = "";
-      var maxReqLineBreakCount = 0;
-      for(var i1 = 0, n1 = results.length; i1 < n1; i1++){
-          var item = results[i1];
-          if (typeof item === "string") {
-              if (maxReqLineBreakCount > 0) {
-                  for(var j = 0; j < maxReqLineBreakCount; j++){
-                      elementInnerText += "\n";
-                  }
-                  maxReqLineBreakCount = 0;
-              }
-              if (item.length > 0) {
-                  elementInnerText += item;
-              }
-          } else {
-              if (elementInnerText.length == 0) {
-                  continue;
-              }
-              // Store the count if it's the max of this run,
-              // but it may be ignored if no text item is found afterwards,
-              // which means that these are consecutive line breaks at the end.
-              if (item > maxReqLineBreakCount) {
-                  maxReqLineBreakCount = item;
-              }
-          }
-      }
-      return elementInnerText;
-  }
   /*
    * Copyright (c) 2018, salesforce.com, inc.
    * All rights reserved.
@@ -4637,6 +4637,6 @@
           return this[DomManualPrivateKey];
       },
       configurable: true
-  }); /** version: 2.13.0 */
+  }); /** version: 2.13.1 */
 
 })();