lwc 2.7.2 → 2.7.3

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

@@ -339,7 +339,7 @@ function htmlPropertyToAttribute(propName) {
   CACHED_PROPERTY_ATTRIBUTE_MAPPING.set(propName, attributeName);
   return attributeName;
 }
-/** version: 2.7.2 */
+/** version: 2.7.3 */
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -461,7 +461,7 @@ function setFeatureFlagForTest(name, value) {
     setFeatureFlag(name, value);
   }
 }
-/** version: 2.7.2 */
+/** version: 2.7.3 */
 
 /* proxy-compat-disable */
 
@@ -995,62 +995,205 @@ function logWarn(message, vm) {
  */
 
 
-function handleEvent(event, vnode) {
-  const {
-    type
-  } = event;
-  const {
-    data: {
-      on
-    }
-  } = vnode;
-  const handler = on && on[type]; // call event handler if exists
+function isUndef(s) {
+  return s === undefined;
+}
+
+function sameVnode(vnode1, vnode2) {
+  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;
+}
+
+function isVNode(vnode) {
+  return vnode != null;
+}
+
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+  const map = {};
+  let j, key, ch; // TODO [#1637]: simplify this by assuming that all vnodes has keys
+
+  for (j = beginIdx; j <= endIdx; ++j) {
+    ch = children[j];
 
-  if (handler) {
-    handler.call(undefined, event);
+    if (isVNode(ch)) {
+      key = ch.key;
+
+      if (key !== undefined) {
+        map[key] = j;
+      }
+    }
   }
+
+  return map;
 }
 
-function createListener() {
-  return function handler(event) {
-    handleEvent(event, handler.vnode);
-  };
+function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {
+  for (; startIdx <= endIdx; ++startIdx) {
+    const ch = vnodes[startIdx];
+
+    if (isVNode(ch)) {
+      ch.hook.create(ch);
+      ch.hook.insert(ch, parentElm, before);
+    }
+  }
 }
 
-function updateAllEventListeners(oldVnode, vnode) {
-  if (isUndefined$1(oldVnode.listener)) {
-    createAllEventListeners(vnode);
-  } else {
-    vnode.listener = oldVnode.listener;
-    vnode.listener.vnode = vnode;
+function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
+  for (; startIdx <= endIdx; ++startIdx) {
+    const ch = vnodes[startIdx]; // text nodes do not have logic associated to them
+
+    if (isVNode(ch)) {
+      ch.hook.remove(ch, parentElm);
+    }
   }
 }
 
-function createAllEventListeners(vnode) {
-  const {
-    elm,
-    data: {
-      on
+function updateDynamicChildren(parentElm, oldCh, newCh) {
+  let oldStartIdx = 0;
+  let newStartIdx = 0;
+  let oldEndIdx = oldCh.length - 1;
+  let oldStartVnode = oldCh[0];
+  let oldEndVnode = oldCh[oldEndIdx];
+  const newChEnd = newCh.length - 1;
+  let newEndIdx = newChEnd;
+  let newStartVnode = newCh[0];
+  let newEndVnode = newCh[newEndIdx];
+  let oldKeyToIdx;
+  let idxInOld;
+  let elmToMove;
+  let before;
+
+  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+    if (!isVNode(oldStartVnode)) {
+      oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
+    } else if (!isVNode(oldEndVnode)) {
+      oldEndVnode = oldCh[--oldEndIdx];
+    } else if (!isVNode(newStartVnode)) {
+      newStartVnode = newCh[++newStartIdx];
+    } else if (!isVNode(newEndVnode)) {
+      newEndVnode = newCh[--newEndIdx];
+    } else if (sameVnode(oldStartVnode, newStartVnode)) {
+      patchVnode(oldStartVnode, newStartVnode);
+      oldStartVnode = oldCh[++oldStartIdx];
+      newStartVnode = newCh[++newStartIdx];
+    } else if (sameVnode(oldEndVnode, newEndVnode)) {
+      patchVnode(oldEndVnode, newEndVnode);
+      oldEndVnode = oldCh[--oldEndIdx];
+      newEndVnode = newCh[--newEndIdx];
+    } else if (sameVnode(oldStartVnode, newEndVnode)) {
+      // Vnode moved right
+      patchVnode(oldStartVnode, newEndVnode);
+      newEndVnode.hook.move(oldStartVnode, parentElm, nextSibling$1(oldEndVnode.elm));
+      oldStartVnode = oldCh[++oldStartIdx];
+      newEndVnode = newCh[--newEndIdx];
+    } else if (sameVnode(oldEndVnode, newStartVnode)) {
+      // Vnode moved left
+      patchVnode(oldEndVnode, newStartVnode);
+      newStartVnode.hook.move(oldEndVnode, parentElm, oldStartVnode.elm);
+      oldEndVnode = oldCh[--oldEndIdx];
+      newStartVnode = newCh[++newStartIdx];
+    } else {
+      if (oldKeyToIdx === undefined) {
+        oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+      }
+
+      idxInOld = oldKeyToIdx[newStartVnode.key];
+
+      if (isUndef(idxInOld)) {
+        // New element
+        newStartVnode.hook.create(newStartVnode);
+        newStartVnode.hook.insert(newStartVnode, parentElm, oldStartVnode.elm);
+        newStartVnode = newCh[++newStartIdx];
+      } else {
+        elmToMove = oldCh[idxInOld];
+
+        if (isVNode(elmToMove)) {
+          if (elmToMove.sel !== newStartVnode.sel) {
+            // New element
+            newStartVnode.hook.create(newStartVnode);
+            newStartVnode.hook.insert(newStartVnode, parentElm, oldStartVnode.elm);
+          } else {
+            patchVnode(elmToMove, newStartVnode);
+            oldCh[idxInOld] = undefined;
+            newStartVnode.hook.move(elmToMove, parentElm, oldStartVnode.elm);
+          }
+        }
+
+        newStartVnode = newCh[++newStartIdx];
+      }
     }
-  } = vnode;
+  }
 
-  if (isUndefined$1(on)) {
+  if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
+    if (oldStartIdx > oldEndIdx) {
+      // There's some cases in which the sub array of vnodes to be inserted is followed by null(s) and an
+      // already processed vnode, in such cases the vnodes to be inserted should be before that processed vnode.
+      let i = newEndIdx;
+      let n;
+
+      do {
+        n = newCh[++i];
+      } while (!isVNode(n) && i < newChEnd);
+
+      before = isVNode(n) ? n.elm : null;
+      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);
+    } else {
+      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
+    }
+  }
+}
+
+function updateStaticChildren(parentElm, oldCh, newCh) {
+  const oldChLength = oldCh.length;
+  const newChLength = newCh.length;
+
+  if (oldChLength === 0) {
+    // the old list is empty, we can directly insert anything new
+    addVnodes(parentElm, null, newCh, 0, newChLength);
     return;
   }
 
-  const listener = vnode.listener = createListener();
-  listener.vnode = vnode;
-  let name;
+  if (newChLength === 0) {
+    // the old list is nonempty and the new list is empty so we can directly remove all old nodes
+    // this is the case in which the dynamic children of an if-directive should be removed
+    removeVnodes(parentElm, oldCh, 0, oldChLength);
+    return;
+  } // if the old list is not empty, the new list MUST have the same
+  // amount of nodes, that's why we call this static children
+
+
+  let referenceElm = null;
+
+  for (let i = newChLength - 1; i >= 0; i -= 1) {
+    const vnode = newCh[i];
+    const oldVNode = oldCh[i];
+
+    if (vnode !== oldVNode) {
+      if (isVNode(oldVNode)) {
+        if (isVNode(vnode)) {
+          // both vnodes must be equivalent, and se just need to patch them
+          patchVnode(oldVNode, vnode);
+          referenceElm = vnode.elm;
+        } else {
+          // removing the old vnode since the new one is null
+          oldVNode.hook.remove(oldVNode, parentElm);
+        }
+      } else if (isVNode(vnode)) {
+        // this condition is unnecessary
+        vnode.hook.create(vnode); // insert the new node one since the old one is null
 
-  for (name in on) {
-    addEventListener$1(elm, name, listener);
+        vnode.hook.insert(vnode, parentElm, referenceElm);
+        referenceElm = vnode.elm;
+      }
+    }
   }
 }
 
-var modEvents = {
-  update: updateAllEventListeners,
-  create: createAllEventListeners
-};
+function patchVnode(oldVnode, vnode) {
+  if (oldVnode !== vnode) {
+    vnode.elm = oldVnode.elm;
+    vnode.hook.update(oldVnode, vnode);
+  }
+}
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -1058,6 +1201,7 @@ var modEvents = {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 
+
 const defaultDefHTMLPropertyNames = ['accessKey', 'dir', 'draggable', 'hidden', 'id', 'lang', 'spellcheck', 'tabIndex', 'title'];
 
 function offsetPropertyErrorMessage(name) {
@@ -1177,313 +1321,379 @@ function unlockAttribute(elm, key) {
  */
 
 
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const xmlNS = 'http://www.w3.org/XML/1998/namespace';
-const ColonCharCode = 58;
-
-function updateAttrs(oldVnode, vnode) {
-  const {
-    data: {
-      attrs
-    }
-  } = vnode;
+function generateDataDescriptor(options) {
+  return assign({
+    configurable: true,
+    enumerable: true,
+    writable: true
+  }, options);
+}
 
-  if (isUndefined$1(attrs)) {
-    return;
-  }
+function generateAccessorDescriptor(options) {
+  return assign({
+    configurable: true,
+    enumerable: true
+  }, options);
+}
 
-  let {
-    data: {
-      attrs: oldAttrs
-    }
-  } = oldVnode;
+let isDomMutationAllowed = false;
 
-  if (oldAttrs === attrs) {
-    return;
+function unlockDomMutation() {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
   }
 
-  if (process.env.NODE_ENV !== 'production') {
-    assert.invariant(isUndefined$1(oldAttrs) || keys(oldAttrs).join(',') === keys(attrs).join(','), `vnode.data.attrs cannot change shape.`);
+  isDomMutationAllowed = true;
+}
+
+function lockDomMutation() {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
   }
 
-  const elm = vnode.elm;
-  let key;
-  oldAttrs = isUndefined$1(oldAttrs) ? EmptyObject : oldAttrs; // update modified attributes, add new attributes
-  // this routine is only useful for data-* attributes in all kind of elements
-  // and aria-* in standard elements (custom elements will use props for these)
+  isDomMutationAllowed = false;
+}
 
-  for (key in attrs) {
-    const cur = attrs[key];
-    const old = oldAttrs[key];
+function logMissingPortalError(name, type) {
+  return logError(`The \`${name}\` ${type} is available only on elements that use the \`lwc:dom="manual"\` directive.`);
+}
 
-    if (old !== cur) {
-      unlockAttribute(elm, key);
+function patchElementWithRestrictions(elm, options) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
 
-      if (StringCharCodeAt.call(key, 3) === ColonCharCode) {
-        // Assume xml namespace
-        setAttribute$1(elm, key, cur, xmlNS);
-      } else if (StringCharCodeAt.call(key, 5) === ColonCharCode) {
-        // Assume xlink namespace
-        setAttribute$1(elm, key, cur, xlinkNS);
-      } else if (isNull(cur) || isUndefined$1(cur)) {
-        removeAttribute$1(elm, key);
-      } else {
-        setAttribute$1(elm, key, cur);
+  const originalOuterHTMLDescriptor = getPropertyDescriptor(elm, 'outerHTML');
+  const descriptors = {
+    outerHTML: generateAccessorDescriptor({
+      get() {
+        return originalOuterHTMLDescriptor.get.call(this);
+      },
+
+      set(_value) {
+        throw new TypeError(`Invalid attempt to set outerHTML on Element.`);
       }
 
-      lockAttribute();
-    }
-  }
-}
+    })
+  }; // Apply extra restriction related to DOM manipulation if the element is not a portal.
 
-const emptyVNode$3 = {
-  data: {}
-};
-var modAttrs = {
-  create: vnode => updateAttrs(emptyVNode$3, vnode),
-  update: updateAttrs
-};
-/*
- * 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
- */
+  if (!options.isLight && !options.isPortal) {
+    const {
+      appendChild,
+      insertBefore,
+      removeChild,
+      replaceChild
+    } = elm;
+    const originalNodeValueDescriptor = getPropertyDescriptor(elm, 'nodeValue');
+    const originalInnerHTMLDescriptor = getPropertyDescriptor(elm, 'innerHTML');
+    const originalTextContentDescriptor = getPropertyDescriptor(elm, 'textContent');
+    assign(descriptors, {
+      appendChild: generateDataDescriptor({
+        value(aChild) {
+          logMissingPortalError('appendChild', 'method');
+          return appendChild.call(this, aChild);
+        }
 
-function isLiveBindingProp(sel, key) {
-  // For properties with live bindings, we read values from the DOM element
-  // instead of relying on internally tracked values.
-  return sel === 'input' && (key === 'value' || key === 'checked');
-}
+      }),
+      insertBefore: generateDataDescriptor({
+        value(newNode, referenceNode) {
+          if (!isDomMutationAllowed) {
+            logMissingPortalError('insertBefore', 'method');
+          }
 
-function update(oldVnode, vnode) {
-  const props = vnode.data.props;
+          return insertBefore.call(this, newNode, referenceNode);
+        }
 
-  if (isUndefined$1(props)) {
-    return;
-  }
+      }),
+      removeChild: generateDataDescriptor({
+        value(aChild) {
+          if (!isDomMutationAllowed) {
+            logMissingPortalError('removeChild', 'method');
+          }
 
-  const oldProps = oldVnode.data.props;
+          return removeChild.call(this, aChild);
+        }
 
-  if (oldProps === props) {
-    return;
-  }
+      }),
+      replaceChild: generateDataDescriptor({
+        value(newChild, oldChild) {
+          logMissingPortalError('replaceChild', 'method');
+          return replaceChild.call(this, newChild, oldChild);
+        }
 
-  if (process.env.NODE_ENV !== 'production') {
-    assert.invariant(isUndefined$1(oldProps) || keys(oldProps).join(',') === keys(props).join(','), 'vnode.data.props cannot change shape.');
-  }
+      }),
+      nodeValue: generateAccessorDescriptor({
+        get() {
+          return originalNodeValueDescriptor.get.call(this);
+        },
 
-  const isFirstPatch = isUndefined$1(oldProps);
-  const {
-    elm,
-    sel
-  } = vnode;
+        set(value) {
+          if (!isDomMutationAllowed) {
+            logMissingPortalError('nodeValue', 'property');
+          }
 
-  for (const key in props) {
-    const cur = props[key]; // if it is the first time this element is patched, or the current value is different to the previous value...
+          originalNodeValueDescriptor.set.call(this, value);
+        }
 
-    if (isFirstPatch || cur !== (isLiveBindingProp(sel, key) ? getProperty$1(elm, key) : oldProps[key])) {
-      setProperty$1(elm, key, cur);
-    }
-  }
-}
+      }),
+      textContent: generateAccessorDescriptor({
+        get() {
+          return originalTextContentDescriptor.get.call(this);
+        },
 
-const emptyVNode$2 = {
-  data: {}
-};
-var modProps = {
-  create: vnode => update(emptyVNode$2, vnode),
-  update
-};
-/*
- * 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
- */
+        set(value) {
+          logMissingPortalError('textContent', 'property');
+          originalTextContentDescriptor.set.call(this, value);
+        }
 
-const classNameToClassMap = create(null);
+      }),
+      innerHTML: generateAccessorDescriptor({
+        get() {
+          return originalInnerHTMLDescriptor.get.call(this);
+        },
 
-function getMapFromClassName(className) {
-  // Intentionally using == to match undefined and null values from computed style attribute
-  if (className == null) {
-    return EmptyObject;
-  } // computed class names must be string
+        set(value) {
+          logMissingPortalError('innerHTML', 'property');
+          return originalInnerHTMLDescriptor.set.call(this, value);
+        }
 
+      })
+    });
+  }
 
-  className = isString(className) ? className : className + '';
-  let map = classNameToClassMap[className];
+  defineProperties(elm, descriptors);
+}
 
-  if (map) {
-    return map;
-  }
+function getShadowRootRestrictionsDescriptors(sr) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  } // 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.
 
-  map = create(null);
-  let start = 0;
-  let o;
-  const len = className.length;
 
-  for (o = 0; o < len; o++) {
-    if (StringCharCodeAt.call(className, o) === SPACE_CHAR) {
-      if (o > start) {
-        map[StringSlice.call(className, start, o)] = true;
+  const originalAddEventListener = sr.addEventListener;
+  const originalInnerHTMLDescriptor = getPropertyDescriptor(sr, 'innerHTML');
+  const originalTextContentDescriptor = getPropertyDescriptor(sr, 'textContent');
+  return {
+    innerHTML: generateAccessorDescriptor({
+      get() {
+        return originalInnerHTMLDescriptor.get.call(this);
+      },
+
+      set(_value) {
+        throw new TypeError(`Invalid attempt to set innerHTML on ShadowRoot.`);
       }
 
-      start = o + 1;
-    }
-  }
+    }),
+    textContent: generateAccessorDescriptor({
+      get() {
+        return originalTextContentDescriptor.get.call(this);
+      },
 
-  if (o > start) {
-    map[StringSlice.call(className, start, o)] = true;
-  }
+      set(_value) {
+        throw new TypeError(`Invalid attempt to set textContent on ShadowRoot.`);
+      }
 
-  classNameToClassMap[className] = map;
+    }),
+    addEventListener: generateDataDescriptor({
+      value(type, listener, options) {
+        // TODO [#420]: this is triggered when the component author attempts to add a listener
+        // programmatically into its Component's shadow root
+        if (!isUndefined$1(options)) {
+          logError('The `addEventListener` method on ShadowRoot does not support any options.', getAssociatedVMIfPresent(this));
+        } // Typescript does not like it when you treat the `arguments` object as an array
+        // @ts-ignore type-mismatch
 
-  if (process.env.NODE_ENV !== 'production') {
-    // just to make sure that this object never changes as part of the diffing algo
-    freeze(map);
-  }
 
-  return map;
-}
+        return originalAddEventListener.apply(this, arguments);
+      }
 
-function updateClassAttribute(oldVnode, vnode) {
-  const {
-    elm,
-    data: {
-      className: newClass
-    }
-  } = vnode;
-  const {
-    data: {
-      className: oldClass
-    }
-  } = oldVnode;
+    })
+  };
+} // Custom Elements Restrictions:
+// -----------------------------
 
-  if (oldClass === newClass) {
-    return;
+
+function getCustomElementRestrictionsDescriptors(elm) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
   }
 
-  const classList = getClassList$1(elm);
-  const newClassMap = getMapFromClassName(newClass);
-  const oldClassMap = getMapFromClassName(oldClass);
-  let name;
+  const originalAddEventListener = elm.addEventListener;
+  const originalInnerHTMLDescriptor = getPropertyDescriptor(elm, 'innerHTML');
+  const originalOuterHTMLDescriptor = getPropertyDescriptor(elm, 'outerHTML');
+  const originalTextContentDescriptor = getPropertyDescriptor(elm, 'textContent');
+  return {
+    innerHTML: generateAccessorDescriptor({
+      get() {
+        return originalInnerHTMLDescriptor.get.call(this);
+      },
 
-  for (name in oldClassMap) {
-    // remove only if it is not in the new class collection and it is not set from within the instance
-    if (isUndefined$1(newClassMap[name])) {
-      classList.remove(name);
-    }
-  }
+      set(_value) {
+        throw new TypeError(`Invalid attempt to set innerHTML on HTMLElement.`);
+      }
 
-  for (name in newClassMap) {
-    if (isUndefined$1(oldClassMap[name])) {
-      classList.add(name);
-    }
-  }
-}
+    }),
+    outerHTML: generateAccessorDescriptor({
+      get() {
+        return originalOuterHTMLDescriptor.get.call(this);
+      },
 
-const emptyVNode$1 = {
-  data: {}
-};
-var modComputedClassName = {
-  create: vnode => updateClassAttribute(emptyVNode$1, vnode),
-  update: updateClassAttribute
-};
-/*
- * 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
- */
+      set(_value) {
+        throw new TypeError(`Invalid attempt to set outerHTML on HTMLElement.`);
+      }
 
-function updateStyleAttribute(oldVnode, vnode) {
-  const {
-    elm,
-    data: {
-      style: newStyle
-    }
-  } = vnode;
+    }),
+    textContent: generateAccessorDescriptor({
+      get() {
+        return originalTextContentDescriptor.get.call(this);
+      },
 
-  if (oldVnode.data.style === newStyle) {
-    return;
-  }
+      set(_value) {
+        throw new TypeError(`Invalid attempt to set textContent on HTMLElement.`);
+      }
 
-  if (!isString(newStyle) || newStyle === '') {
-    removeAttribute$1(elm, 'style');
-  } else {
-    setAttribute$1(elm, 'style', newStyle);
+    }),
+    addEventListener: generateDataDescriptor({
+      value(type, listener, options) {
+        // TODO [#420]: this is triggered when the component author attempts to add a listener
+        // programmatically into a lighting element node
+        if (!isUndefined$1(options)) {
+          logError('The `addEventListener` method in `LightningElement` does not support any options.', getAssociatedVMIfPresent(this));
+        } // Typescript does not like it when you treat the `arguments` object as an array
+        // @ts-ignore type-mismatch
+
+
+        return originalAddEventListener.apply(this, arguments);
+      }
+
+    })
+  };
+}
+
+function getComponentRestrictionsDescriptors() {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
   }
+
+  return {
+    tagName: generateAccessorDescriptor({
+      get() {
+        throw new Error(`Usage of property \`tagName\` is disallowed because the component itself does` + ` not know which tagName will be used to create the element, therefore writing` + ` code that check for that value is error prone.`);
+      },
+
+      configurable: true,
+      enumerable: false // no enumerable properties on component
+
+    })
+  };
 }
 
-const emptyVNode = {
-  data: {}
-};
-var modComputedStyle = {
-  create: vnode => updateStyleAttribute(emptyVNode, vnode),
-  update: updateStyleAttribute
-};
-/*
- * 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 compiler takes care of transforming the inline classnames into an object. It's faster to set the
-// different classnames properties individually instead of via a string.
+function getLightningElementPrototypeRestrictionsDescriptors(proto) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
 
-function createClassAttribute(vnode) {
-  const {
-    elm,
-    data: {
-      classMap
+  const originalDispatchEvent = proto.dispatchEvent;
+  const descriptors = {
+    dispatchEvent: generateDataDescriptor({
+      value(event) {
+        const vm = getAssociatedVM(this);
+
+        if (!isNull(event) && isObject(event)) {
+          const {
+            type
+          } = event;
+
+          if (!/^[a-z][a-z0-9_]*$/.test(type)) {
+            logError(`Invalid event type "${type}" dispatched in element ${getComponentTag(vm)}.` + ` Event name must start with a lowercase letter and followed only lowercase` + ` letters, numbers, and underscores`, vm);
+          }
+        } // Typescript does not like it when you treat the `arguments` object as an array
+        // @ts-ignore type-mismatch
+
+
+        return originalDispatchEvent.apply(this, arguments);
+      }
+
+    })
+  };
+  forEach.call(getOwnPropertyNames$1(globalHTMLProperties), propName => {
+    if (propName in proto) {
+      return; // no need to redefine something that we are already exposing
     }
-  } = vnode;
 
-  if (isUndefined$1(classMap)) {
-    return;
-  }
+    descriptors[propName] = generateAccessorDescriptor({
+      get() {
+        const {
+          error,
+          attribute
+        } = globalHTMLProperties[propName];
+        const msg = [];
+        msg.push(`Accessing the global HTML property "${propName}" is disabled.`);
 
-  const classList = getClassList$1(elm);
+        if (error) {
+          msg.push(error);
+        } else if (attribute) {
+          msg.push(`Instead access it via \`this.getAttribute("${attribute}")\`.`);
+        }
 
-  for (const name in classMap) {
-    classList.add(name);
-  }
+        logError(msg.join('\n'), getAssociatedVM(this));
+      },
+
+      set() {
+        const {
+          readOnly
+        } = globalHTMLProperties[propName];
+
+        if (readOnly) {
+          logError(`The global HTML property \`${propName}\` is read-only.`, getAssociatedVM(this));
+        }
+      }
+
+    });
+  });
+  return descriptors;
+} // This routine will prevent access to certain properties on a shadow root instance to guarantee
+// that all components will work fine in IE11 and other browsers without shadow dom support.
+
+
+function patchShadowRootWithRestrictions(sr) {
+  defineProperties(sr, getShadowRootRestrictionsDescriptors(sr));
 }
 
-var modStaticClassName = {
-  create: createClassAttribute
-};
+function patchCustomElementWithRestrictions(elm) {
+  const restrictionsDescriptors = getCustomElementRestrictionsDescriptors(elm);
+  const elmProto = getPrototypeOf$1(elm);
+  setPrototypeOf(elm, create(elmProto, restrictionsDescriptors));
+}
+
+function patchComponentWithRestrictions(cmp) {
+  defineProperties(cmp, getComponentRestrictionsDescriptors());
+}
+
+function patchLightningElementPrototypeWithRestrictions(proto) {
+  defineProperties(proto, getLightningElementPrototypeRestrictionsDescriptors(proto));
+}
 /*
  * 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 compiler takes care of transforming the inline style into an object. It's faster to set the
-// different style properties individually instead of via a string.
-
-function createStyleAttribute(vnode) {
-  const {
-    elm,
-    data: {
-      styleDecls
-    }
-  } = vnode;
-
-  if (isUndefined$1(styleDecls)) {
-    return;
-  }
+// This is a temporary workaround to get the @lwc/engine-server to evaluate in node without having
+// to inject at runtime.
 
-  for (let i = 0; i < styleDecls.length; i++) {
-    const [prop, value, important] = styleDecls[i];
-    setCSSStyleProperty$1(elm, prop, value, important);
-  }
-}
 
-var modStaticStyle = {
-  create: createStyleAttribute
-};
+const HTMLElementConstructor = typeof HTMLElement !== 'undefined' ? HTMLElement : function () {};
+const HTMLElementPrototype = HTMLElementConstructor.prototype;
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -1491,623 +1701,36 @@ var modStaticStyle = {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 
-function isUndef(s) {
-  return s === undefined;
-}
-
-function sameVnode(vnode1, vnode2) {
-  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;
-}
-
-function isVNode(vnode) {
-  return vnode != null;
-}
-
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-  const map = {};
-  let j, key, ch; // TODO [#1637]: simplify this by assuming that all vnodes has keys
-
-  for (j = beginIdx; j <= endIdx; ++j) {
-    ch = children[j];
+/**
+ * This is a descriptor map that contains
+ * all standard properties that a Custom Element can support (including AOM properties), which
+ * determines what kind of capabilities the Base HTML Element and
+ * Base Lightning Element should support.
+ */
 
-    if (isVNode(ch)) {
-      key = ch.key;
+const HTMLElementOriginalDescriptors = create(null);
+forEach.call(keys(AriaPropNameToAttrNameMap), propName => {
+  // Note: intentionally using our in-house getPropertyDescriptor instead of getOwnPropertyDescriptor here because
+  // in IE11, some properties are on Element.prototype instead of HTMLElement, just to be sure.
+  const descriptor = getPropertyDescriptor(HTMLElementPrototype, propName);
 
-      if (key !== undefined) {
-        map[key] = j;
-      }
-    }
+  if (!isUndefined$1(descriptor)) {
+    HTMLElementOriginalDescriptors[propName] = descriptor;
   }
+});
+forEach.call(defaultDefHTMLPropertyNames, propName => {
+  // Note: intentionally using our in-house getPropertyDescriptor instead of getOwnPropertyDescriptor here because
+  // in IE11, id property is on Element.prototype instead of HTMLElement, and we suspect that more will fall into
+  // this category, so, better to be sure.
+  const descriptor = getPropertyDescriptor(HTMLElementPrototype, propName);
 
-  return map;
-}
-
-function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {
-  for (; startIdx <= endIdx; ++startIdx) {
-    const ch = vnodes[startIdx];
-
-    if (isVNode(ch)) {
-      ch.hook.create(ch);
-      ch.hook.insert(ch, parentElm, before);
-    }
+  if (!isUndefined$1(descriptor)) {
+    HTMLElementOriginalDescriptors[propName] = descriptor;
   }
-}
-
-function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
-  for (; startIdx <= endIdx; ++startIdx) {
-    const ch = vnodes[startIdx]; // text nodes do not have logic associated to them
-
-    if (isVNode(ch)) {
-      ch.hook.remove(ch, parentElm);
-    }
-  }
-}
-
-function updateDynamicChildren(parentElm, oldCh, newCh) {
-  let oldStartIdx = 0;
-  let newStartIdx = 0;
-  let oldEndIdx = oldCh.length - 1;
-  let oldStartVnode = oldCh[0];
-  let oldEndVnode = oldCh[oldEndIdx];
-  const newChEnd = newCh.length - 1;
-  let newEndIdx = newChEnd;
-  let newStartVnode = newCh[0];
-  let newEndVnode = newCh[newEndIdx];
-  let oldKeyToIdx;
-  let idxInOld;
-  let elmToMove;
-  let before;
-
-  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-    if (!isVNode(oldStartVnode)) {
-      oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
-    } else if (!isVNode(oldEndVnode)) {
-      oldEndVnode = oldCh[--oldEndIdx];
-    } else if (!isVNode(newStartVnode)) {
-      newStartVnode = newCh[++newStartIdx];
-    } else if (!isVNode(newEndVnode)) {
-      newEndVnode = newCh[--newEndIdx];
-    } else if (sameVnode(oldStartVnode, newStartVnode)) {
-      patchVnode(oldStartVnode, newStartVnode);
-      oldStartVnode = oldCh[++oldStartIdx];
-      newStartVnode = newCh[++newStartIdx];
-    } else if (sameVnode(oldEndVnode, newEndVnode)) {
-      patchVnode(oldEndVnode, newEndVnode);
-      oldEndVnode = oldCh[--oldEndIdx];
-      newEndVnode = newCh[--newEndIdx];
-    } else if (sameVnode(oldStartVnode, newEndVnode)) {
-      // Vnode moved right
-      patchVnode(oldStartVnode, newEndVnode);
-      newEndVnode.hook.move(oldStartVnode, parentElm, nextSibling$1(oldEndVnode.elm));
-      oldStartVnode = oldCh[++oldStartIdx];
-      newEndVnode = newCh[--newEndIdx];
-    } else if (sameVnode(oldEndVnode, newStartVnode)) {
-      // Vnode moved left
-      patchVnode(oldEndVnode, newStartVnode);
-      newStartVnode.hook.move(oldEndVnode, parentElm, oldStartVnode.elm);
-      oldEndVnode = oldCh[--oldEndIdx];
-      newStartVnode = newCh[++newStartIdx];
-    } else {
-      if (oldKeyToIdx === undefined) {
-        oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-      }
-
-      idxInOld = oldKeyToIdx[newStartVnode.key];
-
-      if (isUndef(idxInOld)) {
-        // New element
-        newStartVnode.hook.create(newStartVnode);
-        newStartVnode.hook.insert(newStartVnode, parentElm, oldStartVnode.elm);
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        elmToMove = oldCh[idxInOld];
-
-        if (isVNode(elmToMove)) {
-          if (elmToMove.sel !== newStartVnode.sel) {
-            // New element
-            newStartVnode.hook.create(newStartVnode);
-            newStartVnode.hook.insert(newStartVnode, parentElm, oldStartVnode.elm);
-          } else {
-            patchVnode(elmToMove, newStartVnode);
-            oldCh[idxInOld] = undefined;
-            newStartVnode.hook.move(elmToMove, parentElm, oldStartVnode.elm);
-          }
-        }
-
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-  }
-
-  if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
-    if (oldStartIdx > oldEndIdx) {
-      // There's some cases in which the sub array of vnodes to be inserted is followed by null(s) and an
-      // already processed vnode, in such cases the vnodes to be inserted should be before that processed vnode.
-      let i = newEndIdx;
-      let n;
-
-      do {
-        n = newCh[++i];
-      } while (!isVNode(n) && i < newChEnd);
-
-      before = isVNode(n) ? n.elm : null;
-      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);
-    } else {
-      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-}
-
-function updateStaticChildren(parentElm, oldCh, newCh) {
-  const oldChLength = oldCh.length;
-  const newChLength = newCh.length;
-
-  if (oldChLength === 0) {
-    // the old list is empty, we can directly insert anything new
-    addVnodes(parentElm, null, newCh, 0, newChLength);
-    return;
-  }
-
-  if (newChLength === 0) {
-    // the old list is nonempty and the new list is empty so we can directly remove all old nodes
-    // this is the case in which the dynamic children of an if-directive should be removed
-    removeVnodes(parentElm, oldCh, 0, oldChLength);
-    return;
-  } // if the old list is not empty, the new list MUST have the same
-  // amount of nodes, that's why we call this static children
-
-
-  let referenceElm = null;
-
-  for (let i = newChLength - 1; i >= 0; i -= 1) {
-    const vnode = newCh[i];
-    const oldVNode = oldCh[i];
-
-    if (vnode !== oldVNode) {
-      if (isVNode(oldVNode)) {
-        if (isVNode(vnode)) {
-          // both vnodes must be equivalent, and se just need to patch them
-          patchVnode(oldVNode, vnode);
-          referenceElm = vnode.elm;
-        } else {
-          // removing the old vnode since the new one is null
-          oldVNode.hook.remove(oldVNode, parentElm);
-        }
-      } else if (isVNode(vnode)) {
-        // this condition is unnecessary
-        vnode.hook.create(vnode); // insert the new node one since the old one is null
-
-        vnode.hook.insert(vnode, parentElm, referenceElm);
-        referenceElm = vnode.elm;
-      }
-    }
-  }
-}
-
-function patchVnode(oldVnode, vnode) {
-  if (oldVnode !== vnode) {
-    vnode.elm = oldVnode.elm;
-    vnode.hook.update(oldVnode, vnode);
-  }
-}
-/*
- * 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 generateDataDescriptor(options) {
-  return assign({
-    configurable: true,
-    enumerable: true,
-    writable: true
-  }, options);
-}
-
-function generateAccessorDescriptor(options) {
-  return assign({
-    configurable: true,
-    enumerable: true
-  }, options);
-}
-
-let isDomMutationAllowed = false;
-
-function unlockDomMutation() {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
-
-  isDomMutationAllowed = true;
-}
-
-function lockDomMutation() {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
-
-  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();
-  }
-
-  const originalOuterHTMLDescriptor = getPropertyDescriptor(elm, 'outerHTML');
-  const descriptors = {
-    outerHTML: generateAccessorDescriptor({
-      get() {
-        return originalOuterHTMLDescriptor.get.call(this);
-      },
-
-      set(_value) {
-        throw new TypeError(`Invalid attempt to set outerHTML on Element.`);
-      }
-
-    })
-  }; // Apply extra restriction related to DOM manipulation if the element is not a portal.
-
-  if (!options.isLight && !options.isPortal) {
-    const {
-      appendChild,
-      insertBefore,
-      removeChild,
-      replaceChild
-    } = elm;
-    const originalNodeValueDescriptor = getPropertyDescriptor(elm, 'nodeValue');
-    const originalInnerHTMLDescriptor = getPropertyDescriptor(elm, 'innerHTML');
-    const originalTextContentDescriptor = getPropertyDescriptor(elm, 'textContent');
-    assign(descriptors, {
-      appendChild: generateDataDescriptor({
-        value(aChild) {
-          logMissingPortalError('appendChild', 'method');
-          return appendChild.call(this, aChild);
-        }
-
-      }),
-      insertBefore: generateDataDescriptor({
-        value(newNode, referenceNode) {
-          if (!isDomMutationAllowed) {
-            logMissingPortalError('insertBefore', 'method');
-          }
-
-          return insertBefore.call(this, newNode, referenceNode);
-        }
-
-      }),
-      removeChild: generateDataDescriptor({
-        value(aChild) {
-          if (!isDomMutationAllowed) {
-            logMissingPortalError('removeChild', 'method');
-          }
-
-          return removeChild.call(this, aChild);
-        }
-
-      }),
-      replaceChild: generateDataDescriptor({
-        value(newChild, oldChild) {
-          logMissingPortalError('replaceChild', 'method');
-          return replaceChild.call(this, newChild, oldChild);
-        }
-
-      }),
-      nodeValue: generateAccessorDescriptor({
-        get() {
-          return originalNodeValueDescriptor.get.call(this);
-        },
-
-        set(value) {
-          if (!isDomMutationAllowed) {
-            logMissingPortalError('nodeValue', 'property');
-          }
-
-          originalNodeValueDescriptor.set.call(this, value);
-        }
-
-      }),
-      textContent: generateAccessorDescriptor({
-        get() {
-          return originalTextContentDescriptor.get.call(this);
-        },
-
-        set(value) {
-          logMissingPortalError('textContent', 'property');
-          originalTextContentDescriptor.set.call(this, value);
-        }
-
-      }),
-      innerHTML: generateAccessorDescriptor({
-        get() {
-          return originalInnerHTMLDescriptor.get.call(this);
-        },
-
-        set(value) {
-          logMissingPortalError('innerHTML', 'property');
-          return originalInnerHTMLDescriptor.set.call(this, value);
-        }
-
-      })
-    });
-  }
-
-  defineProperties(elm, descriptors);
-}
-
-function getShadowRootRestrictionsDescriptors(sr) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  } // 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.
-
-
-  const originalAddEventListener = sr.addEventListener;
-  const originalInnerHTMLDescriptor = getPropertyDescriptor(sr, 'innerHTML');
-  const originalTextContentDescriptor = getPropertyDescriptor(sr, 'textContent');
-  return {
-    innerHTML: generateAccessorDescriptor({
-      get() {
-        return originalInnerHTMLDescriptor.get.call(this);
-      },
-
-      set(_value) {
-        throw new TypeError(`Invalid attempt to set innerHTML on ShadowRoot.`);
-      }
-
-    }),
-    textContent: generateAccessorDescriptor({
-      get() {
-        return originalTextContentDescriptor.get.call(this);
-      },
-
-      set(_value) {
-        throw new TypeError(`Invalid attempt to set textContent on ShadowRoot.`);
-      }
-
-    }),
-    addEventListener: generateDataDescriptor({
-      value(type, listener, options) {
-        // TODO [#420]: this is triggered when the component author attempts to add a listener
-        // programmatically into its Component's shadow root
-        if (!isUndefined$1(options)) {
-          logError('The `addEventListener` method on ShadowRoot does not support any options.', getAssociatedVMIfPresent(this));
-        } // Typescript does not like it when you treat the `arguments` object as an array
-        // @ts-ignore type-mismatch
-
-
-        return originalAddEventListener.apply(this, arguments);
-      }
-
-    })
-  };
-} // Custom Elements Restrictions:
-// -----------------------------
-
-
-function getCustomElementRestrictionsDescriptors(elm) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
-
-  const originalAddEventListener = elm.addEventListener;
-  const originalInnerHTMLDescriptor = getPropertyDescriptor(elm, 'innerHTML');
-  const originalOuterHTMLDescriptor = getPropertyDescriptor(elm, 'outerHTML');
-  const originalTextContentDescriptor = getPropertyDescriptor(elm, 'textContent');
-  return {
-    innerHTML: generateAccessorDescriptor({
-      get() {
-        return originalInnerHTMLDescriptor.get.call(this);
-      },
-
-      set(_value) {
-        throw new TypeError(`Invalid attempt to set innerHTML on HTMLElement.`);
-      }
-
-    }),
-    outerHTML: generateAccessorDescriptor({
-      get() {
-        return originalOuterHTMLDescriptor.get.call(this);
-      },
-
-      set(_value) {
-        throw new TypeError(`Invalid attempt to set outerHTML on HTMLElement.`);
-      }
-
-    }),
-    textContent: generateAccessorDescriptor({
-      get() {
-        return originalTextContentDescriptor.get.call(this);
-      },
-
-      set(_value) {
-        throw new TypeError(`Invalid attempt to set textContent on HTMLElement.`);
-      }
-
-    }),
-    addEventListener: generateDataDescriptor({
-      value(type, listener, options) {
-        // TODO [#420]: this is triggered when the component author attempts to add a listener
-        // programmatically into a lighting element node
-        if (!isUndefined$1(options)) {
-          logError('The `addEventListener` method in `LightningElement` does not support any options.', getAssociatedVMIfPresent(this));
-        } // Typescript does not like it when you treat the `arguments` object as an array
-        // @ts-ignore type-mismatch
-
-
-        return originalAddEventListener.apply(this, arguments);
-      }
-
-    })
-  };
-}
-
-function getComponentRestrictionsDescriptors() {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
-
-  return {
-    tagName: generateAccessorDescriptor({
-      get() {
-        throw new Error(`Usage of property \`tagName\` is disallowed because the component itself does` + ` not know which tagName will be used to create the element, therefore writing` + ` code that check for that value is error prone.`);
-      },
-
-      configurable: true,
-      enumerable: false // no enumerable properties on component
-
-    })
-  };
-}
-
-function getLightningElementPrototypeRestrictionsDescriptors(proto) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
-
-  const originalDispatchEvent = proto.dispatchEvent;
-  const descriptors = {
-    dispatchEvent: generateDataDescriptor({
-      value(event) {
-        const vm = getAssociatedVM(this);
-
-        if (!isNull(event) && isObject(event)) {
-          const {
-            type
-          } = event;
-
-          if (!/^[a-z][a-z0-9_]*$/.test(type)) {
-            logError(`Invalid event type "${type}" dispatched in element ${getComponentTag(vm)}.` + ` Event name must start with a lowercase letter and followed only lowercase` + ` letters, numbers, and underscores`, vm);
-          }
-        } // Typescript does not like it when you treat the `arguments` object as an array
-        // @ts-ignore type-mismatch
-
-
-        return originalDispatchEvent.apply(this, arguments);
-      }
-
-    })
-  };
-  forEach.call(getOwnPropertyNames$1(globalHTMLProperties), propName => {
-    if (propName in proto) {
-      return; // no need to redefine something that we are already exposing
-    }
-
-    descriptors[propName] = generateAccessorDescriptor({
-      get() {
-        const {
-          error,
-          attribute
-        } = globalHTMLProperties[propName];
-        const msg = [];
-        msg.push(`Accessing the global HTML property "${propName}" is disabled.`);
-
-        if (error) {
-          msg.push(error);
-        } else if (attribute) {
-          msg.push(`Instead access it via \`this.getAttribute("${attribute}")\`.`);
-        }
-
-        logError(msg.join('\n'), getAssociatedVM(this));
-      },
-
-      set() {
-        const {
-          readOnly
-        } = globalHTMLProperties[propName];
-
-        if (readOnly) {
-          logError(`The global HTML property \`${propName}\` is read-only.`, getAssociatedVM(this));
-        }
-      }
-
-    });
-  });
-  return descriptors;
-} // This routine will prevent access to certain properties on a shadow root instance to guarantee
-// that all components will work fine in IE11 and other browsers without shadow dom support.
-
-
-function patchShadowRootWithRestrictions(sr) {
-  defineProperties(sr, getShadowRootRestrictionsDescriptors(sr));
-}
-
-function patchCustomElementWithRestrictions(elm) {
-  const restrictionsDescriptors = getCustomElementRestrictionsDescriptors(elm);
-  const elmProto = getPrototypeOf$1(elm);
-  setPrototypeOf(elm, create(elmProto, restrictionsDescriptors));
-}
-
-function patchComponentWithRestrictions(cmp) {
-  defineProperties(cmp, getComponentRestrictionsDescriptors());
-}
-
-function patchLightningElementPrototypeWithRestrictions(proto) {
-  defineProperties(proto, getLightningElementPrototypeRestrictionsDescriptors(proto));
-}
-/*
- * 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
- */
-// This is a temporary workaround to get the @lwc/engine-server to evaluate in node without having
-// to inject at runtime.
-
-
-const HTMLElementConstructor = typeof HTMLElement !== 'undefined' ? HTMLElement : function () {};
-const HTMLElementPrototype = HTMLElementConstructor.prototype;
-/*
- * 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
- */
-
-/**
- * This is a descriptor map that contains
- * all standard properties that a Custom Element can support (including AOM properties), which
- * determines what kind of capabilities the Base HTML Element and
- * Base Lightning Element should support.
- */
-
-const HTMLElementOriginalDescriptors = create(null);
-forEach.call(keys(AriaPropNameToAttrNameMap), propName => {
-  // Note: intentionally using our in-house getPropertyDescriptor instead of getOwnPropertyDescriptor here because
-  // in IE11, some properties are on Element.prototype instead of HTMLElement, just to be sure.
-  const descriptor = getPropertyDescriptor(HTMLElementPrototype, propName);
-
-  if (!isUndefined$1(descriptor)) {
-    HTMLElementOriginalDescriptors[propName] = descriptor;
-  }
-});
-forEach.call(defaultDefHTMLPropertyNames, propName => {
-  // Note: intentionally using our in-house getPropertyDescriptor instead of getOwnPropertyDescriptor here because
-  // in IE11, id property is on Element.prototype instead of HTMLElement, and we suspect that more will fall into
-  // this category, so, better to be sure.
-  const descriptor = getPropertyDescriptor(HTMLElementPrototype, propName);
-
-  if (!isUndefined$1(descriptor)) {
-    HTMLElementOriginalDescriptors[propName] = descriptor;
-  }
-});
-/**
- * Copyright (C) 2017 salesforce.com, inc.
- */
+});
+/**
+ * Copyright (C) 2017 salesforce.com, inc.
+ */
 
 const {
   isArray
@@ -4012,304 +3635,625 @@ function createAttributeChangedCallback(attributeToPropMap, superAttributeChange
         superAttributeChangedCallback.apply(this, arguments);
       }
 
-      return;
-    }
+      return;
+    }
+
+    if (!isAttributeLocked(this, attrName)) {
+      // Ignore changes triggered by the engine itself during:
+      // * diffing when public props are attempting to reflect to the DOM
+      // * component via `this.setAttribute()`, should never update the prop
+      // Both cases, the setAttribute call is always wrapped by the unlocking of the
+      // attribute to be changed
+      return;
+    } // Reflect attribute change to the corresponding property when changed from outside.
+
+
+    this[propName] = newValue;
+  };
+}
+
+function HTMLBridgeElementFactory(SuperClass, props, methods) {
+  let HTMLBridgeElement;
+  /**
+   * Modern browsers will have all Native Constructors as regular Classes
+   * and must be instantiated with the new keyword. In older browsers,
+   * specifically IE11, those are objects with a prototype property defined,
+   * since they are not supposed to be extended or instantiated with the
+   * new keyword. This forking logic supports both cases, specifically because
+   * wc.ts relies on the construction path of the bridges to create new
+   * fully qualifying web components.
+   */
+
+  if (isFunction$1(SuperClass)) {
+    HTMLBridgeElement = class extends SuperClass {};
+  } else {
+    HTMLBridgeElement = function () {
+      // Bridge classes are not supposed to be instantiated directly in
+      // browsers that do not support web components.
+      throw new TypeError('Illegal constructor');
+    }; // prototype inheritance dance
+
+
+    setPrototypeOf(HTMLBridgeElement, SuperClass);
+    setPrototypeOf(HTMLBridgeElement.prototype, SuperClass.prototype);
+    defineProperty(HTMLBridgeElement.prototype, 'constructor', {
+      writable: true,
+      configurable: true,
+      value: HTMLBridgeElement
+    });
+  } // generating the hash table for attributes to avoid duplicate fields and facilitate validation
+  // and false positives in case of inheritance.
+
+
+  const attributeToPropMap = create(null);
+  const {
+    attributeChangedCallback: superAttributeChangedCallback
+  } = SuperClass.prototype;
+  const {
+    observedAttributes: superObservedAttributes = []
+  } = SuperClass;
+  const descriptors = create(null); // expose getters and setters for each public props on the new Element Bridge
+
+  for (let i = 0, len = props.length; i < len; i += 1) {
+    const propName = props[i];
+    attributeToPropMap[htmlPropertyToAttribute(propName)] = propName;
+    descriptors[propName] = {
+      get: createGetter(propName),
+      set: createSetter(propName),
+      enumerable: true,
+      configurable: true
+    };
+  } // expose public methods as props on the new Element Bridge
+
+
+  for (let i = 0, len = methods.length; i < len; i += 1) {
+    const methodName = methods[i];
+    descriptors[methodName] = {
+      value: createMethodCaller(methodName),
+      writable: true,
+      configurable: true
+    };
+  } // creating a new attributeChangedCallback per bridge because they are bound to the corresponding
+  // map of attributes to props. We do this after all other props and methods to avoid the possibility
+  // of getting overrule by a class declaration in user-land, and we make it non-writable, non-configurable
+  // to preserve this definition.
+
+
+  descriptors.attributeChangedCallback = {
+    value: createAttributeChangedCallback(attributeToPropMap, superAttributeChangedCallback)
+  }; // Specify attributes for which we want to reflect changes back to their corresponding
+  // properties via attributeChangedCallback.
+
+  defineProperty(HTMLBridgeElement, 'observedAttributes', {
+    get() {
+      return [...superObservedAttributes, ...keys(attributeToPropMap)];
+    }
+
+  });
+  defineProperties(HTMLBridgeElement.prototype, descriptors);
+  return HTMLBridgeElement;
+}
+
+const BaseBridgeElement = HTMLBridgeElementFactory(HTMLElementConstructor, getOwnPropertyNames$1(HTMLElementOriginalDescriptors), []);
+freeze(BaseBridgeElement);
+seal(BaseBridgeElement.prototype);
+/*
+ * Copyright (c) 2020, 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 resolveCircularModuleDependency(fn) {
+  const module = fn();
+  return (module === null || module === void 0 ? void 0 : module.__esModule) ? module.default : module;
+}
+
+function isCircularModuleDependency(obj) {
+  return isFunction$1(obj) && hasOwnProperty$1.call(obj, '__circular__');
+}
+/*
+ * Copyright (c) 2020, 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 swappedTemplateMap = new WeakMap();
+const swappedComponentMap = new WeakMap();
+const swappedStyleMap = new WeakMap();
+const activeTemplates = new WeakMap();
+const activeComponents = new WeakMap();
+const activeStyles = new WeakMap();
+
+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 getTemplateOrSwappedTemplate(tpl) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
+
+  if (runtimeFlags.ENABLE_HMR) {
+    const visited = new Set();
+
+    while (swappedTemplateMap.has(tpl) && !visited.has(tpl)) {
+      visited.add(tpl);
+      tpl = swappedTemplateMap.get(tpl);
+    }
+  }
+
+  return tpl;
+}
+
+function getComponentOrSwappedComponent(Ctor) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
+
+  if (runtimeFlags.ENABLE_HMR) {
+    const visited = new Set();
+
+    while (swappedComponentMap.has(Ctor) && !visited.has(Ctor)) {
+      visited.add(Ctor);
+      Ctor = swappedComponentMap.get(Ctor);
+    }
+  }
+
+  return Ctor;
+}
+
+function getStyleOrSwappedStyle(style) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
+
+  if (runtimeFlags.ENABLE_HMR) {
+    const visited = new Set();
+
+    while (swappedStyleMap.has(style) && !visited.has(style)) {
+      visited.add(style);
+      style = swappedStyleMap.get(style);
+    }
+  }
+
+  return style;
+}
+
+function setActiveVM(vm) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
+
+  if (runtimeFlags.ENABLE_HMR) {
+    // tracking active component
+    const Ctor = vm.def.ctor;
+    let componentVMs = activeComponents.get(Ctor);
+
+    if (isUndefined$1(componentVMs)) {
+      componentVMs = new Set();
+      activeComponents.set(Ctor, componentVMs);
+    } // this will allow us to keep track of the hot components
+
+
+    componentVMs.add(vm); // tracking active template
+
+    const tpl = vm.cmpTemplate;
+
+    if (tpl) {
+      let templateVMs = activeTemplates.get(tpl);
+
+      if (isUndefined$1(templateVMs)) {
+        templateVMs = new Set();
+        activeTemplates.set(tpl, templateVMs);
+      } // this will allow us to keep track of the templates that are
+      // being used by a hot component
+
 
-    if (!isAttributeLocked(this, attrName)) {
-      // Ignore changes triggered by the engine itself during:
-      // * diffing when public props are attempting to reflect to the DOM
-      // * component via `this.setAttribute()`, should never update the prop
-      // Both cases, the setAttribute call is always wrapped by the unlocking of the
-      // attribute to be changed
-      return;
-    } // Reflect attribute change to the corresponding property when changed from outside.
+      templateVMs.add(vm); // tracking active styles associated to template
 
+      const stylesheets = tpl.stylesheets;
 
-    this[propName] = newValue;
-  };
-}
+      if (!isUndefined$1(stylesheets)) {
+        flattenStylesheets(stylesheets).forEach(stylesheet => {
+          // this is necessary because we don't hold the list of styles
+          // in the vm, we only hold the selected (already swapped template)
+          // but the styles attached to the template might not be the actual
+          // active ones, but the swapped versions of those.
+          stylesheet = getStyleOrSwappedStyle(stylesheet);
+          let stylesheetVMs = activeStyles.get(stylesheet);
 
-function HTMLBridgeElementFactory(SuperClass, props, methods) {
-  let HTMLBridgeElement;
-  /**
-   * Modern browsers will have all Native Constructors as regular Classes
-   * and must be instantiated with the new keyword. In older browsers,
-   * specifically IE11, those are objects with a prototype property defined,
-   * since they are not supposed to be extended or instantiated with the
-   * new keyword. This forking logic supports both cases, specifically because
-   * wc.ts relies on the construction path of the bridges to create new
-   * fully qualifying web components.
-   */
+          if (isUndefined$1(stylesheetVMs)) {
+            stylesheetVMs = new Set();
+            activeStyles.set(stylesheet, stylesheetVMs);
+          } // this will allow us to keep track of the stylesheet that are
+          // being used by a hot component
 
-  if (isFunction$1(SuperClass)) {
-    HTMLBridgeElement = class extends SuperClass {};
-  } else {
-    HTMLBridgeElement = function () {
-      // Bridge classes are not supposed to be instantiated directly in
-      // browsers that do not support web components.
-      throw new TypeError('Illegal constructor');
-    }; // prototype inheritance dance
 
+          stylesheetVMs.add(vm);
+        });
+      }
+    }
+  }
+}
 
-    setPrototypeOf(HTMLBridgeElement, SuperClass);
-    setPrototypeOf(HTMLBridgeElement.prototype, SuperClass.prototype);
-    defineProperty(HTMLBridgeElement.prototype, 'constructor', {
-      writable: true,
-      configurable: true,
-      value: HTMLBridgeElement
-    });
-  } // generating the hash table for attributes to avoid duplicate fields and facilitate validation
-  // and false positives in case of inheritance.
+function removeActiveVM(vm) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
 
+  if (runtimeFlags.ENABLE_HMR) {
+    // tracking inactive component
+    const Ctor = vm.def.ctor;
+    let list = activeComponents.get(Ctor);
 
-  const attributeToPropMap = create(null);
-  const {
-    attributeChangedCallback: superAttributeChangedCallback
-  } = SuperClass.prototype;
-  const {
-    observedAttributes: superObservedAttributes = []
-  } = SuperClass;
-  const descriptors = create(null); // expose getters and setters for each public props on the new Element Bridge
+    if (!isUndefined$1(list)) {
+      // deleting the vm from the set to avoid leaking memory
+      list.delete(vm);
+    } // removing inactive template
 
-  for (let i = 0, len = props.length; i < len; i += 1) {
-    const propName = props[i];
-    attributeToPropMap[htmlPropertyToAttribute(propName)] = propName;
-    descriptors[propName] = {
-      get: createGetter(propName),
-      set: createSetter(propName),
-      enumerable: true,
-      configurable: true
-    };
-  } // expose public methods as props on the new Element Bridge
 
+    const tpl = vm.cmpTemplate;
 
-  for (let i = 0, len = methods.length; i < len; i += 1) {
-    const methodName = methods[i];
-    descriptors[methodName] = {
-      value: createMethodCaller(methodName),
-      writable: true,
-      configurable: true
-    };
-  } // creating a new attributeChangedCallback per bridge because they are bound to the corresponding
-  // map of attributes to props. We do this after all other props and methods to avoid the possibility
-  // of getting overrule by a class declaration in user-land, and we make it non-writable, non-configurable
-  // to preserve this definition.
+    if (tpl) {
+      list = activeTemplates.get(tpl);
 
+      if (!isUndefined$1(list)) {
+        // deleting the vm from the set to avoid leaking memory
+        list.delete(vm);
+      } // removing active styles associated to template
 
-  descriptors.attributeChangedCallback = {
-    value: createAttributeChangedCallback(attributeToPropMap, superAttributeChangedCallback)
-  }; // Specify attributes for which we want to reflect changes back to their corresponding
-  // properties via attributeChangedCallback.
 
-  defineProperty(HTMLBridgeElement, 'observedAttributes', {
-    get() {
-      return [...superObservedAttributes, ...keys(attributeToPropMap)];
-    }
+      const styles = tpl.stylesheets;
 
-  });
-  defineProperties(HTMLBridgeElement.prototype, descriptors);
-  return HTMLBridgeElement;
-}
+      if (!isUndefined$1(styles)) {
+        flattenStylesheets(styles).forEach(style => {
+          list = activeStyles.get(style);
 
-const BaseBridgeElement = HTMLBridgeElementFactory(HTMLElementConstructor, getOwnPropertyNames$1(HTMLElementOriginalDescriptors), []);
-freeze(BaseBridgeElement);
-seal(BaseBridgeElement.prototype);
+          if (!isUndefined$1(list)) {
+            // deleting the vm from the set to avoid leaking memory
+            list.delete(vm);
+          }
+        });
+      }
+    }
+  }
+}
 /*
- * Copyright (c) 2020, salesforce.com, inc.
+ * 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 resolveCircularModuleDependency(fn) {
-  const module = fn();
-  return (module === null || module === void 0 ? void 0 : module.__esModule) ? module.default : module;
-}
 
-function isCircularModuleDependency(obj) {
-  return isFunction$1(obj) && hasOwnProperty$1.call(obj, '__circular__');
+const CtorToDefMap = new WeakMap();
+
+function getCtorProto(Ctor) {
+  let proto = getPrototypeOf$1(Ctor);
+
+  if (isNull(proto)) {
+    throw new ReferenceError(`Invalid prototype chain for ${Ctor.name}, you must extend LightningElement.`);
+  } // covering the cases where the ref is circular in AMD
+
+
+  if (isCircularModuleDependency(proto)) {
+    const p = resolveCircularModuleDependency(proto);
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (isNull(p)) {
+        throw new ReferenceError(`Circular module dependency for ${Ctor.name}, must resolve to a constructor that extends LightningElement.`);
+      }
+    } // escape hatch for Locker and other abstractions to provide their own base class instead
+    // of our Base class without having to leak it to user-land. If the circular function returns
+    // itself, that's the signal that we have hit the end of the proto chain, which must always
+    // be base.
+
+
+    proto = p === proto ? LightningElement : p;
+  }
+
+  return proto;
 }
-/*
- * Copyright (c) 2020, 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 createComponentDef(Ctor) {
+  const {
+    shadowSupportMode: ctorShadowSupportMode,
+    renderMode: ctorRenderMode
+  } = Ctor;
 
-const swappedTemplateMap = new WeakMap();
-const swappedComponentMap = new WeakMap();
-const swappedStyleMap = new WeakMap();
-const activeTemplates = new WeakMap();
-const activeComponents = new WeakMap();
-const activeStyles = new WeakMap();
+  if (process.env.NODE_ENV !== 'production') {
+    const ctorName = Ctor.name; // Removing the following assert until https://bugs.webkit.org/show_bug.cgi?id=190140 is fixed.
+    // assert.isTrue(ctorName && isString(ctorName), `${toString(Ctor)} should have a "name" property with string value, but found ${ctorName}.`);
 
-function flattenStylesheets(stylesheets) {
-  const list = [];
+    assert.isTrue(Ctor.constructor, `Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
 
-  for (const stylesheet of stylesheets) {
-    if (!Array.isArray(stylesheet)) {
-      list.push(stylesheet);
-    } else {
-      list.push(...flattenStylesheets(stylesheet));
+    if (!isUndefined$1(ctorShadowSupportMode)) {
+      assert.invariant(ctorShadowSupportMode === "any"
+      /* Any */
+      || ctorShadowSupportMode === "reset"
+      /* Default */
+      , `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
     }
+
+    if (!isUndefined$1(ctorRenderMode)) {
+      assert.invariant(ctorRenderMode === 'light' || ctorRenderMode === 'shadow', `Invalid value for static property renderMode: '${ctorRenderMode}'. renderMode must be either 'light' or 'shadow'.`);
+    }
+  }
+
+  const decoratorsMeta = getDecoratorsMeta(Ctor);
+  const {
+    apiFields,
+    apiFieldsConfig,
+    apiMethods,
+    wiredFields,
+    wiredMethods,
+    observedFields
+  } = decoratorsMeta;
+  const proto = Ctor.prototype;
+  let {
+    connectedCallback,
+    disconnectedCallback,
+    renderedCallback,
+    errorCallback,
+    render
+  } = proto;
+  const superProto = getCtorProto(Ctor);
+  const superDef = superProto !== LightningElement ? getComponentInternalDef(superProto) : lightingElementDef;
+  const bridge = HTMLBridgeElementFactory(superDef.bridge, keys(apiFields), keys(apiMethods));
+  const props = assign(create(null), superDef.props, apiFields);
+  const propsConfig = assign(create(null), superDef.propsConfig, apiFieldsConfig);
+  const methods = assign(create(null), superDef.methods, apiMethods);
+  const wire = assign(create(null), superDef.wire, wiredFields, wiredMethods);
+  connectedCallback = connectedCallback || superDef.connectedCallback;
+  disconnectedCallback = disconnectedCallback || superDef.disconnectedCallback;
+  renderedCallback = renderedCallback || superDef.renderedCallback;
+  errorCallback = errorCallback || superDef.errorCallback;
+  render = render || superDef.render;
+  let shadowSupportMode = superDef.shadowSupportMode;
+
+  if (!isUndefined$1(ctorShadowSupportMode)) {
+    shadowSupportMode = ctorShadowSupportMode;
+  }
+
+  let renderMode = superDef.renderMode;
+
+  if (!isUndefined$1(ctorRenderMode)) {
+    renderMode = ctorRenderMode === 'light' ? 0
+    /* Light */
+    : 1
+    /* Shadow */
+    ;
   }
 
-  return list;
-}
-
-function getTemplateOrSwappedTemplate(tpl) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
+  const template = getComponentRegisteredTemplate(Ctor) || superDef.template;
+  const name = Ctor.name || superDef.name; // installing observed fields into the prototype.
 
-  if (runtimeFlags.ENABLE_HMR) {
-    const visited = new Set();
+  defineProperties(proto, observedFields);
+  const def = {
+    ctor: Ctor,
+    name,
+    wire,
+    props,
+    propsConfig,
+    methods,
+    bridge,
+    template,
+    renderMode,
+    shadowSupportMode,
+    connectedCallback,
+    disconnectedCallback,
+    renderedCallback,
+    errorCallback,
+    render
+  };
 
-    while (swappedTemplateMap.has(tpl) && !visited.has(tpl)) {
-      visited.add(tpl);
-      tpl = swappedTemplateMap.get(tpl);
-    }
+  if (process.env.NODE_ENV !== 'production') {
+    freeze(Ctor.prototype);
   }
 
-  return tpl;
+  return def;
 }
+/**
+ * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
+ * subject to change or being removed.
+ */
 
-function getComponentOrSwappedComponent(Ctor) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
 
-  if (runtimeFlags.ENABLE_HMR) {
-    const visited = new Set();
+function isComponentConstructor(ctor) {
+  if (!isFunction$1(ctor)) {
+    return false;
+  } // Fast path: LightningElement is part of the prototype chain of the constructor.
 
-    while (swappedComponentMap.has(Ctor) && !visited.has(Ctor)) {
-      visited.add(Ctor);
-      Ctor = swappedComponentMap.get(Ctor);
-    }
-  }
 
-  return Ctor;
-}
+  if (ctor.prototype instanceof LightningElement) {
+    return true;
+  } // Slow path: LightningElement is not part of the prototype chain of the constructor, we need
+  // climb up the constructor prototype chain to check in case there are circular dependencies
+  // to resolve.
 
-function getStyleOrSwappedStyle(style) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
 
-  if (runtimeFlags.ENABLE_HMR) {
-    const visited = new Set();
+  let current = ctor;
 
-    while (swappedStyleMap.has(style) && !visited.has(style)) {
-      visited.add(style);
-      style = swappedStyleMap.get(style);
-    }
-  }
+  do {
+    if (isCircularModuleDependency(current)) {
+      const circularResolved = resolveCircularModuleDependency(current); // If the circular function returns itself, that's the signal that we have hit the end
+      // of the proto chain, which must always be a valid base constructor.
 
-  return style;
-}
+      if (circularResolved === current) {
+        return true;
+      }
 
-function setActiveVM(vm) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
-  }
+      current = circularResolved;
+    }
 
-  if (runtimeFlags.ENABLE_HMR) {
-    // tracking active component
-    const Ctor = vm.def.ctor;
-    let componentVMs = activeComponents.get(Ctor);
+    if (current === LightningElement) {
+      return true;
+    }
+  } while (!isNull(current) && (current = getPrototypeOf$1(current))); // Finally return false if the LightningElement is not part of the prototype chain.
 
-    if (isUndefined$1(componentVMs)) {
-      componentVMs = new Set();
-      activeComponents.set(Ctor, componentVMs);
-    } // this will allow us to keep track of the hot components
 
+  return false;
+}
 
-    componentVMs.add(vm); // tracking active template
+function getComponentInternalDef(Ctor) {
+  if (process.env.NODE_ENV !== 'production') {
+    Ctor = getComponentOrSwappedComponent(Ctor);
+  }
 
-    const tpl = vm.cmpTemplate;
+  let def = CtorToDefMap.get(Ctor);
 
-    if (tpl) {
-      let templateVMs = activeTemplates.get(tpl);
+  if (isUndefined$1(def)) {
+    if (isCircularModuleDependency(Ctor)) {
+      const resolvedCtor = resolveCircularModuleDependency(Ctor);
+      def = getComponentInternalDef(resolvedCtor); // Cache the unresolved component ctor too. The next time if the same unresolved ctor is used,
+      // look up the definition in cache instead of re-resolving and recreating the def.
 
-      if (isUndefined$1(templateVMs)) {
-        templateVMs = new Set();
-        activeTemplates.set(tpl, templateVMs);
-      } // this will allow us to keep track of the templates that are
-      // being used by a hot component
+      CtorToDefMap.set(Ctor, def);
+      return def;
+    }
 
+    if (!isComponentConstructor(Ctor)) {
+      throw new TypeError(`${Ctor} is not a valid component, or does not extends LightningElement from "lwc". You probably forgot to add the extend clause on the class declaration.`);
+    }
 
-      templateVMs.add(vm); // tracking active styles associated to template
+    def = createComponentDef(Ctor);
+    CtorToDefMap.set(Ctor, def);
+  }
 
-      const stylesheets = tpl.stylesheets;
+  return def;
+}
 
-      if (!isUndefined$1(stylesheets)) {
-        flattenStylesheets(stylesheets).forEach(stylesheet => {
-          // this is necessary because we don't hold the list of styles
-          // in the vm, we only hold the selected (already swapped template)
-          // but the styles attached to the template might not be the actual
-          // active ones, but the swapped versions of those.
-          stylesheet = getStyleOrSwappedStyle(stylesheet);
-          let stylesheetVMs = activeStyles.get(stylesheet);
+const lightingElementDef = {
+  ctor: LightningElement,
+  name: LightningElement.name,
+  props: lightningBasedDescriptors,
+  propsConfig: EmptyObject,
+  methods: EmptyObject,
+  renderMode: 1
+  /* Shadow */
+  ,
+  shadowSupportMode: "reset"
+  /* Default */
+  ,
+  wire: EmptyObject,
+  bridge: BaseBridgeElement,
+  template: defaultEmptyTemplate,
+  render: LightningElement.prototype.render
+};
+/**
+ * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
+ * subject to change or being removed.
+ */
 
-          if (isUndefined$1(stylesheetVMs)) {
-            stylesheetVMs = new Set();
-            activeStyles.set(stylesheet, stylesheetVMs);
-          } // this will allow us to keep track of the stylesheet that are
-          // being used by a hot component
+function getComponentDef(Ctor) {
+  const def = getComponentInternalDef(Ctor); // From the internal def object, we need to extract the info that is useful
+  // for some external services, e.g.: Locker Service, usually, all they care
+  // is about the shape of the constructor, the internals of it are not relevant
+  // because they don't have a way to mess with that.
 
+  const {
+    ctor,
+    name,
+    props,
+    propsConfig,
+    methods
+  } = def;
+  const publicProps = {};
 
-          stylesheetVMs.add(vm);
-        });
-      }
-    }
+  for (const key in props) {
+    // avoid leaking the reference to the public props descriptors
+    publicProps[key] = {
+      config: propsConfig[key] || 0,
+      type: "any"
+      /* any */
+      ,
+      attr: htmlPropertyToAttribute(key)
+    };
   }
-}
 
-function removeActiveVM(vm) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
+  const publicMethods = {};
+
+  for (const key in methods) {
+    // avoid leaking the reference to the public method descriptors
+    publicMethods[key] = methods[key].value;
   }
 
-  if (runtimeFlags.ENABLE_HMR) {
-    // tracking inactive component
-    const Ctor = vm.def.ctor;
-    let list = activeComponents.get(Ctor);
+  return {
+    ctor,
+    name,
+    props: publicProps,
+    methods: publicMethods
+  };
+}
+/*
+ * 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
+ */
 
-    if (!isUndefined$1(list)) {
-      // deleting the vm from the set to avoid leaking memory
-      list.delete(vm);
-    } // removing inactive template
 
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const xmlNS = 'http://www.w3.org/XML/1998/namespace';
+const ColonCharCode = 58;
 
-    const tpl = vm.cmpTemplate;
+function patchAttributes(oldVnode, vnode) {
+  const {
+    attrs
+  } = vnode.data;
 
-    if (tpl) {
-      list = activeTemplates.get(tpl);
+  if (isUndefined$1(attrs)) {
+    return;
+  }
 
-      if (!isUndefined$1(list)) {
-        // deleting the vm from the set to avoid leaking memory
-        list.delete(vm);
-      } // removing active styles associated to template
+  const oldAttrs = isNull(oldVnode) ? EmptyObject : oldVnode.data.attrs;
+
+  if (oldAttrs === attrs) {
+    return;
+  }
 
+  const {
+    elm
+  } = vnode;
 
-      const styles = tpl.stylesheets;
+  for (const key in attrs) {
+    const cur = attrs[key];
+    const old = oldAttrs[key];
 
-      if (!isUndefined$1(styles)) {
-        flattenStylesheets(styles).forEach(style => {
-          list = activeStyles.get(style);
+    if (old !== cur) {
+      unlockAttribute(elm, key);
 
-          if (!isUndefined$1(list)) {
-            // deleting the vm from the set to avoid leaking memory
-            list.delete(vm);
-          }
-        });
+      if (StringCharCodeAt.call(key, 3) === ColonCharCode) {
+        // Assume xml namespace
+        setAttribute$1(elm, key, cur, xmlNS);
+      } else if (StringCharCodeAt.call(key, 5) === ColonCharCode) {
+        // Assume xlink namespace
+        setAttribute$1(elm, key, cur, xlinkNS);
+      } else if (isNull(cur) || isUndefined$1(cur)) {
+        removeAttribute$1(elm, key);
+      } else {
+        setAttribute$1(elm, key, cur);
       }
+
+      lockAttribute();
     }
   }
 }
@@ -4321,264 +4265,232 @@ function removeActiveVM(vm) {
  */
 
 
-const CtorToDefMap = new WeakMap();
+function isLiveBindingProp(sel, key) {
+  // For properties with live bindings, we read values from the DOM element
+  // instead of relying on internally tracked values.
+  return sel === 'input' && (key === 'value' || key === 'checked');
+}
 
-function getCtorProto(Ctor) {
-  let proto = getPrototypeOf$1(Ctor);
+function patchProps(oldVnode, vnode) {
+  const {
+    props
+  } = vnode.data;
 
-  if (isNull(proto)) {
-    throw new ReferenceError(`Invalid prototype chain for ${Ctor.name}, you must extend LightningElement.`);
-  } // covering the cases where the ref is circular in AMD
+  if (isUndefined$1(props)) {
+    return;
+  }
 
+  const oldProps = isNull(oldVnode) ? EmptyObject : oldVnode.data.props;
 
-  if (isCircularModuleDependency(proto)) {
-    const p = resolveCircularModuleDependency(proto);
+  if (oldProps === props) {
+    return;
+  }
 
-    if (process.env.NODE_ENV !== 'production') {
-      if (isNull(p)) {
-        throw new ReferenceError(`Circular module dependency for ${Ctor.name}, must resolve to a constructor that extends LightningElement.`);
-      }
-    } // escape hatch for Locker and other abstractions to provide their own base class instead
-    // of our Base class without having to leak it to user-land. If the circular function returns
-    // itself, that's the signal that we have hit the end of the proto chain, which must always
-    // be base.
+  const isFirstPatch = isNull(oldVnode);
+  const {
+    elm,
+    sel
+  } = vnode;
 
+  for (const key in props) {
+    const cur = props[key]; // Set the property if it's the first time is is patched or if the previous property is
+    // different than the one previously set.
 
-    proto = p === proto ? LightningElement : p;
+    if (isFirstPatch || cur !== (isLiveBindingProp(sel, key) ? getProperty$1(elm, key) : oldProps[key])) {
+      setProperty$1(elm, key, cur);
+    }
   }
-
-  return proto;
 }
+/*
+ * 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 createComponentDef(Ctor) {
-  const {
-    shadowSupportMode: ctorShadowSupportMode,
-    renderMode: ctorRenderMode
-  } = Ctor;
-
-  if (process.env.NODE_ENV !== 'production') {
-    const ctorName = Ctor.name; // Removing the following assert until https://bugs.webkit.org/show_bug.cgi?id=190140 is fixed.
-    // assert.isTrue(ctorName && isString(ctorName), `${toString(Ctor)} should have a "name" property with string value, but found ${ctorName}.`);
 
-    assert.isTrue(Ctor.constructor, `Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
+const classNameToClassMap = create(null);
 
-    if (!isUndefined$1(ctorShadowSupportMode)) {
-      assert.invariant(ctorShadowSupportMode === "any"
-      /* Any */
-      || ctorShadowSupportMode === "reset"
-      /* Default */
-      , `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
-    }
+function getMapFromClassName(className) {
+  // Intentionally using == to match undefined and null values from computed style attribute
+  if (className == null) {
+    return EmptyObject;
+  } // computed class names must be string
 
-    if (!isUndefined$1(ctorRenderMode)) {
-      assert.invariant(ctorRenderMode === 'light' || ctorRenderMode === 'shadow', `Invalid value for static property renderMode: '${ctorRenderMode}'. renderMode must be either 'light' or 'shadow'.`);
-    }
-  }
 
-  const decoratorsMeta = getDecoratorsMeta(Ctor);
-  const {
-    apiFields,
-    apiFieldsConfig,
-    apiMethods,
-    wiredFields,
-    wiredMethods,
-    observedFields
-  } = decoratorsMeta;
-  const proto = Ctor.prototype;
-  let {
-    connectedCallback,
-    disconnectedCallback,
-    renderedCallback,
-    errorCallback,
-    render
-  } = proto;
-  const superProto = getCtorProto(Ctor);
-  const superDef = superProto !== LightningElement ? getComponentInternalDef(superProto) : lightingElementDef;
-  const bridge = HTMLBridgeElementFactory(superDef.bridge, keys(apiFields), keys(apiMethods));
-  const props = assign(create(null), superDef.props, apiFields);
-  const propsConfig = assign(create(null), superDef.propsConfig, apiFieldsConfig);
-  const methods = assign(create(null), superDef.methods, apiMethods);
-  const wire = assign(create(null), superDef.wire, wiredFields, wiredMethods);
-  connectedCallback = connectedCallback || superDef.connectedCallback;
-  disconnectedCallback = disconnectedCallback || superDef.disconnectedCallback;
-  renderedCallback = renderedCallback || superDef.renderedCallback;
-  errorCallback = errorCallback || superDef.errorCallback;
-  render = render || superDef.render;
-  let shadowSupportMode = superDef.shadowSupportMode;
+  className = isString(className) ? className : className + '';
+  let map = classNameToClassMap[className];
 
-  if (!isUndefined$1(ctorShadowSupportMode)) {
-    shadowSupportMode = ctorShadowSupportMode;
+  if (map) {
+    return map;
   }
 
-  let renderMode = superDef.renderMode;
+  map = create(null);
+  let start = 0;
+  let o;
+  const len = className.length;
 
-  if (!isUndefined$1(ctorRenderMode)) {
-    renderMode = ctorRenderMode === 'light' ? 0
-    /* Light */
-    : 1
-    /* Shadow */
-    ;
+  for (o = 0; o < len; o++) {
+    if (StringCharCodeAt.call(className, o) === SPACE_CHAR) {
+      if (o > start) {
+        map[StringSlice.call(className, start, o)] = true;
+      }
+
+      start = o + 1;
+    }
   }
 
-  const template = getComponentRegisteredTemplate(Ctor) || superDef.template;
-  const name = Ctor.name || superDef.name; // installing observed fields into the prototype.
+  if (o > start) {
+    map[StringSlice.call(className, start, o)] = true;
+  }
 
-  defineProperties(proto, observedFields);
-  const def = {
-    ctor: Ctor,
-    name,
-    wire,
-    props,
-    propsConfig,
-    methods,
-    bridge,
-    template,
-    renderMode,
-    shadowSupportMode,
-    connectedCallback,
-    disconnectedCallback,
-    renderedCallback,
-    errorCallback,
-    render
-  };
+  classNameToClassMap[className] = map;
 
   if (process.env.NODE_ENV !== 'production') {
-    freeze(Ctor.prototype);
+    // just to make sure that this object never changes as part of the diffing algo
+    freeze(map);
   }
 
-  return def;
+  return map;
 }
-/**
- * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
- * subject to change or being removed.
- */
-
-
-function isComponentConstructor(ctor) {
-  if (!isFunction$1(ctor)) {
-    return false;
-  } // Fast path: LightningElement is part of the prototype chain of the constructor.
 
+function patchClassAttribute(oldVnode, vnode) {
+  const {
+    elm,
+    data: {
+      className: newClass
+    }
+  } = vnode;
+  const oldClass = isNull(oldVnode) ? undefined : oldVnode.data.className;
 
-  if (ctor.prototype instanceof LightningElement) {
-    return true;
-  } // Slow path: LightningElement is not part of the prototype chain of the constructor, we need
-  // climb up the constructor prototype chain to check in case there are circular dependencies
-  // to resolve.
+  if (oldClass === newClass) {
+    return;
+  }
 
+  const classList = getClassList$1(elm);
+  const newClassMap = getMapFromClassName(newClass);
+  const oldClassMap = getMapFromClassName(oldClass);
+  let name;
 
-  let current = ctor;
+  for (name in oldClassMap) {
+    // remove only if it is not in the new class collection and it is not set from within the instance
+    if (isUndefined$1(newClassMap[name])) {
+      classList.remove(name);
+    }
+  }
 
-  do {
-    if (isCircularModuleDependency(current)) {
-      const circularResolved = resolveCircularModuleDependency(current); // If the circular function returns itself, that's the signal that we have hit the end
-      // of the proto chain, which must always be a valid base constructor.
+  for (name in newClassMap) {
+    if (isUndefined$1(oldClassMap[name])) {
+      classList.add(name);
+    }
+  }
+}
+/*
+ * 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
+ */
 
-      if (circularResolved === current) {
-        return true;
-      }
 
-      current = circularResolved;
+function patchStyleAttribute(oldVnode, vnode) {
+  const {
+    elm,
+    data: {
+      style: newStyle
     }
+  } = vnode;
+  const oldStyle = isNull(oldVnode) ? undefined : oldVnode.data.style;
 
-    if (current === LightningElement) {
-      return true;
-    }
-  } while (!isNull(current) && (current = getPrototypeOf$1(current))); // Finally return false if the LightningElement is not part of the prototype chain.
+  if (oldStyle === newStyle) {
+    return;
+  }
+
+  if (!isString(newStyle) || newStyle === '') {
+    removeAttribute$1(elm, 'style');
+  } else {
+    setAttribute$1(elm, 'style', newStyle);
+  }
+}
+/*
+ * 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
+ */
 
 
-  return false;
-}
+function applyEventListeners(vnode) {
+  const {
+    elm,
+    data: {
+      on
+    }
+  } = vnode;
 
-function getComponentInternalDef(Ctor) {
-  if (process.env.NODE_ENV !== 'production') {
-    Ctor = getComponentOrSwappedComponent(Ctor);
+  if (isUndefined$1(on)) {
+    return;
   }
 
-  let def = CtorToDefMap.get(Ctor);
-
-  if (isUndefined$1(def)) {
-    if (isCircularModuleDependency(Ctor)) {
-      const resolvedCtor = resolveCircularModuleDependency(Ctor);
-      def = getComponentInternalDef(resolvedCtor); // Cache the unresolved component ctor too. The next time if the same unresolved ctor is used,
-      // look up the definition in cache instead of re-resolving and recreating the def.
+  for (const name in on) {
+    const handler = on[name];
+    addEventListener$1(elm, name, handler);
+  }
+}
+/*
+ * 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 compiler takes care of transforming the inline classnames into an object. It's faster to set the
+// different classnames properties individually instead of via a string.
 
-      CtorToDefMap.set(Ctor, def);
-      return def;
-    }
 
-    if (!isComponentConstructor(Ctor)) {
-      throw new TypeError(`${Ctor} is not a valid component, or does not extends LightningElement from "lwc". You probably forgot to add the extend clause on the class declaration.`);
+function applyStaticClassAttribute(vnode) {
+  const {
+    elm,
+    data: {
+      classMap
     }
+  } = vnode;
 
-    def = createComponentDef(Ctor);
-    CtorToDefMap.set(Ctor, def);
+  if (isUndefined$1(classMap)) {
+    return;
   }
 
-  return def;
-}
+  const classList = getClassList$1(elm);
 
-const lightingElementDef = {
-  ctor: LightningElement,
-  name: LightningElement.name,
-  props: lightningBasedDescriptors,
-  propsConfig: EmptyObject,
-  methods: EmptyObject,
-  renderMode: 1
-  /* Shadow */
-  ,
-  shadowSupportMode: "reset"
-  /* Default */
-  ,
-  wire: EmptyObject,
-  bridge: BaseBridgeElement,
-  template: defaultEmptyTemplate,
-  render: LightningElement.prototype.render
-};
-/**
- * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
- * subject to change or being removed.
+  for (const name in classMap) {
+    classList.add(name);
+  }
+}
+/*
+ * 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 compiler takes care of transforming the inline style into an object. It's faster to set the
+// different style properties individually instead of via a string.
 
-function getComponentDef(Ctor) {
-  const def = getComponentInternalDef(Ctor); // From the internal def object, we need to extract the info that is useful
-  // for some external services, e.g.: Locker Service, usually, all they care
-  // is about the shape of the constructor, the internals of it are not relevant
-  // because they don't have a way to mess with that.
 
+function applyStaticStyleAttribute(vnode) {
   const {
-    ctor,
-    name,
-    props,
-    propsConfig,
-    methods
-  } = def;
-  const publicProps = {};
+    elm,
+    data: {
+      styleDecls
+    }
+  } = vnode;
 
-  for (const key in props) {
-    // avoid leaking the reference to the public props descriptors
-    publicProps[key] = {
-      config: propsConfig[key] || 0,
-      type: "any"
-      /* any */
-      ,
-      attr: htmlPropertyToAttribute(key)
-    };
+  if (isUndefined$1(styleDecls)) {
+    return;
   }
 
-  const publicMethods = {};
-
-  for (const key in methods) {
-    // avoid leaking the reference to the public method descriptors
-    publicMethods[key] = methods[key].value;
+  for (let i = 0; i < styleDecls.length; i++) {
+    const [prop, value, important] = styleDecls[i];
+    setCSSStyleProperty$1(elm, prop, value, important);
   }
-
-  return {
-    ctor,
-    name,
-    props: publicProps,
-    methods: publicMethods
-  };
 }
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -4652,28 +4564,24 @@ function removeNodeHook(vnode, parentNode) {
   }
 }
 
-function createElmHook(vnode) {
-  modEvents.create(vnode); // Attrs need to be applied to element before props
-  // IE11 will wipe out value on radio inputs if value
-  // is set before type=radio.
+function patchElementPropsAndAttrs(oldVnode, vnode) {
+  if (isNull(oldVnode)) {
+    applyEventListeners(vnode);
+    applyStaticClassAttribute(vnode);
+    applyStaticStyleAttribute(vnode);
+  } // Attrs need to be applied to element before props IE11 will wipe out value on radio inputs if
+  // value is set before type=radio.
 
-  modAttrs.create(vnode);
-  modProps.create(vnode);
-  modStaticClassName.create(vnode);
-  modStaticStyle.create(vnode);
-  modComputedClassName.create(vnode);
-  modComputedStyle.create(vnode);
+
+  patchClassAttribute(oldVnode, vnode);
+  patchStyleAttribute(oldVnode, vnode);
+  patchAttributes(oldVnode, vnode);
+  patchProps(oldVnode, vnode);
 }
 
 function hydrateElmHook(vnode) {
-  modEvents.create(vnode); // Attrs are already on the element.
-  // modAttrs.create(vnode);
-
-  modProps.create(vnode); // Already set.
-  // modStaticClassName.create(vnode);
-  // modStaticStyle.create(vnode);
-  // modComputedClassName.create(vnode);
-  // modComputedStyle.create(vnode);
+  applyEventListeners(vnode);
+  patchProps(null, vnode);
 }
 
 function fallbackElmHook(elm, vnode) {
@@ -4725,26 +4633,11 @@ function fallbackElmHook(elm, vnode) {
   }
 }
 
-function updateElmHook(oldVnode, vnode) {
-  // Attrs need to be applied to element before props
-  // IE11 will wipe out value on radio inputs if value
-  // is set before type=radio.
-  modAttrs.update(oldVnode, vnode);
-  modProps.update(oldVnode, vnode);
-  modComputedClassName.update(oldVnode, vnode);
-  modComputedStyle.update(oldVnode, vnode);
-}
-
-function updateChildrenHook(oldVnode, vnode) {
-  const {
-    elm,
-    children
-  } = vnode;
-
-  if (hasDynamicChildren(children)) {
-    updateDynamicChildren(elm, oldVnode.children, children);
+function patchChildren(parent, oldCh, newCh) {
+  if (hasDynamicChildren(newCh)) {
+    updateDynamicChildren(parent, oldCh, newCh);
   } else {
-    updateStaticChildren(elm, oldVnode.children, children);
+    updateStaticChildren(parent, oldCh, newCh);
   }
 }
 
@@ -4819,19 +4712,6 @@ function createViewModelHook(elm, vnode) {
   }
 }
 
-function createCustomElmHook(vnode) {
-  modEvents.create(vnode); // Attrs need to be applied to element before props
-  // IE11 will wipe out value on radio inputs if value
-  // is set before type=radio.
-
-  modAttrs.create(vnode);
-  modProps.create(vnode);
-  modStaticClassName.create(vnode);
-  modStaticStyle.create(vnode);
-  modComputedClassName.create(vnode);
-  modComputedStyle.create(vnode);
-}
-
 function createChildrenHook(vnode) {
   const {
     elm,
@@ -5012,16 +4892,6 @@ function hydrateChildrenHook(elmChildren, children, vm) {
   }
 }
 
-function updateCustomElmHook(oldVnode, vnode) {
-  // Attrs need to be applied to element before props
-  // IE11 will wipe out value on radio inputs if value
-  // is set before type=radio.
-  modAttrs.update(oldVnode, vnode);
-  modProps.update(oldVnode, vnode);
-  modComputedClassName.update(oldVnode, vnode);
-  modComputedStyle.update(oldVnode, vnode);
-}
-
 function removeElmHook(vnode) {
   // this method only needs to search on child vnodes from template
   // to trigger the remove hook just in case some of those children
@@ -5038,6 +4908,66 @@ function removeElmHook(vnode) {
       ch.hook.remove(ch, elm);
     }
   }
+}
+
+function allocateInSlot(vm, children) {
+  const {
+    cmpSlots: oldSlots
+  } = vm;
+  const cmpSlots = vm.cmpSlots = create(null);
+
+  for (let i = 0, len = children.length; i < len; i += 1) {
+    const vnode = children[i];
+
+    if (isNull(vnode)) {
+      continue;
+    }
+
+    const {
+      data
+    } = vnode;
+    const slotName = data.attrs && data.attrs.slot || '';
+    const vnodes = cmpSlots[slotName] = cmpSlots[slotName] || []; // re-keying the vnodes is necessary to avoid conflicts with default content for the slot
+    // which might have similar keys. Each vnode will always have a key that
+    // starts with a numeric character from compiler. In this case, we add a unique
+    // notation for slotted vnodes keys, e.g.: `@foo:1:1`
+
+    if (!isUndefined$1(vnode.key)) {
+      vnode.key = `@${slotName}:${vnode.key}`;
+    }
+
+    ArrayPush$1.call(vnodes, vnode);
+  }
+
+  if (isFalse(vm.isDirty)) {
+    // We need to determine if the old allocation is really different from the new one
+    // and mark the vm as dirty
+    const oldKeys = keys(oldSlots);
+
+    if (oldKeys.length !== keys(cmpSlots).length) {
+      markComponentAsDirty(vm);
+      return;
+    }
+
+    for (let i = 0, len = oldKeys.length; i < len; i += 1) {
+      const key = oldKeys[i];
+
+      if (isUndefined$1(cmpSlots[key]) || oldSlots[key].length !== cmpSlots[key].length) {
+        markComponentAsDirty(vm);
+        return;
+      }
+
+      const oldVNodes = oldSlots[key];
+      const vnodes = cmpSlots[key];
+
+      for (let j = 0, a = cmpSlots[key].length; j < a; j += 1) {
+        if (oldVNodes[j] !== vnodes[j]) {
+          markComponentAsDirty(vm);
+          return;
+        }
+      }
+    }
+  }
 } // Using a WeakMap instead of a WeakSet because this one works in IE11 :(
 
 
@@ -5184,11 +5114,11 @@ const ElementHook = {
     linkNodeToShadow(elm, owner);
     fallbackElmHook(elm, vnode);
     vnode.elm = elm;
-    createElmHook(vnode);
+    patchElementPropsAndAttrs(null, vnode);
   },
   update: (oldVnode, vnode) => {
-    updateElmHook(oldVnode, vnode);
-    updateChildrenHook(oldVnode, vnode);
+    patchElementPropsAndAttrs(oldVnode, vnode);
+    patchChildren(vnode.elm, oldVnode.children, vnode.children);
   },
   insert: (vnode, parentNode, referenceNode) => {
     insertNodeHook(vnode, parentNode, referenceNode);
@@ -5262,10 +5192,10 @@ const CustomElementHook = {
       throw new TypeError(`Incorrect Component Constructor`);
     }
 
-    createCustomElmHook(vnode);
+    patchElementPropsAndAttrs(null, vnode);
   },
   update: (oldVnode, vnode) => {
-    updateCustomElmHook(oldVnode, vnode);
+    patchElementPropsAndAttrs(oldVnode, vnode);
     const vm = getAssociatedVMIfPresent(vnode.elm);
 
     if (vm) {
@@ -5276,7 +5206,7 @@ const CustomElementHook = {
     // will happen, but in native, it does allocate the light dom
 
 
-    updateChildrenHook(oldVnode, vnode);
+    patchChildren(vnode.elm, oldVnode.children, vnode.children);
 
     if (vm) {
       if (process.env.NODE_ENV !== 'production') {
@@ -6918,7 +6848,6 @@ function patchShadowRoot(vm, newCh) {
     // patch function mutates vnodes by adding the element reference,
     // however, if patching fails it contains partial changes.
     if (oldCh !== newCh) {
-      const fn = hasDynamicChildren(newCh) ? updateDynamicChildren : updateStaticChildren;
       runWithBoundaryProtection(vm, vm, () => {
         // pre
         logOperationStart(2
@@ -6926,8 +6855,8 @@ function patchShadowRoot(vm, newCh) {
         , vm);
       }, () => {
         // job
-        const elementToRenderTo = getRenderRoot(vm);
-        fn(elementToRenderTo, oldCh, newCh);
+        const renderRoot = getRenderRoot(vm);
+        patchChildren(renderRoot, oldCh, newCh);
       }, () => {
         // post
         logOperationEnd(2
@@ -7222,69 +7151,6 @@ function getErrorBoundaryVM(vm) {
 
     currentVm = currentVm.owner;
   }
-} // slow path routine
-// NOTE: we should probably more this routine to the synthetic shadow folder
-// and get the allocation to be cached by in the elm instead of in the VM
-
-
-function allocateInSlot(vm, children) {
-  const {
-    cmpSlots: oldSlots
-  } = vm;
-  const cmpSlots = vm.cmpSlots = create(null);
-
-  for (let i = 0, len = children.length; i < len; i += 1) {
-    const vnode = children[i];
-
-    if (isNull(vnode)) {
-      continue;
-    }
-
-    const {
-      data
-    } = vnode;
-    const slotName = data.attrs && data.attrs.slot || '';
-    const vnodes = cmpSlots[slotName] = cmpSlots[slotName] || []; // re-keying the vnodes is necessary to avoid conflicts with default content for the slot
-    // which might have similar keys. Each vnode will always have a key that
-    // starts with a numeric character from compiler. In this case, we add a unique
-    // notation for slotted vnodes keys, e.g.: `@foo:1:1`
-
-    if (!isUndefined$1(vnode.key)) {
-      vnode.key = `@${slotName}:${vnode.key}`;
-    }
-
-    ArrayPush$1.call(vnodes, vnode);
-  }
-
-  if (isFalse(vm.isDirty)) {
-    // We need to determine if the old allocation is really different from the new one
-    // and mark the vm as dirty
-    const oldKeys = keys(oldSlots);
-
-    if (oldKeys.length !== keys(cmpSlots).length) {
-      markComponentAsDirty(vm);
-      return;
-    }
-
-    for (let i = 0, len = oldKeys.length; i < len; i += 1) {
-      const key = oldKeys[i];
-
-      if (isUndefined$1(cmpSlots[key]) || oldSlots[key].length !== cmpSlots[key].length) {
-        markComponentAsDirty(vm);
-        return;
-      }
-
-      const oldVNodes = oldSlots[key];
-      const vnodes = cmpSlots[key];
-
-      for (let j = 0, a = cmpSlots[key].length; j < a; j += 1) {
-        if (oldVNodes[j] !== vnodes[j]) {
-          markComponentAsDirty(vm);
-          return;
-        }
-      }
-    }
-  }
 }
 
 function runWithBoundaryProtection(vm, owner, pre, job, post) {
@@ -7717,7 +7583,7 @@ function setHooks(hooks) {
   hooksAreSet = true;
   setSanitizeHtmlContentHook(hooks.sanitizeHtmlContent);
 }
-/* version: 2.7.2 */
+/* version: 2.7.3 */
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -8258,7 +8124,7 @@ function renderComponent(tagName, Ctor, props = {}) {
 
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.7.2 */
+/* version: 2.7.3 */
 
 exports.LightningElement = LightningElement;
 exports.api = api$1;