@lwc/engine-core 2.7.2 → 2.7.3

package/dist/engine-core.cjs.js

@@ -442,62 +442,204 @@ function logWarn(message, vm) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 
-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 (shared.isUndefined(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(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 (shared.isUndefined(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(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.
@@ -621,573 +763,49 @@ function unlockAttribute(elm, key) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-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;
 
-  if (shared.isUndefined(attrs)) {
-    return;
-  }
+function generateDataDescriptor(options) {
+  return shared.assign({
+    configurable: true,
+    enumerable: true,
+    writable: true
+  }, options);
+}
 
-  let {
-    data: {
-      attrs: oldAttrs
-    }
-  } = oldVnode;
+function generateAccessorDescriptor(options) {
+  return shared.assign({
+    configurable: true,
+    enumerable: true
+  }, options);
+}
 
-  if (oldAttrs === attrs) {
-    return;
+let isDomMutationAllowed = false;
+function unlockDomMutation() {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
   }
 
-  if (process.env.NODE_ENV !== 'production') {
-    shared.assert.invariant(shared.isUndefined(oldAttrs) || shared.keys(oldAttrs).join(',') === shared.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 = shared.isUndefined(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);
-
-      if (shared.StringCharCodeAt.call(key, 3) === ColonCharCode) {
-        // Assume xml namespace
-        setAttribute(elm, key, cur, xmlNS);
-      } else if (shared.StringCharCodeAt.call(key, 5) === ColonCharCode) {
-        // Assume xlink namespace
-        setAttribute(elm, key, cur, xlinkNS);
-      } else if (shared.isNull(cur) || shared.isUndefined(cur)) {
-        removeAttribute(elm, key);
-      } else {
-        setAttribute(elm, key, cur);
-      }
-
-      lockAttribute();
-    }
-  }
-}
-
-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
- */
-
-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 update(oldVnode, vnode) {
-  const props = vnode.data.props;
-
-  if (shared.isUndefined(props)) {
-    return;
-  }
-
-  const oldProps = oldVnode.data.props;
-
-  if (oldProps === props) {
-    return;
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    shared.assert.invariant(shared.isUndefined(oldProps) || shared.keys(oldProps).join(',') === shared.keys(props).join(','), 'vnode.data.props cannot change shape.');
-  }
-
-  const isFirstPatch = shared.isUndefined(oldProps);
-  const {
-    elm,
-    sel
-  } = vnode;
-
-  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...
-
-    if (isFirstPatch || cur !== (isLiveBindingProp(sel, key) ? getProperty(elm, key) : oldProps[key])) {
-      setProperty(elm, key, cur);
-    }
-  }
-}
-
-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
- */
-const classNameToClassMap = shared.create(null);
-
-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
-
-
-  className = shared.isString(className) ? className : className + '';
-  let map = classNameToClassMap[className];
-
-  if (map) {
-    return map;
-  }
-
-  map = shared.create(null);
-  let start = 0;
-  let o;
-  const len = className.length;
-
-  for (o = 0; o < len; o++) {
-    if (shared.StringCharCodeAt.call(className, o) === SPACE_CHAR) {
-      if (o > start) {
-        map[shared.StringSlice.call(className, start, o)] = true;
-      }
-
-      start = o + 1;
-    }
-  }
-
-  if (o > start) {
-    map[shared.StringSlice.call(className, start, o)] = true;
-  }
-
-  classNameToClassMap[className] = map;
-
-  if (process.env.NODE_ENV !== 'production') {
-    // just to make sure that this object never changes as part of the diffing algo
-    shared.freeze(map);
-  }
-
-  return map;
-}
-
-function updateClassAttribute(oldVnode, vnode) {
-  const {
-    elm,
-    data: {
-      className: newClass
-    }
-  } = vnode;
-  const {
-    data: {
-      className: oldClass
-    }
-  } = oldVnode;
-
-  if (oldClass === newClass) {
-    return;
-  }
-
-  const classList = getClassList(elm);
-  const newClassMap = getMapFromClassName(newClass);
-  const oldClassMap = getMapFromClassName(oldClass);
-  let name;
-
-  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 (shared.isUndefined(newClassMap[name])) {
-      classList.remove(name);
-    }
-  }
-
-  for (name in newClassMap) {
-    if (shared.isUndefined(oldClassMap[name])) {
-      classList.add(name);
-    }
-  }
-}
-
-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
- */
-
-function updateStyleAttribute(oldVnode, vnode) {
-  const {
-    elm,
-    data: {
-      style: newStyle
-    }
-  } = vnode;
-
-  if (oldVnode.data.style === newStyle) {
-    return;
-  }
-
-  if (!shared.isString(newStyle) || newStyle === '') {
-    removeAttribute(elm, 'style');
-  } else {
-    setAttribute(elm, 'style', newStyle);
-  }
-}
-
-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 createClassAttribute(vnode) {
-  const {
-    elm,
-    data: {
-      classMap
-    }
-  } = vnode;
-
-  if (shared.isUndefined(classMap)) {
-    return;
-  }
-
-  const classList = getClassList(elm);
-
-  for (const name in classMap) {
-    classList.add(name);
-  }
-}
-
-var modStaticClassName = {
-  create: createClassAttribute
-};
-
-/*
- * 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 (shared.isUndefined(styleDecls)) {
-    return;
-  }
-
-  for (let i = 0; i < styleDecls.length; i++) {
-    const [prop, value, important] = styleDecls[i];
-    setCSSStyleProperty(elm, prop, value, important);
-  }
-}
-
-var modStaticStyle = {
-  create: createStyleAttribute
-};
-
-/*
- * 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 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 (isVNode(ch)) {
-      key = ch.key;
-
-      if (key !== undefined) {
-        map[key] = j;
-      }
-    }
-  }
-
-  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);
-    }
-  }
-}
-
-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(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 shared.assign({
-    configurable: true,
-    enumerable: true,
-    writable: true
-  }, options);
-}
-
-function generateAccessorDescriptor(options) {
-  return shared.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();
-  }
+function patchElementWithRestrictions(elm, options) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
 
   const originalOuterHTMLDescriptor = shared.getPropertyDescriptor(elm, 'outerHTML');
   const descriptors = {
@@ -3707,145 +3325,461 @@ function setActiveVM(vm) {
     throw new ReferenceError();
   }
 
-  if (features.runtimeFlags.ENABLE_HMR) {
-    // tracking active component
-    const Ctor = vm.def.ctor;
-    let componentVMs = activeComponents.get(Ctor);
+  if (features.runtimeFlags.ENABLE_HMR) {
+    // tracking active component
+    const Ctor = vm.def.ctor;
+    let componentVMs = activeComponents.get(Ctor);
+
+    if (shared.isUndefined(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 (shared.isUndefined(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
+
+
+      templateVMs.add(vm); // tracking active styles associated to template
+
+      const stylesheets = tpl.stylesheets;
+
+      if (!shared.isUndefined(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);
+
+          if (shared.isUndefined(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
+
+
+          stylesheetVMs.add(vm);
+        });
+      }
+    }
+  }
+}
+function removeActiveVM(vm) {
+  if (process.env.NODE_ENV === 'production') {
+    // this method should never leak to prod
+    throw new ReferenceError();
+  }
+
+  if (features.runtimeFlags.ENABLE_HMR) {
+    // tracking inactive component
+    const Ctor = vm.def.ctor;
+    let list = activeComponents.get(Ctor);
+
+    if (!shared.isUndefined(list)) {
+      // deleting the vm from the set to avoid leaking memory
+      list.delete(vm);
+    } // removing inactive template
+
+
+    const tpl = vm.cmpTemplate;
+
+    if (tpl) {
+      list = activeTemplates.get(tpl);
+
+      if (!shared.isUndefined(list)) {
+        // deleting the vm from the set to avoid leaking memory
+        list.delete(vm);
+      } // removing active styles associated to template
+
+
+      const styles = tpl.stylesheets;
+
+      if (!shared.isUndefined(styles)) {
+        flattenStylesheets(styles).forEach(style => {
+          list = activeStyles.get(style);
+
+          if (!shared.isUndefined(list)) {
+            // deleting the vm from the set to avoid leaking memory
+            list.delete(vm);
+          }
+        });
+      }
+    }
+  }
+}
+function swapTemplate(oldTpl, newTpl) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (isTemplateRegistered(oldTpl) && isTemplateRegistered(newTpl)) {
+      swappedTemplateMap.set(oldTpl, newTpl);
+      return rehydrateHotTemplate(oldTpl);
+    } else {
+      throw new TypeError(`Invalid Template`);
+    }
+  }
+
+  if (!features.runtimeFlags.ENABLE_HMR) {
+    throw new Error('HMR is not enabled');
+  }
+
+  return false;
+}
+function swapComponent(oldComponent, newComponent) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (isComponentConstructor(oldComponent) && isComponentConstructor(newComponent)) {
+      swappedComponentMap.set(oldComponent, newComponent);
+      return rehydrateHotComponent(oldComponent);
+    } else {
+      throw new TypeError(`Invalid Component`);
+    }
+  }
+
+  if (!features.runtimeFlags.ENABLE_HMR) {
+    throw new Error('HMR is not enabled');
+  }
+
+  return false;
+}
+function swapStyle(oldStyle, newStyle) {
+  if (process.env.NODE_ENV !== 'production') {
+    // TODO [#1887]: once the support for registering styles is implemented
+    // we can add the validation of both styles around this block.
+    swappedStyleMap.set(oldStyle, newStyle);
+    return rehydrateHotStyle(oldStyle);
+  }
+
+  if (!features.runtimeFlags.ENABLE_HMR) {
+    throw new Error('HMR is not enabled');
+  }
+
+  return false;
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const CtorToDefMap = new WeakMap();
+
+function getCtorProto(Ctor) {
+  let proto = shared.getPrototypeOf(Ctor);
+
+  if (shared.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 (shared.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;
+}
+
+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}.`);
+
+    shared.assert.isTrue(Ctor.constructor, `Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
+
+    if (!shared.isUndefined(ctorShadowSupportMode)) {
+      shared.assert.invariant(ctorShadowSupportMode === "any"
+      /* Any */
+      || ctorShadowSupportMode === "reset"
+      /* Default */
+      , `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
+    }
+
+    if (!shared.isUndefined(ctorRenderMode)) {
+      shared.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, shared.keys(apiFields), shared.keys(apiMethods));
+  const props = shared.assign(shared.create(null), superDef.props, apiFields);
+  const propsConfig = shared.assign(shared.create(null), superDef.propsConfig, apiFieldsConfig);
+  const methods = shared.assign(shared.create(null), superDef.methods, apiMethods);
+  const wire = shared.assign(shared.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 (!shared.isUndefined(ctorShadowSupportMode)) {
+    shadowSupportMode = ctorShadowSupportMode;
+  }
+
+  let renderMode = superDef.renderMode;
 
-    if (shared.isUndefined(componentVMs)) {
-      componentVMs = new Set();
-      activeComponents.set(Ctor, componentVMs);
-    } // this will allow us to keep track of the hot components
+  if (!shared.isUndefined(ctorRenderMode)) {
+    renderMode = ctorRenderMode === 'light' ? 0
+    /* Light */
+    : 1
+    /* Shadow */
+    ;
+  }
 
+  const template = getComponentRegisteredTemplate(Ctor) || superDef.template;
+  const name = Ctor.name || superDef.name; // installing observed fields into the prototype.
 
-    componentVMs.add(vm); // tracking active template
+  shared.defineProperties(proto, observedFields);
+  const def = {
+    ctor: Ctor,
+    name,
+    wire,
+    props,
+    propsConfig,
+    methods,
+    bridge,
+    template,
+    renderMode,
+    shadowSupportMode,
+    connectedCallback,
+    disconnectedCallback,
+    renderedCallback,
+    errorCallback,
+    render
+  };
 
-    const tpl = vm.cmpTemplate;
+  if (process.env.NODE_ENV !== 'production') {
+    shared.freeze(Ctor.prototype);
+  }
 
-    if (tpl) {
-      let templateVMs = activeTemplates.get(tpl);
+  return def;
+}
+/**
+ * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
+ * subject to change or being removed.
+ */
 
-      if (shared.isUndefined(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
 
+function isComponentConstructor(ctor) {
+  if (!shared.isFunction(ctor)) {
+    return false;
+  } // Fast path: LightningElement is part of the prototype chain of the constructor.
 
-      templateVMs.add(vm); // tracking active styles associated to template
 
-      const stylesheets = tpl.stylesheets;
+  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 (!shared.isUndefined(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);
 
-          if (shared.isUndefined(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
+  let current = ctor;
 
+  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.
 
-          stylesheetVMs.add(vm);
-        });
+      if (circularResolved === current) {
+        return true;
       }
+
+      current = circularResolved;
     }
-  }
+
+    if (current === LightningElement) {
+      return true;
+    }
+  } while (!shared.isNull(current) && (current = shared.getPrototypeOf(current))); // Finally return false if the LightningElement is not part of the prototype chain.
+
+
+  return false;
 }
-function removeActiveVM(vm) {
-  if (process.env.NODE_ENV === 'production') {
-    // this method should never leak to prod
-    throw new ReferenceError();
+function getComponentInternalDef(Ctor) {
+  if (process.env.NODE_ENV !== 'production') {
+    Ctor = getComponentOrSwappedComponent(Ctor);
   }
 
-  if (features.runtimeFlags.ENABLE_HMR) {
-    // tracking inactive component
-    const Ctor = vm.def.ctor;
-    let list = activeComponents.get(Ctor);
-
-    if (!shared.isUndefined(list)) {
-      // deleting the vm from the set to avoid leaking memory
-      list.delete(vm);
-    } // removing inactive template
+  let def = CtorToDefMap.get(Ctor);
 
+  if (shared.isUndefined(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.
 
-    const tpl = vm.cmpTemplate;
+      CtorToDefMap.set(Ctor, def);
+      return def;
+    }
 
-    if (tpl) {
-      list = activeTemplates.get(tpl);
+    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.`);
+    }
 
-      if (!shared.isUndefined(list)) {
-        // deleting the vm from the set to avoid leaking memory
-        list.delete(vm);
-      } // removing active styles associated to template
+    def = createComponentDef(Ctor);
+    CtorToDefMap.set(Ctor, def);
+  }
 
+  return def;
+}
+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.
+ */
 
-      const styles = tpl.stylesheets;
+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.
 
-      if (!shared.isUndefined(styles)) {
-        flattenStylesheets(styles).forEach(style => {
-          list = activeStyles.get(style);
+  const {
+    ctor,
+    name,
+    props,
+    propsConfig,
+    methods
+  } = def;
+  const publicProps = {};
 
-          if (!shared.isUndefined(list)) {
-            // deleting the vm from the set to avoid leaking memory
-            list.delete(vm);
-          }
-        });
-      }
-    }
-  }
-}
-function swapTemplate(oldTpl, newTpl) {
-  if (process.env.NODE_ENV !== 'production') {
-    if (isTemplateRegistered(oldTpl) && isTemplateRegistered(newTpl)) {
-      swappedTemplateMap.set(oldTpl, newTpl);
-      return rehydrateHotTemplate(oldTpl);
-    } else {
-      throw new TypeError(`Invalid Template`);
-    }
+  for (const key in props) {
+    // avoid leaking the reference to the public props descriptors
+    publicProps[key] = {
+      config: propsConfig[key] || 0,
+      type: "any"
+      /* any */
+      ,
+      attr: shared.htmlPropertyToAttribute(key)
+    };
   }
 
-  if (!features.runtimeFlags.ENABLE_HMR) {
-    throw new Error('HMR is not enabled');
+  const publicMethods = {};
+
+  for (const key in methods) {
+    // avoid leaking the reference to the public method descriptors
+    publicMethods[key] = methods[key].value;
   }
 
-  return false;
+  return {
+    ctor,
+    name,
+    props: publicProps,
+    methods: publicMethods
+  };
 }
-function swapComponent(oldComponent, newComponent) {
-  if (process.env.NODE_ENV !== 'production') {
-    if (isComponentConstructor(oldComponent) && isComponentConstructor(newComponent)) {
-      swappedComponentMap.set(oldComponent, newComponent);
-      return rehydrateHotComponent(oldComponent);
-    } else {
-      throw new TypeError(`Invalid Component`);
-    }
-  }
 
-  if (!features.runtimeFlags.ENABLE_HMR) {
-    throw new Error('HMR is not enabled');
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const xmlNS = 'http://www.w3.org/XML/1998/namespace';
+const ColonCharCode = 58;
+function patchAttributes(oldVnode, vnode) {
+  const {
+    attrs
+  } = vnode.data;
+
+  if (shared.isUndefined(attrs)) {
+    return;
   }
 
-  return false;
-}
-function swapStyle(oldStyle, newStyle) {
-  if (process.env.NODE_ENV !== 'production') {
-    // TODO [#1887]: once the support for registering styles is implemented
-    // we can add the validation of both styles around this block.
-    swappedStyleMap.set(oldStyle, newStyle);
-    return rehydrateHotStyle(oldStyle);
+  const oldAttrs = shared.isNull(oldVnode) ? EmptyObject : oldVnode.data.attrs;
+
+  if (oldAttrs === attrs) {
+    return;
   }
 
-  if (!features.runtimeFlags.ENABLE_HMR) {
-    throw new Error('HMR is not enabled');
-  }
+  const {
+    elm
+  } = vnode;
+
+  for (const key in attrs) {
+    const cur = attrs[key];
+    const old = oldAttrs[key];
+
+    if (old !== cur) {
+      unlockAttribute(elm, key);
 
-  return false;
+      if (shared.StringCharCodeAt.call(key, 3) === ColonCharCode) {
+        // Assume xml namespace
+        setAttribute(elm, key, cur, xmlNS);
+      } else if (shared.StringCharCodeAt.call(key, 5) === ColonCharCode) {
+        // Assume xlink namespace
+        setAttribute(elm, key, cur, xlinkNS);
+      } else if (shared.isNull(cur) || shared.isUndefined(cur)) {
+        removeAttribute(elm, key);
+      } else {
+        setAttribute(elm, key, cur);
+      }
+
+      lockAttribute();
+    }
+  }
 }
 
 /*
@@ -3854,262 +3788,231 @@ function swapStyle(oldStyle, newStyle) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-const CtorToDefMap = new WeakMap();
 
-function getCtorProto(Ctor) {
-  let proto = shared.getPrototypeOf(Ctor);
+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');
+}
 
-  if (shared.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
+function patchProps(oldVnode, vnode) {
+  const {
+    props
+  } = vnode.data;
 
+  if (shared.isUndefined(props)) {
+    return;
+  }
 
-  if (isCircularModuleDependency(proto)) {
-    const p = resolveCircularModuleDependency(proto);
+  const oldProps = shared.isNull(oldVnode) ? EmptyObject : oldVnode.data.props;
 
-    if (process.env.NODE_ENV !== 'production') {
-      if (shared.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.
+  if (oldProps === props) {
+    return;
+  }
 
+  const isFirstPatch = shared.isNull(oldVnode);
+  const {
+    elm,
+    sel
+  } = vnode;
 
-    proto = p === proto ? LightningElement : p;
-  }
+  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.
 
-  return proto;
+    if (isFirstPatch || cur !== (isLiveBindingProp(sel, key) ? getProperty(elm, key) : oldProps[key])) {
+      setProperty(elm, key, cur);
+    }
+  }
 }
 
-function createComponentDef(Ctor) {
-  const {
-    shadowSupportMode: ctorShadowSupportMode,
-    renderMode: ctorRenderMode
-  } = Ctor;
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const classNameToClassMap = shared.create(null);
 
-  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 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
 
-    shared.assert.isTrue(Ctor.constructor, `Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
 
-    if (!shared.isUndefined(ctorShadowSupportMode)) {
-      shared.assert.invariant(ctorShadowSupportMode === "any"
-      /* Any */
-      || ctorShadowSupportMode === "reset"
-      /* Default */
-      , `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
-    }
+  className = shared.isString(className) ? className : className + '';
+  let map = classNameToClassMap[className];
 
-    if (!shared.isUndefined(ctorRenderMode)) {
-      shared.assert.invariant(ctorRenderMode === 'light' || ctorRenderMode === 'shadow', `Invalid value for static property renderMode: '${ctorRenderMode}'. renderMode must be either 'light' or 'shadow'.`);
-    }
+  if (map) {
+    return map;
   }
 
-  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, shared.keys(apiFields), shared.keys(apiMethods));
-  const props = shared.assign(shared.create(null), superDef.props, apiFields);
-  const propsConfig = shared.assign(shared.create(null), superDef.propsConfig, apiFieldsConfig);
-  const methods = shared.assign(shared.create(null), superDef.methods, apiMethods);
-  const wire = shared.assign(shared.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 (!shared.isUndefined(ctorShadowSupportMode)) {
-    shadowSupportMode = ctorShadowSupportMode;
-  }
+  map = shared.create(null);
+  let start = 0;
+  let o;
+  const len = className.length;
 
-  let renderMode = superDef.renderMode;
+  for (o = 0; o < len; o++) {
+    if (shared.StringCharCodeAt.call(className, o) === SPACE_CHAR) {
+      if (o > start) {
+        map[shared.StringSlice.call(className, start, o)] = true;
+      }
 
-  if (!shared.isUndefined(ctorRenderMode)) {
-    renderMode = ctorRenderMode === 'light' ? 0
-    /* Light */
-    : 1
-    /* Shadow */
-    ;
+      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[shared.StringSlice.call(className, start, o)] = true;
+  }
 
-  shared.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') {
-    shared.freeze(Ctor.prototype);
+    // just to make sure that this object never changes as part of the diffing algo
+    shared.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 patchClassAttribute(oldVnode, vnode) {
+  const {
+    elm,
+    data: {
+      className: newClass
+    }
+  } = vnode;
+  const oldClass = shared.isNull(oldVnode) ? undefined : oldVnode.data.className;
 
-function isComponentConstructor(ctor) {
-  if (!shared.isFunction(ctor)) {
-    return false;
-  } // Fast path: LightningElement is part of the prototype chain of the constructor.
+  if (oldClass === newClass) {
+    return;
+  }
 
+  const classList = getClassList(elm);
+  const newClassMap = getMapFromClassName(newClass);
+  const oldClassMap = getMapFromClassName(oldClass);
+  let name;
 
-  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.
+  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 (shared.isUndefined(newClassMap[name])) {
+      classList.remove(name);
+    }
+  }
 
+  for (name in newClassMap) {
+    if (shared.isUndefined(oldClassMap[name])) {
+      classList.add(name);
+    }
+  }
+}
 
-  let current = ctor;
+/*
+ * 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
+ */
 
-  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.
+function patchStyleAttribute(oldVnode, vnode) {
+  const {
+    elm,
+    data: {
+      style: newStyle
+    }
+  } = vnode;
+  const oldStyle = shared.isNull(oldVnode) ? undefined : oldVnode.data.style;
 
-      if (circularResolved === current) {
-        return true;
-      }
+  if (oldStyle === newStyle) {
+    return;
+  }
 
-      current = circularResolved;
-    }
+  if (!shared.isString(newStyle) || newStyle === '') {
+    removeAttribute(elm, 'style');
+  } else {
+    setAttribute(elm, 'style', newStyle);
+  }
+}
 
-    if (current === LightningElement) {
-      return true;
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+function applyEventListeners(vnode) {
+  const {
+    elm,
+    data: {
+      on
     }
-  } while (!shared.isNull(current) && (current = shared.getPrototypeOf(current))); // Finally return false if the LightningElement is not part of the prototype chain.
-
+  } = vnode;
 
-  return false;
-}
-function getComponentInternalDef(Ctor) {
-  if (process.env.NODE_ENV !== 'production') {
-    Ctor = getComponentOrSwappedComponent(Ctor);
+  if (shared.isUndefined(on)) {
+    return;
   }
 
-  let def = CtorToDefMap.get(Ctor);
-
-  if (shared.isUndefined(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(elm, name, handler);
+  }
+}
 
-      CtorToDefMap.set(Ctor, def);
-      return def;
-    }
+/*
+ * 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.
 
-    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 (shared.isUndefined(classMap)) {
+    return;
   }
 
-  return def;
+  const classList = getClassList(elm);
+
+  for (const name in classMap) {
+    classList.add(name);
+  }
 }
-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.
- */
 
-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.
+/*
+ * 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 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: shared.htmlPropertyToAttribute(key)
-    };
+  if (shared.isUndefined(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(elm, prop, value, important);
   }
-
-  return {
-    ctor,
-    name,
-    props: publicProps,
-    methods: publicMethods
-  };
 }
 
 /*
@@ -4180,27 +4083,23 @@ function removeNodeHook(vnode, parentNode) {
     lockDomMutation();
   }
 }
-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 (shared.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) {
   const {
@@ -4250,25 +4149,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);
   }
 }
 function allocateChildrenHook(vnode, vm) {
@@ -4340,18 +4225,6 @@ function createViewModelHook(elm, vnode) {
     shared.assert.isTrue(shared.isArray(vnode.children), `Invalid vnode for a custom element, it must have children defined.`);
   }
 }
-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,
@@ -4531,15 +4404,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
@@ -4556,14 +4420,76 @@ function removeElmHook(vnode) {
       ch.hook.remove(ch, elm);
     }
   }
+}
+
+function allocateInSlot(vm, children) {
+  const {
+    cmpSlots: oldSlots
+  } = vm;
+  const cmpSlots = vm.cmpSlots = shared.create(null);
+
+  for (let i = 0, len = children.length; i < len; i += 1) {
+    const vnode = children[i];
+
+    if (shared.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 (!shared.isUndefined(vnode.key)) {
+      vnode.key = `@${slotName}:${vnode.key}`;
+    }
+
+    shared.ArrayPush.call(vnodes, vnode);
+  }
+
+  if (shared.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 = shared.keys(oldSlots);
+
+    if (oldKeys.length !== shared.keys(cmpSlots).length) {
+      markComponentAsDirty(vm);
+      return;
+    }
+
+    for (let i = 0, len = oldKeys.length; i < len; i += 1) {
+      const key = oldKeys[i];
+
+      if (shared.isUndefined(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 :(
 
+
 const FromIteration = new WeakMap(); // dynamic children means it was generated by an iteration
 // in a template, and will require a more complex diffing algo.
 
 function markAsDynamicChildren(children) {
   FromIteration.set(children, 1);
 }
+
 function hasDynamicChildren(children) {
   return FromIteration.has(children);
 }
@@ -4698,11 +4624,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);
@@ -4776,10 +4702,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) {
@@ -4790,7 +4716,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') {
@@ -6456,7 +6382,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
@@ -6464,8 +6389,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
@@ -6759,70 +6684,8 @@ 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 = shared.create(null);
-
-  for (let i = 0, len = children.length; i < len; i += 1) {
-    const vnode = children[i];
-
-    if (shared.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 (!shared.isUndefined(vnode.key)) {
-      vnode.key = `@${slotName}:${vnode.key}`;
-    }
-
-    shared.ArrayPush.call(vnodes, vnode);
-  }
-
-  if (shared.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 = shared.keys(oldSlots);
-
-    if (oldKeys.length !== shared.keys(cmpSlots).length) {
-      markComponentAsDirty(vm);
-      return;
-    }
-
-    for (let i = 0, len = oldKeys.length; i < len; i += 1) {
-      const key = oldKeys[i];
-
-      if (shared.isUndefined(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) {
   let error;
   pre();
@@ -7332,4 +7195,4 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/* version: 2.7.2 */
+/* version: 2.7.3 */