@sankhyalabs/sankhyablocks 10.1.0-dev.2 → 10.1.0-dev.20

package/dist/cjs/{index-1cf293c1.js → index-1894343a.js}

@@ -21,6 +21,8 @@ function _interopNamespace(e) {
 }
 
 const NAMESPACE = 'sankhyablocks';
+const BUILD = /* sankhyablocks */ { allRenderFn: true, appendChildSlotFix: false, asyncLoading: true, asyncQueue: false, attachStyles: true, cloneNodeFix: false, cmpDidLoad: true, cmpDidRender: true, cmpDidUnload: false, cmpDidUpdate: true, cmpShouldUpdate: true, cmpWillLoad: true, cmpWillRender: true, cmpWillUpdate: true, connectedCallback: true, constructableCSS: true, cssAnnotations: true, cssVarShim: false, devTools: false, disconnectedCallback: true, dynamicImportShim: false, element: false, event: true, hasRenderFn: true, hostListener: true, hostListenerTarget: true, hostListenerTargetBody: true, hostListenerTargetDocument: false, hostListenerTargetParent: false, hostListenerTargetWindow: true, hotModuleReplacement: false, hydrateClientSide: false, hydrateServerSide: false, hydratedAttribute: false, hydratedClass: true, initializeNextTick: false, invisiblePrehydration: false, isDebug: false, isDev: false, isTesting: false, lazyLoad: true, lifecycle: true, lifecycleDOMEvents: false, member: true, method: true, mode: false, observeAttribute: true, profile: false, prop: true, propBoolean: true, propMutable: true, propNumber: true, propString: true, reflect: true, safari10: false, scoped: true, scopedSlotTextContentFix: false, scriptDataOpts: false, shadowDelegatesFocus: false, shadowDom: true, shadowDomShim: false, slot: true, slotChildNodesFix: false, slotRelocation: true, state: true, style: true, svg: false, 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 = /* sankhyablocks */ {};
 
 /**
  * Virtual DOM patching algorithm based on Snabbdom by
@@ -33,26 +35,120 @@ const NAMESPACE = 'sankhyablocks';
 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 Build = {
+    isDev: BUILD.isDev ? true : false,
+    isBrowser: true,
+    isServer: false,
+    isTesting: BUILD.isTesting ? true : false,
+};
+const Context = {};
+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 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, 'mark').length === 0) {
+            performance.mark(key);
+        }
+        return () => {
+            if (performance.getEntriesByName(measureText, 'measure').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 /* HOST_FLAGS.hasRendered */),
+            hasConnected: !!(flags & 1 /* HOST_FLAGS.hasConnected */),
+            isWaitingForChildren: !!(flags & 4 /* HOST_FLAGS.isWaitingForChildren */),
+            isConstructingInstance: !!(flags & 8 /* HOST_FLAGS.isConstructingInstance */),
+            isQueuedForUpdate: !!(flags & 16 /* HOST_FLAGS.isQueuedForUpdate */),
+            hasInitializedComponent: !!(flags & 32 /* HOST_FLAGS.hasInitializedComponent */),
+            hasLoadedComponent: !!(flags & 64 /* HOST_FLAGS.hasLoadedComponent */),
+            isWatchReady: !!(flags & 128 /* HOST_FLAGS.isWatchReady */),
+            isListenReady: !!(flags & 256 /* HOST_FLAGS.isListenReady */),
+            needsRerender: !!(flags & 512 /* HOST_FLAGS.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 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';
 /**
@@ -63,6 +159,11 @@ const XLINK_NS = 'http://www.w3.org/1999/xlink';
  * Don't add values to these!!
  */
 const EMPTY_OBJ = {};
+/**
+ * Namespaces
+ */
+const SVG_NS = 'http://www.w3.org/2000/svg';
+const HTML_NS = 'http://www.w3.org/1999/xhtml';
 const isDef = (v) => v != null;
 const isComplexType = (o) => {
     // https://jsperf.com/typeof-fn-object/5
@@ -108,6 +209,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;
@@ -122,14 +228,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 =
@@ -141,7 +250,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);
     }
@@ -150,10 +264,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;
@@ -174,13 +288,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;
@@ -246,6 +360,235 @@ const convertToPrivate = (node) => {
     vnode.$name$ = node.vname;
     return vnode;
 };
+/**
+ * Validates the ordering of attributes on an input element
+ *
+ * @param inputElm the element to validate
+ */
+const validateInputProperties = (inputElm) => {
+    const props = Object.keys(inputElm);
+    const value = props.indexOf('value');
+    if (value === -1) {
+        return;
+    }
+    const typeIndex = props.indexOf('type');
+    const minIndex = props.indexOf('min');
+    const maxIndex = props.indexOf('max');
+    const stepIndex = props.indexOf('step');
+    if (value < typeIndex || value < minIndex || value < maxIndex || value < stepIndex) {
+        consoleDevWarn(`The "value" prop of <input> should be set after "min", "max", "type" and "step"`);
+    }
+};
+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 /* NODE_TYPE.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 /* NODE_TYPE.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 /* NODE_TYPE.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 /* NODE_TYPE.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 /* NODE_TYPE.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];
+        }
+    }
+};
+// 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$;
 /**
  * Parse a new property value for a given property type.
  *
@@ -272,16 +615,16 @@ const convertToPrivate = (node) => {
 const parsePropertyValue = (propValue, propType) => {
     // ensure this value is of the correct prop type
     if (propValue != null && !isComplexType(propValue)) {
-        if (propType & 4 /* MEMBER_FLAGS.Boolean */) {
+        if (BUILD.propBoolean && propType & 4 /* MEMBER_FLAGS.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 /* MEMBER_FLAGS.Number */) {
+        if (BUILD.propNumber && propType & 2 /* MEMBER_FLAGS.Number */) {
             // force it to be a number
             return parseFloat(propValue);
         }
-        if (propType & 1 /* MEMBER_FLAGS.String */) {
+        if (BUILD.propString && propType & 1 /* MEMBER_FLAGS.String */) {
             // could have been passed as a number or boolean
             // but we still want it as a string
             return String(propValue);
@@ -293,11 +636,14 @@ const parsePropertyValue = (propValue, propType) => {
     // so no need to change to a different type
     return propValue;
 };
-const getElement = (ref) => (getHostRef(ref).$hostElement$ );
+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 /* EVENT_FLAGS.Bubbles */),
                 composed: !!(flags & 2 /* EVENT_FLAGS.Composed */),
@@ -338,8 +684,11 @@ const registerStyle = (scopeId, cssText, allowCS) => {
 };
 const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
     var _a;
-    let scopeId = getScopeId(cmpMeta);
+    let scopeId = getScopeId(cmpMeta, mode);
     const 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 /* NODE_TYPE.DocumentFragment */ ? styleContainerNode : doc;
@@ -352,8 +701,25 @@ 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 /* CMP_FLAGS.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;
                     }
@@ -362,6 +728,9 @@ const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
                     if (nonce != null) {
                         styleElm.setAttribute('nonce', nonce);
                     }
+                    if (BUILD.hydrateServerSide || BUILD.hotModuleReplacement) {
+                        styleElm.setAttribute(HYDRATED_STYLE_ID, scopeId);
+                    }
                     styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link'));
                 }
                 if (appliedStyles) {
@@ -369,7 +738,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];
         }
     }
@@ -380,8 +749,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 /* CMP_FLAGS.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 /* CMP_FLAGS.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
@@ -391,13 +760,14 @@ const attachStyles = (hostRef) => {
         // DOM WRITE!!
         elm['s-sc'] = scopeId;
         elm.classList.add(scopeId + '-h');
-        if (flags & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+        if (BUILD.scoped && flags & 2 /* CMP_FLAGS.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 /* CMP_FLAGS.hasMode */ ? cmp.$tagName$ + '-' + mode : cmp.$tagName$);
+const convertScopedToShadow = (css) => css.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, '$1{');
 /**
  * Production setAccessor() function based on Preact by
  * Jason Miller (@developit)
@@ -410,19 +780,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 {
@@ -433,7 +803,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 {
@@ -442,15 +812,16 @@ 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 ) &&
+        else if (BUILD.vdomListener &&
+            (BUILD.lazyLoad ? !isProp : !elm.__lookupSetter__(memberName)) &&
             memberName[0] === 'o' &&
             memberName[1] === 'n') {
             // Event Handlers
@@ -489,7 +860,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) {
@@ -518,7 +889,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;
@@ -526,7 +897,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 {
@@ -536,7 +907,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
             }
             else if ((!isProp || flags & 4 /* VNODE_FLAGS.isHost */ || isSvg) && !isComplex) {
                 newValue = newValue === true ? '' : newValue;
-                if (xlink) {
+                if (BUILD.vdomXlink && xlink) {
                     elm.setAttributeNS(XLINK_NS, memberName, newValue);
                 }
                 else {
@@ -557,7 +928,7 @@ const updateElement = (oldVnode, newVnode, isSvgMode, memberName) => {
         : 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)) {
@@ -587,7 +958,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') {
@@ -602,25 +973,38 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
                     1 /* VNODE_FLAGS.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 /* VNODE_FLAGS.isSlotReference */) {
+    else if (BUILD.slotRelocation && newVNode.$flags$ & 1 /* VNODE_FLAGS.isSlotReference */) {
         // create a slot reference node
         elm = newVNode.$elm$ =
-            doc.createTextNode('');
+            BUILD.isDebug || BUILD.hydrateServerSide ? slotReferenceDebugNode(newVNode) : doc.createTextNode('');
     }
     else {
+        if (BUILD.svg && !isSvgMode) {
+            isSvgMode = newVNode.$tag$ === 'svg';
+        }
         // create element
-        elm = newVNode.$elm$ = (doc.createElement(newVNode.$flags$ & 2 /* VNODE_FLAGS.isSlotFallback */
+        elm = newVNode.$elm$ = (BUILD.svg
+            ? doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, BUILD.slotRelocation && newVNode.$flags$ & 2 /* VNODE_FLAGS.isSlotFallback */
+                ? 'slot-fb'
+                : newVNode.$tag$)
+            : doc.createElement(BUILD.slotRelocation && newVNode.$flags$ & 2 /* VNODE_FLAGS.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));
@@ -636,8 +1020,18 @@ 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;
+            }
+            else if (elm.tagName === 'foreignObject') {
+                // Reenter SVG context when we're exiting <foreignObject> element
+                isSvgMode = true;
+            }
+        }
     }
-    {
+    if (BUILD.slotRelocation) {
         elm['s-hn'] = hostTagName;
         if (newVNode.$flags$ & (2 /* VNODE_FLAGS.isSlotFallback */ | 1 /* VNODE_FLAGS.isSlotReference */)) {
             // remember the content reference comment
@@ -697,9 +1091,9 @@ const putBackInOriginalLocation = (parentElm, recursive) => {
  * creating DOM nodes (inclusive)
  */
 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) {
@@ -707,7 +1101,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);
             }
         }
     }
@@ -730,7 +1124,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;
@@ -876,7 +1270,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             //
             // In this situation we need to patch `newEndVnode` onto `oldStartVnode`
             // and move the DOM element for `oldStartVnode`.
-            if ((oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
+            if (BUILD.slotRelocation && (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
                 putBackInOriginalLocation(oldStartVnode.$elm$.parentNode, false);
             }
             patch(oldStartVnode, newEndVnode);
@@ -917,7 +1311,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             // (which will handle updating any changed attributes, reconciling their
             // children etc) but we also need to move the DOM node to which
             // `oldEndVnode` corresponds.
-            if ((oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
+            if (BUILD.slotRelocation && (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
                 putBackInOriginalLocation(oldEndVnode.$elm$.parentNode, false);
             }
             patch(oldEndVnode, newStartVnode);
@@ -940,7 +1334,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             // children which have the same key as the first node in the new
             // children.
             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;
@@ -948,7 +1342,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
                     }
                 }
             }
-            if (idxInOld >= 0) {
+            if (BUILD.vdomKey && idxInOld >= 0) {
                 // We found a node in the old children which matches up with the first
                 // node in the new children! So let's deal with that
                 elmToMove = oldCh[idxInOld];
@@ -975,9 +1369,12 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             }
             if (node) {
                 // if we created a new node then handle inserting it to the DOM
-                {
+                if (BUILD.slotRelocation) {
                     parentReferenceNode(oldStartVnode.$elm$).insertBefore(node, referenceNode(oldStartVnode.$elm$));
                 }
+                else {
+                    oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$);
+                }
             }
         }
     }
@@ -985,7 +1382,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
         // we have some more new nodes to add which don't match up with old nodes
         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) {
         // there are nodes in the `oldCh` array which no longer correspond to nodes
         // in the new array, so lets remove them (which entails cleaning up the
         // relevant DOM nodes)
@@ -1014,13 +1411,14 @@ const isSameVnode = (leftVNode, rightVNode) => {
     // 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 (leftVNode.$tag$ === rightVNode.$tag$) {
-        if (leftVNode.$tag$ === 'slot') {
+        if (BUILD.slotRelocation && leftVNode.$tag$ === 'slot') {
             return leftVNode.$name$ === rightVNode.$name$;
         }
         // this will be set if components in the build have `key` attrs set on them
-        {
+        if (BUILD.vdomKey) {
             return leftVNode.$key$ === rightVNode.$key$;
         }
+        return true;
     }
     return false;
 };
@@ -1047,9 +1445,14 @@ const patch = (oldVNode, newVNode) => {
     const tag = newVNode.$tag$;
     const text = newVNode.$text$;
     let defaultHolder;
-    if (text === null) {
-        {
-            if (tag === 'slot')
+    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;
+        }
+        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
@@ -1058,30 +1461,33 @@ 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
             // so we need to call `updateChildren` to reconcile them
             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 (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;
@@ -1219,7 +1625,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);
     }
@@ -1242,26 +1648,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 /* VNODE_FLAGS.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 /* CMP_FLAGS.shadowDomEncapsulation */) !== 0;
+        useNativeShadowDom = supportsShadow && (cmpMeta.$flags$ & 1 /* CMP_FLAGS.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 /* PLATFORM_FLAGS.isTmpDisconnected */;
@@ -1281,7 +1702,9 @@ const renderVdom = (hostRef, renderFnResults) => {
                     // add a reference node marking this node's original location
                     // keep a reference to this node for later lookups
                     orgLocationNode =
-                        doc.createTextNode('');
+                        BUILD.isDebug || BUILD.hydrateServerSide
+                            ? originalLocationDebugNode(nodeToRelocate)
+                            : doc.createTextNode('');
                     orgLocationNode['s-nr'] = nodeToRelocate;
                     nodeToRelocate.parentNode.insertBefore((nodeToRelocate['s-ol'] = orgLocationNode), nodeToRelocate);
                 }
@@ -1338,16 +1761,23 @@ const renderVdom = (hostRef, renderFnResults) => {
         relocateNodes.length = 0;
     }
 };
+// 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 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 /* HOST_FLAGS.isQueuedForUpdate */;
     }
-    if (hostRef.$flags$ & 4 /* HOST_FLAGS.isWaitingForChildren */) {
+    if (BUILD.asyncLoading && hostRef.$flags$ & 4 /* HOST_FLAGS.isWaitingForChildren */) {
         hostRef.$flags$ |= 512 /* HOST_FLAGS.needsRerender */;
         return;
     }
@@ -1356,30 +1786,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 /* HOST_FLAGS.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();
@@ -1390,15 +1824,46 @@ 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$);
-    {
-        callRender(hostRef, instance);
+    if (BUILD.isDev) {
+        hostRef.$flags$ |= 1024 /* HOST_FLAGS.devOnRender */;
+    }
+    if (BUILD.hydrateServerSide) {
+        await callRender(hostRef, instance, elm);
+    }
+    else {
+        callRender(hostRef, instance, elm);
+    }
+    if (BUILD.cssVarShim && plt.$cssShim$) {
+        plt.$cssShim$.updateHost(elm);
+    }
+    if (BUILD.isDev) {
+        hostRef.$renderCount$++;
+        hostRef.$flags$ &= ~1024 /* HOST_FLAGS.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 /* CMP_FLAGS.shadowDomEncapsulation */) {
+                    elm['s-en'] = '';
+                }
+                else if (hostRef.$cmpMeta$.$flags$ & 2 /* CMP_FLAGS.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
@@ -1407,7 +1872,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) {
@@ -1419,26 +1884,42 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
             childrenPromises.length = 0;
         }
     }
+    else {
+        postUpdateComponent(hostRef);
+    }
 };
 const callRender = (hostRef, instance, elm) => {
+    // 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 {
         renderingRef = instance;
-        instance = instance.render() ;
-        {
+        instance = allRenderFn ? instance.render() : instance.render && instance.render();
+        if (updatable && taskQueue) {
             hostRef.$flags$ &= ~16 /* HOST_FLAGS.isQueuedForUpdate */;
         }
-        {
+        if (updatable || lazyLoad) {
             hostRef.$flags$ |= 2 /* HOST_FLAGS.hasRendered */;
         }
-        {
-            {
+        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) {
+                    return Promise.resolve(instance).then((value) => renderVdom(hostRef, value));
+                }
+                else {
                     renderVdom(hostRef, instance);
                 }
             }
+            else {
+                elm.textContent = instance;
+            }
         }
     }
     catch (e) {
@@ -1452,40 +1933,68 @@ 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 /* HOST_FLAGS.devOnRender */;
+        }
         safeCall(instance, 'componentDidRender');
+        if (BUILD.isDev) {
+            hostRef.$flags$ &= ~1024 /* HOST_FLAGS.devOnRender */;
+        }
     }
+    emitLifecycleEvent(elm, 'componentDidRender');
     if (!(hostRef.$flags$ & 64 /* HOST_FLAGS.hasLoadedComponent */)) {
         hostRef.$flags$ |= 64 /* HOST_FLAGS.hasLoadedComponent */;
-        {
+        if (BUILD.asyncLoading && BUILD.cssAnnotations) {
             // DOM WRITE!
             addHydratedFlag(elm);
         }
-        {
+        if (BUILD.cmpDidLoad) {
+            if (BUILD.isDev) {
+                hostRef.$flags$ |= 2048 /* HOST_FLAGS.devOnDidLoad */;
+            }
             safeCall(instance, 'componentDidLoad');
+            if (BUILD.isDev) {
+                hostRef.$flags$ &= ~2048 /* HOST_FLAGS.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 /* HOST_FLAGS.devOnRender */;
+            }
             safeCall(instance, 'componentDidUpdate');
+            if (BUILD.isDev) {
+                hostRef.$flags$ &= ~1024 /* HOST_FLAGS.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;
@@ -1500,7 +2009,7 @@ const postUpdateComponent = (hostRef) => {
     // (⌐■_■)
 };
 const forceUpdate = (ref) => {
-    {
+    if (BUILD.updatable) {
         const hostRef = getHostRef(ref);
         const isConnected = hostRef.$hostElement$.isConnected;
         if (isConnected &&
@@ -1510,14 +2019,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 /* PLATFORM_FLAGS.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]) {
@@ -1533,27 +2049,61 @@ 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 getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName);
 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]);
     // explicitly check for NaN on both sides, as `NaN === NaN` is always false
     const areBothNaN = Number.isNaN(oldVal) && Number.isNaN(newVal);
     const didValueChange = newVal !== oldVal && !areBothNaN;
-    if ((!(flags & 8 /* HOST_FLAGS.isConstructingInstance */) || oldVal === undefined) && didValueChange) {
+    if ((!BUILD.lazyLoad || !(flags & 8 /* HOST_FLAGS.isConstructingInstance */) || oldVal === undefined) && didValueChange) {
         // 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 /* HOST_FLAGS.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 /* HOST_FLAGS.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 /* HOST_FLAGS.isWatchReady */) {
+            if (BUILD.watchCallback && cmpMeta.$watchers$ && flags & 128 /* HOST_FLAGS.isWatchReady */) {
                 const watchMethods = cmpMeta.$watchers$[propName];
                 if (watchMethods) {
                     // this instance is watching for when this property changed
@@ -1568,8 +2118,9 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
                     });
                 }
             }
-            if ((flags & (2 /* HOST_FLAGS.hasRendered */ | 16 /* HOST_FLAGS.isQueuedForUpdate */)) === 2 /* HOST_FLAGS.hasRendered */) {
-                if (instance.componentShouldUpdate) {
+            if (BUILD.updatable &&
+                (flags & (2 /* HOST_FLAGS.hasRendered */ | 16 /* HOST_FLAGS.isQueuedForUpdate */)) === 2 /* HOST_FLAGS.hasRendered */) {
+                if (BUILD.cmpShouldUpdate && instance.componentShouldUpdate) {
                     if (instance.componentShouldUpdate(newVal, oldVal, propName) === false) {
                         return;
                     }
@@ -1594,16 +2145,17 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
  * @returns a reference to the same constructor passed in (but now mutated)
  */
 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 /* MEMBER_FLAGS.Prop */ ||
-                    ((flags & 2 /* PROXY_FLAGS.proxyState */) && memberFlags & 32 /* MEMBER_FLAGS.State */))) {
+            if ((BUILD.prop || BUILD.state) &&
+                (memberFlags & 31 /* MEMBER_FLAGS.Prop */ ||
+                    ((!BUILD.lazyLoad || flags & 2 /* PROXY_FLAGS.proxyState */) && memberFlags & 32 /* MEMBER_FLAGS.State */))) {
                 // proxyComponent - prop
                 Object.defineProperty(prototype, memberName, {
                     get() {
@@ -1611,6 +2163,21 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                         return getValue(this, memberName);
                     },
                     set(newValue) {
+                        // only during dev time
+                        if (BUILD.isDev) {
+                            const ref = getHostRef(this);
+                            if (
+                            // we are proxying the instance (not element)
+                            (flags & 1 /* PROXY_FLAGS.isElementConstructor */) === 0 &&
+                                // the element is not constructing
+                                (ref.$flags$ & 8 /* HOST_FLAGS.isConstructingInstance */) === 0 &&
+                                // the member is a prop
+                                (memberFlags & 31 /* MEMBER_FLAGS.Prop */) !== 0 &&
+                                // the member is not mutable
+                                (memberFlags & 1024 /* MEMBER_FLAGS.Mutable */) === 0) {
+                                consoleDevWarn(`@Prop() "${memberName}" on <${cmpMeta.$tagName$}> is immutable but was modified from within the component.\nMore information: https://stenciljs.com/docs/properties#prop-mutability`);
+                            }
+                        }
                         // proxyComponent, set value
                         setValue(this, memberName, newValue, cmpMeta);
                     },
@@ -1618,7 +2185,9 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                     enumerable: true,
                 });
             }
-            else if (flags & 1 /* PROXY_FLAGS.isElementConstructor */ &&
+            else if (BUILD.lazyLoad &&
+                BUILD.method &&
+                flags & 1 /* PROXY_FLAGS.isElementConstructor */ &&
                 memberFlags & 64 /* MEMBER_FLAGS.Method */) {
                 // proxyComponent - method
                 Object.defineProperty(prototype, memberName, {
@@ -1629,7 +2198,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                 });
             }
         });
-        if ((flags & 1 /* PROXY_FLAGS.isElementConstructor */)) {
+        if (BUILD.observeAttribute && (!BUILD.lazyLoad || flags & 1 /* PROXY_FLAGS.isElementConstructor */)) {
             const attrNameToPropName = new Map();
             prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) {
                 plt.jmp(() => {
@@ -1689,7 +2258,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                 .map(([propName, m]) => {
                 const attrName = m[1] || propName;
                 attrNameToPropName.set(attrName, propName);
-                if (m[0] & 512 /* MEMBER_FLAGS.ReflectAttr */) {
+                if (BUILD.reflect && m[0] & 512 /* MEMBER_FLAGS.ReflectAttr */) {
                     cmpMeta.$attrsToReflect$.push([propName, attrName]);
                 }
                 return attrName;
@@ -1700,25 +2269,29 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
 };
 const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => {
     // initializeComponent
-    if ((hostRef.$flags$ & 32 /* HOST_FLAGS.hasInitializedComponent */) === 0) {
-        {
+    if ((BUILD.lazyLoad || BUILD.hydrateServerSide || BUILD.style) &&
+        (hostRef.$flags$ & 32 /* HOST_FLAGS.hasInitializedComponent */) === 0) {
+        if (BUILD.lazyLoad || BUILD.hydrateClientSide) {
             // we haven't initialized this element yet
             hostRef.$flags$ |= 32 /* HOST_FLAGS.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've 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 /* PROXY_FLAGS.proxyState */);
@@ -1728,7 +2301,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 /* HOST_FLAGS.isConstructingInstance */;
             }
             // construct the lazy-loaded component implementation
@@ -1741,21 +2314,42 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) =>
             catch (e) {
                 consoleError(e);
             }
-            {
+            if (BUILD.member) {
                 hostRef.$flags$ &= ~8 /* HOST_FLAGS.isConstructingInstance */;
             }
-            {
+            if (BUILD.watchCallback) {
                 hostRef.$flags$ |= 128 /* HOST_FLAGS.isWatchReady */;
             }
             endNewInstance();
             fireConnectedCallback(hostRef.$lazyInstance$);
         }
-        if (Cstr.style) {
+        else {
+            // sync constructor component
+            Cstr = elm.constructor;
+            hostRef.$flags$ |= 32 /* HOST_FLAGS.hasInitializedComponent */;
+            // wait for the CustomElementRegistry to mark the component as ready before setting `isWatchReady`. Otherwise,
+            // watchers may fire prematurely if `customElements.get()`/`customElements.whenDefined()` resolves _before_
+            // Stencil has completed instantiating the component.
+            customElements.whenDefined(cmpMeta.$tagName$).then(() => (hostRef.$flags$ |= 128 /* HOST_FLAGS.isWatchReady */));
+        }
+        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 /* CMP_FLAGS.needsShadowDomShim */) {
+                    style = await Promise.resolve().then(function () { return require('./shadow-css-7e3e0ab1.js'); }).then((m) => m.scopeCss(style, scopeId, false));
+                }
                 registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */));
                 endRegisterStyles();
             }
@@ -1764,7 +2358,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 initial 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
@@ -1778,7 +2372,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) =>
     }
 };
 const fireConnectedCallback = (instance) => {
-    {
+    if (BUILD.lazyLoad && BUILD.connectedCallback) {
         safeCall(instance, 'connectedCallback');
     }
 };
@@ -1787,26 +2381,49 @@ 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 /* HOST_FLAGS.hasConnected */)) {
             // first time this component has connected
             hostRef.$flags$ |= 1 /* HOST_FLAGS.hasConnected */;
-            {
+            let hostId;
+            if (BUILD.hydrateClientSide) {
+                hostId = elm.getAttribute(HYDRATE_ID);
+                if (hostId) {
+                    if (BUILD.shadowDom && supportsShadow && cmpMeta.$flags$ & 1 /* CMP_FLAGS.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 /* CMP_FLAGS.hasSlotRelocation */ | 8 /* CMP_FLAGS.needsShadowDomShim */))) {
+                if (BUILD.hydrateServerSide ||
+                    ((BUILD.slot || BUILD.shadowDom) &&
+                        cmpMeta.$flags$ & (4 /* CMP_FLAGS.hasSlotRelocation */ | 8 /* CMP_FLAGS.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 (ancestorComponent['s-p']) {
+                    if ((BUILD.hydrateClientSide &&
+                        ancestorComponent.nodeType === 1 /* NODE_TYPE.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
                         attachToAncestor(hostRef, (hostRef.$ancestorComponent$ = ancestorComponent));
@@ -1816,7 +2433,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.hydrateServerSide && cmpMeta.$members$) {
                 Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {
                     if (memberFlags & 31 /* MEMBER_FLAGS.Prop */ && elm.hasOwnProperty(memberName)) {
                         const value = elm[memberName];
@@ -1825,7 +2442,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);
             }
         }
@@ -1833,7 +2457,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$);
         }
@@ -1847,28 +2471,317 @@ 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 /* PLATFORM_FLAGS.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 /* CMP_FLAGS.shadowDomEncapsulation */) {
+        cmpMeta.$flags$ |= 8 /* CMP_FLAGS.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);
+            }
+        },
+        __attachShadow() {
+            if (supportsShadow) {
+                if (BUILD.shadowDelegatesFocus) {
+                    this.attachShadow({
+                        mode: 'open',
+                        delegatesFocus: !!(cmpMeta.$flags$ & 16 /* CMP_FLAGS.shadowDelegatesFocus */),
+                    });
+                }
+                else {
+                    this.attachShadow({ mode: 'open' });
+                }
+            }
+            else {
+                this.shadowRoot = this;
+            }
+        },
+    });
+    Cstr.is = cmpMeta.$tagName$;
+    return proxyComponent(Cstr, cmpMeta, 1 /* PROXY_FLAGS.isElementConstructor */ | 2 /* PROXY_FLAGS.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 /* CMP_FLAGS.shadowDomEncapsulation */));
+                }
+                hostRef.$modeName$ = mode;
+                elm.classList.remove(oldScopeId + '-h', oldScopeId + '-s');
+                attachStyles(hostRef);
+                forceUpdate(elm);
+            }
+        }
     }
 };
+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;
+            const 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);
+    };
+};
+/**
+ * Patches the text content of an unnamed slotted node inside a scoped component
+ * @param hostElementPrototype the `Element` to be patched
+ * @param cmpMeta component runtime metadata used to determine if the component should be patched or not
+ */
+const patchTextContent = (hostElementPrototype, cmpMeta) => {
+    if (BUILD.scoped && cmpMeta.$flags$ & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+        const descriptor = Object.getOwnPropertyDescriptor(Node.prototype, 'textContent');
+        Object.defineProperty(hostElementPrototype, '__textContent', descriptor);
+        Object.defineProperty(hostElementPrototype, 'textContent', {
+            get() {
+                var _a;
+                // get the 'default slot', which would be the first slot in a shadow tree (if we were using one), whose name is
+                // the empty string
+                const slotNode = getHostSlotNode(this.childNodes, '');
+                // when a slot node is found, the textContent _may_ be found in the next sibling (text) node, depending on how
+                // nodes were reordered during the vdom render. first try to get the text content from the sibling.
+                if (((_a = slotNode === null || slotNode === void 0 ? void 0 : slotNode.nextSibling) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* NODE_TYPES.TEXT_NODE */) {
+                    return slotNode.nextSibling.textContent;
+                }
+                else if (slotNode) {
+                    return slotNode.textContent;
+                }
+                else {
+                    // fallback to the original implementation
+                    return this.__textContent;
+                }
+            },
+            set(value) {
+                var _a;
+                // get the 'default slot', which would be the first slot in a shadow tree (if we were using one), whose name is
+                // the empty string
+                const slotNode = getHostSlotNode(this.childNodes, '');
+                // when a slot node is found, the textContent _may_ need to be placed in the next sibling (text) node,
+                // depending on how nodes were reordered during the vdom render. first try to set the text content on the
+                // sibling.
+                if (((_a = slotNode === null || slotNode === void 0 ? void 0 : slotNode.nextSibling) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* NODE_TYPES.TEXT_NODE */) {
+                    slotNode.nextSibling.textContent = value;
+                }
+                else if (slotNode) {
+                    slotNode.textContent = value;
+                }
+                else {
+                    // we couldn't find a slot, but that doesn't mean that there isn't one. if this check ran before the DOM
+                    // loaded, we could have missed it. check for a content reference element on the scoped component and insert
+                    // it there
+                    this.__textContent = value;
+                    const contentRefElm = this['s-cr'];
+                    if (contentRefElm) {
+                        this.insertBefore(contentRefElm, this.firstChild);
+                    }
+                }
+            },
+        });
+    }
+};
+const patchChildSlotNodes = (elm, cmpMeta) => {
+    class FakeNodeList extends Array {
+        item(n) {
+            return this[n];
+        }
+    }
+    if (cmpMeta.$flags$ & 8 /* CMP_FLAGS.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 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0 &&
+                    getHostRef(this).$flags$ & 2 /* HOST_FLAGS.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')) || '';
+/**
+ * Recursively searches a series of child nodes for a slot with the provided name.
+ * @param childNodes the nodes to search for a slot with a specific name.
+ * @param slotName the name of the slot to match on.
+ * @returns a reference to the slot node that matches the provided name, `null` otherwise
+ */
+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 hmrStart = (elm, cmpMeta, hmrVersionId) => {
+    // ¯\_(ツ)_/¯
+    const hostRef = getHostRef(elm);
+    // reset state flags to only have been connected
+    hostRef.$flags$ = 1 /* HOST_FLAGS.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 bootstrapLazy = (lazyBundles, options = {}) => {
     var _a;
-    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;
@@ -1876,10 +2789,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 /* PLATFORM_FLAGS.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 /* PLATFORM_FLAGS.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 = {
@@ -1888,19 +2818,24 @@ 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 /* CMP_FLAGS.shadowDomEncapsulation */) {
+                cmpMeta.$flags$ |= 8 /* CMP_FLAGS.needsShadowDomShim */;
+            }
+            const tagName = BUILD.transformTagName && options.transformTagName
+                ? options.transformTagName(cmpMeta.$tagName$)
+                : cmpMeta.$tagName$;
             const HostElement = class extends HTMLElement {
                 // StencilLazyHost
                 constructor(self) {
@@ -1908,16 +2843,28 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
                     super(self);
                     self = this;
                     registerHost(self, cmpMeta);
-                    if (cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) {
+                    if (BUILD.shadowDom && cmpMeta.$flags$ & 1 /* CMP_FLAGS.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 /* CMP_FLAGS.shadowDelegatesFocus */),
+                                });
+                            }
+                            else {
                                 self.attachShadow({ mode: 'open' });
                             }
                         }
+                        else if (!BUILD.hydrateServerSide && !('shadowRoot' in self)) {
+                            self.shadowRoot = self;
+                        }
+                    }
+                    if (BUILD.slotChildNodesFix) {
+                        patchChildSlotNodes(self, cmpMeta);
                     }
                 }
                 connectedCallback() {
@@ -1940,6 +2887,20 @@ 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);
+                };
+            }
+            if (BUILD.scopedSlotTextContentFix) {
+                patchTextContent(HostElement.prototype, cmpMeta);
+            }
             cmpMeta.$lazyBundleId$ = lazyBundle[0];
             if (!exclude.includes(tagName) && !customElements.get(tagName)) {
                 cmpTags.push(tagName);
@@ -1947,7 +2908,7 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
             }
         });
     });
-    {
+    if (BUILD.invisiblePrehydration && (BUILD.hydratedClass || BUILD.hydratedAttribute)) {
         visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS;
         visibilityStyle.setAttribute('data-styles', '');
         // Apply CSP nonce to the style tag if it exists
@@ -1963,18 +2924,89 @@ 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)));
         }
     }
     // Fallback appLoad event
     endBootstrap();
 };
+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 Fragment = (_, children) => children;
 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 /* LISTENER_FLAGS.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 /* LISTENER_FLAGS.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);
@@ -1984,7 +3016,7 @@ const addHostEventListeners = (elm, hostRef, listeners, attachParentListeners) =
 };
 const hostListenerProxy = (hostRef, methodName) => (ev) => {
     try {
-        {
+        if (BUILD.lazyLoad) {
             if (hostRef.$flags$ & 256 /* HOST_FLAGS.isListenReady */) {
                 // instance is ready, let's call it's member method for this event
                 hostRef.$lazyInstance$[methodName](ev);
@@ -1993,20 +3025,32 @@ 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 & 8 /* LISTENER_FLAGS.TargetWindow */)
+    if (BUILD.hostListenerTargetDocument && flags & 4 /* LISTENER_FLAGS.TargetDocument */)
+        return doc;
+    if (BUILD.hostListenerTargetWindow && flags & 8 /* LISTENER_FLAGS.TargetWindow */)
         return win;
-    if (flags & 16 /* LISTENER_FLAGS.TargetBody */)
+    if (BUILD.hostListenerTargetBody && flags & 16 /* LISTENER_FLAGS.TargetBody */)
         return doc.body;
+    if (BUILD.hostListenerTargetParent && flags & 32 /* LISTENER_FLAGS.TargetParent */)
+        return elm.parentElement;
     return elm;
 };
 // prettier-ignore
-const hostListenerOpts = (flags) => (flags & 2 /* LISTENER_FLAGS.Capture */) !== 0;
+const hostListenerOpts = (flags) => supportsListenerOptions
+    ? ({
+        passive: (flags & 1 /* LISTENER_FLAGS.Passive */) !== 0,
+        capture: (flags & 2 /* LISTENER_FLAGS.Capture */) !== 0,
+    })
+    : (flags & 2 /* LISTENER_FLAGS.Capture */) !== 0;
 /**
  * Assigns the given value to the nonce property on the runtime platform object.
  * During runtime, this value is used to set the nonce attribute on all dynamically created script and style tags.
@@ -2014,6 +3058,146 @@ const hostListenerOpts = (flags) => (flags & 2 /* LISTENER_FLAGS.Capture */) !==
  * @returns void
  */
 const setNonce = (nonce) => (plt.$nonce$ = nonce);
+const setPlatformOptions = (opts) => Object.assign(plt, opts);
+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 /* NODE_TYPE.ElementNode */) {
+                        nodeRef.setAttribute(HYDRATE_CHILD_ID, childId);
+                    }
+                    else if (nodeRef.nodeType === 3 /* NODE_TYPE.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 /* NODE_TYPE.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 /* NODE_TYPE.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 /* NODE_TYPE.ElementNode */) {
+        childElm.setAttribute(HYDRATE_CHILD_ID, childId);
+    }
+    else if (childElm.nodeType === 3 /* NODE_TYPE.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 /* NODE_TYPE.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 hostRefs = /*@__PURE__*/ new WeakMap();
 const getHostRef = (ref) => hostRefs.get(ref);
 const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef);
@@ -2024,25 +3208,42 @@ 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];
     }
@@ -2126,6 +3327,10 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
           return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
             /* webpackMode: "lazy" */
             './snk-custom-slot-elements.cjs.entry.js')); }).then(processMod, consoleError);
+        case 'snk-custom-slot-guide.cjs':
+          return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+            /* webpackMode: "lazy" */
+            './snk-custom-slot-guide.cjs.entry.js')); }).then(processMod, consoleError);
         case 'snk-entity-list.cjs':
           return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
             /* webpackMode: "lazy" */
@@ -2249,16 +3454,20 @@ 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 = /*@__PURE__*/ new Map();
+const modeResolutionChain = [];
 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$: '',
@@ -2268,8 +3477,27 @@ const plt = {
     rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
     ce: (eventName, opts) => new CustomEvent(eventName, opts),
 };
+const setPlatformHelpers = (helpers) => {
+    Object.assign(plt, helpers);
+};
+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 supportsConstructableStylesheets = /*@__PURE__*/ (() => {
+const supportsConstructableStylesheets = BUILD.constructableCSS
+    ? /*@__PURE__*/ (() => {
         try {
             new CSSStyleSheet();
             return typeof new CSSStyleSheet().replaceSync === 'function';
@@ -2277,9 +3505,10 @@ const supportsConstructableStylesheets = /*@__PURE__*/ (() => {
         catch (e) { }
         return false;
     })()
-    ;
+    : false;
 const queueDomReads = [];
 const queueDomWrites = [];
+const queueDomWritesLow = [];
 const queueTask = (queue, write) => (cb) => {
     queue.push(cb);
     if (!queuePending) {
@@ -2303,13 +3532,53 @@ 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 /* PLATFORM_FLAGS.queueMask */) === 2 /* PLATFORM_FLAGS.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
@@ -2319,16 +3588,91 @@ const flush = () => {
     }
 };
 const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb);
+const readTask = /*@__PURE__*/ queueTask(queueDomReads, false);
 const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true);
 
+const StencilCore = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Build: Build,
+  CSS: CSS,
+  Context: Context,
+  Fragment: Fragment,
+  H: H,
+  HTMLElement: H,
+  Host: Host,
+  STENCIL_DEV_MODE: STENCIL_DEV_MODE,
+  addHostEventListeners: addHostEventListeners,
+  bootstrapLazy: bootstrapLazy,
+  cmpModules: cmpModules,
+  connectedCallback: connectedCallback,
+  consoleDevError: consoleDevError,
+  consoleDevInfo: consoleDevInfo,
+  consoleDevWarn: consoleDevWarn,
+  consoleError: consoleError,
+  createEvent: createEvent,
+  defineCustomElement: defineCustomElement,
+  disconnectedCallback: disconnectedCallback,
+  doc: doc,
+  forceModeUpdate: forceModeUpdate,
+  forceUpdate: forceUpdate,
+  getAssetPath: getAssetPath,
+  getConnect: getConnect,
+  getContext: getContext,
+  getElement: getElement,
+  getHostRef: getHostRef,
+  getMode: getMode,
+  getRenderingRef: getRenderingRef,
+  getValue: getValue,
+  h: h,
+  insertVdomAnnotations: insertVdomAnnotations,
+  isMemberInElement: isMemberInElement,
+  loadModule: loadModule,
+  modeResolutionChain: modeResolutionChain,
+  nextTick: nextTick,
+  parsePropertyValue: parsePropertyValue,
+  plt: plt,
+  postUpdateComponent: postUpdateComponent,
+  promiseResolve: promiseResolve,
+  proxyComponent: proxyComponent,
+  proxyCustomElement: proxyCustomElement,
+  readTask: readTask,
+  registerHost: registerHost,
+  registerInstance: registerInstance,
+  renderVdom: renderVdom,
+  setAssetPath: setAssetPath,
+  setErrorHandler: setErrorHandler,
+  setMode: setMode,
+  setNonce: setNonce,
+  setPlatformHelpers: setPlatformHelpers,
+  setPlatformOptions: setPlatformOptions,
+  setValue: setValue,
+  styles: styles,
+  supportsConstructableStylesheets: supportsConstructableStylesheets,
+  supportsListenerOptions: supportsListenerOptions,
+  supportsShadow: supportsShadow,
+  win: win,
+  writeTask: writeTask,
+  BUILD: BUILD,
+  Env: Env,
+  NAMESPACE: NAMESPACE
+});
+
+exports.BUILD = BUILD;
+exports.CSS = CSS;
 exports.Fragment = Fragment;
+exports.H = H;
 exports.Host = Host;
+exports.NAMESPACE = NAMESPACE;
+exports.StencilCore = StencilCore;
 exports.bootstrapLazy = bootstrapLazy;
+exports.consoleDevInfo = consoleDevInfo;
 exports.createEvent = createEvent;
+exports.doc = doc;
 exports.forceUpdate = forceUpdate;
 exports.getElement = getElement;
-exports.getRenderingRef = getRenderingRef;
 exports.h = h;
+exports.plt = plt;
 exports.promiseResolve = promiseResolve;
 exports.registerInstance = registerInstance;
 exports.setNonce = setNonce;
+exports.win = win;