@pine-ds/core 1.2.0 → 1.3.0-dev.0

package/dist/{cjs/index-ed42e2ee.js → pine-core/index-cccc19b7.js}

@@ -1,27 +1,6 @@
-'use strict';
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () {
-            return e[k];
-          }
-        });
-      }
-    });
-  }
-  n['default'] = e;
-  return Object.freeze(n);
-}
-
 const NAMESPACE = 'pine-core';
-const BUILD = /* pine-core */ { allRenderFn: true, appendChildSlotFix: false, asyncLoading: true, asyncQueue: false, attachStyles: true, cloneNodeFix: false, cmpDidLoad: true, cmpDidRender: true, cmpDidUnload: false, cmpDidUpdate: true, cmpShouldUpdate: false, cmpWillLoad: true, cmpWillRender: true, cmpWillUpdate: false, connectedCallback: true, constructableCSS: true, cssAnnotations: true, devTools: false, disconnectedCallback: true, element: false, event: true, experimentalScopedSlotChanges: false, experimentalSlotFixes: false, formAssociated: false, hasRenderFn: true, hostListener: true, hostListenerTarget: true, hostListenerTargetBody: true, hostListenerTargetDocument: false, hostListenerTargetParent: false, hostListenerTargetWindow: false, hotModuleReplacement: false, hydrateClientSide: true, hydrateServerSide: false, hydratedAttribute: false, hydratedClass: true, initializeNextTick: false, invisiblePrehydration: true, 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, scoped: true, scopedSlotTextContentFix: false, scriptDataOpts: false, shadowDelegatesFocus: false, shadowDom: true, slot: true, slotChildNodesFix: false, slotRelocation: true, state: true, style: true, svg: true, taskQueue: true, transformTagName: false, updatable: true, vdomAttribute: true, vdomClass: true, vdomFunctional: true, vdomKey: true, vdomListener: true, vdomPropOrAttr: true, vdomRef: true, vdomRender: true, vdomStyle: true, vdomText: true, vdomXlink: true, watchCallback: true };
+const BUILD = /* pine-core */ { allRenderFn: true, appendChildSlotFix: false, asyncLoading: true, asyncQueue: false, attachStyles: true, cloneNodeFix: false, cmpDidLoad: true, cmpDidRender: true, cmpDidUnload: false, cmpDidUpdate: true, cmpShouldUpdate: false, cmpWillLoad: true, cmpWillRender: true, cmpWillUpdate: false, connectedCallback: false, constructableCSS: false, cssAnnotations: true, devTools: true, disconnectedCallback: false, element: false, event: true, experimentalScopedSlotChanges: false, experimentalSlotFixes: false, formAssociated: false, hasRenderFn: true, hostListener: true, hostListenerTarget: true, hostListenerTargetBody: true, hostListenerTargetDocument: false, hostListenerTargetParent: false, hostListenerTargetWindow: false, hotModuleReplacement: true, hydrateClientSide: true, hydrateServerSide: false, hydratedAttribute: false, hydratedClass: true, initializeNextTick: false, invisiblePrehydration: true, isDebug: false, isDev: true, isTesting: false, lazyLoad: true, lifecycle: true, lifecycleDOMEvents: false, member: true, method: true, mode: false, observeAttribute: true, profile: true, prop: true, propBoolean: true, propMutable: true, propNumber: true, propString: true, reflect: true, scoped: true, scopedSlotTextContentFix: false, scriptDataOpts: false, shadowDelegatesFocus: false, shadowDom: true, slot: true, slotChildNodesFix: false, slotRelocation: true, state: true, style: true, svg: true, taskQueue: true, transformTagName: false, updatable: true, vdomAttribute: true, vdomClass: true, vdomFunctional: true, vdomKey: true, vdomListener: true, vdomPropOrAttr: true, vdomRef: true, vdomRender: true, vdomStyle: true, vdomText: true, vdomXlink: true, watchCallback: true };
+const Env = /* pine-core */ {};
 
 /**
  * Virtual DOM patching algorithm based on Snabbdom by
@@ -34,25 +13,112 @@ const BUILD = /* pine-core */ { allRenderFn: true, appendChildSlotFix: false, as
 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 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';
@@ -69,6 +135,12 @@ const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}';
  */
 const SLOT_FB_CSS = 'slot-fb{display:contents}slot-fb[hidden]{display:none}';
 const XLINK_NS = 'http://www.w3.org/1999/xlink';
+const FORM_ASSOCIATED_CUSTOM_ELEMENT_CALLBACKS = [
+    'formAssociatedCallback',
+    'formResetCallback',
+    'formDisabledCallback',
+    'formStateRestoreCallback',
+];
 /**
  * Default style mode id
  */
@@ -134,6 +206,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;
@@ -148,14 +225,17 @@ const h = (nodeName, vnodeData, ...children) => {
     };
     walk(children);
     if (vnodeData) {
-        if (vnodeData.key) {
+        if (BUILD.isDev && nodeName === 'input') {
+            validateInputProperties(vnodeData);
+        }
+        if (BUILD.vdomKey && vnodeData.key) {
             key = vnodeData.key;
         }
-        if (vnodeData.name) {
+        if (BUILD.slotRelocation && vnodeData.name) {
             slotName = vnodeData.name;
         }
         // normalize class / className attributes
-        {
+        if (BUILD.vdomClass) {
             const classData = vnodeData.className || vnodeData.class;
             if (classData) {
                 vnodeData.class =
@@ -167,7 +247,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);
     }
@@ -176,10 +261,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;
@@ -200,13 +285,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;
@@ -272,6 +357,25 @@ 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"`);
+    }
+};
 /**
  * Entrypoint of the client-side hydration process. Facilitates calls to hydrate the
  * document and all its nodes.
@@ -288,7 +392,7 @@ const initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {
     const shadowRoot = hostElm.shadowRoot;
     const childRenderNodes = [];
     const slotNodes = [];
-    const shadowRootNodes = shadowRoot ? [] : null;
+    const shadowRootNodes = BUILD.shadowDom && shadowRoot ? [] : null;
     const vnode = (hostRef.$vnode$ = newVNode(tagName, null));
     if (!plt.$orgLocNodes$) {
         initializeDocumentHydrate(doc.body, (plt.$orgLocNodes$ = new Map()));
@@ -314,7 +418,7 @@ const initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {
         }
         plt.$orgLocNodes$.delete(orgLocationId);
     });
-    if (shadowRoot) {
+    if (BUILD.shadowDom && shadowRoot) {
         shadowRootNodes.map((shadowRootNode) => {
             if (shadowRootNode) {
                 shadowRoot.appendChild(shadowRootNode);
@@ -440,7 +544,7 @@ const clientHydrate = (parentVNode, childRenderNodes, slotNodes, shadowRootNodes
                         node['s-sn'] = '';
                     }
                     node['s-sr'] = true;
-                    if (shadowRootNodes) {
+                    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$);
@@ -464,11 +568,11 @@ const clientHydrate = (parentVNode, childRenderNodes, slotNodes, shadowRootNodes
                 }
                 else if (childNodeType === CONTENT_REF_ID) {
                     // `${CONTENT_REF_ID}.${hostId}`;
-                    if (shadowRootNodes) {
+                    if (BUILD.shadowDom && shadowRootNodes) {
                         // remove the content ref comment since it's not needed for shadow
                         node.remove();
                     }
-                    else {
+                    else if (BUILD.slotRelocation) {
                         hostElm['s-cr'] = node;
                         node['s-cn'] = true;
                     }
@@ -513,6 +617,11 @@ const initializeDocumentHydrate = (node, orgLocNodes) => {
         }
     }
 };
+// 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.
  *
@@ -539,16 +648,16 @@ const initializeDocumentHydrate = (node, orgLocNodes) => {
 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);
@@ -560,11 +669,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 */),
@@ -605,8 +717,11 @@ const registerStyle = (scopeId, cssText, allowCS) => {
 };
 const addStyle = (styleContainerNode, cmpMeta, mode) => {
     var _a;
-    const scopeId = getScopeId(cmpMeta);
+    const 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;
@@ -619,7 +734,8 @@ const addStyle = (styleContainerNode, cmpMeta, mode) => {
                 rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set()));
             }
             if (!appliedStyles.has(scopeId)) {
-                if (styleContainerNode.host &&
+                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;
@@ -632,6 +748,9 @@ const addStyle = (styleContainerNode, cmpMeta, mode) => {
                     if (nonce != null) {
                         styleElm.setAttribute('nonce', nonce);
                     }
+                    if (BUILD.hydrateServerSide || BUILD.hotModuleReplacement) {
+                        styleElm.setAttribute(HYDRATED_STYLE_ID, scopeId);
+                    }
                     styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link'));
                 }
                 // Add styles for `slot-fb` elements if we're using slots outside the Shadow DOM
@@ -643,7 +762,7 @@ const addStyle = (styleContainerNode, cmpMeta, mode) => {
                 }
             }
         }
-        else if (!styleContainerNode.adoptedStyleSheets.includes(style)) {
+        else if (BUILD.constructableCSS && !styleContainerNode.adoptedStyleSheets.includes(style)) {
             styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style];
         }
     }
@@ -654,8 +773,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$);
+    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
@@ -665,13 +784,13 @@ 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
@@ -700,19 +819,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 {
@@ -723,7 +842,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 {
@@ -732,15 +851,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
@@ -787,7 +907,7 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
                 }
             }
         }
-        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) {
@@ -820,7 +940,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;
@@ -828,7 +948,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 {
@@ -838,7 +958,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 {
@@ -866,7 +986,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 of sortedAttrNames(Object.keys(oldVnodeAttrs))) {
             if (!(memberName in newVnodeAttrs)) {
@@ -915,7 +1035,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') {
@@ -930,32 +1050,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 (!isSvgMode) {
+        if (BUILD.svg && !isSvgMode) {
             isSvgMode = newVNode.$tag$ === 'svg';
         }
         // create element
-        elm = newVNode.$elm$ = (doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, 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$)
-            );
-        if (isSvgMode && newVNode.$tag$ === 'foreignObject') {
+            : 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));
@@ -971,7 +1097,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
                 }
             }
         }
-        {
+        if (BUILD.svg) {
             if (newVNode.$tag$ === 'svg') {
                 // Only reset the SVG context when we're exiting <svg> element
                 isSvgMode = false;
@@ -985,7 +1111,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
     // This needs to always happen so we can hide nodes that are projected
     // to another component but don't end up in a slot
     elm['s-hn'] = hostTagName;
-    {
+    if (BUILD.slotRelocation) {
         if (newVNode.$flags$ & (2 /* VNODE_FLAGS.isSlotFallback */ | 1 /* VNODE_FLAGS.isSlotReference */)) {
             // remember the content reference comment
             elm['s-sr'] = true;
@@ -998,7 +1124,12 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
             // check if we've got an old vnode for this slot
             oldVNode = oldParentVNode && oldParentVNode.$children$ && oldParentVNode.$children$[childIndex];
             if (oldVNode && oldVNode.$tag$ === newVNode.$tag$ && oldParentVNode.$elm$) {
-                {
+                if (BUILD.experimentalSlotFixes) {
+                    // we've got an old slot vnode and the wrapper is being replaced
+                    // so let's move the old slot content to the root of the element currently being rendered
+                    relocateToHostRoot(oldParentVNode.$elm$);
+                }
+                else {
                     // we've got an old slot vnode and the wrapper is being replaced
                     // so let's move the old slot content back to its original location
                     putBackInOriginalLocation(oldParentVNode.$elm$, false);
@@ -1008,6 +1139,36 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
     }
     return elm;
 };
+/**
+ * Relocates all child nodes of an element that were a part of a previous slot relocation
+ * to the root of the Stencil component currently being rendered. This happens when a parent
+ * element of a slot reference node dynamically changes and triggers a re-render. We cannot use
+ * `putBackInOriginalLocation()` because that may relocate nodes to elements that will not be re-rendered
+ * and so they will not be relocated again.
+ *
+ * @param parentElm The element potentially containing relocated nodes.
+ */
+const relocateToHostRoot = (parentElm) => {
+    plt.$flags$ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
+    const host = parentElm.closest(hostTagName.toLowerCase());
+    if (host != null) {
+        const contentRefNode = Array.from(host.childNodes).find((ref) => ref['s-cr']);
+        const childNodeArray = Array.from(parentElm.childNodes);
+        // If we have a content ref, we need to invert the order of the nodes we're relocating
+        // to preserve the correct order of elements in the DOM on future relocations
+        for (const childNode of contentRefNode ? childNodeArray.reverse() : childNodeArray) {
+            // Only relocate nodes that were slotted in
+            if (childNode['s-sh'] != null) {
+                host.insertBefore(childNode, contentRefNode !== null && contentRefNode !== void 0 ? contentRefNode : null);
+                // Reset so we can correctly move the node around again.
+                childNode['s-sh'] = undefined;
+                // Need to tell the render pipeline to check to relocate slot content again
+                checkSlotRelocate = true;
+            }
+        }
+    }
+    plt.$flags$ &= ~1 /* PLATFORM_FLAGS.isTmpDisconnected */;
+};
 const putBackInOriginalLocation = (parentElm, recursive) => {
     plt.$flags$ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
     const oldSlotChildNodes = Array.from(parentElm.childNodes);
@@ -1055,9 +1216,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) {
@@ -1065,7 +1226,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);
             }
         }
     }
@@ -1088,7 +1249,7 @@ const removeVnodes = (vnodes, startIdx, endIdx) => {
             const elm = vnode.$elm$;
             nullifyVNodeRefs(vnode);
             if (elm) {
-                {
+                if (BUILD.slotRelocation) {
                     // we're removing this element
                     // so it's possible we need to show slot fallback content now
                     checkSlotFallbackVisibility = true;
@@ -1236,7 +1397,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh, isInitialRender = fal
             //
             // 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, isInitialRender);
@@ -1277,7 +1438,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh, isInitialRender = fal
             // (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, isInitialRender);
@@ -1300,7 +1461,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh, isInitialRender = fal
             // 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;
@@ -1308,7 +1469,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh, isInitialRender = fal
                     }
                 }
             }
-            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];
@@ -1335,9 +1496,12 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh, isInitialRender = fal
             }
             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$);
+                }
             }
         }
     }
@@ -1345,7 +1509,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh, isInitialRender = fal
         // 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)
@@ -1375,7 +1539,7 @@ const isSameVnode = (leftVNode, rightVNode, isInitialRender = false) => {
     // 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 JSX tags in the build have `key` attrs set on them
@@ -1383,7 +1547,7 @@ const isSameVnode = (leftVNode, rightVNode, isInitialRender = false) => {
         // first render `leftVNode.$key$` will always be `null`, so we can be led
         // astray and, for instance, accidentally delete a DOM node that we want to
         // keep around.
-        if (!isInitialRender) {
+        if (BUILD.vdomKey && !isInitialRender) {
             return leftVNode.$key$ === rightVNode.$key$;
         }
         return true;
@@ -1414,14 +1578,19 @@ const patch = (oldVNode, newVNode, isInitialRender = false) => {
     const tag = newVNode.$tag$;
     const text = newVNode.$text$;
     let defaultHolder;
-    if (text === null) {
-        {
+    if (!BUILD.vdomText || text === null) {
+        if (BUILD.svg) {
             // test if we're rendering an svg element, or still rendering nodes inside of one
             // only add this to the when the compiler sees we're using an svg somewhere
             isSvgMode = tag === 'svg' ? true : tag === 'foreignObject' ? false : isSvgMode;
         }
-        {
-            if (tag === 'slot' && !useNativeShadowDom) ;
+        if (BUILD.vdomAttribute || BUILD.reflect) {
+            if (BUILD.slot && tag === 'slot' && !useNativeShadowDom) {
+                if (BUILD.experimentalSlotFixes && oldVNode.$name$ !== newVNode.$name$) {
+                    newVNode.$elm$['s-sn'] = newVNode.$name$ || '';
+                    relocateToHostRoot(newVNode.$elm$.parentElement);
+                }
+            }
             else {
                 // either this is the first render of an element OR it's an update
                 // AND we already know it's possible it could have changed
@@ -1429,33 +1598,33 @@ const patch = (oldVNode, newVNode, isInitialRender = false) => {
                 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, isInitialRender);
         }
         else if (newChildren !== null) {
             // no old child vnodes, but there are new child vnodes to add
-            if (oldVNode.$text$ !== null) {
+            if (BUILD.updatable && BUILD.vdomText && oldVNode.$text$ !== null) {
                 // the old vnode was text, so be sure to clear it out
                 elm.textContent = '';
             }
             // add the new vnode children
             addVnodes(elm, null, newVNode, newChildren, 0, newChildren.length - 1);
         }
-        else if (oldChildren !== null) {
+        else if (BUILD.updatable && oldChildren !== null) {
             // no new child vnodes, but there are old child vnodes to remove
             removeVnodes(oldChildren, 0, oldChildren.length - 1);
         }
-        if (isSvgMode && tag === 'svg') {
+        if (BUILD.svg && isSvgMode && tag === 'svg') {
             isSvgMode = false;
         }
     }
-    else if ((defaultHolder = elm['s-cr'])) {
+    else if (BUILD.vdomText && BUILD.slotRelocation && (defaultHolder = elm['s-cr'])) {
         // this element has slotted content
         defaultHolder.parentNode.textContent = text;
     }
-    else if (oldVNode.$text$ !== text) {
+    else if (BUILD.vdomText && oldVNode.$text$ !== text) {
         // update the text content for the text only vnode
         // and also only if the text is different than before
         elm.data = text;
@@ -1556,7 +1725,7 @@ const markSlotContentForRelocation = (elm) => {
                 if (!node['s-cn'] &&
                     !node['s-nr'] &&
                     node['s-hn'] !== childNode['s-hn'] &&
-                    (!BUILD.experimentalSlotFixes  )) {
+                    (!BUILD.experimentalSlotFixes || !node['s-sh'] || node['s-sh'] !== childNode['s-hn'])) {
                     // if `node` is located in the slot that `childNode` refers to (via the
                     // `'s-sn'` property) then we need to relocate it from it's current spot
                     // (under the host element parent) to the right slot location
@@ -1646,7 +1815,7 @@ const isNodeLocatedInSlot = (nodeToRelocate, slotName) => {
  * @param vNode a virtual DOM node
  */
 const nullifyVNodeRefs = (vNode) => {
-    {
+    if (BUILD.vdomRef) {
         vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null);
         vNode.$children$ && vNode.$children$.map(nullifyVNodeRefs);
     }
@@ -1665,7 +1834,7 @@ const nullifyVNodeRefs = (vNode) => {
  * @param isInitialLoad whether or not this is the first call after page load
  */
 const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const hostElm = hostRef.$hostElement$;
     const cmpMeta = hostRef.$cmpMeta$;
     const oldVNode = hostRef.$vnode$ || newVNode(null, null);
@@ -1676,7 +1845,22 @@ const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
     // contains attrs that need to be set on the host element.
     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]));
     }
@@ -1704,19 +1888,19 @@ const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
     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'];
     }
-    useNativeShadowDom = (cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) !== 0;
-    {
+    useNativeShadowDom = supportsShadow && (cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) !== 0;
+    if (BUILD.slotRelocation) {
         contentRef = hostElm['s-cr'];
         // always reset
         checkSlotFallbackVisibility = false;
     }
     // synchronous patch
     patch(oldVNode, rootVnode, isInitialLoad);
-    {
+    if (BUILD.slotRelocation) {
         // while we're moving nodes around existing nodes, temporarily disable
         // the disconnectCallback from working
         plt.$flags$ |= 1 /* PLATFORM_FLAGS.isTmpDisconnected */;
@@ -1727,7 +1911,9 @@ const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
                 if (!nodeToRelocate['s-ol']) {
                     // add a reference node marking this node's original location
                     // keep a reference to this node for later lookups
-                    const orgLocationNode = doc.createTextNode('');
+                    const orgLocationNode = BUILD.isDebug || BUILD.hydrateServerSide
+                        ? originalLocationDebugNode(nodeToRelocate)
+                        : doc.createTextNode('');
                     orgLocationNode['s-nr'] = nodeToRelocate;
                     nodeToRelocate.parentNode.insertBefore((nodeToRelocate['s-ol'] = orgLocationNode), nodeToRelocate);
                 }
@@ -1751,7 +1937,8 @@ const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
                     // to make sure they get inserted into their new home in the same order they were declared in their original location.
                     //
                     // TODO(STENCIL-914): Remove `experimentalSlotFixes` check
-                    {
+                    if (!BUILD.experimentalSlotFixes ||
+                        (insertBeforeNode && insertBeforeNode.nodeType === 1 /* NODE_TYPE.ElementNode */)) {
                         let orgLocationNode = (_a = nodeToRelocate['s-ol']) === null || _a === void 0 ? void 0 : _a.previousSibling;
                         while (orgLocationNode) {
                             let refNode = (_b = orgLocationNode['s-nr']) !== null && _b !== void 0 ? _b : null;
@@ -1776,7 +1963,7 @@ const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
                         // since that the node to relocate
                         // has a different next sibling or parent relocated
                         if (nodeToRelocate !== insertBeforeNode) {
-                            if (!nodeToRelocate['s-hn'] && nodeToRelocate['s-ol']) {
+                            if (!BUILD.experimentalSlotFixes && !nodeToRelocate['s-hn'] && nodeToRelocate['s-ol']) {
                                 // probably a component in the index.html that doesn't have its hostname set
                                 nodeToRelocate['s-hn'] = nodeToRelocate['s-ol'].parentNode.nodeName;
                             }
@@ -1818,19 +2005,41 @@ const renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
         // always reset
         relocateNodes.length = 0;
     }
+    // Hide any elements that were projected through, but don't have a slot to go to.
+    // Only an issue if there were no "slots" rendered. Otherwise, nodes are hidden correctly.
+    // This _only_ happens for `scoped` components!
+    if (BUILD.experimentalScopedSlotChanges && cmpMeta.$flags$ & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+        for (const childNode of rootVnode.$elm$.childNodes) {
+            if (childNode['s-hn'] !== hostTagName && !childNode['s-sh']) {
+                // Store the initial value of `hidden` so we can reset it later when
+                // moving nodes around.
+                if (isInitialLoad && childNode['s-ih'] == null) {
+                    childNode['s-ih'] = (_e = childNode.hidden) !== null && _e !== void 0 ? _e : false;
+                }
+                childNode.hidden = true;
+            }
+        }
+    }
     // Clear the content ref so we don't create a memory leak
     contentRef = undefined;
 };
+// 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;
     }
@@ -1839,7 +2048,7 @@ 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();
 };
 /**
  * Dispatch initial-render and update lifecycle hooks, enqueuing calls to
@@ -1852,8 +2061,9 @@ const scheduleUpdate = (hostRef, isInitialLoad) => {
  * the component
  */
 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;
     // We're going to use this variable together with `enqueue` to implement a
     // little promise-based queue. We start out with it `undefined`. When we add
     // the first function to the queue we'll set this variable to be that
@@ -1868,14 +2078,15 @@ const dispatchHooks = (hostRef, isInitialLoad) => {
     //    called in order after `dispatchHooks` exits.
     let maybePromise;
     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$ = undefined;
             }
         }
-        {
+        emitLifecycleEvent(elm, 'componentWillLoad');
+        if (BUILD.cmpWillLoad) {
             // If `componentWillLoad` returns a `Promise` then we want to wait on
             // whatever's going on in that `Promise` before we launch into
             // rendering the component, doing other lifecycle stuff, etc. So
@@ -1884,7 +2095,19 @@ const dispatchHooks = (hostRef, isInitialLoad) => {
             maybePromise = safeCall(instance, 'componentWillLoad');
         }
     }
-    {
+    else {
+        emitLifecycleEvent(elm, 'componentWillUpdate');
+        if (BUILD.cmpWillUpdate) {
+            // Like `componentWillLoad` above, we allow Stencil component
+            // authors to return a `Promise` from this lifecycle callback, and
+            // we specify that our runtime will wait for that `Promise` to
+            // resolve before the component re-renders. So if the method
+            // returns a `Promise` we need to keep it around!
+            maybePromise = safeCall(instance, 'componentWillUpdate');
+        }
+    }
+    emitLifecycleEvent(elm, 'componentWillRender');
+    if (BUILD.cmpWillRender) {
         maybePromise = enqueue(maybePromise, () => safeCall(instance, 'componentWillRender'));
     }
     endSchedule();
@@ -1934,15 +2157,43 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
     const elm = hostRef.$hostElement$;
     const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$);
     const rc = elm['s-rc'];
-    if (isInitialLoad) {
+    if (BUILD.style && isInitialLoad) {
         // DOM WRITE!
         attachStyles(hostRef);
     }
     const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$);
-    {
+    if (BUILD.isDev) {
+        hostRef.$flags$ |= 1024 /* HOST_FLAGS.devOnRender */;
+    }
+    if (BUILD.hydrateServerSide) {
+        await callRender(hostRef, instance, elm, isInitialLoad);
+    }
+    else {
         callRender(hostRef, instance, elm, isInitialLoad);
     }
-    if (rc) {
+    if (BUILD.isDev) {
+        hostRef.$renderCount$ = hostRef.$renderCount$ === undefined ? 1 : hostRef.$renderCount$ + 1;
+        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 (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
@@ -1951,7 +2202,7 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
     }
     endRender();
     endUpdate();
-    {
+    if (BUILD.asyncLoading) {
         const childrenPromises = (_a = elm['s-p']) !== null && _a !== void 0 ? _a : [];
         const postUpdate = () => postUpdateComponent(hostRef);
         if (childrenPromises.length === 0) {
@@ -1963,6 +2214,9 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
             childrenPromises.length = 0;
         }
     }
+    else {
+        postUpdateComponent(hostRef);
+    }
 };
 /**
  * Handle making the call to the VDom renderer with the proper context given
@@ -1977,72 +2231,119 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
  * @returns an empty promise
  */
 const callRender = (hostRef, instance, elm, isInitialLoad) => {
+    // in order for bundlers to correctly tree-shake 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;
         /**
          * minification optimization: `allRenderFn` is `true` if all components have a `render`
          * method, so we can call the method immediately. If not, check before calling it.
          */
-        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, isInitialLoad));
+                }
+                else {
                     renderVdom(hostRef, instance, isInitialLoad);
                 }
             }
+            else {
+                const shadowRoot = elm.shadowRoot;
+                if (hostRef.$cmpMeta$.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) {
+                    shadowRoot.textContent = instance;
+                }
+                else {
+                    elm.textContent = instance;
+                }
+            }
         }
     }
     catch (e) {
         consoleError(e, hostRef.$hostElement$);
     }
+    renderingRef = null;
     return null;
 };
+const getRenderingRef = () => renderingRef;
 const postUpdateComponent = (hostRef) => {
     const tagName = hostRef.$cmpMeta$.$tagName$;
     const elm = hostRef.$hostElement$;
     const endPostUpdate = createTime('postUpdate', tagName);
-    const instance = hostRef.$lazyInstance$ ;
+    const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
     const ancestorComponent = hostRef.$ancestorComponent$;
-    {
+    if (BUILD.cmpDidRender) {
+        if (BUILD.isDev) {
+            hostRef.$flags$ |= 1024 /* 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.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;
@@ -2056,13 +2357,32 @@ const postUpdateComponent = (hostRef) => {
     // ( •_•)>⌐■-■
     // (⌐■_■)
 };
+const forceUpdate = (ref) => {
+    if (BUILD.updatable && (Build.isBrowser || Build.isTesting)) {
+        const hostRef = getHostRef(ref);
+        const isConnected = hostRef.$hostElement$.isConnected;
+        if (isConnected &&
+            (hostRef.$flags$ & (2 /* HOST_FLAGS.hasRendered */ | 16 /* HOST_FLAGS.isQueuedForUpdate */)) === 2 /* HOST_FLAGS.hasRendered */) {
+            scheduleUpdate(hostRef, false);
+        }
+        // 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');
+    }
 };
 /**
  * Allows to safely call a method, e.g. `componentDidLoad`, on an instance,
@@ -2085,27 +2405,67 @@ const safeCall = (instance, method, arg) => {
     }
     return undefined;
 };
-const addHydratedFlag = (elm) => elm.classList.add('hydrated')
-    ;
+/**
+ * For debugging purposes as `BUILD.lifecycleDOMEvents` is `false` by default and will
+ * get removed by the compiler. Used for timing events to see how long they take.
+ * @param elm the target of the Event
+ * @param lifecycleName name of the event
+ */
+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
@@ -2120,7 +2480,13 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
                     });
                 }
             }
-            if ((flags & (2 /* HOST_FLAGS.hasRendered */ | 16 /* HOST_FLAGS.isQueuedForUpdate */)) === 2 /* HOST_FLAGS.hasRendered */) {
+            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;
+                    }
+                }
                 // looks like this value actually changed, so we've got work to do!
                 // but only if we've already rendered, otherwise just chill out
                 // queue that we need to do an update, but don't worry about queuing
@@ -2143,15 +2509,39 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
 const proxyComponent = (Cstr, cmpMeta, flags) => {
     var _a;
     const prototype = Cstr.prototype;
-    if (cmpMeta.$members$) {
-        if (Cstr.watchers) {
+    /**
+     * proxy form associated custom element lifecycle callbacks
+     * @ref https://web.dev/articles/more-capable-form-controls#lifecycle_callbacks
+     */
+    if (BUILD.formAssociated && cmpMeta.$flags$ & 64 /* CMP_FLAGS.formAssociated */ && flags & 1 /* PROXY_FLAGS.isElementConstructor */) {
+        FORM_ASSOCIATED_CUSTOM_ELEMENT_CALLBACKS.forEach((cbName) => Object.defineProperty(prototype, cbName, {
+            value(...args) {
+                const hostRef = getHostRef(this);
+                const elm = BUILD.lazyLoad ? hostRef.$hostElement$ : this;
+                const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
+                if (!instance) {
+                    hostRef.$onReadyPromise$.then((instance) => {
+                        const cb = instance[cbName];
+                        typeof cb === 'function' && cb.call(instance, ...args);
+                    });
+                }
+                else {
+                    const cb = instance[cbName];
+                    typeof cb === 'function' && cb.call(instance, ...args);
+                }
+            },
+        }));
+    }
+    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$);
         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() {
@@ -2159,6 +2549,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 && 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);
                     },
@@ -2166,7 +2571,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, {
@@ -2178,7 +2585,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(() => {
@@ -2242,7 +2649,8 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                             !(flags & 8 /* HOST_FLAGS.isConstructingInstance */) &&
                             flags & 128 /* HOST_FLAGS.isWatchReady */ &&
                             newValue !== oldValue) {
-                            const instance = hostRef.$lazyInstance$ ;
+                            const elm = BUILD.lazyLoad ? hostRef.$hostElement$ : this;
+                            const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm;
                             const entry = (_a = cmpMeta.$watchers$) === null || _a === void 0 ? void 0 : _a[attrName];
                             entry === null || entry === void 0 ? void 0 : entry.forEach((callbackName) => {
                                 if (instance[callbackName] != null) {
@@ -2268,7 +2676,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                     var _a;
                     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 */) {
                         (_a = cmpMeta.$attrsToReflect$) === null || _a === void 0 ? void 0 : _a.push([propName, attrName]);
                     }
                     return attrName;
@@ -2295,22 +2703,25 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
         // Let the runtime know that the component has been initialized
         hostRef.$flags$ |= 32 /* HOST_FLAGS.hasInitializedComponent */;
         const bundleId = cmpMeta.$lazyBundleId$;
-        if (bundleId) {
+        if ((BUILD.lazyLoad || BUILD.hydrateClientSide) && bundleId) {
             // 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 */);
@@ -2320,7 +2731,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
             // 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
@@ -2333,10 +2744,10 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
             catch (e) {
                 consoleError(e);
             }
-            {
+            if (BUILD.member) {
                 hostRef.$flags$ &= ~8 /* HOST_FLAGS.isConstructingInstance */;
             }
-            {
+            if (BUILD.watchCallback) {
                 hostRef.$flags$ |= 128 /* HOST_FLAGS.isWatchReady */;
             }
             endNewInstance();
@@ -2350,12 +2761,25 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
             // Stencil has completed instantiating the component.
             customElements.whenDefined(cmpMeta.$tagName$).then(() => (hostRef.$flags$ |= 128 /* HOST_FLAGS.isWatchReady */));
         }
-        if (Cstr.style) {
+        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 &&
+                    // TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
+                    BUILD.shadowDomShim &&
+                    cmpMeta.$flags$ & 8 /* CMP_FLAGS.needsShadowDomShim */) {
+                    style = await import('./shadow-css-2e0fed52.js').then((m) => m.scopeCss(style, scopeId, false));
+                }
                 registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */));
                 endRegisterStyles();
             }
@@ -2364,7 +2788,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
     // 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
@@ -2378,7 +2802,7 @@ const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
     }
 };
 const fireConnectedCallback = (instance) => {
-    {
+    if (BUILD.lazyLoad && BUILD.connectedCallback) {
         safeCall(instance, 'connectedCallback');
     }
 };
@@ -2387,38 +2811,47 @@ 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 (cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) {
-                        const scopeId = addStyle(elm.shadowRoot, cmpMeta);
+                    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 (!hostId) {
+            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 ((// TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
+                if (BUILD.hydrateServerSide ||
+                    ((BUILD.slot || BUILD.shadowDom) &&
+                        // TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
                         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.nodeType === 1 /* NODE_TYPE.ElementNode */ &&
+                    if ((BUILD.hydrateClientSide &&
+                        ancestorComponent.nodeType === 1 /* NODE_TYPE.ElementNode */ &&
                         ancestorComponent.hasAttribute('s-id') &&
                         ancestorComponent['s-p']) ||
                         ancestorComponent['s-p']) {
@@ -2431,7 +2864,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];
@@ -2440,7 +2873,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);
             }
         }
@@ -2448,7 +2888,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
             if (hostRef === null || hostRef === void 0 ? void 0 : hostRef.$lazyInstance$) {
                 fireConnectedCallback(hostRef.$lazyInstance$);
@@ -2467,25 +2907,31 @@ 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 disconnectInstance = (instance) => {
-    {
+    if (BUILD.lazyLoad && BUILD.disconnectedCallback) {
         safeCall(instance, 'disconnectedCallback');
     }
+    if (BUILD.cmpDidUnload) {
+        safeCall(instance, 'componentDidUnload');
+    }
 };
 const disconnectedCallback = async (elm) => {
     if ((plt.$flags$ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {
         const hostRef = getHostRef(elm);
-        {
+        if (BUILD.hostListener) {
             if (hostRef.$rmListeners$) {
                 hostRef.$rmListeners$.map((rmListener) => rmListener());
                 hostRef.$rmListeners$ = undefined;
             }
         }
-        if (hostRef === null || hostRef === void 0 ? void 0 : hostRef.$lazyInstance$) {
+        if (!BUILD.lazyLoad) {
+            disconnectInstance(elm);
+        }
+        else if (hostRef === null || hostRef === void 0 ? void 0 : hostRef.$lazyInstance$) {
             disconnectInstance(hostRef.$lazyInstance$);
         }
         else if (hostRef === null || hostRef === void 0 ? void 0 : hostRef.$onReadyPromise$) {
@@ -2493,9 +2939,556 @@ const disconnectedCallback = async (elm) => {
         }
     }
 };
+const patchPseudoShadowDom = (hostElementPrototype, descriptorPrototype) => {
+    patchCloneNode(hostElementPrototype);
+    patchSlotAppendChild(hostElementPrototype);
+    patchSlotAppend(hostElementPrototype);
+    patchSlotPrepend(hostElementPrototype);
+    patchSlotInsertAdjacentElement(hostElementPrototype);
+    patchSlotInsertAdjacentHTML(hostElementPrototype);
+    patchSlotInsertAdjacentText(hostElementPrototype);
+    patchTextContent(hostElementPrototype);
+    patchChildSlotNodes(hostElementPrototype, descriptorPrototype);
+    patchSlotRemoveChild(hostElementPrototype);
+};
+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',
+                's-rf',
+            ];
+            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;
+    };
+};
+/**
+ * Patches the `appendChild` method on a `scoped` Stencil component.
+ * The patch will attempt to find a slot with the same name as the node being appended
+ * and insert it into the slot reference if found. Otherwise, it falls-back to the original
+ * `appendChild` method.
+ *
+ * @param HostElementPrototype The Stencil component to be patched
+ */
+const patchSlotAppendChild = (HostElementPrototype) => {
+    HostElementPrototype.__appendChild = HostElementPrototype.appendChild;
+    HostElementPrototype.appendChild = function (newChild) {
+        const slotName = (newChild['s-sn'] = getSlotName(newChild));
+        const slotNode = getHostSlotNode(this.childNodes, slotName, this.tagName);
+        if (slotNode) {
+            const slotChildNodes = getHostSlotChildNodes(slotNode, slotName);
+            const appendAfter = slotChildNodes[slotChildNodes.length - 1];
+            const insertedNode = appendAfter.parentNode.insertBefore(newChild, appendAfter.nextSibling);
+            // Check if there is fallback content that should be hidden
+            updateFallbackSlotVisibility(this);
+            return insertedNode;
+        }
+        return this.__appendChild(newChild);
+    };
+};
+/**
+ * Patches the `removeChild` method on a `scoped` Stencil component.
+ * This patch attempts to remove the specified node from a slot reference
+ * if the slot exists. Otherwise, it falls-back to the original `removeChild` method.
+ *
+ * @param ElementPrototype The Stencil component to be patched
+ */
+const patchSlotRemoveChild = (ElementPrototype) => {
+    ElementPrototype.__removeChild = ElementPrototype.removeChild;
+    ElementPrototype.removeChild = function (toRemove) {
+        if (toRemove && typeof toRemove['s-sn'] !== 'undefined') {
+            const slotNode = getHostSlotNode(this.childNodes, toRemove['s-sn'], this.tagName);
+            if (slotNode) {
+                // Get all slot content
+                const slotChildNodes = getHostSlotChildNodes(slotNode, toRemove['s-sn']);
+                // See if any of the slotted content matches the node to remove
+                const existingNode = slotChildNodes.find((n) => n === toRemove);
+                if (existingNode) {
+                    existingNode.remove();
+                    // Check if there is fallback content that should be displayed if that
+                    // was the last node in the slot
+                    updateFallbackSlotVisibility(this);
+                    return;
+                }
+            }
+        }
+        return this.__removeChild(toRemove);
+    };
+};
+/**
+ * Patches the `prepend` method for a slotted node inside a scoped component.
+ *
+ * @param HostElementPrototype the `Element` to be patched
+ */
+const patchSlotPrepend = (HostElementPrototype) => {
+    const originalPrepend = HostElementPrototype.prepend;
+    HostElementPrototype.prepend = function (...newChildren) {
+        newChildren.forEach((newChild) => {
+            if (typeof newChild === 'string') {
+                newChild = this.ownerDocument.createTextNode(newChild);
+            }
+            const slotName = (newChild['s-sn'] = getSlotName(newChild));
+            const slotNode = getHostSlotNode(this.childNodes, slotName, this.tagName);
+            if (slotNode) {
+                const slotPlaceholder = document.createTextNode('');
+                slotPlaceholder['s-nr'] = newChild;
+                slotNode['s-cr'].parentNode.__appendChild(slotPlaceholder);
+                newChild['s-ol'] = slotPlaceholder;
+                const slotChildNodes = getHostSlotChildNodes(slotNode, slotName);
+                const appendAfter = slotChildNodes[0];
+                return appendAfter.parentNode.insertBefore(newChild, appendAfter.nextSibling);
+            }
+            if (newChild.nodeType === 1 && !!newChild.getAttribute('slot')) {
+                newChild.hidden = true;
+            }
+            return originalPrepend.call(this, newChild);
+        });
+    };
+};
+/**
+ * Patches the `append` method for a slotted node inside a scoped component. The patched method uses
+ * `appendChild` under-the-hood while creating text nodes for any new children that passed as bare strings.
+ *
+ * @param HostElementPrototype the `Element` to be patched
+ */
+const patchSlotAppend = (HostElementPrototype) => {
+    HostElementPrototype.append = function (...newChildren) {
+        newChildren.forEach((newChild) => {
+            if (typeof newChild === 'string') {
+                newChild = this.ownerDocument.createTextNode(newChild);
+            }
+            this.appendChild(newChild);
+        });
+    };
+};
+/**
+ * Patches the `insertAdjacentHTML` method for a slotted node inside a scoped component. Specifically,
+ * we only need to patch the behavior for the specific `beforeend` and `afterbegin` positions so the element
+ * gets inserted into the DOM in the correct location.
+ *
+ * @param HostElementPrototype the `Element` to be patched
+ */
+const patchSlotInsertAdjacentHTML = (HostElementPrototype) => {
+    const originalInsertAdjacentHtml = HostElementPrototype.insertAdjacentHTML;
+    HostElementPrototype.insertAdjacentHTML = function (position, text) {
+        if (position !== 'afterbegin' && position !== 'beforeend') {
+            return originalInsertAdjacentHtml.call(this, position, text);
+        }
+        const container = this.ownerDocument.createElement('_');
+        let node;
+        container.innerHTML = text;
+        if (position === 'afterbegin') {
+            while ((node = container.firstChild)) {
+                this.prepend(node);
+            }
+        }
+        else if (position === 'beforeend') {
+            while ((node = container.firstChild)) {
+                this.append(node);
+            }
+        }
+    };
+};
+/**
+ * Patches the `insertAdjacentText` method for a slotted node inside a scoped component. Specifically,
+ * we only need to patch the behavior for the specific `beforeend` and `afterbegin` positions so the text node
+ * gets inserted into the DOM in the correct location.
+ *
+ * @param HostElementPrototype the `Element` to be patched
+ */
+const patchSlotInsertAdjacentText = (HostElementPrototype) => {
+    HostElementPrototype.insertAdjacentText = function (position, text) {
+        this.insertAdjacentHTML(position, text);
+    };
+};
+/**
+ * Patches the `insertAdjacentElement` method for a slotted node inside a scoped component. Specifically,
+ * we only need to patch the behavior for the specific `beforeend` and `afterbegin` positions so the element
+ * gets inserted into the DOM in the correct location.
+ *
+ * @param HostElementPrototype the `Element` to be patched
+ */
+const patchSlotInsertAdjacentElement = (HostElementPrototype) => {
+    const originalInsertAdjacentElement = HostElementPrototype.insertAdjacentElement;
+    HostElementPrototype.insertAdjacentElement = function (position, element) {
+        if (position !== 'afterbegin' && position !== 'beforeend') {
+            return originalInsertAdjacentElement.call(this, position, element);
+        }
+        if (position === 'afterbegin') {
+            this.prepend(element);
+            return element;
+        }
+        else if (position === 'beforeend') {
+            this.append(element);
+            return element;
+        }
+        return element;
+    };
+};
+/**
+ * Patches the text content of an unnamed slotted node inside a scoped component
+ * @param hostElementPrototype the `Element` to be patched
+ */
+const patchTextContent = (hostElementPrototype) => {
+    const descriptor = Object.getOwnPropertyDescriptor(Node.prototype, 'textContent');
+    Object.defineProperty(hostElementPrototype, '__textContent', descriptor);
+    if (BUILD.experimentalScopedSlotChanges) {
+        // Patch `textContent` to mimic shadow root behavior
+        Object.defineProperty(hostElementPrototype, 'textContent', {
+            // To mimic shadow root behavior, we need to return the text content of all
+            // nodes in a slot reference node
+            get() {
+                const slotRefNodes = getAllChildSlotNodes(this.childNodes);
+                const textContent = slotRefNodes
+                    .map((node) => {
+                    var _a, _b;
+                    const text = [];
+                    // Need to get the text content of all nodes in the slot reference node
+                    let slotContent = node.nextSibling;
+                    while (slotContent && slotContent['s-sn'] === node['s-sn']) {
+                        if (slotContent.nodeType === 3 /* NODE_TYPES.TEXT_NODE */ || slotContent.nodeType === 1 /* NODE_TYPES.ELEMENT_NODE */) {
+                            text.push((_b = (_a = slotContent.textContent) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '');
+                        }
+                        slotContent = slotContent.nextSibling;
+                    }
+                    return text.filter((ref) => ref !== '').join(' ');
+                })
+                    .filter((text) => text !== '')
+                    .join(' ');
+                // Pad the string to return
+                return ' ' + textContent + ' ';
+            },
+            // To mimic shadow root behavior, we need to overwrite all nodes in a slot
+            // reference node. If a default slot reference node exists, the text content will be
+            // placed there. Otherwise, the new text node will be hidden
+            set(value) {
+                const slotRefNodes = getAllChildSlotNodes(this.childNodes);
+                slotRefNodes.forEach((node) => {
+                    // Remove the existing content of the slot
+                    let slotContent = node.nextSibling;
+                    while (slotContent && slotContent['s-sn'] === node['s-sn']) {
+                        const tmp = slotContent;
+                        slotContent = slotContent.nextSibling;
+                        tmp.remove();
+                    }
+                    // If this is a default slot, add the text node in the slot location.
+                    // Otherwise, destroy the slot reference node
+                    if (node['s-sn'] === '') {
+                        const textNode = this.ownerDocument.createTextNode(value);
+                        textNode['s-sn'] = '';
+                        node.parentElement.insertBefore(textNode, node.nextSibling);
+                    }
+                    else {
+                        node.remove();
+                    }
+                });
+            },
+        });
+    }
+    else {
+        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, '', this.tagName);
+                // 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, '', this.tagName);
+                // 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];
+        }
+    }
+    // TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
+    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);
+            },
+        });
+    }
+};
+/**
+ * Recursively finds all slot reference nodes ('s-sr') in a series of child nodes.
+ *
+ * @param childNodes The set of child nodes to search for slot reference nodes.
+ * @returns An array of slot reference nodes.
+ */
+const getAllChildSlotNodes = (childNodes) => {
+    const slotRefNodes = [];
+    for (const childNode of Array.from(childNodes)) {
+        if (childNode['s-sr']) {
+            slotRefNodes.push(childNode);
+        }
+        slotRefNodes.push(...getAllChildSlotNodes(childNode.childNodes));
+    }
+    return slotRefNodes;
+};
+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.
+ * @param hostName the host 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, hostName) => {
+    let i = 0;
+    let childNode;
+    for (; i < childNodes.length; i++) {
+        childNode = childNodes[i];
+        if (childNode['s-sr'] && childNode['s-sn'] === slotName && childNode['s-hn'] === hostName) {
+            return childNode;
+        }
+        childNode = getHostSlotNode(childNode.childNodes, slotName, hostName);
+        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 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 */) {
+        // TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
+        cmpMeta.$flags$ |= 8 /* CMP_FLAGS.needsShadowDomShim */;
+    }
+    // TODO(STENCIL-914): this check and `else` block can go away and be replaced by just the `scoped` check
+    if (BUILD.experimentalSlotFixes) {
+        if (BUILD.scoped && cmpMeta.$flags$ & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+            // This check is intentionally not combined with the surrounding `experimentalSlotFixes` check
+            // since, moving forward, we only want to patch the pseudo shadow DOM when the component is scoped
+            patchPseudoShadowDom(Cstr.prototype, cmpMeta);
+        }
+    }
+    else {
+        if (BUILD.slotChildNodesFix) {
+            patchChildSlotNodes(Cstr.prototype, cmpMeta);
+        }
+        if (BUILD.cloneNodeFix) {
+            patchCloneNode(Cstr.prototype);
+        }
+        if (BUILD.appendChildSlotFix) {
+            patchSlotAppendChild(Cstr.prototype);
+        }
+        if (BUILD.scopedSlotTextContentFix && cmpMeta.$flags$ & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+            patchTextContent(Cstr.prototype);
+        }
+    }
+    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);
+            }
+        }
+    }
+};
+/**
+ * Kick off hot-module-replacement for a component. In order to replace the
+ * component in-place we:
+ *
+ * 1. get a reference to the {@link d.HostRef} for the element
+ * 2. reset the element's runtime flags
+ * 3. re-run the initialization logic for the element (via
+ *    {@link initializeComponent})
+ *
+ * @param hostElement the host element for the component which we want to start
+ * doing HMR
+ * @param cmpMeta runtime metadata for the component
+ * @param hmrVersionId the current HMR version ID
+ */
+const hmrStart = (hostElement, cmpMeta, hmrVersionId) => {
+    // ¯\_(ツ)_/¯
+    const hostRef = getHostRef(hostElement);
+    // reset state flags to only have been connected
+    hostRef.$flags$ = 1 /* HOST_FLAGS.hasConnected */;
+    // TODO
+    // detach 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
+    // re-initialize the component
+    initializeComponent(hostElement, 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;
@@ -2509,12 +3502,17 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
     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);
         }
@@ -2534,19 +3532,25 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
             if (cmpMeta.$flags$ & 4 /* CMP_FLAGS.hasSlotRelocation */) {
                 hasSlotRelocation = true;
             }
-            {
+            if (BUILD.member) {
                 cmpMeta.$members$ = compactMeta[2];
             }
-            {
+            if (BUILD.hostListener) {
                 cmpMeta.$listeners$ = compactMeta[3];
             }
-            {
+            if (BUILD.reflect) {
                 cmpMeta.$attrsToReflect$ = [];
             }
-            {
+            if (BUILD.watchCallback) {
                 cmpMeta.$watchers$ = (_a = compactMeta[4]) !== null && _a !== void 0 ? _a : {};
             }
-            const tagName = cmpMeta.$tagName$;
+            if (BUILD.shadowDom && !supportsShadow && cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) {
+                // TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
+                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) {
@@ -2554,16 +3558,25 @@ 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;
+                        }
                     }
                 }
                 connectedCallback() {
@@ -2586,6 +3599,42 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
                     return getHostRef(this).$onReadyPromise$;
                 }
             };
+            // TODO(STENCIL-914): this check and `else` block can go away and be replaced by just the `scoped` check
+            if (BUILD.experimentalSlotFixes) {
+                // This check is intentionally not combined with the surrounding `experimentalSlotFixes` check
+                // since, moving forward, we only want to patch the pseudo shadow DOM when the component is scoped
+                if (BUILD.scoped && cmpMeta.$flags$ & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+                    patchPseudoShadowDom(HostElement.prototype, cmpMeta);
+                }
+            }
+            else {
+                if (BUILD.slotChildNodesFix) {
+                    patchChildSlotNodes(HostElement.prototype, cmpMeta);
+                }
+                if (BUILD.cloneNodeFix) {
+                    patchCloneNode(HostElement.prototype);
+                }
+                if (BUILD.appendChildSlotFix) {
+                    patchSlotAppendChild(HostElement.prototype);
+                }
+                if (BUILD.scopedSlotTextContentFix && cmpMeta.$flags$ & 2 /* CMP_FLAGS.scopedCssEncapsulation */) {
+                    patchTextContent(HostElement.prototype);
+                }
+            }
+            // if the component is formAssociated we need to set that on the host
+            // element so that it will be ready for `attachInternals` to be called on
+            // it later on
+            if (BUILD.formAssociated && cmpMeta.$flags$ & 64 /* CMP_FLAGS.formAssociated */) {
+                HostElement.formAssociated = true;
+            }
+            if (BUILD.hotModuleReplacement) {
+                // if we're in an HMR dev build then we need to set up the callback
+                // which will carry out the work of actually replacing the module for
+                // this particular component
+                HostElement.prototype['s-hmr'] = function (hmrVersionId) {
+                    hmrStart(this, cmpMeta, hmrVersionId);
+                };
+            }
             cmpMeta.$lazyBundleId$ = lazyBundle[0];
             if (!exclude.includes(tagName) && !customElements.get(tagName)) {
                 cmpTags.push(tagName);
@@ -2601,7 +3650,7 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
             dataStyles.textContent += SLOT_FB_CSS;
         }
         // Add hydration styles
-        {
+        if (BUILD.invisiblePrehydration && (BUILD.hydratedClass || BUILD.hydratedAttribute)) {
             dataStyles.textContent += cmpTags + HYDRATED_CSS;
         }
         // If we have styles, add them to the DOM
@@ -2623,17 +3672,40 @@ 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 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);
@@ -2643,7 +3715,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);
@@ -2652,14 +3724,23 @@ 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 & 16 /* LISTENER_FLAGS.TargetBody */)
+    if (BUILD.hostListenerTargetDocument && flags & 4 /* LISTENER_FLAGS.TargetDocument */)
+        return doc;
+    if (BUILD.hostListenerTargetWindow && flags & 8 /* LISTENER_FLAGS.TargetWindow */)
+        return win;
+    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
@@ -2676,6 +3757,194 @@ const hostListenerOpts = (flags) => supportsListenerOptions
  * @returns void
  */
 const setNonce = (nonce) => (plt.$nonce$ = nonce);
+const setPlatformOptions = (opts) => Object.assign(plt, opts);
+/**
+ * Updates the DOM generated on the server with annotations such as node attributes and
+ * comment nodes to facilitate future client-side hydration. These annotations are used for things
+ * like moving elements back to their original hosts if using Shadow DOM on the client, and for quickly
+ * reconstructing the vNode representations of the DOM.
+ *
+ * @param doc The DOM generated by the server.
+ * @param staticComponents Any components that should be considered static and do not need client-side hydration.
+ */
+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) => {
+            var _a, _b;
+            if (orgLocationNode != null && orgLocationNode['s-nr']) {
+                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 = (_a = nodeRef.nodeValue) === null || _a === void 0 ? void 0 : _a.trim();
+                            if (textContent === '') {
+                                // useless whitespace node at the document root
+                                orgLocationNode.remove();
+                                return;
+                            }
+                        }
+                        const commentBeforeTextNode = doc.createComment(childId);
+                        commentBeforeTextNode.nodeValue = `${TEXT_NODE_ID}.${childId}`;
+                        (_b = nodeRef.parentNode) === null || _b === void 0 ? void 0 : _b.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;
+            }
+        });
+    }
+};
+/**
+ * Recursively parses a node generated by the server and its children to set host and child id
+ * attributes read during client-side hydration. This function also tracks whether each node is
+ * an original location reference node meaning that a node has been moved via slot relocation.
+ *
+ * @param doc The DOM generated by the server.
+ * @param node The node to parse.
+ * @param docData An object containing metadata about the document.
+ * @param orgLocationNodes An array of nodes that have been moved via slot relocation.
+ */
+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);
+        });
+    }
+};
+/**
+ * Insert attribute annotations on an element for its host ID and, potentially, its child ID.
+ * Also makes calls to insert annotations on the element's children, keeping track of the depth of
+ * the component tree.
+ *
+ * @param doc The DOM generated by the server.
+ * @param hostElm The element to insert annotations for.
+ * @param vnode The vNode representation of the element.
+ * @param docData An object containing metadata about the document.
+ * @param cmpData An object containing metadata about the component.
+ */
+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 this element does not already have a child ID and has a sibling comment node
+        // representing a slot, we use the content of the comment to set the child ID attribute
+        // on the host element.
+        if (hostElm && vnode && vnode.$elm$ && !hostElm.hasAttribute(HYDRATE_CHILD_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}`);
+                }
+            }
+        }
+    }
+};
+/**
+ * Recursively analyzes the type of a child vNode and inserts annotations on the vNodes's element based on its type.
+ * Element nodes receive a child ID attribute, text nodes have a comment with the child ID inserted before them,
+ * and comment nodes representing a slot have their node value set to a slot node ID containing the child ID.
+ *
+ * @param doc The DOM generated by the server.
+ * @param vnodeChild The vNode to insert annotations for.
+ * @param cmpData An object containing metadata about the component.
+ * @param hostId The host ID of this element's parent.
+ * @param depth How deep this element sits in the component tree relative to its parent.
+ * @param index The index of this element in its parent's children array.
+ */
+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 === null || parentNode === void 0 ? void 0 : parentNode.nodeName;
+        if (nodeName !== 'STYLE' && nodeName !== 'SCRIPT') {
+            const textNodeId = `${TEXT_NODE_ID}.${childId}`;
+            const commentBeforeTextNode = doc.createComment(textNodeId);
+            parentNode === null || parentNode === void 0 ? void 0 : 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) {
+        // Increment depth each time we recur deeper into the tree
+        const childDepth = depth + 1;
+        vnodeChild.$children$.forEach((vnode, index) => {
+            insertChildVNodeAnnotations(doc, vnode, cmpData, hostId, childDepth, index);
+        });
+    }
+};
+var _a;
 /**
  * A WeakMap mapping runtime component references to their corresponding host reference
  * instances.
@@ -2691,7 +3960,9 @@ const setNonce = (nonce) => (plt.$nonce$ = nonce);
  * component will not have access to the previous hostRef map, leading to a
  * bug where the new version of the component cannot properly initialize.
  */
-const hostRefs = new WeakMap();
+const hostRefs = BUILD.hotModuleReplacement
+    ? ((_a = window).__STENCIL_HOSTREFS__ || (_a.__STENCIL_HOSTREFS__ = new WeakMap()))
+    : new WeakMap();
 /**
  * Given a {@link d.RuntimeRef} retrieve the corresponding {@link d.HostRef}
  *
@@ -2724,44 +3995,64 @@ const registerHost = (hostElement, 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));
         hostElement['s-p'] = [];
         hostElement['s-rc'] = [];
     }
-    addHostEventListeners(hostElement, hostRef, cmpMeta.$listeners$);
+    addHostEventListeners(hostElement, hostRef, cmpMeta.$listeners$, false);
     return hostRefs.set(hostElement, 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];
     }
     /*!__STENCIL_STATIC_IMPORT_SWITCH__*/
-    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+    return import(
     /* @vite-ignore */
     /* 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 doc = win.document || { head: {} };
+const H = (win.HTMLElement || class {
+});
 const plt = {
     $flags$: 0,
     $resourcesUrl$: '',
@@ -2771,9 +4062,14 @@ 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 = 
 // TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
-true;
+BUILD.shadowDomShim && BUILD.shadowDom
+    ? /*@__PURE__*/ (() => (doc.head.attachShadow + '').indexOf('[native') > -1)()
+    : true;
 const supportsListenerOptions = /*@__PURE__*/ (() => {
     let supportsListenerOptions = false;
     try {
@@ -2787,7 +4083,8 @@ const supportsListenerOptions = /*@__PURE__*/ (() => {
     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';
@@ -2795,9 +4092,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) {
@@ -2821,13 +4119,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
@@ -2837,15 +4175,9 @@ const flush = () => {
     }
 };
 const nextTick = (cb) => promiseResolve().then(cb);
+const readTask = /*@__PURE__*/ queueTask(queueDomReads, false);
 const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true);
 
-exports.Host = Host;
-exports.bootstrapLazy = bootstrapLazy;
-exports.createEvent = createEvent;
-exports.getElement = getElement;
-exports.h = h;
-exports.promiseResolve = promiseResolve;
-exports.registerInstance = registerInstance;
-exports.setNonce = setNonce;
+export { BUILD as B, H, NAMESPACE as N, Host as a, bootstrapLazy as b, consoleDevInfo as c, doc as d, createEvent as e, getElement as g, h, promiseResolve as p, registerInstance as r, setNonce as s };
 
-//# sourceMappingURL=index-ed42e2ee.js.map
+//# sourceMappingURL=index-cccc19b7.js.map