@qwik.dev/core 2.0.0-beta.26 → 2.0.0-beta.28

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.26-dev+c693cf5
+ * @qwik.dev/core 2.0.0-beta.28-dev+fac55b7
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -10,12 +10,13 @@ export { isBrowser, isDev, isServer } from '@qwik.dev/core/build';
 import { p } from '@qwik.dev/core/preloader';
 
 // same as isDev but separate so we can test
-const qDev = globalThis.qDev !== false;
-const qInspector = globalThis.qInspector === true;
-const qSerialize = globalThis.qSerialize !== false;
-const qDynamicPlatform = globalThis.qDynamicPlatform !== false;
-const qTest = globalThis.qTest === true;
-const qRuntimeQrl = globalThis.qRuntimeQrl === true;
+const g = globalThis;
+const qDev = g.qDev !== false;
+const qInspector = g.qInspector === true;
+const qSerialize = g.qSerialize !== false;
+const qDynamicPlatform = g.qDynamicPlatform !== false;
+const qTest = g.qTest === true;
+const qRuntimeQrl = g.qRuntimeQrl === true;
 const seal = (obj) => {
     if (qDev) {
         Object.seal(obj);
@@ -199,7 +200,7 @@ const codeToText = (code, ...parts) => {
             'Only primitive and object literals can be serialized. {{0}}', // 3
             'You can render over a existing q:container. Skipping render().', // 4
             'QRL is not a function', // 5
-            'Dynamic import not found', // 6
+            'Dynamic import {{0}} not found', // 6
             'Unknown type argument', // 7
             `Actual value for useContext({{0}}) can not be found, make sure some ancestor component has set a value using useContextProvider(). In the browser make sure that the context was used during SSR so its state was serialized.`, // 8
             "Invoking 'use*()' method outside of invocation context.", // 9
@@ -1007,7 +1008,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.26-dev+c693cf5";
+const version = "2.0.0-beta.28-dev+fac55b7";
 
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
@@ -1670,28 +1671,6 @@ class SignalImpl {
         return { value: this.$untrackedValue$ };
     }
 }
-const setupSignalValueAccess = (target, effectsProp, valueProp) => {
-    const ctx = tryGetInvokeContext();
-    // We need a container for this
-    // Grab the container if we have access to it
-    if (ctx && (target.$container$ ||= ctx.$container$ || null)) {
-        isDev &&
-            assertTrue(!ctx.$container$ || ctx.$container$ === target.$container$, 'Do not use signals across containers');
-        const effectSubscriber = ctx.$effectSubscriber$;
-        if (effectSubscriber) {
-            // Let's make sure that we have a reference to this effect.
-            // Adding reference is essentially adding a subscription, so if the signal
-            // changes we know who to notify.
-            ensureContainsSubscription((target[effectsProp] ||= new Set()), effectSubscriber);
-            // But when effect is scheduled in needs to be able to know which signals
-            // to unsubscribe from. So we need to store the reference from the effect back
-            // to this signal.
-            ensureContainsBackRef(effectSubscriber, target);
-            addQrlToSerializationCtx(effectSubscriber, target.$container$);
-        }
-    }
-    return target[valueProp];
-};
 
 /** @internal */
 const _CONST_PROPS = Symbol('CONST');
@@ -2187,7 +2166,8 @@ class AsyncJob {
     }
     /** Backward compatible cache method for resource */
     cache() {
-        console.error('useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior.');
+        isDev &&
+            console.error('useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior.');
     }
     get previous() {
         const val = this.$signal$.$untrackedValue$;
@@ -2266,7 +2246,9 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         if ((import.meta.env.TEST ? isServerPlatform() : isServer) &&
             this.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */ &&
             this.$untrackedValue$ === NEEDS_COMPUTATION) {
-            throw new Error('During SSR, cannot read .value from clientOnly async signal without an initial value. Use .loading or provide an initial value.');
+            throw new Error(isDev
+                ? 'During SSR, cannot read .value from clientOnly async signal without an initial value. Use .loading or provide an initial value.'
+                : 'Cannot read .value from clientOnly');
         }
         return this.$untrackedValue$;
     }
@@ -2281,7 +2263,19 @@ class AsyncSignalImpl extends ComputedSignalImpl {
      * `signal.loading ? <Loading /> : signal.value`.
      */
     get loading() {
-        return setupSignalValueAccess(this, '$loadingEffects$', 'untrackedLoading');
+        const val = this.untrackedLoading;
+        const ctx = tryGetInvokeContext();
+        if (ctx && (this.$container$ ||= ctx.$container$ || null)) {
+            isDev &&
+                assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, 'Do not use signals across containers');
+            const effectSubscriber = ctx.$effectSubscriber$;
+            if (effectSubscriber) {
+                ensureContainsSubscription((this.$loadingEffects$ ||= new Set()), effectSubscriber);
+                ensureContainsBackRef(effectSubscriber, this);
+                addQrlToSerializationCtx(effectSubscriber, this.$container$);
+            }
+        }
+        return val;
     }
     set untrackedLoading(value) {
         if (value !== this.$untrackedLoading$) {
@@ -2300,7 +2294,19 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     }
     /** The error that occurred when the signal was resolved. */
     get error() {
-        return setupSignalValueAccess(this, '$errorEffects$', 'untrackedError');
+        const val = this.untrackedError;
+        const ctx = tryGetInvokeContext();
+        if (ctx && (this.$container$ ||= ctx.$container$ || null)) {
+            isDev &&
+                assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, 'Do not use signals across containers');
+            const effectSubscriber = ctx.$effectSubscriber$;
+            if (effectSubscriber) {
+                ensureContainsSubscription((this.$errorEffects$ ||= new Set()), effectSubscriber);
+                ensureContainsBackRef(effectSubscriber, this);
+                addQrlToSerializationCtx(effectSubscriber, this.$container$);
+            }
+        }
+        return val;
     }
     set untrackedError(value) {
         if (value !== this.$untrackedError$) {
@@ -2942,15 +2948,17 @@ const _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 class JSXNodeImpl {
     type;
     children;
+    flags;
     toSort;
     key;
     varProps;
     constProps;
     dev;
     _proxy = null;
-    constructor(type, varProps, constProps, children, key, toSort, dev) {
+    constructor(type, varProps, constProps, children, flags, key, toSort, dev) {
         this.type = type;
         this.children = children;
+        this.flags = flags;
         this.toSort = !!toSort;
         this.key = key === null || key === undefined ? null : typeof key === 'string' ? key : '' + key;
         this.varProps = !varProps || isObjectEmpty(varProps) ? EMPTY_OBJ : varProps;
@@ -3029,7 +3037,7 @@ const _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 const _jsxSorted = (type, varProps, constProps, children, 
 // TODO use this to know static parts of the tree
 flags, key, dev) => {
-    return new JSXNodeImpl(type, varProps, constProps, children, key, false, dev);
+    return new JSXNodeImpl(type, varProps, constProps, children, flags, key, false, dev);
 };
 /**
  * Create a JSXNode, with the properties split into variable and constant parts, but the variable
@@ -3228,7 +3236,7 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
             }
         }
     }
-    return new JSXNodeImpl(type, varProps, constProps, children, key, toSort || true, dev);
+    return new JSXNodeImpl(type, varProps, constProps, children, flags, key, toSort || true, dev);
 };
 /** @internal @deprecated v1 compat */
 const _jsxC = (type, mutable, _flags, key) => jsx(type, mutable, key);
@@ -3289,7 +3297,7 @@ function h(type, props, ...children) {
 const Fragment = (props) => props.children;
 /** @public */
 const RenderOnce = (props, key) => {
-    return new JSXNodeImpl(Virtual, null, null, props.children, key);
+    return new JSXNodeImpl(Virtual, null, null, props.children, 0, key);
 };
 
 /**
@@ -3549,7 +3557,7 @@ function injectPlaceholderElement(jsx) {
 }
 /** @returns An empty <script> element for adding qwik metadata attributes to */
 function createPlaceholderScriptNode() {
-    return new JSXNodeImpl('script', null, { hidden: '' }, null, null);
+    return new JSXNodeImpl('script', null, { hidden: '' }, null, 0, null);
 }
 
 /**
@@ -3637,7 +3645,7 @@ const _restProps = (props, omit = [], target = {}) => {
             varPropsTarget[key] = varProps[key];
         }
     }
-    return createPropsProxy(new JSXNodeImpl(null, varPropsTarget, constPropsTarget, null, null));
+    return createPropsProxy(new JSXNodeImpl(null, varPropsTarget, constPropsTarget, null, 0, null));
 };
 
 class DeleteOperation {
@@ -3781,31 +3789,31 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
 }
 function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
     return {
-        container,
-        journal,
-        cursor,
-        scopedStyleIdPrefix,
-        stack: [],
-        asyncQueue: [],
-        asyncAttributePromises: [],
-        vParent: null,
-        vCurrent: null,
-        vNewNode: null,
-        vSiblings: null,
-        vSiblingsArray: null,
-        vSideBuffer: null,
-        jsxChildren: null,
-        jsxValue: null,
-        jsxIdx: 0,
-        jsxCount: 0,
-        shouldAdvance: true,
-        isCreationMode: false,
-        subscriptionData: {
-            const: new SubscriptionData({
+        $container$: container,
+        $journal$: journal,
+        $cursor$: cursor,
+        $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+        $stack$: [],
+        $asyncQueue$: [],
+        $asyncAttributePromises$: [],
+        $vParent$: null,
+        $vCurrent$: null,
+        $vNewNode$: null,
+        $vSiblings$: null,
+        $vSiblingsArray$: null,
+        $vSideBuffer$: null,
+        $jsxChildren$: null,
+        $jsxValue$: null,
+        $jsxIdx$: 0,
+        $jsxCount$: 0,
+        $shouldAdvance$: true,
+        $isCreationMode$: false,
+        $subscriptionData$: {
+            $const$: new SubscriptionData({
                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
                 $isConst$: true,
             }),
-            var: new SubscriptionData({
+            $var$: new SubscriptionData({
                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
                 $isConst$: false,
             }),
@@ -3833,56 +3841,56 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
 function diff(diffContext, jsxNode, vStartNode) {
     isDev && assertFalse(vnode_isVNode(jsxNode), 'JSXNode should not be a VNode');
     isDev && assertTrue(vnode_isVNode(vStartNode), 'vStartNode should be a VNode');
-    diffContext.vParent = vStartNode;
-    diffContext.vNewNode = null;
-    diffContext.vCurrent = vnode_getFirstChild(vStartNode);
+    diffContext.$vParent$ = vStartNode;
+    diffContext.$vNewNode$ = null;
+    diffContext.$vCurrent$ = vnode_getFirstChild(vStartNode);
     stackPush(diffContext, jsxNode, true);
-    if (diffContext.vParent.flags & 32 /* VNodeFlags.Deleted */) {
+    if (diffContext.$vParent$.flags & 32 /* VNodeFlags.Deleted */) {
         // Ignore diff if the parent is deleted.
         return;
     }
-    while (diffContext.stack.length) {
-        while (diffContext.jsxIdx < diffContext.jsxCount) {
+    while (diffContext.$stack$.length) {
+        while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
             isDev &&
-                assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same");
-            if (typeof diffContext.jsxValue === 'string') {
-                expectText(diffContext, diffContext.jsxValue);
+                assertFalse(diffContext.$vParent$ === diffContext.$vCurrent$, "Parent and current can't be the same");
+            if (typeof diffContext.$jsxValue$ === 'string') {
+                expectText(diffContext, diffContext.$jsxValue$);
             }
-            else if (typeof diffContext.jsxValue === 'number') {
-                expectText(diffContext, String(diffContext.jsxValue));
+            else if (typeof diffContext.$jsxValue$ === 'number') {
+                expectText(diffContext, String(diffContext.$jsxValue$));
             }
-            else if (diffContext.jsxValue && typeof diffContext.jsxValue === 'object') {
-                if (isJSXNode(diffContext.jsxValue)) {
-                    const type = diffContext.jsxValue.type;
+            else if (diffContext.$jsxValue$ && typeof diffContext.$jsxValue$ === 'object') {
+                if (isJSXNode(diffContext.$jsxValue$)) {
+                    const type = diffContext.$jsxValue$.type;
                     if (typeof type === 'string') {
                         expectNoTextNode(diffContext);
-                        expectElement(diffContext, diffContext.jsxValue, type);
-                        const hasDangerousInnerHTML = (diffContext.jsxValue.constProps &&
-                            _hasOwnProperty.call(diffContext.jsxValue.constProps, dangerouslySetInnerHTML)) ||
-                            _hasOwnProperty.call(diffContext.jsxValue.varProps, dangerouslySetInnerHTML);
+                        expectElement(diffContext, diffContext.$jsxValue$, type);
+                        const hasDangerousInnerHTML = (diffContext.$jsxValue$.constProps &&
+                            _hasOwnProperty.call(diffContext.$jsxValue$.constProps, dangerouslySetInnerHTML)) ||
+                            _hasOwnProperty.call(diffContext.$jsxValue$.varProps, dangerouslySetInnerHTML);
                         if (hasDangerousInnerHTML) {
                             expectNoChildren(diffContext, false);
                         }
                         else {
-                            descend(diffContext, diffContext.jsxValue.children, true);
+                            descend(diffContext, diffContext.$jsxValue$.children, true);
                         }
                     }
                     else if (typeof type === 'function') {
                         if (type === Fragment) {
                             expectNoTextNode(diffContext);
-                            expectVirtual(diffContext, "F" /* VirtualType.Fragment */, diffContext.jsxValue.key);
-                            descend(diffContext, diffContext.jsxValue.children, true);
+                            expectVirtual(diffContext, "F" /* VirtualType.Fragment */, diffContext.$jsxValue$.key);
+                            descend(diffContext, diffContext.$jsxValue$.children, true);
                         }
                         else if (type === Slot) {
                             expectNoTextNode(diffContext);
                             if (!expectSlot(diffContext)) {
                                 // nothing to project, so try to render the Slot default content.
-                                descend(diffContext, diffContext.jsxValue.children, true);
+                                descend(diffContext, diffContext.$jsxValue$.children, true);
                             }
                         }
                         else if (type === Projection) {
                             expectProjection(diffContext);
-                            descend(diffContext, diffContext.jsxValue.children, true, 
+                            descend(diffContext, diffContext.$jsxValue$.children, true, 
                             // special case for projection, we don't want to expect no children
                             // because the projection's children are not removed
                             false);
@@ -3900,30 +3908,30 @@ function diff(diffContext, jsxNode, vStartNode) {
                         }
                     }
                 }
-                else if (Array.isArray(diffContext.jsxValue)) {
-                    descend(diffContext, diffContext.jsxValue, false);
+                else if (Array.isArray(diffContext.$jsxValue$)) {
+                    descend(diffContext, diffContext.$jsxValue$, false);
                 }
-                else if (isSignal(diffContext.jsxValue)) {
+                else if (isSignal(diffContext.$jsxValue$)) {
                     expectVirtual(diffContext, "S" /* VirtualType.WrappedSignal */, null);
-                    const unwrappedSignal = diffContext.jsxValue instanceof WrappedSignalImpl
-                        ? diffContext.jsxValue.$unwrapIfSignal$()
-                        : diffContext.jsxValue;
-                    const signals = diffContext.vCurrent?.[_EFFECT_BACK_REF]?.get("." /* EffectProperty.VNODE */)?.backRef;
+                    const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl
+                        ? diffContext.$jsxValue$.$unwrapIfSignal$()
+                        : diffContext.$jsxValue$;
+                    const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get("." /* EffectProperty.VNODE */)?.backRef;
                     let hasUnwrappedSignal = signals?.has(unwrappedSignal);
                     if (signals && unwrappedSignal instanceof WrappedSignalImpl) {
                         hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal);
                     }
                     if (!hasUnwrappedSignal) {
-                        const vHost = (diffContext.vNewNode || diffContext.vCurrent);
-                        descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, "." /* EffectProperty.VNODE */, diffContext.container)), true);
+                        const vHost = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
+                        descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, "." /* EffectProperty.VNODE */, diffContext.$container$)), true);
                     }
                 }
-                else if (isPromise(diffContext.jsxValue)) {
+                else if (isPromise(diffContext.$jsxValue$)) {
                     expectVirtual(diffContext, "A" /* VirtualType.Awaited */, null);
-                    diffContext.asyncQueue.push(diffContext.jsxValue, diffContext.vNewNode || diffContext.vCurrent);
+                    diffContext.$asyncQueue$.push(diffContext.$jsxValue$, diffContext.$vNewNode$ || diffContext.$vCurrent$);
                 }
             }
-            else if (diffContext.jsxValue === SkipRender) ;
+            else if (diffContext.$jsxValue$ === SkipRender) ;
             else {
                 expectText(diffContext, '');
             }
@@ -3943,35 +3951,35 @@ function resolveSignalAndDescend(diffContext, fn) {
         if (isPromise(e)) {
             // The thrown promise will resolve when the signal is ready, then retry fn() with retry logic
             const retryPromise = e.then(() => retryOnPromise(fn));
-            diffContext.asyncQueue.push(retryPromise, diffContext.vNewNode || diffContext.vCurrent);
+            diffContext.$asyncQueue$.push(retryPromise, diffContext.$vNewNode$ || diffContext.$vCurrent$);
             return null;
         }
         throw e;
     }
 }
 function advance(diffContext) {
-    if (!diffContext.shouldAdvance) {
-        diffContext.shouldAdvance = true;
+    if (!diffContext.$shouldAdvance$) {
+        diffContext.$shouldAdvance$ = true;
         return;
     }
-    diffContext.jsxIdx++;
-    if (diffContext.jsxIdx < diffContext.jsxCount) {
-        diffContext.jsxValue = diffContext.jsxChildren[diffContext.jsxIdx];
+    diffContext.$jsxIdx$++;
+    if (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
+        diffContext.$jsxValue$ = diffContext.$jsxChildren$[diffContext.$jsxIdx$];
     }
-    else if (diffContext.stack.length > 0 &&
-        diffContext.stack[diffContext.stack.length - 1] === false) {
+    else if (diffContext.$stack$.length > 0 &&
+        diffContext.$stack$[diffContext.$stack$.length - 1] === false) {
         // this was special `descendVNode === false` so pop and try again
         return ascend(diffContext);
     }
-    if (diffContext.vNewNode !== null) {
+    if (diffContext.$vNewNode$ !== null) {
         // We have a new Node.
         // This means that the `vCurrent` was deemed not useful and we inserted in front of it.
         // This means that the next node we should look at is the `vCurrent` so just clear the
         // vNewNode  and try again.
-        diffContext.vNewNode = null;
+        diffContext.$vNewNode$ = null;
     }
     else {
-        diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
+        diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
     }
 }
 /**
@@ -4002,69 +4010,69 @@ function descend(diffContext, children, descendVNode, shouldExpectNoChildren = t
     stackPush(diffContext, children, descendVNode);
     if (descendVNode) {
         isDev &&
-            assertDefined(diffContext.vCurrent || diffContext.vNewNode, 'Expecting vCurrent to be defined.');
-        const creationMode = diffContext.isCreationMode ||
-            !!diffContext.vNewNode ||
-            !vnode_getFirstChild(diffContext.vCurrent);
-        diffContext.isCreationMode = creationMode;
-        diffContext.vSideBuffer = null;
-        diffContext.vSiblings = null;
-        diffContext.vSiblingsArray = null;
-        diffContext.vParent = (diffContext.vNewNode || diffContext.vCurrent);
-        diffContext.vCurrent = vnode_getFirstChild(diffContext.vParent);
-        diffContext.vNewNode = null;
-    }
-    diffContext.shouldAdvance = false;
+            assertDefined(diffContext.$vCurrent$ || diffContext.$vNewNode$, 'Expecting vCurrent to be defined.');
+        const creationMode = diffContext.$isCreationMode$ ||
+            !!diffContext.$vNewNode$ ||
+            !vnode_getFirstChild(diffContext.$vCurrent$);
+        diffContext.$isCreationMode$ = creationMode;
+        diffContext.$vSideBuffer$ = null;
+        diffContext.$vSiblings$ = null;
+        diffContext.$vSiblingsArray$ = null;
+        diffContext.$vParent$ = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
+        diffContext.$vCurrent$ = vnode_getFirstChild(diffContext.$vParent$);
+        diffContext.$vNewNode$ = null;
+    }
+    diffContext.$shouldAdvance$ = false;
 }
 function ascend(diffContext) {
-    const descendVNode = diffContext.stack.pop(); // boolean: descendVNode
+    const descendVNode = diffContext.$stack$.pop(); // boolean: descendVNode
     if (descendVNode) {
-        diffContext.isCreationMode = diffContext.stack.pop();
-        diffContext.vSideBuffer = diffContext.stack.pop();
-        diffContext.vSiblings = diffContext.stack.pop();
-        diffContext.vSiblingsArray = diffContext.stack.pop();
-        diffContext.vNewNode = diffContext.stack.pop();
-        diffContext.vCurrent = diffContext.stack.pop();
-        diffContext.vParent = diffContext.stack.pop();
-    }
-    diffContext.jsxValue = diffContext.stack.pop();
-    diffContext.jsxCount = diffContext.stack.pop();
-    diffContext.jsxIdx = diffContext.stack.pop();
-    diffContext.jsxChildren = diffContext.stack.pop();
+        diffContext.$isCreationMode$ = diffContext.$stack$.pop();
+        diffContext.$vSideBuffer$ = diffContext.$stack$.pop();
+        diffContext.$vSiblings$ = diffContext.$stack$.pop();
+        diffContext.$vSiblingsArray$ = diffContext.$stack$.pop();
+        diffContext.$vNewNode$ = diffContext.$stack$.pop();
+        diffContext.$vCurrent$ = diffContext.$stack$.pop();
+        diffContext.$vParent$ = diffContext.$stack$.pop();
+    }
+    diffContext.$jsxValue$ = diffContext.$stack$.pop();
+    diffContext.$jsxCount$ = diffContext.$stack$.pop();
+    diffContext.$jsxIdx$ = diffContext.$stack$.pop();
+    diffContext.$jsxChildren$ = diffContext.$stack$.pop();
     advance(diffContext);
 }
 function stackPush(diffContext, children, descendVNode) {
-    diffContext.stack.push(diffContext.jsxChildren, diffContext.jsxIdx, diffContext.jsxCount, diffContext.jsxValue);
+    diffContext.$stack$.push(diffContext.$jsxChildren$, diffContext.$jsxIdx$, diffContext.$jsxCount$, diffContext.$jsxValue$);
     if (descendVNode) {
-        diffContext.stack.push(diffContext.vParent, diffContext.vCurrent, diffContext.vNewNode, diffContext.vSiblingsArray, diffContext.vSiblings, diffContext.vSideBuffer, diffContext.isCreationMode);
+        diffContext.$stack$.push(diffContext.$vParent$, diffContext.$vCurrent$, diffContext.$vNewNode$, diffContext.$vSiblingsArray$, diffContext.$vSiblings$, diffContext.$vSideBuffer$, diffContext.$isCreationMode$);
     }
-    diffContext.stack.push(descendVNode);
+    diffContext.$stack$.push(descendVNode);
     if (Array.isArray(children)) {
-        diffContext.jsxIdx = 0;
-        diffContext.jsxCount = children.length;
-        diffContext.jsxChildren = children;
-        diffContext.jsxValue = diffContext.jsxCount > 0 ? children[0] : null;
+        diffContext.$jsxIdx$ = 0;
+        diffContext.$jsxCount$ = children.length;
+        diffContext.$jsxChildren$ = children;
+        diffContext.$jsxValue$ = diffContext.$jsxCount$ > 0 ? children[0] : null;
     }
     else if (children === undefined) {
         // no children
-        diffContext.jsxIdx = 0;
-        diffContext.jsxValue = null;
-        diffContext.jsxChildren = null;
-        diffContext.jsxCount = 0;
+        diffContext.$jsxIdx$ = 0;
+        diffContext.$jsxValue$ = null;
+        diffContext.$jsxChildren$ = null;
+        diffContext.$jsxCount$ = 0;
     }
     else {
-        diffContext.jsxIdx = 0;
-        diffContext.jsxValue = children;
-        diffContext.jsxChildren = null;
-        diffContext.jsxCount = 1;
+        diffContext.$jsxIdx$ = 0;
+        diffContext.$jsxValue$ = children;
+        diffContext.$jsxChildren$ = null;
+        diffContext.$jsxCount$ = 1;
     }
 }
 function getInsertBefore(diffContext) {
-    if (diffContext.vNewNode) {
-        return diffContext.vCurrent;
+    if (diffContext.$vNewNode$) {
+        return diffContext.$vCurrent$;
     }
     else {
-        return peekNextSibling(diffContext.vCurrent);
+        return peekNextSibling(diffContext.$vCurrent$);
     }
 }
 /////////////////////////////////////////////////////////////////////////////
@@ -4073,7 +4081,7 @@ function getInsertBefore(diffContext) {
 function descendContentToProject(diffContext, children, host) {
     const projectionChildren = Array.isArray(children) ? children : [children];
     const createProjectionJSXNode = (slotName) => {
-        return new JSXNodeImpl(Projection, null, null, [], slotName);
+        return new JSXNodeImpl(Projection, null, null, [], 0, slotName);
     };
     const projections = [];
     if (host) {
@@ -4116,32 +4124,32 @@ function descendContentToProject(diffContext, children, host) {
     descend(diffContext, projections, true);
 }
 function expectProjection(diffContext) {
-    const jsxNode = diffContext.jsxValue;
+    const jsxNode = diffContext.$jsxValue$;
     const slotName = jsxNode.key;
     // console.log('expectProjection', JSON.stringify(slotName));
     // The parent is the component and it should have our portal.
-    diffContext.vCurrent = vnode_getProp(diffContext.vParent, slotName, (id) => vnode_locate(diffContext.container.rootVNode, id));
+    diffContext.$vCurrent$ = vnode_getProp(diffContext.$vParent$, slotName, (id) => vnode_locate(diffContext.$container$.rootVNode, id));
     // if projection is marked as deleted then we need to create a new one
-    diffContext.vCurrent =
-        diffContext.vCurrent && diffContext.vCurrent.flags & 32 /* VNodeFlags.Deleted */
+    diffContext.$vCurrent$ =
+        diffContext.$vCurrent$ && diffContext.$vCurrent$.flags & 32 /* VNodeFlags.Deleted */
             ? null
-            : diffContext.vCurrent;
-    if (diffContext.vCurrent == null) {
-        diffContext.vNewNode = vnode_newVirtual();
+            : diffContext.$vCurrent$;
+    if (diffContext.$vCurrent$ == null) {
+        diffContext.$vNewNode$ = vnode_newVirtual();
         // you may be tempted to add the projection into the current parent, but
         // that is wrong. We don't yet know if the projection will be projected, so
         // we should leave it unattached.
         // vNewNode[VNodeProps.parent] = vParent;
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
-        isDev && vnode_setProp(diffContext.vNewNode, 'q:code', 'expectProjection');
-        vnode_setProp(diffContext.vNewNode, QSlot, slotName);
-        diffContext.vNewNode.slotParent = diffContext.vParent;
-        vnode_setProp(diffContext.vParent, slotName, diffContext.vNewNode);
+            vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
+        isDev && vnode_setProp(diffContext.$vNewNode$, 'q:code', 'expectProjection');
+        vnode_setProp(diffContext.$vNewNode$, QSlot, slotName);
+        diffContext.$vNewNode$.slotParent = diffContext.$vParent$;
+        vnode_setProp(diffContext.$vParent$, slotName, diffContext.$vNewNode$);
     }
 }
 function expectSlot(diffContext) {
-    const vHost = vnode_getProjectionParentComponent(diffContext.vParent);
+    const vHost = vnode_getProjectionParentComponent(diffContext.$vParent$);
     const slotNameKey = getSlotNameKey(diffContext, vHost);
     const vProjectedNode = vHost
         ? vnode_getProp(vHost, slotNameKey, 
@@ -4151,65 +4159,65 @@ function expectSlot(diffContext) {
         )
         : null;
     if (vProjectedNode == null) {
-        diffContext.vNewNode = vnode_newVirtual();
-        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-        vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
+        diffContext.$vNewNode$ = vnode_newVirtual();
+        vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+        vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
+            vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
+        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$ && getInsertBefore(diffContext));
         return false;
     }
-    else if (vProjectedNode === diffContext.vCurrent) ;
+    else if (vProjectedNode === diffContext.$vCurrent$) ;
     else {
         // move from q:template to the target node
         const oldParent = vProjectedNode.parent;
-        diffContext.vNewNode = vProjectedNode;
-        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-        vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
+        diffContext.$vNewNode$ = vProjectedNode;
+        vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+        vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
-        vnode_inflateProjectionTrailingText(diffContext.journal, diffContext.vNewNode);
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
+            vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
+        vnode_inflateProjectionTrailingText(diffContext.$journal$, diffContext.$vNewNode$);
+        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$ && getInsertBefore(diffContext));
         // If we moved from a q:template and it's now empty, remove it
         if (oldParent &&
             vnode_isElementVNode(oldParent) &&
             !oldParent.firstChild &&
             vnode_getElementName(oldParent) === QTemplate) {
-            vnode_remove(diffContext.journal, oldParent.parent, oldParent, true);
+            vnode_remove(diffContext.$journal$, oldParent.parent, oldParent, true);
         }
     }
     return true;
 }
 function getSlotNameKey(diffContext, vHost) {
-    const jsxNode = diffContext.jsxValue;
+    const jsxNode = diffContext.$jsxValue$;
     const constProps = jsxNode.constProps;
     if (constProps && typeof constProps == 'object' && _hasOwnProperty.call(constProps, 'name')) {
         const constValue = constProps.name;
         if (vHost && constValue instanceof WrappedSignalImpl) {
-            return trackSignalAndAssignHost(constValue, vHost, ":" /* EffectProperty.COMPONENT */, diffContext.container);
+            return trackSignalAndAssignHost(constValue, vHost, ":" /* EffectProperty.COMPONENT */, diffContext.$container$);
         }
     }
     return directGetPropsProxyProp(jsxNode, 'name') || QDefaultSlot;
 }
 function cleanupSideBuffer(diffContext) {
-    if (diffContext.vSideBuffer) {
+    if (diffContext.$vSideBuffer$) {
         // Remove all nodes in the side buffer as they are no longer needed
-        for (const vNode of diffContext.vSideBuffer.values()) {
+        for (const vNode of diffContext.$vSideBuffer$.values()) {
             if (vNode.flags & 32 /* VNodeFlags.Deleted */) {
                 continue;
             }
-            cleanup(diffContext.container, diffContext.journal, vNode, diffContext.cursor);
-            vnode_remove(diffContext.journal, diffContext.vParent, vNode, true);
+            cleanup(diffContext.$container$, diffContext.$journal$, vNode, diffContext.$cursor$);
+            vnode_remove(diffContext.$journal$, diffContext.$vParent$, vNode, true);
         }
-        diffContext.vSideBuffer.clear();
-        diffContext.vSideBuffer = null;
+        diffContext.$vSideBuffer$.clear();
+        diffContext.$vSideBuffer$ = null;
     }
-    diffContext.vCurrent = null;
+    diffContext.$vCurrent$ = null;
 }
 function drainAsyncQueue(diffContext) {
-    while (diffContext.asyncQueue.length) {
-        const jsxNode = diffContext.asyncQueue.shift();
-        const vHostNode = diffContext.asyncQueue.shift();
+    while (diffContext.$asyncQueue$.length) {
+        const jsxNode = diffContext.$asyncQueue$.shift();
+        const vHostNode = diffContext.$asyncQueue$.shift();
         if (isPromise(jsxNode)) {
             return jsxNode
                 .then((jsxNode) => {
@@ -4217,7 +4225,7 @@ function drainAsyncQueue(diffContext) {
                 return drainAsyncQueue(diffContext);
             })
                 .catch((e) => {
-                diffContext.container.handleError(e, vHostNode);
+                diffContext.$container$.handleError(e, vHostNode);
                 return drainAsyncQueue(diffContext);
             });
         }
@@ -4226,8 +4234,8 @@ function drainAsyncQueue(diffContext) {
         }
     }
     // Wait for all async attribute promises to complete, then check for more work
-    if (diffContext.asyncAttributePromises.length) {
-        const promises = diffContext.asyncAttributePromises.splice(0);
+    if (diffContext.$asyncAttributePromises$.length) {
+        const promises = diffContext.$asyncAttributePromises$.splice(0);
         return Promise.all(promises).then(() => {
             // After attributes are set, check if there's more work in the queue
             return drainAsyncQueue(diffContext);
@@ -4235,42 +4243,42 @@ function drainAsyncQueue(diffContext) {
     }
 }
 function cleanupDiffContext(diffContext) {
-    diffContext.journal = null;
-    diffContext.cursor = null;
+    diffContext.$journal$ = null;
+    diffContext.$cursor$ = null;
 }
 function expectNoChildren(diffContext, removeDOM = true) {
-    const vFirstChild = diffContext.vCurrent && vnode_getFirstChild(diffContext.vCurrent);
+    const vFirstChild = diffContext.$vCurrent$ && vnode_getFirstChild(diffContext.$vCurrent$);
     if (vFirstChild !== null) {
         let vChild = vFirstChild;
         while (vChild) {
-            cleanup(diffContext.container, diffContext.journal, vChild, diffContext.cursor);
+            cleanup(diffContext.$container$, diffContext.$journal$, vChild, diffContext.$cursor$);
             vChild = vChild.nextSibling;
         }
-        vnode_truncate(diffContext.journal, diffContext.vCurrent, vFirstChild, removeDOM);
+        vnode_truncate(diffContext.$journal$, diffContext.$vCurrent$, vFirstChild, removeDOM);
     }
 }
 /** Expect no more nodes - Any nodes which are still at cursor, need to be removed. */
 function expectNoMore(diffContext) {
     isDev &&
-        assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same");
-    if (diffContext.vCurrent !== null) {
-        while (diffContext.vCurrent) {
-            const toRemove = diffContext.vCurrent;
-            diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
-            if (diffContext.vParent === toRemove.parent) {
-                cleanup(diffContext.container, diffContext.journal, toRemove, diffContext.cursor);
+        assertFalse(diffContext.$vParent$ === diffContext.$vCurrent$, "Parent and current can't be the same");
+    if (diffContext.$vCurrent$ !== null) {
+        while (diffContext.$vCurrent$) {
+            const toRemove = diffContext.$vCurrent$;
+            diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+            if (diffContext.$vParent$ === toRemove.parent) {
+                cleanup(diffContext.$container$, diffContext.$journal$, toRemove, diffContext.$cursor$);
                 // If we are diffing projection than the parent is not the parent of the node.
                 // If that is the case we don't want to remove the node from the parent.
-                vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
+                vnode_remove(diffContext.$journal$, diffContext.$vParent$, toRemove, true);
             }
         }
     }
 }
 function expectNoTextNode(diffContext) {
-    if (diffContext.vCurrent !== null && vnode_isTextVNode(diffContext.vCurrent)) {
-        const toRemove = diffContext.vCurrent;
-        diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
-        vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
+    if (diffContext.$vCurrent$ !== null && vnode_isTextVNode(diffContext.$vCurrent$)) {
+        const toRemove = diffContext.$vCurrent$;
+        diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+        vnode_remove(diffContext.$journal$, diffContext.$vParent$, toRemove, true);
     }
 }
 function createNewElement(diffContext, jsx, elementName, currentFile) {
@@ -4283,7 +4291,7 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
         for (const key in constProps) {
             let value = constProps[key];
             if (isHtmlAttributeAnEventName(key)) {
-                registerEventHandlers(key, value, element, diffContext.vNewNode, diffContext);
+                registerEventHandlers(key, value, element, diffContext.$vNewNode$, diffContext);
                 continue;
             }
             if (key === 'ref') {
@@ -4303,14 +4311,14 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
                 }
             }
             if (isSignal(value)) {
-                const vHost = diffContext.vNewNode;
+                const vHost = diffContext.$vNewNode$;
                 const signal = value;
-                value = retryOnPromise(() => trackSignalAndAssignHost(signal, vHost, key, diffContext.container, diffContext.subscriptionData.const));
+                value = retryOnPromise(() => trackSignalAndAssignHost(signal, vHost, key, diffContext.$container$, diffContext.$subscriptionData$.$const$));
             }
             if (isPromise(value)) {
-                const vHost = diffContext.vNewNode;
-                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.scopedStyleIdPrefix), (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
-                diffContext.asyncAttributePromises.push(attributePromise);
+                const vHost = diffContext.$vNewNode$;
+                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.$scopedStyleIdPrefix$), (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
+                diffContext.$asyncAttributePromises$.push(attributePromise);
                 continue;
             }
             if (key === dangerouslySetInnerHTML) {
@@ -4330,22 +4338,22 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
                 element.value = escapeHTML(value || '');
                 continue;
             }
-            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.scopedStyleIdPrefix), (diffContext.vNewNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
+            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.$scopedStyleIdPrefix$), (diffContext.$vNewNode$.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
         }
     }
     const key = jsx.key;
     if (key) {
-        diffContext.vNewNode.key = key;
+        diffContext.$vNewNode$.key = key;
     }
     // append class attribute if styleScopedId exists and there is no class attribute
-    if (diffContext.scopedStyleIdPrefix) {
+    if (diffContext.$scopedStyleIdPrefix$) {
         const classAttributeExists = _hasOwnProperty.call(jsx.varProps, 'class') ||
             (jsx.constProps && _hasOwnProperty.call(jsx.constProps, 'class'));
         if (!classAttributeExists) {
-            element.setAttribute('class', diffContext.scopedStyleIdPrefix);
+            element.setAttribute('class', diffContext.$scopedStyleIdPrefix$);
         }
     }
-    vnode_insertElementBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent);
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$);
 }
 function registerEventHandlers(key, value, element, vnode, diffContext) {
     const scopedKebabName = key.slice(2);
@@ -4378,33 +4386,34 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
     // window and document events need attrs so qwik loader can find them
     // TODO only do these when not already present
     if (key.charAt(2) !== 'e') {
-        vnode_setAttr(diffContext.journal, vnode, key, '');
+        vnode_setAttr(diffContext.$journal$, vnode, key, '');
     }
     registerQwikLoaderEvent(diffContext, scopedKebabName);
 }
 function createElementWithNamespace(diffContext, elementName) {
-    const domParentVNode = vnode_getDomParentVNode(diffContext.vParent, true);
+    const domParentVNode = vnode_getDomParentVNode(diffContext.$vParent$, true);
     const namespaceData = getNewElementNamespaceData(domParentVNode, elementName);
-    const currentDocument = import.meta.env.TEST ? diffContext.container.document : document;
+    const currentDocument = import.meta.env.TEST ? diffContext.$container$.document : document;
     const element = namespaceData.elementNamespaceFlag === 0 /* VNodeFlags.NS_html */
         ? currentDocument.createElement(elementName)
         : currentDocument.createElementNS(namespaceData.elementNamespace, elementName);
-    diffContext.vNewNode = vnode_newElement(element, elementName);
-    diffContext.vNewNode.flags |= namespaceData.elementNamespaceFlag;
+    diffContext.$vNewNode$ = vnode_newElement(element, elementName);
+    diffContext.$vNewNode$.flags |= namespaceData.elementNamespaceFlag;
     return element;
 }
 function expectElement(diffContext, jsx, elementName) {
-    if (diffContext.isCreationMode) {
+    if (diffContext.$isCreationMode$) {
         createNewElement(diffContext, jsx, elementName, null);
     }
     else {
-        const isElementVNode = diffContext.vCurrent && vnode_isElementVNode(diffContext.vCurrent);
-        const isSameElementName = isElementVNode && elementName === vnode_getElementName(diffContext.vCurrent);
+        const isElementVNode = diffContext.$vCurrent$ && vnode_isElementVNode(diffContext.$vCurrent$);
+        const isSameElementName = isElementVNode &&
+            elementName === vnode_getElementName(diffContext.$vCurrent$);
         const jsxKey = jsx.key;
-        const currentKey = isElementVNode && diffContext.vCurrent.key;
+        const currentKey = isElementVNode && diffContext.$vCurrent$.key;
         if (!isSameElementName || jsxKey !== currentKey) {
             const sideBufferKey = getSideBufferKey(elementName, jsxKey);
-            if (moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.vParent)) {
+            if (moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.$vParent$)) {
                 createNewElement(diffContext, jsx, elementName, null);
             }
         }
@@ -4415,15 +4424,15 @@ function expectElement(diffContext, jsx, elementName) {
     }
     // reconcile attributes
     const jsxProps = jsx.varProps;
-    const vNode = (diffContext.vNewNode || diffContext.vCurrent);
+    const vNode = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
     if (jsxProps) {
         diffProps(diffContext, vNode, jsxProps, (isDev && getFileLocationFromJsx(jsx.dev)) || null);
     }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
-    if (!diffContext.isCreationMode) {
+    if (!diffContext.$isCreationMode$) {
         // inflate only resumed vnodes
-        vnode_ensureElementInflated(diffContext.container, vnode);
+        vnode_ensureElementInflated(diffContext.$container$, vnode);
     }
     const oldAttrs = vnode.props;
     // Actual diffing logic
@@ -4496,29 +4505,29 @@ const patchProperty = (diffContext, vnode, key, value, currentFile) => {
             return;
         }
         if (currentEffect) {
-            clearEffectSubscription(diffContext.container, currentEffect);
+            clearEffectSubscription(diffContext.$container$, currentEffect);
         }
         const vHost = vnode;
-        value = retryOnPromise(() => trackSignalAndAssignHost(unwrappedSignal, vHost, key, diffContext.container, diffContext.subscriptionData.var));
+        value = retryOnPromise(() => trackSignalAndAssignHost(unwrappedSignal, vHost, key, diffContext.$container$, diffContext.$subscriptionData$.$var$));
     }
     else {
         if (currentEffect) {
-            clearEffectSubscription(diffContext.container, currentEffect);
+            clearEffectSubscription(diffContext.$container$, currentEffect);
         }
     }
     if (isPromise(value)) {
         const vHost = vnode;
         const attributePromise = value.then((resolvedValue) => {
-            setAttribute(diffContext.journal, vHost, key, resolvedValue, diffContext.scopedStyleIdPrefix, originalValue);
+            setAttribute(diffContext.$journal$, vHost, key, resolvedValue, diffContext.$scopedStyleIdPrefix$, originalValue);
         });
-        diffContext.asyncAttributePromises.push(attributePromise);
+        diffContext.$asyncAttributePromises$.push(attributePromise);
         return;
     }
-    setAttribute(diffContext.journal, vnode, key, value, diffContext.scopedStyleIdPrefix, originalValue);
+    setAttribute(diffContext.$journal$, vnode, key, value, diffContext.$scopedStyleIdPrefix$, originalValue);
 };
 function registerQwikLoaderEvent(diffContext, eventName) {
     const qWindow = import.meta.env.TEST
-        ? diffContext.container.document.defaultView
+        ? diffContext.$container$.document.defaultView
         : window;
     if (qWindow) {
         (qWindow._qwikEv ||= []).push(eventName);
@@ -4526,35 +4535,35 @@ function registerQwikLoaderEvent(diffContext, eventName) {
 }
 function retrieveChildWithKey(diffContext, nodeName, key) {
     let vNodeWithKey = null;
-    if (diffContext.vSiblings === null) {
+    if (diffContext.$vSiblings$ === null) {
         // check if the current node is the one we are looking for
-        const vCurrent = diffContext.vCurrent;
+        const vCurrent = diffContext.$vCurrent$;
         if (vCurrent) {
             const name = vnode_isElementVNode(vCurrent) ? vnode_getElementName(vCurrent) : null;
             const vKey = getKey(vCurrent) ||
-                getComponentHash(vCurrent, diffContext.container.$getObjectById$);
+                getComponentHash(vCurrent, diffContext.$container$.$getObjectById$);
             if (vKey === key && name === nodeName) {
                 return vCurrent;
             }
         }
         // it is not materialized; so materialize it.
-        diffContext.vSiblings = new Map();
-        diffContext.vSiblingsArray = [];
-        let vNode = diffContext.vCurrent;
+        diffContext.$vSiblings$ = new Map();
+        diffContext.$vSiblingsArray$ = [];
+        let vNode = diffContext.$vCurrent$;
         while (vNode) {
             const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
             const vKey = getKey(vNode) ||
-                getComponentHash(vNode, diffContext.container.$getObjectById$);
+                getComponentHash(vNode, diffContext.$container$.$getObjectById$);
             if (vNodeWithKey === null && vKey == key && name == nodeName) {
                 vNodeWithKey = vNode;
             }
             else {
                 if (vKey === null) {
-                    diffContext.vSiblingsArray.push(name, vNode);
+                    diffContext.$vSiblingsArray$.push(name, vNode);
                 }
                 else {
                     // we only add the elements which we did not find yet.
-                    diffContext.vSiblings.set(getSideBufferKey(name, vKey), vNode);
+                    diffContext.$vSiblings$.set(getSideBufferKey(name, vKey), vNode);
                 }
             }
             vNode = vNode.nextSibling;
@@ -4562,20 +4571,20 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
     }
     else {
         if (key === null) {
-            for (let i = 0; i < diffContext.vSiblingsArray.length; i += 2) {
-                if (diffContext.vSiblingsArray[i] === nodeName) {
-                    vNodeWithKey = diffContext.vSiblingsArray[i + 1];
-                    diffContext.vSiblingsArray.splice(i, 2);
+            for (let i = 0; i < diffContext.$vSiblingsArray$.length; i += 2) {
+                if (diffContext.$vSiblingsArray$[i] === nodeName) {
+                    vNodeWithKey = diffContext.$vSiblingsArray$[i + 1];
+                    diffContext.$vSiblingsArray$.splice(i, 2);
                     break;
                 }
             }
         }
         else {
             const siblingsKey = getSideBufferKey(nodeName, key);
-            const sibling = diffContext.vSiblings.get(siblingsKey);
+            const sibling = diffContext.$vSiblings$.get(siblingsKey);
             if (sibling) {
                 vNodeWithKey = sibling;
-                diffContext.vSiblings.delete(siblingsKey);
+                diffContext.$vSiblings$.delete(siblingsKey);
             }
         }
     }
@@ -4584,32 +4593,32 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
 }
 function collectSideBufferSiblings(diffContext, targetNode) {
     if (!targetNode) {
-        if (diffContext.vCurrent) {
-            const name = vnode_isElementVNode(diffContext.vCurrent)
-                ? vnode_getElementName(diffContext.vCurrent)
+        if (diffContext.$vCurrent$) {
+            const name = vnode_isElementVNode(diffContext.$vCurrent$)
+                ? vnode_getElementName(diffContext.$vCurrent$)
                 : null;
-            const vKey = getKey(diffContext.vCurrent) ||
-                getComponentHash(diffContext.vCurrent, diffContext.container.$getObjectById$);
+            const vKey = getKey(diffContext.$vCurrent$) ||
+                getComponentHash(diffContext.$vCurrent$, diffContext.$container$.$getObjectById$);
             if (vKey != null) {
                 const sideBufferKey = getSideBufferKey(name, vKey);
-                diffContext.vSideBuffer ||= new Map();
-                diffContext.vSideBuffer.set(sideBufferKey, diffContext.vCurrent);
-                diffContext.vSiblings?.delete(sideBufferKey);
+                diffContext.$vSideBuffer$ ||= new Map();
+                diffContext.$vSideBuffer$.set(sideBufferKey, diffContext.$vCurrent$);
+                diffContext.$vSiblings$?.delete(sideBufferKey);
             }
         }
         return;
     }
     // Walk from vCurrent up to the target node and collect all keyed siblings
-    let vNode = diffContext.vCurrent;
+    let vNode = diffContext.$vCurrent$;
     while (vNode && vNode !== targetNode) {
         const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
         const vKey = getKey(vNode) ||
-            getComponentHash(vNode, diffContext.container.$getObjectById$);
+            getComponentHash(vNode, diffContext.$container$.$getObjectById$);
         if (vKey != null) {
             const sideBufferKey = getSideBufferKey(name, vKey);
-            diffContext.vSideBuffer ||= new Map();
-            diffContext.vSideBuffer.set(sideBufferKey, vNode);
-            diffContext.vSiblings?.delete(sideBufferKey);
+            diffContext.$vSideBuffer$ ||= new Map();
+            diffContext.$vSideBuffer$.set(sideBufferKey, vNode);
+            diffContext.$vSiblings$?.delete(sideBufferKey);
         }
         vNode = vNode.nextSibling;
     }
@@ -4622,8 +4631,8 @@ function getSideBufferKey(nodeName, key) {
 }
 function deleteFromSideBuffer(diffContext, nodeName, key) {
     const sbKey = getSideBufferKey(nodeName, key);
-    if (sbKey && diffContext.vSideBuffer?.has(sbKey)) {
-        diffContext.vSideBuffer.delete(sbKey);
+    if (sbKey && diffContext.$vSideBuffer$?.has(sbKey)) {
+        diffContext.$vSideBuffer$.delete(sbKey);
         return true;
     }
     return false;
@@ -4641,40 +4650,40 @@ function deleteFromSideBuffer(diffContext, nodeName, key) {
  */
 function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey, parentForInsert, addCurrentToSideBufferOnSideInsert) {
     // 1) Try to find the node among upcoming siblings
-    diffContext.vNewNode = retrieveChildWithKey(diffContext, nodeName, lookupKey);
-    if (diffContext.vNewNode) {
+    diffContext.$vNewNode$ = retrieveChildWithKey(diffContext, nodeName, lookupKey);
+    if (diffContext.$vNewNode$) {
         if (!sideBufferKey) {
-            vnode_insertBefore(diffContext.journal, parentForInsert, diffContext.vNewNode, diffContext.vCurrent);
+            vnode_insertBefore(diffContext.$journal$, parentForInsert, diffContext.$vNewNode$, diffContext.$vCurrent$);
         }
-        diffContext.vCurrent = diffContext.vNewNode;
-        diffContext.vNewNode = null;
+        diffContext.$vCurrent$ = diffContext.$vNewNode$;
+        diffContext.$vNewNode$ = null;
         return false;
     }
     // 2) Try side buffer
     if (sideBufferKey != null) {
-        const buffered = diffContext.vSideBuffer?.get(sideBufferKey) || null;
+        const buffered = diffContext.$vSideBuffer$?.get(sideBufferKey) || null;
         if (buffered) {
-            diffContext.vSideBuffer.delete(sideBufferKey);
-            if (addCurrentToSideBufferOnSideInsert && diffContext.vCurrent) {
-                const currentKey = getKey(diffContext.vCurrent) ||
-                    getComponentHash(diffContext.vCurrent, diffContext.container.$getObjectById$);
+            diffContext.$vSideBuffer$.delete(sideBufferKey);
+            if (addCurrentToSideBufferOnSideInsert && diffContext.$vCurrent$) {
+                const currentKey = getKey(diffContext.$vCurrent$) ||
+                    getComponentHash(diffContext.$vCurrent$, diffContext.$container$.$getObjectById$);
                 if (currentKey != null) {
-                    const currentName = vnode_isElementVNode(diffContext.vCurrent)
-                        ? vnode_getElementName(diffContext.vCurrent)
+                    const currentName = vnode_isElementVNode(diffContext.$vCurrent$)
+                        ? vnode_getElementName(diffContext.$vCurrent$)
                         : null;
                     const currentSideKey = getSideBufferKey(currentName, currentKey);
                     if (currentSideKey != null) {
-                        diffContext.vSideBuffer ||= new Map();
-                        diffContext.vSideBuffer.set(currentSideKey, diffContext.vCurrent);
+                        diffContext.$vSideBuffer$ ||= new Map();
+                        diffContext.$vSideBuffer$.set(currentSideKey, diffContext.$vCurrent$);
                     }
                 }
             }
             // Only move if the node is not already in the correct position
-            if (buffered !== diffContext.vCurrent) {
-                vnode_insertBefore(diffContext.journal, parentForInsert, buffered, diffContext.vCurrent);
+            if (buffered !== diffContext.$vCurrent$) {
+                vnode_insertBefore(diffContext.$journal$, parentForInsert, buffered, diffContext.$vCurrent$);
             }
-            diffContext.vCurrent = buffered;
-            diffContext.vNewNode = null;
+            diffContext.$vCurrent$ = buffered;
+            diffContext.$vNewNode$ = null;
             return false;
         }
     }
@@ -4683,8 +4692,8 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
 }
 function expectVirtual(diffContext, type, jsxKey) {
     const checkKey = type === "F" /* VirtualType.Fragment */;
-    const currentKey = getKey(diffContext.vCurrent);
-    const currentIsVirtual = diffContext.vCurrent && vnode_isVirtualVNode(diffContext.vCurrent);
+    const currentKey = getKey(diffContext.$vCurrent$);
+    const currentIsVirtual = diffContext.$vCurrent$ && vnode_isVirtualVNode(diffContext.$vCurrent$);
     const isSameNode = currentIsVirtual && currentKey === jsxKey && (checkKey ? !!jsxKey : true);
     if (isSameNode) {
         // All is good.
@@ -4692,29 +4701,29 @@ function expectVirtual(diffContext, type, jsxKey) {
         return;
     }
     // For fragments without a key, always create a new virtual node (ensures rerender semantics)
-    if (jsxKey === null || diffContext.isCreationMode) {
-        vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-        diffContext.vNewNode.key = jsxKey;
-        isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    if (jsxKey === null || diffContext.$isCreationMode$) {
+        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        diffContext.$vNewNode$.key = jsxKey;
+        isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
         return;
     }
-    if (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.vParent, true)) {
-        vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-        diffContext.vNewNode.key = jsxKey;
-        isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    if (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.$vParent$, true)) {
+        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        diffContext.$vNewNode$.key = jsxKey;
+        isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
     }
 }
 function expectComponent(diffContext, component) {
     const componentMeta = component[SERIALIZABLE_STATE];
-    let host = (diffContext.vNewNode || diffContext.vCurrent);
-    const jsxNode = diffContext.jsxValue;
+    let host = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
+    const jsxNode = diffContext.$jsxValue$;
     if (componentMeta) {
         const jsxProps = jsxNode.props;
         // QComponent
         let shouldRender = false;
         const [componentQRL] = componentMeta;
         const componentHash = componentQRL.$hash$;
-        const vNodeComponentHash = getComponentHash(host, diffContext.container.$getObjectById$);
+        const vNodeComponentHash = getComponentHash(host, diffContext.$container$.$getObjectById$);
         const lookupKey = jsxNode.key || componentHash;
         const vNodeLookupKey = getKey(host) || vNodeComponentHash;
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
@@ -4725,25 +4734,25 @@ function expectComponent(diffContext, component) {
             }
             else {
                 insertNewComponent(diffContext, host, componentQRL, jsxProps);
-                host = diffContext.vNewNode;
+                host = diffContext.$vNewNode$;
                 shouldRender = true;
             }
         }
         else {
-            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.$vParent$)) {
                 insertNewComponent(diffContext, host, componentQRL, jsxProps);
                 shouldRender = true;
             }
-            host = (diffContext.vNewNode || diffContext.vCurrent);
+            host = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
         }
         if (host) {
-            const vNodeProps = vnode_getProp(host, ELEMENT_PROPS, diffContext.container.$getObjectById$);
+            const vNodeProps = vnode_getProp(host, ELEMENT_PROPS, diffContext.$container$.$getObjectById$);
             if (!shouldRender) {
-                const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.container);
+                const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.$container$);
                 // if props changed but key is null we need to insert a new component, because we need to execute hooks etc
                 if (propsChanged && jsxNode.key == null) {
                     insertNewComponent(diffContext, host, componentQRL, jsxProps);
-                    host = diffContext.vNewNode;
+                    host = diffContext.$vNewNode$;
                     shouldRender = true;
                 }
                 shouldRender ||= propsChanged;
@@ -4757,7 +4766,7 @@ function expectComponent(diffContext, component) {
                  * cleanup run. Now we found it and want to reuse it, so we need to mark it as not deleted.
                  */
                 host.flags &= -33 /* VNodeFlags.Deleted */;
-                markVNodeDirty(diffContext.container, host, 4 /* ChoreBits.COMPONENT */, diffContext.cursor);
+                markVNodeDirty(diffContext.$container$, host, 4 /* ChoreBits.COMPONENT */, diffContext.$cursor$);
             }
         }
         descendContentToProject(diffContext, jsxNode.children, host);
@@ -4766,18 +4775,18 @@ function expectComponent(diffContext, component) {
         const lookupKey = jsxNode.key;
         const vNodeLookupKey = getKey(host);
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
-        const vNodeComponentHash = getComponentHash(host, diffContext.container.$getObjectById$);
+        const vNodeComponentHash = getComponentHash(host, diffContext.$container$.$getObjectById$);
         const isInlineComponent = vNodeComponentHash == null;
         if ((host && !isInlineComponent) || !host) {
             insertNewInlineComponent(diffContext);
-            host = diffContext.vNewNode;
+            host = diffContext.$vNewNode$;
         }
         else if (!lookupKeysAreEqual) {
-            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.$vParent$)) {
                 // We did not find the inline component, create it.
                 insertNewInlineComponent(diffContext);
             }
-            host = (diffContext.vNewNode || diffContext.vCurrent);
+            host = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
         }
         else {
             // delete the key from the side buffer if it is the same component
@@ -4792,44 +4801,44 @@ function expectComponent(diffContext, component) {
                     : true)) {
                 componentHost = componentHost.parent || vnode_getProjectionParentComponent(componentHost);
             }
-            const jsxOutput = executeComponent(diffContext.container, host, (componentHost || diffContext.container.rootVNode), component, jsxNode.props);
-            diffContext.asyncQueue.push(jsxOutput, host);
+            const jsxOutput = executeComponent(diffContext.$container$, host, (componentHost || diffContext.$container$.rootVNode), component, jsxNode.props);
+            diffContext.$asyncQueue$.push(jsxOutput, host);
         }
     }
 }
 function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     if (host) {
-        clearAllEffects(diffContext.container, host);
+        clearAllEffects(diffContext.$container$, host);
     }
-    vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-    const jsxNode = diffContext.jsxValue;
-    isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "C" /* VirtualType.Component */);
-    vnode_setProp(diffContext.vNewNode, OnRenderProp, componentQRL);
-    vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxProps);
-    diffContext.vNewNode.key = jsxNode.key;
+    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+    const jsxNode = diffContext.$jsxValue$;
+    isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* VirtualType.Component */);
+    vnode_setProp(diffContext.$vNewNode$, OnRenderProp, componentQRL);
+    vnode_setProp(diffContext.$vNewNode$, ELEMENT_PROPS, jsxProps);
+    diffContext.$vNewNode$.key = jsxNode.key;
 }
 function insertNewInlineComponent(diffContext) {
-    vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-    const jsxNode = diffContext.jsxValue;
+    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+    const jsxNode = diffContext.$jsxValue$;
     isDev &&
-        vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "I" /* VirtualType.InlineComponent */);
-    vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxNode.props);
+        vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* VirtualType.InlineComponent */);
+    vnode_setProp(diffContext.$vNewNode$, ELEMENT_PROPS, jsxNode.props);
     if (jsxNode.key) {
-        diffContext.vNewNode.key = jsxNode.key;
+        diffContext.$vNewNode$.key = jsxNode.key;
     }
 }
 function expectText(diffContext, text) {
-    if (diffContext.vCurrent !== null) {
-        const type = vnode_getType(diffContext.vCurrent);
+    if (diffContext.$vCurrent$ !== null) {
+        const type = vnode_getType(diffContext.$vCurrent$);
         if (type === 3 /* Text */) {
-            if (text !== vnode_getText(diffContext.vCurrent)) {
-                vnode_setText(diffContext.journal, diffContext.vCurrent, text);
+            if (text !== vnode_getText(diffContext.$vCurrent$)) {
+                vnode_setText(diffContext.$journal$, diffContext.$vCurrent$, text);
                 return;
             }
             return;
         }
     }
-    vnode_insertElementBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newText((import.meta.env.TEST ? diffContext.container.document : document).createTextNode(text), text)), diffContext.vCurrent);
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newText((import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text), text)), diffContext.$vCurrent$);
 }
 /**
  * Retrieve the key from the VNode.
@@ -6179,6 +6188,20 @@ const fastGetter = (prototype, name) => {
             return this[name];
         });
 };
+/**
+ * Creates a cached fast property accessor by pulling the native getter from the prototype chain.
+ * The getter is resolved lazily on the first call and then reused, bypassing prototype lookups on
+ * every subsequent access.
+ */
+const createFastGetter = (propName) => {
+    let getter = null;
+    return (node) => {
+        if (!getter) {
+            getter = fastGetter(node, propName);
+        }
+        return getter.call(node);
+    };
+};
 
 /**
  * @file
@@ -7297,13 +7320,7 @@ const fastGetAttribute = (element, key) => {
     }
     return _fastGetAttribute.call(element, key);
 };
-let _fastNodeType = null;
-const fastNodeType = (node) => {
-    if (!_fastNodeType) {
-        _fastNodeType = fastGetter(node, 'nodeType');
-    }
-    return _fastNodeType.call(node);
-};
+const fastNodeType = createFastGetter('nodeType');
 const fastIsTextOrElement = (node) => {
     const type = fastNodeType(node);
     return type === /* Node.TEXT_NODE */ 3 || type === /* Node.ELEMENT_NODE */ 1;
@@ -7364,13 +7381,7 @@ function getNodeAfterCommentNode(node, commentValue, nextSibling, firstChild) {
     }
     return null;
 }
-let _fastParentNode = null;
-const fastParentNode = (node) => {
-    if (!_fastParentNode) {
-        _fastParentNode = fastGetter(node, 'parentNode');
-    }
-    return _fastParentNode.call(node);
-};
+const fastParentNode = createFastGetter('parentNode');
 let _fastFirstChild = null;
 const fastFirstChild = (node) => {
     if (!_fastFirstChild) {
@@ -7382,34 +7393,9 @@ const fastFirstChild = (node) => {
     }
     return node;
 };
-let _fastNamespaceURI = null;
-const fastNamespaceURI = (element) => {
-    if (!_fastNamespaceURI) {
-        _fastNamespaceURI = fastGetter(element, 'namespaceURI');
-    }
-    return _fastNamespaceURI.call(element);
-};
-let _fastNodeName = null;
-const fastNodeName = (element) => {
-    if (!_fastNodeName) {
-        _fastNodeName = fastGetter(element, 'nodeName');
-    }
-    return _fastNodeName.call(element);
-};
-let _fastOwnerDocument = null;
-const fastOwnerDocument = (node) => {
-    if (!_fastOwnerDocument) {
-        _fastOwnerDocument = fastGetter(node, 'ownerDocument');
-    }
-    return _fastOwnerDocument.call(node);
-};
-const hasQStyleAttribute = (element) => {
-    return (element.nodeName === 'STYLE' &&
-        (element.hasAttribute(QScopedStyle) || element.hasAttribute(QStyle)));
-};
-const hasPropsSeparator = (element) => {
-    return element.hasAttribute(Q_PROPS_SEPARATOR);
-};
+const fastNamespaceURI = createFastGetter('namespaceURI');
+const fastNodeName = createFastGetter('nodeName');
+const fastOwnerDocument = createFastGetter('ownerDocument');
 const materializeFromDOM = (vParent, firstChild, vData) => {
     let vFirstChild = null;
     const skipElements = () => {
@@ -7678,11 +7664,12 @@ const isLowercase = (ch) => /* `a` */ 97 <= ch && ch <= 122; /* `z` */
 function shouldSkipElement(element) {
     return (
     // Skip over elements that don't have a props separator. They are not rendered by Qwik.
-    !hasPropsSeparator(element) ||
+    !element.hasAttribute(Q_PROPS_SEPARATOR) ||
         // We pretend that style element's don't exist as they can get moved out.
         // skip over style elements, as those need to be moved to the head
         // and are not included in the counts.
-        hasQStyleAttribute(element));
+        (element.nodeName === 'STYLE' &&
+            (element.hasAttribute(QScopedStyle) || element.hasAttribute(QStyle))));
 }
 const stack = [];
 function materializeFromVNodeData(vParent, vData, element, child) {
@@ -8650,7 +8637,7 @@ const allocate = (container, typeId, value) => {
         case 28 /* TypeIds.FormData */:
             return new FormData();
         case 29 /* TypeIds.JSXNode */:
-            return new JSXNodeImpl(null, null, null, null, null);
+            return new JSXNodeImpl(null, null, null, null, 0, null);
         case 12 /* TypeIds.BigInt */:
             return BigInt(value);
         case 17 /* TypeIds.Set */:
@@ -8863,13 +8850,13 @@ const _fnSignal = (fn, args, fnStr) => {
  */
 class Serializer {
     $serializationContext$;
-    rootIdx = 0;
-    forwardRefs = [];
-    forwardRefsId = 0;
-    promises = new Set();
-    s11nWeakRefs = new Map();
-    parent;
-    qrlMap = new Map();
+    $rootIdx$ = 0;
+    $forwardRefs$ = [];
+    $forwardRefsId$ = 0;
+    $promises$ = new Set();
+    $s11nWeakRefs$ = new Map();
+    $parent$;
+    $qrlMap$ = new Map();
     $writer$;
     constructor($serializationContext$) {
         this.$serializationContext$ = $serializationContext$;
@@ -8940,7 +8927,7 @@ class Serializer {
     }
     getSeenRefOrOutput(value, index, keepWeak) {
         let seen = this.$serializationContext$.getSeenRef(value);
-        const forwardRefIdx = !keepWeak && this.s11nWeakRefs.get(value);
+        const forwardRefIdx = !keepWeak && this.$s11nWeakRefs$.get(value);
         if (!seen) {
             if (keepWeak) {
                 // we're testing a weakref, so don't mark it as seen yet
@@ -8952,14 +8939,14 @@ class Serializer {
                 seen = this.$serializationContext$.$addRoot$(value, true);
             }
             else {
-                return this.$serializationContext$.$markSeen$(value, this.parent, index);
+                return this.$serializationContext$.$markSeen$(value, this.$parent$, index);
             }
         }
         // Now that we saw it a second time, make sure it's a root
         if (seen.$parent$) {
             // Note, this means it was output before so we always need a backref
             // Special case: we're a root so instead of adding a backref, we replace ourself
-            if (!this.parent) {
+            if (!this.$parent$) {
                 this.$serializationContext$.$promoteToRoot$(seen, index);
                 value = this.$serializationContext$.$roots$[index];
             }
@@ -8969,13 +8956,13 @@ class Serializer {
         }
         // Check if there was a weakref to us
         if (typeof forwardRefIdx === 'number') {
-            this.forwardRefs[forwardRefIdx] = seen.$index$;
-            this.s11nWeakRefs.delete(value);
+            this.$forwardRefs$[forwardRefIdx] = seen.$index$;
+            this.$s11nWeakRefs$.delete(value);
         }
         // Now we know it's a root and we should output a RootRef
         const rootIdx = value instanceof SerializationBackRef ? value.$path$ : seen.$index$;
         // But make sure we do output ourselves
-        if (!this.parent && rootIdx === index) {
+        if (!this.$parent$ && rootIdx === index) {
             return seen;
         }
         this.output(1 /* TypeIds.RootRef */, rootIdx);
@@ -9057,7 +9044,7 @@ class Serializer {
                                 // not a sync QRL, replace all parts with string references
                                 data = `${this.$serializationContext$.$addRoot$(chunk)}#${this.$serializationContext$.$addRoot$(symbol)}${captures ? '#' + captures : ''}`;
                                 // Since we map QRLs to strings, we need to keep track of this secondary mapping
-                                const existing = this.qrlMap.get(data);
+                                const existing = this.$qrlMap$.get(data);
                                 if (existing) {
                                     // We encountered the same QRL again, make it a root
                                     const ref = this.$serializationContext$.$addRoot$(existing);
@@ -9065,7 +9052,7 @@ class Serializer {
                                     return;
                                 }
                                 else {
-                                    this.qrlMap.set(data, value);
+                                    this.$qrlMap$.set(data, value);
                                 }
                             }
                             else {
@@ -9100,11 +9087,11 @@ class Serializer {
                     else {
                         const newSeenRef = this.getSeenRefOrOutput(value, index);
                         if (newSeenRef) {
-                            const oldParent = this.parent;
-                            this.parent = newSeenRef;
+                            const oldParent = this.$parent$;
+                            this.$parent$ = newSeenRef;
                             // separate function for readability
                             this.writeObjectValue(value);
-                            this.parent = oldParent;
+                            this.$parent$ = oldParent;
                         }
                     }
                     break;
@@ -9162,8 +9149,8 @@ class Serializer {
             }
             else {
                 // We replace ourselves with this value
-                const index = this.parent.$index$;
-                this.parent = this.parent.$parent$;
+                const index = this.$parent$.$index$;
+                this.$parent$ = this.$parent$.$parent$;
                 this.writeValue(result, index);
             }
         }
@@ -9378,8 +9365,8 @@ class Serializer {
                 }
                 else if (value.$resolved$) {
                     // We replace ourselves with this value
-                    const index = this.parent.$index$;
-                    this.parent = this.parent.$parent$;
+                    const index = this.$parent$.$index$;
+                    this.$parent$ = this.$parent$.$parent$;
                     this.writeValue(value.$value$, index);
                 }
                 else {
@@ -9403,12 +9390,12 @@ class Serializer {
         else if (value instanceof SerializationWeakRef) {
             const obj = value.$obj$;
             // This will return a fake SeenRef if it's not been seen before
-            if (this.getSeenRefOrOutput(obj, this.parent.$index$, true)) {
-                let forwardRefId = this.s11nWeakRefs.get(obj);
+            if (this.getSeenRefOrOutput(obj, this.$parent$.$index$, true)) {
+                let forwardRefId = this.$s11nWeakRefs$.get(obj);
                 if (forwardRefId === undefined) {
-                    forwardRefId = this.forwardRefsId++;
-                    this.s11nWeakRefs.set(obj, forwardRefId);
-                    this.forwardRefs[forwardRefId] = -1;
+                    forwardRefId = this.$forwardRefsId$++;
+                    this.$s11nWeakRefs$.set(obj, forwardRefId);
+                    this.$forwardRefs$[forwardRefId] = -1;
                 }
                 this.output(2 /* TypeIds.ForwardRef */, forwardRefId);
             }
@@ -9421,56 +9408,56 @@ class Serializer {
         }
     }
     resolvePromise(promise, classCreator) {
-        const forwardRefId = this.forwardRefsId++;
+        const forwardRefId = this.$forwardRefsId$++;
         promise
             .then((resolvedValue) => {
-            this.promises.delete(promise);
-            this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(true, resolvedValue));
+            this.$promises$.delete(promise);
+            this.$forwardRefs$[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(true, resolvedValue));
         })
             .catch((err) => {
-            this.promises.delete(promise);
-            this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(false, err));
+            this.$promises$.delete(promise);
+            this.$forwardRefs$[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(false, err));
         });
-        this.promises.add(promise);
+        this.$promises$.add(promise);
         return forwardRefId;
     }
     async outputRoots() {
         this.$writer$.write(BRACKET_OPEN);
         const { $roots$ } = this.$serializationContext$;
-        while (this.rootIdx < $roots$.length || this.promises.size) {
-            if (this.rootIdx !== 0) {
+        while (this.$rootIdx$ < $roots$.length || this.$promises$.size) {
+            if (this.$rootIdx$ !== 0) {
                 this.$writer$.write(COMMA);
             }
             let separator = false;
-            for (; this.rootIdx < $roots$.length; this.rootIdx++) {
+            for (; this.$rootIdx$ < $roots$.length; this.$rootIdx$++) {
                 if (separator) {
                     this.$writer$.write(COMMA);
                 }
                 else {
                     separator = true;
                 }
-                this.writeValue($roots$[this.rootIdx], this.rootIdx);
+                this.writeValue($roots$[this.$rootIdx$], this.$rootIdx$);
             }
-            if (this.promises.size) {
+            if (this.$promises$.size) {
                 try {
-                    await Promise.race(this.promises);
+                    await Promise.race(this.$promises$);
                 }
                 catch {
                     // ignore rejections, they will be serialized as rejected promises
                 }
             }
         }
-        if (this.forwardRefs.length) {
-            let lastIdx = this.forwardRefs.length - 1;
-            while (lastIdx >= 0 && this.forwardRefs[lastIdx] === -1) {
+        if (this.$forwardRefs$.length) {
+            let lastIdx = this.$forwardRefs$.length - 1;
+            while (lastIdx >= 0 && this.$forwardRefs$[lastIdx] === -1) {
                 lastIdx--;
             }
             if (lastIdx >= 0) {
                 this.$writer$.write(COMMA);
                 this.$writer$.write(14 /* TypeIds.ForwardRefs */ + COMMA);
-                const out = lastIdx === this.forwardRefs.length - 1
-                    ? this.forwardRefs
-                    : this.forwardRefs.slice(0, lastIdx + 1);
+                const out = lastIdx === this.$forwardRefs$.length - 1
+                    ? this.$forwardRefs$
+                    : this.$forwardRefs$.slice(0, lastIdx + 1);
                 // We could also implement RLE of -1 values
                 this.outputArray(out, true, (value) => {
                     this.$writer$.write(String(value));
@@ -9885,7 +9872,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                         appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue);
                     }
                 }
-                const innerHTML = ssr.openElement(type, jsx.key, jsx.varProps, jsx.constProps, options.currentStyleScoped, qwikInspectorAttrValue);
+                const innerHTML = ssr.openElement(type, jsx.key, jsx.varProps, jsx.constProps, options.currentStyleScoped, qwikInspectorAttrValue, !!(jsx.flags & 4 /* JSXNodeFlags.HasCapturedProps */));
                 if (innerHTML) {
                     ssr.htmlNode(innerHTML);
                 }
@@ -10198,7 +10185,7 @@ const isResourceReturn = (obj) => {
 };
 
 /** @internal */
-function setEvent(serializationCtx, key, rawValue, isLoopElement) {
+function setEvent(serializationCtx, key, rawValue, hasMovedCaptures) {
     let value = null;
     const qrls = rawValue;
     const appendToValue = (valueToAppend) => {
@@ -10211,7 +10198,7 @@ function setEvent(serializationCtx, key, rawValue, isLoopElement) {
          *
          * For internal qrls (starting with `_`) we assume that they do the right thing.
          */
-        if (!qrl.$symbol$.startsWith('_') && (qrl.$captures$?.length || isLoopElement)) {
+        if (!qrl.$symbol$.startsWith('_') && (qrl.$captures$?.length || hasMovedCaptures)) {
             qrl = createQRL(null, '_run', _run, null, [qrl]);
         }
         return qrlToString(serializationCtx, qrl);
@@ -10225,7 +10212,7 @@ function setEvent(serializationCtx, key, rawValue, isLoopElement) {
             }
             else if (qrl != null) {
                 // nested arrays etc.
-                const nestedValue = setEvent(serializationCtx, key, qrl, isLoopElement);
+                const nestedValue = setEvent(serializationCtx, key, qrl, hasMovedCaptures);
                 if (nestedValue) {
                     appendToValue(nestedValue);
                 }
@@ -10248,6 +10235,211 @@ function addQwikEventToSerializationContext(serializationCtx, key, qrl) {
     }
 }
 
+// <docs markdown="../readme.md#useOn">
+// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
+// (edit ../readme.md#useOn instead and run `pnpm docs.sync`)
+/**
+ * Register a listener on the current component's host element.
+ *
+ * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
+ * have access to the JSX. Otherwise, it's adding a JSX listener in the `<div>` is a better idea.
+ *
+ * Events are case sensitive.
+ *
+ * @public
+ * @see `useOn`, `useOnWindow`, `useOnDocument`.
+ */
+// </docs>
+const useOn = (event, eventQrl) => {
+    _useOn("q-e:" /* EventNameHtmlScope.on */, event, eventQrl);
+};
+// <docs markdown="../readme.md#useOnDocument">
+// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
+// (edit ../readme.md#useOnDocument instead and run `pnpm docs.sync`)
+/**
+ * Register a listener on `document`.
+ *
+ * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
+ * have access to the JSX.
+ *
+ * Events are case sensitive.
+ *
+ * @public
+ * @see `useOn`, `useOnWindow`, `useOnDocument`.
+ *
+ * ```tsx
+ * function useScroll() {
+ *   useOnDocument(
+ *     'scroll',
+ *     $((event) => {
+ *       console.log('body scrolled', event);
+ *     })
+ *   );
+ * }
+ *
+ * const Cmp = component$(() => {
+ *   useScroll();
+ *   return <div>Profit!</div>;
+ * });
+ * ```
+ */
+// </docs>
+const useOnDocument = (event, eventQrl) => {
+    _useOn("q-d:" /* EventNameHtmlScope.document */, event, eventQrl);
+};
+// <docs markdown="../readme.md#useOnWindow">
+// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
+// (edit ../readme.md#useOnWindow instead and run `pnpm docs.sync`)
+/**
+ * Register a listener on `window`.
+ *
+ * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
+ * have access to the JSX.
+ *
+ * Events are case sensitive.
+ *
+ * @public
+ * @see `useOn`, `useOnWindow`, `useOnDocument`.
+ *
+ * ```tsx
+ * function useAnalytics() {
+ *   useOnWindow(
+ *     'popstate',
+ *     $((event) => {
+ *       console.log('navigation happened', event);
+ *       // report to analytics
+ *     })
+ *   );
+ * }
+ *
+ * const Cmp = component$(() => {
+ *   useAnalytics();
+ *   return <div>Profit!</div>;
+ * });
+ * ```
+ */
+// </docs>
+const useOnWindow = (event, eventQrl) => {
+    _useOn("q-w:" /* EventNameHtmlScope.window */, event, eventQrl);
+};
+const _useOn = (prefix, eventName, eventQrl) => {
+    const { isAdded, addEvent } = useOnEventsSequentialScope();
+    if (isAdded) {
+        return;
+    }
+    if (eventQrl) {
+        if (Array.isArray(eventName)) {
+            for (const event of eventName) {
+                addEvent(prefix + fromCamelToKebabCase(event), eventQrl);
+            }
+        }
+        else {
+            addEvent(prefix + fromCamelToKebabCase(eventName), eventQrl);
+        }
+    }
+};
+/**
+ * This hook is like the `useSequentialScope` but it is specifically for `useOn`. This is needed
+ * because we want to execute the `useOn` hooks only once and store the event listeners on the host
+ * element. From Qwik V2 the component is rerunning when the promise is thrown, so we need to make
+ * sure that the event listeners are not added multiple times.
+ *
+ * - The event listeners are stored in the `USE_ON_LOCAL` property.
+ * - The `USE_ON_LOCAL_SEQ_IDX` is used to keep track of the index of the hook that calls this.
+ * - The `USE_ON_LOCAL_FLAGS` is used to keep track of whether the event listener has been added or
+ *   not.
+ */
+const useOnEventsSequentialScope = () => {
+    const iCtx = useInvokeContext();
+    const hostElement = iCtx.$hostElement$;
+    const host = hostElement;
+    let onMap = iCtx.$container$.getHostProp(host, USE_ON_LOCAL);
+    if (onMap === null) {
+        onMap = {};
+        iCtx.$container$.setHostProp(host, USE_ON_LOCAL, onMap);
+    }
+    let seqIdx = iCtx.$container$.getHostProp(host, USE_ON_LOCAL_SEQ_IDX);
+    if (seqIdx === null) {
+        seqIdx = 0;
+    }
+    iCtx.$container$.setHostProp(host, USE_ON_LOCAL_SEQ_IDX, seqIdx + 1);
+    let addedFlags = iCtx.$container$.getHostProp(host, USE_ON_LOCAL_FLAGS);
+    if (addedFlags === null) {
+        addedFlags = [];
+        iCtx.$container$.setHostProp(host, USE_ON_LOCAL_FLAGS, addedFlags);
+    }
+    while (addedFlags.length <= seqIdx) {
+        addedFlags.push(false);
+    }
+    const addEvent = (eventName, eventQrl) => {
+        addedFlags[seqIdx] = true;
+        let events = onMap[eventName];
+        if (!events) {
+            onMap[eventName] = events = [];
+        }
+        events.push(eventQrl);
+    };
+    return {
+        isAdded: addedFlags[seqIdx],
+        addEvent,
+    };
+};
+
+/**
+ * HMR event handler. Replaces the component QRL with a fresh one and marks dirty.
+ *
+ * @internal
+ */
+const _hmr = (event, element) => {
+    const ctx = newInvokeContextFromDOM(event, element);
+    const container = ctx.$container$;
+    let host = ctx.$hostElement$;
+    if (!container || !host) {
+        return;
+    }
+    // host is a VNode from vnode_locate. Walk up to the nearest component VirtualVNode
+    // (the one with OnRenderProp) so we can replace its QRL and mark it dirty.
+    if (!container.getHostProp(host, OnRenderProp)) {
+        const parent = container.getParentHost(host);
+        if (!parent) {
+            return;
+        }
+        host = parent;
+    }
+    // Replace the component QRL with a fresh one to bypass caching
+    // TODO use a qrl registry to invalidate all QRLs from a parent
+    const oldQrl = container.getHostProp(host, OnRenderProp);
+    if (oldQrl) {
+        const chunk = oldQrl.$chunk$;
+        const now = Date.now();
+        const bustUrl = chunk.includes('?') ? chunk + '&t=' + now : chunk + '?t=' + now;
+        const freshQrl = qrl(bustUrl, oldQrl.$symbol$);
+        freshQrl.$container$ = container;
+        freshQrl.dev = oldQrl.dev;
+        container.setHostProp(host, OnRenderProp, freshQrl);
+    }
+    markVNodeDirty(container, host, 4 /* ChoreBits.COMPONENT */);
+};
+/** Sanitize path to a valid CSS-safe event name (no colons, dots, slashes). */
+const toEventName = (devPath) => 'qHmr' + devPath.replace(/[^a-zA-Z0-9_]/g, '_');
+let hmrQrl;
+/**
+ * Injected by the optimizer into component$ bodies in HMR mode. Registers a document event listener
+ * that triggers component re-render on HMR updates.
+ *
+ * @internal
+ */
+function _useHmr(devPath) {
+    const iCtx = tryGetInvokeContext();
+    if (!iCtx) {
+        return;
+    }
+    hmrQrl ||= inlinedQrl(_hmr, '_hmr');
+    // The event name must be CSS-attribute-safe (no colons, dots) because
+    // the qwikloader uses querySelectorAll('[q-d\\:eventName]') to find handlers.
+    useOnDocument(toEventName(devPath), hmrQrl);
+}
+
 let loading = Promise.resolve();
 const inflate = (container, target, typeId, data) => {
     if (typeId === 0 /* TypeIds.Plain */) {
@@ -10455,7 +10647,7 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             let owner = d[0];
             if (owner === _UNINITIALIZED) {
-                owner = new JSXNodeImpl(Fragment, d[1], d[2], null, null);
+                owner = new JSXNodeImpl(Fragment, d[1], d[2], null, 0, null);
                 owner._proxy = propsProxy;
             }
             propsProxy[_OWNER] = owner;
@@ -10988,12 +11180,12 @@ class DomContainer extends _SharedContainer {
     qManifestHash;
     rootVNode;
     document;
-    $rawStateData$;
     $storeProxyMap$ = new WeakMap();
     $qFuncs$;
     $instanceHash$;
     $forwardRefs$ = null;
     vNodeLocate = (id) => vnode_locate(this.rootVNode, id);
+    $rawStateData$;
     $stateData$;
     $styleIds$ = null;
     constructor(element) {
@@ -12314,7 +12506,7 @@ const makeResolveFunction = (qrl, symbolFn) => {
         symbolRef = maybeThen(importP, (resolved) => {
             // We memoize the result on the symbolFn
             // Make sure not to memoize the wrapped function!
-            if (symbolFn) {
+            if (!isDev && symbolFn) {
                 symbolFn[symbol] = resolved;
             }
             return (symbolRef = qrl.resolved = bindCaptures(qrl, resolved));
@@ -13244,156 +13436,6 @@ const _useStyles = (styleQrl, transform, scoped) => {
     return styleId;
 };
 
-// <docs markdown="../readme.md#useOn">
-// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
-// (edit ../readme.md#useOn instead and run `pnpm docs.sync`)
-/**
- * Register a listener on the current component's host element.
- *
- * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
- * have access to the JSX. Otherwise, it's adding a JSX listener in the `<div>` is a better idea.
- *
- * Events are case sensitive.
- *
- * @public
- * @see `useOn`, `useOnWindow`, `useOnDocument`.
- */
-// </docs>
-const useOn = (event, eventQrl) => {
-    _useOn("q-e:" /* EventNameHtmlScope.on */, event, eventQrl);
-};
-// <docs markdown="../readme.md#useOnDocument">
-// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
-// (edit ../readme.md#useOnDocument instead and run `pnpm docs.sync`)
-/**
- * Register a listener on `document`.
- *
- * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
- * have access to the JSX.
- *
- * Events are case sensitive.
- *
- * @public
- * @see `useOn`, `useOnWindow`, `useOnDocument`.
- *
- * ```tsx
- * function useScroll() {
- *   useOnDocument(
- *     'scroll',
- *     $((event) => {
- *       console.log('body scrolled', event);
- *     })
- *   );
- * }
- *
- * const Cmp = component$(() => {
- *   useScroll();
- *   return <div>Profit!</div>;
- * });
- * ```
- */
-// </docs>
-const useOnDocument = (event, eventQrl) => {
-    _useOn("q-d:" /* EventNameHtmlScope.document */, event, eventQrl);
-};
-// <docs markdown="../readme.md#useOnWindow">
-// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
-// (edit ../readme.md#useOnWindow instead and run `pnpm docs.sync`)
-/**
- * Register a listener on `window`.
- *
- * Used to programmatically add event listeners. Useful from custom `use*` methods, which do not
- * have access to the JSX.
- *
- * Events are case sensitive.
- *
- * @public
- * @see `useOn`, `useOnWindow`, `useOnDocument`.
- *
- * ```tsx
- * function useAnalytics() {
- *   useOnWindow(
- *     'popstate',
- *     $((event) => {
- *       console.log('navigation happened', event);
- *       // report to analytics
- *     })
- *   );
- * }
- *
- * const Cmp = component$(() => {
- *   useAnalytics();
- *   return <div>Profit!</div>;
- * });
- * ```
- */
-// </docs>
-const useOnWindow = (event, eventQrl) => {
-    _useOn("q-w:" /* EventNameHtmlScope.window */, event, eventQrl);
-};
-const _useOn = (prefix, eventName, eventQrl) => {
-    const { isAdded, addEvent } = useOnEventsSequentialScope();
-    if (isAdded) {
-        return;
-    }
-    if (eventQrl) {
-        if (Array.isArray(eventName)) {
-            for (const event of eventName) {
-                addEvent(prefix + fromCamelToKebabCase(event), eventQrl);
-            }
-        }
-        else {
-            addEvent(prefix + fromCamelToKebabCase(eventName), eventQrl);
-        }
-    }
-};
-/**
- * This hook is like the `useSequentialScope` but it is specifically for `useOn`. This is needed
- * because we want to execute the `useOn` hooks only once and store the event listeners on the host
- * element. From Qwik V2 the component is rerunning when the promise is thrown, so we need to make
- * sure that the event listeners are not added multiple times.
- *
- * - The event listeners are stored in the `USE_ON_LOCAL` property.
- * - The `USE_ON_LOCAL_SEQ_IDX` is used to keep track of the index of the hook that calls this.
- * - The `USE_ON_LOCAL_FLAGS` is used to keep track of whether the event listener has been added or
- *   not.
- */
-const useOnEventsSequentialScope = () => {
-    const iCtx = useInvokeContext();
-    const hostElement = iCtx.$hostElement$;
-    const host = hostElement;
-    let onMap = iCtx.$container$.getHostProp(host, USE_ON_LOCAL);
-    if (onMap === null) {
-        onMap = {};
-        iCtx.$container$.setHostProp(host, USE_ON_LOCAL, onMap);
-    }
-    let seqIdx = iCtx.$container$.getHostProp(host, USE_ON_LOCAL_SEQ_IDX);
-    if (seqIdx === null) {
-        seqIdx = 0;
-    }
-    iCtx.$container$.setHostProp(host, USE_ON_LOCAL_SEQ_IDX, seqIdx + 1);
-    let addedFlags = iCtx.$container$.getHostProp(host, USE_ON_LOCAL_FLAGS);
-    if (addedFlags === null) {
-        addedFlags = [];
-        iCtx.$container$.setHostProp(host, USE_ON_LOCAL_FLAGS, addedFlags);
-    }
-    while (addedFlags.length <= seqIdx) {
-        addedFlags.push(false);
-    }
-    const addEvent = (eventName, eventQrl) => {
-        addedFlags[seqIdx] = true;
-        let events = onMap[eventName];
-        if (!events) {
-            onMap[eventName] = events = [];
-        }
-        events.push(eventQrl);
-    };
-    return {
-        isAdded: addedFlags[seqIdx],
-        addEvent,
-    };
-};
-
 const getSignal = (initialState) => {
     const value = isFunction(initialState) && !isQwikComponent(initialState)
         ? invoke(undefined, initialState)
@@ -13868,5 +13910,5 @@ if (import.meta.hot) {
     });
 }
 
-export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _captures, _chk, createQRL as _createQRL, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _regSymbol, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, setEvent as _setEvent, scheduleTask as _task, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _captures, _chk, createQRL as _createQRL, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, _hmr, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _regSymbol, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, setEvent as _setEvent, scheduleTask as _task, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
 //# sourceMappingURL=core.mjs.map