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

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.26-dev+c693cf5
+ * @qwik.dev/core/testing 2.0.0-beta.27-dev+7fc6984
  * 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
@@ -23645,18 +23645,19 @@ import { _isJSXNode, _isStringifiable } from "@qwik.dev/core/internal";
 import { expect } from "vitest";
 
 // packages/qwik/src/core/client/vnode-utils.ts
-import { isDev as isDev24 } from "@qwik.dev/core/build";
+import { isDev as isDev25 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/error/assert.ts
 import { isDev } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/utils/qdev.ts
-var qDev = globalThis.qDev !== false;
-var qInspector = globalThis.qInspector === true;
-var qSerialize = globalThis.qSerialize !== false;
-var qDynamicPlatform = globalThis.qDynamicPlatform !== false;
-var qTest = globalThis.qTest === true;
-var qRuntimeQrl = globalThis.qRuntimeQrl === true;
+var g = globalThis;
+var qDev = g.qDev !== false;
+var qInspector = g.qInspector === true;
+var qSerialize = g.qSerialize !== false;
+var qDynamicPlatform = g.qDynamicPlatform !== false;
+var qTest = g.qTest === true;
+var qRuntimeQrl = g.qRuntimeQrl === true;
 var seal = (obj) => {
   if (qDev) {
     Object.seal(obj);
@@ -23788,7 +23789,7 @@ var codeToText = (code2, ...parts) => {
       // 4
       "QRL is not a function",
       // 5
-      "Dynamic import not found",
+      "Dynamic import {{0}} not found",
       // 6
       "Unknown type argument",
       // 7
@@ -24132,10 +24133,10 @@ function retryOnPromise(fn, onError = justThrow) {
 }
 
 // packages/qwik/src/core/use/use-core.ts
-import { isDev as isDev20 } from "@qwik.dev/core/build";
+import { isDev as isDev21 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/client/dom-container.ts
-import { isDev as isDev19 } from "@qwik.dev/core/build";
+import { isDev as isDev20 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/use/use-sequential-scope.ts
 var useSequentialScope = () => {
@@ -24289,7 +24290,7 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser as isBrowser3, isDev as isDev18 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser3, isDev as isDev19 } from "@qwik.dev/core/build";
 import { p as preload } from "@qwik.dev/core/preloader";
 
 // packages/qwik/src/core/reactive-primitives/backref.ts
@@ -24605,26 +24606,6 @@ var SignalImpl = class {
     return { value: this.$untrackedValue$ };
   }
 };
-var setupSignalValueAccess = (target, effectsProp, valueProp) => {
-  const ctx = tryGetInvokeContext();
-  if (ctx && (target.$container$ || (target.$container$ = ctx.$container$ || null))) {
-    isDev8 && assertTrue(
-      !ctx.$container$ || ctx.$container$ === target.$container$,
-      "Do not use signals across containers"
-    );
-    const effectSubscriber = ctx.$effectSubscriber$;
-    if (effectSubscriber) {
-      ensureContainsSubscription(
-        target[effectsProp] || (target[effectsProp] = /* @__PURE__ */ new Set()),
-        effectSubscriber
-      );
-      ensureContainsBackRef(effectSubscriber, target);
-      addQrlToSerializationCtx(effectSubscriber, target.$container$);
-      DEBUG && log("read->sub", pad("\n" + target.toString(), "  "));
-    }
-  }
-  return target[valueProp];
-};
 
 // packages/qwik/src/core/shared/jsx/props-proxy.ts
 import { isDev as isDev9 } from "@qwik.dev/core/build";
@@ -24789,7 +24770,7 @@ var isPropsProxy = (obj) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
-import { isBrowser, isServer as isServer5 } from "@qwik.dev/core/build";
+import { isBrowser, isDev as isDev11, isServer as isServer5 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/reactive-primitives/subscriber.ts
 import { isServer as isServer4 } from "@qwik.dev/core/build";
@@ -24965,7 +24946,7 @@ var AsyncJob = class {
   }
   /** Backward compatible cache method for resource */
   cache() {
-    console.error(
+    isDev11 && console.error(
       "useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior."
     );
   }
@@ -25036,7 +25017,7 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
     }
     if ((import.meta.env.TEST ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* 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."
+        isDev11 ? "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$;
@@ -25052,7 +25033,21 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
    * `signal.loading ? <Loading /> : signal.value`.
    */
   get loading() {
-    return setupSignalValueAccess(this, "$loadingEffects$", "untrackedLoading");
+    const val = this.untrackedLoading;
+    const ctx = tryGetInvokeContext();
+    if (ctx && (this.$container$ || (this.$container$ = ctx.$container$ || null))) {
+      isDev11 && assertTrue(
+        !ctx.$container$ || ctx.$container$ === this.$container$,
+        "Do not use signals across containers"
+      );
+      const effectSubscriber = ctx.$effectSubscriber$;
+      if (effectSubscriber) {
+        ensureContainsSubscription(this.$loadingEffects$ || (this.$loadingEffects$ = /* @__PURE__ */ new Set()), effectSubscriber);
+        ensureContainsBackRef(effectSubscriber, this);
+        addQrlToSerializationCtx(effectSubscriber, this.$container$);
+      }
+    }
+    return val;
   }
   set untrackedLoading(value) {
     if (value !== this.$untrackedLoading$) {
@@ -25071,7 +25066,21 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
   }
   /** 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$ || (this.$container$ = ctx.$container$ || null))) {
+      isDev11 && assertTrue(
+        !ctx.$container$ || ctx.$container$ === this.$container$,
+        "Do not use signals across containers"
+      );
+      const effectSubscriber = ctx.$effectSubscriber$;
+      if (effectSubscriber) {
+        ensureContainsSubscription(this.$errorEffects$ || (this.$errorEffects$ = /* @__PURE__ */ new Set()), effectSubscriber);
+        ensureContainsBackRef(effectSubscriber, this);
+        addQrlToSerializationCtx(effectSubscriber, this.$container$);
+      }
+    }
+    return val;
   }
   set untrackedError(value) {
     if (value !== this.$untrackedError$) {
@@ -25465,7 +25474,7 @@ function setCursorData(vNode, cursorData) {
 }
 
 // packages/qwik/src/core/client/vnode-diff.ts
-import { isDev as isDev14 } from "@qwik.dev/core/build";
+import { isDev as isDev15 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/reactive-primitives/subscription-data.ts
 var SubscriptionData = class {
@@ -25476,22 +25485,22 @@ var SubscriptionData = class {
 };
 
 // packages/qwik/src/core/shared/component-execution.ts
-import { isDev as isDev12, isServer as isServer6 } from "@qwik.dev/core/build";
+import { isDev as isDev13, isServer as isServer6 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/component.public.ts
-import { isDev as isDev11 } from "@qwik.dev/core/build";
-var componentQrl = (componentQrl2) => {
+import { isDev as isDev12 } from "@qwik.dev/core/build";
+var componentQrl = (componentQrl3) => {
   function QwikComponent(props, key, flags = 0) {
-    isDev11 && assertQrl(componentQrl2);
-    isDev11 && assertNumber(flags, "The Qwik Component was not invoked correctly");
-    const hash3 = qTest ? "sX" : componentQrl2.$hash$.slice(0, 4);
+    isDev12 && assertQrl(componentQrl3);
+    isDev12 && assertNumber(flags, "The Qwik Component was not invoked correctly");
+    const hash3 = qTest ? "sX" : componentQrl3.$hash$.slice(0, 4);
     const finalKey = hash3 + ":" + (key ? key : "");
     const InnerCmp = () => {
     };
-    InnerCmp[SERIALIZABLE_STATE] = [componentQrl2];
+    InnerCmp[SERIALIZABLE_STATE] = [componentQrl3];
     return _jsxSplit(InnerCmp, props, null, props.children, flags, finalKey);
   }
-  QwikComponent[SERIALIZABLE_STATE] = [componentQrl2];
+  QwikComponent[SERIALIZABLE_STATE] = [componentQrl3];
   return QwikComponent;
 };
 var SERIALIZABLE_STATE = /* @__PURE__ */ Symbol("serializable-data");
@@ -25512,9 +25521,10 @@ var isObjectEmpty = (obj) => {
 // packages/qwik/src/core/shared/jsx/jsx-node.ts
 var _hasOwnProperty = Object.prototype.hasOwnProperty;
 var JSXNodeImpl = class {
-  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;
     __publicField(this, "toSort");
     __publicField(this, "key");
     __publicField(this, "varProps");
@@ -25587,7 +25597,7 @@ var executeComponent = (container, renderHost, subscriptionHost, componentQRL, p
   let isInlineComponent = false;
   if (componentQRL === null) {
     componentQRL = container.getHostProp(renderHost, OnRenderProp);
-    isDev12 && assertDefined(componentQRL, "No Component found at this location");
+    isDev13 && assertDefined(componentQRL, "No Component found at this location");
   }
   if (isQrl(componentQRL)) {
     props = props || container.getHostProp(renderHost, ELEMENT_PROPS) || EMPTY_OBJ;
@@ -25666,7 +25676,7 @@ function addUseOnEvents(jsx2, useOnEvents) {
             }
             targetElement = placeholderElement;
           } else {
-            if (isDev12) {
+            if (isDev13) {
               logWarn(
                 'You are trying to add an event "' + key + '" using `useOn` hook, but a node to which you can add an event is not found. Please make sure that the component has a valid element node. '
               );
@@ -25677,7 +25687,7 @@ function addUseOnEvents(jsx2, useOnEvents) {
         if (targetElement) {
           if (targetElement.type === "script" && key === qVisibleEvent) {
             eventKey = "q-d:qinit";
-            if (isDev12) {
+            if (isDev13) {
               logWarn(
                 'You are trying to add an event "' + key + '" using the `useVisibleTask$` hook with the "intersection-observer" strategy, but a node to which you can add an event is not found. Using "document-ready" or "document-idle" instead.'
               );
@@ -25755,7 +25765,7 @@ function injectPlaceholderElement(jsx2) {
   return [null, jsx2];
 }
 function createPlaceholderScriptNode() {
-  return new JSXNodeImpl("script", null, { hidden: "" }, null, null);
+  return new JSXNodeImpl("script", null, { hidden: "" }, null, 0, null);
 }
 
 // packages/qwik/src/core/shared/jsx/utils.public.ts
@@ -25764,9 +25774,9 @@ var SSRRaw = () => null;
 var SSRComment = () => null;
 
 // packages/qwik/src/core/client/vnode-namespace.ts
-import { isDev as isDev13 } from "@qwik.dev/core/build";
+import { isDev as isDev14 } from "@qwik.dev/core/build";
 var isForeignObjectElement = (elementName) => {
-  return isDev13 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
+  return isDev14 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
 };
 var isSvgElement = (elementName) => elementName === "svg" || isForeignObjectElement(elementName);
 var isMathElement = (elementName) => elementName === "math";
@@ -26579,31 +26589,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
       })
@@ -26623,52 +26633,52 @@ var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleId
   }
 };
 function diff(diffContext, jsxNode, vStartNode) {
-  isDev14 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
-  isDev14 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
-  diffContext.vParent = vStartNode;
-  diffContext.vNewNode = null;
-  diffContext.vCurrent = vnode_getFirstChild(vStartNode);
+  isDev15 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
+  isDev15 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
+  diffContext.$vParent$ = vStartNode;
+  diffContext.$vNewNode$ = null;
+  diffContext.$vCurrent$ = vnode_getFirstChild(vStartNode);
   stackPush(diffContext, jsxNode, true);
-  if (diffContext.vParent.flags & 32 /* Deleted */) {
+  if (diffContext.$vParent$.flags & 32 /* Deleted */) {
     return;
   }
-  while (diffContext.stack.length) {
-    while (diffContext.jsxIdx < diffContext.jsxCount) {
-      isDev14 && assertFalse(
-        diffContext.vParent === diffContext.vCurrent,
+  while (diffContext.$stack$.length) {
+    while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
+      isDev15 && 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 (diffContext.jsxValue && typeof diffContext.jsxValue === "object") {
-        if (isJSXNode(diffContext.jsxValue)) {
-          const type = diffContext.jsxValue.type;
+      if (typeof diffContext.$jsxValue$ === "string") {
+        expectText(diffContext, 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;
           if (typeof type === "string") {
             expectNoTextNode(diffContext);
-            expectElement(diffContext, diffContext.jsxValue, type);
-            const hasDangerousInnerHTML = diffContext.jsxValue.constProps && _hasOwnProperty2.call(diffContext.jsxValue.constProps, dangerouslySetInnerHTML) || _hasOwnProperty2.call(diffContext.jsxValue.varProps, dangerouslySetInnerHTML);
+            expectElement(diffContext, diffContext.$jsxValue$, type);
+            const hasDangerousInnerHTML = diffContext.$jsxValue$.constProps && _hasOwnProperty2.call(diffContext.$jsxValue$.constProps, dangerouslySetInnerHTML) || _hasOwnProperty2.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" /* Fragment */, diffContext.jsxValue.key);
-              descend(diffContext, diffContext.jsxValue.children, true);
+              expectVirtual(diffContext, "F" /* Fragment */, diffContext.$jsxValue$.key);
+              descend(diffContext, diffContext.$jsxValue$.children, true);
             } else if (type === Slot) {
               expectNoTextNode(diffContext);
               if (!expectSlot(diffContext)) {
-                descend(diffContext, diffContext.jsxValue.children, true);
+                descend(diffContext, diffContext.$jsxValue$.children, true);
               }
             } else if (type === Projection) {
               expectProjection(diffContext);
               descend(
                 diffContext,
-                diffContext.jsxValue.children,
+                diffContext.$jsxValue$.children,
                 true,
                 // special case for projection, we don't want to expect no children
                 // because the projection's children are not removed
@@ -26683,12 +26693,12 @@ function diff(diffContext, jsxNode, vStartNode) {
               expectComponent(diffContext, type);
             }
           }
-        } else if (Array.isArray(diffContext.jsxValue)) {
-          descend(diffContext, diffContext.jsxValue, false);
-        } else if (isSignal(diffContext.jsxValue)) {
+        } else if (Array.isArray(diffContext.$jsxValue$)) {
+          descend(diffContext, diffContext.$jsxValue$, false);
+        } else if (isSignal(diffContext.$jsxValue$)) {
           expectVirtual(diffContext, "S" /* WrappedSignal */, null);
-          const unwrappedSignal = diffContext.jsxValue instanceof WrappedSignalImpl ? diffContext.jsxValue.$unwrapIfSignal$() : diffContext.jsxValue;
-          const signals = diffContext.vCurrent?.[_EFFECT_BACK_REF]?.get(
+          const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl ? diffContext.$jsxValue$.$unwrapIfSignal$() : diffContext.$jsxValue$;
+          const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get(
             "." /* VNODE */
           )?.backRef;
           let hasUnwrappedSignal = signals?.has(unwrappedSignal);
@@ -26696,7 +26706,7 @@ function diff(diffContext, jsxNode, vStartNode) {
             hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal);
           }
           if (!hasUnwrappedSignal) {
-            const vHost = diffContext.vNewNode || diffContext.vCurrent;
+            const vHost = diffContext.$vNewNode$ || diffContext.$vCurrent$;
             descend(
               diffContext,
               resolveSignalAndDescend(
@@ -26705,20 +26715,20 @@ function diff(diffContext, jsxNode, vStartNode) {
                   unwrappedSignal,
                   vHost,
                   "." /* VNODE */,
-                  diffContext.container
+                  diffContext.$container$
                 )
               ),
               true
             );
           }
-        } else if (isPromise(diffContext.jsxValue)) {
+        } else if (isPromise(diffContext.$jsxValue$)) {
           expectVirtual(diffContext, "A" /* 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, "");
       }
@@ -26735,27 +26745,27 @@ function resolveSignalAndDescend(diffContext, fn) {
   } catch (e) {
     if (isPromise(e)) {
       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];
-  } else if (diffContext.stack.length > 0 && diffContext.stack[diffContext.stack.length - 1] === false) {
+  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) {
     return ascend(diffContext);
   }
-  if (diffContext.vNewNode !== null) {
-    diffContext.vNewNode = null;
+  if (diffContext.$vNewNode$ !== null) {
+    diffContext.$vNewNode$ = null;
   } else {
-    diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
+    diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
   }
 }
 function descend(diffContext, children, descendVNode, shouldExpectNoChildren = true) {
@@ -26765,85 +26775,85 @@ function descend(diffContext, children, descendVNode, shouldExpectNoChildren = t
   }
   stackPush(diffContext, children, descendVNode);
   if (descendVNode) {
-    isDev14 && assertDefined(
-      diffContext.vCurrent || diffContext.vNewNode,
+    isDev15 && 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;
+    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;
+  diffContext.$shouldAdvance$ = false;
 }
 function ascend(diffContext) {
-  const descendVNode = diffContext.stack.pop();
+  const descendVNode = diffContext.$stack$.pop();
   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 === void 0) {
-    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$);
   }
 }
 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) {
@@ -26883,25 +26893,25 @@ function descendContentToProject(diffContext, children, host) {
   descend(diffContext, projections, true);
 }
 function expectProjection(diffContext) {
-  const jsxNode = diffContext.jsxValue;
+  const jsxNode = diffContext.$jsxValue$;
   const slotName = jsxNode.key;
-  diffContext.vCurrent = vnode_getProp(
-    diffContext.vParent,
+  diffContext.$vCurrent$ = vnode_getProp(
+    diffContext.$vParent$,
     slotName,
-    (id) => vnode_locate(diffContext.container.rootVNode, id)
+    (id) => vnode_locate(diffContext.$container$.rootVNode, id)
   );
-  diffContext.vCurrent = diffContext.vCurrent && diffContext.vCurrent.flags & 32 /* Deleted */ ? null : diffContext.vCurrent;
-  if (diffContext.vCurrent == null) {
-    diffContext.vNewNode = vnode_newVirtual();
-    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
-    isDev14 && 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);
+  diffContext.$vCurrent$ = diffContext.$vCurrent$ && diffContext.$vCurrent$.flags & 32 /* Deleted */ ? null : diffContext.$vCurrent$;
+  if (diffContext.$vCurrent$ == null) {
+    diffContext.$vNewNode$ = vnode_newVirtual();
+    isDev15 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
+    isDev15 && 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,
@@ -26912,34 +26922,37 @@ function expectSlot(diffContext) {
     //(id) => vnode_locate(container.rootVNode, id)
   ) : null;
   if (vProjectedNode == null) {
-    diffContext.vNewNode = vnode_newVirtual();
-    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-    vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
-    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
+    diffContext.$vNewNode$ = vnode_newVirtual();
+    vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+    vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
+    isDev15 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
     vnode_insertBefore(
-      diffContext.journal,
-      diffContext.vParent,
-      diffContext.vNewNode,
-      diffContext.vCurrent && getInsertBefore(diffContext)
+      diffContext.$journal$,
+      diffContext.$vParent$,
+      diffContext.$vNewNode$,
+      diffContext.$vCurrent$ && getInsertBefore(diffContext)
     );
     return false;
-  } else if (vProjectedNode === diffContext.vCurrent) {
+  } else if (vProjectedNode === diffContext.$vCurrent$) {
   } else {
     const oldParent = vProjectedNode.parent;
-    diffContext.vNewNode = vProjectedNode;
-    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-    vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
-    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
-    vnode_inflateProjectionTrailingText(diffContext.journal, diffContext.vNewNode);
+    diffContext.$vNewNode$ = vProjectedNode;
+    vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+    vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
+    isDev15 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
+    vnode_inflateProjectionTrailingText(
+      diffContext.$journal$,
+      diffContext.$vNewNode$
+    );
     vnode_insertBefore(
-      diffContext.journal,
-      diffContext.vParent,
-      diffContext.vNewNode,
-      diffContext.vCurrent && getInsertBefore(diffContext)
+      diffContext.$journal$,
+      diffContext.$vParent$,
+      diffContext.$vNewNode$,
+      diffContext.$vCurrent$ && getInsertBefore(diffContext)
     );
     if (oldParent && vnode_isElementVNode(oldParent) && !oldParent.firstChild && vnode_getElementName(oldParent) === QTemplate) {
       vnode_remove(
-        diffContext.journal,
+        diffContext.$journal$,
         oldParent.parent,
         oldParent,
         true
@@ -26949,7 +26962,7 @@ function expectSlot(diffContext) {
   return true;
 }
 function getSlotNameKey(diffContext, vHost) {
-  const jsxNode = diffContext.jsxValue;
+  const jsxNode = diffContext.$jsxValue$;
   const constProps = jsxNode.constProps;
   if (constProps && typeof constProps == "object" && _hasOwnProperty2.call(constProps, "name")) {
     const constValue = constProps.name;
@@ -26958,90 +26971,90 @@ function getSlotNameKey(diffContext, vHost) {
         constValue,
         vHost,
         ":" /* COMPONENT */,
-        diffContext.container
+        diffContext.$container$
       );
     }
   }
   return directGetPropsProxyProp(jsxNode, "name") || QDefaultSlot;
 }
 function cleanupSideBuffer(diffContext) {
-  if (diffContext.vSideBuffer) {
-    for (const vNode of diffContext.vSideBuffer.values()) {
+  if (diffContext.$vSideBuffer$) {
+    for (const vNode of diffContext.$vSideBuffer$.values()) {
       if (vNode.flags & 32 /* 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((jsxNode2) => {
         diff(diffContext, jsxNode2, vHostNode);
         return drainAsyncQueue(diffContext);
       }).catch((e) => {
-        diffContext.container.handleError(e, vHostNode);
+        diffContext.$container$.handleError(e, vHostNode);
         return drainAsyncQueue(diffContext);
       });
     } else {
       diff(diffContext, jsxNode, vHostNode);
     }
   }
-  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(() => {
       return 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,
+      diffContext.$journal$,
+      diffContext.$vCurrent$,
       vFirstChild,
       removeDOM
     );
   }
 }
 function expectNoMore(diffContext) {
-  isDev14 && assertFalse(
-    diffContext.vParent === diffContext.vCurrent,
+  isDev15 && 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);
-        vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
+  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$);
+        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, jsx2, elementName, currentFile) {
@@ -27055,7 +27068,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
           key2,
           value,
           element,
-          diffContext.vNewNode,
+          diffContext.$vNewNode$,
           diffContext
         );
         continue;
@@ -27074,29 +27087,29 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
         }
       }
       if (isSignal(value)) {
-        const vHost = diffContext.vNewNode;
+        const vHost = diffContext.$vNewNode$;
         const signal = value;
         value = retryOnPromise(
           () => trackSignalAndAssignHost(
             signal,
             vHost,
             key2,
-            diffContext.container,
-            diffContext.subscriptionData.const
+            diffContext.$container$,
+            diffContext.$subscriptionData$.$const$
           )
         );
       }
       if (isPromise(value)) {
-        const vHost = diffContext.vNewNode;
+        const vHost = diffContext.$vNewNode$;
         const attributePromise = value.then(
           (resolvedValue) => directSetAttribute(
             element,
             key2,
-            serializeAttribute(key2, resolvedValue, diffContext.scopedStyleIdPrefix),
+            serializeAttribute(key2, resolvedValue, diffContext.$scopedStyleIdPrefix$),
             (vHost.flags & 512 /* NS_svg */) !== 0
           )
         );
-        diffContext.asyncAttributePromises.push(attributePromise);
+        diffContext.$asyncAttributePromises$.push(attributePromise);
         continue;
       }
       if (key2 === dangerouslySetInnerHTML) {
@@ -27108,7 +27121,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
       }
       if (elementName === "textarea" && key2 === "value") {
         if (value && typeof value !== "string") {
-          if (isDev14) {
+          if (isDev15) {
             throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
           continue;
@@ -27119,26 +27132,26 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
       directSetAttribute(
         element,
         key2,
-        serializeAttribute(key2, value, diffContext.scopedStyleIdPrefix),
-        (diffContext.vNewNode.flags & 512 /* NS_svg */) !== 0
+        serializeAttribute(key2, value, diffContext.$scopedStyleIdPrefix$),
+        (diffContext.$vNewNode$.flags & 512 /* NS_svg */) !== 0
       );
     }
   }
   const key = jsx2.key;
   if (key) {
-    diffContext.vNewNode.key = key;
+    diffContext.$vNewNode$.key = key;
   }
-  if (diffContext.scopedStyleIdPrefix) {
+  if (diffContext.$scopedStyleIdPrefix$) {
     const classAttributeExists = _hasOwnProperty2.call(jsx2.varProps, "class") || jsx2.constProps && _hasOwnProperty2.call(jsx2.constProps, "class");
     if (!classAttributeExists) {
-      element.setAttribute("class", diffContext.scopedStyleIdPrefix);
+      element.setAttribute("class", diffContext.$scopedStyleIdPrefix$);
     }
   }
   vnode_insertElementBefore(
-    diffContext.journal,
-    diffContext.vParent,
-    diffContext.vNewNode,
-    diffContext.vCurrent
+    diffContext.$journal$,
+    diffContext.$vParent$,
+    diffContext.$vNewNode$,
+    diffContext.$vCurrent$
   );
 }
 function registerEventHandlers(key, value, element, vnode, diffContext) {
@@ -27168,27 +27181,27 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
     ];
   }
   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 /* 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, jsx2, elementName) {
-  if (diffContext.isCreationMode) {
+  if (diffContext.$isCreationMode$) {
     createNewElement(diffContext, jsx2, 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 = jsx2.key;
-    const currentKey = isElementVNode && diffContext.vCurrent.key;
+    const currentKey = isElementVNode && diffContext.$vCurrent$.key;
     if (!isSameElementName || jsxKey !== currentKey) {
       const sideBufferKey = getSideBufferKey(elementName, jsxKey);
       if (moveOrCreateKeyedNode(
@@ -27196,7 +27209,7 @@ function expectElement(diffContext, jsx2, elementName) {
         elementName,
         jsxKey,
         sideBufferKey,
-        diffContext.vParent
+        diffContext.$vParent$
       )) {
         createNewElement(diffContext, jsx2, elementName, null);
       }
@@ -27205,14 +27218,14 @@ function expectElement(diffContext, jsx2, elementName) {
     }
   }
   const jsxProps = jsx2.varProps;
-  const vNode = diffContext.vNewNode || diffContext.vCurrent;
+  const vNode = diffContext.$vNewNode$ || diffContext.$vCurrent$;
   if (jsxProps) {
-    diffProps(diffContext, vNode, jsxProps, isDev14 && getFileLocationFromJsx(jsx2.dev) || null);
+    diffProps(diffContext, vNode, jsxProps, isDev15 && getFileLocationFromJsx(jsx2.dev) || null);
   }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
-  if (!diffContext.isCreationMode) {
-    vnode_ensureElementInflated(diffContext.container, vnode);
+  if (!diffContext.$isCreationMode$) {
+    vnode_ensureElementInflated(diffContext.$container$, vnode);
   }
   const oldAttrs = vnode.props;
   for (const key in newAttrs) {
@@ -27272,7 +27285,7 @@ var patchProperty = (diffContext, vnode, key, value, currentFile) => {
       return;
     }
     if (currentEffect) {
-      clearEffectSubscription(diffContext.container, currentEffect);
+      clearEffectSubscription(diffContext.$container$, currentEffect);
     }
     const vHost = vnode;
     value = retryOnPromise(
@@ -27280,88 +27293,88 @@ var patchProperty = (diffContext, vnode, key, value, currentFile) => {
         unwrappedSignal,
         vHost,
         key,
-        diffContext.container,
-        diffContext.subscriptionData.var
+        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,
+        diffContext.$journal$,
         vHost,
         key,
         resolvedValue,
-        diffContext.scopedStyleIdPrefix,
+        diffContext.$scopedStyleIdPrefix$,
         originalValue
       );
     });
-    diffContext.asyncAttributePromises.push(attributePromise);
+    diffContext.$asyncAttributePromises$.push(attributePromise);
     return;
   }
   setAttribute(
-    diffContext.journal,
+    diffContext.$journal$,
     vnode,
     key,
     value,
-    diffContext.scopedStyleIdPrefix,
+    diffContext.$scopedStyleIdPrefix$,
     originalValue
   );
 };
 function registerQwikLoaderEvent(diffContext, eventName) {
-  const qWindow = import.meta.env.TEST ? diffContext.container.document.defaultView : window;
+  const qWindow = import.meta.env.TEST ? diffContext.$container$.document.defaultView : window;
   if (qWindow) {
     (qWindow._qwikEv || (qWindow._qwikEv = [])).push(eventName);
   }
 }
 function retrieveChildWithKey(diffContext, nodeName, key) {
   let vNodeWithKey = null;
-  if (diffContext.vSiblings === null) {
-    const vCurrent = diffContext.vCurrent;
+  if (diffContext.$vSiblings$ === null) {
+    const vCurrent = diffContext.$vCurrent$;
     if (vCurrent) {
       const name = vnode_isElementVNode(vCurrent) ? vnode_getElementName(vCurrent) : null;
-      const vKey = getKey(vCurrent) || getComponentHash(vCurrent, diffContext.container.$getObjectById$);
+      const vKey = getKey(vCurrent) || getComponentHash(vCurrent, diffContext.$container$.$getObjectById$);
       if (vKey === key && name === nodeName) {
         return vCurrent;
       }
     }
-    diffContext.vSiblings = /* @__PURE__ */ new Map();
-    diffContext.vSiblingsArray = [];
-    let vNode = diffContext.vCurrent;
+    diffContext.$vSiblings$ = /* @__PURE__ */ 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$);
+      const vKey = getKey(vNode) || 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 {
-          diffContext.vSiblings.set(getSideBufferKey(name, vKey), vNode);
+          diffContext.$vSiblings$.set(getSideBufferKey(name, vKey), vNode);
         }
       }
       vNode = vNode.nextSibling;
     }
   } 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);
       }
     }
   }
@@ -27370,27 +27383,27 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
 }
 function collectSideBufferSiblings(diffContext, targetNode) {
   if (!targetNode) {
-    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$);
+    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$);
       if (vKey != null) {
         const sideBufferKey = getSideBufferKey(name, vKey);
-        diffContext.vSideBuffer || (diffContext.vSideBuffer = /* @__PURE__ */ new Map());
-        diffContext.vSideBuffer.set(sideBufferKey, diffContext.vCurrent);
-        diffContext.vSiblings?.delete(sideBufferKey);
+        diffContext.$vSideBuffer$ || (diffContext.$vSideBuffer$ = /* @__PURE__ */ new Map());
+        diffContext.$vSideBuffer$.set(sideBufferKey, diffContext.$vCurrent$);
+        diffContext.$vSiblings$?.delete(sideBufferKey);
       }
     }
     return;
   }
-  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$);
+    const vKey = getKey(vNode) || getComponentHash(vNode, diffContext.$container$.$getObjectById$);
     if (vKey != null) {
       const sideBufferKey = getSideBufferKey(name, vKey);
-      diffContext.vSideBuffer || (diffContext.vSideBuffer = /* @__PURE__ */ new Map());
-      diffContext.vSideBuffer.set(sideBufferKey, vNode);
-      diffContext.vSiblings?.delete(sideBufferKey);
+      diffContext.$vSideBuffer$ || (diffContext.$vSideBuffer$ = /* @__PURE__ */ new Map());
+      diffContext.$vSideBuffer$.set(sideBufferKey, vNode);
+      diffContext.$vSiblings$?.delete(sideBufferKey);
     }
     vNode = vNode.nextSibling;
   }
@@ -27403,52 +27416,52 @@ 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;
 }
 function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey, parentForInsert, addCurrentToSideBufferOnSideInsert) {
-  diffContext.vNewNode = retrieveChildWithKey(diffContext, nodeName, lookupKey);
-  if (diffContext.vNewNode) {
+  diffContext.$vNewNode$ = retrieveChildWithKey(diffContext, nodeName, lookupKey);
+  if (diffContext.$vNewNode$) {
     if (!sideBufferKey) {
       vnode_insertBefore(
-        diffContext.journal,
+        diffContext.$journal$,
         parentForInsert,
-        diffContext.vNewNode,
-        diffContext.vCurrent
+        diffContext.$vNewNode$,
+        diffContext.$vCurrent$
       );
     }
-    diffContext.vCurrent = diffContext.vNewNode;
-    diffContext.vNewNode = null;
+    diffContext.$vCurrent$ = diffContext.$vNewNode$;
+    diffContext.$vNewNode$ = null;
     return false;
   }
   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) : null;
+          const currentName = vnode_isElementVNode(diffContext.$vCurrent$) ? vnode_getElementName(diffContext.$vCurrent$) : null;
           const currentSideKey = getSideBufferKey(currentName, currentKey);
           if (currentSideKey != null) {
-            diffContext.vSideBuffer || (diffContext.vSideBuffer = /* @__PURE__ */ new Map());
-            diffContext.vSideBuffer.set(currentSideKey, diffContext.vCurrent);
+            diffContext.$vSideBuffer$ || (diffContext.$vSideBuffer$ = /* @__PURE__ */ new Map());
+            diffContext.$vSideBuffer$.set(currentSideKey, diffContext.$vCurrent$);
           }
         }
       }
-      if (buffered !== diffContext.vCurrent) {
+      if (buffered !== diffContext.$vCurrent$) {
         vnode_insertBefore(
-          diffContext.journal,
+          diffContext.$journal$,
           parentForInsert,
           buffered,
-          diffContext.vCurrent
+          diffContext.$vCurrent$
         );
       }
-      diffContext.vCurrent = buffered;
-      diffContext.vNewNode = null;
+      diffContext.$vCurrent$ = buffered;
+      diffContext.$vNewNode$ = null;
       return false;
     }
   }
@@ -27456,22 +27469,24 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
 }
 function expectVirtual(diffContext, type, jsxKey) {
   const checkKey = type === "F" /* 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) {
     deleteFromSideBuffer(diffContext, null, currentKey);
     return;
   }
-  if (jsxKey === null || diffContext.isCreationMode) {
+  if (jsxKey === null || diffContext.$isCreationMode$) {
     vnode_insertVirtualBefore(
-      diffContext.journal,
-      diffContext.vParent,
-      diffContext.vNewNode = vnode_newVirtual(),
-      diffContext.vCurrent && getInsertBefore(diffContext)
+      diffContext.$journal$,
+      diffContext.$vParent$,
+      diffContext.$vNewNode$ = vnode_newVirtual(),
+      diffContext.$vCurrent$ && getInsertBefore(diffContext)
     );
-    diffContext.vNewNode.key = jsxKey;
-    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    diffContext.$vNewNode$.key = jsxKey;
+    isDev15 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
     return;
   }
   if (moveOrCreateKeyedNode(
@@ -27479,29 +27494,29 @@ function expectVirtual(diffContext, type, jsxKey) {
     null,
     jsxKey,
     getSideBufferKey(null, jsxKey),
-    diffContext.vParent,
+    diffContext.$vParent$,
     true
   )) {
     vnode_insertVirtualBefore(
-      diffContext.journal,
-      diffContext.vParent,
-      diffContext.vNewNode = vnode_newVirtual(),
-      diffContext.vCurrent && getInsertBefore(diffContext)
+      diffContext.$journal$,
+      diffContext.$vParent$,
+      diffContext.$vNewNode$ = vnode_newVirtual(),
+      diffContext.$vCurrent$ && getInsertBefore(diffContext)
     );
-    diffContext.vNewNode.key = jsxKey;
-    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    diffContext.$vNewNode$.key = jsxKey;
+    isDev15 && 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;
     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;
@@ -27511,27 +27526,27 @@ function expectComponent(diffContext, component) {
         deleteFromSideBuffer(diffContext, null, lookupKey);
       } 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$
+        diffContext.$container$.$getObjectById$
       );
       if (!shouldRender) {
-        const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.container);
+        const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.$container$);
         if (propsChanged && jsxNode.key == null) {
           insertNewComponent(diffContext, host, componentQRL, jsxProps);
-          host = diffContext.vNewNode;
+          host = diffContext.$vNewNode$;
           shouldRender = true;
         }
         shouldRender || (shouldRender = propsChanged);
@@ -27540,10 +27555,10 @@ function expectComponent(diffContext, component) {
         vnode_setProp(host, OnRenderProp, componentQRL);
         host.flags &= ~32 /* Deleted */;
         markVNodeDirty(
-          diffContext.container,
+          diffContext.$container$,
           host,
           4 /* COMPONENT */,
-          diffContext.cursor
+          diffContext.$cursor$
         );
       }
     }
@@ -27552,22 +27567,22 @@ 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
+        diffContext.$vParent$
       )) {
         insertNewInlineComponent(diffContext);
       }
-      host = diffContext.vNewNode || diffContext.vCurrent;
+      host = diffContext.$vNewNode$ || diffContext.$vCurrent$;
     } else {
       deleteFromSideBuffer(diffContext, null, lookupKey);
     }
@@ -27581,65 +27596,65 @@ function expectComponent(diffContext, component) {
         componentHost = componentHost.parent || vnode_getProjectionParentComponent(componentHost);
       }
       const jsxOutput = executeComponent(
-        diffContext.container,
+        diffContext.$container$,
         host,
-        componentHost || diffContext.container.rootVNode,
+        componentHost || diffContext.$container$.rootVNode,
         component,
         jsxNode.props
       );
-      diffContext.asyncQueue.push(jsxOutput, host);
+      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)
+    diffContext.$journal$,
+    diffContext.$vParent$,
+    diffContext.$vNewNode$ = vnode_newVirtual(),
+    diffContext.$vCurrent$ && getInsertBefore(diffContext)
   );
-  const jsxNode = diffContext.jsxValue;
-  isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "C" /* Component */);
-  vnode_setProp(diffContext.vNewNode, OnRenderProp, componentQRL);
-  vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxProps);
-  diffContext.vNewNode.key = jsxNode.key;
+  const jsxNode = diffContext.$jsxValue$;
+  isDev15 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* 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)
+    diffContext.$journal$,
+    diffContext.$vParent$,
+    diffContext.$vNewNode$ = vnode_newVirtual(),
+    diffContext.$vCurrent$ && getInsertBefore(diffContext)
   );
-  const jsxNode = diffContext.jsxValue;
-  isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "I" /* InlineComponent */);
-  vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxNode.props);
+  const jsxNode = diffContext.$jsxValue$;
+  isDev15 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* 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) {
-      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),
+    diffContext.$journal$,
+    diffContext.$vParent$,
+    diffContext.$vNewNode$ = vnode_newText(
+      (import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text),
       text
     ),
-    diffContext.vCurrent
+    diffContext.$vCurrent$
   );
 }
 function getKey(vNode) {
@@ -28227,7 +28242,7 @@ var createMacroTask = (fn) => {
 };
 
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { isBrowser as isBrowser2, isDev as isDev15, isServer as isServer7 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser2, isDev as isDev16, isServer as isServer7 } from "@qwik.dev/core/build";
 var DEBUG6 = false;
 var nextMicroTask = createMicroTask(processCursorQueue);
 var nextMacroTask = createMacroTask(processCursorQueue);
@@ -28264,7 +28279,7 @@ function walkCursor(cursor, options) {
     return;
   }
   const container = cursorData.container;
-  isDev15 && assertDefined(container, "Cursor container not found");
+  isDev16 && assertDefined(container, "Cursor container not found");
   if (!cursor.dirty) {
     finishWalk(container, cursor, cursorData, isRunningOnServer);
     return;
@@ -28342,7 +28357,7 @@ function walkCursor(cursor, options) {
       }
     }
   }
-  isDev15 && assertFalse(
+  isDev16 && assertFalse(
     !!(cursor.dirty & 127 /* DIRTY_MASK */ && !cursorData.position),
     "Cursor is still dirty and position is not set after walking"
   );
@@ -28580,7 +28595,7 @@ function addVNodeOperation(journal, operation) {
 }
 
 // packages/qwik/src/core/reactive-primitives/impl/wrapped-signal-impl.ts
-import { isDev as isDev16 } from "@qwik.dev/core/build";
+import { isDev as isDev17 } from "@qwik.dev/core/build";
 var _a5, _b3;
 var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a5 = _EFFECT_BACK_REF, _b3) {
   constructor(container, fn, args, fnStr, flags = 1 /* INVALID */ | 4 /* UNWRAP */) {
@@ -28615,7 +28630,7 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a5 = _EFFECT_BACK_REF,
   }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev16 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev17 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
   $computeIfNeeded$() {
@@ -28852,7 +28867,7 @@ function _chk(_, element) {
 var version = globalThis.QWIK_VERSION;
 
 // packages/qwik/src/core/shared/serdes/serialize.ts
-import { isDev as isDev17 } from "@qwik.dev/core/build";
+import { isDev as isDev18 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/ssr-const.ts
 var LT = "<";
@@ -28872,13 +28887,13 @@ var COMMA = ",";
 var Serializer = class {
   constructor($serializationContext$) {
     this.$serializationContext$ = $serializationContext$;
-    __publicField(this, "rootIdx", 0);
-    __publicField(this, "forwardRefs", []);
-    __publicField(this, "forwardRefsId", 0);
-    __publicField(this, "promises", /* @__PURE__ */ new Set());
-    __publicField(this, "s11nWeakRefs", /* @__PURE__ */ new Map());
-    __publicField(this, "parent");
-    __publicField(this, "qrlMap", /* @__PURE__ */ new Map());
+    __publicField(this, "$rootIdx$", 0);
+    __publicField(this, "$forwardRefs$", []);
+    __publicField(this, "$forwardRefsId$", 0);
+    __publicField(this, "$promises$", /* @__PURE__ */ new Set());
+    __publicField(this, "$s11nWeakRefs$", /* @__PURE__ */ new Map());
+    __publicField(this, "$parent$");
+    __publicField(this, "$qrlMap$", /* @__PURE__ */ new Map());
     __publicField(this, "$writer$");
     this.$writer$ = $serializationContext$.$writer$;
   }
@@ -28943,7 +28958,7 @@ var Serializer = class {
   }
   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) {
         return true;
@@ -28951,11 +28966,11 @@ var Serializer = class {
       if (typeof forwardRefIdx === "number") {
         seen = this.$serializationContext$.$addRoot$(value, true);
       } else {
-        return this.$serializationContext$.$markSeen$(value, this.parent, index);
+        return this.$serializationContext$.$markSeen$(value, this.$parent$, index);
       }
     }
     if (seen.$parent$) {
-      if (!this.parent) {
+      if (!this.$parent$) {
         this.$serializationContext$.$promoteToRoot$(seen, index);
         value = this.$serializationContext$.$roots$[index];
       } else {
@@ -28963,11 +28978,11 @@ var Serializer = class {
       }
     }
     if (typeof forwardRefIdx === "number") {
-      this.forwardRefs[forwardRefIdx] = seen.$index$;
-      this.s11nWeakRefs.delete(value);
+      this.$forwardRefs$[forwardRefIdx] = seen.$index$;
+      this.$s11nWeakRefs$.delete(value);
     }
     const rootIdx = value instanceof SerializationBackRef ? value.$path$ : seen.$index$;
-    if (!this.parent && rootIdx === index) {
+    if (!this.$parent$ && rootIdx === index) {
       return seen;
     }
     this.output(1 /* RootRef */, rootIdx);
@@ -29041,13 +29056,13 @@ var Serializer = class {
               let data;
               if (chunk !== "") {
                 data = `${this.$serializationContext$.$addRoot$(chunk)}#${this.$serializationContext$.$addRoot$(symbol)}${captures ? "#" + captures : ""}`;
-                const existing = this.qrlMap.get(data);
+                const existing = this.$qrlMap$.get(data);
                 if (existing) {
                   const ref = this.$serializationContext$.$addRoot$(existing);
                   this.output(1 /* RootRef */, ref);
                   return;
                 } else {
-                  this.qrlMap.set(data, value);
+                  this.$qrlMap$.set(data, value);
                 }
               } else {
                 data = Number(symbol);
@@ -29074,10 +29089,10 @@ var Serializer = class {
           } else {
             const newSeenRef = this.getSeenRefOrOutput(value, index);
             if (newSeenRef) {
-              const oldParent = this.parent;
-              this.parent = newSeenRef;
+              const oldParent = this.$parent$;
+              this.$parent$ = newSeenRef;
               this.writeObjectValue(value);
-              this.parent = oldParent;
+              this.$parent$ = oldParent;
             }
           }
           break;
@@ -29134,8 +29149,8 @@ var Serializer = class {
         });
         this.output(2 /* ForwardRef */, forwardRef);
       } else {
-        const index = this.parent.$index$;
-        this.parent = this.parent.$parent$;
+        const index = this.$parent$.$index$;
+        this.$parent$ = this.$parent$.$parent$;
         this.writeValue(result2, index);
       }
     } else if (isObjectLiteral(value)) {
@@ -29236,7 +29251,7 @@ var Serializer = class {
     } else if (value instanceof Error) {
       const out = [value.message];
       out.push(...Object.entries(value).flat());
-      if (isDev17) {
+      if (isDev18) {
         out.push("stack", value.stack);
       }
       this.output(15 /* Error */, out);
@@ -29318,8 +29333,8 @@ var Serializer = class {
         if (value.$qrl$) {
           this.output(26 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
         } else if (value.$resolved$) {
-          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 {
           console.error(value.$value$);
@@ -29338,12 +29353,12 @@ var Serializer = class {
       this.output(19 /* Uint8Array */, out);
     } else if (value instanceof SerializationWeakRef) {
       const obj = value.$obj$;
-      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 === void 0) {
-          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 /* ForwardRef */, forwardRefId);
       }
@@ -29354,53 +29369,53 @@ var Serializer = class {
     }
   }
   resolvePromise(promise, classCreator) {
-    const forwardRefId = this.forwardRefsId++;
+    const forwardRefId = this.$forwardRefsId$++;
     promise.then((resolvedValue) => {
-      this.promises.delete(promise);
-      this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(
+      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$(
+      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 {
         }
       }
     }
-    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 /* 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);
         this.outputArray(out, true, (value) => {
           this.$writer$.write(String(value));
         });
@@ -29738,7 +29753,7 @@ var allocate = (container, typeId, value) => {
     case 28 /* FormData */:
       return new FormData();
     case 29 /* JSXNode */:
-      return new JSXNodeImpl(null, null, null, null, null);
+      return new JSXNodeImpl(null, null, null, null, 0, null);
     case 12 /* BigInt */:
       return BigInt(value);
     case 17 /* Set */:
@@ -29973,7 +29988,7 @@ var 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;
@@ -30134,7 +30149,7 @@ var makeResolveFunction = (qrl, symbolFn) => {
       }
     }
     if (qrl.$chunk$ === "") {
-      isDev18 && assertDefined(qrl.$container$, "Sync QRL must have container element");
+      isDev19 && assertDefined(qrl.$container$, "Sync QRL must have container element");
       const hash3 = qrl.$container$.$instanceHash$;
       const doc2 = qrl.$container$.element?.ownerDocument || document;
       const qFuncs2 = getQFuncs(doc2, hash3);
@@ -30279,7 +30294,7 @@ var BIND_VALUE = "bind:value";
 var BIND_CHECKED = "bind:checked";
 var _hasOwnProperty3 = Object.prototype.hasOwnProperty;
 var _jsxSorted = (type, varProps, constProps, children, flags, key, dev) => {
-  return new JSXNodeImpl(type, varProps, constProps, children, key, false, dev);
+  return new JSXNodeImpl(type, varProps, constProps, children, flags, key, false, dev);
 };
 var _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
   let toSort = false;
@@ -30444,7 +30459,7 @@ var _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);
 };
 var Virtual = (props) => props.children;
 
@@ -30875,12 +30890,12 @@ var DomContainer = class extends _SharedContainer {
     __publicField(this, "qManifestHash");
     __publicField(this, "rootVNode");
     __publicField(this, "document");
-    __publicField(this, "$rawStateData$");
     __publicField(this, "$storeProxyMap$", /* @__PURE__ */ new WeakMap());
     __publicField(this, "$qFuncs$");
     __publicField(this, "$instanceHash$");
     __publicField(this, "$forwardRefs$", null);
     __publicField(this, "vNodeLocate", (id) => vnode_locate(this.rootVNode, id));
+    __publicField(this, "$rawStateData$");
     __publicField(this, "$stateData$");
     __publicField(this, "$styleIds$", null);
     __publicField(this, "$getObjectById$", (id) => {
@@ -31055,7 +31070,7 @@ var DomContainer = class extends _SharedContainer {
   }
   getSyncFn(id) {
     const fn = this.$qFuncs$[id];
-    isDev19 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
+    isDev20 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
     return fn;
   }
   $appendStyle$(content, styleId, host, scoped) {
@@ -31408,8 +31423,8 @@ var useInvokeContext = () => {
   if (!ctx || ctx.$event$ !== RenderEvent) {
     throw qError(10 /* useInvokeContext */);
   }
-  isDev20 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
-  isDev20 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
+  isDev21 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
+  isDev21 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
   return ctx;
 };
 function invoke(context, fn, ...args) {
@@ -31497,7 +31512,7 @@ var trackSignalAndAssignHost = (value, host, property, container, data) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/store.ts
-import { isDev as isDev21, isServer as isServer11 } from "@qwik.dev/core/build";
+import { isDev as isDev22, isServer as isServer11 } from "@qwik.dev/core/build";
 var DEBUG7 = false;
 var log6 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
 var getStoreHandler = (value) => {
@@ -31558,7 +31573,7 @@ var StoreHandler2 = class {
         }
         this.$container$ = ctx.$container$;
       } else {
-        isDev21 && assertTrue(
+        isDev22 && assertTrue(
           !ctx.$container$ || ctx.$container$ === this.$container$,
           "Do not use signals across containers"
         );
@@ -31899,13 +31914,13 @@ function preprocessState(data, container) {
 }
 
 // packages/qwik/src/core/shared/serdes/serdes.public.ts
-import { isDev as isDev22 } from "@qwik.dev/core/build";
+import { isDev as isDev23 } from "@qwik.dev/core/build";
 function getObjectById(id, stateData) {
   if (typeof id === "string") {
     id = parseInt(id, 10);
     return stateData[id];
   }
-  isDev22 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
+  isDev23 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
   return stateData[id];
 }
 
@@ -32002,7 +32017,7 @@ var NoSerializeSymbol = /* @__PURE__ */ Symbol("noSerialize");
 var SerializerSymbol = /* @__PURE__ */ Symbol("serialize");
 
 // packages/qwik/src/core/reactive-primitives/utils.ts
-import { isDev as isDev23, isServer as isServer12 } from "@qwik.dev/core/build";
+import { isDev as isDev24, isServer as isServer12 } from "@qwik.dev/core/build";
 var DEBUG8 = false;
 var log7 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var throwIfQRLNotResolved = (qrl) => {
@@ -32043,7 +32058,7 @@ var scheduleEffects = (container, signal, effects) => {
     const scheduleEffect = (effectSubscription) => {
       const consumer = effectSubscription.consumer;
       const property = effectSubscription.property;
-      isDev23 && assertDefined(container, "Container must be defined.");
+      isDev24 && assertDefined(container, "Container must be defined.");
       if (isTask(consumer)) {
         consumer.$flags$ |= 4 /* DIRTY */;
         markVNodeDirty(container, consumer.$el$, 1 /* TASKS */);
@@ -32212,10 +32227,19 @@ var fastGetter = (prototype, name) => {
     return this[name];
   };
 };
+var createFastGetter = (propName) => {
+  let getter = null;
+  return (node) => {
+    if (!getter) {
+      getter = fastGetter(node, propName);
+    }
+    return getter.call(node);
+  };
+};
 
 // packages/qwik/src/core/client/vnode-utils.ts
 var vnode_newElement = (element, elementName, key = null) => {
-  isDev24 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev25 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     key,
     1 /* Element */ | 8 /* Inflated */ | -1 << 11 /* shift */,
@@ -32233,7 +32257,7 @@ var vnode_newElement = (element, elementName, key = null) => {
   return vnode;
 };
 var vnode_newUnMaterializedElement = (element) => {
-  isDev24 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev25 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     null,
     1 /* Element */ | -1 << 11 /* shift */,
@@ -32251,7 +32275,7 @@ var vnode_newUnMaterializedElement = (element) => {
   return vnode;
 };
 var vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
-  isDev24 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
+  isDev25 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
   const vnode = new TextVNode(
     4 /* Text */ | -1 << 11 /* shift */,
     // Flag
@@ -32283,10 +32307,10 @@ var vnode_newText = (textNode, textContent) => {
     textContent
     // Text Content
   );
-  isDev24 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
-  isDev24 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev25 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
+  isDev25 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev25 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev25 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_newVirtual = () => {
@@ -32301,9 +32325,9 @@ var vnode_newVirtual = () => {
     null,
     null
   );
-  isDev24 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev25 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev25 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev25 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_isVNode = (vNode) => {
@@ -32313,12 +32337,12 @@ var vnode_isElementVNode = (vNode) => {
   return (vNode.flags & 1 /* Element */) === 1 /* Element */;
 };
 var vnode_isElementOrTextVNode = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev25 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 5 /* ELEMENT_OR_TEXT_MASK */) !== 0;
 };
 var vnode_isMaterialized = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev25 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 1 /* Element */) === 1 /* Element */ && vNode.firstChild !== void 0 && vNode.lastChild !== void 0;
 };
@@ -32329,26 +32353,26 @@ var vnode_isVirtualVNode = (vNode) => {
   return (vNode.flags & 2 /* Virtual */) === 2 /* Virtual */;
 };
 var vnode_isProjection = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev25 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 2 /* Virtual */) === 2 /* Virtual */ && vnode_getProp(vNode, QSlot, null) !== null;
 };
 var ensureTextVNode = (vNode) => {
-  isDev24 && assertTrue(
+  isDev25 && assertTrue(
     vnode_isTextVNode(vNode),
     "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)
   );
   return vNode;
 };
 var ensureElementOrVirtualVNode = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
-  isDev24 && assertTrue(
+  isDev25 && assertDefined(vNode, "Missing vNode");
+  isDev25 && assertTrue(
     (vNode.flags & 3 /* ELEMENT_OR_VIRTUAL_MASK */) !== 0,
     "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode)
   );
 };
 var ensureElementVNode = (vNode) => {
-  isDev24 && assertTrue(
+  isDev25 && assertTrue(
     vnode_isElementVNode(vNode),
     "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)
   );
@@ -32580,7 +32604,7 @@ var vnode_ensureTextInflated = (journal, vnode) => {
   const flags = textVNode.flags;
   if ((flags & 8 /* Inflated */) === 0) {
     const parentNode = vnode_getDomParent(vnode, true);
-    isDev24 && assertDefined(parentNode, "Missing parent node.");
+    isDev25 && assertDefined(parentNode, "Missing parent node.");
     const sharedTextNode = textVNode.node;
     const doc2 = fastOwnerDocument(parentNode);
     let vCursor = vnode_getDomSibling(vnode, false, true);
@@ -32629,7 +32653,7 @@ var vnode_locate = (rootVNode, id) => {
   let elementOffset = -1;
   let refElement;
   if (typeof id === "string") {
-    isDev24 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
+    isDev25 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
     elementOffset = parseInt(id);
     refElement = qVNodeRefs.get(elementOffset);
   } else {
@@ -32639,9 +32663,9 @@ var vnode_locate = (rootVNode, id) => {
       return vNode2;
     }
   }
-  isDev24 && assertDefined(refElement, "Missing refElement.");
+  isDev25 && assertDefined(refElement, "Missing refElement.");
   if (!vnode_isVNode(refElement)) {
-    isDev24 && assertTrue(
+    isDev25 && assertTrue(
       containerElement2.contains(refElement),
       `Couldn't find the element inside the container while locating the VNode.`
     );
@@ -32685,10 +32709,10 @@ var vnode_locate = (rootVNode, id) => {
 };
 var vnode_getChildWithIdx = (vNode, childIdx) => {
   let child = vnode_getFirstChild(vNode);
-  isDev24 && assertDefined(child, "Missing child.");
+  isDev25 && assertDefined(child, "Missing child.");
   while (child.flags >>> 11 /* shift */ !== childIdx) {
     child = child.nextSibling;
-    isDev24 && assertDefined(child, "Missing child.");
+    isDev25 && assertDefined(child, "Missing child.");
   }
   return child;
 };
@@ -32696,7 +32720,7 @@ var vNodeStack = [];
 var vnode_getVNodeForChildNode = (vNode, childElement) => {
   ensureElementVNode(vNode);
   let child = vnode_getFirstChild(vNode);
-  isDev24 && assertDefined(child, "Missing child.");
+  isDev25 && assertDefined(child, "Missing child.");
   while (child && (child instanceof ElementVNode ? child.node !== childElement : true)) {
     if (vnode_isVirtualVNode(child)) {
       const next = child.nextSibling;
@@ -32715,13 +32739,13 @@ var vnode_getVNodeForChildNode = (vNode, childElement) => {
         child = next || vNodeStack.pop();
       }
     }
-    isDev24 && assertDefined(child, "Missing child.");
+    isDev25 && assertDefined(child, "Missing child.");
   }
   while (vNodeStack.length) {
     vNodeStack.pop();
   }
   ensureElementVNode(child);
-  isDev24 && assertEqual(child.node, childElement, "Child not found.");
+  isDev25 && assertEqual(child.node, childElement, "Child not found.");
   return child;
 };
 var indexOfAlphanumeric = (id, length) => {
@@ -32972,7 +32996,7 @@ var vnode_getDomParentVNode = (vnode, includeProjection) => {
   return vnode;
 };
 var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
-  isDev24 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
+  isDev25 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
   if (vnode_isTextVNode(vToRemove)) {
     vnode_ensureTextInflated(journal, vToRemove);
   }
@@ -33005,7 +33029,7 @@ var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
   vToRemove.nextSibling = null;
 };
 var vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
-  isDev24 && assertDefined(vDelete, "Missing vDelete.");
+  isDev25 && assertDefined(vDelete, "Missing vDelete.");
   const parent = vnode_getDomParent(vParent, true);
   if (parent && removeDOM) {
     if (vnode_isElementOrTextVNode(vParent)) {
@@ -33099,8 +33123,8 @@ var ensureMaterialized = (vnode) => {
       vFirstChild = vnode_materialize(vParent);
     }
   }
-  isDev24 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
-  isDev24 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
+  isDev25 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
+  isDev25 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
   return vFirstChild;
 };
 var _fastHasAttribute = null;
@@ -33117,13 +33141,7 @@ var fastGetAttribute = (element, key) => {
   }
   return _fastGetAttribute.call(element, key);
 };
-var _fastNodeType = null;
-var fastNodeType = (node) => {
-  if (!_fastNodeType) {
-    _fastNodeType = fastGetter(node, "nodeType");
-  }
-  return _fastNodeType.call(node);
-};
+var fastNodeType = createFastGetter("nodeType");
 var fastIsTextOrElement = (node) => {
   const type = fastNodeType(node);
   return type === /* Node.TEXT_NODE */
@@ -33186,13 +33204,7 @@ function getNodeAfterCommentNode(node, commentValue, nextSibling, firstChild) {
   }
   return null;
 }
-var _fastParentNode = null;
-var fastParentNode = (node) => {
-  if (!_fastParentNode) {
-    _fastParentNode = fastGetter(node, "parentNode");
-  }
-  return _fastParentNode.call(node);
-};
+var fastParentNode = createFastGetter("parentNode");
 var _fastFirstChild = null;
 var fastFirstChild = (node) => {
   if (!_fastFirstChild) {
@@ -33204,33 +33216,9 @@ var fastFirstChild = (node) => {
   }
   return node;
 };
-var _fastNamespaceURI = null;
-var fastNamespaceURI = (element) => {
-  if (!_fastNamespaceURI) {
-    _fastNamespaceURI = fastGetter(element, "namespaceURI");
-  }
-  return _fastNamespaceURI.call(element);
-};
-var _fastNodeName = null;
-var fastNodeName = (element) => {
-  if (!_fastNodeName) {
-    _fastNodeName = fastGetter(element, "nodeName");
-  }
-  return _fastNodeName.call(element);
-};
-var _fastOwnerDocument = null;
-var fastOwnerDocument = (node) => {
-  if (!_fastOwnerDocument) {
-    _fastOwnerDocument = fastGetter(node, "ownerDocument");
-  }
-  return _fastOwnerDocument.call(node);
-};
-var hasQStyleAttribute = (element) => {
-  return element.nodeName === "STYLE" && (element.hasAttribute(QScopedStyle) || element.hasAttribute(QStyle));
-};
-var hasPropsSeparator = (element) => {
-  return element.hasAttribute(Q_PROPS_SEPARATOR);
-};
+var fastNamespaceURI = createFastGetter("namespaceURI");
+var fastNodeName = createFastGetter("nodeName");
+var fastOwnerDocument = createFastGetter("ownerDocument");
 var materializeFromDOM = (vParent, firstChild, vData) => {
   let vFirstChild = null;
   const skipElements = () => {
@@ -33275,7 +33263,7 @@ var materializeFromDOM = (vParent, firstChild, vData) => {
         }
         const id = consumeValue();
         container.$setRawState$(parseInt(id), vParent);
-        isDev24 && vnode_setProp(vParent, ELEMENT_ID, id);
+        isDev25 && vnode_setProp(vParent, ELEMENT_ID, id);
       } else if (peek() === VNodeDataChar.BACK_REFS) {
         if (!container) {
           container = getDomContainer(vParent.node);
@@ -33481,10 +33469,10 @@ var isLowercase = (ch) => (
 function shouldSkipElement(element) {
   return (
     // Skip over elements that don't have a props separator. They are not rendered by Qwik.
-    !hasPropsSeparator(element) || // We pretend that style element's don't exist as they can get moved out.
+    !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))
   );
 }
 var stack = [];
@@ -33553,7 +33541,7 @@ function materializeFromVNodeData(vParent, vData, element, child) {
       }
       const id = consumeValue();
       container.$setRawState$(parseInt(id), vParent);
-      isDev24 && vnode_setProp(vParent, ELEMENT_ID, id);
+      isDev25 && vnode_setProp(vParent, ELEMENT_ID, id);
     } else if (peek() === VNodeDataChar.PROPS) {
       vnode_setProp(vParent, ELEMENT_PROPS, consumeValue());
     } else if (peek() === VNodeDataChar.KEY) {
@@ -34852,7 +34840,7 @@ async function expectDOM(actual, expected) {
 
 // packages/qwik/src/testing/rendering.unit-util.tsx
 var import_esbuild = __toESM(require_main(), 1);
-import { Slot as Slot3, component$, render } from "../core.mjs";
+import { Slot as Slot3, componentQrl as componentQrl2, inlinedQrl, render } from "../core.mjs";
 import { _getDomContainer as _getDomContainer2 } from "@qwik.dev/core/internal";
 import { readFileSync } from "fs";
 import { join } from "path";
@@ -34861,7 +34849,7 @@ import { expect as expect2 } from "vitest";
 
 // packages/qwik/src/server/platform.ts
 import { setPlatform as setPlatform2 } from "../core.mjs";
-import { isDev as isDev25 } from "@qwik.dev/core/build";
+import { isDev as isDev26 } from "@qwik.dev/core/build";
 var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
   const existing = mapper?.[hash3];
   if (existing) {
@@ -34883,9 +34871,9 @@ var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
 function createPlatform3(opts, resolvedManifest) {
   const mapper = resolvedManifest?.mapper;
   const mapperFn = opts.symbolMapper ? opts.symbolMapper : (symbolName, _chunk, parent) => {
-    if (mapper || isDev25 && import.meta.env.MODE !== "test") {
+    if (mapper || isDev26 && import.meta.env.MODE !== "test") {
       const hash3 = getSymbolHash2(symbolName);
-      const result2 = !isDev25 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
+      const result2 = !isDev26 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
       if (!result2) {
         if (hash3 === SYNC_QRL) {
           return [hash3, ""];
@@ -34962,7 +34950,7 @@ var versions = {
 };
 
 // packages/qwik/src/server/ssr-container.ts
-import { isDev as isDev27 } from "@qwik.dev/core/build";
+import { isDev as isDev28 } from "@qwik.dev/core/build";
 import {
   _SubscriptionData as SubscriptionData2,
   _SharedContainer as _SharedContainer2,
@@ -35242,7 +35230,7 @@ import {
   _EMPTY_OBJ,
   _EFFECT_BACK_REF as _EFFECT_BACK_REF2
 } from "@qwik.dev/core/internal";
-import { isDev as isDev26 } from "@qwik.dev/core/build";
+import { isDev as isDev27 } from "@qwik.dev/core/build";
 var SsrNode = class {
   constructor(parentComponent, id, attributesIndex, cleanupQueue, vnodeData, currentFile) {
     this.parentComponent = parentComponent;
@@ -35267,7 +35255,7 @@ var SsrNode = class {
     this.flags = 1 /* Updatable */;
     this.attrs = this.attributesIndex >= 0 ? this.vnodeData[this.attributesIndex] : _EMPTY_OBJ;
     this.parentComponent?.addChild(this);
-    if (isDev26 && id.indexOf("undefined") != -1) {
+    if (isDev27 && id.indexOf("undefined") != -1) {
       throw new Error(`Invalid SSR node id: ${id}`);
     }
   }
@@ -35331,7 +35319,7 @@ var SsrNode = class {
     }
   }
   toString() {
-    if (isDev26) {
+    if (isDev27) {
       let stringifiedAttrs = "";
       for (const key in this.attrs) {
         const value = this.attrs[key];
@@ -35698,7 +35686,7 @@ var SSRContainer = class extends _SharedContainer2 {
     containerAttributes[QContainerAttr] = "paused" /* PAUSED */;
     containerAttributes[QRuntimeAttr] = "2";
     containerAttributes[QVersionAttr] = this.$version$ ?? "dev";
-    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev27 ? "ssr-dev" : "ssr");
+    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev28 ? "ssr-dev" : "ssr");
     containerAttributes[QBaseAttr] = this.$buildBase$ || "";
     containerAttributes[QLocaleAttr] = this.$locale$;
     containerAttributes[QManifestHashAttr] = this.resolvedManifest.manifest.manifestHash;
@@ -35714,7 +35702,7 @@ var SSRContainer = class extends _SharedContainer2 {
     return this.closeElement();
   }
   /** Renders opening tag for DOM element */
-  openElement(elementName, key, varAttrs, constAttrs = null, styleScopedId = null, currentFile = null) {
+  openElement(elementName, key, varAttrs, constAttrs = null, styleScopedId = null, currentFile = null, hasMovedCaptures = true) {
     const isQwikStyle = isQwikStyleElement(elementName, varAttrs) || isQwikStyleElement(elementName, constAttrs);
     if (
       // don't append qwik loader before qwik style elements
@@ -35741,7 +35729,14 @@ var SSRContainer = class extends _SharedContainer2 {
     this.write(elementName);
     const lastNode = this.getOrCreateLastNode();
     if (varAttrs) {
-      innerHTML = this.writeAttrs(elementName, varAttrs, false, styleScopedId, currentFile);
+      innerHTML = this.writeAttrs(
+        elementName,
+        varAttrs,
+        false,
+        styleScopedId,
+        currentFile,
+        hasMovedCaptures
+      );
     }
     this.write(" " + Q_PROPS_SEPARATOR);
     if (key !== null) {
@@ -35750,7 +35745,14 @@ var SSRContainer = class extends _SharedContainer2 {
       this.write(EMPTY_ATTR);
     }
     if (constAttrs && !isObjectEmpty(constAttrs)) {
-      innerHTML = this.writeAttrs(elementName, constAttrs, true, styleScopedId, currentFile) || innerHTML;
+      innerHTML = this.writeAttrs(
+        elementName,
+        constAttrs,
+        true,
+        styleScopedId,
+        currentFile,
+        hasMovedCaptures
+      ) || innerHTML;
     }
     this.write(GT);
     if (lastNode) {
@@ -35873,7 +35875,7 @@ var SSRContainer = class extends _SharedContainer2 {
       const slotName = componentFrame.slots[i];
       const children = componentFrame.slots[i + 1];
       this.openFragment(
-        isDev27 ? { [DEBUG_TYPE]: "P" /* Projection */, [QSlotParent]: componentFrame.componentNode.id } : { [QSlotParent]: componentFrame.componentNode.id }
+        isDev28 ? { [DEBUG_TYPE]: "P" /* Projection */, [QSlotParent]: componentFrame.componentNode.id } : { [QSlotParent]: componentFrame.componentNode.id }
       );
       const lastNode = this.getOrCreateLastNode();
       if (lastNode.vnodeData) {
@@ -36194,7 +36196,7 @@ var SSRContainer = class extends _SharedContainer2 {
       scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
     }
     this.openElement("script", null, scriptAttrs);
-    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev27 });
+    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev28 });
     this.write(backpatchScript);
     this.closeElement();
   }
@@ -36292,7 +36294,7 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   createAndPushFrame(elementName, depthFirstElementIdx, currentFile) {
     let tagNesting = 10 /* ANYTHING */;
-    if (isDev27) {
+    if (isDev28) {
       if (!this.currentElementFrame) {
         tagNesting = initialTag(elementName);
       } else {
@@ -36338,7 +36340,7 @@ var SSRContainer = class extends _SharedContainer2 {
       elementName,
       depthFirstElementIdx,
       vNodeData: [0 /* NONE */],
-      currentFile: isDev27 ? currentFile || null : null
+      currentFile: isDev28 ? currentFile || null : null
     };
     this.currentElementFrame = frame;
     this.vNodeDatas.push(frame.vNodeData);
@@ -36362,22 +36364,18 @@ var SSRContainer = class extends _SharedContainer2 {
       this.write(element);
     }
   }
-  writeAttrs(tag, attrs, isConst, styleScopedId, currentFile) {
+  writeAttrs(tag, attrs, isConst, styleScopedId, currentFile, hasMovedCaptures) {
     let innerHTML = void 0;
-    let isLoopElement = null;
     for (let key in attrs) {
       let value = attrs[key];
       if (isSSRUnsafeAttr(key)) {
-        if (isDev27) {
+        if (isDev28) {
           throw qError(32 /* unsafeAttr */, [key]);
         }
         continue;
       }
       if (isHtmlAttributeAnEventName(key)) {
-        if (isLoopElement === null) {
-          isLoopElement = attributesContainsIterationProp(attrs);
-        }
-        value = _setEvent(this.serializationCtx, key, value, isLoopElement);
+        value = _setEvent(this.serializationCtx, key, value, hasMovedCaptures);
       } else if (key === "ref") {
         const lastNode = this.getOrCreateLastNode();
         if (isSignal3(value)) {
@@ -36426,7 +36424,7 @@ var SSRContainer = class extends _SharedContainer2 {
       }
       if (tag === "textarea" && key === "value") {
         if (value && typeof value !== "string") {
-          if (isDev27) {
+          if (isDev28) {
             throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
           continue;
@@ -36466,9 +36464,6 @@ var isQwikStyleElement = (tag, attrs) => {
   }
   return false;
 };
-var attributesContainsIterationProp = (attrs) => {
-  return Object.prototype.hasOwnProperty.call(attrs, ITERATION_ITEM_SINGLE) || Object.prototype.hasOwnProperty.call(attrs, ITERATION_ITEM_MULTI);
-};
 function newTagError(text) {
   return qError(12 /* tagError */, [text]);
 }
@@ -36901,11 +36896,13 @@ function getHostVNode(vElement) {
   return vElement;
 }
 var ErrorProvider = Object.assign(
-  component$(() => {
-    ErrorProvider.error = null;
-    useContextProvider(ERROR_CONTEXT, ErrorProvider);
-    return /* @__PURE__ */ jsx(Slot3, {});
-  }),
+  componentQrl2(
+    inlinedQrl(() => {
+      ErrorProvider.error = null;
+      useContextProvider(ERROR_CONTEXT, ErrorProvider);
+      return /* @__PURE__ */ jsx(Slot3, {});
+    }, "s_ErrorProvider")
+  ),
   { error: null }
 );
 export {