lwc 2.34.0 → 2.35.1

package/dist/engine-server/esm/es2017/engine-server.js

@@ -45,7 +45,7 @@ const { assign, create, defineProperties, defineProperty, freeze, getOwnProperty
 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;
 }
@@ -192,41 +192,11 @@ function isAriaAttribute(attrName) {
  * 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;
 const KEY__SHADOW_RESOLVER = '$shadowResolver$';
 const KEY__SHADOW_STATIC = '$shadowStaticNode$';
 const KEY__SYNTHETIC_MODE = '$$lwc-synthetic-mode';
@@ -470,9 +440,9 @@ function htmlEscape(str, attrMode = false) {
  * 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) 2020, salesforce.com, inc.
@@ -557,7 +527,8 @@ function setFeatureFlag(name, value) {
         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;
     }
@@ -577,11 +548,12 @@ function setFeatureFlag(name, value) {
  * 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.
@@ -645,7 +617,7 @@ function applyAriaReflection(prototype = Element.prototype) {
         }
     }
 }
-/** version: 2.34.0 */
+/** version: 2.35.1 */
 
 /* proxy-compat-disable */
 
@@ -656,8 +628,7 @@ function applyAriaReflection(prototype = Element.prototype) {
  * 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) {
@@ -671,87 +642,6 @@ if (process.env.NODE_ENV !== 'production' && typeof __karma__ !== 'undefined') {
     }));
   });
 }
-const SPACE_CHAR = 32;
-const EmptyObject = seal(create(null));
-const EmptyArray = seal([]);
-function guid() {
-    function s4() {
-        return Math.floor((1 + Math.random()) * 0x10000)
-            .toString(16)
-            .substring(1);
-    }
-    return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
-}
-function flattenStylesheets(stylesheets) {
-    const list = [];
-    for (const stylesheet of stylesheets) {
-        if (!Array.isArray(stylesheet)) {
-            list.push(stylesheet);
-        }
-        else {
-            list.push(...flattenStylesheets(stylesheet));
-        }
-    }
-    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');
-    }
-    // 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;
-    }
-}
-
-/*
- * Copyright (c) 2019, 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 TargetToReactiveRecordMap = new WeakMap();
-function valueMutated(target, key) {
-    const reactiveRecord = TargetToReactiveRecordMap.get(target);
-    if (!isUndefined$1(reactiveRecord)) {
-        const reactiveObservers = reactiveRecord[key];
-        if (!isUndefined$1(reactiveObservers)) {
-            for (let i = 0, len = reactiveObservers.length; i < len; i += 1) {
-                const ro = reactiveObservers[i];
-                ro.notify();
-            }
-        }
-    }
-}
-function valueObserved(target, key) {
-    // We should determine if an active Observing Record is present to track mutations.
-    {
-        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
- */
-const DUMMY_REACTIVE_OBSERVER = {
-    observe(job) {
-        job();
-    },
-    reset() { },
-    link() { },
-};
-function createReactiveObserver(callback) {
-    // On the server side, we don't need mutation tracking. Skipping it improves performance.
-    return DUMMY_REACTIVE_OBSERVER;
-}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -806,11 +696,25 @@ function addErrorComponentStack(vm, error) {
  * 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) {
+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);
+    }
     // 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 */
@@ -826,7 +730,96 @@ function log(method, message, vm) {
     }
 }
 function logError(message, vm) {
-    log('error', message, vm);
+    log('error', message, vm, false);
+}
+
+/*
+ * Copyright (c) 2019, 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 TargetToReactiveRecordMap = new WeakMap();
+function valueMutated(target, key) {
+    const reactiveRecord = TargetToReactiveRecordMap.get(target);
+    if (!isUndefined$1(reactiveRecord)) {
+        const reactiveObservers = reactiveRecord[key];
+        if (!isUndefined$1(reactiveObservers)) {
+            for (let i = 0, len = reactiveObservers.length; i < len; i += 1) {
+                const ro = reactiveObservers[i];
+                ro.notify();
+            }
+        }
+    }
+}
+function valueObserved(target, key) {
+    // We should determine if an active Observing Record is present to track mutations.
+    {
+        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
+ */
+const DUMMY_REACTIVE_OBSERVER = {
+    observe(job) {
+        job();
+    },
+    reset() { },
+    link() { },
+};
+function createReactiveObserver(callback) {
+    // On the server side, we don't need mutation tracking. Skipping it improves performance.
+    return DUMMY_REACTIVE_OBSERVER;
+}
+const SPACE_CHAR = 32;
+const EmptyObject = seal(create(null));
+const EmptyArray = seal([]);
+function guid() {
+    function s4() {
+        return Math.floor((1 + Math.random()) * 0x10000)
+            .toString(16)
+            .substring(1);
+    }
+    return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+}
+function flattenStylesheets(stylesheets) {
+    const list = [];
+    for (const stylesheet of stylesheets) {
+        if (!Array.isArray(stylesheet)) {
+            list.push(stylesheet);
+        }
+        else {
+            list.push(...flattenStylesheets(stylesheet));
+        }
+    }
+    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');
+    }
+    // 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;
+    }
+}
+// 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();
+    }
 }
 
 /*
@@ -881,7 +874,7 @@ function offsetPropertyErrorMessage(name) {
 //
 // 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',
     },
@@ -966,7 +959,7 @@ const globalHTMLProperties = assign(create(null), {
     role: {
         attribute: 'role',
     },
-});
+};
 let controlledElement = null;
 let controlledAttributeName;
 function isAttributeLocked(elm, attrName) {
@@ -1033,27 +1026,18 @@ function generateAccessorDescriptor(options) {
 }
 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({
@@ -1134,10 +1118,7 @@ function patchElementWithRestrictions(elm, options) {
     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.
@@ -1178,10 +1159,7 @@ function getShadowRootRestrictionsDescriptors(sr) {
 // 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');
@@ -1226,10 +1204,7 @@ function getCustomElementRestrictionsDescriptors(elm) {
     };
 }
 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() {
@@ -1243,10 +1218,7 @@ function getComponentRestrictionsDescriptors() {
     };
 }
 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({
@@ -1951,7 +1923,6 @@ function createBridgeToElementDescriptor(propName, descriptor) {
     }
   };
 }
-const EMPTY_REFS = freeze(create(null));
 const refsCache = new WeakMap();
 /**
  * This class is the base class for any LWC element.
@@ -2238,7 +2209,6 @@ LightningElement.prototype = {
     }
     const {
       refVNodes,
-      hasRefVNodes,
       cmpTemplate
     } = vm;
     // If the `cmpTemplate` is null, that means that the template has not been rendered yet. Most likely this occurs
@@ -2252,15 +2222,9 @@ LightningElement.prototype = {
     // 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.
@@ -2419,16 +2383,291 @@ function createObservedFieldPropertyDescriptor(key) {
  * 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);
+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) {
+  // creating the reactive observer for reactive params when needed
+  const ro = createReactiveObserver();
+  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;
+      }
+      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);
+}
+
+/*
+ * 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 api$1() {
+    if (process.env.NODE_ENV !== 'production') {
+        assert.fail(`@api decorator can only be used as a decorator function.`);
+    }
+    throw new Error();
+}
+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);
@@ -2784,8 +3023,8 @@ function getDecoratorsMeta(Ctor) {
  * 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;
@@ -3007,10 +3246,7 @@ const activeTemplates = new WeakMap();
 const activeComponents = new WeakMap();
 const activeStyles = new WeakMap();
 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);
@@ -3019,10 +3255,7 @@ function getTemplateOrSwappedTemplate(tpl) {
     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);
@@ -3031,10 +3264,7 @@ function getComponentOrSwappedComponent(Ctor) {
     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);
@@ -3043,10 +3273,7 @@ function getStyleOrSwappedStyle(style) {
     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);
@@ -3089,10 +3316,7 @@ function setActiveVM(vm) {
     }
 }
 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);
@@ -5143,10 +5367,7 @@ function setVMBeingRendered(vm) {
     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) {
@@ -5275,9 +5496,7 @@ function evaluateTemplate(vm, html) {
                 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 = [];
@@ -5292,220 +5511,32 @@ function evaluateTemplate(vm, html) {
     }, () => {
         // post
         isUpdatingTemplate = isUpdatingTemplateInception;
-        vmBeingRendered = vmOfTemplateBeingUpdatedInception;
-        logOperationEnd(1 /* OperationId.Render */, vm);
-    });
-    if (process.env.NODE_ENV !== 'production') {
-        assert.invariant(isArray$1(vnodes), `Compiler should produce html functions that always return an array.`);
-    }
-    return vnodes;
-}
-function computeHasScopedStylesInStylesheets(stylesheets) {
-    if (hasStyles(stylesheets)) {
-        for (let i = 0; i < stylesheets.length; i++) {
-            if (isTrue(stylesheets[i][KEY__SCOPED_CSS])) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function computeHasScopedStyles(template, vm) {
-    const { stylesheets } = template;
-    const vmStylesheets = !isUndefined$1(vm) ? vm.stylesheets : null;
-    return (computeHasScopedStylesInStylesheets(stylesheets) ||
-        computeHasScopedStylesInStylesheets(vmStylesheets));
-}
-function hasStyles(stylesheets) {
-    return !isUndefined$1(stylesheets) && !isNull(stylesheets) && stylesheets.length > 0;
-}
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-let isInvokingRender = false;
-let vmBeingConstructed = null;
-function isBeingConstructed(vm) {
-    return vmBeingConstructed === vm;
-}
-function invokeComponentCallback(vm, fn, args) {
-    const { component, callHook, owner } = vm;
-    runWithBoundaryProtection(vm, owner, noop, () => {
-        callHook(component, fn, args);
-    }, noop);
-}
-function invokeComponentConstructor(vm, Ctor) {
-    const vmBeingConstructedInception = vmBeingConstructed;
-    let error;
-    logOperationStart(0 /* OperationId.Constructor */, vm);
-    vmBeingConstructed = vm;
-    /**
-     * Constructors don't need to be wrapped with a boundary because for root elements
-     * it should throw, while elements from template are already wrapped by a boundary
-     * associated to the diffing algo.
-     */
-    try {
-        // job
-        const result = new Ctor();
-        // Check indirectly if the constructor result is an instance of LightningElement. Using
-        // the "instanceof" operator would not work here since Locker Service provides its own
-        // implementation of LightningElement, so we indirectly check if the base constructor is
-        // invoked by accessing the component on the vm.
-        if (vmBeingConstructed.component !== result) {
-            throw new TypeError('Invalid component constructor, the class should extend LightningElement.');
-        }
-    }
-    catch (e) {
-        error = Object(e);
-    }
-    finally {
-        logOperationEnd(0 /* OperationId.Constructor */, vm);
-        vmBeingConstructed = vmBeingConstructedInception;
-        if (!isUndefined$1(error)) {
-            addErrorComponentStack(vm, error);
-            // re-throwing the original error annotated after restoring the context
-            throw error; // eslint-disable-line no-unsafe-finally
-        }
-    }
-}
-function invokeComponentRenderMethod(vm) {
-    const { def: { render }, callHook, component, owner, } = vm;
-    const isRenderBeingInvokedInception = isInvokingRender;
-    const vmBeingRenderedInception = getVMBeingRendered();
-    let html;
-    let renderInvocationSuccessful = false;
-    runWithBoundaryProtection(vm, owner, () => {
-        // pre
-        isInvokingRender = true;
-        setVMBeingRendered(vm);
-    }, () => {
-        // job
-        vm.tro.observe(() => {
-            html = callHook(component, render);
-            renderInvocationSuccessful = true;
-        });
-    }, () => {
-        // post
-        isInvokingRender = isRenderBeingInvokedInception;
-        setVMBeingRendered(vmBeingRenderedInception);
-    });
-    // If render() invocation failed, process errorCallback in boundary and return an empty template
-    return renderInvocationSuccessful ? evaluateTemplate(vm, html) : [];
-}
-function invokeEventListener(vm, fn, thisValue, event) {
-    const { callHook, owner } = vm;
-    runWithBoundaryProtection(vm, owner, noop, () => {
-        // job
-        if (process.env.NODE_ENV !== 'production') {
-            assert.isTrue(isFunction$1(fn), `Invalid event handler for event '${event.type}' on ${vm}.`);
-        }
-        callHook(thisValue, fn, [event]);
-    }, noop);
-}
-
-/*
- * 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 signedTemplateMap = new Map();
-/**
- * INTERNAL: This function can only be invoked by compiled code. The compiler
- * will prevent this function from being imported by userland code.
- */
-function registerComponent(
-// We typically expect a LightningElementConstructor, but technically you can call this with anything
-Ctor, { tmpl }) {
-    if (isFunction$1(Ctor)) {
-        if (process.env.NODE_ENV !== 'production') {
-            checkVersionMismatch(Ctor, 'component');
-        }
-        signedTemplateMap.set(Ctor, tmpl);
-    }
-    // chaining this method as a way to wrap existing assignment of component constructor easily,
-    // without too much transformation
-    return Ctor;
-}
-function getComponentRegisteredTemplate(Ctor) {
-    return signedTemplateMap.get(Ctor);
-}
-function getTemplateReactiveObserver(vm) {
-    return createReactiveObserver();
-}
-function renderComponent$1(vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        assert.invariant(vm.isDirty, `${vm} is not dirty.`);
-    }
-    vm.tro.reset();
-    const vnodes = invokeComponentRenderMethod(vm);
-    vm.isDirty = false;
-    vm.isScheduled = false;
-    return vnodes;
-}
-function markComponentAsDirty(vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        const vmBeingRendered = getVMBeingRendered();
-        assert.isFalse(vm.isDirty, `markComponentAsDirty() for ${vm} should not be called when the component is already dirty.`);
-        assert.isFalse(isInvokingRender, `markComponentAsDirty() for ${vm} cannot be called during rendering of ${vmBeingRendered}.`);
-        assert.isFalse(isUpdatingTemplate, `markComponentAsDirty() for ${vm} cannot be called while updating template of ${vmBeingRendered}.`);
-    }
-    vm.isDirty = true;
-}
-const cmpEventListenerMap = new WeakMap();
-function getWrappedComponentsListener(vm, listener) {
-    if (!isFunction$1(listener)) {
-        throw new TypeError(); // avoiding problems with non-valid listeners
-    }
-    let wrappedListener = cmpEventListenerMap.get(listener);
-    if (isUndefined$1(wrappedListener)) {
-        wrappedListener = function (event) {
-            invokeEventListener(vm, listener, undefined, event);
-        };
-        cmpEventListenerMap.set(listener, wrappedListener);
-    }
-    return wrappedListener;
-}
-
-/*
- * 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 Services = create(null);
-const hooks = ['rendered', 'connected', 'disconnected'];
-/**
- * EXPERIMENTAL: This function allows for the registration of "services"
- * in LWC by exposing hooks into the component life-cycle. This API is
- * subject to change or being removed.
- */
-function register(service) {
+        vmBeingRendered = vmOfTemplateBeingUpdatedInception;
+        logOperationEnd(1 /* OperationId.Render */, vm);
+    });
     if (process.env.NODE_ENV !== 'production') {
-        assert.isTrue(isObject(service), `Invalid service declaration, ${service}: service must be an object`);
+        assert.invariant(isArray$1(vnodes), `Compiler should produce html functions that always return an array.`);
     }
-    for (let i = 0; i < hooks.length; ++i) {
-        const hookName = hooks[i];
-        if (hookName in service) {
-            let l = Services[hookName];
-            if (isUndefined$1(l)) {
-                Services[hookName] = l = [];
+    return vnodes;
+}
+function computeHasScopedStylesInStylesheets(stylesheets) {
+    if (hasStyles(stylesheets)) {
+        for (let i = 0; i < stylesheets.length; i++) {
+            if (isTrue(stylesheets[i][KEY__SCOPED_CSS])) {
+                return true;
             }
-            ArrayPush$1.call(l, service[hookName]);
         }
     }
+    return false;
 }
-function invokeServiceHook(vm, cbs) {
-    if (process.env.NODE_ENV !== 'production') {
-        assert.isTrue(isArray$1(cbs) && cbs.length > 0, `Optimize invokeServiceHook() to be invoked only when needed`);
-    }
-    const { component, def, context } = vm;
-    for (let i = 0, len = cbs.length; i < len; ++i) {
-        cbs[i].call(undefined, component, {}, def, context);
-    }
+function computeHasScopedStyles(template, vm) {
+    const { stylesheets } = template;
+    const vmStylesheets = !isUndefined$1(vm) ? vm.stylesheets : null;
+    return (computeHasScopedStylesInStylesheets(stylesheets) ||
+        computeHasScopedStylesInStylesheets(vmStylesheets));
+}
+function hasStyles(stylesheets) {
+    return !isUndefined$1(stylesheets) && !isNull(stylesheets) && stylesheets.length > 0;
 }
 
 /*
@@ -5514,742 +5545,654 @@ function invokeServiceHook(vm, cbs) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-let idx = 0;
-/** The internal slot used to associate different objects the engine manipulates with the VM */
-const ViewModelReflection = new WeakMap();
-function callHook(cmp, fn, args = []) {
-  return fn.apply(cmp, args);
-}
-function setHook(cmp, prop, newValue) {
-  cmp[prop] = newValue;
-}
-function getHook(cmp, prop) {
-  return cmp[prop];
-}
-function rerenderVM(vm) {
-  rehydrate(vm);
-}
-function connectRootElement(elm) {
-  const vm = getAssociatedVM(elm);
-  logGlobalOperationStart(7 /* OperationId.GlobalHydrate */, vm);
-  // Usually means moving the element from one place to another, which is observable via
-  // life-cycle hooks.
-  if (vm.state === 1 /* VMState.connected */) {
-    disconnectRootElement(elm);
-  }
-  runConnectedCallback(vm);
-  rehydrate(vm);
-  logGlobalOperationEnd(7 /* OperationId.GlobalHydrate */, vm);
-}
-function disconnectRootElement(elm) {
-  const vm = getAssociatedVM(elm);
-  resetComponentStateWhenRemoved(vm);
-}
-function appendVM(vm) {
-  rehydrate(vm);
-}
-// just in case the component comes back, with this we guarantee re-rendering it
-// while preventing any attempt to rehydration until after reinsertion.
-function resetComponentStateWhenRemoved(vm) {
-  const {
-    state
-  } = vm;
-  if (state !== 2 /* VMState.disconnected */) {
-    const {
-      tro
-    } = vm;
-    // Making sure that any observing record will not trigger the rehydrated on this vm
-    tro.reset();
-    runDisconnectedCallback(vm);
-    // Spec: https://dom.spec.whatwg.org/#concept-node-remove (step 14-15)
-    runChildNodesDisconnectedCallback(vm);
-    runLightChildNodesDisconnectedCallback(vm);
-  }
-  if (process.env.NODE_ENV !== 'production') {
-    removeActiveVM(vm);
-  }
-}
-// this method is triggered by the diffing algo only when a vnode from the
-// old vnode.children is removed from the DOM.
-function removeVM(vm) {
-  if (process.env.NODE_ENV !== 'production') {
-    assert.isTrue(vm.state === 1 /* VMState.connected */ || vm.state === 2 /* VMState.disconnected */, `${vm} must have been connected.`);
-  }
-  resetComponentStateWhenRemoved(vm);
+let isInvokingRender = false;
+let vmBeingConstructed = null;
+function isBeingConstructed(vm) {
+    return vmBeingConstructed === vm;
 }
-function getNearestShadowAncestor(vm) {
-  let ancestor = vm.owner;
-  while (!isNull(ancestor) && ancestor.renderMode === 0 /* RenderMode.Light */) {
-    ancestor = ancestor.owner;
-  }
-  return ancestor;
+function invokeComponentCallback(vm, fn, args) {
+    const { component, callHook, owner } = vm;
+    runWithBoundaryProtection(vm, owner, noop, () => {
+        callHook(component, fn, args);
+    }, noop);
 }
-function createVM(elm, ctor, renderer, options) {
-  const {
-    mode,
-    owner,
-    tagName,
-    hydrated
-  } = options;
-  const def = getComponentInternalDef(ctor);
-  const vm = {
-    elm,
-    def,
-    idx: idx++,
-    state: 0 /* VMState.created */,
-    isScheduled: false,
-    isDirty: true,
-    tagName,
-    mode,
-    owner,
-    refVNodes: null,
-    hasRefVNodes: false,
-    children: EmptyArray,
-    aChildren: EmptyArray,
-    velements: EmptyArray,
-    cmpProps: create(null),
-    cmpFields: create(null),
-    cmpSlots: {
-      slotAssignments: create(null)
-    },
-    cmpTemplate: null,
-    hydrated: Boolean(hydrated),
-    renderMode: def.renderMode,
-    context: {
-      stylesheetToken: undefined,
-      hasTokenInClass: undefined,
-      hasTokenInAttribute: undefined,
-      hasScopedStyles: undefined,
-      styleVNodes: null,
-      tplCache: EmptyObject,
-      wiredConnecting: EmptyArray,
-      wiredDisconnecting: EmptyArray
-    },
-    // Properties set right after VM creation.
-    tro: null,
-    shadowMode: null,
-    stylesheets: null,
-    // Properties set by the LightningElement constructor.
-    component: null,
-    shadowRoot: null,
-    renderRoot: null,
-    callHook,
-    setHook,
-    getHook,
-    renderer
-  };
-  if (process.env.NODE_ENV !== 'production') {
-    vm.debugInfo = create(null);
-  }
-  vm.stylesheets = computeStylesheets(vm, def.ctor);
-  vm.shadowMode = computeShadowMode(vm, renderer);
-  vm.tro = getTemplateReactiveObserver();
-  if (process.env.NODE_ENV !== 'production') {
-    vm.toString = () => {
-      return `[object:vm ${def.name} (${vm.idx})]`;
-    };
-    if (lwcRuntimeFlags.ENABLE_FORCE_NATIVE_SHADOW_MODE_FOR_TEST) {
-      vm.shadowMode = 0 /* ShadowMode.Native */;
+function invokeComponentConstructor(vm, Ctor) {
+    const vmBeingConstructedInception = vmBeingConstructed;
+    let error;
+    logOperationStart(0 /* OperationId.Constructor */, vm);
+    vmBeingConstructed = vm;
+    /**
+     * Constructors don't need to be wrapped with a boundary because for root elements
+     * it should throw, while elements from template are already wrapped by a boundary
+     * associated to the diffing algo.
+     */
+    try {
+        // job
+        const result = new Ctor();
+        // Check indirectly if the constructor result is an instance of LightningElement. Using
+        // the "instanceof" operator would not work here since Locker Service provides its own
+        // implementation of LightningElement, so we indirectly check if the base constructor is
+        // invoked by accessing the component on the vm.
+        if (vmBeingConstructed.component !== result) {
+            throw new TypeError('Invalid component constructor, the class should extend LightningElement.');
+        }
     }
-  }
-  // Create component instance associated to the vm and the element.
-  invokeComponentConstructor(vm, def.ctor);
-  // Initializing the wire decorator per instance only when really needed
-  if (hasWireAdapters(vm)) {
-    installWireAdapters(vm);
-  }
-  return vm;
-}
-function validateComponentStylesheets(vm, stylesheets) {
-  let valid = true;
-  const validate = arrayOrStylesheet => {
-    if (isArray$1(arrayOrStylesheet)) {
-      for (let i = 0; i < arrayOrStylesheet.length; i++) {
-        validate(arrayOrStylesheet[i]);
-      }
-    } else if (!isFunction$1(arrayOrStylesheet)) {
-      // function assumed to be a stylesheet factory
-      valid = false;
+    catch (e) {
+        error = Object(e);
     }
-  };
-  if (!isArray$1(stylesheets)) {
-    valid = false;
-  } else {
-    validate(stylesheets);
-  }
-  return valid;
+    finally {
+        logOperationEnd(0 /* OperationId.Constructor */, vm);
+        vmBeingConstructed = vmBeingConstructedInception;
+        if (!isUndefined$1(error)) {
+            addErrorComponentStack(vm, error);
+            // re-throwing the original error annotated after restoring the context
+            throw error; // eslint-disable-line no-unsafe-finally
+        }
+    }
+}
+function invokeComponentRenderMethod(vm) {
+    const { def: { render }, callHook, component, owner, } = vm;
+    const isRenderBeingInvokedInception = isInvokingRender;
+    const vmBeingRenderedInception = getVMBeingRendered();
+    let html;
+    let renderInvocationSuccessful = false;
+    runWithBoundaryProtection(vm, owner, () => {
+        // pre
+        isInvokingRender = true;
+        setVMBeingRendered(vm);
+    }, () => {
+        // job
+        vm.tro.observe(() => {
+            html = callHook(component, render);
+            renderInvocationSuccessful = true;
+        });
+    }, () => {
+        // post
+        isInvokingRender = isRenderBeingInvokedInception;
+        setVMBeingRendered(vmBeingRenderedInception);
+    });
+    // If render() invocation failed, process errorCallback in boundary and return an empty template
+    return renderInvocationSuccessful ? evaluateTemplate(vm, html) : [];
 }
-// Validate and flatten any stylesheets defined as `static stylesheets`
-function computeStylesheets(vm, ctor) {
-  if (lwcRuntimeFlags.ENABLE_PROGRAMMATIC_STYLESHEETS) {
-    const {
-      stylesheets
-    } = ctor;
-    if (!isUndefined$1(stylesheets)) {
-      const valid = validateComponentStylesheets(vm, stylesheets);
-      if (valid) {
-        return flattenStylesheets(stylesheets);
-      } else if (process.env.NODE_ENV !== 'production') {
-        logError(`static stylesheets must be an array of CSS stylesheets. Found invalid stylesheets on <${vm.tagName}>`, vm);
-      }
-    }
-  }
-  return null;
+function invokeEventListener(vm, fn, thisValue, event) {
+    const { callHook, owner } = vm;
+    runWithBoundaryProtection(vm, owner, noop, () => {
+        // job
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isTrue(isFunction$1(fn), `Invalid event handler for event '${event.type}' on ${vm}.`);
+        }
+        callHook(thisValue, fn, [event]);
+    }, noop);
 }
-function computeShadowMode(vm, renderer) {
-  const {
-    def
-  } = vm;
-  const {
-    isSyntheticShadowDefined,
-    isNativeShadowDefined
-  } = renderer;
-  let shadowMode;
-  if (isSyntheticShadowDefined) {
-    if (def.renderMode === 0 /* RenderMode.Light */) {
-      // ShadowMode.Native implies "not synthetic shadow" which is consistent with how
-      // everything defaults to native when the synthetic shadow polyfill is unavailable.
-      shadowMode = 0 /* ShadowMode.Native */;
-    } else if (isNativeShadowDefined) {
-      // Not combined with above condition because @lwc/features only supports identifiers in
-      // the if-condition.
-      if (lwcRuntimeFlags.ENABLE_MIXED_SHADOW_MODE) {
-        if (def.shadowSupportMode === "any" /* ShadowSupportMode.Any */) {
-          shadowMode = 0 /* ShadowMode.Native */;
-        } else {
-          const shadowAncestor = getNearestShadowAncestor(vm);
-          if (!isNull(shadowAncestor) && shadowAncestor.shadowMode === 0 /* ShadowMode.Native */) {
-            // Transitive support for native Shadow DOM. A component in native mode
-            // transitively opts all of its descendants into native.
-            shadowMode = 0 /* ShadowMode.Native */;
-          } else {
-            // Synthetic if neither this component nor any of its ancestors are configured
-            // to be native.
-            shadowMode = 1 /* ShadowMode.Synthetic */;
-          }
+
+/*
+ * 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 signedTemplateMap = new Map();
+/**
+ * INTERNAL: This function can only be invoked by compiled code. The compiler
+ * will prevent this function from being imported by userland code.
+ */
+function registerComponent(
+// We typically expect a LightningElementConstructor, but technically you can call this with anything
+Ctor, { tmpl }) {
+    if (isFunction$1(Ctor)) {
+        if (process.env.NODE_ENV !== 'production') {
+            checkVersionMismatch(Ctor, 'component');
         }
-      } else {
-        shadowMode = 1 /* ShadowMode.Synthetic */;
-      }
-    } else {
-      // Synthetic if there is no native Shadow DOM support.
-      shadowMode = 1 /* ShadowMode.Synthetic */;
+        signedTemplateMap.set(Ctor, tmpl);
     }
-  } else {
-    // Native if the synthetic shadow polyfill is unavailable.
-    shadowMode = 0 /* ShadowMode.Native */;
-  }
-
-  return shadowMode;
-}
-function assertIsVM(obj) {
-  if (isNull(obj) || !isObject(obj) || !('renderRoot' in obj)) {
-    throw new TypeError(`${obj} is not a VM.`);
-  }
+    // chaining this method as a way to wrap existing assignment of component constructor easily,
+    // without too much transformation
+    return Ctor;
 }
-function associateVM(obj, vm) {
-  ViewModelReflection.set(obj, vm);
+function getComponentRegisteredTemplate(Ctor) {
+    return signedTemplateMap.get(Ctor);
 }
-function getAssociatedVM(obj) {
-  const vm = ViewModelReflection.get(obj);
-  if (process.env.NODE_ENV !== 'production') {
-    assertIsVM(vm);
-  }
-  return vm;
+function getTemplateReactiveObserver(vm) {
+    return createReactiveObserver();
 }
-function getAssociatedVMIfPresent(obj) {
-  const maybeVm = ViewModelReflection.get(obj);
-  if (process.env.NODE_ENV !== 'production') {
-    if (!isUndefined$1(maybeVm)) {
-      assertIsVM(maybeVm);
+function renderComponent$1(vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        assert.invariant(vm.isDirty, `${vm} is not dirty.`);
     }
-  }
-  return maybeVm;
+    vm.tro.reset();
+    const vnodes = invokeComponentRenderMethod(vm);
+    vm.isDirty = false;
+    vm.isScheduled = false;
+    return vnodes;
 }
-function rehydrate(vm) {
-  if (isTrue(vm.isDirty)) {
-    const children = renderComponent$1(vm);
-    patchShadowRoot(vm, children);
-  }
+function markComponentAsDirty(vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        const vmBeingRendered = getVMBeingRendered();
+        assert.isFalse(vm.isDirty, `markComponentAsDirty() for ${vm} should not be called when the component is already dirty.`);
+        assert.isFalse(isInvokingRender, `markComponentAsDirty() for ${vm} cannot be called during rendering of ${vmBeingRendered}.`);
+        assert.isFalse(isUpdatingTemplate, `markComponentAsDirty() for ${vm} cannot be called while updating template of ${vmBeingRendered}.`);
+    }
+    vm.isDirty = true;
 }
-function patchShadowRoot(vm, newCh) {
-  const {
-    renderRoot,
-    children: oldCh,
-    renderer
-  } = vm;
-  // caching the new children collection
-  vm.children = newCh;
-  if (newCh.length > 0 || oldCh.length > 0) {
-    // patch function mutates vnodes by adding the element reference,
-    // however, if patching fails it contains partial changes.
-    if (oldCh !== newCh) {
-      runWithBoundaryProtection(vm, vm, () => {
-        // pre
-        logOperationStart(2 /* OperationId.Patch */, vm);
-      }, () => {
-        // job
-        patchChildren(oldCh, newCh, renderRoot, renderer);
-      }, () => {
-        // post
-        logOperationEnd(2 /* OperationId.Patch */, vm);
-      });
+const cmpEventListenerMap = new WeakMap();
+function getWrappedComponentsListener(vm, listener) {
+    if (!isFunction$1(listener)) {
+        throw new TypeError('Expected an EventListener but received ' + typeof listener); // avoiding problems with non-valid listeners
     }
-  }
-  if (vm.state === 1 /* VMState.connected */) ;
+    let wrappedListener = cmpEventListenerMap.get(listener);
+    if (isUndefined$1(wrappedListener)) {
+        wrappedListener = function (event) {
+            invokeEventListener(vm, listener, undefined, event);
+        };
+        cmpEventListenerMap.set(listener, wrappedListener);
+    }
+    return wrappedListener;
 }
 
-function runConnectedCallback(vm) {
-  const {
-    state
-  } = vm;
-  if (state === 1 /* VMState.connected */) {
-    return; // nothing to do since it was already connected
-  }
+/*
+ * 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 Services = create(null);
+const hooks = ['rendered', 'connected', 'disconnected'];
+/**
+ * EXPERIMENTAL: This function allows for the registration of "services"
+ * in LWC by exposing hooks into the component life-cycle. This API is
+ * subject to change or being removed.
+ */
+function register(service) {
+    if (process.env.NODE_ENV !== 'production') {
+        assert.isTrue(isObject(service), `Invalid service declaration, ${service}: service must be an object`);
+    }
+    for (let i = 0; i < hooks.length; ++i) {
+        const hookName = hooks[i];
+        if (hookName in service) {
+            let l = Services[hookName];
+            if (isUndefined$1(l)) {
+                Services[hookName] = l = [];
+            }
+            ArrayPush$1.call(l, service[hookName]);
+        }
+    }
+}
+function invokeServiceHook(vm, cbs) {
+    if (process.env.NODE_ENV !== 'production') {
+        assert.isTrue(isArray$1(cbs) && cbs.length > 0, `Optimize invokeServiceHook() to be invoked only when needed`);
+    }
+    const { component, def, context } = vm;
+    for (let i = 0, len = cbs.length; i < len; ++i) {
+        cbs[i].call(undefined, component, {}, def, context);
+    }
+}
 
-  vm.state = 1 /* VMState.connected */;
-  // reporting connection
-  const {
-    connected
-  } = Services;
-  if (connected) {
-    invokeServiceHook(vm, connected);
-  }
-  if (hasWireAdapters(vm)) {
-    connectWireAdapters(vm);
-  }
-  const {
-    connectedCallback
-  } = vm.def;
-  if (!isUndefined$1(connectedCallback)) {
-    logOperationStart(3 /* OperationId.ConnectedCallback */, vm);
-    invokeComponentCallback(vm, connectedCallback);
-    logOperationEnd(3 /* OperationId.ConnectedCallback */, 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
+ */
+let idx = 0;
+/** The internal slot used to associate different objects the engine manipulates with the VM */
+const ViewModelReflection = new WeakMap();
+function callHook(cmp, fn, args = []) {
+  return fn.apply(cmp, args);
+}
+function setHook(cmp, prop, newValue) {
+  cmp[prop] = newValue;
+}
+function getHook(cmp, prop) {
+  return cmp[prop];
+}
+function rerenderVM(vm) {
+  rehydrate(vm);
+}
+function connectRootElement(elm) {
+  const vm = getAssociatedVM(elm);
+  logGlobalOperationStart(7 /* OperationId.GlobalHydrate */, vm);
+  // Usually means moving the element from one place to another, which is observable via
+  // life-cycle hooks.
+  if (vm.state === 1 /* VMState.connected */) {
+    disconnectRootElement(elm);
   }
+  runConnectedCallback(vm);
+  rehydrate(vm);
+  logGlobalOperationEnd(7 /* OperationId.GlobalHydrate */, vm);
 }
-function hasWireAdapters(vm) {
-  return getOwnPropertyNames$1(vm.def.wire).length > 0;
+function disconnectRootElement(elm) {
+  const vm = getAssociatedVM(elm);
+  resetComponentStateWhenRemoved(vm);
 }
-function runDisconnectedCallback(vm) {
-  if (process.env.NODE_ENV !== 'production') {
-    assert.isTrue(vm.state !== 2 /* VMState.disconnected */, `${vm} must be inserted.`);
-  }
-  if (isFalse(vm.isDirty)) {
-    // this guarantees that if the component is reused/reinserted,
-    // it will be re-rendered because we are disconnecting the reactivity
-    // linking, so mutations are not automatically reflected on the state
-    // of disconnected components.
-    vm.isDirty = true;
-  }
-  vm.state = 2 /* VMState.disconnected */;
-  // reporting disconnection
-  const {
-    disconnected
-  } = Services;
-  if (disconnected) {
-    invokeServiceHook(vm, disconnected);
-  }
-  if (hasWireAdapters(vm)) {
-    disconnectWireAdapters(vm);
-  }
-  const {
-    disconnectedCallback
-  } = vm.def;
-  if (!isUndefined$1(disconnectedCallback)) {
-    logOperationStart(5 /* OperationId.DisconnectedCallback */, vm);
-    invokeComponentCallback(vm, disconnectedCallback);
-    logOperationEnd(5 /* OperationId.DisconnectedCallback */, vm);
-  }
+function appendVM(vm) {
+  rehydrate(vm);
 }
-function runChildNodesDisconnectedCallback(vm) {
+// just in case the component comes back, with this we guarantee re-rendering it
+// while preventing any attempt to rehydration until after reinsertion.
+function resetComponentStateWhenRemoved(vm) {
   const {
-    velements: vCustomElementCollection
+    state
   } = vm;
-  // Reporting disconnection for every child in inverse order since they are
-  // inserted in reserved order.
-  for (let i = vCustomElementCollection.length - 1; i >= 0; i -= 1) {
+  if (state !== 2 /* VMState.disconnected */) {
     const {
-      elm
-    } = vCustomElementCollection[i];
-    // There are two cases where the element could be undefined:
-    // * when there is an error during the construction phase, and an error
-    //   boundary picks it, there is a possibility that the VCustomElement
-    //   is not properly initialized, and therefore is should be ignored.
-    // * when slotted custom element is not used by the element where it is
-    //   slotted into it, as  a result, the custom element was never
-    //   initialized.
-    if (!isUndefined$1(elm)) {
-      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);
-      }
-    }
+      tro
+    } = vm;
+    // Making sure that any observing record will not trigger the rehydrated on this vm
+    tro.reset();
+    runDisconnectedCallback(vm);
+    // Spec: https://dom.spec.whatwg.org/#concept-node-remove (step 14-15)
+    runChildNodesDisconnectedCallback(vm);
+    runLightChildNodesDisconnectedCallback(vm);
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    removeActiveVM(vm);
   }
 }
-function runLightChildNodesDisconnectedCallback(vm) {
-  const {
-    aChildren: adoptedChildren
-  } = vm;
-  recursivelyDisconnectChildren(adoptedChildren);
+// this method is triggered by the diffing algo only when a vnode from the
+// old vnode.children is removed from the DOM.
+function removeVM(vm) {
+  if (process.env.NODE_ENV !== 'production') {
+    assert.isTrue(vm.state === 1 /* VMState.connected */ || vm.state === 2 /* VMState.disconnected */, `${vm} must have been connected.`);
+  }
+  resetComponentStateWhenRemoved(vm);
 }
-/**
- * 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;
-          }
-      }
-    }
+function getNearestShadowAncestor(vm) {
+  let ancestor = vm.owner;
+  while (!isNull(ancestor) && ancestor.renderMode === 0 /* RenderMode.Light */) {
+    ancestor = ancestor.owner;
   }
+  return ancestor;
 }
-// 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) {
+function createVM(elm, ctor, renderer, options) {
   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);
+    mode,
+    owner,
+    tagName,
+    hydrated
+  } = options;
+  const def = getComponentInternalDef(ctor);
+  const vm = {
+    elm,
+    def,
+    idx: idx++,
+    state: 0 /* VMState.created */,
+    isScheduled: false,
+    isDirty: true,
+    tagName,
+    mode,
+    owner,
+    refVNodes: null,
+    children: EmptyArray,
+    aChildren: EmptyArray,
+    velements: EmptyArray,
+    cmpProps: create(null),
+    cmpFields: create(null),
+    cmpSlots: {
+      slotAssignments: create(null)
+    },
+    cmpTemplate: null,
+    hydrated: Boolean(hydrated),
+    renderMode: def.renderMode,
+    context: {
+      stylesheetToken: undefined,
+      hasTokenInClass: undefined,
+      hasTokenInAttribute: undefined,
+      hasScopedStyles: undefined,
+      styleVNodes: null,
+      tplCache: EmptyObject,
+      wiredConnecting: EmptyArray,
+      wiredDisconnecting: EmptyArray
+    },
+    // Properties set right after VM creation.
+    tro: null,
+    shadowMode: null,
+    stylesheets: null,
+    // Properties set by the LightningElement constructor.
+    component: null,
+    shadowRoot: null,
+    renderRoot: null,
+    callHook,
+    setHook,
+    getHook,
+    renderer
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    vm.debugInfo = create(null);
+  }
+  vm.stylesheets = computeStylesheets(vm, def.ctor);
+  vm.shadowMode = computeShadowMode(vm, renderer);
+  vm.tro = getTemplateReactiveObserver();
+  if (process.env.NODE_ENV !== 'production') {
+    vm.toString = () => {
+      return `[object:vm ${def.name} (${vm.idx})]`;
+    };
+    if (lwcRuntimeFlags.ENABLE_FORCE_NATIVE_SHADOW_MODE_FOR_TEST) {
+      vm.shadowMode = 0 /* ShadowMode.Native */;
     }
   }
-  vm.children = EmptyArray;
-  runChildNodesDisconnectedCallback(vm);
-  vm.velements = EmptyArray;
+  // Create component instance associated to the vm and the element.
+  invokeComponentConstructor(vm, def.ctor);
+  // Initializing the wire decorator per instance only when really needed
+  if (hasWireAdapters(vm)) {
+    installWireAdapters(vm);
+  }
+  return vm;
 }
-function getErrorBoundaryVM(vm) {
-  let currentVm = vm;
-  while (!isNull(currentVm)) {
-    if (!isUndefined$1(currentVm.def.errorCallback)) {
-      return currentVm;
+function validateComponentStylesheets(vm, stylesheets) {
+  let valid = true;
+  const validate = arrayOrStylesheet => {
+    if (isArray$1(arrayOrStylesheet)) {
+      for (let i = 0; i < arrayOrStylesheet.length; i++) {
+        validate(arrayOrStylesheet[i]);
+      }
+    } else if (!isFunction$1(arrayOrStylesheet)) {
+      // function assumed to be a stylesheet factory
+      valid = false;
     }
-    currentVm = currentVm.owner;
+  };
+  if (!isArray$1(stylesheets)) {
+    valid = false;
+  } else {
+    validate(stylesheets);
   }
+  return valid;
 }
-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
+// Validate and flatten any stylesheets defined as `static stylesheets`
+function computeStylesheets(vm, ctor) {
+  if (lwcRuntimeFlags.ENABLE_PROGRAMMATIC_STYLESHEETS) {
+    const {
+      stylesheets
+    } = ctor;
+    if (!isUndefined$1(stylesheets)) {
+      const valid = validateComponentStylesheets(vm, stylesheets);
+      if (valid) {
+        return flattenStylesheets(stylesheets);
+      } else if (process.env.NODE_ENV !== 'production') {
+        logError(`static stylesheets must be an array of CSS stylesheets. Found invalid stylesheets on <${vm.tagName}>`, vm);
       }
-
-      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);
     }
   }
+  return null;
 }
-
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-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 computeShadowMode(vm, renderer) {
+  const {
+    def
+  } = vm;
+  const {
+    isSyntheticShadowDefined,
+    isNativeShadowDefined
+  } = renderer;
+  let shadowMode;
+  if (isSyntheticShadowDefined) {
+    if (def.renderMode === 0 /* RenderMode.Light */) {
+      // ShadowMode.Native implies "not synthetic shadow" which is consistent with how
+      // everything defaults to native when the synthetic shadow polyfill is unavailable.
+      shadowMode = 0 /* ShadowMode.Native */;
+    } else if (isNativeShadowDefined) {
+      // Not combined with above condition because @lwc/features only supports identifiers in
+      // the if-condition.
+      if (lwcRuntimeFlags.ENABLE_MIXED_SHADOW_MODE) {
+        if (def.shadowSupportMode === "any" /* ShadowSupportMode.Any */) {
+          shadowMode = 0 /* ShadowMode.Native */;
+        } else {
+          const shadowAncestor = getNearestShadowAncestor(vm);
+          if (!isNull(shadowAncestor) && shadowAncestor.shadowMode === 0 /* ShadowMode.Native */) {
+            // Transitive support for native Shadow DOM. A component in native mode
+            // transitively opts all of its descendants into native.
+            shadowMode = 0 /* ShadowMode.Native */;
+          } else {
+            // Synthetic if neither this component nor any of its ancestors are configured
+            // to be native.
+            shadowMode = 1 /* ShadowMode.Synthetic */;
+          }
+        }
+      } else {
+        shadowMode = 1 /* ShadowMode.Synthetic */;
       }
-    });
+    } else {
+      // Synthetic if there is no native Shadow DOM support.
+      shadowMode = 1 /* ShadowMode.Synthetic */;
+    }
+  } else {
+    // Native if the synthetic shadow polyfill is unavailable.
+    shadowMode = 0 /* ShadowMode.Native */;
   }
+
+  return shadowMode;
 }
-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 assertIsVM(obj) {
+  if (isNull(obj) || !isObject(obj) || !('renderRoot' in obj)) {
+    throw new TypeError(`${obj} is not a VM.`);
+  }
 }
-function createConfigWatcher(component, configCallback, callbackWhenConfigIsReady) {
-  // creating the reactive observer for reactive params when needed
-  const ro = createReactiveObserver();
-  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 associateVM(obj, vm) {
+  ViewModelReflection.set(obj, vm);
 }
-function createContextWatcher(vm, wireDef, callbackWhenContextIsReady) {
-  const {
-    adapter
-  } = wireDef;
-  const adapterContextToken = getAdapterToken(adapter);
-  if (isUndefined$1(adapterContextToken)) {
-    return; // no provider found, nothing to be done
+function getAssociatedVM(obj) {
+  const vm = ViewModelReflection.get(obj);
+  if (process.env.NODE_ENV !== 'production') {
+    assertIsVM(vm);
   }
-
-  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);
-  });
+  return vm;
 }
-function createConnector(vm, name, wireDef) {
-  const {
-    method,
-    adapter,
-    configCallback,
-    dynamic
-  } = wireDef;
-  let debugInfo;
+function getAssociatedVMIfPresent(obj) {
+  const maybeVm = ViewModelReflection.get(obj);
   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;
+    if (!isUndefined$1(maybeVm)) {
+      assertIsVM(maybeVm);
     }
-    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.
+  }
+  return maybeVm;
+}
+function rehydrate(vm) {
+  if (isTrue(vm.isDirty)) {
+    const children = renderComponent$1(vm);
+    patchShadowRoot(vm, children);
+  }
+}
+function patchShadowRoot(vm, newCh) {
   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();
-        }
-      }
-    });
+    renderRoot,
+    children: oldCh,
+    renderer
+  } = vm;
+  // caching the new children collection
+  vm.children = newCh;
+  if (newCh.length > 0 || oldCh.length > 0) {
+    // patch function mutates vnodes by adding the element reference,
+    // however, if patching fails it contains partial changes.
+    if (oldCh !== newCh) {
+      runWithBoundaryProtection(vm, vm, () => {
+        // pre
+        logOperationStart(2 /* OperationId.Patch */, vm);
+      }, () => {
+        // job
+        patchChildren(oldCh, newCh, renderRoot, renderer);
+      }, () => {
+        // post
+        logOperationEnd(2 /* OperationId.Patch */, vm);
+      });
+    }
   }
-  return {
-    // @ts-ignore the boundary protection executes sync, connector is always defined
-    connector,
-    computeConfigAndUpdate,
-    resetConfigWatcher: () => ro.reset()
-  };
+  if (vm.state === 1 /* VMState.connected */) ;
 }
-const AdapterToTokenMap = new Map();
-function getAdapterToken(adapter) {
-  return AdapterToTokenMap.get(adapter);
+
+function runConnectedCallback(vm) {
+  const {
+    state
+  } = vm;
+  if (state === 1 /* VMState.connected */) {
+    return; // nothing to do since it was already connected
+  }
+
+  vm.state = 1 /* VMState.connected */;
+  // reporting connection
+  const {
+    connected
+  } = Services;
+  if (connected) {
+    invokeServiceHook(vm, connected);
+  }
+  if (hasWireAdapters(vm)) {
+    connectWireAdapters(vm);
+  }
+  const {
+    connectedCallback
+  } = vm.def;
+  if (!isUndefined$1(connectedCallback)) {
+    logOperationStart(3 /* OperationId.ConnectedCallback */, vm);
+    invokeComponentCallback(vm, connectedCallback);
+    logOperationEnd(3 /* OperationId.ConnectedCallback */, vm);
+  }
 }
-function setAdapterToken(adapter, token) {
-  AdapterToTokenMap.set(adapter, token);
+function hasWireAdapters(vm) {
+  return getOwnPropertyNames$1(vm.def.wire).length > 0;
 }
-function storeWiredMethodMeta(descriptor, adapter, configCallback, dynamic) {
-  // support for callable adapters
-  if (adapter.adapter) {
-    adapter = adapter.adapter;
+function runDisconnectedCallback(vm) {
+  if (process.env.NODE_ENV !== 'production') {
+    assert.isTrue(vm.state !== 2 /* VMState.disconnected */, `${vm} must be inserted.`);
   }
-  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;
+  if (isFalse(vm.isDirty)) {
+    // this guarantees that if the component is reused/reinserted,
+    // it will be re-rendered because we are disconnecting the reactivity
+    // linking, so mutations are not automatically reflected on the state
+    // of disconnected components.
+    vm.isDirty = true;
+  }
+  vm.state = 2 /* VMState.disconnected */;
+  // reporting disconnection
+  const {
+    disconnected
+  } = Services;
+  if (disconnected) {
+    invokeServiceHook(vm, disconnected);
+  }
+  if (hasWireAdapters(vm)) {
+    disconnectWireAdapters(vm);
+  }
+  const {
+    disconnectedCallback
+  } = vm.def;
+  if (!isUndefined$1(disconnectedCallback)) {
+    logOperationStart(5 /* OperationId.DisconnectedCallback */, vm);
+    invokeComponentCallback(vm, disconnectedCallback);
+    logOperationEnd(5 /* OperationId.DisconnectedCallback */, vm);
   }
-  const def = {
-    adapter,
-    configCallback,
-    dynamic
-  };
-  WireMetaMap.set(descriptor, def);
 }
-function installWireAdapters(vm) {
+function runChildNodesDisconnectedCallback(vm) {
   const {
-    context,
-    def: {
-      wire
-    }
+    velements: vCustomElementCollection
   } = 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.`);
+  // Reporting disconnection for every child in inverse order since they are
+  // inserted in reserved order.
+  for (let i = vCustomElementCollection.length - 1; i >= 0; i -= 1) {
+    const {
+      elm
+    } = vCustomElementCollection[i];
+    // There are two cases where the element could be undefined:
+    // * when there is an error during the construction phase, and an error
+    //   boundary picks it, there is a possibility that the VCustomElement
+    //   is not properly initialized, and therefore is should be ignored.
+    // * when slotted custom element is not used by the element where it is
+    //   slotted into it, as  a result, the custom element was never
+    //   initialized.
+    if (!isUndefined$1(elm)) {
+      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);
+      }
     }
-    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;
+  }
+}
+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;
           }
-        }
-        computeConfigAndUpdate();
-      });
-      ArrayPush$1.call(wiredDisconnecting, () => {
-        connector.disconnect();
-        resetConfigWatcher();
-      });
+      }
     }
   }
 }
-function connectWireAdapters(vm) {
+// 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 {
-    wiredConnecting
-  } = vm.context;
-  for (let i = 0, len = wiredConnecting.length; i < len; i += 1) {
-    wiredConnecting[i]();
+    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 disconnectWireAdapters(vm) {
-  const {
-    wiredDisconnecting
-  } = vm.context;
-  runWithBoundaryProtection(vm, vm, noop, () => {
-    // job
-    for (let i = 0, len = wiredDisconnecting.length; i < len; i += 1) {
-      wiredDisconnecting[i]();
+function getErrorBoundaryVM(vm) {
+  let currentVm = vm;
+  while (!isNull(currentVm)) {
+    if (!isUndefined$1(currentVm.def.errorCallback)) {
+      return currentVm;
     }
-  }, noop);
+    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);
+    }
+  }
 }
 
 /*
@@ -6496,7 +6439,7 @@ function freezeTemplate(tmpl) {
     }
   }
 }
-/* version: 2.34.0 */
+/* version: 2.35.1 */
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -6967,6 +6910,6 @@ function renderComponent(tagName, Ctor, props = {}) {
  */
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.34.0 */
+/* version: 2.35.1 */
 
 export { LightningElement, api$1 as api, createContextProvider, freezeTemplate, getComponentDef, isComponentConstructor, parseFragment, parseFragment as parseSVGFragment, readonly, register, registerComponent, registerDecorators, registerTemplate, renderComponent, renderer, sanitizeAttribute, setFeatureFlag, setFeatureFlagForTest, setHooks, track, unwrap, wire };