lwc 2.13.0 → 2.13.3

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

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