npm - @qwik.dev/core - Versions diffs - 2.0.0-beta.25 → 2.0.0-beta.27 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/bindings/qwik.darwin-arm64.node +0 -0
package/bindings/qwik.linux-x64-gnu.node +0 -0
package/bindings/qwik.win32-x64-msvc.node +0 -0
package/bindings/qwik_wasm_bg.wasm +0 -0
package/dist/backpatch/package.json +1 -1
package/dist/build/package.json +1 -1
package/dist/cli.mjs +2 -2
package/dist/core-internal.d.ts +14 -5
package/dist/core.min.mjs +1 -1
package/dist/core.mjs +525 -460
package/dist/core.mjs.map +1 -1
package/dist/core.prod.mjs +6068 -6041
package/dist/insights/index.qwik.mjs +80 -57
package/dist/loader/package.json +1 -1
package/dist/optimizer.mjs +320 -319
package/dist/preloader.mjs +86 -86
package/dist/server.mjs +30 -36
package/dist/server.prod.mjs +3263 -0
package/dist/starters/adapters/fastify/package.json +1 -1
package/dist/testing/index.d.ts +10 -1
package/dist/testing/index.mjs +624 -613
package/dist/testing/package.json +1 -1
package/package.json +8 -4

package/dist/testing/index.mjs CHANGED Viewed

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.25-dev+2677279
+ * @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
@@ -24004,6 +24005,7 @@ var createPlatform = () => {
         if (regSym) {
           return regSym;
         }
+        throw qError(6 /* dynamicImportFailed */, [symbolName]);
       }
       if (!url) {
         throw qError(14 /* qrlMissingChunk */, [symbolName]);
@@ -24131,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 = () => {
@@ -24288,7 +24290,7 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser as isBrowser2, 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
@@ -24418,7 +24420,13 @@ function parseQRL(qrl) {
 var QRL_RUNTIME_CHUNK = "mock-chunk";
 // packages/qwik/src/core/client/run-qrl.ts
-function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
+function runEventHandlerQRL(handler, event, element, ctx) {
+  if (!element.isConnected) {
+    return;
+  }
+  if (!ctx) {
+    ctx = newInvokeContextFromDOM(event, element);
+  }
   const container = ctx.$container$;
   const hostElement = ctx.$hostElement$;
   vnode_ensureElementInflated(container, hostElement);
@@ -24598,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";
@@ -24782,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";
@@ -24958,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."
     );
   }
@@ -25029,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$;
@@ -25045,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$) {
@@ -25064,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$) {
@@ -25458,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 {
@@ -25469,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");
@@ -25505,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");
@@ -25580,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;
@@ -25659,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. '
               );
@@ -25670,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.'
               );
@@ -25748,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
@@ -25757,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";
@@ -26570,38 +26587,41 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
     )
   );
 }
-var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
-  const diffContext = {
-    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({
+function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
+  return {
+    $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
       })
     }
   };
+}
+var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
+  const diffContext = createDiffContext(container, journal, cursor, scopedStyleIdPrefix);
   diff(diffContext, jsxNode, vStartNode);
   const result2 = drainAsyncQueue(diffContext);
   if (isPromise(result2)) {
@@ -26613,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
@@ -26673,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);
@@ -26686,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(
@@ -26695,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, "");
       }
@@ -26725,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) {
@@ -26755,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) {
@@ -26873,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,
@@ -26902,33 +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 */);
+    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
@@ -26938,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;
@@ -26947,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) {
@@ -27044,7 +27068,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
           key2,
           value,
           element,
-          diffContext.vNewNode,
+          diffContext.$vNewNode$,
           diffContext
         );
         continue;
@@ -27063,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) {
@@ -27097,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;
@@ -27108,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) {
@@ -27157,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(
@@ -27185,7 +27209,7 @@ function expectElement(diffContext, jsx2, elementName) {
         elementName,
         jsxKey,
         sideBufferKey,
-        diffContext.vParent
+        diffContext.$vParent$
       )) {
         createNewElement(diffContext, jsx2, elementName, null);
       }
@@ -27194,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) {
@@ -27261,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(
@@ -27269,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);
       }
     }
   }
@@ -27359,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;
   }
@@ -27392,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;
     }
   }
@@ -27445,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(
@@ -27468,69 +27494,71 @@ 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;
     const hashesAreEqual = componentHash === vNodeComponentHash;
-    if (!lookupKeysAreEqual) {
-      if (moveOrCreateKeyedNode(
-        diffContext,
-        null,
-        lookupKey,
-        lookupKey,
-        diffContext.vParent
-      )) {
+    if (lookupKeysAreEqual) {
+      if (hashesAreEqual) {
+        deleteFromSideBuffer(diffContext, null, lookupKey);
+      } else {
         insertNewComponent(diffContext, host, componentQRL, jsxProps);
+        host = diffContext.$vNewNode$;
         shouldRender = true;
       }
-      host = diffContext.vNewNode || diffContext.vCurrent;
-    } else if (!hashesAreEqual || !jsxNode.key) {
-      insertNewComponent(diffContext, host, componentQRL, jsxProps);
-      host = diffContext.vNewNode;
-      shouldRender = true;
     } else {
-      deleteFromSideBuffer(diffContext, null, lookupKey);
+      if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.$vParent$)) {
+        insertNewComponent(diffContext, host, componentQRL, jsxProps);
+        shouldRender = true;
+      }
+      host = diffContext.$vNewNode$ || diffContext.$vCurrent$;
     }
     if (host) {
       const vNodeProps = vnode_getProp(
         host,
         ELEMENT_PROPS,
-        diffContext.container.$getObjectById$
+        diffContext.$container$.$getObjectById$
       );
       if (!shouldRender) {
-        shouldRender || (shouldRender = 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$;
+          shouldRender = true;
+        }
+        shouldRender || (shouldRender = propsChanged);
       }
       if (shouldRender) {
         vnode_setProp(host, OnRenderProp, componentQRL);
         host.flags &= ~32 /* Deleted */;
         markVNodeDirty(
-          diffContext.container,
+          diffContext.$container$,
           host,
           4 /* COMPONENT */,
-          diffContext.cursor
+          diffContext.$cursor$
         );
       }
     }
@@ -27539,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 || lookupKey == 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);
     }
@@ -27568,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) {
@@ -28214,7 +28242,7 @@ var createMacroTask = (fn) => {
 };
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { 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);
@@ -28251,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;
@@ -28321,7 +28349,7 @@ function walkCursor(cursor, options) {
       });
       return;
     }
-    if (!isRunningOnServer && !import.meta.env.TEST) {
+    if (isBrowser2) {
       const elapsed = performance.now() - startTime;
       if (elapsed >= timeBudget) {
         scheduleYield();
@@ -28329,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"
   );
@@ -28389,10 +28417,10 @@ function getNextVNode(vNode, cursor) {
     return null;
   }
   let parent = null;
-  if (vNode.parent && vNode.parent.dirty & 32 /* CHILDREN */) {
-    parent = vNode.parent;
-  } else if (vNode.slotParent && vNode.slotParent.dirty & 32 /* CHILDREN */) {
+  if (vNode.slotParent && vNode.slotParent.dirty & 32 /* CHILDREN */) {
     parent = vNode.slotParent;
+  } else if (vNode.parent && vNode.parent.dirty & 32 /* CHILDREN */) {
+    parent = vNode.parent;
   }
   if (!parent) {
     if (cursor.dirty & 127 /* DIRTY_MASK */) {
@@ -28460,12 +28488,14 @@ function propagatePath(target) {
     const parent = reusablePath[i + 1] || target;
     parent.dirty |= 32 /* CHILDREN */;
     parent.dirtyChildren || (parent.dirtyChildren = []);
-    parent.dirtyChildren.push(child);
+    if (!parent.dirtyChildren.includes(child)) {
+      parent.dirtyChildren.push(child);
+    }
   }
 }
 function propagateToCursorRoot(vNode, cursorRoot) {
   reusablePath.push(vNode);
-  let current = vNode.parent || vNode.slotParent;
+  let current = vNode.slotParent || vNode.parent;
   while (current) {
     const isDirty = current.dirty & 127 /* DIRTY_MASK */;
     const currentIsCursor = isCursor(current);
@@ -28487,14 +28517,14 @@ function propagateToCursorRoot(vNode, cursorRoot) {
       }
     }
     reusablePath.push(current);
-    current = current.parent || current.slotParent;
+    current = current.slotParent || current.parent;
   }
   reusablePath.length = 0;
   throwErrorAndStop("Cursor root not found in current path!");
 }
 function findAndPropagateToBlockingCursor(vNode) {
   reusablePath.push(vNode);
-  let current = vNode.parent || vNode.slotParent;
+  let current = vNode.slotParent || vNode.parent;
   while (current) {
     const currentIsCursor = isCursor(current);
     if (currentIsCursor) {
@@ -28503,7 +28533,7 @@ function findAndPropagateToBlockingCursor(vNode) {
       return true;
     }
     reusablePath.push(current);
-    current = current.parent || current.slotParent;
+    current = current.slotParent || current.parent;
   }
   reusablePath.length = 0;
   return false;
@@ -28525,7 +28555,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
   if ((isRealDirty ? prevDirty & 127 /* DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
     return;
   }
-  const parent = vNode.parent || vNode.slotParent;
+  const parent = vNode.slotParent || vNode.parent;
   if (cursorRoot && isRealDirty && parent && !parent.dirty) {
     propagateToCursorRoot(vNode, cursorRoot);
     return;
@@ -28535,7 +28565,9 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
       parent.dirty |= 32 /* CHILDREN */;
     }
     parent.dirtyChildren || (parent.dirtyChildren = []);
-    parent.dirtyChildren.push(vNode);
+    if (!parent.dirtyChildren.includes(vNode)) {
+      parent.dirtyChildren.push(vNode);
+    }
     if (isRealDirty && vNode.dirtyChildren) {
       const cursor = findCursor(vNode);
       if (cursor) {
@@ -28543,7 +28575,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
         let cursorPosition = cursorData.position;
         if (cursorPosition) {
           while (cursorPosition !== cursor) {
-            cursorPosition = cursorPosition.parent || cursorPosition.slotParent;
+            cursorPosition = cursorPosition.slotParent || cursorPosition.parent;
             if (cursorPosition === vNode) {
               cursorData.position = vNode;
               break;
@@ -28563,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 */) {
@@ -28598,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$() {
@@ -28835,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 = "<";
@@ -28855,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$;
   }
@@ -28926,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;
@@ -28934,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 {
@@ -28946,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);
@@ -29024,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);
@@ -29057,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;
@@ -29117,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)) {
@@ -29219,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);
@@ -29301,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$);
@@ -29321,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);
       }
@@ -29337,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));
         });
@@ -29721,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 */:
@@ -29956,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;
@@ -30117,13 +30149,13 @@ 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);
       return qrl.resolved = symbolRef = qFuncs2[Number(qrl.$symbol$)];
     }
-    if (isBrowser2 && qrl.$chunk$) {
+    if (isBrowser3 && qrl.$chunk$) {
       preload(qrl.$chunk$, 1);
     }
     const start = now();
@@ -30221,7 +30253,7 @@ var createQRL = (chunk, symbol, symbolRef, symbolFn, captures) => {
       })
     );
   }
-  if (isBrowser2 && chunk) {
+  if (isBrowser3 && chunk) {
     preload(chunk, 0.8);
   }
   return qrl;
@@ -30262,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;
@@ -30427,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;
@@ -30858,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) => {
@@ -31038,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) {
@@ -31081,17 +31113,17 @@ var DomContainer = class extends _SharedContainer {
 };
 // packages/qwik/src/core/preloader/queue.ts
-import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser5 } from "@qwik.dev/core/build";
 // packages/qwik/src/core/preloader/constants.ts
-import { isBrowser as isBrowser3 } from "@qwik.dev/core/build";
-var doc = isBrowser3 ? document : void 0;
+import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
+var doc = isBrowser4 ? document : void 0;
 var config = {
   $DEBUG$: false,
   $maxIdlePreloads$: 25,
   $invPreloadProbability$: 0.65
 };
-var rel = isBrowser3 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
+var rel = isBrowser4 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
 var loadStart = Date.now();
 var isJSRegex = /\.[mc]?js$/;
@@ -31338,11 +31370,11 @@ var preload2 = (name, probability) => {
   } else {
     handleBundle(name, inverseProbability);
   }
-  if (isBrowser4) {
+  if (isBrowser5) {
     trigger();
   }
 };
-if (isBrowser4) {
+if (isBrowser5) {
   document.addEventListener("qsymbol", (ev) => {
     const { symbol, href } = ev.detail;
     if (href) {
@@ -31391,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) {
@@ -31480,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) => {
@@ -31541,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"
         );
@@ -31882,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];
 }
@@ -31985,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) => {
@@ -32021,12 +32053,12 @@ var addQrlToSerializationCtx = (effectSubscriber, container) => {
   }
 };
 var scheduleEffects = (container, signal, effects) => {
-  const isBrowser5 = import.meta.env.TEST ? !isServerPlatform() : !isServer12;
+  const isBrowser6 = import.meta.env.TEST ? !isServerPlatform() : !isServer12;
   if (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 */);
@@ -32035,7 +32067,7 @@ var scheduleEffects = (container, signal, effects) => {
       } else if (property === ":" /* COMPONENT */) {
         markVNodeDirty(container, consumer, 4 /* COMPONENT */);
       } else if (property === "." /* VNODE */) {
-        if (isBrowser5) {
+        if (isBrowser6) {
           setNodeDiffPayload(consumer, signal);
           markVNodeDirty(container, consumer, 2 /* NODE_DIFF */);
         }
@@ -32048,7 +32080,7 @@ var scheduleEffects = (container, signal, effects) => {
             scopedStyleIdPrefix: data.$scopedStyleIdPrefix$,
             value: signal
           };
-          if (isBrowser5) {
+          if (isBrowser6) {
             setNodePropData(consumer, property, payload);
           } else {
             const node = consumer;
@@ -32195,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 */,
@@ -32216,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 */,
@@ -32234,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
@@ -32266,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 = () => {
@@ -32284,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) => {
@@ -32296,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;
 };
@@ -32312,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)
   );
@@ -32462,6 +32503,7 @@ function vnode_walkDirectChildren(journal, vParent, callback) {
 function vnode_walkVNode(vNode, callback) {
   let vCursor = vNode;
   if (vnode_isTextVNode(vNode)) {
+    callback?.(vNode, null);
     return;
   }
   let vParent = null;
@@ -32557,17 +32599,12 @@ var vnode_getDomSibling = (vNode, nextDirection, descend2) => {
   }
   return null;
 };
-var vnode_ensureInflatedIfText = (journal, vNode) => {
-  if (vnode_isTextVNode(vNode)) {
-    vnode_ensureTextInflated(journal, vNode);
-  }
-};
 var vnode_ensureTextInflated = (journal, vnode) => {
   const textVNode = ensureTextVNode(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);
@@ -32616,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 {
@@ -32626,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.`
     );
@@ -32672,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;
 };
@@ -32683,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;
@@ -32702,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) => {
@@ -32908,7 +32945,7 @@ var vnode_findInsertBefore = (journal, parent, insertBefore) => {
   } else {
     adjustedInsertBefore = insertBefore;
   }
-  adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+  adjustedInsertBefore && vnode_isTextVNode(adjustedInsertBefore) && vnode_ensureTextInflated(journal, adjustedInsertBefore);
   return adjustedInsertBefore;
 };
 var vnode_connectSiblings = (parent, vNode, vNext) => {
@@ -32932,6 +32969,15 @@ var vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild) =>
     vnode_remove(journal, currentParent, newChild, false);
   }
 };
+var vnode_inflateProjectionTrailingText = (journal, projection) => {
+  let last = projection;
+  while (last && vnode_isVirtualVNode(last)) {
+    last = last.lastChild;
+  }
+  if (last && vnode_isTextVNode(last) && (last.flags & 8 /* Inflated */) === 0) {
+    vnode_ensureTextInflated(journal, last);
+  }
+};
 var vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
   if (vnode_isElementOrTextVNode(newChild)) {
     vnode_insertElementBefore(journal, parent, newChild, insertBefore);
@@ -32950,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);
   }
@@ -32983,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)) {
@@ -33077,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;
@@ -33095,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 */
@@ -33164,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) {
@@ -33182,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 = () => {
@@ -33253,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);
@@ -33459,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 = [];
@@ -33531,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) {
@@ -34830,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";
@@ -34839,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) {
@@ -34861,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, ""];
@@ -34885,15 +34895,7 @@ function createPlatform3(opts, resolvedManifest) {
       if (regSym) {
         return regSym;
       }
-      let modulePath = String(url);
-      if (!modulePath.endsWith(".js")) {
-        modulePath += ".js";
-      }
-      const module = __require(modulePath);
-      if (!(symbolName in module)) {
-        throw new Error(`Q-ERROR: missing symbol '${symbolName}' in module '${modulePath}'.`);
-      }
-      return module[symbolName];
+      throw qError(6 /* dynamicImportFailed */, [symbolName]);
     },
     raf: () => {
       console.error("server can not rerender");
@@ -34948,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,
@@ -35228,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;
@@ -35253,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}`);
     }
   }
@@ -35317,7 +35319,7 @@ var SsrNode = class {
     }
   }
   toString() {
-    if (isDev26) {
+    if (isDev27) {
       let stringifiedAttrs = "";
       for (const key in this.attrs) {
         const value = this.attrs[key];
@@ -35684,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;
@@ -35700,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
@@ -35727,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) {
@@ -35736,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) {
@@ -35859,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) {
@@ -36180,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();
   }
@@ -36278,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 {
@@ -36324,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);
@@ -36348,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)) {
@@ -36412,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;
@@ -36452,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]);
 }
@@ -36887,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 {