lwc 2.34.0 → 2.35.1

package/dist/engine-dom/iife/es2017/engine-dom.js

@@ -48,7 +48,7 @@ var LWC = (function (exports) {
   const { isArray: isArray$1 } = Array;
   const { concat: ArrayConcat$1, copyWithin: ArrayCopyWithin, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush$1, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, } = Array.prototype;
   const { fromCharCode: StringFromCharCode } = String;
-  const { charCodeAt: StringCharCodeAt, replace: StringReplace, slice: StringSlice, toLowerCase: StringToLowerCase, } = String.prototype;
+  const { charCodeAt: StringCharCodeAt, replace: StringReplace, split: StringSplit, slice: StringSlice, toLowerCase: StringToLowerCase, } = String.prototype;
   function isUndefined$1(obj) {
       return obj === undefined;
   }
@@ -185,6 +185,19 @@ var LWC = (function (exports) {
       });
       return { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap };
   })();
+  // These attributes take either an ID or a list of IDs as values.
+  // This includes aria-* attributes as well as the special non-ARIA "for" attribute
+  const ID_REFERENCING_ATTRIBUTES_SET = new Set([
+      'aria-activedescendant',
+      'aria-controls',
+      'aria-describedby',
+      'aria-details',
+      'aria-errormessage',
+      'aria-flowto',
+      'aria-labelledby',
+      'aria-owns',
+      'for',
+  ]);
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -192,41 +205,11 @@ var LWC = (function (exports) {
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  // Inspired from: https://mathiasbynens.be/notes/globalthis
-  const _globalThis = /*@__PURE__*/ (function () {
-      // On recent browsers, `globalThis` is already defined. In this case return it directly.
-      if (typeof globalThis === 'object') {
-          return globalThis;
-      }
-      let _globalThis;
-      try {
-          // eslint-disable-next-line no-extend-native
-          Object.defineProperty(Object.prototype, '__magic__', {
-              get: function () {
-                  return this;
-              },
-              configurable: true,
-          });
-          // __magic__ is undefined in Safari 10 and IE10 and older.
-          // @ts-ignore
-          // eslint-disable-next-line no-undef
-          _globalThis = __magic__;
-          // @ts-ignore
-          delete Object.prototype.__magic__;
-      }
-      catch (ex) {
-          // In IE8, Object.defineProperty only works on DOM objects.
-      }
-      finally {
-          // If the magic above fails for some reason we assume that we are in a legacy browser.
-          // Assume `window` exists in this case.
-          if (typeof _globalThis === 'undefined') {
-              // @ts-ignore
-              _globalThis = window;
-          }
-      }
-      return _globalThis;
-  })();
+  // See browser support for globalThis:
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
+  /* istanbul ignore next */
+  // @ts-ignore
+  const _globalThis = typeof globalThis === 'object' ? globalThis : window;
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -240,6 +223,8 @@ var LWC = (function (exports) {
   const KEY__SHADOW_TOKEN = '$shadowToken$';
   const KEY__SYNTHETIC_MODE = '$$lwc-synthetic-mode';
   const KEY__SCOPED_CSS = '$scoped$';
+  const KEY__NATIVE_GET_ELEMENT_BY_ID = '$nativeGetElementById$';
+  const KEY__NATIVE_QUERY_SELECTOR_ALL = '$nativeQuerySelectorAll$';
   const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
   const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
   const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
@@ -347,9 +332,9 @@ var LWC = (function (exports) {
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // Increment whenever the LWC template compiler changes
-  const LWC_VERSION = "2.34.0";
+  const LWC_VERSION = "2.35.1";
   const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-  /** version: 2.34.0 */
+  /** version: 2.35.1 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -402,7 +387,8 @@ var LWC = (function (exports) {
           console.warn(`Failed to set the value "${value}" for the runtime feature flag "${name}" because it is undefined. Available flags: ${availableFlags}.`);
           return;
       }
-      if (process.env.NODE_ENV !== 'production') {
+      // This may seem redundant, but `process.env.NODE_ENV === 'test-karma-lwc'` is replaced by Karma tests
+      if (process.env.NODE_ENV === 'test-karma-lwc' || process.env.NODE_ENV !== 'production') {
           // Allow the same flag to be set more than once outside of production to enable testing
           lwcRuntimeFlags[name] = value;
       }
@@ -422,11 +408,12 @@ var LWC = (function (exports) {
    * purposes. It is a no-op when invoked in production mode.
    */
   function setFeatureFlagForTest(name, value) {
-      if (process.env.NODE_ENV !== 'production') {
+      // This may seem redundant, but `process.env.NODE_ENV === 'test-karma-lwc'` is replaced by Karma tests
+      if (process.env.NODE_ENV === 'test-karma-lwc' || process.env.NODE_ENV !== 'production') {
           setFeatureFlag(name, value);
       }
   }
-  /** version: 2.34.0 */
+  /** version: 2.35.1 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -490,7 +477,7 @@ var LWC = (function (exports) {
           }
       }
   }
-  /** version: 2.34.0 */
+  /** version: 2.35.1 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -511,8 +498,7 @@ var LWC = (function (exports) {
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // Only used in LWC's Karma tests
-  // @ts-ignore
-  if (process.env.NODE_ENV !== 'production' && typeof __karma__ !== 'undefined') {
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
     window.addEventListener('test-dummy-flag', () => {
       let hasFlag = false;
       if (lwcRuntimeFlags.DUMMY_TEST_FLAG) {
@@ -536,8 +522,7 @@ var LWC = (function (exports) {
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // Only used in LWC's Karma tests
-  // @ts-ignore
-  if (process.env.NODE_ENV !== 'production' && typeof __karma__ !== 'undefined') {
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
     window.addEventListener('test-dummy-flag', () => {
       let hasFlag = false;
       if (lwcRuntimeFlags.DUMMY_TEST_FLAG) {
@@ -558,94 +543,167 @@ var LWC = (function (exports) {
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  let nextTickCallbackQueue = [];
-  const SPACE_CHAR = 32;
-  const EmptyObject = seal(create(null));
-  const EmptyArray = seal([]);
-  function flushCallbackQueue() {
-      if (process.env.NODE_ENV !== 'production') {
-          if (nextTickCallbackQueue.length === 0) {
-              throw new Error(`Internal Error: If callbackQueue is scheduled, it is because there must be at least one callback on this pending queue.`);
+  /** Callbacks to invoke when reporting is enabled **/
+  const onReportingEnabledCallbacks = [];
+  /** The currently assigned reporting dispatcher. */
+  let currentDispatcher$1 = noop;
+  /**
+   * Whether reporting is enabled.
+   *
+   * Note that this may seem redundant, given you can just check if the currentDispatcher is undefined,
+   * but it turns out that Terser only strips out unused code if we use this explicit boolean.
+   */
+  let enabled$1 = false;
+  const reportingControl = {
+      /**
+       * Attach a new reporting control (aka dispatcher).
+       *
+       * @param dispatcher - reporting control
+       */
+      attachDispatcher(dispatcher) {
+          enabled$1 = true;
+          currentDispatcher$1 = dispatcher;
+          for (const callback of onReportingEnabledCallbacks) {
+              try {
+                  callback();
+              }
+              catch (err) {
+                  // This should never happen. But if it does, we don't want one callback to cause another to fail
+                  // eslint-disable-next-line no-console
+                  console.error('Could not invoke callback', err);
+              }
           }
+          onReportingEnabledCallbacks.length = 0; // clear the array
+      },
+      /**
+       * Detach the current reporting control (aka dispatcher).
+       */
+      detachDispatcher() {
+          enabled$1 = false;
+          currentDispatcher$1 = noop;
+      },
+  };
+  /**
+   * Call a callback when reporting is enabled, or immediately if reporting is already enabled.
+   * Will only ever be called once.
+   * @param callback
+   */
+  function onReportingEnabled(callback) {
+      if (enabled$1) {
+          // call immediately
+          callback();
       }
-      const callbacks = nextTickCallbackQueue;
-      nextTickCallbackQueue = []; // reset to a new queue
-      for (let i = 0, len = callbacks.length; i < len; i += 1) {
-          callbacks[i]();
+      else {
+          // call later
+          onReportingEnabledCallbacks.push(callback);
       }
   }
-  function addCallbackToNextTick(callback) {
-      if (process.env.NODE_ENV !== 'production') {
-          if (!isFunction$1(callback)) {
-              throw new Error(`Internal Error: addCallbackToNextTick() can only accept a function callback`);
-          }
-      }
-      if (nextTickCallbackQueue.length === 0) {
-          Promise.resolve().then(flushCallbackQueue);
+  /**
+   * Report to the current dispatcher, if there is one.
+   * @param reportingEventId
+   * @param vm
+   */
+  function report(reportingEventId, vm) {
+      if (enabled$1) {
+          currentDispatcher$1(reportingEventId, vm.tagName, vm.idx);
       }
-      ArrayPush$1.call(nextTickCallbackQueue, callback);
   }
-  function guid() {
-      function s4() {
-          return Math.floor((1 + Math.random()) * 0x10000)
-              .toString(16)
-              .substring(1);
+
+  /*
+   * Copyright (c) 2018, salesforce.com, inc.
+   * All rights reserved.
+   * SPDX-License-Identifier: MIT
+   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+   */
+  function getComponentTag(vm) {
+      return `<${StringToLowerCase.call(vm.tagName)}>`;
+  }
+  // TODO [#1695]: Unify getComponentStack and getErrorComponentStack
+  function getComponentStack(vm) {
+      const stack = [];
+      let prefix = '';
+      while (!isNull(vm.owner)) {
+          ArrayPush$1.call(stack, prefix + getComponentTag(vm));
+          vm = vm.owner;
+          prefix += '\t';
       }
-      return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+      return ArrayJoin.call(stack, '\n');
   }
-  // Borrowed from Vue template compiler.
-  // https://github.com/vuejs/vue/blob/531371b818b0e31a989a06df43789728f23dc4e8/src/platforms/web/util/style.js#L5-L16
-  const DECLARATION_DELIMITER = /;(?![^(]*\))/g;
-  const PROPERTY_DELIMITER = /:(.+)/;
-  function parseStyleText(cssText) {
-      const styleMap = {};
-      const declarations = cssText.split(DECLARATION_DELIMITER);
-      for (const declaration of declarations) {
-          if (declaration) {
-              const [prop, value] = declaration.split(PROPERTY_DELIMITER);
-              if (prop !== undefined && value !== undefined) {
-                  styleMap[prop.trim()] = value.trim();
-              }
-          }
+  function getErrorComponentStack(vm) {
+      const wcStack = [];
+      let currentVm = vm;
+      while (!isNull(currentVm)) {
+          ArrayPush$1.call(wcStack, getComponentTag(currentVm));
+          currentVm = currentVm.owner;
       }
-      return styleMap;
+      return wcStack.reverse().join('\n\t');
   }
-  // Make a shallow copy of an object but omit the given key
-  function cloneAndOmitKey(object, keyToOmit) {
-      const result = {};
-      for (const key of Object.keys(object)) {
-          if (key !== keyToOmit) {
-              result[key] = object[key];
-          }
+
+  /*
+   * 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 addErrorComponentStack(vm, error) {
+      if (!isFrozen(error) && isUndefined$1(error.wcStack)) {
+          const wcStack = getErrorComponentStack(vm);
+          defineProperty(error, 'wcStack', {
+              get() {
+                  return wcStack;
+              },
+          });
       }
-      return result;
   }
-  function flattenStylesheets(stylesheets) {
-      const list = [];
-      for (const stylesheet of stylesheets) {
-          if (!Array.isArray(stylesheet)) {
-              list.push(stylesheet);
-          }
-          else {
-              list.push(...flattenStylesheets(stylesheet));
+
+  /*
+   * 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 alreadyLoggedMessages = new Set();
+  // Only used in LWC's Karma tests
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
+      // @ts-ignore
+      window.__lwcResetAlreadyLoggedMessages = () => {
+          alreadyLoggedMessages.clear();
+      };
+  }
+  function log(method, message, vm, once) {
+      let msg = `[LWC ${method}]: ${message}`;
+      if (!isUndefined$1(vm)) {
+          msg = `${msg}\n${getComponentStack(vm)}`;
+      }
+      if (once) {
+          if (alreadyLoggedMessages.has(msg)) {
+              return;
           }
+          alreadyLoggedMessages.add(msg);
       }
-      return list;
-  }
-  // Set a ref (lwc:ref) on a VM, from a template API
-  function setRefVNode(vm, ref, vnode) {
-      if (process.env.NODE_ENV !== 'production' && isUndefined$1(vm.refVNodes)) {
-          throw new Error('refVNodes must be defined when setting a ref');
+      // In Jest tests, reduce the warning and error verbosity by not printing the callstack
+      if (process.env.NODE_ENV === 'test') {
+          /* eslint-disable-next-line no-console */
+          console[method](msg);
+          return;
       }
-      // If this method is called, then vm.refVNodes is set as the template has refs.
-      // If not, then something went wrong and we threw an error above.
-      const refVNodes = vm.refVNodes;
-      // In cases of conflict (two elements with the same ref), prefer, the last one,
-      // in depth-first traversal order.
-      if (!(ref in refVNodes) || refVNodes[ref].key < vnode.key) {
-          refVNodes[ref] = vnode;
+      try {
+          throw new Error(msg);
+      }
+      catch (e) {
+          /* eslint-disable-next-line no-console */
+          console[method](e);
       }
   }
+  function logError(message, vm) {
+      log('error', message, vm, false);
+  }
+  function logWarn(message, vm) {
+      log('warn', message, vm, false);
+  }
+  function logWarnOnce(message, vm) {
+      log('warn', message, vm, true);
+  }
 
   /*
    * Copyright (c) 2019, salesforce.com, inc.
@@ -767,77 +825,101 @@ var LWC = (function (exports) {
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  function getComponentTag(vm) {
-      return `<${StringToLowerCase.call(vm.tagName)}>`;
-  }
-  // TODO [#1695]: Unify getComponentStack and getErrorComponentStack
-  function getComponentStack(vm) {
-      const stack = [];
-      let prefix = '';
-      while (!isNull(vm.owner)) {
-          ArrayPush$1.call(stack, prefix + getComponentTag(vm));
-          vm = vm.owner;
-          prefix += '\t';
+  let nextTickCallbackQueue = [];
+  const SPACE_CHAR = 32;
+  const EmptyObject = seal(create(null));
+  const EmptyArray = seal([]);
+  function flushCallbackQueue() {
+      if (process.env.NODE_ENV !== 'production') {
+          if (nextTickCallbackQueue.length === 0) {
+              throw new Error(`Internal Error: If callbackQueue is scheduled, it is because there must be at least one callback on this pending queue.`);
+          }
       }
-      return ArrayJoin.call(stack, '\n');
-  }
-  function getErrorComponentStack(vm) {
-      const wcStack = [];
-      let currentVm = vm;
-      while (!isNull(currentVm)) {
-          ArrayPush$1.call(wcStack, getComponentTag(currentVm));
-          currentVm = currentVm.owner;
+      const callbacks = nextTickCallbackQueue;
+      nextTickCallbackQueue = []; // reset to a new queue
+      for (let i = 0, len = callbacks.length; i < len; i += 1) {
+          callbacks[i]();
       }
-      return wcStack.reverse().join('\n\t');
   }
-
-  /*
-   * 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 addErrorComponentStack(vm, error) {
-      if (!isFrozen(error) && isUndefined$1(error.wcStack)) {
-          const wcStack = getErrorComponentStack(vm);
-          defineProperty(error, 'wcStack', {
-              get() {
-                  return wcStack;
-              },
-          });
+  function addCallbackToNextTick(callback) {
+      if (process.env.NODE_ENV !== 'production') {
+          if (!isFunction$1(callback)) {
+              throw new Error(`Internal Error: addCallbackToNextTick() can only accept a function callback`);
+          }
+      }
+      if (nextTickCallbackQueue.length === 0) {
+          Promise.resolve().then(flushCallbackQueue);
       }
+      ArrayPush$1.call(nextTickCallbackQueue, callback);
   }
-
-  /*
-   * 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 log(method, message, vm) {
-      let msg = `[LWC ${method}]: ${message}`;
-      if (!isUndefined$1(vm)) {
-          msg = `${msg}\n${getComponentStack(vm)}`;
+  function guid() {
+      function s4() {
+          return Math.floor((1 + Math.random()) * 0x10000)
+              .toString(16)
+              .substring(1);
       }
-      // In Jest tests, reduce the warning and error verbosity by not printing the callstack
-      if (process.env.NODE_ENV === 'test') {
-          /* eslint-disable-next-line no-console */
-          console[method](msg);
-          return;
+      return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+  }
+  // Borrowed from Vue template compiler.
+  // https://github.com/vuejs/vue/blob/531371b818b0e31a989a06df43789728f23dc4e8/src/platforms/web/util/style.js#L5-L16
+  const DECLARATION_DELIMITER = /;(?![^(]*\))/g;
+  const PROPERTY_DELIMITER = /:(.+)/;
+  function parseStyleText(cssText) {
+      const styleMap = {};
+      const declarations = cssText.split(DECLARATION_DELIMITER);
+      for (const declaration of declarations) {
+          if (declaration) {
+              const [prop, value] = declaration.split(PROPERTY_DELIMITER);
+              if (prop !== undefined && value !== undefined) {
+                  styleMap[prop.trim()] = value.trim();
+              }
+          }
       }
-      try {
-          throw new Error(msg);
+      return styleMap;
+  }
+  // Make a shallow copy of an object but omit the given key
+  function cloneAndOmitKey(object, keyToOmit) {
+      const result = {};
+      for (const key of Object.keys(object)) {
+          if (key !== keyToOmit) {
+              result[key] = object[key];
+          }
       }
-      catch (e) {
-          /* eslint-disable-next-line no-console */
-          console[method](e);
+      return result;
+  }
+  function flattenStylesheets(stylesheets) {
+      const list = [];
+      for (const stylesheet of stylesheets) {
+          if (!Array.isArray(stylesheet)) {
+              list.push(stylesheet);
+          }
+          else {
+              list.push(...flattenStylesheets(stylesheet));
+          }
       }
+      return list;
   }
-  function logError(message, vm) {
-      log('error', message, vm);
+  // Set a ref (lwc:ref) on a VM, from a template API
+  function setRefVNode(vm, ref, vnode) {
+      if (process.env.NODE_ENV !== 'production' && isUndefined$1(vm.refVNodes)) {
+          throw new Error('refVNodes must be defined when setting a ref');
+      }
+      // If this method is called, then vm.refVNodes is set as the template has refs.
+      // If not, then something went wrong and we threw an error above.
+      const refVNodes = vm.refVNodes;
+      // In cases of conflict (two elements with the same ref), prefer, the last one,
+      // in depth-first traversal order.
+      if (!(ref in refVNodes) || refVNodes[ref].key < vnode.key) {
+          refVNodes[ref] = vnode;
+      }
   }
-  function logWarn(message, vm) {
-      log('warn', message, vm);
+  // Throw an error if we're running in prod mode. Ensures code is truly removed from prod mode.
+  function assertNotProd() {
+      /* istanbul ignore if */
+      if (process.env.NODE_ENV === 'production') {
+          // this method should never leak to prod
+          throw new ReferenceError();
+      }
   }
 
   /*
@@ -892,7 +974,7 @@ var LWC = (function (exports) {
   //
   // If you update this list, check for test files that recapitulate the same list. Searching the codebase
   // for e.g. "dropzone" should suffice.
-  const globalHTMLProperties = assign(create(null), {
+  const globalHTMLProperties = {
       accessKey: {
           attribute: 'accesskey',
       },
@@ -977,7 +1059,7 @@ var LWC = (function (exports) {
       role: {
           attribute: 'role',
       },
-  });
+  };
   let controlledElement = null;
   let controlledAttributeName;
   function isAttributeLocked(elm, attrName) {
@@ -1044,27 +1126,18 @@ var LWC = (function (exports) {
   }
   let isDomMutationAllowed = false;
   function unlockDomMutation() {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       isDomMutationAllowed = true;
   }
   function lockDomMutation() {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       isDomMutationAllowed = false;
   }
   function logMissingPortalError(name, type) {
       return logError(`The \`${name}\` ${type} is available only on elements that use the \`lwc:dom="manual"\` directive.`);
   }
   function patchElementWithRestrictions(elm, options) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const originalOuterHTMLDescriptor = getPropertyDescriptor(elm, 'outerHTML');
       const descriptors = {
           outerHTML: generateAccessorDescriptor({
@@ -1145,10 +1218,7 @@ var LWC = (function (exports) {
       defineProperties(elm, descriptors);
   }
   function getShadowRootRestrictionsDescriptors(sr) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       // Disallowing properties in dev mode only to avoid people doing the wrong
       // thing when using the real shadow root, because if that's the case,
       // the component will not work when running with synthetic shadow.
@@ -1189,10 +1259,7 @@ var LWC = (function (exports) {
   // Custom Elements Restrictions:
   // -----------------------------
   function getCustomElementRestrictionsDescriptors(elm) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const originalAddEventListener = elm.addEventListener;
       const originalInnerHTMLDescriptor = getPropertyDescriptor(elm, 'innerHTML');
       const originalOuterHTMLDescriptor = getPropertyDescriptor(elm, 'outerHTML');
@@ -1237,10 +1304,7 @@ var LWC = (function (exports) {
       };
   }
   function getComponentRestrictionsDescriptors() {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       return {
           tagName: generateAccessorDescriptor({
               get() {
@@ -1254,10 +1318,7 @@ var LWC = (function (exports) {
       };
   }
   function getLightningElementPrototypeRestrictionsDescriptors(proto) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const originalDispatchEvent = proto.dispatchEvent;
       const descriptors = {
           dispatchEvent: generateDataDescriptor({
@@ -1971,7 +2032,6 @@ var LWC = (function (exports) {
       }
     };
   }
-  const EMPTY_REFS = freeze(create(null));
   const refsCache = new WeakMap();
   /**
    * This class is the base class for any LWC element.
@@ -2259,7 +2319,6 @@ var LWC = (function (exports) {
       }
       const {
         refVNodes,
-        hasRefVNodes,
         cmpTemplate
       } = vm;
       // If the `cmpTemplate` is null, that means that the template has not been rendered yet. Most likely this occurs
@@ -2273,15 +2332,9 @@ var LWC = (function (exports) {
       // were introduced, we return undefined if the template has no refs defined
       // anywhere. This fixes components that may want to add an expando called `refs`
       // and are checking if it exists with `if (this.refs)`  before adding it.
-      // Note it is not sufficient to just check if `refVNodes` is null or empty,
-      // because a template may have `lwc:ref` defined within a falsy `if:true` block.
-      if (!hasRefVNodes) {
-        return;
-      }
-      // For templates that are using `lwc:ref`, if there are no refs currently available
-      // (e.g. refs inside of a falsy `if:true` block), we return an empty object.
+      // Note we use a null refVNodes to indicate that the template has no refs defined.
       if (isNull(refVNodes)) {
-        return EMPTY_REFS;
+        return;
       }
       // The refNodes can be cached based on the refVNodes, since the refVNodes
       // are recreated from scratch every time the template is rendered.
@@ -2439,109 +2492,286 @@ var LWC = (function (exports) {
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  function api$1() {
-      if (process.env.NODE_ENV !== 'production') {
-          assert.fail(`@api decorator can only be used as a decorator function.`);
-      }
-      throw new Error();
+  const DeprecatedWiredElementHost = '$$DeprecatedWiredElementHostKey$$';
+  const DeprecatedWiredParamsMeta = '$$DeprecatedWiredParamsMetaKey$$';
+  const WIRE_DEBUG_ENTRY = '@wire';
+  const WireMetaMap = new Map();
+  class WireContextRegistrationEvent extends CustomEvent {
+    constructor(adapterToken, {
+      setNewContext,
+      setDisconnectedCallback
+    }) {
+      super(adapterToken, {
+        bubbles: true,
+        composed: true
+      });
+      defineProperties(this, {
+        setNewContext: {
+          value: setNewContext
+        },
+        setDisconnectedCallback: {
+          value: setDisconnectedCallback
+        }
+      });
+    }
   }
-  function createPublicPropertyDescriptor(key) {
-      return {
-          get() {
-              const vm = getAssociatedVM(this);
-              if (isBeingConstructed(vm)) {
-                  if (process.env.NODE_ENV !== 'production') {
-                      logError(`Can’t read the value of property \`${toString$1(key)}\` from the constructor because the owner component hasn’t set the value yet. Instead, use the constructor to set a default value for the property.`, vm);
-                  }
-                  return;
-              }
-              componentValueObserved(vm, key);
-              return vm.cmpProps[key];
-          },
-          set(newValue) {
-              const vm = getAssociatedVM(this);
-              if (process.env.NODE_ENV !== 'production') {
-                  const vmBeingRendered = getVMBeingRendered();
-                  assert.invariant(!isInvokingRender, `${vmBeingRendered}.render() method has side effects on the state of ${vm}.${toString$1(key)}`);
-                  assert.invariant(!isUpdatingTemplate, `Updating the template of ${vmBeingRendered} has side effects on the state of ${vm}.${toString$1(key)}`);
-              }
-              vm.cmpProps[key] = newValue;
-              componentValueMutated(vm, key);
-          },
-          enumerable: true,
-          configurable: true,
-      };
+  function createFieldDataCallback(vm, name) {
+    return value => {
+      updateComponentValue(vm, name, value);
+    };
   }
-  function createPublicAccessorDescriptor(key, descriptor) {
-      const { get, set, enumerable, configurable } = descriptor;
-      if (!isFunction$1(get)) {
-          if (process.env.NODE_ENV !== 'production') {
-              assert.invariant(isFunction$1(get), `Invalid compiler output for public accessor ${toString$1(key)} decorated with @api`);
-          }
-          throw new Error();
+  function createMethodDataCallback(vm, method) {
+    return value => {
+      // dispatching new value into the wired method
+      runWithBoundaryProtection(vm, vm.owner, noop, () => {
+        // job
+        method.call(vm.component, value);
+      }, noop);
+    };
+  }
+  function createConfigWatcher(component, configCallback, callbackWhenConfigIsReady) {
+    let hasPendingConfig = false;
+    // creating the reactive observer for reactive params when needed
+    const ro = createReactiveObserver(() => {
+      if (hasPendingConfig === false) {
+        hasPendingConfig = true;
+        // collect new config in the micro-task
+        Promise.resolve().then(() => {
+          hasPendingConfig = false;
+          // resetting current reactive params
+          ro.reset();
+          // dispatching a new config due to a change in the configuration
+          computeConfigAndUpdate();
+        });
       }
-      return {
-          get() {
-              if (process.env.NODE_ENV !== 'production') {
-                  // Assert that the this value is an actual Component with an associated VM.
-                  getAssociatedVM(this);
-              }
-              return get.call(this);
-          },
-          set(newValue) {
-              const vm = getAssociatedVM(this);
-              if (process.env.NODE_ENV !== 'production') {
-                  const vmBeingRendered = getVMBeingRendered();
-                  assert.invariant(!isInvokingRender, `${vmBeingRendered}.render() method has side effects on the state of ${vm}.${toString$1(key)}`);
-                  assert.invariant(!isUpdatingTemplate, `Updating the template of ${vmBeingRendered} has side effects on the state of ${vm}.${toString$1(key)}`);
-              }
-              if (set) {
-                  set.call(this, newValue);
-              }
-              else if (process.env.NODE_ENV !== 'production') {
-                  assert.fail(`Invalid attempt to set a new value for property ${toString$1(key)} of ${vm} that does not has a setter decorated with @api.`);
-              }
-          },
-          enumerable,
-          configurable,
-      };
+    });
+    const computeConfigAndUpdate = () => {
+      let config;
+      ro.observe(() => config = configCallback(component));
+      // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
+      // TODO: dev-mode validation of config based on the adapter.configSchema
+      // @ts-ignore it is assigned in the observe() callback
+      callbackWhenConfigIsReady(config);
+    };
+    return {
+      computeConfigAndUpdate,
+      ro
+    };
   }
+  function createContextWatcher(vm, wireDef, callbackWhenContextIsReady) {
+    const {
+      adapter
+    } = wireDef;
+    const adapterContextToken = getAdapterToken(adapter);
+    if (isUndefined$1(adapterContextToken)) {
+      return; // no provider found, nothing to be done
+    }
 
-  /*
-   * 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 track(target) {
-      if (arguments.length === 1) {
-          return getReactiveProxy(target);
-      }
-      if (process.env.NODE_ENV !== 'production') {
-          assert.fail(`@track decorator can only be used with one argument to return a trackable object, or as a decorator function.`);
+    const {
+      elm,
+      context: {
+        wiredConnecting,
+        wiredDisconnecting
+      },
+      renderer: {
+        dispatchEvent
       }
-      throw new Error();
-  }
-  function internalTrackDecorator(key) {
-      return {
-          get() {
-              const vm = getAssociatedVM(this);
-              componentValueObserved(vm, key);
-              return vm.cmpFields[key];
-          },
-          set(newValue) {
-              const vm = getAssociatedVM(this);
-              if (process.env.NODE_ENV !== 'production') {
-                  const vmBeingRendered = getVMBeingRendered();
-                  assert.invariant(!isInvokingRender, `${vmBeingRendered}.render() method has side effects on the state of ${vm}.${toString$1(key)}`);
-                  assert.invariant(!isUpdatingTemplate, `Updating the template of ${vmBeingRendered} has side effects on the state of ${vm}.${toString$1(key)}`);
-              }
-              const reactiveOrAnyValue = getReactiveProxy(newValue);
-              updateComponentValue(vm, key, reactiveOrAnyValue);
-          },
-          enumerable: true,
-          configurable: true,
-      };
+    } = vm;
+    // waiting for the component to be connected to formally request the context via the token
+    ArrayPush$1.call(wiredConnecting, () => {
+      // This event is responsible for connecting the host element with another
+      // element in the composed path that is providing contextual data. The provider
+      // must be listening for a special dom event with the name corresponding to the value of
+      // `adapterContextToken`, which will remain secret and internal to this file only to
+      // guarantee that the linkage can be forged.
+      const contextRegistrationEvent = new WireContextRegistrationEvent(adapterContextToken, {
+        setNewContext(newContext) {
+          // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
+          // TODO: dev-mode validation of config based on the adapter.contextSchema
+          callbackWhenContextIsReady(newContext);
+        },
+        setDisconnectedCallback(disconnectCallback) {
+          // adds this callback into the disconnect bucket so it gets disconnected from parent
+          // the the element hosting the wire is disconnected
+          ArrayPush$1.call(wiredDisconnecting, disconnectCallback);
+        }
+      });
+      dispatchEvent(elm, contextRegistrationEvent);
+    });
+  }
+  function createConnector(vm, name, wireDef) {
+    const {
+      method,
+      adapter,
+      configCallback,
+      dynamic
+    } = wireDef;
+    let debugInfo;
+    if (process.env.NODE_ENV !== 'production') {
+      const wiredPropOrMethod = isUndefined$1(method) ? name : method.name;
+      debugInfo = create(null);
+      debugInfo.wasDataProvisionedForConfig = false;
+      vm.debugInfo[WIRE_DEBUG_ENTRY][wiredPropOrMethod] = debugInfo;
+    }
+    const fieldOrMethodCallback = isUndefined$1(method) ? createFieldDataCallback(vm, name) : createMethodDataCallback(vm, method);
+    const dataCallback = value => {
+      if (process.env.NODE_ENV !== 'production') {
+        debugInfo.data = value;
+        // Note: most of the time, the data provided is for the current config, but there may be
+        // some conditions in which it does not, ex:
+        // race conditions in a poor network while the adapter does not cancel a previous request.
+        debugInfo.wasDataProvisionedForConfig = true;
+      }
+      fieldOrMethodCallback(value);
+    };
+    let context;
+    let connector;
+    // Workaround to pass the component element associated to this wire adapter instance.
+    defineProperty(dataCallback, DeprecatedWiredElementHost, {
+      value: vm.elm
+    });
+    defineProperty(dataCallback, DeprecatedWiredParamsMeta, {
+      value: dynamic
+    });
+    runWithBoundaryProtection(vm, vm, noop, () => {
+      // job
+      connector = new adapter(dataCallback);
+    }, noop);
+    const updateConnectorConfig = config => {
+      // every time the config is recomputed due to tracking,
+      // this callback will be invoked with the new computed config
+      runWithBoundaryProtection(vm, vm, noop, () => {
+        // job
+        if (process.env.NODE_ENV !== 'production') {
+          debugInfo.config = config;
+          debugInfo.context = context;
+          debugInfo.wasDataProvisionedForConfig = false;
+        }
+        connector.update(config, context);
+      }, noop);
+    };
+    // Computes the current wire config and calls the update method on the wire adapter.
+    // If it has params, we will need to observe changes in the next tick.
+    const {
+      computeConfigAndUpdate,
+      ro
+    } = createConfigWatcher(vm.component, configCallback, updateConnectorConfig);
+    // if the adapter needs contextualization, we need to watch for new context and push it alongside the config
+    if (!isUndefined$1(adapter.contextSchema)) {
+      createContextWatcher(vm, wireDef, newContext => {
+        // every time the context is pushed into this component,
+        // this callback will be invoked with the new computed context
+        if (context !== newContext) {
+          context = newContext;
+          // Note: when new context arrives, the config will be recomputed and pushed along side the new
+          // context, this is to preserve the identity characteristics, config should not have identity
+          // (ever), while context can have identity
+          if (vm.state === 1 /* VMState.connected */) {
+            computeConfigAndUpdate();
+          }
+        }
+      });
+    }
+    return {
+      // @ts-ignore the boundary protection executes sync, connector is always defined
+      connector,
+      computeConfigAndUpdate,
+      resetConfigWatcher: () => ro.reset()
+    };
+  }
+  const AdapterToTokenMap = new Map();
+  function getAdapterToken(adapter) {
+    return AdapterToTokenMap.get(adapter);
+  }
+  function setAdapterToken(adapter, token) {
+    AdapterToTokenMap.set(adapter, token);
+  }
+  function storeWiredMethodMeta(descriptor, adapter, configCallback, dynamic) {
+    // support for callable adapters
+    if (adapter.adapter) {
+      adapter = adapter.adapter;
+    }
+    const method = descriptor.value;
+    const def = {
+      adapter,
+      method,
+      configCallback,
+      dynamic
+    };
+    WireMetaMap.set(descriptor, def);
+  }
+  function storeWiredFieldMeta(descriptor, adapter, configCallback, dynamic) {
+    // support for callable adapters
+    if (adapter.adapter) {
+      adapter = adapter.adapter;
+    }
+    const def = {
+      adapter,
+      configCallback,
+      dynamic
+    };
+    WireMetaMap.set(descriptor, def);
+  }
+  function installWireAdapters(vm) {
+    const {
+      context,
+      def: {
+        wire
+      }
+    } = vm;
+    if (process.env.NODE_ENV !== 'production') {
+      vm.debugInfo[WIRE_DEBUG_ENTRY] = create(null);
+    }
+    const wiredConnecting = context.wiredConnecting = [];
+    const wiredDisconnecting = context.wiredDisconnecting = [];
+    for (const fieldNameOrMethod in wire) {
+      const descriptor = wire[fieldNameOrMethod];
+      const wireDef = WireMetaMap.get(descriptor);
+      if (process.env.NODE_ENV !== 'production') {
+        assert.invariant(wireDef, `Internal Error: invalid wire definition found.`);
+      }
+      if (!isUndefined$1(wireDef)) {
+        const {
+          connector,
+          computeConfigAndUpdate,
+          resetConfigWatcher
+        } = createConnector(vm, fieldNameOrMethod, wireDef);
+        const hasDynamicParams = wireDef.dynamic.length > 0;
+        ArrayPush$1.call(wiredConnecting, () => {
+          connector.connect();
+          if (!lwcRuntimeFlags.ENABLE_WIRE_SYNC_EMIT) {
+            if (hasDynamicParams) {
+              Promise.resolve().then(computeConfigAndUpdate);
+              return;
+            }
+          }
+          computeConfigAndUpdate();
+        });
+        ArrayPush$1.call(wiredDisconnecting, () => {
+          connector.disconnect();
+          resetConfigWatcher();
+        });
+      }
+    }
+  }
+  function connectWireAdapters(vm) {
+    const {
+      wiredConnecting
+    } = vm.context;
+    for (let i = 0, len = wiredConnecting.length; i < len; i += 1) {
+      wiredConnecting[i]();
+    }
+  }
+  function disconnectWireAdapters(vm) {
+    const {
+      wiredDisconnecting
+    } = vm.context;
+    runWithBoundaryProtection(vm, vm, noop, () => {
+      // job
+      for (let i = 0, len = wiredDisconnecting.length; i < len; i += 1) {
+        wiredDisconnecting[i]();
+      }
+    }, noop);
   }
 
   /*
@@ -2550,46 +2780,157 @@ var LWC = (function (exports) {
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  /**
-   * @wire decorator to wire fields and methods to a wire adapter in
-   * LWC Components. This function implements the internals of this
-   * decorator.
-   */
-  function wire(_adapter, _config) {
+  function api$1() {
       if (process.env.NODE_ENV !== 'production') {
-          assert.fail('@wire(adapter, config?) may only be used as a decorator.');
+          assert.fail(`@api decorator can only be used as a decorator function.`);
       }
       throw new Error();
   }
-  function internalWireFieldDecorator(key) {
+  function createPublicPropertyDescriptor(key) {
       return {
           get() {
               const vm = getAssociatedVM(this);
+              if (isBeingConstructed(vm)) {
+                  if (process.env.NODE_ENV !== 'production') {
+                      logError(`Can’t read the value of property \`${toString$1(key)}\` from the constructor because the owner component hasn’t set the value yet. Instead, use the constructor to set a default value for the property.`, vm);
+                  }
+                  return;
+              }
               componentValueObserved(vm, key);
-              return vm.cmpFields[key];
+              return vm.cmpProps[key];
           },
-          set(value) {
+          set(newValue) {
               const vm = getAssociatedVM(this);
-              /**
-               * Reactivity for wired fields is provided in wiring.
-               * We intentionally add reactivity here since this is just
-               * letting the author to do the wrong thing, but it will keep our
-               * system to be backward compatible.
-               */
-              updateComponentValue(vm, key, value);
+              if (process.env.NODE_ENV !== 'production') {
+                  const vmBeingRendered = getVMBeingRendered();
+                  assert.invariant(!isInvokingRender, `${vmBeingRendered}.render() method has side effects on the state of ${vm}.${toString$1(key)}`);
+                  assert.invariant(!isUpdatingTemplate, `Updating the template of ${vmBeingRendered} has side effects on the state of ${vm}.${toString$1(key)}`);
+              }
+              vm.cmpProps[key] = newValue;
+              componentValueMutated(vm, key);
           },
           enumerable: true,
           configurable: true,
       };
   }
-
-  /*
-   * Copyright (c) 2018, salesforce.com, inc.
-   * All rights reserved.
-   * SPDX-License-Identifier: MIT
-   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
-   */
-  function getClassDescriptorType(descriptor) {
+  function createPublicAccessorDescriptor(key, descriptor) {
+      const { get, set, enumerable, configurable } = descriptor;
+      if (!isFunction$1(get)) {
+          if (process.env.NODE_ENV !== 'production') {
+              assert.invariant(isFunction$1(get), `Invalid compiler output for public accessor ${toString$1(key)} decorated with @api`);
+          }
+          throw new Error();
+      }
+      return {
+          get() {
+              if (process.env.NODE_ENV !== 'production') {
+                  // Assert that the this value is an actual Component with an associated VM.
+                  getAssociatedVM(this);
+              }
+              return get.call(this);
+          },
+          set(newValue) {
+              const vm = getAssociatedVM(this);
+              if (process.env.NODE_ENV !== 'production') {
+                  const vmBeingRendered = getVMBeingRendered();
+                  assert.invariant(!isInvokingRender, `${vmBeingRendered}.render() method has side effects on the state of ${vm}.${toString$1(key)}`);
+                  assert.invariant(!isUpdatingTemplate, `Updating the template of ${vmBeingRendered} has side effects on the state of ${vm}.${toString$1(key)}`);
+              }
+              if (set) {
+                  set.call(this, newValue);
+              }
+              else if (process.env.NODE_ENV !== 'production') {
+                  assert.fail(`Invalid attempt to set a new value for property ${toString$1(key)} of ${vm} that does not has a setter decorated with @api.`);
+              }
+          },
+          enumerable,
+          configurable,
+      };
+  }
+
+  /*
+   * 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 track(target) {
+      if (arguments.length === 1) {
+          return getReactiveProxy(target);
+      }
+      if (process.env.NODE_ENV !== 'production') {
+          assert.fail(`@track decorator can only be used with one argument to return a trackable object, or as a decorator function.`);
+      }
+      throw new Error();
+  }
+  function internalTrackDecorator(key) {
+      return {
+          get() {
+              const vm = getAssociatedVM(this);
+              componentValueObserved(vm, key);
+              return vm.cmpFields[key];
+          },
+          set(newValue) {
+              const vm = getAssociatedVM(this);
+              if (process.env.NODE_ENV !== 'production') {
+                  const vmBeingRendered = getVMBeingRendered();
+                  assert.invariant(!isInvokingRender, `${vmBeingRendered}.render() method has side effects on the state of ${vm}.${toString$1(key)}`);
+                  assert.invariant(!isUpdatingTemplate, `Updating the template of ${vmBeingRendered} has side effects on the state of ${vm}.${toString$1(key)}`);
+              }
+              const reactiveOrAnyValue = getReactiveProxy(newValue);
+              updateComponentValue(vm, key, reactiveOrAnyValue);
+          },
+          enumerable: true,
+          configurable: true,
+      };
+  }
+
+  /*
+   * Copyright (c) 2018, salesforce.com, inc.
+   * All rights reserved.
+   * SPDX-License-Identifier: MIT
+   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+   */
+  /**
+   * @wire decorator to wire fields and methods to a wire adapter in
+   * LWC Components. This function implements the internals of this
+   * decorator.
+   */
+  function wire(_adapter, _config) {
+      if (process.env.NODE_ENV !== 'production') {
+          assert.fail('@wire(adapter, config?) may only be used as a decorator.');
+      }
+      throw new Error();
+  }
+  function internalWireFieldDecorator(key) {
+      return {
+          get() {
+              const vm = getAssociatedVM(this);
+              componentValueObserved(vm, key);
+              return vm.cmpFields[key];
+          },
+          set(value) {
+              const vm = getAssociatedVM(this);
+              /**
+               * Reactivity for wired fields is provided in wiring.
+               * We intentionally add reactivity here since this is just
+               * letting the author to do the wrong thing, but it will keep our
+               * system to be backward compatible.
+               */
+              updateComponentValue(vm, key, value);
+          },
+          enumerable: true,
+          configurable: true,
+      };
+  }
+
+  /*
+   * Copyright (c) 2018, salesforce.com, inc.
+   * All rights reserved.
+   * SPDX-License-Identifier: MIT
+   * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+   */
+  function getClassDescriptorType(descriptor) {
       if (isFunction$1(descriptor.value)) {
           return "method" /* DescriptorType.Method */;
       }
@@ -2808,8 +3149,8 @@ var LWC = (function (exports) {
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   let warned = false;
-  // @ts-ignore
-  if (process.env.NODE_ENV !== 'production' && typeof __karma__ !== 'undefined') {
+  // Only used in LWC's Karma tests
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
       // @ts-ignore
       window.__lwcResetWarnedOnVersionMismatch = () => {
           warned = false;
@@ -3105,10 +3446,7 @@ var LWC = (function (exports) {
       return canRefreshAllInstances;
   }
   function getTemplateOrSwappedTemplate(tpl) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const visited = new Set();
       while (swappedTemplateMap.has(tpl) && !visited.has(tpl)) {
           visited.add(tpl);
@@ -3117,10 +3455,7 @@ var LWC = (function (exports) {
       return tpl;
   }
   function getComponentOrSwappedComponent(Ctor) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const visited = new Set();
       while (swappedComponentMap.has(Ctor) && !visited.has(Ctor)) {
           visited.add(Ctor);
@@ -3129,10 +3464,7 @@ var LWC = (function (exports) {
       return Ctor;
   }
   function getStyleOrSwappedStyle(style) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const visited = new Set();
       while (swappedStyleMap.has(style) && !visited.has(style)) {
           visited.add(style);
@@ -3141,10 +3473,7 @@ var LWC = (function (exports) {
       return style;
   }
   function setActiveVM(vm) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       // tracking active component
       const Ctor = vm.def.ctor;
       let componentVMs = activeComponents.get(Ctor);
@@ -3187,10 +3516,7 @@ var LWC = (function (exports) {
       }
   }
   function removeActiveVM(vm) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       // tracking inactive component
       const Ctor = vm.def.ctor;
       let list = activeComponents.get(Ctor);
@@ -5363,10 +5689,7 @@ var LWC = (function (exports) {
       vmBeingRendered = vm;
   }
   function validateSlots(vm, html) {
-      if (process.env.NODE_ENV === 'production') {
-          // this method should never leak to prod
-          throw new ReferenceError();
-      }
+      assertNotProd(); // this method should never leak to prod
       const { cmpSlots } = vm;
       const { slots = EmptyArray } = html;
       for (const slotName in cmpSlots.slotAssignments) {
@@ -5500,9 +5823,7 @@ var LWC = (function (exports) {
                   setActiveVM(vm);
               }
               // reset the refs; they will be set during the tmpl() instantiation
-              const hasRefVNodes = Boolean(html.hasRefs);
-              vm.hasRefVNodes = hasRefVNodes;
-              vm.refVNodes = hasRefVNodes ? create(null) : null;
+              vm.refVNodes = html.hasRefs ? create(null) : null;
               // right before producing the vnodes, we clear up all internal references
               // to custom elements from the template.
               vm.velements = [];
@@ -5689,7 +6010,7 @@ var LWC = (function (exports) {
   const cmpEventListenerMap = new WeakMap();
   function getWrappedComponentsListener(vm, listener) {
       if (!isFunction$1(listener)) {
-          throw new TypeError(); // avoiding problems with non-valid listeners
+          throw new TypeError('Expected an EventListener but received ' + typeof listener); // avoiding problems with non-valid listeners
       }
       let wrappedListener = cmpEventListenerMap.get(listener);
       if (isUndefined$1(wrappedListener)) {
@@ -5834,7 +6155,6 @@ var LWC = (function (exports) {
       mode,
       owner,
       refVNodes: null,
-      hasRefVNodes: false,
       children: EmptyArray,
       aChildren: EmptyArray,
       velements: EmptyArray,
@@ -6167,413 +6487,270 @@ var LWC = (function (exports) {
         const childVM = getAssociatedVMIfPresent(elm);
         // The VM associated with the element might be associated undefined
         // in the case where the VM failed in the middle of its creation,
-        // eg: constructor throwing before invoking super().
-        if (!isUndefined$1(childVM)) {
-          resetComponentStateWhenRemoved(childVM);
-        }
-      }
-    }
-  }
-  function runLightChildNodesDisconnectedCallback(vm) {
-    const {
-      aChildren: adoptedChildren
-    } = vm;
-    recursivelyDisconnectChildren(adoptedChildren);
-  }
-  /**
-   * The recursion doesn't need to be a complete traversal of the vnode graph,
-   * instead it can be partial, when a custom element vnode is found, we don't
-   * need to continue into its children because by attempting to disconnect the
-   * custom element itself will trigger the removal of anything slotted or anything
-   * defined on its shadow.
-   */
-  function recursivelyDisconnectChildren(vnodes) {
-    for (let i = 0, len = vnodes.length; i < len; i += 1) {
-      const vnode = vnodes[i];
-      if (!isNull(vnode) && !isUndefined$1(vnode.elm)) {
-        switch (vnode.type) {
-          case 2 /* VNodeType.Element */:
-            recursivelyDisconnectChildren(vnode.children);
-            break;
-          case 3 /* VNodeType.CustomElement */:
-            {
-              const vm = getAssociatedVM(vnode.elm);
-              resetComponentStateWhenRemoved(vm);
-              break;
-            }
-        }
-      }
-    }
-  }
-  // This is a super optimized mechanism to remove the content of the root node (shadow root
-  // for shadow DOM components and the root element itself for light DOM) without having to go
-  // into snabbdom. Especially useful when the reset is a consequence of an error, in which case the
-  // children VNodes might not be representing the current state of the DOM.
-  function resetComponentRoot(vm) {
-    const {
-      children,
-      renderRoot,
-      renderer: {
-        remove
-      }
-    } = vm;
-    for (let i = 0, len = children.length; i < len; i++) {
-      const child = children[i];
-      if (!isNull(child) && !isUndefined$1(child.elm)) {
-        remove(child.elm, renderRoot);
-      }
-    }
-    vm.children = EmptyArray;
-    runChildNodesDisconnectedCallback(vm);
-    vm.velements = EmptyArray;
-  }
-  function scheduleRehydration(vm) {
-    if (isTrue(vm.isScheduled)) {
-      return;
-    }
-    vm.isScheduled = true;
-    if (rehydrateQueue.length === 0) {
-      addCallbackToNextTick(flushRehydrationQueue);
-    }
-    ArrayPush$1.call(rehydrateQueue, vm);
-  }
-  function getErrorBoundaryVM(vm) {
-    let currentVm = vm;
-    while (!isNull(currentVm)) {
-      if (!isUndefined$1(currentVm.def.errorCallback)) {
-        return currentVm;
-      }
-      currentVm = currentVm.owner;
-    }
-  }
-  function runWithBoundaryProtection(vm, owner, pre, job, post) {
-    let error;
-    pre();
-    try {
-      job();
-    } catch (e) {
-      error = Object(e);
-    } finally {
-      post();
-      if (!isUndefined$1(error)) {
-        addErrorComponentStack(vm, error);
-        const errorBoundaryVm = isNull(owner) ? undefined : getErrorBoundaryVM(owner);
-        if (isUndefined$1(errorBoundaryVm)) {
-          throw error; // eslint-disable-line no-unsafe-finally
-        }
-
-        resetComponentRoot(vm); // remove offenders
-        logOperationStart(6 /* OperationId.ErrorCallback */, vm);
-        // error boundaries must have an ErrorCallback
-        const errorCallback = errorBoundaryVm.def.errorCallback;
-        invokeComponentCallback(errorBoundaryVm, errorCallback, [error, error.wcStack]);
-        logOperationEnd(6 /* OperationId.ErrorCallback */, vm);
-      }
-    }
-  }
-  function forceRehydration(vm) {
-    // if we must reset the shadowRoot content and render the template
-    // from scratch on an active instance, the way to force the reset
-    // is by replacing the value of old template, which is used during
-    // to determine if the template has changed or not during the rendering
-    // process. If the template returned by render() is different from the
-    // previous stored template, the styles will be reset, along with the
-    // content of the shadowRoot, this way we can guarantee that all children
-    // elements will be throw away, and new instances will be created.
-    vm.cmpTemplate = () => [];
-    if (isFalse(vm.isDirty)) {
-      // forcing the vm to rehydrate in the next tick
-      markComponentAsDirty(vm);
-      scheduleRehydration(vm);
-    }
-  }
-
-  /*
-   * 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 DeprecatedWiredElementHost = '$$DeprecatedWiredElementHostKey$$';
-  const DeprecatedWiredParamsMeta = '$$DeprecatedWiredParamsMetaKey$$';
-  const WIRE_DEBUG_ENTRY = '@wire';
-  const WireMetaMap = new Map();
-  class WireContextRegistrationEvent extends CustomEvent {
-    constructor(adapterToken, {
-      setNewContext,
-      setDisconnectedCallback
-    }) {
-      super(adapterToken, {
-        bubbles: true,
-        composed: true
-      });
-      defineProperties(this, {
-        setNewContext: {
-          value: setNewContext
-        },
-        setDisconnectedCallback: {
-          value: setDisconnectedCallback
-        }
-      });
-    }
-  }
-  function createFieldDataCallback(vm, name) {
-    return value => {
-      updateComponentValue(vm, name, value);
-    };
-  }
-  function createMethodDataCallback(vm, method) {
-    return value => {
-      // dispatching new value into the wired method
-      runWithBoundaryProtection(vm, vm.owner, noop, () => {
-        // job
-        method.call(vm.component, value);
-      }, noop);
-    };
-  }
-  function createConfigWatcher(component, configCallback, callbackWhenConfigIsReady) {
-    let hasPendingConfig = false;
-    // creating the reactive observer for reactive params when needed
-    const ro = createReactiveObserver(() => {
-      if (hasPendingConfig === false) {
-        hasPendingConfig = true;
-        // collect new config in the micro-task
-        Promise.resolve().then(() => {
-          hasPendingConfig = false;
-          // resetting current reactive params
-          ro.reset();
-          // dispatching a new config due to a change in the configuration
-          computeConfigAndUpdate();
-        });
-      }
-    });
-    const computeConfigAndUpdate = () => {
-      let config;
-      ro.observe(() => config = configCallback(component));
-      // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
-      // TODO: dev-mode validation of config based on the adapter.configSchema
-      // @ts-ignore it is assigned in the observe() callback
-      callbackWhenConfigIsReady(config);
-    };
-    return {
-      computeConfigAndUpdate,
-      ro
-    };
-  }
-  function createContextWatcher(vm, wireDef, callbackWhenContextIsReady) {
-    const {
-      adapter
-    } = wireDef;
-    const adapterContextToken = getAdapterToken(adapter);
-    if (isUndefined$1(adapterContextToken)) {
-      return; // no provider found, nothing to be done
-    }
-
-    const {
-      elm,
-      context: {
-        wiredConnecting,
-        wiredDisconnecting
-      },
-      renderer: {
-        dispatchEvent
-      }
-    } = vm;
-    // waiting for the component to be connected to formally request the context via the token
-    ArrayPush$1.call(wiredConnecting, () => {
-      // This event is responsible for connecting the host element with another
-      // element in the composed path that is providing contextual data. The provider
-      // must be listening for a special dom event with the name corresponding to the value of
-      // `adapterContextToken`, which will remain secret and internal to this file only to
-      // guarantee that the linkage can be forged.
-      const contextRegistrationEvent = new WireContextRegistrationEvent(adapterContextToken, {
-        setNewContext(newContext) {
-          // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
-          // TODO: dev-mode validation of config based on the adapter.contextSchema
-          callbackWhenContextIsReady(newContext);
-        },
-        setDisconnectedCallback(disconnectCallback) {
-          // adds this callback into the disconnect bucket so it gets disconnected from parent
-          // the the element hosting the wire is disconnected
-          ArrayPush$1.call(wiredDisconnecting, disconnectCallback);
-        }
-      });
-      dispatchEvent(elm, contextRegistrationEvent);
-    });
-  }
-  function createConnector(vm, name, wireDef) {
-    const {
-      method,
-      adapter,
-      configCallback,
-      dynamic
-    } = wireDef;
-    let debugInfo;
-    if (process.env.NODE_ENV !== 'production') {
-      const wiredPropOrMethod = isUndefined$1(method) ? name : method.name;
-      debugInfo = create(null);
-      debugInfo.wasDataProvisionedForConfig = false;
-      vm.debugInfo[WIRE_DEBUG_ENTRY][wiredPropOrMethod] = debugInfo;
-    }
-    const fieldOrMethodCallback = isUndefined$1(method) ? createFieldDataCallback(vm, name) : createMethodDataCallback(vm, method);
-    const dataCallback = value => {
-      if (process.env.NODE_ENV !== 'production') {
-        debugInfo.data = value;
-        // Note: most of the time, the data provided is for the current config, but there may be
-        // some conditions in which it does not, ex:
-        // race conditions in a poor network while the adapter does not cancel a previous request.
-        debugInfo.wasDataProvisionedForConfig = true;
-      }
-      fieldOrMethodCallback(value);
-    };
-    let context;
-    let connector;
-    // Workaround to pass the component element associated to this wire adapter instance.
-    defineProperty(dataCallback, DeprecatedWiredElementHost, {
-      value: vm.elm
-    });
-    defineProperty(dataCallback, DeprecatedWiredParamsMeta, {
-      value: dynamic
-    });
-    runWithBoundaryProtection(vm, vm, noop, () => {
-      // job
-      connector = new adapter(dataCallback);
-    }, noop);
-    const updateConnectorConfig = config => {
-      // every time the config is recomputed due to tracking,
-      // this callback will be invoked with the new computed config
-      runWithBoundaryProtection(vm, vm, noop, () => {
-        // job
-        if (process.env.NODE_ENV !== 'production') {
-          debugInfo.config = config;
-          debugInfo.context = context;
-          debugInfo.wasDataProvisionedForConfig = false;
+        // eg: constructor throwing before invoking super().
+        if (!isUndefined$1(childVM)) {
+          resetComponentStateWhenRemoved(childVM);
         }
-        connector.update(config, context);
-      }, noop);
-    };
-    // Computes the current wire config and calls the update method on the wire adapter.
-    // If it has params, we will need to observe changes in the next tick.
+      }
+    }
+  }
+  function runLightChildNodesDisconnectedCallback(vm) {
     const {
-      computeConfigAndUpdate,
-      ro
-    } = createConfigWatcher(vm.component, configCallback, updateConnectorConfig);
-    // if the adapter needs contextualization, we need to watch for new context and push it alongside the config
-    if (!isUndefined$1(adapter.contextSchema)) {
-      createContextWatcher(vm, wireDef, newContext => {
-        // every time the context is pushed into this component,
-        // this callback will be invoked with the new computed context
-        if (context !== newContext) {
-          context = newContext;
-          // Note: when new context arrives, the config will be recomputed and pushed along side the new
-          // context, this is to preserve the identity characteristics, config should not have identity
-          // (ever), while context can have identity
-          if (vm.state === 1 /* VMState.connected */) {
-            computeConfigAndUpdate();
-          }
+      aChildren: adoptedChildren
+    } = vm;
+    recursivelyDisconnectChildren(adoptedChildren);
+  }
+  /**
+   * The recursion doesn't need to be a complete traversal of the vnode graph,
+   * instead it can be partial, when a custom element vnode is found, we don't
+   * need to continue into its children because by attempting to disconnect the
+   * custom element itself will trigger the removal of anything slotted or anything
+   * defined on its shadow.
+   */
+  function recursivelyDisconnectChildren(vnodes) {
+    for (let i = 0, len = vnodes.length; i < len; i += 1) {
+      const vnode = vnodes[i];
+      if (!isNull(vnode) && !isUndefined$1(vnode.elm)) {
+        switch (vnode.type) {
+          case 2 /* VNodeType.Element */:
+            recursivelyDisconnectChildren(vnode.children);
+            break;
+          case 3 /* VNodeType.CustomElement */:
+            {
+              const vm = getAssociatedVM(vnode.elm);
+              resetComponentStateWhenRemoved(vm);
+              break;
+            }
         }
-      });
+      }
     }
-    return {
-      // @ts-ignore the boundary protection executes sync, connector is always defined
-      connector,
-      computeConfigAndUpdate,
-      resetConfigWatcher: () => ro.reset()
-    };
-  }
-  const AdapterToTokenMap = new Map();
-  function getAdapterToken(adapter) {
-    return AdapterToTokenMap.get(adapter);
   }
-  function setAdapterToken(adapter, token) {
-    AdapterToTokenMap.set(adapter, token);
+  // This is a super optimized mechanism to remove the content of the root node (shadow root
+  // for shadow DOM components and the root element itself for light DOM) without having to go
+  // into snabbdom. Especially useful when the reset is a consequence of an error, in which case the
+  // children VNodes might not be representing the current state of the DOM.
+  function resetComponentRoot(vm) {
+    const {
+      children,
+      renderRoot,
+      renderer: {
+        remove
+      }
+    } = vm;
+    for (let i = 0, len = children.length; i < len; i++) {
+      const child = children[i];
+      if (!isNull(child) && !isUndefined$1(child.elm)) {
+        remove(child.elm, renderRoot);
+      }
+    }
+    vm.children = EmptyArray;
+    runChildNodesDisconnectedCallback(vm);
+    vm.velements = EmptyArray;
   }
-  function storeWiredMethodMeta(descriptor, adapter, configCallback, dynamic) {
-    // support for callable adapters
-    if (adapter.adapter) {
-      adapter = adapter.adapter;
+  function scheduleRehydration(vm) {
+    if (isTrue(vm.isScheduled)) {
+      return;
     }
-    const method = descriptor.value;
-    const def = {
-      adapter,
-      method,
-      configCallback,
-      dynamic
-    };
-    WireMetaMap.set(descriptor, def);
+    vm.isScheduled = true;
+    if (rehydrateQueue.length === 0) {
+      addCallbackToNextTick(flushRehydrationQueue);
+    }
+    ArrayPush$1.call(rehydrateQueue, vm);
   }
-  function storeWiredFieldMeta(descriptor, adapter, configCallback, dynamic) {
-    // support for callable adapters
-    if (adapter.adapter) {
-      adapter = adapter.adapter;
+  function getErrorBoundaryVM(vm) {
+    let currentVm = vm;
+    while (!isNull(currentVm)) {
+      if (!isUndefined$1(currentVm.def.errorCallback)) {
+        return currentVm;
+      }
+      currentVm = currentVm.owner;
     }
-    const def = {
-      adapter,
-      configCallback,
-      dynamic
-    };
-    WireMetaMap.set(descriptor, def);
   }
-  function installWireAdapters(vm) {
-    const {
-      context,
-      def: {
-        wire
+  function runWithBoundaryProtection(vm, owner, pre, job, post) {
+    let error;
+    pre();
+    try {
+      job();
+    } catch (e) {
+      error = Object(e);
+    } finally {
+      post();
+      if (!isUndefined$1(error)) {
+        addErrorComponentStack(vm, error);
+        const errorBoundaryVm = isNull(owner) ? undefined : getErrorBoundaryVM(owner);
+        if (isUndefined$1(errorBoundaryVm)) {
+          throw error; // eslint-disable-line no-unsafe-finally
+        }
+
+        resetComponentRoot(vm); // remove offenders
+        logOperationStart(6 /* OperationId.ErrorCallback */, vm);
+        // error boundaries must have an ErrorCallback
+        const errorCallback = errorBoundaryVm.def.errorCallback;
+        invokeComponentCallback(errorBoundaryVm, errorCallback, [error, error.wcStack]);
+        logOperationEnd(6 /* OperationId.ErrorCallback */, vm);
       }
-    } = vm;
-    if (process.env.NODE_ENV !== 'production') {
-      vm.debugInfo[WIRE_DEBUG_ENTRY] = create(null);
     }
-    const wiredConnecting = context.wiredConnecting = [];
-    const wiredDisconnecting = context.wiredDisconnecting = [];
-    for (const fieldNameOrMethod in wire) {
-      const descriptor = wire[fieldNameOrMethod];
-      const wireDef = WireMetaMap.get(descriptor);
+  }
+  function forceRehydration(vm) {
+    // if we must reset the shadowRoot content and render the template
+    // from scratch on an active instance, the way to force the reset
+    // is by replacing the value of old template, which is used during
+    // to determine if the template has changed or not during the rendering
+    // process. If the template returned by render() is different from the
+    // previous stored template, the styles will be reset, along with the
+    // content of the shadowRoot, this way we can guarantee that all children
+    // elements will be throw away, and new instances will be created.
+    vm.cmpTemplate = () => [];
+    if (isFalse(vm.isDirty)) {
+      // forcing the vm to rehydrate in the next tick
+      markComponentAsDirty(vm);
+      scheduleRehydration(vm);
+    }
+  }
+
+  /*
+   * 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
+   */
+  //
+  // The goal of this code is to detect invalid cross-root ARIA references in synthetic shadow DOM.
+  // These invalid references should be fixed before the offending components can be migrated to native shadow DOM.
+  // When invalid usage is detected, we warn in dev mode and call the reporting API if enabled.
+  // See: https://lwc.dev/guide/accessibility#link-ids-and-aria-attributes-from-different-templates
+  //
+  // Use the unpatched native getElementById/querySelectorAll rather than the synthetic one
+  const getElementById = _globalThis[KEY__NATIVE_GET_ELEMENT_BY_ID];
+  const querySelectorAll = _globalThis[KEY__NATIVE_QUERY_SELECTOR_ALL];
+  function isSyntheticShadowRootInstance(rootNode) {
+      return rootNode !== document && isTrue(rootNode.synthetic);
+  }
+  function reportViolation(source, target, attrName) {
+      // The vm is either for the source, the target, or both. Either one or both must be using synthetic
+      // shadow for a violation to be detected.
+      let vm = getAssociatedVMIfPresent(source.getRootNode().host);
+      if (isUndefined$1(vm)) {
+          vm = getAssociatedVMIfPresent(target.getRootNode().host);
+      }
+      if (isUndefined$1(vm)) {
+          // vm should never be undefined here, but just to be safe, bail out and don't report
+          return;
+      }
+      report(0 /* ReportingEventId.CrossRootAriaInSyntheticShadow */, vm);
       if (process.env.NODE_ENV !== 'production') {
-        assert.invariant(wireDef, `Internal Error: invalid wire definition found.`);
+          // Avoid excessively logging to the console in the case of duplicates.
+          logWarnOnce(`Element <${source.tagName.toLowerCase()}> uses attribute "${attrName}" to reference element ` +
+              `<${target.tagName.toLowerCase()}>, which is not in the same shadow root. This will break in native shadow DOM. ` +
+              `For details, see: https://lwc.dev/guide/accessibility#link-ids-and-aria-attributes-from-different-templates`, vm);
       }
-      if (!isUndefined$1(wireDef)) {
-        const {
-          connector,
-          computeConfigAndUpdate,
-          resetConfigWatcher
-        } = createConnector(vm, fieldNameOrMethod, wireDef);
-        const hasDynamicParams = wireDef.dynamic.length > 0;
-        ArrayPush$1.call(wiredConnecting, () => {
-          connector.connect();
-          if (!lwcRuntimeFlags.ENABLE_WIRE_SYNC_EMIT) {
-            if (hasDynamicParams) {
-              Promise.resolve().then(computeConfigAndUpdate);
+  }
+  function parseIdRefAttributeValue(attrValue) {
+      // split on whitespace and skip empty strings after splitting
+      return isString(attrValue) ? ArrayFilter.call(StringSplit.call(attrValue, /\s+/), Boolean) : [];
+  }
+  function detectSyntheticCrossRootAria(elm, attrName, attrValue) {
+      const root = elm.getRootNode();
+      if (!isSyntheticShadowRootInstance(root)) {
+          return;
+      }
+      if (attrName === 'id') {
+          // elm is the target, find the source
+          if (!isString(attrValue) || attrValue.length === 0) {
+              // if our id is null or empty, nobody can reference us
               return;
-            }
           }
-          computeConfigAndUpdate();
-        });
-        ArrayPush$1.call(wiredDisconnecting, () => {
-          connector.disconnect();
-          resetConfigWatcher();
-        });
+          for (const idRefAttrName of ID_REFERENCING_ATTRIBUTES_SET) {
+              // Query all global elements with this attribute. The attribute selector syntax `~=` is for values
+              // that reference multiple IDs, separated by whitespace.
+              const query = `[${idRefAttrName}~="${CSS.escape(attrValue)}"]`;
+              const sourceElements = querySelectorAll.call(document, query);
+              for (let i = 0; i < sourceElements.length; i++) {
+                  const sourceElement = sourceElements[i];
+                  const sourceRoot = sourceElement.getRootNode();
+                  if (sourceRoot !== root) {
+                      reportViolation(sourceElement, elm, idRefAttrName);
+                      break;
+                  }
+              }
+          }
+      }
+      else {
+          // elm is the source, find the target
+          const ids = parseIdRefAttributeValue(attrValue);
+          for (const id of ids) {
+              const target = getElementById.call(document, id);
+              if (!isNull(target)) {
+                  const targetRoot = target.getRootNode();
+                  if (targetRoot !== root) {
+                      // target element's shadow root is not the same as ours
+                      reportViolation(elm, target, attrName);
+                  }
+              }
+          }
       }
-    }
   }
-  function connectWireAdapters(vm) {
-    const {
-      wiredConnecting
-    } = vm.context;
-    for (let i = 0, len = wiredConnecting.length; i < len; i += 1) {
-      wiredConnecting[i]();
-    }
+  let enabled = false;
+  // We want to avoid patching globals whenever possible, so this should be tree-shaken out in prod-mode and if
+  // reporting is not enabled. It should also only run once
+  function enableDetection() {
+      if (enabled) {
+          return; // don't double-apply the patches
+      }
+      enabled = true;
+      const { setAttribute } = Element.prototype;
+      // Detect calling `setAttribute` to set an idref or an id
+      assign(Element.prototype, {
+          setAttribute(attrName, attrValue) {
+              setAttribute.call(this, attrName, attrValue);
+              if (attrName === 'id' || ID_REFERENCING_ATTRIBUTES_SET.has(attrName)) {
+                  detectSyntheticCrossRootAria(this, attrName, attrValue);
+              }
+          },
+      });
+      // Detect `elm.id = 'foo'`
+      const idDescriptor = getOwnPropertyDescriptor$1(Element.prototype, 'id');
+      if (!isUndefined$1(idDescriptor)) {
+          const { get, set } = idDescriptor;
+          // These should always be a getter and a setter, but if someone is monkeying with the global descriptor, ignore it
+          if (isFunction$1(get) && isFunction$1(set)) {
+              defineProperty(Element.prototype, 'id', {
+                  get() {
+                      return get.call(this);
+                  },
+                  set(value) {
+                      set.call(this, value);
+                      detectSyntheticCrossRootAria(this, 'id', value);
+                  },
+                  // On the default descriptor for 'id', enumerable and configurable are true
+                  enumerable: true,
+                  configurable: true,
+              });
+          }
+      }
   }
-  function disconnectWireAdapters(vm) {
-    const {
-      wiredDisconnecting
-    } = vm.context;
-    runWithBoundaryProtection(vm, vm, noop, () => {
-      // job
-      for (let i = 0, len = wiredDisconnecting.length; i < len; i += 1) {
-        wiredDisconnecting[i]();
+  // Our detection logic relies on some modern browser features. We can just skip reporting the data
+  // for unsupported browsers
+  function supportsCssEscape() {
+      return typeof CSS !== 'undefined' && isFunction$1(CSS.escape);
+  }
+  // If this page is not using synthetic shadow, then we don't need to install detection. Note
+  // that we are assuming synthetic shadow is loaded before LWC.
+  function isSyntheticShadowLoaded() {
+      // We should probably be calling `renderer.isSyntheticShadowDefined`, but 1) we don't have access to the renderer,
+      // and 2) this code needs to run in @lwc/engine-core, so it can access `logWarn()` and `report()`.
+      return hasOwnProperty$1.call(Element.prototype, KEY__SHADOW_TOKEN);
+  }
+  // Detecting cross-root ARIA in synthetic shadow only makes sense for the browser
+  if (supportsCssEscape() && isSyntheticShadowLoaded()) {
+      // Always run detection in dev mode, so we can at least print to the console
+      if (process.env.NODE_ENV !== 'production') {
+          enableDetection();
+      }
+      else {
+          // In prod mode, only enable detection if reporting is enabled
+          onReportingEnabled(enableDetection);
       }
-    }, noop);
   }
 
   /*
@@ -7245,7 +7422,7 @@ var LWC = (function (exports) {
       }
       return ctor;
   }
-  /* version: 2.34.0 */
+  /* version: 2.35.1 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -7353,8 +7530,7 @@ var LWC = (function (exports) {
   // Test utilities
   //
   // Only used in LWC's Karma tests
-  // @ts-ignore
-  if (process.env.NODE_ENV !== 'production' && typeof __karma__ !== 'undefined') {
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
       // @ts-ignore
       window.__lwcResetGlobalStylesheets = () => {
           stylesheetCache.clear();
@@ -8220,7 +8396,7 @@ var LWC = (function (exports) {
       function isNull(obj) {
           return obj === null;
       }
-      /** version: 2.34.0 */
+      /** version: 2.35.1 */
 
       /*
        * Copyright (c) 2018, salesforce.com, inc.
@@ -8781,10 +8957,11 @@ var LWC = (function (exports) {
   });
   freeze(LightningElement);
   seal(LightningElement.prototype);
-  /* version: 2.34.0 */
+  /* version: 2.35.1 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;
+  exports.__unstable__ReportingControl = reportingControl;
   exports.api = api$1;
   exports.buildCustomElementConstructor = deprecatedBuildCustomElementConstructor;
   exports.createContextProvider = createContextProvider;