lwc 2.6.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.6.2 */
+/** version: 2.7.3 */
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -397,7 +397,6 @@ const features = {
   ENABLE_NODE_LIST_PATCH: null,
   ENABLE_HTML_COLLECTIONS_PATCH: null,
   ENABLE_NODE_PATCH: null,
-  ENABLE_MIXED_SHADOW_MODE: null,
   ENABLE_WIRE_SYNC_EMIT: null
 };
 
@@ -462,7 +461,7 @@ function setFeatureFlagForTest(name, value) {
     setFeatureFlag(name, value);
   }
 }
-/** version: 2.6.2 */
+/** version: 2.7.3 */
 
 /* proxy-compat-disable */
 
@@ -536,6 +535,249 @@ function parseStyleText(cssText) {
   }
 
   return styleMap;
+} //
+// Primitives
+//
+
+
+let ssr$1;
+
+function setSsr(ssrImpl) {
+  ssr$1 = ssrImpl;
+}
+
+let isNativeShadowDefined$1;
+
+function setIsNativeShadowDefined(isNativeShadowDefinedImpl) {
+  isNativeShadowDefined$1 = isNativeShadowDefinedImpl;
+}
+
+let isSyntheticShadowDefined$1;
+
+function setIsSyntheticShadowDefined(isSyntheticShadowDefinedImpl) {
+  isSyntheticShadowDefined$1 = isSyntheticShadowDefinedImpl;
+}
+
+let HTMLElementExported$1;
+
+function setHTMLElement(HTMLElementImpl) {
+  HTMLElementExported$1 = HTMLElementImpl;
+}
+
+let isHydrating$1;
+
+function setIsHydrating(isHydratingImpl) {
+  isHydrating$1 = isHydratingImpl;
+}
+
+let insert$1;
+
+function setInsert(insertImpl) {
+  insert$1 = insertImpl;
+}
+
+let remove$1;
+
+function setRemove(removeImpl) {
+  remove$1 = removeImpl;
+}
+
+let createElement$1;
+
+function setCreateElement(createElementImpl) {
+  createElement$1 = createElementImpl;
+}
+
+let createText$1;
+
+function setCreateText(createTextImpl) {
+  createText$1 = createTextImpl;
+}
+
+let createComment$1;
+
+function setCreateComment(createCommentImpl) {
+  createComment$1 = createCommentImpl;
+}
+
+let nextSibling$1;
+
+function setNextSibling(nextSiblingImpl) {
+  nextSibling$1 = nextSiblingImpl;
+}
+
+let attachShadow$1;
+
+function setAttachShadow(attachShadowImpl) {
+  attachShadow$1 = attachShadowImpl;
+}
+
+let getProperty$1;
+
+function setGetProperty(getPropertyImpl) {
+  getProperty$1 = getPropertyImpl;
+}
+
+let setProperty$1;
+
+function setSetProperty(setPropertyImpl) {
+  setProperty$1 = setPropertyImpl;
+}
+
+let setText$1;
+
+function setSetText(setTextImpl) {
+  setText$1 = setTextImpl;
+}
+
+let getAttribute$1;
+
+function setGetAttribute(getAttributeImpl) {
+  getAttribute$1 = getAttributeImpl;
+}
+
+let setAttribute$1;
+
+function setSetAttribute(setAttributeImpl) {
+  setAttribute$1 = setAttributeImpl;
+}
+
+let removeAttribute$1;
+
+function setRemoveAttribute(removeAttributeImpl) {
+  removeAttribute$1 = removeAttributeImpl;
+}
+
+let addEventListener$1;
+
+function setAddEventListener(addEventListenerImpl) {
+  addEventListener$1 = addEventListenerImpl;
+}
+
+let removeEventListener$1;
+
+function setRemoveEventListener(removeEventListenerImpl) {
+  removeEventListener$1 = removeEventListenerImpl;
+}
+
+let dispatchEvent$1;
+
+function setDispatchEvent(dispatchEventImpl) {
+  dispatchEvent$1 = dispatchEventImpl;
+}
+
+let getClassList$1;
+
+function setGetClassList(getClassListImpl) {
+  getClassList$1 = getClassListImpl;
+}
+
+let setCSSStyleProperty$1;
+
+function setSetCSSStyleProperty(setCSSStylePropertyImpl) {
+  setCSSStyleProperty$1 = setCSSStylePropertyImpl;
+}
+
+let getBoundingClientRect$1;
+
+function setGetBoundingClientRect(getBoundingClientRectImpl) {
+  getBoundingClientRect$1 = getBoundingClientRectImpl;
+}
+
+let querySelector$1;
+
+function setQuerySelector(querySelectorImpl) {
+  querySelector$1 = querySelectorImpl;
+}
+
+let querySelectorAll$1;
+
+function setQuerySelectorAll(querySelectorAllImpl) {
+  querySelectorAll$1 = querySelectorAllImpl;
+}
+
+let getElementsByTagName$1;
+
+function setGetElementsByTagName(getElementsByTagNameImpl) {
+  getElementsByTagName$1 = getElementsByTagNameImpl;
+}
+
+let getElementsByClassName$1;
+
+function setGetElementsByClassName(getElementsByClassNameImpl) {
+  getElementsByClassName$1 = getElementsByClassNameImpl;
+}
+
+let getChildren$1;
+
+function setGetChildren(getChildrenImpl) {
+  getChildren$1 = getChildrenImpl;
+}
+
+let getChildNodes$1;
+
+function setGetChildNodes(getChildNodesImpl) {
+  getChildNodes$1 = getChildNodesImpl;
+}
+
+let getFirstChild$1;
+
+function setGetFirstChild(getFirstChildImpl) {
+  getFirstChild$1 = getFirstChildImpl;
+}
+
+let getFirstElementChild$1;
+
+function setGetFirstElementChild(getFirstElementChildImpl) {
+  getFirstElementChild$1 = getFirstElementChildImpl;
+}
+
+let getLastChild$1;
+
+function setGetLastChild(getLastChildImpl) {
+  getLastChild$1 = getLastChildImpl;
+}
+
+let getLastElementChild$1;
+
+function setGetLastElementChild(getLastElementChildImpl) {
+  getLastElementChild$1 = getLastElementChildImpl;
+}
+
+let isConnected$1;
+
+function setIsConnected(isConnectedImpl) {
+  isConnected$1 = isConnectedImpl;
+}
+
+let insertGlobalStylesheet$1;
+
+function setInsertGlobalStylesheet(insertGlobalStylesheetImpl) {
+  insertGlobalStylesheet$1 = insertGlobalStylesheetImpl;
+}
+
+let insertStylesheet$1;
+
+function setInsertStylesheet(insertStylesheetImpl) {
+  insertStylesheet$1 = insertStylesheetImpl;
+}
+
+let assertInstanceOfHTMLElement$1;
+
+function setAssertInstanceOfHTMLElement(assertInstanceOfHTMLElementImpl) {
+  assertInstanceOfHTMLElement$1 = assertInstanceOfHTMLElementImpl;
+}
+
+let defineCustomElement$1;
+
+function setDefineCustomElement(defineCustomElementImpl) {
+  defineCustomElement$1 = defineCustomElementImpl;
+}
+
+let getCustomElement$1;
+
+function setGetCustomElement(getCustomElementImpl) {
+  getCustomElement$1 = getCustomElementImpl;
 }
 /*
  * Copyright (c) 2019, salesforce.com, inc.
@@ -665,612 +907,86 @@ class ReactiveObserver {
  */
 
 
-function componentValueMutated(vm, key) {
-  valueMutated(vm.component, key);
-}
-
-function componentValueObserved(vm, key) {
-  valueObserved(vm.component, key);
-}
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-
-function getComponentTag(vm) {
-  return `<${StringToLowerCase.call(vm.tagName)}>`;
-} // TODO [#1695]: Unify getComponentStack and getErrorComponentStack
-
-
-function getComponentStack(vm) {
-  const stack = [];
-  let prefix = '';
-
-  while (!isNull(vm.owner)) {
-    ArrayPush$1.call(stack, prefix + getComponentTag(vm));
-    vm = vm.owner;
-    prefix += '\t';
-  }
-
-  return ArrayJoin.call(stack, '\n');
-}
-
-function getErrorComponentStack(vm) {
-  const wcStack = [];
-  let currentVm = vm;
-
-  while (!isNull(currentVm)) {
-    ArrayPush$1.call(wcStack, getComponentTag(currentVm));
-    currentVm = currentVm.owner;
-  }
-
-  return wcStack.reverse().join('\n\t');
-}
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-
-function log(method, message, vm) {
-  let msg = `[LWC ${method}]: ${message}`;
-
-  if (!isUndefined$1(vm)) {
-    msg = `${msg}\n${getComponentStack(vm)}`;
-  }
-
-  if (process.env.NODE_ENV === 'test') {
-    /* eslint-disable-next-line no-console */
-    console[method](msg);
-    return;
-  }
-
-  try {
-    throw new Error(msg);
-  } catch (e) {
-    /* eslint-disable-next-line no-console */
-    console[method](e);
-  }
-}
-
-function logError(message, vm) {
-  log('error', message, vm);
-}
-
-function logWarn(message, vm) {
-  log('warn', message, vm);
-}
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-
-function handleEvent(event, vnode) {
-  const {
-    type
-  } = event;
-  const {
-    data: {
-      on
-    }
-  } = vnode;
-  const handler = on && on[type]; // call event handler if exists
-
-  if (handler) {
-    handler.call(undefined, event);
-  }
-}
-
-function createListener() {
-  return function handler(event) {
-    handleEvent(event, handler.vnode);
-  };
-}
-
-function updateAllEventListeners(oldVnode, vnode) {
-  if (isUndefined$1(oldVnode.listener)) {
-    createAllEventListeners(vnode);
-  } else {
-    vnode.listener = oldVnode.listener;
-    vnode.listener.vnode = vnode;
-  }
-}
-
-function createAllEventListeners(vnode) {
-  const {
-    elm,
-    data: {
-      on
-    },
-    owner: {
-      renderer
-    }
-  } = vnode;
-
-  if (isUndefined$1(on)) {
-    return;
-  }
-
-  const listener = vnode.listener = createListener();
-  listener.vnode = vnode;
-  let name;
-
-  for (name in on) {
-    renderer.addEventListener(elm, name, listener);
-  }
-}
-
-var modEvents = {
-  update: updateAllEventListeners,
-  create: createAllEventListeners
-};
-/*
- * 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 defaultDefHTMLPropertyNames = ['accessKey', 'dir', 'draggable', 'hidden', 'id', 'lang', 'spellcheck', 'tabIndex', 'title'];
-
-function offsetPropertyErrorMessage(name) {
-  return `Using the \`${name}\` property is an anti-pattern because it rounds the value to an integer. Instead, use the \`getBoundingClientRect\` method to obtain fractional values for the size of an element and its position relative to the viewport.`;
-} // Global HTML Attributes & Properties
-// https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
-// https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement
-
-
-const globalHTMLProperties = assign(create(null), {
-  accessKey: {
-    attribute: 'accesskey'
-  },
-  accessKeyLabel: {
-    readOnly: true
-  },
-  className: {
-    attribute: 'class',
-    error: 'Using the `className` property is an anti-pattern because of slow runtime behavior and potential conflicts with classes provided by the owner element. Use the `classList` API instead.'
-  },
-  contentEditable: {
-    attribute: 'contenteditable'
-  },
-  dataset: {
-    readOnly: true,
-    error: "Using the `dataset` property is an anti-pattern because it can't be statically analyzed. Expose each property individually using the `@api` decorator instead."
-  },
-  dir: {
-    attribute: 'dir'
-  },
-  draggable: {
-    attribute: 'draggable'
-  },
-  dropzone: {
-    attribute: 'dropzone',
-    readOnly: true
-  },
-  hidden: {
-    attribute: 'hidden'
-  },
-  id: {
-    attribute: 'id'
-  },
-  inputMode: {
-    attribute: 'inputmode'
-  },
-  lang: {
-    attribute: 'lang'
-  },
-  slot: {
-    attribute: 'slot',
-    error: 'Using the `slot` property is an anti-pattern.'
-  },
-  spellcheck: {
-    attribute: 'spellcheck'
-  },
-  style: {
-    attribute: 'style'
-  },
-  tabIndex: {
-    attribute: 'tabindex'
-  },
-  title: {
-    attribute: 'title'
-  },
-  translate: {
-    attribute: 'translate'
-  },
-  // additional "global attributes" that are not present in the link above.
-  isContentEditable: {
-    readOnly: true
-  },
-  offsetHeight: {
-    readOnly: true,
-    error: offsetPropertyErrorMessage('offsetHeight')
-  },
-  offsetLeft: {
-    readOnly: true,
-    error: offsetPropertyErrorMessage('offsetLeft')
-  },
-  offsetParent: {
-    readOnly: true
-  },
-  offsetTop: {
-    readOnly: true,
-    error: offsetPropertyErrorMessage('offsetTop')
-  },
-  offsetWidth: {
-    readOnly: true,
-    error: offsetPropertyErrorMessage('offsetWidth')
-  },
-  role: {
-    attribute: 'role'
-  }
-});
-let controlledElement = null;
-let controlledAttributeName;
-
-function isAttributeLocked(elm, attrName) {
-  return elm !== controlledElement || attrName !== controlledAttributeName;
-}
-
-function lockAttribute(_elm, _key) {
-  controlledElement = null;
-  controlledAttributeName = undefined;
-}
-
-function unlockAttribute(elm, key) {
-  controlledElement = elm;
-  controlledAttributeName = key;
-}
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-
-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
-    },
-    owner: {
-      renderer
-    }
-  } = vnode;
-
-  if (isUndefined$1(attrs)) {
-    return;
-  }
-
-  let {
-    data: {
-      attrs: oldAttrs
-    }
-  } = oldVnode;
-
-  if (oldAttrs === attrs) {
-    return;
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    assert.invariant(isUndefined$1(oldAttrs) || keys(oldAttrs).join(',') === keys(attrs).join(','), `vnode.data.attrs cannot change shape.`);
-  }
-
-  const elm = vnode.elm;
-  const {
-    setAttribute,
-    removeAttribute
-  } = renderer;
-  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)
-
-  for (key in attrs) {
-    const cur = attrs[key];
-    const old = oldAttrs[key];
-
-    if (old !== cur) {
-      unlockAttribute(elm, key);
-
-      if (StringCharCodeAt.call(key, 3) === ColonCharCode) {
-        // Assume xml namespace
-        setAttribute(elm, key, cur, xmlNS);
-      } else if (StringCharCodeAt.call(key, 5) === ColonCharCode) {
-        // Assume xlink namespace
-        setAttribute(elm, key, cur, xlinkNS);
-      } else if (isNull(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 (isUndefined$1(props)) {
-    return;
-  }
-
-  const oldProps = oldVnode.data.props;
-
-  if (oldProps === props) {
-    return;
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    assert.invariant(isUndefined$1(oldProps) || keys(oldProps).join(',') === keys(props).join(','), 'vnode.data.props cannot change shape.');
-  }
-
-  const isFirstPatch = isUndefined$1(oldProps);
-  const {
-    elm,
-    sel,
-    owner: {
-      renderer
-    }
-  } = 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) ? renderer.getProperty(elm, key) : oldProps[key])) {
-      renderer.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 = 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 = isString(className) ? className : className + '';
-  let map = classNameToClassMap[className];
-
-  if (map) {
-    return map;
-  }
-
-  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;
-      }
-
-      start = o + 1;
-    }
-  }
-
-  if (o > start) {
-    map[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
-    freeze(map);
-  }
-
-  return map;
-}
-
-function updateClassAttribute(oldVnode, vnode) {
-  const {
-    elm,
-    data: {
-      className: newClass
-    },
-    owner: {
-      renderer
-    }
-  } = vnode;
-  const {
-    data: {
-      className: oldClass
-    }
-  } = oldVnode;
-
-  if (oldClass === newClass) {
-    return;
-  }
-
-  const classList = renderer.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 (isUndefined$1(newClassMap[name])) {
-      classList.remove(name);
-    }
-  }
-
-  for (name in newClassMap) {
-    if (isUndefined$1(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
-    },
-    owner: {
-      renderer
-    }
-  } = vnode;
-  const {
-    setAttribute,
-    removeAttribute
-  } = renderer;
-
-  if (oldVnode.data.style === newStyle) {
-    return;
-  }
-
-  if (!isString(newStyle) || newStyle === '') {
-    removeAttribute(elm, 'style');
-  } else {
-    setAttribute(elm, 'style', newStyle);
-  }
+function componentValueMutated(vm, key) {
+  valueMutated(vm.component, key);
 }
 
-const emptyVNode = {
-  data: {}
-};
-var modComputedStyle = {
-  create: vnode => updateStyleAttribute(emptyVNode, vnode),
-  update: updateStyleAttribute
-};
+function componentValueObserved(vm, key) {
+  valueObserved(vm.component, key);
+}
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-// 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
-    },
-    owner: {
-      renderer
-    }
-  } = vnode;
 
-  if (isUndefined$1(classMap)) {
-    return;
-  }
+function getComponentTag(vm) {
+  return `<${StringToLowerCase.call(vm.tagName)}>`;
+} // TODO [#1695]: Unify getComponentStack and getErrorComponentStack
 
-  const classList = renderer.getClassList(elm);
 
-  for (const name in classMap) {
-    classList.add(name);
+function getComponentStack(vm) {
+  const stack = [];
+  let prefix = '';
+
+  while (!isNull(vm.owner)) {
+    ArrayPush$1.call(stack, prefix + getComponentTag(vm));
+    vm = vm.owner;
+    prefix += '\t';
   }
+
+  return ArrayJoin.call(stack, '\n');
 }
 
-var modStaticClassName = {
-  create: createClassAttribute
-};
+function getErrorComponentStack(vm) {
+  const wcStack = [];
+  let currentVm = vm;
+
+  while (!isNull(currentVm)) {
+    ArrayPush$1.call(wcStack, getComponentTag(currentVm));
+    currentVm = currentVm.owner;
+  }
+
+  return wcStack.reverse().join('\n\t');
+}
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-// 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
-    },
-    owner: {
-      renderer
-    }
-  } = vnode;
 
-  if (isUndefined$1(styleDecls)) {
+function log(method, message, vm) {
+  let msg = `[LWC ${method}]: ${message}`;
+
+  if (!isUndefined$1(vm)) {
+    msg = `${msg}\n${getComponentStack(vm)}`;
+  }
+
+  if (process.env.NODE_ENV === 'test') {
+    /* eslint-disable-next-line no-console */
+    console[method](msg);
     return;
   }
 
-  for (let i = 0; i < styleDecls.length; i++) {
-    const [prop, value, important] = styleDecls[i];
-    renderer.setCSSStyleProperty(elm, prop, value, important);
+  try {
+    throw new Error(msg);
+  } catch (e) {
+    /* eslint-disable-next-line no-console */
+    console[method](e);
   }
 }
 
-var modStaticStyle = {
-  create: createStyleAttribute
-};
+function logError(message, vm) {
+  log('error', message, vm);
+}
+
+function logWarn(message, vm) {
+  log('warn', message, vm);
+}
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -1278,14 +994,6 @@ var modStaticStyle = {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 
-/**
-@license
-Copyright (c) 2015 Simon Friis Vindum.
-This code may only be used under the MIT License found at
-https://github.com/snabbdom/snabbdom/blob/master/LICENSE
-Code distributed by Snabbdom as part of the Snabbdom project at
-https://github.com/snabbdom/snabbdom/
-*/
 
 function isUndef(s) {
   return s === undefined;
@@ -1374,7 +1082,7 @@ function updateDynamicChildren(parentElm, oldCh, newCh) {
     } else if (sameVnode(oldStartVnode, newEndVnode)) {
       // Vnode moved right
       patchVnode(oldStartVnode, newEndVnode);
-      newEndVnode.hook.move(oldStartVnode, parentElm, oldEndVnode.owner.renderer.nextSibling(oldEndVnode.elm));
+      newEndVnode.hook.move(oldStartVnode, parentElm, nextSibling$1(oldEndVnode.elm));
       oldStartVnode = oldCh[++oldStartIdx];
       newEndVnode = newCh[--newEndIdx];
     } else if (sameVnode(oldEndVnode, newStartVnode)) {
@@ -1494,6 +1202,125 @@ function patchVnode(oldVnode, vnode) {
  */
 
 
+const defaultDefHTMLPropertyNames = ['accessKey', 'dir', 'draggable', 'hidden', 'id', 'lang', 'spellcheck', 'tabIndex', 'title'];
+
+function offsetPropertyErrorMessage(name) {
+  return `Using the \`${name}\` property is an anti-pattern because it rounds the value to an integer. Instead, use the \`getBoundingClientRect\` method to obtain fractional values for the size of an element and its position relative to the viewport.`;
+} // Global HTML Attributes & Properties
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
+// https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement
+
+
+const globalHTMLProperties = assign(create(null), {
+  accessKey: {
+    attribute: 'accesskey'
+  },
+  accessKeyLabel: {
+    readOnly: true
+  },
+  className: {
+    attribute: 'class',
+    error: 'Using the `className` property is an anti-pattern because of slow runtime behavior and potential conflicts with classes provided by the owner element. Use the `classList` API instead.'
+  },
+  contentEditable: {
+    attribute: 'contenteditable'
+  },
+  dataset: {
+    readOnly: true,
+    error: "Using the `dataset` property is an anti-pattern because it can't be statically analyzed. Expose each property individually using the `@api` decorator instead."
+  },
+  dir: {
+    attribute: 'dir'
+  },
+  draggable: {
+    attribute: 'draggable'
+  },
+  dropzone: {
+    attribute: 'dropzone',
+    readOnly: true
+  },
+  hidden: {
+    attribute: 'hidden'
+  },
+  id: {
+    attribute: 'id'
+  },
+  inputMode: {
+    attribute: 'inputmode'
+  },
+  lang: {
+    attribute: 'lang'
+  },
+  slot: {
+    attribute: 'slot',
+    error: 'Using the `slot` property is an anti-pattern.'
+  },
+  spellcheck: {
+    attribute: 'spellcheck'
+  },
+  style: {
+    attribute: 'style'
+  },
+  tabIndex: {
+    attribute: 'tabindex'
+  },
+  title: {
+    attribute: 'title'
+  },
+  translate: {
+    attribute: 'translate'
+  },
+  // additional "global attributes" that are not present in the link above.
+  isContentEditable: {
+    readOnly: true
+  },
+  offsetHeight: {
+    readOnly: true,
+    error: offsetPropertyErrorMessage('offsetHeight')
+  },
+  offsetLeft: {
+    readOnly: true,
+    error: offsetPropertyErrorMessage('offsetLeft')
+  },
+  offsetParent: {
+    readOnly: true
+  },
+  offsetTop: {
+    readOnly: true,
+    error: offsetPropertyErrorMessage('offsetTop')
+  },
+  offsetWidth: {
+    readOnly: true,
+    error: offsetPropertyErrorMessage('offsetWidth')
+  },
+  role: {
+    attribute: 'role'
+  }
+});
+let controlledElement = null;
+let controlledAttributeName;
+
+function isAttributeLocked(elm, attrName) {
+  return elm !== controlledElement || attrName !== controlledAttributeName;
+}
+
+function lockAttribute(_elm, _key) {
+  controlledElement = null;
+  controlledAttributeName = undefined;
+}
+
+function unlockAttribute(elm, key) {
+  controlledElement = elm;
+  controlledAttributeName = key;
+}
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+
+
 function generateDataDescriptor(options) {
   return assign({
     configurable: true,
@@ -1856,7 +1683,7 @@ function patchLightningElementPrototypeWithRestrictions(proto) {
   defineProperties(proto, getLightningElementPrototypeRestrictionsDescriptors(proto));
 }
 /*
- * 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
@@ -2776,9 +2603,7 @@ function createBridgeToElementDescriptor(propName, descriptor) {
 
 
 const LightningElement = function () {
-  var _a; // This should be as performant as possible, while any initialization should be done lazily
-
-
+  // This should be as performant as possible, while any initialization should be done lazily
   if (isNull(vmBeingConstructed)) {
     throw new ReferenceError('Illegal constructor');
   }
@@ -2786,15 +2611,14 @@ const LightningElement = function () {
   const vm = vmBeingConstructed;
   const {
     def,
-    elm,
-    renderer
+    elm
   } = vm;
   const {
     bridge
   } = def;
 
   if (process.env.NODE_ENV !== 'production') {
-    (_a = renderer.assertInstanceOfHTMLElement) === null || _a === void 0 ? void 0 : _a.call(renderer, vm.elm, `Component creation requires a DOM element to be associated to ${vm}.`);
+    assertInstanceOfHTMLElement$1(vm.elm, `Component creation requires a DOM element to be associated to ${vm}.`);
   }
 
   const component = this;
@@ -2824,7 +2648,7 @@ const LightningElement = function () {
   if (vm.renderMode === 1
   /* Shadow */
   ) {
-    attachShadow(vm);
+    doAttachShadow(vm);
   } // Adding extra guard rails in DEV mode.
 
 
@@ -2836,17 +2660,16 @@ const LightningElement = function () {
   return this;
 };
 
-function attachShadow(vm) {
+function doAttachShadow(vm) {
   const {
     elm,
     mode,
-    renderer,
     shadowMode,
     def: {
       ctor
     }
   } = vm;
-  const cmpRoot = renderer.attachShadow(elm, {
+  const cmpRoot = attachShadow$1(elm, {
     [KEY__SYNTHETIC_MODE]: shadowMode === 1
     /* Synthetic */
     ,
@@ -2873,21 +2696,15 @@ LightningElement.prototype = {
 
   dispatchEvent(event) {
     const {
-      elm,
-      renderer: {
-        dispatchEvent
-      }
+      elm
     } = getAssociatedVM(this);
-    return dispatchEvent(elm, event);
+    return dispatchEvent$1(elm, event);
   },
 
   addEventListener(type, listener, options) {
     const vm = getAssociatedVM(this);
     const {
-      elm,
-      renderer: {
-        addEventListener
-      }
+      elm
     } = vm;
 
     if (process.env.NODE_ENV !== 'production') {
@@ -2898,92 +2715,68 @@ LightningElement.prototype = {
     }
 
     const wrappedListener = getWrappedComponentsListener(vm, listener);
-    addEventListener(elm, type, wrappedListener, options);
+    addEventListener$1(elm, type, wrappedListener, options);
   },
 
   removeEventListener(type, listener, options) {
     const vm = getAssociatedVM(this);
     const {
-      elm,
-      renderer: {
-        removeEventListener
-      }
+      elm
     } = vm;
     const wrappedListener = getWrappedComponentsListener(vm, listener);
-    removeEventListener(elm, type, wrappedListener, options);
+    removeEventListener$1(elm, type, wrappedListener, options);
   },
 
   hasAttribute(name) {
     const {
-      elm,
-      renderer: {
-        getAttribute
-      }
+      elm
     } = getAssociatedVM(this);
-    return !isNull(getAttribute(elm, name));
+    return !isNull(getAttribute$1(elm, name));
   },
 
   hasAttributeNS(namespace, name) {
     const {
-      elm,
-      renderer: {
-        getAttribute
-      }
+      elm
     } = getAssociatedVM(this);
-    return !isNull(getAttribute(elm, name, namespace));
+    return !isNull(getAttribute$1(elm, name, namespace));
   },
 
   removeAttribute(name) {
     const {
-      elm,
-      renderer: {
-        removeAttribute
-      }
+      elm
     } = getAssociatedVM(this);
     unlockAttribute(elm, name);
-    removeAttribute(elm, name);
+    removeAttribute$1(elm, name);
     lockAttribute();
   },
 
   removeAttributeNS(namespace, name) {
     const {
-      elm,
-      renderer: {
-        removeAttribute
-      }
+      elm
     } = getAssociatedVM(this);
     unlockAttribute(elm, name);
-    removeAttribute(elm, name, namespace);
+    removeAttribute$1(elm, name, namespace);
     lockAttribute();
   },
 
   getAttribute(name) {
     const {
-      elm,
-      renderer: {
-        getAttribute
-      }
+      elm
     } = getAssociatedVM(this);
-    return getAttribute(elm, name);
+    return getAttribute$1(elm, name);
   },
 
   getAttributeNS(namespace, name) {
     const {
-      elm,
-      renderer: {
-        getAttribute
-      }
+      elm
     } = getAssociatedVM(this);
-    return getAttribute(elm, name, namespace);
+    return getAttribute$1(elm, name, namespace);
   },
 
   setAttribute(name, value) {
     const vm = getAssociatedVM(this);
     const {
-      elm,
-      renderer: {
-        setAttribute
-      }
+      elm
     } = vm;
 
     if (process.env.NODE_ENV !== 'production') {
@@ -2991,17 +2784,14 @@ LightningElement.prototype = {
     }
 
     unlockAttribute(elm, name);
-    setAttribute(elm, name, value);
+    setAttribute$1(elm, name, value);
     lockAttribute();
   },
 
   setAttributeNS(namespace, name, value) {
     const vm = getAssociatedVM(this);
     const {
-      elm,
-      renderer: {
-        setAttribute
-      }
+      elm
     } = vm;
 
     if (process.env.NODE_ENV !== 'production') {
@@ -3009,43 +2799,34 @@ LightningElement.prototype = {
     }
 
     unlockAttribute(elm, name);
-    setAttribute(elm, name, value, namespace);
+    setAttribute$1(elm, name, value, namespace);
     lockAttribute();
   },
 
   getBoundingClientRect() {
     const vm = getAssociatedVM(this);
     const {
-      elm,
-      renderer: {
-        getBoundingClientRect
-      }
+      elm
     } = vm;
 
     if (process.env.NODE_ENV !== 'production') {
       warnIfInvokedDuringConstruction(vm, 'getBoundingClientRect()');
     }
 
-    return getBoundingClientRect(elm);
+    return getBoundingClientRect$1(elm);
   },
 
   get isConnected() {
     const {
-      elm,
-      renderer: {
-        isConnected
-      }
+      elm
     } = getAssociatedVM(this);
-    return isConnected(elm);
+    return isConnected$1(elm);
   },
 
   get classList() {
     const vm = getAssociatedVM(this);
     const {
-      elm,
-      renderer: {
-        getClassList
-      }
+      elm
     } = vm;
 
     if (process.env.NODE_ENV !== 'production') {
@@ -3054,7 +2835,7 @@ LightningElement.prototype = {
       assert.isFalse(isBeingConstructed(vm), `Failed to construct ${vm}: The result must not have attributes. Adding or tampering with classname in constructor is not allowed in a web component, use connectedCallback() instead.`);
     }
 
-    return getClassList(elm);
+    return getClassList$1(elm);
   },
 
   get template() {
@@ -3088,23 +2869,48 @@ LightningElement.prototype = {
   }
 
 };
-const queryAndChildGetterDescriptors = create(null);
-const childGetters = [['children', 'getChildren'], ['childNodes', 'getChildNodes'], ['firstChild', 'getFirstChild'], ['firstElementChild', 'getFirstElementChild'], ['lastChild', 'getLastChild'], ['lastElementChild', 'getLastElementChild']]; // Generic passthrough for child getters on HTMLElement to the relevant Renderer APIs
+const queryAndChildGetterDescriptors = create(null); // The reason we don't just call `import * as renderer from '../renderer'` here is that the bundle size
+// is smaller if we reference each function individually. Otherwise Rollup will create one big frozen
+// object representing the renderer, with a lot of methods we don't actually need.
+
+const childGetters = ['children', 'childNodes', 'firstChild', 'firstElementChild', 'lastChild', 'lastElementChild'];
+
+function getChildGetter(methodName) {
+  switch (methodName) {
+    case 'children':
+      return getChildren$1;
+
+    case 'childNodes':
+      return getChildNodes$1;
+
+    case 'firstChild':
+      return getFirstChild$1;
+
+    case 'firstElementChild':
+      return getFirstElementChild$1;
+
+    case 'lastChild':
+      return getLastChild$1;
+
+    case 'lastElementChild':
+      return getLastElementChild$1;
+  }
+} // Generic passthrough for child getters on HTMLElement to the relevant Renderer APIs
+
 
-for (const [elementProp, rendererMethod] of childGetters) {
-  queryAndChildGetterDescriptors[elementProp] = {
+for (const childGetter of childGetters) {
+  queryAndChildGetterDescriptors[childGetter] = {
     get() {
       const vm = getAssociatedVM(this);
       const {
-        elm,
-        renderer
+        elm
       } = vm;
 
       if (process.env.NODE_ENV !== 'production') {
-        warnIfInvokedDuringConstruction(vm, elementProp);
+        warnIfInvokedDuringConstruction(vm, childGetter);
       }
 
-      return renderer[rendererMethod](elm);
+      return getChildGetter(childGetter)(elm);
     },
 
     configurable: true,
@@ -3112,22 +2918,38 @@ for (const [elementProp, rendererMethod] of childGetters) {
   };
 }
 
-const queryMethods = ['getElementsByClassName', 'getElementsByTagName', 'querySelector', 'querySelectorAll']; // Generic passthrough for query APIs on HTMLElement to the relevant Renderer APIs
+const queryMethods = ['getElementsByClassName', 'getElementsByTagName', 'querySelector', 'querySelectorAll'];
+
+function getQueryMethod(methodName) {
+  switch (methodName) {
+    case 'getElementsByClassName':
+      return getElementsByClassName$1;
+
+    case 'getElementsByTagName':
+      return getElementsByTagName$1;
+
+    case 'querySelector':
+      return querySelector$1;
+
+    case 'querySelectorAll':
+      return querySelectorAll$1;
+  }
+} // Generic passthrough for query APIs on HTMLElement to the relevant Renderer APIs
+
 
 for (const queryMethod of queryMethods) {
   queryAndChildGetterDescriptors[queryMethod] = {
     value(arg) {
       const vm = getAssociatedVM(this);
       const {
-        elm,
-        renderer
+        elm
       } = vm;
 
       if (process.env.NODE_ENV !== 'production') {
         warnIfInvokedDuringConstruction(vm, `${queryMethod}()`);
       }
 
-      return renderer[queryMethod](elm, arg);
+      return getQueryMethod(queryMethod)(elm, arg);
     },
 
     configurable: true,
@@ -4163,10 +3985,6 @@ function createComponentDef(Ctor) {
 
     assert.isTrue(Ctor.constructor, `Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
 
-    if (!runtimeFlags.ENABLE_MIXED_SHADOW_MODE) {
-      assert.isFalse('shadowSupportMode' in Ctor, `${ctorName || 'Anonymous class'} is an invalid LWC component. The shadowSupportMode static property is not available in this environment.`);
-    }
-
     if (!isUndefined$1(ctorShadowSupportMode)) {
       assert.invariant(ctorShadowSupportMode === "any"
       /* Any */
@@ -4272,118 +4090,407 @@ function isComponentConstructor(ctor) {
   // to resolve.
 
 
-  let current = ctor;
+  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.
+
+      if (circularResolved === current) {
+        return true;
+      }
+
+      current = circularResolved;
+    }
+
+    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.
+
+
+  return false;
+}
+
+function getComponentInternalDef(Ctor) {
+  if (process.env.NODE_ENV !== 'production') {
+    Ctor = getComponentOrSwappedComponent(Ctor);
+  }
+
+  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.
+
+      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.`);
+    }
+
+    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.
+ */
+
+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 = {};
+
+  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)
+    };
+  }
+
+  const publicMethods = {};
+
+  for (const key in methods) {
+    // avoid leaking the reference to the public method descriptors
+    publicMethods[key] = methods[key].value;
+  }
+
+  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
+ */
+
+
+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 (isUndefined$1(attrs)) {
+    return;
+  }
+
+  const oldAttrs = isNull(oldVnode) ? EmptyObject : oldVnode.data.attrs;
+
+  if (oldAttrs === attrs) {
+    return;
+  }
+
+  const {
+    elm
+  } = vnode;
+
+  for (const key in attrs) {
+    const cur = attrs[key];
+    const old = oldAttrs[key];
+
+    if (old !== cur) {
+      unlockAttribute(elm, key);
+
+      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();
+    }
+  }
+}
+/*
+ * 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 patchProps(oldVnode, vnode) {
+  const {
+    props
+  } = vnode.data;
+
+  if (isUndefined$1(props)) {
+    return;
+  }
+
+  const oldProps = isNull(oldVnode) ? EmptyObject : oldVnode.data.props;
+
+  if (oldProps === props) {
+    return;
+  }
+
+  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.
+
+    if (isFirstPatch || cur !== (isLiveBindingProp(sel, key) ? getProperty$1(elm, key) : oldProps[key])) {
+      setProperty$1(elm, key, cur);
+    }
+  }
+}
+/*
+ * 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 = 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 = isString(className) ? className : className + '';
+  let map = classNameToClassMap[className];
+
+  if (map) {
+    return map;
+  }
+
+  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;
+      }
+
+      start = o + 1;
+    }
+  }
+
+  if (o > start) {
+    map[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
+    freeze(map);
+  }
+
+  return map;
+}
+
+function patchClassAttribute(oldVnode, vnode) {
+  const {
+    elm,
+    data: {
+      className: newClass
+    }
+  } = vnode;
+  const oldClass = isNull(oldVnode) ? undefined : oldVnode.data.className;
 
-  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.
+  if (oldClass === newClass) {
+    return;
+  }
 
-      if (circularResolved === current) {
-        return true;
-      }
+  const classList = getClassList$1(elm);
+  const newClassMap = getMapFromClassName(newClass);
+  const oldClassMap = getMapFromClassName(oldClass);
+  let name;
 
-      current = circularResolved;
+  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);
     }
+  }
 
-    if (current === LightningElement) {
-      return true;
+  for (name in newClassMap) {
+    if (isUndefined$1(oldClassMap[name])) {
+      classList.add(name);
     }
-  } while (!isNull(current) && (current = getPrototypeOf$1(current))); // Finally return false if the LightningElement is not part of the prototype chain.
+  }
+}
+/*
+ * 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 patchStyleAttribute(oldVnode, vnode) {
+  const {
+    elm,
+    data: {
+      style: newStyle
+    }
+  } = vnode;
+  const oldStyle = isNull(oldVnode) ? undefined : oldVnode.data.style;
 
-function getComponentInternalDef(Ctor) {
-  if (process.env.NODE_ENV !== 'production') {
-    Ctor = getComponentOrSwappedComponent(Ctor);
+  if (oldStyle === newStyle) {
+    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.
+  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
+ */
 
-      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 applyEventListeners(vnode) {
+  const {
+    elm,
+    data: {
+      on
     }
+  } = vnode;
 
-    def = createComponentDef(Ctor);
-    CtorToDefMap.set(Ctor, def);
+  if (isUndefined$1(on)) {
+    return;
   }
 
-  return def;
+  for (const name in on) {
+    const handler = on[name];
+    addEventListener$1(elm, name, handler);
+  }
 }
-
-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.
+/*
+ * 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 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 applyStaticClassAttribute(vnode) {
   const {
-    ctor,
-    name,
-    props,
-    propsConfig,
-    methods
-  } = def;
-  const publicProps = {};
+    elm,
+    data: {
+      classMap
+    }
+  } = 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(classMap)) {
+    return;
   }
 
-  const publicMethods = {};
+  const classList = getClassList$1(elm);
 
-  for (const key in methods) {
-    // avoid leaking the reference to the public method descriptors
-    publicMethods[key] = methods[key].value;
+  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 applyStaticStyleAttribute(vnode) {
+  const {
+    elm,
+    data: {
+      styleDecls
+    }
+  } = vnode;
+
+  if (isUndefined$1(styleDecls)) {
+    return;
   }
 
-  return {
-    ctor,
-    name,
-    props: publicProps,
-    methods: publicMethods
-  };
+  for (let i = 0; i < styleDecls.length; i++) {
+    const [prop, value, important] = styleDecls[i];
+    setCSSStyleProperty$1(elm, prop, value, important);
+  }
 }
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -4410,17 +4517,14 @@ function setScopeTokenClassIfNecessary(elm, owner) {
   const token = cmpTemplate === null || cmpTemplate === void 0 ? void 0 : cmpTemplate.stylesheetToken;
 
   if (!isUndefined$1(token) && context.hasScopedStyles) {
-    owner.renderer.getClassList(elm).add(token);
+    getClassList$1(elm).add(token);
   }
 }
 
 function updateNodeHook(oldVnode, vnode) {
   const {
     elm,
-    text,
-    owner: {
-      renderer
-    }
+    text
   } = vnode;
 
   if (oldVnode.text !== text) {
@@ -4428,7 +4532,7 @@ function updateNodeHook(oldVnode, vnode) {
       unlockDomMutation();
     }
 
-    renderer.setText(elm, text);
+    setText$1(elm, text);
 
     if (process.env.NODE_ENV !== 'production') {
       lockDomMutation();
@@ -4437,15 +4541,11 @@ function updateNodeHook(oldVnode, vnode) {
 }
 
 function insertNodeHook(vnode, parentNode, referenceNode) {
-  const {
-    renderer
-  } = vnode.owner;
-
   if (process.env.NODE_ENV !== 'production') {
     unlockDomMutation();
   }
 
-  renderer.insert(vnode.elm, parentNode, referenceNode);
+  insert$1(vnode.elm, parentNode, referenceNode);
 
   if (process.env.NODE_ENV !== 'production') {
     lockDomMutation();
@@ -4453,43 +4553,35 @@ function insertNodeHook(vnode, parentNode, referenceNode) {
 }
 
 function removeNodeHook(vnode, parentNode) {
-  const {
-    renderer
-  } = vnode.owner;
-
   if (process.env.NODE_ENV !== 'production') {
     unlockDomMutation();
   }
 
-  renderer.remove(vnode.elm, parentNode);
+  remove$1(vnode.elm, parentNode);
 
   if (process.env.NODE_ENV !== 'production') {
     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 (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) {
@@ -4541,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);
   }
 }
 
@@ -4627,8 +4704,7 @@ function createViewModelHook(elm, vnode) {
   createVM(elm, def, {
     mode,
     owner,
-    tagName: sel,
-    renderer: owner.renderer
+    tagName: sel
   });
 
   if (process.env.NODE_ENV !== 'production') {
@@ -4636,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,
@@ -4674,16 +4737,13 @@ function vnodesAndElementHaveCompatibleAttrs(vnode, elm) {
   const {
     data: {
       attrs = {}
-    },
-    owner: {
-      renderer
     }
   } = vnode;
   let nodesAreCompatible = true; // Validate attributes, though we could always recovery from those by running the update mods.
   // Note: intentionally ONLY matching vnodes.attrs to elm.attrs, in case SSR is adding extra attributes.
 
   for (const [attrName, attrValue] of Object.entries(attrs)) {
-    const elmAttrValue = renderer.getAttribute(elm, attrName);
+    const elmAttrValue = getAttribute$1(elm, attrName);
 
     if (String(attrValue) !== elmAttrValue) {
       logError(`Mismatch hydrating element <${elm.tagName.toLowerCase()}>: attribute "${attrName}" has different values, expected "${attrValue}" but found "${elmAttrValue}"`, vnode.owner);
@@ -4699,9 +4759,6 @@ function vnodesAndElementHaveCompatibleClass(vnode, elm) {
     data: {
       className,
       classMap
-    },
-    owner: {
-      renderer
     }
   } = vnode;
   let nodesAreCompatible = true;
@@ -4713,7 +4770,7 @@ function vnodesAndElementHaveCompatibleClass(vnode, elm) {
     vnodeClassName = className;
   } else if (!isUndefined$1(classMap)) {
     // classMap is used when class is set to static value.
-    const classList = renderer.getClassList(elm);
+    const classList = getClassList$1(elm);
     let computedClassName = ''; // all classes from the vnode should be in the element.classList
 
     for (const name in classMap) {
@@ -4743,12 +4800,9 @@ function vnodesAndElementHaveCompatibleStyle(vnode, elm) {
     data: {
       style,
       styleDecls
-    },
-    owner: {
-      renderer
     }
   } = vnode;
-  const elmStyle = renderer.getAttribute(elm, 'style') || '';
+  const elmStyle = getAttribute$1(elm, 'style') || '';
   let vnodeStyle;
   let nodesAreCompatible = true;
 
@@ -4821,47 +4875,97 @@ function hydrateChildrenHook(elmChildren, children, vm) {
           } // Note: props are not yet set
 
 
-          const hasIncompatibleAttrs = vnodesAndElementHaveCompatibleAttrs(ch, childNode);
-          const hasIncompatibleClass = vnodesAndElementHaveCompatibleClass(ch, childNode);
-          const hasIncompatibleStyle = vnodesAndElementHaveCompatibleStyle(ch, childNode);
-          const isVNodeAndElementCompatible = hasIncompatibleAttrs && hasIncompatibleClass && hasIncompatibleStyle;
+          const hasIncompatibleAttrs = vnodesAndElementHaveCompatibleAttrs(ch, childNode);
+          const hasIncompatibleClass = vnodesAndElementHaveCompatibleClass(ch, childNode);
+          const hasIncompatibleStyle = vnodesAndElementHaveCompatibleStyle(ch, childNode);
+          const isVNodeAndElementCompatible = hasIncompatibleAttrs && hasIncompatibleClass && hasIncompatibleStyle;
+
+          if (!isVNodeAndElementCompatible) {
+            throwHydrationError();
+          }
+        }
+      }
+
+      ch.hook.hydrate(ch, childNode);
+      elmCurrentChildIdx++;
+    }
+  }
+}
+
+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
+  // are custom elements.
+  const {
+    children,
+    elm
+  } = vnode;
+
+  for (let j = 0, len = children.length; j < len; ++j) {
+    const ch = children[j];
+
+    if (!isNull(ch)) {
+      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 (!isVNodeAndElementCompatible) {
-            throwHydrationError();
-          }
-        }
-      }
+  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);
 
-      ch.hook.hydrate(ch, childNode);
-      elmCurrentChildIdx++;
+    if (oldKeys.length !== keys(cmpSlots).length) {
+      markComponentAsDirty(vm);
+      return;
     }
-  }
-}
 
-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);
-}
+    for (let i = 0, len = oldKeys.length; i < len; i += 1) {
+      const key = oldKeys[i];
 
-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
-  // are custom elements.
-  const {
-    children,
-    elm
-  } = vnode;
+      if (isUndefined$1(cmpSlots[key]) || oldSlots[key].length !== cmpSlots[key].length) {
+        markComponentAsDirty(vm);
+        return;
+      }
 
-  for (let j = 0, len = children.length; j < len; ++j) {
-    const ch = children[j];
+      const oldVNodes = oldSlots[key];
+      const vnodes = cmpSlots[key];
 
-    if (!isNull(ch)) {
-      ch.hook.remove(ch, elm);
+      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 :(
@@ -4885,12 +4989,12 @@ function hasDynamicChildren(children) {
  */
 
 
-function getUpgradableConstructor(tagName, renderer) {
+function getUpgradableConstructor(tagName) {
   // Should never get a tag with upper case letter at this point, the compiler should
   // produce only tags with lowercase letters
   // But, for backwards compatibility, we will lower case the tagName
   tagName = tagName.toLowerCase();
-  let CE = renderer.getCustomElement(tagName);
+  let CE = getCustomElement$1(tagName);
 
   if (!isUndefined$1(CE)) {
     return CE;
@@ -4901,7 +5005,7 @@ function getUpgradableConstructor(tagName, renderer) {
    */
 
 
-  CE = class LWCUpgradableElement extends renderer.HTMLElement {
+  CE = class LWCUpgradableElement extends HTMLElementExported$1 {
     constructor(upgradeCallback) {
       super();
 
@@ -4911,7 +5015,7 @@ function getUpgradableConstructor(tagName, renderer) {
     }
 
   };
-  renderer.defineCustomElement(tagName, CE);
+  defineCustomElement$1(tagName, CE);
   return CE;
 }
 /*
@@ -4929,10 +5033,7 @@ const TextHook = {
     const {
       owner
     } = vnode;
-    const {
-      renderer
-    } = owner;
-    const elm = renderer.createText(vnode.text);
+    const elm = createText$1(vnode.text);
     linkNodeToShadow(elm, owner);
     vnode.elm = elm;
   },
@@ -4966,10 +5067,7 @@ const CommentHook = {
       owner,
       text
     } = vnode;
-    const {
-      renderer
-    } = owner;
-    const elm = renderer.createComment(text);
+    const elm = createComment$1(text);
     linkNodeToShadow(elm, owner);
     vnode.elm = elm;
   },
@@ -5011,19 +5109,16 @@ const ElementHook = {
         svg
       }
     } = vnode;
-    const {
-      renderer
-    } = owner;
     const namespace = isTrue(svg) ? SVG_NAMESPACE : undefined;
-    const elm = renderer.createElement(sel, namespace);
+    const elm = createElement$1(sel, namespace);
     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);
@@ -5075,10 +5170,7 @@ const CustomElementHook = {
       sel,
       owner
     } = vnode;
-    const {
-      renderer
-    } = owner;
-    const UpgradableConstructor = getUpgradableConstructor(sel, renderer);
+    const UpgradableConstructor = getUpgradableConstructor(sel);
     /**
      * Note: if the upgradable constructor does not expect, or throw when we new it
      * with a callback as the first argument, we could implement a more advanced
@@ -5100,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) {
@@ -5114,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') {
@@ -5171,8 +5263,7 @@ const CustomElementHook = {
     createVM(elm, def, {
       mode,
       owner,
-      tagName: sel,
-      renderer: owner.renderer
+      tagName: sel
     });
     vnode.elm = elm;
     const vm = getAssociatedVM(elm);
@@ -5201,12 +5292,11 @@ const CustomElementHook = {
 
 function linkNodeToShadow(elm, owner) {
   const {
-    renderer,
     renderMode,
     shadowMode
   } = owner; // TODO [#1164]: this should eventually be done by the polyfill directly
 
-  if (renderer.isSyntheticShadowDefined) {
+  if (isSyntheticShadowDefined$1) {
     if (shadowMode === 1
     /* Synthetic */
     || renderMode === 0
@@ -5738,7 +5828,6 @@ function updateStylesheetToken(vm, template) {
   const {
     elm,
     context,
-    renderer,
     renderMode,
     shadowMode
   } = vm;
@@ -5765,11 +5854,11 @@ function updateStylesheetToken(vm, template) {
   } = context;
 
   if (oldHasTokenInClass) {
-    renderer.getClassList(elm).remove(makeHostToken(oldToken));
+    getClassList$1(elm).remove(makeHostToken(oldToken));
   }
 
   if (oldHasTokenInAttribute) {
-    renderer.removeAttribute(elm, makeHostToken(oldToken));
+    removeAttribute$1(elm, makeHostToken(oldToken));
   } // Apply the new template styling token to the host element, if the new template has any
   // associated stylesheets. In the case of light DOM, also ensure there is at least one scoped stylesheet.
 
@@ -5781,12 +5870,12 @@ function updateStylesheetToken(vm, template) {
 
   if (!isUndefined$1(newToken)) {
     if (hasScopedStyles) {
-      renderer.getClassList(elm).add(makeHostToken(newToken));
+      getClassList$1(elm).add(makeHostToken(newToken));
       newHasTokenInClass = true;
     }
 
     if (isSyntheticShadow) {
-      renderer.setAttribute(elm, makeHostToken(newToken), '');
+      setAttribute$1(elm, makeHostToken(newToken), '');
       newHasTokenInAttribute = true;
     }
   } // Update the styling tokens present on the context object.
@@ -5907,7 +5996,6 @@ function getNearestNativeShadowComponent(vm) {
 
 function createStylesheet(vm, stylesheets) {
   const {
-    renderer,
     renderMode,
     shadowMode
   } = vm;
@@ -5918,9 +6006,9 @@ function createStylesheet(vm, stylesheets) {
   /* Synthetic */
   ) {
     for (let i = 0; i < stylesheets.length; i++) {
-      renderer.insertGlobalStylesheet(stylesheets[i]);
+      insertGlobalStylesheet$1(stylesheets[i]);
     }
-  } else if (renderer.ssr || renderer.isHydrating()) {
+  } else if (ssr$1 || isHydrating$1()) {
     // Note: We need to ensure that during hydration, the stylesheets method is the same as those in ssr.
     //       This works in the client, because the stylesheets are created, and cached in the VM
     //       the first time the VM renders.
@@ -5934,10 +6022,10 @@ function createStylesheet(vm, stylesheets) {
 
     for (let i = 0; i < stylesheets.length; i++) {
       if (isGlobal) {
-        renderer.insertGlobalStylesheet(stylesheets[i]);
+        insertGlobalStylesheet$1(stylesheets[i]);
       } else {
         // local level
-        renderer.insertStylesheet(stylesheets[i], root.cmpRoot);
+        insertStylesheet$1(stylesheets[i], root.cmpRoot);
       }
     }
   }
@@ -6571,7 +6659,6 @@ function createVM(elm, def, options) {
   const {
     mode,
     owner,
-    renderer,
     tagName
   } = options;
   const vm = {
@@ -6586,7 +6673,6 @@ function createVM(elm, def, options) {
     tagName,
     mode,
     owner,
-    renderer,
     children: EmptyArray,
     aChildren: EmptyArray,
     velements: EmptyArray,
@@ -6641,16 +6727,11 @@ function createVM(elm, def, options) {
 
 function computeShadowMode(vm) {
   const {
-    def,
-    renderer
+    def
   } = vm;
-  const {
-    isNativeShadowDefined,
-    isSyntheticShadowDefined
-  } = renderer;
   let shadowMode;
 
-  if (isSyntheticShadowDefined) {
+  if (isSyntheticShadowDefined$1) {
     if (def.renderMode === 0
     /* Light */
     ) {
@@ -6659,7 +6740,7 @@ function computeShadowMode(vm) {
       shadowMode = 0
       /* Native */
       ;
-    } else if (isNativeShadowDefined) {
+    } else if (isNativeShadowDefined$1) {
       if (def.shadowSupportMode === "any"
       /* Any */
       ) {
@@ -6767,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
@@ -6775,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
@@ -6799,13 +6879,12 @@ function patchShadowRoot(vm, newCh) {
 
 function runRenderedCallback(vm) {
   const {
-    renderer,
     def: {
       renderedCallback
     }
   } = vm;
 
-  if (isTrue(renderer.ssr)) {
+  if (isTrue(ssr$1)) {
     return;
   }
 
@@ -7031,8 +7110,7 @@ function recursivelyDisconnectChildren(vnodes) {
 
 function resetComponentRoot(vm) {
   const {
-    children,
-    renderer
+    children
   } = vm;
   const rootNode = getRenderRoot(vm);
 
@@ -7040,7 +7118,7 @@ function resetComponentRoot(vm) {
     const child = children[i];
 
     if (!isNull(child) && !isUndefined$1(child.elm)) {
-      renderer.remove(child.elm, rootNode);
+      remove$1(child.elm, rootNode);
     }
   }
 
@@ -7050,7 +7128,7 @@ function resetComponentRoot(vm) {
 }
 
 function scheduleRehydration(vm) {
-  if (isTrue(vm.renderer.ssr) || isTrue(vm.isScheduled)) {
+  if (isTrue(ssr$1) || isTrue(vm.isScheduled)) {
     return;
   }
 
@@ -7073,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) {
@@ -7277,7 +7292,6 @@ function createContextWatcher(vm, wireDef, callbackWhenContextIsReady) {
 
   const {
     elm,
-    renderer,
     context: {
       wiredConnecting,
       wiredDisconnecting
@@ -7304,7 +7318,7 @@ function createContextWatcher(vm, wireDef, callbackWhenContextIsReady) {
       }
 
     });
-    renderer.dispatchEvent(elm, contextRegistrationEvent);
+    dispatchEvent$1(elm, contextRegistrationEvent);
   });
 }
 
@@ -7569,7 +7583,7 @@ function setHooks(hooks) {
   hooksAreSet = true;
   setSanitizeHtmlContentHook(hooks.sanitizeHtmlContent);
 }
-/* version: 2.6.2 */
+/* version: 2.7.3 */
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -7643,7 +7657,7 @@ function registerCustomElement(name, ctor) {
   reverseRegistry.set(ctor, name);
 }
 
-class HTMLElement$1 {
+class HTMLElementImpl {
   constructor() {
     const {
       constructor
@@ -7659,275 +7673,321 @@ class HTMLElement$1 {
 
 }
 
-const renderer = {
-  ssr: true,
-
-  isHydrating() {
-    return false;
-  },
+const ssr = true;
 
-  isNativeShadowDefined: false,
-  isSyntheticShadowDefined: false,
+function isHydrating() {
+  return false;
+}
 
-  insert(node, parent, anchor) {
-    if (node.parent !== null && node.parent !== parent) {
-      const nodeIndex = node.parent.children.indexOf(node);
-      node.parent.children.splice(nodeIndex, 1);
-    }
+const isNativeShadowDefined = false;
+const isSyntheticShadowDefined = false;
 
-    node.parent = parent;
-    const anchorIndex = isNull(anchor) ? -1 : parent.children.indexOf(anchor);
+function insert(node, parent, anchor) {
+  if (node.parent !== null && node.parent !== parent) {
+    const nodeIndex = node.parent.children.indexOf(node);
+    node.parent.children.splice(nodeIndex, 1);
+  }
 
-    if (anchorIndex === -1) {
-      parent.children.push(node);
-    } else {
-      parent.children.splice(anchorIndex, 0, node);
-    }
-  },
+  node.parent = parent;
+  const anchorIndex = isNull(anchor) ? -1 : parent.children.indexOf(anchor);
 
-  remove(node, parent) {
-    const nodeIndex = parent.children.indexOf(node);
-    parent.children.splice(nodeIndex, 1);
-  },
+  if (anchorIndex === -1) {
+    parent.children.push(node);
+  } else {
+    parent.children.splice(anchorIndex, 0, node);
+  }
+}
 
-  createElement,
+function remove(node, parent) {
+  const nodeIndex = parent.children.indexOf(node);
+  parent.children.splice(nodeIndex, 1);
+}
 
-  createText(content) {
-    return {
-      type: HostNodeType.Text,
-      value: String(content),
-      parent: null
-    };
-  },
+function createText(content) {
+  return {
+    type: HostNodeType.Text,
+    value: String(content),
+    parent: null
+  };
+}
 
-  createComment(content) {
-    return {
-      type: HostNodeType.Comment,
-      value: content,
-      parent: null
-    };
-  },
+function createComment(content) {
+  return {
+    type: HostNodeType.Comment,
+    value: content,
+    parent: null
+  };
+}
 
-  nextSibling(node) {
-    const {
-      parent
-    } = node;
+function nextSibling(node) {
+  const {
+    parent
+  } = node;
 
-    if (isNull(parent)) {
-      return null;
-    }
+  if (isNull(parent)) {
+    return null;
+  }
 
-    const nodeIndex = parent.children.indexOf(node);
-    return parent.children[nodeIndex + 1] || null;
-  },
+  const nodeIndex = parent.children.indexOf(node);
+  return parent.children[nodeIndex + 1] || null;
+}
 
-  attachShadow(element, config) {
-    element.shadowRoot = {
-      type: HostNodeType.ShadowRoot,
-      children: [],
-      mode: config.mode,
-      delegatesFocus: !!config.delegatesFocus
-    };
-    return element.shadowRoot;
-  },
+function attachShadow(element, config) {
+  element.shadowRoot = {
+    type: HostNodeType.ShadowRoot,
+    children: [],
+    mode: config.mode,
+    delegatesFocus: !!config.delegatesFocus
+  };
+  return element.shadowRoot;
+}
 
-  getProperty(node, key) {
-    var _a, _b;
+function getProperty(node, key) {
+  var _a, _b;
 
-    if (key in node) {
-      return node[key];
-    }
+  if (key in node) {
+    return node[key];
+  }
 
-    if (node.type === HostNodeType.Element) {
-      const attrName = htmlPropertyToAttribute(key); // Handle all the boolean properties.
+  if (node.type === HostNodeType.Element) {
+    const attrName = htmlPropertyToAttribute(key); // Handle all the boolean properties.
 
-      if (isBooleanAttribute(attrName, node.name)) {
-        return (_a = this.getAttribute(node, attrName)) !== null && _a !== void 0 ? _a : false;
-      } // Handle global html attributes and AOM.
+    if (isBooleanAttribute(attrName, node.name)) {
+      return (_a = getAttribute(node, attrName)) !== null && _a !== void 0 ? _a : false;
+    } // Handle global html attributes and AOM.
 
 
-      if (isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) {
-        return this.getAttribute(node, attrName);
-      } // Handle special elements live bindings. The checked property is already handled above
-      // in the boolean case.
+    if (isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) {
+      return getAttribute(node, attrName);
+    } // Handle special elements live bindings. The checked property is already handled above
+    // in the boolean case.
 
 
-      if (node.name === 'input' && key === 'value') {
-        return (_b = this.getAttribute(node, 'value')) !== null && _b !== void 0 ? _b : '';
-      }
+    if (node.name === 'input' && key === 'value') {
+      return (_b = getAttribute(node, 'value')) !== null && _b !== void 0 ? _b : '';
     }
+  }
 
-    if (process.env.NODE_ENV !== 'production') {
-      // eslint-disable-next-line no-console
-      console.error(`Unexpected "${key}" property access from the renderer`);
-    }
-  },
+  if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line no-console
+    console.error(`Unexpected "${key}" property access from the renderer`);
+  }
+}
 
-  setProperty(node, key, value) {
-    if (key in node) {
-      return node[key] = value;
-    }
+function setProperty(node, key, value) {
+  if (key in node) {
+    return node[key] = value;
+  }
 
-    if (node.type === HostNodeType.Element) {
-      const attrName = htmlPropertyToAttribute(key);
+  if (node.type === HostNodeType.Element) {
+    const attrName = htmlPropertyToAttribute(key);
 
-      if (key === 'innerHTML') {
-        node.children = [{
-          type: HostNodeType.Raw,
-          parent: node,
-          value
-        }];
-        return;
-      } // Handle all the boolean properties.
+    if (key === 'innerHTML') {
+      node.children = [{
+        type: HostNodeType.Raw,
+        parent: node,
+        value
+      }];
+      return;
+    } // Handle all the boolean properties.
 
 
-      if (isBooleanAttribute(attrName, node.name)) {
-        return value === true ? this.setAttribute(node, attrName, '') : this.removeAttribute(node, attrName);
-      } // Handle global html attributes and AOM.
+    if (isBooleanAttribute(attrName, node.name)) {
+      return value === true ? setAttribute(node, attrName, '') : removeAttribute(node, attrName);
+    } // Handle global html attributes and AOM.
 
 
-      if (isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) {
-        return this.setAttribute(node, attrName, value);
-      } // Handle special elements live bindings. The checked property is already handled above
-      // in the boolean case.
+    if (isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) {
+      return setAttribute(node, attrName, value);
+    } // Handle special elements live bindings. The checked property is already handled above
+    // in the boolean case.
 
 
-      if (node.name === 'input' && attrName === 'value') {
-        return isNull(value) || isUndefined$1(value) ? this.removeAttribute(node, 'value') : this.setAttribute(node, 'value', value);
-      }
+    if (node.name === 'input' && attrName === 'value') {
+      return isNull(value) || isUndefined$1(value) ? removeAttribute(node, 'value') : setAttribute(node, 'value', value);
     }
+  }
 
-    if (process.env.NODE_ENV !== 'production') {
-      // eslint-disable-next-line no-console
-      console.error(`Unexpected attempt to set "${key}=${value}" property from the renderer`);
-    }
-  },
+  if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line no-console
+    console.error(`Unexpected attempt to set "${key}=${value}" property from the renderer`);
+  }
+}
 
-  setText(node, content) {
-    if (node.type === HostNodeType.Text) {
-      node.value = content;
-    } else if (node.type === HostNodeType.Element) {
-      node.children = [{
-        type: HostNodeType.Text,
-        parent: node,
-        value: content
-      }];
-    }
-  },
+function setText(node, content) {
+  if (node.type === HostNodeType.Text) {
+    node.value = content;
+  } else if (node.type === HostNodeType.Element) {
+    node.children = [{
+      type: HostNodeType.Text,
+      parent: node,
+      value: content
+    }];
+  }
+}
 
-  getAttribute(element, name, namespace = null) {
-    const attribute = element.attributes.find(attr => attr.name === name && attr.namespace === namespace);
-    return attribute ? attribute.value : null;
-  },
+function getAttribute(element, name, namespace = null) {
+  const attribute = element.attributes.find(attr => attr.name === name && attr.namespace === namespace);
+  return attribute ? attribute.value : null;
+}
 
-  setAttribute(element, name, value, namespace = null) {
-    const attribute = element.attributes.find(attr => attr.name === name && attr.namespace === namespace);
+function setAttribute(element, name, value, namespace = null) {
+  const attribute = element.attributes.find(attr => attr.name === name && attr.namespace === namespace);
 
-    if (isUndefined$1(attribute)) {
-      element.attributes.push({
-        name,
-        namespace,
-        value: String(value)
-      });
-    } else {
-      attribute.value = value;
+  if (isUndefined$1(namespace)) {
+    namespace = null;
+  }
+
+  if (isUndefined$1(attribute)) {
+    element.attributes.push({
+      name,
+      namespace,
+      value: String(value)
+    });
+  } else {
+    attribute.value = value;
+  }
+}
+
+function removeAttribute(element, name, namespace) {
+  element.attributes = element.attributes.filter(attr => attr.name !== name && attr.namespace !== namespace);
+}
+
+function getClassList(element) {
+  function getClassAttribute() {
+    let classAttribute = element.attributes.find(attr => attr.name === 'class' && isNull(attr.namespace));
+
+    if (isUndefined$1(classAttribute)) {
+      classAttribute = {
+        name: 'class',
+        namespace: null,
+        value: ''
+      };
+      element.attributes.push(classAttribute);
     }
-  },
 
-  removeAttribute(element, name, namespace) {
-    element.attributes = element.attributes.filter(attr => attr.name !== name && attr.namespace !== namespace);
-  },
+    return classAttribute;
+  }
 
-  getClassList(element) {
-    function getClassAttribute() {
-      let classAttribute = element.attributes.find(attr => attr.name === 'class' && isNull(attr.namespace));
-
-      if (isUndefined$1(classAttribute)) {
-        classAttribute = {
-          name: 'class',
-          namespace: null,
-          value: ''
-        };
-        element.attributes.push(classAttribute);
-      }
+  return {
+    add(...names) {
+      const classAttribute = getClassAttribute();
+      const tokenList = classNameToTokenList(classAttribute.value);
+      names.forEach(name => tokenList.add(name));
+      classAttribute.value = tokenListToClassName(tokenList);
+    },
 
-      return classAttribute;
+    remove(...names) {
+      const classAttribute = getClassAttribute();
+      const tokenList = classNameToTokenList(classAttribute.value);
+      names.forEach(name => tokenList.delete(name));
+      classAttribute.value = tokenListToClassName(tokenList);
     }
 
-    return {
-      add(...names) {
-        const classAttribute = getClassAttribute();
-        const tokenList = classNameToTokenList(classAttribute.value);
-        names.forEach(name => tokenList.add(name));
-        classAttribute.value = tokenListToClassName(tokenList);
-      },
+  };
+}
 
-      remove(...names) {
-        const classAttribute = getClassAttribute();
-        const tokenList = classNameToTokenList(classAttribute.value);
-        names.forEach(name => tokenList.delete(name));
-        classAttribute.value = tokenListToClassName(tokenList);
-      }
+function setCSSStyleProperty(element, name, value, important) {
+  const styleAttribute = element.attributes.find(attr => attr.name === 'style' && isNull(attr.namespace));
+  const serializedProperty = `${name}: ${value}${important ? ' !important' : ''}`;
 
-    };
-  },
+  if (isUndefined$1(styleAttribute)) {
+    element.attributes.push({
+      name: 'style',
+      namespace: null,
+      value: serializedProperty
+    });
+  } else {
+    styleAttribute.value += `; ${serializedProperty}`;
+  }
+}
 
-  setCSSStyleProperty(element, name, value, important) {
-    const styleAttribute = element.attributes.find(attr => attr.name === 'style' && isNull(attr.namespace));
-    const serializedProperty = `${name}: ${value}${important ? ' !important' : ''}`;
+function isConnected(node) {
+  return !isNull(node.parent);
+} // Noop on SSR (for now). This need to be reevaluated whenever we will implement support for
+// synthetic shadow.
 
-    if (isUndefined$1(styleAttribute)) {
-      element.attributes.push({
-        name: 'style',
-        namespace: null,
-        value: serializedProperty
-      });
-    } else {
-      styleAttribute.value += `; ${serializedProperty}`;
-    }
-  },
 
-  isConnected(node) {
-    return !isNull(node.parent);
-  },
+const insertGlobalStylesheet = noop; // Noop on SSR (for now). This need to be reevaluated whenever we will implement support for
+// synthetic shadow.
 
-  insertGlobalStylesheet() {// Noop on SSR (for now). This need to be reevaluated whenever we will implement support for
-    // synthetic shadow.
-  },
+const insertStylesheet = noop; // Noop on SSR.
 
-  insertStylesheet() {// Noop on SSR (for now). This need to be reevaluated whenever we will implement support for
-    // synthetic shadow.
-  },
+const addEventListener = noop; // Noop on SSR.
 
-  addEventListener() {// Noop on SSR.
-  },
+const removeEventListener = noop;
+const dispatchEvent = unsupportedMethod('dispatchEvent');
+const getBoundingClientRect = unsupportedMethod('getBoundingClientRect');
+const querySelector = unsupportedMethod('querySelector');
+const querySelectorAll = unsupportedMethod('querySelectorAll');
+const getElementsByTagName = unsupportedMethod('getElementsByTagName');
+const getElementsByClassName = unsupportedMethod('getElementsByClassName');
+const getChildren = unsupportedMethod('getChildren');
+const getChildNodes = unsupportedMethod('getChildNodes');
+const getFirstChild = unsupportedMethod('getFirstChild');
+const getFirstElementChild = unsupportedMethod('getFirstElementChild');
+const getLastChild = unsupportedMethod('getLastChild');
+const getLastElementChild = unsupportedMethod('getLastElementChild');
 
-  removeEventListener() {// Noop on SSR.
-  },
+function defineCustomElement(name, constructor, _options) {
+  registerCustomElement(name, constructor);
+}
 
-  dispatchEvent: unsupportedMethod('dispatchEvent'),
-  getBoundingClientRect: unsupportedMethod('getBoundingClientRect'),
-  querySelector: unsupportedMethod('querySelector'),
-  querySelectorAll: unsupportedMethod('querySelectorAll'),
-  getElementsByTagName: unsupportedMethod('getElementsByTagName'),
-  getElementsByClassName: unsupportedMethod('getElementsByClassName'),
-  getChildren: unsupportedMethod('getChildren'),
-  getChildNodes: unsupportedMethod('getChildNodes'),
-  getFirstChild: unsupportedMethod('getFirstChild'),
-  getFirstElementChild: unsupportedMethod('getFirstElementChild'),
-  getLastChild: unsupportedMethod('getLastChild'),
-  getLastElementChild: unsupportedMethod('getLastElementChild'),
-
-  defineCustomElement(name, constructor, _options) {
-    registerCustomElement(name, constructor);
-  },
+function getCustomElement(name) {
+  return registry[name];
+}
 
-  getCustomElement(name) {
-    return registry[name];
-  },
+const HTMLElementExported = HTMLElementImpl;
+/* noop */
 
-  HTMLElement: HTMLElement$1
-};
+const assertInstanceOfHTMLElement = noop;
+/*
+ * 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
+ */
+
+setAssertInstanceOfHTMLElement(assertInstanceOfHTMLElement);
+setAttachShadow(attachShadow);
+setCreateComment(createComment);
+setCreateElement(createElement);
+setCreateText(createText);
+setDefineCustomElement(defineCustomElement);
+setDispatchEvent(dispatchEvent);
+setGetAttribute(getAttribute);
+setGetBoundingClientRect(getBoundingClientRect);
+setGetChildNodes(getChildNodes);
+setGetChildren(getChildren);
+setGetClassList(getClassList);
+setGetCustomElement(getCustomElement);
+setGetElementsByClassName(getElementsByClassName);
+setGetElementsByTagName(getElementsByTagName);
+setGetFirstChild(getFirstChild);
+setGetFirstElementChild(getFirstElementChild);
+setGetLastChild(getLastChild);
+setGetLastElementChild(getLastElementChild);
+setGetProperty(getProperty);
+setHTMLElement(HTMLElementExported);
+setInsert(insert);
+setInsertGlobalStylesheet(insertGlobalStylesheet);
+setInsertStylesheet(insertStylesheet);
+setIsConnected(isConnected);
+setIsHydrating(isHydrating);
+setIsNativeShadowDefined(isNativeShadowDefined);
+setIsSyntheticShadowDefined(isSyntheticShadowDefined);
+setNextSibling(nextSibling);
+setQuerySelector(querySelector);
+setQuerySelectorAll(querySelectorAll);
+setRemove(remove);
+setRemoveAttribute(removeAttribute);
+setRemoveEventListener(removeEventListener);
+setSetAttribute(setAttribute);
+setSetCSSStyleProperty(setCSSStyleProperty);
+setSetProperty(setProperty);
+setSetText(setText);
+setSsr(ssr);
+setAddEventListener(addEventListener);
 /*
  * Copyright (c) 2020, salesforce.com, inc.
  * All rights reserved.
@@ -8038,12 +8098,11 @@ function renderComponent(tagName, Ctor, props = {}) {
     throw new TypeError(`"renderComponent" expects an object as the third parameter but instead received ${props}.`);
   }
 
-  const element = renderer.createElement(tagName);
+  const element = createElement(tagName);
   const def = getComponentInternalDef(Ctor);
   createVM(element, def, {
     mode: 'open',
     owner: null,
-    renderer,
     tagName
   });
 
@@ -8065,7 +8124,7 @@ function renderComponent(tagName, Ctor, props = {}) {
 
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.6.2 */
+/* version: 2.7.3 */
 
 exports.LightningElement = LightningElement;
 exports.api = api$1;