bromcom-ui 2.3.55 → 2.3.59

package/dist/{esm/index-8fe7aea4.js → bromcom-ui/index-9dbea026.js}

@@ -1,15 +1,24 @@
 const NAMESPACE = 'bromcom-ui';
+const BUILD = /* bromcom-ui */ { allRenderFn: true, appendChildSlotFix: false, asyncLoading: true, asyncQueue: false, attachStyles: true, cloneNodeFix: false, cmpDidLoad: true, cmpDidRender: true, cmpDidUnload: false, cmpDidUpdate: true, cmpShouldUpdate: false, cmpWillLoad: true, cmpWillRender: true, cmpWillUpdate: true, connectedCallback: true, constructableCSS: false, cssAnnotations: true, cssVarShim: false, devTools: true, disconnectedCallback: true, dynamicImportShim: false, element: false, event: true, hasRenderFn: true, hostListener: true, hostListenerTarget: true, hostListenerTargetBody: false, hostListenerTargetDocument: true, hostListenerTargetParent: false, hostListenerTargetWindow: true, hotModuleReplacement: true, hydrateClientSide: false, hydrateServerSide: false, hydratedAttribute: false, hydratedClass: true, initializeNextTick: false, isDebug: false, isDev: true, isTesting: false, lazyLoad: true, lifecycle: true, lifecycleDOMEvents: false, member: true, method: true, mode: false, observeAttribute: true, profile: true, prop: true, propBoolean: true, propMutable: true, propNumber: true, propString: true, reflect: true, safari10: false, scoped: false, scriptDataOpts: false, shadowDelegatesFocus: false, shadowDom: true, shadowDomShim: false, slot: true, slotChildNodesFix: false, slotRelocation: true, state: true, style: true, svg: true, taskQueue: true, transformTagName: false, updatable: true, vdomAttribute: true, vdomClass: true, vdomFunctional: true, vdomKey: true, vdomListener: true, vdomPropOrAttr: true, vdomRef: true, vdomRender: true, vdomStyle: true, vdomText: true, vdomXlink: true, watchCallback: true };
+const Env = /* bromcom-ui */ {};
 
 let scopeId;
 let contentRef;
 let hostTagName;
+let customError;
+let i = 0;
 let useNativeShadowDom = false;
 let checkSlotFallbackVisibility = false;
 let checkSlotRelocate = false;
 let isSvgMode = false;
+let renderingRef = null;
+let queueCongestion = 0;
 let queuePending = false;
 const win = typeof window !== 'undefined' ? window : {};
+const CSS = BUILD.cssVarShim ? win.CSS : null;
 const doc = win.document || { head: {} };
+const H = (win.HTMLElement || class {
+});
 const plt = {
     $flags$: 0,
     $resourcesUrl$: '',
@@ -19,8 +28,22 @@ const plt = {
     rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
     ce: (eventName, opts) => new CustomEvent(eventName, opts),
 };
+const supportsShadow = BUILD.shadowDomShim && BUILD.shadowDom ? /*@__PURE__*/ (() => (doc.head.attachShadow + '').indexOf('[native') > -1)() : true;
+const supportsListenerOptions = /*@__PURE__*/ (() => {
+    let supportsListenerOptions = false;
+    try {
+        doc.addEventListener('e', null, Object.defineProperty({}, 'passive', {
+            get() {
+                supportsListenerOptions = true;
+            },
+        }));
+    }
+    catch (e) { }
+    return supportsListenerOptions;
+})();
 const promiseResolve = (v) => Promise.resolve(v);
-const supportsConstructibleStylesheets =  /*@__PURE__*/ (() => {
+const supportsConstructibleStylesheets = BUILD.constructableCSS
+    ? /*@__PURE__*/ (() => {
         try {
             new CSSStyleSheet();
             return true;
@@ -28,11 +51,31 @@ const supportsConstructibleStylesheets =  /*@__PURE__*/ (() => {
         catch (e) { }
         return false;
     })()
-    ;
+    : false;
+const Context = {};
 const addHostEventListeners = (elm, hostRef, listeners, attachParentListeners) => {
-    if ( listeners) {
+    if (BUILD.hostListener && listeners) {
+        // this is called immediately within the element's constructor
+        // initialize our event listeners on the host element
+        // we do this now so that we can listen to events that may
+        // have fired even before the instance is ready
+        if (BUILD.hostListenerTargetParent) {
+            // this component may have event listeners that should be attached to the parent
+            if (attachParentListeners) {
+                // this is being ran from within the connectedCallback
+                // which is important so that we know the host element actually has a parent element
+                // filter out the listeners to only have the ones that ARE being attached to the parent
+                listeners = listeners.filter(([flags]) => flags & 32 /* TargetParent */);
+            }
+            else {
+                // this is being ran from within the component constructor
+                // everything BUT the parent element listeners should be attached at this time
+                // filter out the listeners that are NOT being attached to the parent
+                listeners = listeners.filter(([flags]) => !(flags & 32 /* TargetParent */));
+            }
+        }
         listeners.map(([flags, name, method]) => {
-            const target =  getHostListenerTarget(elm, flags) ;
+            const target = BUILD.hostListenerTarget ? getHostListenerTarget(elm, flags) : elm;
             const handler = hostListenerProxy(hostRef, method);
             const opts = hostListenerOpts(flags);
             plt.ael(target, name, handler, opts);
@@ -42,7 +85,7 @@ const addHostEventListeners = (elm, hostRef, listeners, attachParentListeners) =
 };
 const hostListenerProxy = (hostRef, methodName) => (ev) => {
     try {
-        {
+        if (BUILD.lazyLoad) {
             if (hostRef.$flags$ & 256 /* isListenReady */) {
                 // instance is ready, let's call it's member method for this event
                 hostRef.$lazyInstance$[methodName](ev);
@@ -51,36 +94,127 @@ const hostListenerProxy = (hostRef, methodName) => (ev) => {
                 (hostRef.$queuedListeners$ = hostRef.$queuedListeners$ || []).push([methodName, ev]);
             }
         }
+        else {
+            hostRef.$hostElement$[methodName](ev);
+        }
     }
     catch (e) {
         consoleError(e);
     }
 };
 const getHostListenerTarget = (elm, flags) => {
-    if ( flags & 4 /* TargetDocument */)
+    if (BUILD.hostListenerTargetDocument && flags & 4 /* TargetDocument */)
         return doc;
-    if ( flags & 8 /* TargetWindow */)
+    if (BUILD.hostListenerTargetWindow && flags & 8 /* TargetWindow */)
         return win;
+    if (BUILD.hostListenerTargetBody && flags & 16 /* TargetBody */)
+        return doc.body;
+    if (BUILD.hostListenerTargetParent && flags & 32 /* TargetParent */)
+        return elm.parentElement;
     return elm;
 };
 // prettier-ignore
-const hostListenerOpts = (flags) =>  (flags & 2 /* Capture */) !== 0;
+const hostListenerOpts = (flags) => supportsListenerOptions
+    ? ({
+        passive: (flags & 1 /* Passive */) !== 0,
+        capture: (flags & 2 /* Capture */) !== 0,
+    })
+    : (flags & 2 /* Capture */) !== 0;
+const CONTENT_REF_ID = 'r';
+const ORG_LOCATION_ID = 'o';
+const SLOT_NODE_ID = 's';
+const TEXT_NODE_ID = 't';
+const HYDRATE_ID = 's-id';
+const HYDRATED_STYLE_ID = 'sty-id';
+const HYDRATE_CHILD_ID = 'c-id';
 const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}';
 const XLINK_NS = 'http://www.w3.org/1999/xlink';
 const createTime = (fnName, tagName = '') => {
-    {
+    if (BUILD.profile && performance.mark) {
+        const key = `st:${fnName}:${tagName}:${i++}`;
+        // Start
+        performance.mark(key);
+        // End
+        return () => performance.measure(`[Stencil] ${fnName}() <${tagName}>`, key);
+    }
+    else {
         return () => {
             return;
         };
     }
 };
 const uniqueTime = (key, measureText) => {
-    {
+    if (BUILD.profile && performance.mark) {
+        if (performance.getEntriesByName(key).length === 0) {
+            performance.mark(key);
+        }
+        return () => {
+            if (performance.getEntriesByName(measureText).length === 0) {
+                performance.measure(measureText, key);
+            }
+        };
+    }
+    else {
         return () => {
             return;
         };
     }
 };
+const inspect = (ref) => {
+    const hostRef = getHostRef(ref);
+    if (!hostRef) {
+        return undefined;
+    }
+    const flags = hostRef.$flags$;
+    const hostElement = hostRef.$hostElement$;
+    return {
+        renderCount: hostRef.$renderCount$,
+        flags: {
+            hasRendered: !!(flags & 2 /* hasRendered */),
+            hasConnected: !!(flags & 1 /* hasConnected */),
+            isWaitingForChildren: !!(flags & 4 /* isWaitingForChildren */),
+            isConstructingInstance: !!(flags & 8 /* isConstructingInstance */),
+            isQueuedForUpdate: !!(flags & 16 /* isQueuedForUpdate */),
+            hasInitializedComponent: !!(flags & 32 /* hasInitializedComponent */),
+            hasLoadedComponent: !!(flags & 64 /* hasLoadedComponent */),
+            isWatchReady: !!(flags & 128 /* isWatchReady */),
+            isListenReady: !!(flags & 256 /* isListenReady */),
+            needsRerender: !!(flags & 512 /* needsRerender */),
+        },
+        instanceValues: hostRef.$instanceValues$,
+        ancestorComponent: hostRef.$ancestorComponent$,
+        hostElement,
+        lazyInstance: hostRef.$lazyInstance$,
+        vnode: hostRef.$vnode$,
+        modeName: hostRef.$modeName$,
+        onReadyPromise: hostRef.$onReadyPromise$,
+        onReadyResolve: hostRef.$onReadyResolve$,
+        onInstancePromise: hostRef.$onInstancePromise$,
+        onInstanceResolve: hostRef.$onInstanceResolve$,
+        onRenderResolve: hostRef.$onRenderResolve$,
+        queuedListeners: hostRef.$queuedListeners$,
+        rmListeners: hostRef.$rmListeners$,
+        ['s-id']: hostElement['s-id'],
+        ['s-cr']: hostElement['s-cr'],
+        ['s-lr']: hostElement['s-lr'],
+        ['s-p']: hostElement['s-p'],
+        ['s-rc']: hostElement['s-rc'],
+        ['s-sc']: hostElement['s-sc'],
+    };
+};
+const installDevTools = () => {
+    if (BUILD.devTools) {
+        const stencil = (win.stencil = win.stencil || {});
+        const originalInspect = stencil.inspect;
+        stencil.inspect = (ref) => {
+            let result = inspect(ref);
+            if (!result && typeof originalInspect === 'function') {
+                result = originalInspect(ref);
+            }
+            return result;
+        };
+    }
+};
 const rootAppliedStyles = new WeakMap();
 const registerStyle = (scopeId, cssText, allowCS) => {
     let style = styles.get(scopeId);
@@ -94,8 +228,11 @@ const registerStyle = (scopeId, cssText, allowCS) => {
     styles.set(scopeId, style);
 };
 const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
-    let scopeId = getScopeId(cmpMeta);
+    let scopeId = getScopeId(cmpMeta, mode);
     let style = styles.get(scopeId);
+    if (!BUILD.attachStyles) {
+        return scopeId;
+    }
     // if an element is NOT connected then getRootNode() will return the wrong root node
     // so the fallback is to always use the document for the root node in those cases
     styleContainerNode = styleContainerNode.nodeType === 11 /* DocumentFragment */ ? styleContainerNode : doc;
@@ -108,11 +245,29 @@ const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
                 rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set()));
             }
             if (!appliedStyles.has(scopeId)) {
-                {
-                    {
+                if (BUILD.hydrateClientSide && styleContainerNode.host && (styleElm = styleContainerNode.querySelector(`[${HYDRATED_STYLE_ID}="${scopeId}"]`))) {
+                    // This is only happening on native shadow-dom, do not needs CSS var shim
+                    styleElm.innerHTML = style;
+                }
+                else {
+                    if (BUILD.cssVarShim && plt.$cssShim$) {
+                        styleElm = plt.$cssShim$.createHostStyle(hostElm, scopeId, style, !!(cmpMeta.$flags$ & 10 /* needsScopedEncapsulation */));
+                        const newScopeId = styleElm['s-sc'];
+                        if (newScopeId) {
+                            scopeId = newScopeId;
+                            // we don't want to add this styleID to the appliedStyles Set
+                            // since the cssVarShim might need to apply several different
+                            // stylesheets for the same component
+                            appliedStyles = null;
+                        }
+                    }
+                    else {
                         styleElm = doc.createElement('style');
                         styleElm.innerHTML = style;
                     }
+                    if (BUILD.hydrateServerSide || BUILD.hotModuleReplacement) {
+                        styleElm.setAttribute(HYDRATED_STYLE_ID, scopeId);
+                    }
                     styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link'));
                 }
                 if (appliedStyles) {
@@ -120,7 +275,7 @@ const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
                 }
             }
         }
-        else if ( !styleContainerNode.adoptedStyleSheets.includes(style)) {
+        else if (BUILD.constructableCSS && !styleContainerNode.adoptedStyleSheets.includes(style)) {
             styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style];
         }
     }
@@ -131,8 +286,8 @@ const attachStyles = (hostRef) => {
     const elm = hostRef.$hostElement$;
     const flags = cmpMeta.$flags$;
     const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$);
-    const scopeId = addStyle( elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta);
-    if ( flags & 10 /* needsScopedEncapsulation */) {
+    const scopeId = addStyle(BUILD.shadowDom && supportsShadow && elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta, hostRef.$modeName$, elm);
+    if ((BUILD.shadowDom || BUILD.scoped) && BUILD.cssAnnotations && flags & 10 /* needsScopedEncapsulation */) {
         // only required when we're NOT using native shadow dom (slot)
         // or this browser doesn't support native shadow dom
         // and this host element was NOT created with SSR
@@ -142,10 +297,19 @@ const attachStyles = (hostRef) => {
         // DOM WRITE!!
         elm['s-sc'] = scopeId;
         elm.classList.add(scopeId + '-h');
+        if (BUILD.scoped && flags & 2 /* scopedCssEncapsulation */) {
+            elm.classList.add(scopeId + '-s');
+        }
     }
     endAttachStyles();
 };
-const getScopeId = (cmp, mode) => 'sc-' + ( cmp.$tagName$);
+const getScopeId = (cmp, mode) => 'sc-' + (BUILD.mode && mode && cmp.$flags$ & 32 /* hasMode */ ? cmp.$tagName$ + '-' + mode : cmp.$tagName$);
+const convertScopedToShadow = (css) => css.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, '$1{');
+// Private
+const computeMode = (elm) => modeResolutionChain.map(h => h(elm)).find(m => !!m);
+// Public
+const setMode = (handler) => modeResolutionChain.push(handler);
+const getMode = (ref) => getHostRef(ref).$modeName$;
 /**
  * Default style mode id
  */
@@ -193,6 +357,11 @@ const h = (nodeName, vnodeData, ...children) => {
                 if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) {
                     child = String(child);
                 }
+                else if (BUILD.isDev && typeof nodeName !== 'function' && child.$flags$ === undefined) {
+                    consoleDevError(`vNode passed as children has unexpected type.
+Make sure it's using the correct h() function.
+Empty objects can also be the cause, look for JSX comments that became objects.`);
+                }
                 if (simple && lastSimple) {
                     // If the previous child was simple (string), we merge both
                     vNodeChildren[vNodeChildren.length - 1].$text$ += child;
@@ -207,14 +376,17 @@ const h = (nodeName, vnodeData, ...children) => {
     };
     walk(children);
     if (vnodeData) {
+        if (BUILD.isDev && nodeName === 'input') {
+            validateInputProperties(vnodeData);
+        }
         // normalize class / classname attributes
-        if ( vnodeData.key) {
+        if (BUILD.vdomKey && vnodeData.key) {
             key = vnodeData.key;
         }
-        if ( vnodeData.name) {
+        if (BUILD.slotRelocation && vnodeData.name) {
             slotName = vnodeData.name;
         }
-        {
+        if (BUILD.vdomClass) {
             const classData = vnodeData.className || vnodeData.class;
             if (classData) {
                 vnodeData.class =
@@ -226,7 +398,12 @@ const h = (nodeName, vnodeData, ...children) => {
             }
         }
     }
-    if ( typeof nodeName === 'function') {
+    if (BUILD.isDev && vNodeChildren.some(isHost)) {
+        consoleDevError(`The <Host> must be the single root component. Make sure:
+- You are NOT using hostData() and <Host> in the same component.
+- <Host> is used once, and it's the single root component of the render() function.`);
+    }
+    if (BUILD.vdomFunctional && typeof nodeName === 'function') {
         // nodeName is a functional component
         return nodeName(vnodeData === null ? {} : vnodeData, vNodeChildren, vdomFnUtils);
     }
@@ -235,10 +412,10 @@ const h = (nodeName, vnodeData, ...children) => {
     if (vNodeChildren.length > 0) {
         vnode.$children$ = vNodeChildren;
     }
-    {
+    if (BUILD.vdomKey) {
         vnode.$key$ = key;
     }
-    {
+    if (BUILD.slotRelocation) {
         vnode.$name$ = slotName;
     }
     return vnode;
@@ -251,13 +428,13 @@ const newVNode = (tag, text) => {
         $elm$: null,
         $children$: null,
     };
-    {
+    if (BUILD.vdomAttribute) {
         vnode.$attrs$ = null;
     }
-    {
+    if (BUILD.vdomKey) {
         vnode.$key$ = null;
     }
-    {
+    if (BUILD.slotRelocation) {
         vnode.$name$ = null;
     }
     return vnode;
@@ -294,6 +471,20 @@ const convertToPrivate = (node) => {
     vnode.$name$ = node.vname;
     return vnode;
 };
+const validateInputProperties = (vnodeData) => {
+    const props = Object.keys(vnodeData);
+    const typeIndex = props.indexOf('type');
+    const minIndex = props.indexOf('min');
+    const maxIndex = props.indexOf('max');
+    const stepIndex = props.indexOf('min');
+    const value = props.indexOf('value');
+    if (value === -1) {
+        return;
+    }
+    if (value < typeIndex || value < minIndex || value < maxIndex || value < stepIndex) {
+        consoleDevWarn(`The "value" prop of <input> should be set after "min", "max", "type" and "step"`);
+    }
+};
 /**
  * Production setAccessor() function based on Preact by
  * Jason Miller (@developit)
@@ -306,19 +497,19 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
     if (oldValue !== newValue) {
         let isProp = isMemberInElement(elm, memberName);
         let ln = memberName.toLowerCase();
-        if ( memberName === 'class') {
+        if (BUILD.vdomClass && memberName === 'class') {
             const classList = elm.classList;
             const oldClasses = parseClassList(oldValue);
             const newClasses = parseClassList(newValue);
             classList.remove(...oldClasses.filter(c => c && !newClasses.includes(c)));
             classList.add(...newClasses.filter(c => c && !oldClasses.includes(c)));
         }
-        else if ( memberName === 'style') {
+        else if (BUILD.vdomStyle && memberName === 'style') {
             // update style attribute, css properties and values
-            {
+            if (BUILD.updatable) {
                 for (const prop in oldValue) {
                     if (!newValue || newValue[prop] == null) {
-                        if ( prop.includes('-')) {
+                        if (!BUILD.hydrateServerSide && prop.includes('-')) {
                             elm.style.removeProperty(prop);
                         }
                         else {
@@ -329,7 +520,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
             }
             for (const prop in newValue) {
                 if (!oldValue || newValue[prop] !== oldValue[prop]) {
-                    if ( prop.includes('-')) {
+                    if (!BUILD.hydrateServerSide && prop.includes('-')) {
                         elm.style.setProperty(prop, newValue[prop]);
                     }
                     else {
@@ -338,15 +529,15 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
                 }
             }
         }
-        else if ( memberName === 'key')
+        else if (BUILD.vdomKey && memberName === 'key')
             ;
-        else if ( memberName === 'ref') {
+        else if (BUILD.vdomRef && memberName === 'ref') {
             // minifier will clean this up
             if (newValue) {
                 newValue(elm);
             }
         }
-        else if ( ( !isProp ) && memberName[0] === 'o' && memberName[1] === 'n') {
+        else if (BUILD.vdomListener && (BUILD.lazyLoad ? !isProp : !elm.__lookupSetter__(memberName)) && memberName[0] === 'o' && memberName[1] === 'n') {
             // Event Handlers
             // so if the member name starts with "on" and the 3rd characters is
             // a capital letter, and it's not already a member on the element,
@@ -383,7 +574,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
                 plt.ael(elm, memberName, newValue, false);
             }
         }
-        else {
+        else if (BUILD.vdomPropOrAttr) {
             // Set property if it exists and it's not a SVG
             const isComplex = isComplexType(newValue);
             if ((isProp || (isComplex && newValue !== null)) && !isSvg) {
@@ -413,7 +604,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
              * - if the newValue is null/undefined or 'false'.
              */
             let xlink = false;
-            {
+            if (BUILD.vdomXlink) {
                 if (ln !== (ln = ln.replace(/^xlink\:?/, ''))) {
                     memberName = ln;
                     xlink = true;
@@ -421,7 +612,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
             }
             if (newValue == null || newValue === false) {
                 if (newValue !== false || elm.getAttribute(memberName) === '') {
-                    if ( xlink) {
+                    if (BUILD.vdomXlink && xlink) {
                         elm.removeAttributeNS(XLINK_NS, memberName);
                     }
                     else {
@@ -431,7 +622,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
             }
             else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex) {
                 newValue = newValue === true ? '' : newValue;
-                if ( xlink) {
+                if (BUILD.vdomXlink && xlink) {
                     elm.setAttributeNS(XLINK_NS, memberName, newValue);
                 }
                 else {
@@ -450,7 +641,7 @@ const updateElement = (oldVnode, newVnode, isSvgMode, memberName) => {
     const elm = newVnode.$elm$.nodeType === 11 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$;
     const oldVnodeAttrs = (oldVnode && oldVnode.$attrs$) || EMPTY_OBJ;
     const newVnodeAttrs = newVnode.$attrs$ || EMPTY_OBJ;
-    {
+    if (BUILD.updatable) {
         // remove attributes no longer present on the vnode by setting them to undefined
         for (memberName in oldVnodeAttrs) {
             if (!(memberName in newVnodeAttrs)) {
@@ -470,7 +661,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
     let elm;
     let childNode;
     let oldVNode;
-    if ( !useNativeShadowDom) {
+    if (BUILD.slotRelocation && !useNativeShadowDom) {
         // remember for later we need to check to relocate nodes
         checkSlotRelocate = true;
         if (newVNode.$tag$ === 'slot') {
@@ -485,29 +676,33 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
                     1 /* isSlotReference */;
         }
     }
-    if ( newVNode.$text$ !== null) {
+    if (BUILD.isDev && newVNode.$elm$) {
+        consoleDevError(`The JSX ${newVNode.$text$ !== null ? `"${newVNode.$text$}" text` : `"${newVNode.$tag$}" element`} node should not be shared within the same renderer. The renderer caches element lookups in order to improve performance. However, a side effect from this is that the exact same JSX node should not be reused. For more information please see https://stenciljs.com/docs/templating-jsx#avoid-shared-jsx-nodes`);
+    }
+    if (BUILD.vdomText && newVNode.$text$ !== null) {
         // create text node
         elm = newVNode.$elm$ = doc.createTextNode(newVNode.$text$);
     }
-    else if ( newVNode.$flags$ & 1 /* isSlotReference */) {
+    else if (BUILD.slotRelocation && newVNode.$flags$ & 1 /* isSlotReference */) {
         // create a slot reference node
-        elm = newVNode.$elm$ =  doc.createTextNode('');
+        elm = newVNode.$elm$ = BUILD.isDebug || BUILD.hydrateServerSide ? slotReferenceDebugNode(newVNode) : doc.createTextNode('');
     }
     else {
-        if ( !isSvgMode) {
+        if (BUILD.svg && !isSvgMode) {
             isSvgMode = newVNode.$tag$ === 'svg';
         }
         // create element
-        elm = newVNode.$elm$ = ( doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS,  newVNode.$flags$ & 2 /* isSlotFallback */ ? 'slot-fb' : newVNode.$tag$)
-            );
-        if ( isSvgMode && newVNode.$tag$ === 'foreignObject') {
+        elm = newVNode.$elm$ = (BUILD.svg
+            ? doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, BUILD.slotRelocation && newVNode.$flags$ & 2 /* isSlotFallback */ ? 'slot-fb' : newVNode.$tag$)
+            : doc.createElement(BUILD.slotRelocation && newVNode.$flags$ & 2 /* isSlotFallback */ ? 'slot-fb' : newVNode.$tag$));
+        if (BUILD.svg && isSvgMode && newVNode.$tag$ === 'foreignObject') {
             isSvgMode = false;
         }
         // add css classes, attrs, props, listeners, etc.
-        {
+        if (BUILD.vdomAttribute) {
             updateElement(null, newVNode, isSvgMode);
         }
-        if ( isDef(scopeId) && elm['s-si'] !== scopeId) {
+        if ((BUILD.shadowDom || BUILD.scoped) && isDef(scopeId) && elm['s-si'] !== scopeId) {
             // if there is a scopeId and this is the initial render
             // then let's add the scopeId as a css class
             elm.classList.add((elm['s-si'] = scopeId));
@@ -523,7 +718,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
                 }
             }
         }
-        {
+        if (BUILD.svg) {
             if (newVNode.$tag$ === 'svg') {
                 // Only reset the SVG context when we're exiting <svg> element
                 isSvgMode = false;
@@ -534,7 +729,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
             }
         }
     }
-    {
+    if (BUILD.slotRelocation) {
         elm['s-hn'] = hostTagName;
         if (newVNode.$flags$ & (2 /* isSlotFallback */ | 1 /* isSlotReference */)) {
             // remember the content reference comment
@@ -579,9 +774,9 @@ const putBackInOriginalLocation = (parentElm, recursive) => {
     plt.$flags$ &= ~1 /* isTmpDisconnected */;
 };
 const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {
-    let containerElm = (( parentElm['s-cr'] && parentElm['s-cr'].parentNode) || parentElm);
+    let containerElm = ((BUILD.slotRelocation && parentElm['s-cr'] && parentElm['s-cr'].parentNode) || parentElm);
     let childNode;
-    if ( containerElm.shadowRoot && containerElm.tagName === hostTagName) {
+    if (BUILD.shadowDom && containerElm.shadowRoot && containerElm.tagName === hostTagName) {
         containerElm = containerElm.shadowRoot;
     }
     for (; startIdx <= endIdx; ++startIdx) {
@@ -589,7 +784,7 @@ const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) =>
             childNode = createElm(null, parentVNode, startIdx, parentElm);
             if (childNode) {
                 vnodes[startIdx].$elm$ = childNode;
-                containerElm.insertBefore(childNode,  referenceNode(before) );
+                containerElm.insertBefore(childNode, BUILD.slotRelocation ? referenceNode(before) : before);
             }
         }
     }
@@ -599,7 +794,7 @@ const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => {
         if ((vnode = vnodes[startIdx])) {
             elm = vnode.$elm$;
             callNodeRefs(vnode);
-            {
+            if (BUILD.slotRelocation) {
                 // we're removing this element
                 // so it's possible we need to show slot fallback content now
                 checkSlotFallbackVisibility = true;
@@ -657,7 +852,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
         }
         else if (isSameVnode(oldStartVnode, newEndVnode)) {
             // Vnode moved right
-            if ( (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
+            if (BUILD.slotRelocation && (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
                 putBackInOriginalLocation(oldStartVnode.$elm$.parentNode, false);
             }
             patch(oldStartVnode, newEndVnode);
@@ -667,7 +862,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
         }
         else if (isSameVnode(oldEndVnode, newStartVnode)) {
             // Vnode moved left
-            if ( (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
+            if (BUILD.slotRelocation && (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
                 putBackInOriginalLocation(oldEndVnode.$elm$.parentNode, false);
             }
             patch(oldEndVnode, newStartVnode);
@@ -678,7 +873,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
         else {
             // createKeyToOldIdx
             idxInOld = -1;
-            {
+            if (BUILD.vdomKey) {
                 for (i = oldStartIdx; i <= oldEndIdx; ++i) {
                     if (oldCh[i] && oldCh[i].$key$ !== null && oldCh[i].$key$ === newStartVnode.$key$) {
                         idxInOld = i;
@@ -686,7 +881,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
                     }
                 }
             }
-            if ( idxInOld >= 0) {
+            if (BUILD.vdomKey && idxInOld >= 0) {
                 elmToMove = oldCh[idxInOld];
                 if (elmToMove.$tag$ !== newStartVnode.$tag$) {
                     node = createElm(oldCh && oldCh[newStartIdx], newVNode, idxInOld, parentElm);
@@ -704,16 +899,19 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
                 newStartVnode = newCh[++newStartIdx];
             }
             if (node) {
-                {
+                if (BUILD.slotRelocation) {
                     parentReferenceNode(oldStartVnode.$elm$).insertBefore(node, referenceNode(oldStartVnode.$elm$));
                 }
+                else {
+                    oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$);
+                }
             }
         }
     }
     if (oldStartIdx > oldEndIdx) {
         addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx);
     }
-    else if ( newStartIdx > newEndIdx) {
+    else if (BUILD.updatable && newStartIdx > newEndIdx) {
         removeVnodes(oldCh, oldStartIdx, oldEndIdx);
     }
 };
@@ -721,12 +919,13 @@ const isSameVnode = (vnode1, vnode2) => {
     // compare if two vnode to see if they're "technically" the same
     // need to have the same element tag, and same key to be the same
     if (vnode1.$tag$ === vnode2.$tag$) {
-        if ( vnode1.$tag$ === 'slot') {
+        if (BUILD.slotRelocation && vnode1.$tag$ === 'slot') {
             return vnode1.$name$ === vnode2.$name$;
         }
-        {
+        if (BUILD.vdomKey) {
             return vnode1.$key$ === vnode2.$key$;
         }
+        return true;
     }
     return false;
 };
@@ -745,15 +944,15 @@ const patch = (oldVNode, newVNode) => {
     const tag = newVNode.$tag$;
     const text = newVNode.$text$;
     let defaultHolder;
-    if ( text === null) {
-        {
+    if (!BUILD.vdomText || text === null) {
+        if (BUILD.svg) {
             // test if we're rendering an svg element, or still rendering nodes inside of one
             // only add this to the when the compiler sees we're using an svg somewhere
             isSvgMode = tag === 'svg' ? true : tag === 'foreignObject' ? false : isSvgMode;
         }
         // element node
-        {
-            if ( tag === 'slot')
+        if (BUILD.vdomAttribute || BUILD.reflect) {
+            if (BUILD.slot && tag === 'slot')
                 ;
             else {
                 // either this is the first render of an element OR it's an update
@@ -762,32 +961,32 @@ const patch = (oldVNode, newVNode) => {
                 updateElement(oldVNode, newVNode, isSvgMode);
             }
         }
-        if ( oldChildren !== null && newChildren !== null) {
+        if (BUILD.updatable && oldChildren !== null && newChildren !== null) {
             // looks like there's child vnodes for both the old and new vnodes
             updateChildren(elm, oldChildren, newVNode, newChildren);
         }
         else if (newChildren !== null) {
             // no old child vnodes, but there are new child vnodes to add
-            if ( oldVNode.$text$ !== null) {
+            if (BUILD.updatable && BUILD.vdomText && oldVNode.$text$ !== null) {
                 // the old vnode was text, so be sure to clear it out
                 elm.textContent = '';
             }
             // add the new vnode children
             addVnodes(elm, null, newVNode, newChildren, 0, newChildren.length - 1);
         }
-        else if ( oldChildren !== null) {
+        else if (BUILD.updatable && oldChildren !== null) {
             // no new child vnodes, but there are old child vnodes to remove
             removeVnodes(oldChildren, 0, oldChildren.length - 1);
         }
-        if ( isSvgMode && tag === 'svg') {
+        if (BUILD.svg && isSvgMode && tag === 'svg') {
             isSvgMode = false;
         }
     }
-    else if ( (defaultHolder = elm['s-cr'])) {
+    else if (BUILD.vdomText && BUILD.slotRelocation && (defaultHolder = elm['s-cr'])) {
         // this element has slotted content
         defaultHolder.parentNode.textContent = text;
     }
-    else if ( oldVNode.$text$ !== text) {
+    else if (BUILD.vdomText && oldVNode.$text$ !== text) {
         // update the text content for the text only vnode
         // and also only if the text is different than before
         elm.data = text;
@@ -927,7 +1126,7 @@ const isNodeLocatedInSlot = (nodeToRelocate, slotNameAttr) => {
     return slotNameAttr === '';
 };
 const callNodeRefs = (vNode) => {
-    {
+    if (BUILD.vdomRef) {
         vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null);
         vNode.$children$ && vNode.$children$.map(callNodeRefs);
     }
@@ -938,26 +1137,41 @@ const renderVdom = (hostRef, renderFnResults) => {
     const oldVNode = hostRef.$vnode$ || newVNode(null, null);
     const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults);
     hostTagName = hostElm.tagName;
-    if ( cmpMeta.$attrsToReflect$) {
+    // <Host> runtime check
+    if (BUILD.isDev && Array.isArray(renderFnResults) && renderFnResults.some(isHost)) {
+        throw new Error(`The <Host> must be the single root component.
+Looks like the render() function of "${hostTagName.toLowerCase()}" is returning an array that contains the <Host>.
+
+The render() function should look like this instead:
+
+render() {
+  // Do not return an array
+  return (
+    <Host>{content}</Host>
+  );
+}
+  `);
+    }
+    if (BUILD.reflect && cmpMeta.$attrsToReflect$) {
         rootVnode.$attrs$ = rootVnode.$attrs$ || {};
         cmpMeta.$attrsToReflect$.map(([propName, attribute]) => (rootVnode.$attrs$[attribute] = hostElm[propName]));
     }
     rootVnode.$tag$ = null;
     rootVnode.$flags$ |= 4 /* isHost */;
     hostRef.$vnode$ = rootVnode;
-    rootVnode.$elm$ = oldVNode.$elm$ = ( hostElm.shadowRoot || hostElm );
-    {
+    rootVnode.$elm$ = oldVNode.$elm$ = (BUILD.shadowDom ? hostElm.shadowRoot || hostElm : hostElm);
+    if (BUILD.scoped || BUILD.shadowDom) {
         scopeId = hostElm['s-sc'];
     }
-    {
+    if (BUILD.slotRelocation) {
         contentRef = hostElm['s-cr'];
-        useNativeShadowDom =  (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) !== 0;
+        useNativeShadowDom = supportsShadow && (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) !== 0;
         // always reset
         checkSlotFallbackVisibility = false;
     }
     // synchronous patch
     patch(oldVNode, rootVnode);
-    {
+    if (BUILD.slotRelocation) {
         // while we're moving nodes around existing nodes, temporarily disable
         // the disconnectCallback from working
         plt.$flags$ |= 1 /* isTmpDisconnected */;
@@ -976,7 +1190,7 @@ const renderVdom = (hostRef, renderFnResults) => {
                 if (!nodeToRelocate['s-ol']) {
                     // add a reference node marking this node's original location
                     // keep a reference to this node for later lookups
-                    orgLocationNode =  doc.createTextNode('');
+                    orgLocationNode = BUILD.isDebug || BUILD.hydrateServerSide ? originalLocationDebugNode(nodeToRelocate) : doc.createTextNode('');
                     orgLocationNode['s-nr'] = nodeToRelocate;
                     nodeToRelocate.parentNode.insertBefore((nodeToRelocate['s-ol'] = orgLocationNode), nodeToRelocate);
                 }
@@ -1032,11 +1246,18 @@ const renderVdom = (hostRef, renderFnResults) => {
         relocateNodes.length = 0;
     }
 };
-const getElement = (ref) => ( getHostRef(ref).$hostElement$ );
+// slot comment debug nodes only created with the `--debug` flag
+// otherwise these nodes are text nodes w/out content
+const slotReferenceDebugNode = (slotVNode) => doc.createComment(`<slot${slotVNode.$name$ ? ' name="' + slotVNode.$name$ + '"' : ''}> (host=${hostTagName.toLowerCase()})`);
+const originalLocationDebugNode = (nodeToRelocate) => doc.createComment(`org-location for ` + (nodeToRelocate.localName ? `<${nodeToRelocate.localName}> (host=${nodeToRelocate['s-hn']})` : `[${nodeToRelocate.textContent}]`));
+const getElement = (ref) => (BUILD.lazyLoad ? getHostRef(ref).$hostElement$ : ref);
 const createEvent = (ref, name, flags) => {
     const elm = getElement(ref);
     return {
         emit: (detail) => {
+            if (BUILD.isDev && !elm.isConnected) {
+                consoleDevWarn(`The "${name}" event was emitted, but the dispatcher node is no longer connected to the dom.`);
+            }
             return emitEvent(elm, name, {
                 bubbles: !!(flags & 4 /* Bubbles */),
                 composed: !!(flags & 2 /* Composed */),
@@ -1052,15 +1273,15 @@ const emitEvent = (elm, name, opts) => {
     return ev;
 };
 const attachToAncestor = (hostRef, ancestorComponent) => {
-    if ( ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) {
+    if (BUILD.asyncLoading && ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) {
         ancestorComponent['s-p'].push(new Promise(r => (hostRef.$onRenderResolve$ = r)));
     }
 };
 const scheduleUpdate = (hostRef, isInitialLoad) => {
-    {
+    if (BUILD.taskQueue && BUILD.updatable) {
         hostRef.$flags$ |= 16 /* isQueuedForUpdate */;
     }
-    if ( hostRef.$flags$ & 4 /* isWaitingForChildren */) {
+    if (BUILD.asyncLoading && hostRef.$flags$ & 4 /* isWaitingForChildren */) {
         hostRef.$flags$ |= 512 /* needsRerender */;
         return;
     }
@@ -1069,30 +1290,34 @@ const scheduleUpdate = (hostRef, isInitialLoad) => {
     // has already fired off its lifecycle update then
     // fire off the initial update
     const dispatch = () => dispatchHooks(hostRef, isInitialLoad);
-    return  writeTask(dispatch) ;
+    return BUILD.taskQueue ? writeTask(dispatch) : dispatch();
 };
 const dispatchHooks = (hostRef, isInitialLoad) => {
+    const elm = hostRef.$hostElement$;
     const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$);
-    const instance =  hostRef.$lazyInstance$ ;
+    const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
     let promise;
     if (isInitialLoad) {
-        {
+        if (BUILD.lazyLoad && BUILD.hostListener) {
             hostRef.$flags$ |= 256 /* isListenReady */;
             if (hostRef.$queuedListeners$) {
                 hostRef.$queuedListeners$.map(([methodName, event]) => safeCall(instance, methodName, event));
                 hostRef.$queuedListeners$ = null;
             }
         }
-        {
+        emitLifecycleEvent(elm, 'componentWillLoad');
+        if (BUILD.cmpWillLoad) {
             promise = safeCall(instance, 'componentWillLoad');
         }
     }
     else {
-        {
+        emitLifecycleEvent(elm, 'componentWillUpdate');
+        if (BUILD.cmpWillUpdate) {
             promise = safeCall(instance, 'componentWillUpdate');
         }
     }
-    {
+    emitLifecycleEvent(elm, 'componentWillRender');
+    if (BUILD.cmpWillRender) {
         promise = then(promise, () => safeCall(instance, 'componentWillRender'));
     }
     endSchedule();
@@ -1103,22 +1328,56 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
     const elm = hostRef.$hostElement$;
     const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$);
     const rc = elm['s-rc'];
-    if ( isInitialLoad) {
+    if (BUILD.style && isInitialLoad) {
         // DOM WRITE!
         attachStyles(hostRef);
     }
     const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$);
-    {
-        {
+    if (BUILD.isDev) {
+        hostRef.$flags$ |= 1024 /* devOnRender */;
+    }
+    if (BUILD.hasRenderFn || BUILD.reflect) {
+        if (BUILD.vdomRender || BUILD.reflect) {
             // looks like we've got child nodes to render into this host element
             // or we need to update the css class/attrs on the host element
             // DOM WRITE!
-            {
+            if (BUILD.hydrateServerSide) {
+                renderVdom(hostRef, await callRender(hostRef, instance));
+            }
+            else {
                 renderVdom(hostRef, callRender(hostRef, instance));
             }
         }
+        else {
+            elm.textContent = callRender(hostRef, instance);
+        }
+    }
+    if (BUILD.cssVarShim && plt.$cssShim$) {
+        plt.$cssShim$.updateHost(elm);
+    }
+    if (BUILD.isDev) {
+        hostRef.$renderCount$++;
+        hostRef.$flags$ &= ~1024 /* devOnRender */;
+    }
+    if (BUILD.hydrateServerSide) {
+        try {
+            // manually connected child components during server-side hydrate
+            serverSideConnected(elm);
+            if (isInitialLoad) {
+                // using only during server-side hydrate
+                if (hostRef.$cmpMeta$.$flags$ & 1 /* shadowDomEncapsulation */) {
+                    elm['s-en'] = '';
+                }
+                else if (hostRef.$cmpMeta$.$flags$ & 2 /* scopedCssEncapsulation */) {
+                    elm['s-en'] = 'c';
+                }
+            }
+        }
+        catch (e) {
+            consoleError(e, elm);
+        }
     }
-    if ( rc) {
+    if (BUILD.asyncLoading && rc) {
         // ok, so turns out there are some child host elements
         // waiting on this parent element to load
         // let's fire off all update callbacks waiting
@@ -1127,7 +1386,7 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
     }
     endRender();
     endUpdate();
-    {
+    if (BUILD.asyncLoading) {
         const childrenPromises = elm['s-p'];
         const postUpdate = () => postUpdateComponent(hostRef);
         if (childrenPromises.length === 0) {
@@ -1139,60 +1398,101 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
             childrenPromises.length = 0;
         }
     }
+    else {
+        postUpdateComponent(hostRef);
+    }
 };
 const callRender = (hostRef, instance) => {
+    // in order for bundlers to correctly treeshake the BUILD object
+    // we need to ensure BUILD is not deoptimized within a try/catch
+    // https://rollupjs.org/guide/en/#treeshake tryCatchDeoptimization
+    const allRenderFn = BUILD.allRenderFn ? true : false;
+    const lazyLoad = BUILD.lazyLoad ? true : false;
+    const taskQueue = BUILD.taskQueue ? true : false;
+    const updatable = BUILD.updatable ? true : false;
     try {
-        instance =  instance.render() ;
-        {
+        renderingRef = instance;
+        instance = allRenderFn ? instance.render() : instance.render && instance.render();
+        if (updatable && taskQueue) {
             hostRef.$flags$ &= ~16 /* isQueuedForUpdate */;
         }
-        {
+        if (updatable || lazyLoad) {
             hostRef.$flags$ |= 2 /* hasRendered */;
         }
     }
     catch (e) {
         consoleError(e, hostRef.$hostElement$);
     }
+    renderingRef = null;
     return instance;
 };
+const getRenderingRef = () => renderingRef;
 const postUpdateComponent = (hostRef) => {
     const tagName = hostRef.$cmpMeta$.$tagName$;
     const elm = hostRef.$hostElement$;
     const endPostUpdate = createTime('postUpdate', tagName);
-    const instance =  hostRef.$lazyInstance$ ;
+    const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
     const ancestorComponent = hostRef.$ancestorComponent$;
-    {
+    if (BUILD.cmpDidRender) {
+        if (BUILD.isDev) {
+            hostRef.$flags$ |= 1024 /* devOnRender */;
+        }
         safeCall(instance, 'componentDidRender');
+        if (BUILD.isDev) {
+            hostRef.$flags$ &= ~1024 /* devOnRender */;
+        }
     }
+    emitLifecycleEvent(elm, 'componentDidRender');
     if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) {
         hostRef.$flags$ |= 64 /* hasLoadedComponent */;
-        {
+        if (BUILD.asyncLoading && BUILD.cssAnnotations) {
             // DOM WRITE!
             addHydratedFlag(elm);
         }
-        {
+        if (BUILD.cmpDidLoad) {
+            if (BUILD.isDev) {
+                hostRef.$flags$ |= 2048 /* devOnDidLoad */;
+            }
             safeCall(instance, 'componentDidLoad');
+            if (BUILD.isDev) {
+                hostRef.$flags$ &= ~2048 /* devOnDidLoad */;
+            }
         }
+        emitLifecycleEvent(elm, 'componentDidLoad');
         endPostUpdate();
-        {
+        if (BUILD.asyncLoading) {
             hostRef.$onReadyResolve$(elm);
             if (!ancestorComponent) {
-                appDidLoad();
+                appDidLoad(tagName);
             }
         }
     }
     else {
-        {
+        if (BUILD.cmpDidUpdate) {
+            // we've already loaded this component
+            // fire off the user's componentDidUpdate method (if one was provided)
+            // componentDidUpdate runs AFTER render() has been called
+            // and all child components have finished updating
+            if (BUILD.isDev) {
+                hostRef.$flags$ |= 1024 /* devOnRender */;
+            }
             safeCall(instance, 'componentDidUpdate');
+            if (BUILD.isDev) {
+                hostRef.$flags$ &= ~1024 /* devOnRender */;
+            }
         }
+        emitLifecycleEvent(elm, 'componentDidUpdate');
         endPostUpdate();
     }
-    {
+    if (BUILD.hotModuleReplacement) {
+        elm['s-hmr-load'] && elm['s-hmr-load']();
+    }
+    if (BUILD.method && BUILD.lazyLoad) {
         hostRef.$onInstanceResolve$(elm);
     }
     // load events fire from bottom to top
     // the deepest elements load first then bubbles up
-    {
+    if (BUILD.asyncLoading) {
         if (hostRef.$onRenderResolve$) {
             hostRef.$onRenderResolve$();
             hostRef.$onRenderResolve$ = undefined;
@@ -1207,7 +1507,7 @@ const postUpdateComponent = (hostRef) => {
     // (⌐■_■)
 };
 const forceUpdate = (ref) => {
-    {
+    if (BUILD.updatable) {
         const hostRef = getHostRef(ref);
         const isConnected = hostRef.$hostElement$.isConnected;
         if (isConnected && (hostRef.$flags$ & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
@@ -1216,14 +1516,21 @@ const forceUpdate = (ref) => {
         // Returns "true" when the forced update was successfully scheduled
         return isConnected;
     }
+    return false;
 };
 const appDidLoad = (who) => {
     // on appload
     // we have finish the first big initial render
-    {
+    if (BUILD.cssAnnotations) {
         addHydratedFlag(doc.documentElement);
     }
+    if (BUILD.asyncQueue) {
+        plt.$flags$ |= 2 /* appLoaded */;
+    }
     nextTick(() => emitEvent(win, 'appload', { detail: { namespace: NAMESPACE } }));
+    if (BUILD.profile && performance.measure) {
+        performance.measure(`[Stencil] ${NAMESPACE} initial load (by ${who})`, 'st:app:start');
+    }
 };
 const safeCall = (instance, method, arg) => {
     if (instance && instance[method]) {
@@ -1239,20 +1546,248 @@ const safeCall = (instance, method, arg) => {
 const then = (promise, thenFn) => {
     return promise && promise.then ? promise.then(thenFn) : thenFn();
 };
-const addHydratedFlag = (elm) => ( elm.classList.add('hydrated') );
+const emitLifecycleEvent = (elm, lifecycleName) => {
+    if (BUILD.lifecycleDOMEvents) {
+        emitEvent(elm, 'stencil_' + lifecycleName, {
+            bubbles: true,
+            composed: true,
+            detail: {
+                namespace: NAMESPACE,
+            },
+        });
+    }
+};
+const addHydratedFlag = (elm) => (BUILD.hydratedClass ? elm.classList.add('hydrated') : BUILD.hydratedAttribute ? elm.setAttribute('hydrated', '') : undefined);
+const serverSideConnected = (elm) => {
+    const children = elm.children;
+    if (children != null) {
+        for (let i = 0, ii = children.length; i < ii; i++) {
+            const childElm = children[i];
+            if (typeof childElm.connectedCallback === 'function') {
+                childElm.connectedCallback();
+            }
+            serverSideConnected(childElm);
+        }
+    }
+};
+const initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {
+    const endHydrate = createTime('hydrateClient', tagName);
+    const shadowRoot = hostElm.shadowRoot;
+    const childRenderNodes = [];
+    const slotNodes = [];
+    const shadowRootNodes = BUILD.shadowDom && shadowRoot ? [] : null;
+    const vnode = (hostRef.$vnode$ = newVNode(tagName, null));
+    if (!plt.$orgLocNodes$) {
+        initializeDocumentHydrate(doc.body, (plt.$orgLocNodes$ = new Map()));
+    }
+    hostElm[HYDRATE_ID] = hostId;
+    hostElm.removeAttribute(HYDRATE_ID);
+    clientHydrate(vnode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, hostElm, hostId);
+    childRenderNodes.map(c => {
+        const orgLocationId = c.$hostId$ + '.' + c.$nodeId$;
+        const orgLocationNode = plt.$orgLocNodes$.get(orgLocationId);
+        const node = c.$elm$;
+        if (orgLocationNode && supportsShadow && orgLocationNode['s-en'] === '') {
+            orgLocationNode.parentNode.insertBefore(node, orgLocationNode.nextSibling);
+        }
+        if (!shadowRoot) {
+            node['s-hn'] = tagName;
+            if (orgLocationNode) {
+                node['s-ol'] = orgLocationNode;
+                node['s-ol']['s-nr'] = node;
+            }
+        }
+        plt.$orgLocNodes$.delete(orgLocationId);
+    });
+    if (BUILD.shadowDom && shadowRoot) {
+        shadowRootNodes.map(shadowRootNode => {
+            if (shadowRootNode) {
+                shadowRoot.appendChild(shadowRootNode);
+            }
+        });
+    }
+    endHydrate();
+};
+const clientHydrate = (parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node, hostId) => {
+    let childNodeType;
+    let childIdSplt;
+    let childVNode;
+    let i;
+    if (node.nodeType === 1 /* ElementNode */) {
+        childNodeType = node.getAttribute(HYDRATE_CHILD_ID);
+        if (childNodeType) {
+            // got the node data from the element's attribute
+            // `${hostId}.${nodeId}.${depth}.${index}`
+            childIdSplt = childNodeType.split('.');
+            if (childIdSplt[0] === hostId || childIdSplt[0] === '0') {
+                childVNode = {
+                    $flags$: 0,
+                    $hostId$: childIdSplt[0],
+                    $nodeId$: childIdSplt[1],
+                    $depth$: childIdSplt[2],
+                    $index$: childIdSplt[3],
+                    $tag$: node.tagName.toLowerCase(),
+                    $elm$: node,
+                    $attrs$: null,
+                    $children$: null,
+                    $key$: null,
+                    $name$: null,
+                    $text$: null,
+                };
+                childRenderNodes.push(childVNode);
+                node.removeAttribute(HYDRATE_CHILD_ID);
+                // this is a new child vnode
+                // so ensure its parent vnode has the vchildren array
+                if (!parentVNode.$children$) {
+                    parentVNode.$children$ = [];
+                }
+                // add our child vnode to a specific index of the vnode's children
+                parentVNode.$children$[childVNode.$index$] = childVNode;
+                // this is now the new parent vnode for all the next child checks
+                parentVNode = childVNode;
+                if (shadowRootNodes && childVNode.$depth$ === '0') {
+                    shadowRootNodes[childVNode.$index$] = childVNode.$elm$;
+                }
+            }
+        }
+        // recursively drill down, end to start so we can remove nodes
+        for (i = node.childNodes.length - 1; i >= 0; i--) {
+            clientHydrate(parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node.childNodes[i], hostId);
+        }
+        if (node.shadowRoot) {
+            // keep drilling down through the shadow root nodes
+            for (i = node.shadowRoot.childNodes.length - 1; i >= 0; i--) {
+                clientHydrate(parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node.shadowRoot.childNodes[i], hostId);
+            }
+        }
+    }
+    else if (node.nodeType === 8 /* CommentNode */) {
+        // `${COMMENT_TYPE}.${hostId}.${nodeId}.${depth}.${index}`
+        childIdSplt = node.nodeValue.split('.');
+        if (childIdSplt[1] === hostId || childIdSplt[1] === '0') {
+            // comment node for either the host id or a 0 host id
+            childNodeType = childIdSplt[0];
+            childVNode = {
+                $flags$: 0,
+                $hostId$: childIdSplt[1],
+                $nodeId$: childIdSplt[2],
+                $depth$: childIdSplt[3],
+                $index$: childIdSplt[4],
+                $elm$: node,
+                $attrs$: null,
+                $children$: null,
+                $key$: null,
+                $name$: null,
+                $tag$: null,
+                $text$: null,
+            };
+            if (childNodeType === TEXT_NODE_ID) {
+                childVNode.$elm$ = node.nextSibling;
+                if (childVNode.$elm$ && childVNode.$elm$.nodeType === 3 /* TextNode */) {
+                    childVNode.$text$ = childVNode.$elm$.textContent;
+                    childRenderNodes.push(childVNode);
+                    // remove the text comment since it's no longer needed
+                    node.remove();
+                    if (!parentVNode.$children$) {
+                        parentVNode.$children$ = [];
+                    }
+                    parentVNode.$children$[childVNode.$index$] = childVNode;
+                    if (shadowRootNodes && childVNode.$depth$ === '0') {
+                        shadowRootNodes[childVNode.$index$] = childVNode.$elm$;
+                    }
+                }
+            }
+            else if (childVNode.$hostId$ === hostId) {
+                // this comment node is specifcally for this host id
+                if (childNodeType === SLOT_NODE_ID) {
+                    // `${SLOT_NODE_ID}.${hostId}.${nodeId}.${depth}.${index}.${slotName}`;
+                    childVNode.$tag$ = 'slot';
+                    if (childIdSplt[5]) {
+                        node['s-sn'] = childVNode.$name$ = childIdSplt[5];
+                    }
+                    else {
+                        node['s-sn'] = '';
+                    }
+                    node['s-sr'] = true;
+                    if (BUILD.shadowDom && shadowRootNodes) {
+                        // browser support shadowRoot and this is a shadow dom component
+                        // create an actual slot element
+                        childVNode.$elm$ = doc.createElement(childVNode.$tag$);
+                        if (childVNode.$name$) {
+                            // add the slot name attribute
+                            childVNode.$elm$.setAttribute('name', childVNode.$name$);
+                        }
+                        // insert the new slot element before the slot comment
+                        node.parentNode.insertBefore(childVNode.$elm$, node);
+                        // remove the slot comment since it's not needed for shadow
+                        node.remove();
+                        if (childVNode.$depth$ === '0') {
+                            shadowRootNodes[childVNode.$index$] = childVNode.$elm$;
+                        }
+                    }
+                    slotNodes.push(childVNode);
+                    if (!parentVNode.$children$) {
+                        parentVNode.$children$ = [];
+                    }
+                    parentVNode.$children$[childVNode.$index$] = childVNode;
+                }
+                else if (childNodeType === CONTENT_REF_ID) {
+                    // `${CONTENT_REF_ID}.${hostId}`;
+                    if (BUILD.shadowDom && shadowRootNodes) {
+                        // remove the content ref comment since it's not needed for shadow
+                        node.remove();
+                    }
+                    else if (BUILD.slotRelocation) {
+                        hostElm['s-cr'] = node;
+                        node['s-cn'] = true;
+                    }
+                }
+            }
+        }
+    }
+    else if (parentVNode && parentVNode.$tag$ === 'style') {
+        const vnode = newVNode(null, node.textContent);
+        vnode.$elm$ = node;
+        vnode.$index$ = '0';
+        parentVNode.$children$ = [vnode];
+    }
+};
+const initializeDocumentHydrate = (node, orgLocNodes) => {
+    if (node.nodeType === 1 /* ElementNode */) {
+        let i = 0;
+        for (; i < node.childNodes.length; i++) {
+            initializeDocumentHydrate(node.childNodes[i], orgLocNodes);
+        }
+        if (node.shadowRoot) {
+            for (i = 0; i < node.shadowRoot.childNodes.length; i++) {
+                initializeDocumentHydrate(node.shadowRoot.childNodes[i], orgLocNodes);
+            }
+        }
+    }
+    else if (node.nodeType === 8 /* CommentNode */) {
+        const childIdSplt = node.nodeValue.split('.');
+        if (childIdSplt[0] === ORG_LOCATION_ID) {
+            orgLocNodes.set(childIdSplt[1] + '.' + childIdSplt[2], node);
+            node.nodeValue = '';
+            // useful to know if the original location is
+            // the root light-dom of a shadow dom component
+            node['s-en'] = childIdSplt[3];
+        }
+    }
+};
 const parsePropertyValue = (propValue, propType) => {
     // ensure this value is of the correct prop type
     if (propValue != null && !isComplexType(propValue)) {
-        if ( propType & 4 /* Boolean */) {
+        if (BUILD.propBoolean && propType & 4 /* Boolean */) {
             // per the HTML spec, any string value means it is a boolean true value
             // but we'll cheat here and say that the string "false" is the boolean false
             return propValue === 'false' ? false : propValue === '' || !!propValue;
         }
-        if ( propType & 2 /* Number */) {
+        if (BUILD.propNumber && propType & 2 /* Number */) {
             // force it to be a number
             return parseFloat(propValue);
         }
-        if ( propType & 1 /* String */) {
+        if (BUILD.propString && propType & 1 /* String */) {
             // could have been passed as a number or boolean
             // but we still want it as a string
             return String(propValue);
@@ -1268,18 +1803,26 @@ const getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propNam
 const setValue = (ref, propName, newVal, cmpMeta) => {
     // check our new property value against our internal value
     const hostRef = getHostRef(ref);
-    const elm =  hostRef.$hostElement$ ;
+    const elm = BUILD.lazyLoad ? hostRef.$hostElement$ : ref;
     const oldVal = hostRef.$instanceValues$.get(propName);
     const flags = hostRef.$flags$;
-    const instance =  hostRef.$lazyInstance$ ;
+    const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
     newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]);
-    if (( !(flags & 8 /* isConstructingInstance */) || oldVal === undefined) && newVal !== oldVal) {
+    if ((!BUILD.lazyLoad || !(flags & 8 /* isConstructingInstance */) || oldVal === undefined) && newVal !== oldVal) {
         // gadzooks! the property's value has changed!!
         // set our new value!
         hostRef.$instanceValues$.set(propName, newVal);
-        if ( instance) {
+        if (BUILD.isDev) {
+            if (hostRef.$flags$ & 1024 /* devOnRender */) {
+                consoleDevWarn(`The state/prop "${propName}" changed during rendering. This can potentially lead to infinite-loops and other bugs.`, '\nElement', elm, '\nNew value', newVal, '\nOld value', oldVal);
+            }
+            else if (hostRef.$flags$ & 2048 /* devOnDidLoad */) {
+                consoleDevWarn(`The state/prop "${propName}" changed during "componentDidLoad()", this triggers extra re-renders, try to setup on "componentWillLoad()"`, '\nElement', elm, '\nNew value', newVal, '\nOld value', oldVal);
+            }
+        }
+        if (!BUILD.lazyLoad || instance) {
             // get an array of method names of watch functions to call
-            if ( cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) {
+            if (BUILD.watchCallback && cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) {
                 const watchMethods = cmpMeta.$watchers$[propName];
                 if (watchMethods) {
                     // this instance is watching for when this property changed
@@ -1294,7 +1837,12 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
                     });
                 }
             }
-            if ( (flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+            if (BUILD.updatable && (flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+                if (BUILD.cmpShouldUpdate && instance.componentShouldUpdate) {
+                    if (instance.componentShouldUpdate(newVal, oldVal, propName) === false) {
+                        return;
+                    }
+                }
                 // looks like this value actually changed, so we've got work to do!
                 // but only if we've already rendered, otherwise just chill out
                 // queue that we need to do an update, but don't worry about queuing
@@ -1305,15 +1853,15 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
     }
 };
 const proxyComponent = (Cstr, cmpMeta, flags) => {
-    if ( cmpMeta.$members$) {
-        if ( Cstr.watchers) {
+    if (BUILD.member && cmpMeta.$members$) {
+        if (BUILD.watchCallback && Cstr.watchers) {
             cmpMeta.$watchers$ = Cstr.watchers;
         }
         // It's better to have a const than two Object.entries()
         const members = Object.entries(cmpMeta.$members$);
         const prototype = Cstr.prototype;
         members.map(([memberName, [memberFlags]]) => {
-            if ( (memberFlags & 31 /* Prop */ || (( flags & 2 /* proxyState */) && memberFlags & 32 /* State */))) {
+            if ((BUILD.prop || BUILD.state) && (memberFlags & 31 /* Prop */ || ((!BUILD.lazyLoad || flags & 2 /* proxyState */) && memberFlags & 32 /* State */))) {
                 // proxyComponent - prop
                 Object.defineProperty(prototype, memberName, {
                     get() {
@@ -1321,6 +1869,15 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                         return getValue(this, memberName);
                     },
                     set(newValue) {
+                        if (
+                        // only during dev time
+                        BUILD.isDev &&
+                            // we are proxing the instance (not element)
+                            (flags & 1 /* isElementConstructor */) === 0 &&
+                            // the member is a non-mutable prop
+                            (memberFlags & (31 /* Prop */ | 1024 /* Mutable */)) === 31 /* Prop */) {
+                            consoleDevWarn(`@Prop() "${memberName}" on "${cmpMeta.$tagName$}" cannot be modified.\nFurther information: https://stenciljs.com/docs/properties#prop-mutability`);
+                        }
                         // proxyComponent, set value
                         setValue(this, memberName, newValue, cmpMeta);
                     },
@@ -1328,7 +1885,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                     enumerable: true,
                 });
             }
-            else if ( flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) {
+            else if (BUILD.lazyLoad && BUILD.method && flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) {
                 // proxyComponent - method
                 Object.defineProperty(prototype, memberName, {
                     value(...args) {
@@ -1338,7 +1895,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                 });
             }
         });
-        if ( ( flags & 1 /* isElementConstructor */)) {
+        if (BUILD.observeAttribute && (!BUILD.lazyLoad || flags & 1 /* isElementConstructor */)) {
             const attrNameToPropName = new Map();
             prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) {
                 plt.jmp(() => {
@@ -1353,7 +1910,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                 .map(([propName, m]) => {
                 const attrName = m[1] || propName;
                 attrNameToPropName.set(attrName, propName);
-                if ( m[0] & 512 /* ReflectAttr */) {
+                if (BUILD.reflect && m[0] & 512 /* ReflectAttr */) {
                     cmpMeta.$attrsToReflect$.push([propName, attrName]);
                 }
                 return attrName;
@@ -1364,25 +1921,28 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
 };
 const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => {
     // initializeComponent
-    if ( (hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) {
-        {
+    if ((BUILD.lazyLoad || BUILD.hydrateServerSide || BUILD.style) && (hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) {
+        if (BUILD.lazyLoad || BUILD.hydrateClientSide) {
             // we haven't initialized this element yet
             hostRef.$flags$ |= 32 /* hasInitializedComponent */;
             // lazy loaded components
             // request the component's implementation to be
             // wired up with the host element
-            Cstr = loadModule(cmpMeta);
+            Cstr = loadModule(cmpMeta, hostRef, hmrVersionId);
             if (Cstr.then) {
                 // Await creates a micro-task avoid if possible
-                const endLoad = uniqueTime();
+                const endLoad = uniqueTime(`st:load:${cmpMeta.$tagName$}:${hostRef.$modeName$}`, `[Stencil] Load module for <${cmpMeta.$tagName$}>`);
                 Cstr = await Cstr;
                 endLoad();
             }
-            if ( !Cstr.isProxied) {
+            if ((BUILD.isDev || BUILD.isDebug) && !Cstr) {
+                throw new Error(`Constructor for "${cmpMeta.$tagName$}#${hostRef.$modeName$}" was not found`);
+            }
+            if (BUILD.member && !Cstr.isProxied) {
                 // we'eve never proxied this Constructor before
                 // let's add the getters/setters to its prototype before
                 // the first time we create an instance of the implementation
-                {
+                if (BUILD.watchCallback) {
                     cmpMeta.$watchers$ = Cstr.watchers;
                 }
                 proxyComponent(Cstr, cmpMeta, 2 /* proxyState */);
@@ -1392,7 +1952,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) =>
             // ok, time to construct the instance
             // but let's keep track of when we start and stop
             // so that the getters/setters don't incorrectly step on data
-            {
+            if (BUILD.member) {
                 hostRef.$flags$ |= 8 /* isConstructingInstance */;
             }
             // construct the lazy-loaded component implementation
@@ -1405,21 +1965,35 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) =>
             catch (e) {
                 consoleError(e);
             }
-            {
+            if (BUILD.member) {
                 hostRef.$flags$ &= ~8 /* isConstructingInstance */;
             }
-            {
+            if (BUILD.watchCallback) {
                 hostRef.$flags$ |= 128 /* isWatchReady */;
             }
             endNewInstance();
             fireConnectedCallback(hostRef.$lazyInstance$);
         }
-        if ( Cstr.style) {
+        else {
+            // sync constructor component
+            Cstr = elm.constructor;
+            hostRef.$flags$ |= 128 /* isWatchReady */ | 32 /* hasInitializedComponent */;
+        }
+        if (BUILD.style && Cstr.style) {
             // this component has styles but we haven't registered them yet
             let style = Cstr.style;
-            const scopeId = getScopeId(cmpMeta);
+            if (BUILD.mode && typeof style !== 'string') {
+                style = style[(hostRef.$modeName$ = computeMode(elm))];
+                if (BUILD.hydrateServerSide && hostRef.$modeName$) {
+                    elm.setAttribute('s-mode', hostRef.$modeName$);
+                }
+            }
+            const scopeId = getScopeId(cmpMeta, hostRef.$modeName$);
             if (!styles.has(scopeId)) {
                 const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$);
+                if (!BUILD.hydrateServerSide && BUILD.shadowDom && BUILD.shadowDomShim && cmpMeta.$flags$ & 8 /* needsShadowDomShim */) {
+                    style = await import('./shadow-css-3ef739e8.js').then(m => m.scopeCss(style, scopeId, false));
+                }
                 registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */));
                 endRegisterStyles();
             }
@@ -1428,7 +2002,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) =>
     // we've successfully created a lazy instance
     const ancestorComponent = hostRef.$ancestorComponent$;
     const schedule = () => scheduleUpdate(hostRef, true);
-    if ( ancestorComponent && ancestorComponent['s-rc']) {
+    if (BUILD.asyncLoading && ancestorComponent && ancestorComponent['s-rc']) {
         // this is the intial load and this component it has an ancestor component
         // but the ancestor component has NOT fired its will update lifecycle yet
         // so let's just cool our jets and wait for the ancestor to continue first
@@ -1442,7 +2016,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) =>
     }
 };
 const fireConnectedCallback = (instance) => {
-    {
+    if (BUILD.lazyLoad && BUILD.connectedCallback) {
         safeCall(instance, 'connectedCallback');
     }
 };
@@ -1451,26 +2025,41 @@ const connectedCallback = (elm) => {
         const hostRef = getHostRef(elm);
         const cmpMeta = hostRef.$cmpMeta$;
         const endConnected = createTime('connectedCallback', cmpMeta.$tagName$);
+        if (BUILD.hostListenerTargetParent) {
+            // only run if we have listeners being attached to a parent
+            addHostEventListeners(elm, hostRef, cmpMeta.$listeners$, true);
+        }
         if (!(hostRef.$flags$ & 1 /* hasConnected */)) {
             // first time this component has connected
             hostRef.$flags$ |= 1 /* hasConnected */;
-            {
+            let hostId;
+            if (BUILD.hydrateClientSide) {
+                hostId = elm.getAttribute(HYDRATE_ID);
+                if (hostId) {
+                    if (BUILD.shadowDom && supportsShadow && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
+                        const scopeId = BUILD.mode ? addStyle(elm.shadowRoot, cmpMeta, elm.getAttribute('s-mode')) : addStyle(elm.shadowRoot, cmpMeta);
+                        elm.classList.remove(scopeId + '-h', scopeId + '-s');
+                    }
+                    initializeClientHydrate(elm, cmpMeta.$tagName$, hostId, hostRef);
+                }
+            }
+            if (BUILD.slotRelocation && !hostId) {
                 // initUpdate
                 // if the slot polyfill is required we'll need to put some nodes
                 // in here to act as original content anchors as we move nodes around
                 // host element has been connected to the DOM
-                if ( ( cmpMeta.$flags$ & (4 /* hasSlotRelocation */ | 8 /* needsShadowDomShim */))) {
+                if (BUILD.hydrateServerSide || ((BUILD.slot || BUILD.shadowDom) && cmpMeta.$flags$ & (4 /* hasSlotRelocation */ | 8 /* needsShadowDomShim */))) {
                     setContentReference(elm);
                 }
             }
-            {
+            if (BUILD.asyncLoading) {
                 // find the first ancestor component (if there is one) and register
                 // this component as one of the actively loading child components for its ancestor
                 let ancestorComponent = elm;
                 while ((ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host)) {
                     // climb up the ancestors looking for the first
                     // component that hasn't finished its lifecycle update yet
-                    if (
+                    if ((BUILD.hydrateClientSide && ancestorComponent.nodeType === 1 /* ElementNode */ && ancestorComponent.hasAttribute('s-id') && ancestorComponent['s-p']) ||
                         ancestorComponent['s-p']) {
                         // we found this components first ancestor component
                         // keep a reference to this component's ancestor component
@@ -1481,7 +2070,7 @@ const connectedCallback = (elm) => {
             }
             // Lazy properties
             // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties
-            if ( cmpMeta.$members$) {
+            if (BUILD.prop && BUILD.lazyLoad && !BUILD.hydrateServerSide && cmpMeta.$members$) {
                 Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {
                     if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) {
                         const value = elm[memberName];
@@ -1490,7 +2079,14 @@ const connectedCallback = (elm) => {
                     }
                 });
             }
-            {
+            if (BUILD.initializeNextTick) {
+                // connectedCallback, taskQueue, initialLoad
+                // angular sets attribute AFTER connectCallback
+                // https://github.com/angular/angular/issues/18909
+                // https://github.com/angular/angular/issues/19940
+                nextTick(() => initializeComponent(elm, hostRef, cmpMeta));
+            }
+            else {
                 initializeComponent(elm, hostRef, cmpMeta);
             }
         }
@@ -1498,7 +2094,7 @@ const connectedCallback = (elm) => {
             // not the first time this has connected
             // reattach any event listeners to the host
             // since they would have been removed when disconnected
-            addHostEventListeners(elm, hostRef, cmpMeta.$listeners$);
+            addHostEventListeners(elm, hostRef, cmpMeta.$listeners$, false);
             // fire off connectedCallback() on component instance
             fireConnectedCallback(hostRef.$lazyInstance$);
         }
@@ -1512,27 +2108,231 @@ const setContentReference = (elm) => {
     // let's pick out the inner content for slot projection
     // create a node to represent where the original
     // content was first placed, which is useful later on
-    const contentRefElm = (elm['s-cr'] = doc.createComment( ''));
+    const contentRefElm = (elm['s-cr'] = doc.createComment(BUILD.isDebug ? `content-ref (host=${elm.localName})` : ''));
     contentRefElm['s-cn'] = true;
     elm.insertBefore(contentRefElm, elm.firstChild);
 };
 const disconnectedCallback = (elm) => {
     if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {
         const hostRef = getHostRef(elm);
-        const instance =  hostRef.$lazyInstance$ ;
-        {
+        const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
+        if (BUILD.hostListener) {
             if (hostRef.$rmListeners$) {
                 hostRef.$rmListeners$.map(rmListener => rmListener());
                 hostRef.$rmListeners$ = undefined;
             }
         }
-        {
+        // clear CSS var-shim tracking
+        if (BUILD.cssVarShim && plt.$cssShim$) {
+            plt.$cssShim$.removeHost(elm);
+        }
+        if (BUILD.lazyLoad && BUILD.disconnectedCallback) {
             safeCall(instance, 'disconnectedCallback');
         }
+        if (BUILD.cmpDidUnload) {
+            safeCall(instance, 'componentDidUnload');
+        }
+    }
+};
+const defineCustomElement = (Cstr, compactMeta) => {
+    customElements.define(compactMeta[1], proxyCustomElement(Cstr, compactMeta));
+};
+const proxyCustomElement = (Cstr, compactMeta) => {
+    const cmpMeta = {
+        $flags$: compactMeta[0],
+        $tagName$: compactMeta[1],
+    };
+    if (BUILD.member) {
+        cmpMeta.$members$ = compactMeta[2];
+    }
+    if (BUILD.hostListener) {
+        cmpMeta.$listeners$ = compactMeta[3];
+    }
+    if (BUILD.watchCallback) {
+        cmpMeta.$watchers$ = Cstr.$watchers$;
+    }
+    if (BUILD.reflect) {
+        cmpMeta.$attrsToReflect$ = [];
+    }
+    if (BUILD.shadowDom && !supportsShadow && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
+        cmpMeta.$flags$ |= 8 /* needsShadowDomShim */;
     }
+    const originalConnectedCallback = Cstr.prototype.connectedCallback;
+    const originalDisconnectedCallback = Cstr.prototype.disconnectedCallback;
+    Object.assign(Cstr.prototype, {
+        __registerHost() {
+            registerHost(this, cmpMeta);
+        },
+        connectedCallback() {
+            connectedCallback(this);
+            if (BUILD.connectedCallback && originalConnectedCallback) {
+                originalConnectedCallback.call(this);
+            }
+        },
+        disconnectedCallback() {
+            disconnectedCallback(this);
+            if (BUILD.disconnectedCallback && originalDisconnectedCallback) {
+                originalDisconnectedCallback.call(this);
+            }
+        },
+    });
+    Cstr.is = cmpMeta.$tagName$;
+    return proxyComponent(Cstr, cmpMeta, 1 /* isElementConstructor */ | 2 /* proxyState */);
+};
+const forceModeUpdate = (elm) => {
+    if (BUILD.style && BUILD.mode && !BUILD.lazyLoad) {
+        const mode = computeMode(elm);
+        const hostRef = getHostRef(elm);
+        if (hostRef.$modeName$ !== mode) {
+            const cmpMeta = hostRef.$cmpMeta$;
+            const oldScopeId = elm['s-sc'];
+            const scopeId = getScopeId(cmpMeta, mode);
+            const style = elm.constructor.style[mode];
+            const flags = cmpMeta.$flags$;
+            if (style) {
+                if (!styles.has(scopeId)) {
+                    registerStyle(scopeId, style, !!(flags & 1 /* shadowDomEncapsulation */));
+                }
+                hostRef.$modeName$ = mode;
+                elm.classList.remove(oldScopeId + '-h', oldScopeId + '-s');
+                attachStyles(hostRef);
+                forceUpdate(elm);
+            }
+        }
+    }
+};
+const attachShadow = (el) => {
+    if (supportsShadow) {
+        el.attachShadow({ mode: 'open' });
+    }
+    else {
+        el.shadowRoot = el;
+    }
+};
+const hmrStart = (elm, cmpMeta, hmrVersionId) => {
+    // ¯\_(ツ)_/¯
+    const hostRef = getHostRef(elm);
+    // reset state flags to only have been connected
+    hostRef.$flags$ = 1 /* hasConnected */;
+    // TODO
+    // detatch any event listeners that may have been added
+    // because we're not passing an exact event name it'll
+    // remove all of this element's event, which is good
+    // create a callback for when this component finishes hmr
+    elm['s-hmr-load'] = () => {
+        // finished hmr for this element
+        delete elm['s-hmr-load'];
+    };
+    // re-initialize the component
+    initializeComponent(elm, hostRef, cmpMeta, hmrVersionId);
+};
+const patchCloneNode = (HostElementPrototype) => {
+    const orgCloneNode = HostElementPrototype.cloneNode;
+    HostElementPrototype.cloneNode = function (deep) {
+        const srcNode = this;
+        const isShadowDom = BUILD.shadowDom ? srcNode.shadowRoot && supportsShadow : false;
+        const clonedNode = orgCloneNode.call(srcNode, isShadowDom ? deep : false);
+        if (BUILD.slot && !isShadowDom && deep) {
+            let i = 0;
+            let slotted, nonStencilNode;
+            let stencilPrivates = ['s-id', 's-cr', 's-lr', 's-rc', 's-sc', 's-p', 's-cn', 's-sr', 's-sn', 's-hn', 's-ol', 's-nr', 's-si'];
+            for (; i < srcNode.childNodes.length; i++) {
+                slotted = srcNode.childNodes[i]['s-nr'];
+                nonStencilNode = stencilPrivates.every((privateField) => !srcNode.childNodes[i][privateField]);
+                if (slotted) {
+                    if (BUILD.appendChildSlotFix && clonedNode.__appendChild) {
+                        clonedNode.__appendChild(slotted.cloneNode(true));
+                    }
+                    else {
+                        clonedNode.appendChild(slotted.cloneNode(true));
+                    }
+                }
+                if (nonStencilNode) {
+                    clonedNode.appendChild(srcNode.childNodes[i].cloneNode(true));
+                }
+            }
+        }
+        return clonedNode;
+    };
+};
+const patchSlotAppendChild = (HostElementPrototype) => {
+    HostElementPrototype.__appendChild = HostElementPrototype.appendChild;
+    HostElementPrototype.appendChild = function (newChild) {
+        const slotName = (newChild['s-sn'] = getSlotName(newChild));
+        const slotNode = getHostSlotNode(this.childNodes, slotName);
+        if (slotNode) {
+            const slotChildNodes = getHostSlotChildNodes(slotNode, slotName);
+            const appendAfter = slotChildNodes[slotChildNodes.length - 1];
+            return appendAfter.parentNode.insertBefore(newChild, appendAfter.nextSibling);
+        }
+        return this.__appendChild(newChild);
+    };
+};
+const patchChildSlotNodes = (elm, cmpMeta) => {
+    class FakeNodeList extends Array {
+        item(n) {
+            return this[n];
+        }
+    }
+    if (cmpMeta.$flags$ & 8 /* needsShadowDomShim */) {
+        const childNodesFn = elm.__lookupGetter__('childNodes');
+        Object.defineProperty(elm, 'children', {
+            get() {
+                return this.childNodes.map((n) => n.nodeType === 1);
+            },
+        });
+        Object.defineProperty(elm, 'childElementCount', {
+            get() {
+                return elm.children.length;
+            },
+        });
+        Object.defineProperty(elm, 'childNodes', {
+            get() {
+                const childNodes = childNodesFn.call(this);
+                if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0 && getHostRef(this).$flags$ & 2 /* hasRendered */) {
+                    const result = new FakeNodeList();
+                    for (let i = 0; i < childNodes.length; i++) {
+                        const slot = childNodes[i]['s-nr'];
+                        if (slot) {
+                            result.push(slot);
+                        }
+                    }
+                    return result;
+                }
+                return FakeNodeList.from(childNodes);
+            },
+        });
+    }
+};
+const getSlotName = (node) => node['s-sn'] || (node.nodeType === 1 && node.getAttribute('slot')) || '';
+const getHostSlotNode = (childNodes, slotName) => {
+    let i = 0;
+    let childNode;
+    for (; i < childNodes.length; i++) {
+        childNode = childNodes[i];
+        if (childNode['s-sr'] && childNode['s-sn'] === slotName) {
+            return childNode;
+        }
+        childNode = getHostSlotNode(childNode.childNodes, slotName);
+        if (childNode) {
+            return childNode;
+        }
+    }
+    return null;
+};
+const getHostSlotChildNodes = (n, slotName) => {
+    const childNodes = [n];
+    while ((n = n.nextSibling) && n['s-sn'] === slotName) {
+        childNodes.push(n);
+    }
+    return childNodes;
 };
 const bootstrapLazy = (lazyBundles, options = {}) => {
-    const endBootstrap = createTime();
+    if (BUILD.profile && performance.mark) {
+        performance.mark('st:app:start');
+    }
+    installDevTools();
+    const endBootstrap = createTime('bootstrapLazy');
     const cmpTags = [];
     const exclude = options.exclude || [];
     const customElements = win.customElements;
@@ -1540,10 +2340,27 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
     const metaCharset = /*@__PURE__*/ head.querySelector('meta[charset]');
     const visibilityStyle = /*@__PURE__*/ doc.createElement('style');
     const deferredConnectedCallbacks = [];
+    const styles = /*@__PURE__*/ doc.querySelectorAll(`[${HYDRATED_STYLE_ID}]`);
     let appLoadFallback;
     let isBootstrapping = true;
+    let i = 0;
     Object.assign(plt, options);
     plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href;
+    if (BUILD.asyncQueue) {
+        if (options.syncQueue) {
+            plt.$flags$ |= 4 /* queueSync */;
+        }
+    }
+    if (BUILD.hydrateClientSide) {
+        // If the app is already hydrated there is not point to disable the
+        // async queue. This will improve the first input delay
+        plt.$flags$ |= 2 /* appLoaded */;
+    }
+    if (BUILD.hydrateClientSide && BUILD.shadowDom) {
+        for (; i < styles.length; i++) {
+            registerStyle(styles[i].getAttribute(HYDRATED_STYLE_ID), convertScopedToShadow(styles[i].innerHTML), true);
+        }
+    }
     lazyBundles.map(lazyBundle => lazyBundle[1].map(compactMeta => {
         const cmpMeta = {
             $flags$: compactMeta[0],
@@ -1551,19 +2368,22 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
             $members$: compactMeta[2],
             $listeners$: compactMeta[3],
         };
-        {
+        if (BUILD.member) {
             cmpMeta.$members$ = compactMeta[2];
         }
-        {
+        if (BUILD.hostListener) {
             cmpMeta.$listeners$ = compactMeta[3];
         }
-        {
+        if (BUILD.reflect) {
             cmpMeta.$attrsToReflect$ = [];
         }
-        {
+        if (BUILD.watchCallback) {
             cmpMeta.$watchers$ = {};
         }
-        const tagName =  cmpMeta.$tagName$;
+        if (BUILD.shadowDom && !supportsShadow && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
+            cmpMeta.$flags$ |= 8 /* needsShadowDomShim */;
+        }
+        const tagName = BUILD.transformTagName && options.transformTagName ? options.transformTagName(cmpMeta.$tagName$) : cmpMeta.$tagName$;
         const HostElement = class extends HTMLElement {
             // StencilLazyHost
             constructor(self) {
@@ -1571,16 +2391,28 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
                 super(self);
                 self = this;
                 registerHost(self, cmpMeta);
-                if ( cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
+                if (BUILD.shadowDom && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
                     // this component is using shadow dom
                     // and this browser supports shadow dom
                     // add the read-only property "shadowRoot" to the host element
                     // adding the shadow root build conditionals to minimize runtime
-                    {
-                        {
+                    if (supportsShadow) {
+                        if (BUILD.shadowDelegatesFocus) {
+                            self.attachShadow({
+                                mode: 'open',
+                                delegatesFocus: !!(cmpMeta.$flags$ & 16 /* shadowDelegatesFocus */),
+                            });
+                        }
+                        else {
                             self.attachShadow({ mode: 'open' });
                         }
                     }
+                    else if (!BUILD.hydrateServerSide && !('shadowRoot' in self)) {
+                        self.shadowRoot = self;
+                    }
+                }
+                if (BUILD.slotChildNodesFix) {
+                    patchChildSlotNodes(self, cmpMeta);
                 }
             }
             connectedCallback() {
@@ -1603,13 +2435,24 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
                 return getHostRef(this).$onReadyPromise$;
             }
         };
+        if (BUILD.cloneNodeFix) {
+            patchCloneNode(HostElement.prototype);
+        }
+        if (BUILD.appendChildSlotFix) {
+            patchSlotAppendChild(HostElement.prototype);
+        }
+        if (BUILD.hotModuleReplacement) {
+            HostElement.prototype['s-hmr'] = function (hmrVersionId) {
+                hmrStart(this, cmpMeta, hmrVersionId);
+            };
+        }
         cmpMeta.$lazyBundleId$ = lazyBundle[0];
         if (!exclude.includes(tagName) && !customElements.get(tagName)) {
             cmpTags.push(tagName);
             customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */));
         }
     }));
-    {
+    if (BUILD.hydratedClass || BUILD.hydratedAttribute) {
         visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS;
         visibilityStyle.setAttribute('data-styles', '');
         head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild);
@@ -1620,7 +2463,10 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
         deferredConnectedCallbacks.map(host => host.connectedCallback());
     }
     else {
-        {
+        if (BUILD.profile) {
+            plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30, 'timeout')));
+        }
+        else {
             plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30)));
         }
     }
@@ -1631,6 +2477,196 @@ const getAssetPath = (path) => {
     const assetUrl = new URL(path, plt.$resourcesUrl$);
     return assetUrl.origin !== win.location.origin ? assetUrl.href : assetUrl.pathname;
 };
+const setAssetPath = (path) => (plt.$resourcesUrl$ = path);
+const getConnect = (_ref, tagName) => {
+    const componentOnReady = () => {
+        let elm = doc.querySelector(tagName);
+        if (!elm) {
+            elm = doc.createElement(tagName);
+            doc.body.appendChild(elm);
+        }
+        return typeof elm.componentOnReady === 'function' ? elm.componentOnReady() : Promise.resolve(elm);
+    };
+    const create = (...args) => {
+        return componentOnReady().then(el => el.create(...args));
+    };
+    return {
+        create,
+        componentOnReady,
+    };
+};
+const getContext = (_elm, context) => {
+    if (context in Context) {
+        return Context[context];
+    }
+    else if (context === 'window') {
+        return win;
+    }
+    else if (context === 'document') {
+        return doc;
+    }
+    else if (context === 'isServer' || context === 'isPrerender') {
+        return BUILD.hydrateServerSide ? true : false;
+    }
+    else if (context === 'isClient') {
+        return BUILD.hydrateServerSide ? false : true;
+    }
+    else if (context === 'resourcesUrl' || context === 'publicPath') {
+        return getAssetPath('.');
+    }
+    else if (context === 'queue') {
+        return {
+            write: writeTask,
+            read: readTask,
+            tick: {
+                then(cb) {
+                    return nextTick(cb);
+                },
+            },
+        };
+    }
+    return undefined;
+};
+const insertVdomAnnotations = (doc, staticComponents) => {
+    if (doc != null) {
+        const docData = {
+            hostIds: 0,
+            rootLevelIds: 0,
+            staticComponents: new Set(staticComponents),
+        };
+        const orgLocationNodes = [];
+        parseVNodeAnnotations(doc, doc.body, docData, orgLocationNodes);
+        orgLocationNodes.forEach(orgLocationNode => {
+            if (orgLocationNode != null) {
+                const nodeRef = orgLocationNode['s-nr'];
+                let hostId = nodeRef['s-host-id'];
+                let nodeId = nodeRef['s-node-id'];
+                let childId = `${hostId}.${nodeId}`;
+                if (hostId == null) {
+                    hostId = 0;
+                    docData.rootLevelIds++;
+                    nodeId = docData.rootLevelIds;
+                    childId = `${hostId}.${nodeId}`;
+                    if (nodeRef.nodeType === 1 /* ElementNode */) {
+                        nodeRef.setAttribute(HYDRATE_CHILD_ID, childId);
+                    }
+                    else if (nodeRef.nodeType === 3 /* TextNode */) {
+                        if (hostId === 0) {
+                            const textContent = nodeRef.nodeValue.trim();
+                            if (textContent === '') {
+                                // useless whitespace node at the document root
+                                orgLocationNode.remove();
+                                return;
+                            }
+                        }
+                        const commentBeforeTextNode = doc.createComment(childId);
+                        commentBeforeTextNode.nodeValue = `${TEXT_NODE_ID}.${childId}`;
+                        nodeRef.parentNode.insertBefore(commentBeforeTextNode, nodeRef);
+                    }
+                }
+                let orgLocationNodeId = `${ORG_LOCATION_ID}.${childId}`;
+                const orgLocationParentNode = orgLocationNode.parentElement;
+                if (orgLocationParentNode) {
+                    if (orgLocationParentNode['s-en'] === '') {
+                        // ending with a "." means that the parent element
+                        // of this node's original location is a SHADOW dom element
+                        // and this node is apart of the root level light dom
+                        orgLocationNodeId += `.`;
+                    }
+                    else if (orgLocationParentNode['s-en'] === 'c') {
+                        // ending with a ".c" means that the parent element
+                        // of this node's original location is a SCOPED element
+                        // and this node is apart of the root level light dom
+                        orgLocationNodeId += `.c`;
+                    }
+                }
+                orgLocationNode.nodeValue = orgLocationNodeId;
+            }
+        });
+    }
+};
+const parseVNodeAnnotations = (doc, node, docData, orgLocationNodes) => {
+    if (node == null) {
+        return;
+    }
+    if (node['s-nr'] != null) {
+        orgLocationNodes.push(node);
+    }
+    if (node.nodeType === 1 /* ElementNode */) {
+        node.childNodes.forEach(childNode => {
+            const hostRef = getHostRef(childNode);
+            if (hostRef != null && !docData.staticComponents.has(childNode.nodeName.toLowerCase())) {
+                const cmpData = {
+                    nodeIds: 0,
+                };
+                insertVNodeAnnotations(doc, childNode, hostRef.$vnode$, docData, cmpData);
+            }
+            parseVNodeAnnotations(doc, childNode, docData, orgLocationNodes);
+        });
+    }
+};
+const insertVNodeAnnotations = (doc, hostElm, vnode, docData, cmpData) => {
+    if (vnode != null) {
+        const hostId = ++docData.hostIds;
+        hostElm.setAttribute(HYDRATE_ID, hostId);
+        if (hostElm['s-cr'] != null) {
+            hostElm['s-cr'].nodeValue = `${CONTENT_REF_ID}.${hostId}`;
+        }
+        if (vnode.$children$ != null) {
+            const depth = 0;
+            vnode.$children$.forEach((vnodeChild, index) => {
+                insertChildVNodeAnnotations(doc, vnodeChild, cmpData, hostId, depth, index);
+            });
+        }
+        if (hostElm && vnode && vnode.$elm$ && !hostElm.hasAttribute('c-id')) {
+            const parent = hostElm.parentElement;
+            if (parent && parent.childNodes) {
+                const parentChildNodes = Array.from(parent.childNodes);
+                const comment = parentChildNodes.find(node => node.nodeType === 8 /* CommentNode */ && node['s-sr']);
+                if (comment) {
+                    const index = parentChildNodes.indexOf(hostElm) - 1;
+                    vnode.$elm$.setAttribute(HYDRATE_CHILD_ID, `${comment['s-host-id']}.${comment['s-node-id']}.0.${index}`);
+                }
+            }
+        }
+    }
+};
+const insertChildVNodeAnnotations = (doc, vnodeChild, cmpData, hostId, depth, index) => {
+    const childElm = vnodeChild.$elm$;
+    if (childElm == null) {
+        return;
+    }
+    const nodeId = cmpData.nodeIds++;
+    const childId = `${hostId}.${nodeId}.${depth}.${index}`;
+    childElm['s-host-id'] = hostId;
+    childElm['s-node-id'] = nodeId;
+    if (childElm.nodeType === 1 /* ElementNode */) {
+        childElm.setAttribute(HYDRATE_CHILD_ID, childId);
+    }
+    else if (childElm.nodeType === 3 /* TextNode */) {
+        const parentNode = childElm.parentNode;
+        const nodeName = parentNode.nodeName;
+        if (nodeName !== 'STYLE' && nodeName !== 'SCRIPT') {
+            const textNodeId = `${TEXT_NODE_ID}.${childId}`;
+            const commentBeforeTextNode = doc.createComment(textNodeId);
+            parentNode.insertBefore(commentBeforeTextNode, childElm);
+        }
+    }
+    else if (childElm.nodeType === 8 /* CommentNode */) {
+        if (childElm['s-sr']) {
+            const slotName = childElm['s-sn'] || '';
+            const slotNodeId = `${SLOT_NODE_ID}.${childId}.${slotName}`;
+            childElm.nodeValue = slotNodeId;
+        }
+    }
+    if (vnodeChild.$children$ != null) {
+        const childDepth = depth + 1;
+        vnodeChild.$children$.forEach((vnode, index) => {
+            insertChildVNodeAnnotations(doc, vnode, cmpData, hostId, childDepth, index);
+        });
+    }
+};
+const Fragment = (_, children) => children;
 const hostRefs = new WeakMap();
 const getHostRef = (ref) => hostRefs.get(ref);
 const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef);
@@ -1641,25 +2677,39 @@ const registerHost = (elm, cmpMeta) => {
         $cmpMeta$: cmpMeta,
         $instanceValues$: new Map(),
     };
-    {
+    if (BUILD.isDev) {
+        hostRef.$renderCount$ = 0;
+    }
+    if (BUILD.method && BUILD.lazyLoad) {
         hostRef.$onInstancePromise$ = new Promise(r => (hostRef.$onInstanceResolve$ = r));
     }
-    {
+    if (BUILD.asyncLoading) {
         hostRef.$onReadyPromise$ = new Promise(r => (hostRef.$onReadyResolve$ = r));
         elm['s-p'] = [];
         elm['s-rc'] = [];
     }
-    addHostEventListeners(elm, hostRef, cmpMeta.$listeners$);
+    addHostEventListeners(elm, hostRef, cmpMeta.$listeners$, false);
     return hostRefs.set(elm, hostRef);
 };
 const isMemberInElement = (elm, memberName) => memberName in elm;
-const consoleError = (e, el) => ( 0, console.error)(e, el);
+const consoleError = (e, el) => (customError || console.error)(e, el);
+const STENCIL_DEV_MODE = BUILD.isTesting
+    ? ['STENCIL:'] // E2E testing
+    : ['%cstencil', 'color: white;background:#4c47ff;font-weight: bold; font-size:10px; padding:2px 6px; border-radius: 5px'];
+const consoleDevError = (...m) => console.error(...STENCIL_DEV_MODE, ...m);
+const consoleDevWarn = (...m) => console.warn(...STENCIL_DEV_MODE, ...m);
+const consoleDevInfo = (...m) => console.info(...STENCIL_DEV_MODE, ...m);
+const setErrorHandler = (handler) => customError = handler;
 const cmpModules = /*@__PURE__*/ new Map();
 const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
     // loadModuleImport
     const exportName = cmpMeta.$tagName$.replace(/-/g, '_');
     const bundleId = cmpMeta.$lazyBundleId$;
-    const module =  cmpModules.get(bundleId) ;
+    if (BUILD.isDev && typeof bundleId !== 'string') {
+        consoleDevError(`Trying to lazily load component <${cmpMeta.$tagName$}> with style mode "${hostRef.$modeName$}", but it does not exist.`);
+        return undefined;
+    }
+    const module = !BUILD.hotModuleReplacement ? cmpModules.get(bundleId) : false;
     if (module) {
         return module[exportName];
     }
@@ -1667,16 +2717,18 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
     /* webpackInclude: /\.entry\.js$/ */
     /* webpackExclude: /\.system\.entry\.js$/ */
     /* webpackMode: "lazy" */
-    `./${bundleId}.entry.js${ ''}`).then(importedModule => {
-        {
+    `./${bundleId}.entry.js${BUILD.hotModuleReplacement && hmrVersionId ? '?s-hmr=' + hmrVersionId : ''}`).then(importedModule => {
+        if (!BUILD.hotModuleReplacement) {
             cmpModules.set(bundleId, importedModule);
         }
         return importedModule[exportName];
     }, consoleError);
 };
 const styles = new Map();
+const modeResolutionChain = [];
 const queueDomReads = [];
 const queueDomWrites = [];
+const queueDomWritesLow = [];
 const queueTask = (queue, write) => (cb) => {
     queue.push(cb);
     if (!queuePending) {
@@ -1700,13 +2752,51 @@ const consume = (queue) => {
     }
     queue.length = 0;
 };
+const consumeTimeout = (queue, timeout) => {
+    let i = 0;
+    let ts = 0;
+    while (i < queue.length && (ts = performance.now()) < timeout) {
+        try {
+            queue[i++](ts);
+        }
+        catch (e) {
+            consoleError(e);
+        }
+    }
+    if (i === queue.length) {
+        queue.length = 0;
+    }
+    else if (i !== 0) {
+        queue.splice(0, i);
+    }
+};
 const flush = () => {
+    if (BUILD.asyncQueue) {
+        queueCongestion++;
+    }
     // always force a bunch of medium callbacks to run, but still have
     // a throttle on how many can run in a certain time
     // DOM READS!!!
     consume(queueDomReads);
     // DOM WRITES!!!
-    {
+    if (BUILD.asyncQueue) {
+        const timeout = (plt.$flags$ & 6 /* queueMask */) === 2 /* appLoaded */ ? performance.now() + 14 * Math.ceil(queueCongestion * (1.0 / 10.0)) : Infinity;
+        consumeTimeout(queueDomWrites, timeout);
+        consumeTimeout(queueDomWritesLow, timeout);
+        if (queueDomWrites.length > 0) {
+            queueDomWritesLow.push(...queueDomWrites);
+            queueDomWrites.length = 0;
+        }
+        if ((queuePending = queueDomReads.length + queueDomWrites.length + queueDomWritesLow.length > 0)) {
+            // still more to do yet, but we've run out of time
+            // let's let this thing cool off and try again in the next tick
+            plt.raf(flush);
+        }
+        else {
+            queueCongestion = 0;
+        }
+    }
+    else {
         consume(queueDomWrites);
         if ((queuePending = queueDomReads.length > 0)) {
             // still more to do yet, but we've run out of time
@@ -1716,6 +2806,13 @@ const flush = () => {
     }
 };
 const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb);
+const readTask = /*@__PURE__*/ queueTask(queueDomReads, false);
 const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true);
+const Build = {
+    isDev: BUILD.isDev ? true : false,
+    isBrowser: true,
+    isServer: false,
+    isTesting: BUILD.isTesting ? true : false,
+};
 
-export { Host as H, getAssetPath as a, bootstrapLazy as b, createEvent as c, forceUpdate as f, getElement as g, h, promiseResolve as p, registerInstance as r };
+export { BUILD as B, CSS as C, H, NAMESPACE as N, promiseResolve as a, bootstrapLazy as b, consoleDevInfo as c, doc as d, createEvent as e, Host as f, getElement as g, h, getAssetPath as i, forceUpdate as j, plt as p, registerInstance as r, win as w };