@qwik.dev/core 2.0.0-alpha.6 → 2.0.0-alpha.7

package/dist/insights/index.qwik.cjs

@@ -2,15 +2,23 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a, _b, _c;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const core = require("@qwik.dev/core");
+var isBrowser = /* @__PURE__ */ (() => typeof window !== "undefined" && typeof HTMLElement !== "undefined" && !!window.document && String(HTMLElement).includes("[native code]"))();
+var isServer = !isBrowser;
+var isDev = false;
 /**
  * @license
- * @qwik.dev/core 2.0.0-alpha.6-dev+d848ba5
+ * @qwik.dev/core 2.0.0-alpha.7-dev+a26598a
  * 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
  */
+const logError = (message, ...optionalParams) => createAndLogError(false, message, ...optionalParams);
+const throwErrorAndStop = (message, ...optionalParams) => {
+  throw createAndLogError(false, message, ...optionalParams);
+};
 const logErrorAndStop = (message, ...optionalParams) => createAndLogError(true, message, ...optionalParams);
 const createAndLogError = (asyncThrow, message, ...optionalParams) => {
   const err = message instanceof Error ? message : new Error(message);
@@ -18,6 +26,10 @@ const createAndLogError = (asyncThrow, message, ...optionalParams) => {
     throw err;
   }, 0), err;
 };
+function assertDefined() {
+}
+function assertEqual() {
+}
 function assertTrue() {
 }
 function assertFalse() {
@@ -25,12 +37,18 @@ function assertFalse() {
 const codeToText = (code) => `Code(Q${code}) https://github.com/QwikDev/qwik/blob/main/packages/qwik/src/core/error/error.ts#L${8 + code}`;
 var QError;
 !function(QError2) {
-  QError2[QError2.stringifyClassOrStyle = 0] = "stringifyClassOrStyle", QError2[QError2.UNUSED_1 = 1] = "UNUSED_1", QError2[QError2.UNUSED_2 = 2] = "UNUSED_2", QError2[QError2.verifySerializable = 3] = "verifySerializable", QError2[QError2.UNUSED_4 = 4] = "UNUSED_4", QError2[QError2.cannotRenderOverExistingContainer = 5] = "cannotRenderOverExistingContainer", QError2[QError2.UNUSED_6 = 6] = "UNUSED_6", QError2[QError2.UNUSED_7 = 7] = "UNUSED_7", QError2[QError2.UNUSED_8 = 8] = "UNUSED_8", QError2[QError2.UNUSED_9 = 9] = "UNUSED_9", QError2[QError2.qrlIsNotFunction = 10] = "qrlIsNotFunction", QError2[QError2.dynamicImportFailed = 11] = "dynamicImportFailed", QError2[QError2.unknownTypeArgument = 12] = "unknownTypeArgument", QError2[QError2.notFoundContext = 13] = "notFoundContext", QError2[QError2.useMethodOutsideContext = 14] = "useMethodOutsideContext", QError2[QError2.UNUSED_15 = 15] = "UNUSED_15", QError2[QError2.UNUSED_16 = 16] = "UNUSED_16", QError2[QError2.UNUSED_17 = 17] = "UNUSED_17", QError2[QError2.UNUSED_18 = 18] = "UNUSED_18", QError2[QError2.UNUSED_19 = 19] = "UNUSED_19", QError2[QError2.useInvokeContext = 20] = "useInvokeContext", QError2[QError2.UNUSED_21 = 21] = "UNUSED_21", QError2[QError2.UNUSED_22 = 22] = "UNUSED_22", QError2[QError2.UNUSED_23 = 23] = "UNUSED_23", QError2[QError2.UNUSED_24 = 24] = "UNUSED_24", QError2[QError2.UNUSED_25 = 25] = "UNUSED_25", QError2[QError2.UNUSED_26 = 26] = "UNUSED_26", QError2[QError2.UNUSED_27 = 27] = "UNUSED_27", QError2[QError2.invalidContext = 28] = "invalidContext", QError2[QError2.tagError = 29] = "tagError", QError2[QError2.qrlMissingContainer = 30] = "qrlMissingContainer", QError2[QError2.qrlMissingChunk = 31] = "qrlMissingChunk", QError2[QError2.invalidRefValue = 32] = "invalidRefValue", QError2[QError2.serializeErrorNotImplemented = 33] = "serializeErrorNotImplemented", QError2[QError2.serializeErrorExpectedVNode = 34] = "serializeErrorExpectedVNode", QError2[QError2.serializeErrorCannotAllocate = 35] = "serializeErrorCannotAllocate", QError2[QError2.serializeErrorMissingRootId = 36] = "serializeErrorMissingRootId", QError2[QError2.serializeErrorUnknownType = 37] = "serializeErrorUnknownType", QError2[QError2.serializeErrorUnvisited = 38] = "serializeErrorUnvisited", QError2[QError2.serializeErrorMissingChunk = 39] = "serializeErrorMissingChunk", QError2[QError2.wrongTextareaValue = 40] = "wrongTextareaValue", QError2[QError2.containerNotFound = 41] = "containerNotFound", QError2[QError2.elementWithoutContainer = 42] = "elementWithoutContainer", QError2[QError2.invalidVNodeType = 43] = "invalidVNodeType", QError2[QError2.materializeVNodeDataError = 44] = "materializeVNodeDataError", QError2[QError2.cannotCoerceSignal = 45] = "cannotCoerceSignal", QError2[QError2.computedNotSync = 46] = "computedNotSync", QError2[QError2.computedReadOnly = 47] = "computedReadOnly", QError2[QError2.wrappedReadOnly = 48] = "wrappedReadOnly", QError2[QError2.promisesNotExpected = 49] = "promisesNotExpected", QError2[QError2.unsafeAttr = 50] = "unsafeAttr";
+  QError2[QError2.stringifyClassOrStyle = 0] = "stringifyClassOrStyle", QError2[QError2.schedulerNotFound = 1] = "schedulerNotFound", QError2[QError2.trackObjectWithoutProp = 2] = "trackObjectWithoutProp", QError2[QError2.verifySerializable = 3] = "verifySerializable", QError2[QError2.UNUSED_4 = 4] = "UNUSED_4", QError2[QError2.cannotRenderOverExistingContainer = 5] = "cannotRenderOverExistingContainer", QError2[QError2.UNUSED_6 = 6] = "UNUSED_6", QError2[QError2.UNUSED_7 = 7] = "UNUSED_7", QError2[QError2.UNUSED_8 = 8] = "UNUSED_8", QError2[QError2.UNUSED_9 = 9] = "UNUSED_9", QError2[QError2.qrlIsNotFunction = 10] = "qrlIsNotFunction", QError2[QError2.dynamicImportFailed = 11] = "dynamicImportFailed", QError2[QError2.unknownTypeArgument = 12] = "unknownTypeArgument", QError2[QError2.notFoundContext = 13] = "notFoundContext", QError2[QError2.useMethodOutsideContext = 14] = "useMethodOutsideContext", QError2[QError2.UNUSED_15 = 15] = "UNUSED_15", QError2[QError2.UNUSED_16 = 16] = "UNUSED_16", QError2[QError2.UNUSED_17 = 17] = "UNUSED_17", QError2[QError2.UNUSED_18 = 18] = "UNUSED_18", QError2[QError2.UNUSED_19 = 19] = "UNUSED_19", QError2[QError2.useInvokeContext = 20] = "useInvokeContext", QError2[QError2.UNUSED_21 = 21] = "UNUSED_21", QError2[QError2.UNUSED_22 = 22] = "UNUSED_22", QError2[QError2.UNUSED_23 = 23] = "UNUSED_23", QError2[QError2.UNUSED_24 = 24] = "UNUSED_24", QError2[QError2.UNUSED_25 = 25] = "UNUSED_25", QError2[QError2.UNUSED_26 = 26] = "UNUSED_26", QError2[QError2.UNUSED_27 = 27] = "UNUSED_27", QError2[QError2.invalidContext = 28] = "invalidContext", QError2[QError2.tagError = 29] = "tagError", QError2[QError2.qrlMissingContainer = 30] = "qrlMissingContainer", QError2[QError2.qrlMissingChunk = 31] = "qrlMissingChunk", QError2[QError2.invalidRefValue = 32] = "invalidRefValue", QError2[QError2.serializeErrorNotImplemented = 33] = "serializeErrorNotImplemented", QError2[QError2.serializeErrorExpectedVNode = 34] = "serializeErrorExpectedVNode", QError2[QError2.serializeErrorCannotAllocate = 35] = "serializeErrorCannotAllocate", QError2[QError2.serializeErrorMissingRootId = 36] = "serializeErrorMissingRootId", QError2[QError2.serializeErrorUnknownType = 37] = "serializeErrorUnknownType", QError2[QError2.serializeErrorUnvisited = 38] = "serializeErrorUnvisited", QError2[QError2.serializeErrorMissingChunk = 39] = "serializeErrorMissingChunk", QError2[QError2.wrongTextareaValue = 40] = "wrongTextareaValue", QError2[QError2.containerNotFound = 41] = "containerNotFound", QError2[QError2.elementWithoutContainer = 42] = "elementWithoutContainer", QError2[QError2.invalidVNodeType = 43] = "invalidVNodeType", QError2[QError2.materializeVNodeDataError = 44] = "materializeVNodeDataError", QError2[QError2.cannotCoerceSignal = 45] = "cannotCoerceSignal", QError2[QError2.computedNotSync = 46] = "computedNotSync", QError2[QError2.computedReadOnly = 47] = "computedReadOnly", QError2[QError2.wrappedReadOnly = 48] = "wrappedReadOnly", QError2[QError2.unsafeAttr = 49] = "unsafeAttr";
 }(QError || (QError = {}));
 const qError = (code, errorMessageArgs = []) => {
   const text = codeToText(code, ...errorMessageArgs);
   return logErrorAndStop(text, ...errorMessageArgs);
 };
+const isSyncQrl = (value) => isQrl$1(value) && "<sync>" == value.$symbol$;
+const isQrl$1 = (value) => "function" == typeof value && "function" == typeof value.getSymbol;
+const getSymbolHash = (symbolName) => {
+  const index = symbolName.lastIndexOf("_");
+  return index > -1 ? symbolName.slice(index + 1) : symbolName;
+};
 var VirtualType;
 !function(VirtualType2) {
   VirtualType2.Virtual = "V", VirtualType2.Fragment = "F", VirtualType2.WrappedSignal = "S", VirtualType2.Awaited = "A", VirtualType2.Component = "C", VirtualType2.InlineComponent = "I", VirtualType2.Projection = "P";
@@ -48,93 +66,1675 @@ var QContainerValue;
 !function(QContainerValue2) {
   QContainerValue2.PAUSED = "paused", QContainerValue2.RESUMED = "resumed", QContainerValue2.HTML = "html", QContainerValue2.TEXT = "text";
 }(QContainerValue || (QContainerValue = {}));
+const QSlot = "q:slot";
+const QSlotS = "q:s";
+const QStyle = "q:style";
+const QStyleSelector = "style[q\\:style]";
+const QStylesAllSelector = "style[q\\:style],style[q\\:sstyle]";
+const getQFuncs = (document2, hash) => document2["qFuncs_" + hash] || [];
+const QContainerIsland = "q:container-island";
+const QContainerIslandEnd = "/" + QContainerIsland;
+const QIgnore = "q:ignore";
+const QIgnoreEnd = "/q:ignore";
+const QTemplate = "q:template";
 const QContainerSelector = "[q\\:container]:not([q\\:container=" + QContainerValue.HTML + "]):not([q\\:container=" + QContainerValue.TEXT + "])";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const SVG_NS = "http://www.w3.org/2000/svg";
+const MATH_NS = "http://www.w3.org/1998/Math/MathML";
 const dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
+const createPlatform = () => ({
+  isServer,
+  importSymbol(containerEl, url, symbolName) {
+    if (isServer) {
+      const hash = getSymbolHash(symbolName);
+      const regSym = globalThis.__qwik_reg_symbols?.get(hash);
+      if (regSym) {
+        return regSym;
+      }
+    }
+    if (!url) {
+      throw qError(QError.qrlMissingChunk, [symbolName]);
+    }
+    if (!containerEl) {
+      throw qError(QError.qrlMissingContainer, [url, symbolName]);
+    }
+    const urlDoc = toUrl(containerEl.ownerDocument, containerEl, url).toString();
+    const urlCopy = new URL(urlDoc);
+    urlCopy.hash = "";
+    return import(urlCopy.href).then((mod) => mod[symbolName]);
+  },
+  raf: (fn) => new Promise((resolve) => {
+    requestAnimationFrame(() => {
+      resolve(fn());
+    });
+  }),
+  nextTick: (fn) => new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(fn());
+    });
+  }),
+  chunkForSymbol: (symbolName, chunk) => [symbolName, chunk ?? "_"]
+});
+const toUrl = (doc, containerEl, url) => {
+  const baseURI = doc.baseURI;
+  const base = new URL(containerEl.getAttribute("q:base") ?? baseURI, baseURI);
+  return new URL(url, base);
+};
+let _platform = /* @__PURE__ */ createPlatform();
+const getPlatform = () => _platform;
+const isServerPlatform = () => _platform.isServer;
 const isPromise = (value) => !!value && "object" == typeof value && "function" == typeof value.then;
+const safeCall = (call, thenFn, rejectFn) => {
+  try {
+    const result = call();
+    return isPromise(result) ? result.then(thenFn, rejectFn) : thenFn(result);
+  } catch (e) {
+    return rejectFn(e);
+  }
+};
+const maybeThen = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn, shouldNotError) : thenFn(valueOrPromise);
+const shouldNotError = (reason) => {
+  throwErrorAndStop(reason);
+};
+const delay = (timeout) => new Promise((resolve) => {
+  setTimeout(resolve, timeout);
+});
+function retryOnPromise(fn, retryCount = 0) {
+  const retryOrThrow = (e) => {
+    if (isPromise(e) && retryCount < 100) {
+      return e.then(retryOnPromise.bind(null, fn, retryCount++));
+    }
+    throw e;
+  };
+  try {
+    const result = fn();
+    return isPromise(result) ? result.catch((e) => retryOrThrow(e)) : result;
+  } catch (e) {
+    return retryOrThrow(e);
+  }
+}
+const isSerializableObject = (v) => {
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === Array.prototype || null === proto;
+};
 const isArray = (v) => Array.isArray(v);
+const isString = (v) => "string" == typeof v;
+const isFunction = (v) => "function" == typeof v;
 var VNodeDataFlag;
 !function(VNodeDataFlag2) {
   VNodeDataFlag2[VNodeDataFlag2.NONE = 0] = "NONE", VNodeDataFlag2[VNodeDataFlag2.TEXT_DATA = 1] = "TEXT_DATA", VNodeDataFlag2[VNodeDataFlag2.VIRTUAL_NODE = 2] = "VIRTUAL_NODE", VNodeDataFlag2[VNodeDataFlag2.ELEMENT_NODE = 4] = "ELEMENT_NODE", VNodeDataFlag2[VNodeDataFlag2.REFERENCE = 8] = "REFERENCE", VNodeDataFlag2[VNodeDataFlag2.SERIALIZE = 16] = "SERIALIZE";
 }(VNodeDataFlag || (VNodeDataFlag = {}));
-const isQrl$1 = (value) => "function" == typeof value && "function" == typeof value.getSymbol;
+const isQrl = (value) => "function" == typeof value && "function" == typeof value.getSymbol;
+const EMPTY_ARRAY = [];
 const EMPTY_OBJ = {};
-Object.freeze(EMPTY_OBJ);
+Object.freeze(EMPTY_ARRAY), Object.freeze(EMPTY_OBJ);
+var ChoreType;
+!function(ChoreType2) {
+  ChoreType2[ChoreType2.MACRO = 240] = "MACRO", ChoreType2[ChoreType2.MICRO = 15] = "MICRO", ChoreType2[ChoreType2.QRL_RESOLVE = 1] = "QRL_RESOLVE", ChoreType2[ChoreType2.RUN_QRL = 2] = "RUN_QRL", ChoreType2[ChoreType2.TASK = 3] = "TASK", ChoreType2[ChoreType2.NODE_DIFF = 4] = "NODE_DIFF", ChoreType2[ChoreType2.NODE_PROP = 5] = "NODE_PROP", ChoreType2[ChoreType2.COMPONENT = 6] = "COMPONENT", ChoreType2[ChoreType2.RECOMPUTE_AND_SCHEDULE_EFFECTS = 7] = "RECOMPUTE_AND_SCHEDULE_EFFECTS", ChoreType2[ChoreType2.JOURNAL_FLUSH = 16] = "JOURNAL_FLUSH", ChoreType2[ChoreType2.VISIBLE = 32] = "VISIBLE", ChoreType2[ChoreType2.CLEANUP_VISIBLE = 48] = "CLEANUP_VISIBLE", ChoreType2[ChoreType2.WAIT_FOR_ALL = 255] = "WAIT_FOR_ALL";
+}(ChoreType || (ChoreType = {}));
+const Slot = (props) => _jsxSorted(Virtual, null, {
+  [QSlotS]: ""
+}, props.children, 0, props.name ?? "");
+const SkipRender = Symbol("skip render");
+const SSRRaw = () => null;
+const SSRComment = () => null;
+const isJsxPropertyAnEventName = (name) => (name.startsWith("on") || name.startsWith("window:on") || name.startsWith("document:on")) && name.endsWith("$");
+const isHtmlAttributeAnEventName = (name) => name.startsWith("on:") || name.startsWith("on-window:") || name.startsWith("on-document:");
+const getEventNameFromJsxProp = (name) => {
+  if (name.endsWith("$")) {
+    let idx = -1;
+    if (name.startsWith("on") ? idx = 2 : name.startsWith("window:on") ? idx = 9 : name.startsWith("document:on") && (idx = 11), -1 != idx) {
+      const isCaseSensitive = isDashAt(name, idx) && !isDashAt(name, idx + 1);
+      isCaseSensitive && idx++;
+      let lastIdx = idx;
+      let eventName = "";
+      for (; ; ) {
+        idx = name.indexOf("-", lastIdx);
+        const chunk = name.substring(lastIdx, -1 === idx ? name.length - 1 : idx);
+        if (eventName += isCaseSensitive ? chunk : chunk.toLowerCase(), -1 == idx) {
+          return eventName;
+        }
+        isDashAt(name, idx + 1) ? (eventName += "-", idx++) : (eventName += name.charAt(idx + 1).toUpperCase(), idx++), lastIdx = idx + 1;
+      }
+    }
+  }
+  return null;
+};
+const getEventNameScopeFromJsxProp = (name) => {
+  const index = name.indexOf(":");
+  return -1 !== index ? name.substring(0, index) : "";
+};
+const isDashAt = (name, idx) => 45 === name.charCodeAt(idx);
+const convertEventNameFromJsxPropToHtmlAttr = (name) => {
+  if (name.endsWith("$")) {
+    let prefix = null;
+    if (name.startsWith("on") ? prefix = "on:" : name.startsWith("window:on") ? prefix = "on-window:" : name.startsWith("document:on") && (prefix = "on-document:"), null !== prefix) {
+      const eventName = getEventNameFromJsxProp(name);
+      return prefix + fromCamelToKebabCase(eventName);
+    }
+  }
+  return null;
+};
+const fromCamelToKebabCase = (text) => text.replace(/([A-Z-])/g, "-$1").toLowerCase();
+function isPreventDefault(key) {
+  return key.startsWith("preventdefault:");
+}
+function getFileLocationFromJsx(jsxDev) {
+  if (!jsxDev) {
+    return null;
+  }
+  const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, "/");
+  return sanitizedFileName ? `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}` : null;
+}
+const styleContent = (styleId) => "⚡️" + styleId;
+function hasClassAttr(props) {
+  for (const key in props) {
+    if (Object.prototype.hasOwnProperty.call(props, key) && isClassAttr(key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isClassAttr(key) {
+  return "class" === key || "className" === key;
+}
+function convertScopedStyleIdsToArray(scopedStyleIds) {
+  return scopedStyleIds?.split(" ") ?? null;
+}
+function convertStyleIdsToString(scopedStyleIds) {
+  return Array.from(scopedStyleIds).join(" ");
+}
+const addComponentStylePrefix = (styleId) => {
+  if (styleId) {
+    let idx = 0;
+    do {
+      styleId = styleId.substring(0, idx) + styleContent(styleId.substring(idx));
+    } while (0 !== (idx = styleId.indexOf(" ", idx) + 1));
+  }
+  return styleId || null;
+};
+const unitlessNumbers = /* @__PURE__ */ new Set(["animationIterationCount", "aspectRatio", "borderImageOutset", "borderImageSlice", "borderImageWidth", "boxFlex", "boxFlexGroup", "boxOrdinalGroup", "columnCount", "columns", "flex", "flexGrow", "flexShrink", "gridArea", "gridRow", "gridRowEnd", "gridRowStart", "gridColumn", "gridColumnEnd", "gridColumnStart", "fontWeight", "lineClamp", "lineHeight", "opacity", "order", "orphans", "scale", "tabSize", "widows", "zIndex", "zoom", "MozAnimationIterationCount", "MozBoxFlex", "msFlex", "msFlexPositive", "WebkitAnimationIterationCount", "WebkitBoxFlex", "WebkitBoxOrdinalGroup", "WebkitColumnCount", "WebkitColumns", "WebkitFlex", "WebkitFlexGrow", "WebkitFlexShrink", "WebkitLineClamp"]);
+const isUnitlessNumber = (name) => unitlessNumbers.has(name);
+const serializeClass = (obj) => {
+  if (!obj) {
+    return "";
+  }
+  if (isString(obj)) {
+    return obj.trim();
+  }
+  const classes = [];
+  if (isArray(obj)) {
+    for (const o of obj) {
+      const classList = serializeClass(o);
+      classList && classes.push(classList);
+    }
+  } else {
+    for (const [key, value] of Object.entries(obj)) {
+      value && classes.push(key.trim());
+    }
+  }
+  return classes.join(" ");
+};
+const fromCamelToKebabCaseWithDash = (text) => text.replace(/([A-Z])/g, "-$1").toLowerCase();
+const stringifyStyle = (obj) => {
+  if (null == obj) {
+    return "";
+  }
+  if ("object" == typeof obj) {
+    if (isArray(obj)) {
+      throw qError(QError.stringifyClassOrStyle, [obj, "style"]);
+    }
+    {
+      const chunks = [];
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          const value = obj[key];
+          null != value && "function" != typeof value && (key.startsWith("--") ? chunks.push(key + ":" + value) : chunks.push(fromCamelToKebabCaseWithDash(key) + ":" + setValueForStyle(key, value)));
+        }
+      }
+      return chunks.join(";");
+    }
+  }
+  return String(obj);
+};
+const serializeBooleanOrNumberAttribute = (value) => null != value ? String(value) : null;
+function serializeAttribute(key, value, styleScopedId) {
+  if (isClassAttr(key)) {
+    const serializedClass = serializeClass(value);
+    value = styleScopedId ? styleScopedId + (serializedClass.length ? " " + serializedClass : serializedClass) : serializedClass;
+  } else {
+    "style" === key ? value = stringifyStyle(value) : isEnumeratedBooleanAttribute(key) || "number" == typeof value ? value = serializeBooleanOrNumberAttribute(value) : false === value || null == value ? value = null : true === value && isPreventDefault(key) && (value = "");
+  }
+  return value;
+}
+function isEnumeratedBooleanAttribute(key) {
+  return isAriaAttribute(key) || ["spellcheck", "draggable", "contenteditable"].includes(key);
+}
+const setValueForStyle = (styleName, value) => "number" != typeof value || 0 === value || isUnitlessNumber(styleName) ? value : value + "px";
+function isAriaAttribute(prop) {
+  return prop.startsWith("aria-");
+}
 const STORE_TARGET = Symbol("store.target");
+const STORE_HANDLER = Symbol("store.handler");
+const STORE_ARRAY_PROP = Symbol("store.array");
 var StoreFlags;
 !function(StoreFlags2) {
   StoreFlags2[StoreFlags2.NONE = 0] = "NONE", StoreFlags2[StoreFlags2.RECURSIVE = 1] = "RECURSIVE", StoreFlags2[StoreFlags2.IMMUTABLE = 2] = "IMMUTABLE";
 }(StoreFlags || (StoreFlags = {}));
+const getStoreHandler = (value) => value[STORE_HANDLER];
+const getStoreTarget = (value) => value?.[STORE_TARGET] || null;
+const unwrapStore = (value) => getStoreTarget(value) || value;
 const isStore = (value) => STORE_TARGET in value;
-class Subscriber {
+function createStore(container, obj, flags) {
+  return new Proxy(obj, new StoreHandler(flags, container || null));
+}
+const getOrCreateStore = (obj, flags, container) => {
+  if (isSerializableObject(obj) && container) {
+    let store = container.$storeProxyMap$.get(obj);
+    return store || (store = createStore(container, obj, flags), container.$storeProxyMap$.set(obj, store)), store;
+  }
+  return obj;
+};
+class StoreHandler {
+  constructor($flags$, $container$) {
+    __publicField(this, "$flags$");
+    __publicField(this, "$container$");
+    __publicField(this, "$effects$", null);
+    this.$flags$ = $flags$, this.$container$ = $container$;
+  }
+  toString() {
+    return "[Store]";
+  }
+  get(target, prop) {
+    if ("symbol" == typeof prop) {
+      return prop === STORE_TARGET ? target : prop === STORE_HANDLER ? this : target[prop];
+    }
+    const ctx = tryGetInvokeContext();
+    const value = target[prop];
+    if (ctx) {
+      if (null === this.$container$) {
+        if (!ctx.$container$) {
+          return value;
+        }
+        this.$container$ = ctx.$container$;
+      } else {
+        assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$);
+      }
+      const effectSubscriber = ctx.$effectSubscriber$;
+      effectSubscriber && addEffect(target, Array.isArray(target) ? STORE_ARRAY_PROP : prop, this, effectSubscriber);
+    }
+    if ("toString" === prop && value === Object.prototype.toString) {
+      return this.toString;
+    }
+    return this.$flags$ & StoreFlags.RECURSIVE && "object" == typeof value && null !== value && !Object.isFrozen(value) && !isStore(value) && !Object.isFrozen(target) ? getOrCreateStore(value, this.$flags$, this.$container$) : value;
+  }
+  set(target, prop, value) {
+    if ("symbol" == typeof prop) {
+      return target[prop] = value, true;
+    }
+    const newValue = this.$flags$ & StoreFlags.RECURSIVE ? unwrapStore(value) : value;
+    if (prop in target) {
+      newValue !== target[prop] && setNewValueAndTriggerEffects(prop, newValue, target, this);
+    } else {
+      setNewValueAndTriggerEffects(prop, newValue, target, this);
+    }
+    return true;
+  }
+  deleteProperty(target, prop) {
+    return "string" == typeof prop && delete target[prop] && (triggerEffects(this.$container$, this, getEffects(target, prop, this.$effects$)), true);
+  }
+  has(target, prop) {
+    if (prop === STORE_TARGET) {
+      return true;
+    }
+    if ("string" == typeof prop) {
+      const ctx = tryGetInvokeContext();
+      if (ctx) {
+        const effectSubscriber = ctx.$effectSubscriber$;
+        effectSubscriber && addEffect(target, Array.isArray(target) ? STORE_ARRAY_PROP : prop, this, effectSubscriber);
+      }
+    }
+    return Object.prototype.hasOwnProperty.call(target, prop);
+  }
+  ownKeys(target) {
+    const ctx = tryGetInvokeContext();
+    const effectSubscriber = ctx?.$effectSubscriber$;
+    return effectSubscriber && addEffect(target, STORE_ARRAY_PROP, this, effectSubscriber), Reflect.ownKeys(target);
+  }
+  getOwnPropertyDescriptor(target, prop) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+    return Array.isArray(target) || "symbol" == typeof prop || descriptor && !descriptor.configurable ? descriptor : {
+      enumerable: true,
+      configurable: true
+    };
+  }
+}
+function addEffect(target, prop, store, effectSubscription) {
+  const effectsMap = store.$effects$ || (store.$effects$ = /* @__PURE__ */ new Map());
+  let effects = effectsMap.get(prop);
+  effects || (effects = /* @__PURE__ */ new Set(), effectsMap.set(prop, effects)), ensureContainsSubscription(effects, effectSubscription), ensureContainsBackRef(effectSubscription, target), addQrlToSerializationCtx(effectSubscription, store.$container$);
+}
+function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
+  target[prop] = value, triggerEffects(currentStore.$container$, currentStore, getEffects(target, prop, currentStore.$effects$));
+}
+function getEffects(target, prop, storeEffects) {
+  let effectsToTrigger;
+  if (storeEffects) {
+    if (Array.isArray(target)) {
+      for (const effects of storeEffects.values()) {
+        effectsToTrigger || (effectsToTrigger = /* @__PURE__ */ new Set());
+        for (const effect of effects) {
+          effectsToTrigger.add(effect);
+        }
+      }
+    } else {
+      effectsToTrigger = storeEffects.get(prop);
+    }
+  }
+  const storeArrayValue = storeEffects?.get(STORE_ARRAY_PROP);
+  if (storeArrayValue) {
+    effectsToTrigger || (effectsToTrigger = /* @__PURE__ */ new Set());
+    for (const effect of storeArrayValue) {
+      effectsToTrigger.add(effect);
+    }
+  }
+  return effectsToTrigger || null;
+}
+const NEEDS_COMPUTATION = Symbol("invalid");
+const _EFFECT_BACK_REF = Symbol("backRef");
+_a = _EFFECT_BACK_REF;
+class BackRef {
   constructor() {
-    __publicField(this, "$effectDependencies$", null);
+    __publicField(this, _a, null);
+  }
+}
+function clearAllEffects(container, consumer) {
+  vnode_isVNode(consumer) && vnode_isElementVNode(consumer) && ensureMaterialized(consumer);
+  const effects = consumer[_EFFECT_BACK_REF];
+  if (effects) {
+    for (const [, effect] of effects) {
+      const backRefs = effect[EffectSubscriptionProp.BACK_REF];
+      if (!backRefs) {
+        return;
+      }
+      for (const producer of backRefs) {
+        if (producer instanceof Signal) {
+          clearSignal(container, producer, effect);
+        } else if (container.$storeProxyMap$.has(producer)) {
+          const target = container.$storeProxyMap$.get(producer);
+          clearStore(getStoreHandler(target), effect);
+        }
+      }
+    }
+  }
+}
+function clearSignal(container, producer, effect) {
+  const effects = producer.$effects$;
+  effects && effects.delete(effect), producer instanceof WrappedSignal && (producer.$hostElement$ = null, clearAllEffects(container, producer));
+}
+function clearStore(producer, effect) {
+  const effects = producer?.$effects$;
+  if (effects) {
+    for (const propEffects of effects.values()) {
+      propEffects.delete(effect);
+    }
+  }
+}
+function getSubscriber(effect, prop, data) {
+  effect[_EFFECT_BACK_REF] || (isServer && isSsrNode(effect) ? effect.setProp("q:brefs", /* @__PURE__ */ new Map()) : effect[_EFFECT_BACK_REF] = /* @__PURE__ */ new Map());
+  const subMap = effect[_EFFECT_BACK_REF];
+  let sub = subMap.get(prop);
+  return sub || (sub = [effect, prop], subMap.set(prop, sub)), data && (sub[EffectSubscriptionProp.DATA] = data), sub;
+}
+function isSsrNode(value) {
+  return "__brand__" in value && "currentComponentNode" in value;
+}
+var TaskFlags;
+!function(TaskFlags2) {
+  TaskFlags2[TaskFlags2.VISIBLE_TASK = 1] = "VISIBLE_TASK", TaskFlags2[TaskFlags2.TASK = 2] = "TASK", TaskFlags2[TaskFlags2.RESOURCE = 4] = "RESOURCE", TaskFlags2[TaskFlags2.DIRTY = 8] = "DIRTY";
+}(TaskFlags || (TaskFlags = {}));
+const runTask = (task, container, host) => {
+  task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
+  const iCtx = newInvokeContext(container.$locale$, host, void 0, "qTask");
+  iCtx.$container$ = container;
+  const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
+  let cleanupFns = null;
+  const cleanup2 = (fn) => {
+    "function" == typeof fn && (cleanupFns || (cleanupFns = [], task.$destroy$ = noSerialize(() => {
+      task.$destroy$ = null, cleanupFns.forEach((fn2) => {
+        try {
+          fn2();
+        } catch (err) {
+          container.handleError(err, host);
+        }
+      });
+    })), cleanupFns.push(fn));
+  };
+  const taskApi = {
+    track: (obj, prop) => {
+      const ctx = newInvokeContext();
+      return ctx.$effectSubscriber$ = getSubscriber(task, EffectProperty.COMPONENT), ctx.$container$ = container, invoke(ctx, () => {
+        if (isFunction(obj)) {
+          return obj();
+        }
+        if (prop) {
+          return obj[prop];
+        }
+        if (isSignal(obj)) {
+          return obj.value;
+        }
+        throw qError(QError.trackObjectWithoutProp);
+      });
+    },
+    cleanup: cleanup2
+  };
+  return safeCall(() => taskFn(taskApi), cleanup2, (err) => {
+    if (isPromise(err)) {
+      return err.then(() => runTask(task, container, host));
+    }
+    throw err;
+  });
+};
+const cleanupTask = (task) => {
+  const destroy = task.$destroy$;
+  if (destroy) {
+    task.$destroy$ = null;
+    try {
+      destroy();
+    } catch (err) {
+      logError(err);
+    }
+  }
+};
+class Task extends BackRef {
+  constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
+    super();
+    __publicField(this, "$flags$");
+    __publicField(this, "$index$");
+    __publicField(this, "$el$");
+    __publicField(this, "$qrl$");
+    __publicField(this, "$state$");
+    __publicField(this, "$destroy$");
+    this.$flags$ = $flags$, this.$index$ = $index$, this.$el$ = $el$, this.$qrl$ = $qrl$, this.$state$ = $state$, this.$destroy$ = $destroy$;
+  }
+}
+const isTask = (value) => value instanceof Task;
+var VNodeFlags;
+var VNodeFlagsIndex;
+var VNodeProps;
+var ElementVNodeProps;
+var TextVNodeProps;
+var VirtualVNodeProps;
+!function(VNodeFlags2) {
+  VNodeFlags2[VNodeFlags2.Element = 1] = "Element", VNodeFlags2[VNodeFlags2.Virtual = 2] = "Virtual", VNodeFlags2[VNodeFlags2.ELEMENT_OR_VIRTUAL_MASK = 3] = "ELEMENT_OR_VIRTUAL_MASK", VNodeFlags2[VNodeFlags2.ELEMENT_OR_TEXT_MASK = 5] = "ELEMENT_OR_TEXT_MASK", VNodeFlags2[VNodeFlags2.TYPE_MASK = 7] = "TYPE_MASK", VNodeFlags2[VNodeFlags2.INFLATED_TYPE_MASK = 15] = "INFLATED_TYPE_MASK", VNodeFlags2[VNodeFlags2.Text = 4] = "Text", VNodeFlags2[VNodeFlags2.Inflated = 8] = "Inflated", VNodeFlags2[VNodeFlags2.Resolved = 16] = "Resolved", VNodeFlags2[VNodeFlags2.Deleted = 32] = "Deleted", VNodeFlags2[VNodeFlags2.NAMESPACE_MASK = 192] = "NAMESPACE_MASK", VNodeFlags2[VNodeFlags2.NEGATED_NAMESPACE_MASK = -193] = "NEGATED_NAMESPACE_MASK", VNodeFlags2[VNodeFlags2.NS_html = 0] = "NS_html", VNodeFlags2[VNodeFlags2.NS_svg = 64] = "NS_svg", VNodeFlags2[VNodeFlags2.NS_math = 128] = "NS_math";
+}(VNodeFlags || (VNodeFlags = {})), function(VNodeFlagsIndex2) {
+  VNodeFlagsIndex2[VNodeFlagsIndex2.mask = -256] = "mask", VNodeFlagsIndex2[VNodeFlagsIndex2.negated_mask = 255] = "negated_mask", VNodeFlagsIndex2[VNodeFlagsIndex2.shift = 8] = "shift";
+}(VNodeFlagsIndex || (VNodeFlagsIndex = {})), function(VNodeProps2) {
+  VNodeProps2[VNodeProps2.flags = 0] = "flags", VNodeProps2[VNodeProps2.parent = 1] = "parent", VNodeProps2[VNodeProps2.previousSibling = 2] = "previousSibling", VNodeProps2[VNodeProps2.nextSibling = 3] = "nextSibling";
+}(VNodeProps || (VNodeProps = {})), function(ElementVNodeProps2) {
+  ElementVNodeProps2[ElementVNodeProps2.firstChild = 4] = "firstChild", ElementVNodeProps2[ElementVNodeProps2.lastChild = 5] = "lastChild", ElementVNodeProps2[ElementVNodeProps2.element = 6] = "element", ElementVNodeProps2[ElementVNodeProps2.elementName = 7] = "elementName", ElementVNodeProps2[ElementVNodeProps2.PROPS_OFFSET = 8] = "PROPS_OFFSET";
+}(ElementVNodeProps || (ElementVNodeProps = {})), function(TextVNodeProps2) {
+  TextVNodeProps2[TextVNodeProps2.node = 4] = "node", TextVNodeProps2[TextVNodeProps2.text = 5] = "text";
+}(TextVNodeProps || (TextVNodeProps = {})), function(VirtualVNodeProps2) {
+  VirtualVNodeProps2[VirtualVNodeProps2.firstChild = 4] = "firstChild", VirtualVNodeProps2[VirtualVNodeProps2.lastChild = 5] = "lastChild", VirtualVNodeProps2[VirtualVNodeProps2.PROPS_OFFSET = 6] = "PROPS_OFFSET";
+}(VirtualVNodeProps || (VirtualVNodeProps = {}));
+const mapApp_findIndx = (elementVNode, key, start) => {
+  let bottom = start >> 1;
+  let top = elementVNode.length - 2 >> 1;
+  for (; bottom <= top; ) {
+    const mid = bottom + (top - bottom >> 1);
+    const midKey = elementVNode[mid << 1];
+    if (midKey === key) {
+      return mid << 1;
+    }
+    midKey < key ? bottom = mid + 1 : top = mid - 1;
+  }
+  return ~(bottom << 1);
+};
+const mapArray_set = (elementVNode, key, value, start) => {
+  const indx = mapApp_findIndx(elementVNode, key, start);
+  indx >= 0 ? null == value ? elementVNode.splice(indx, 2) : elementVNode[indx + 1] = value : null != value && elementVNode.splice(~indx, 0, key, value);
+};
+const mapArray_get = (elementVNode, key, start) => {
+  const indx = mapApp_findIndx(elementVNode, key, start);
+  return indx >= 0 ? elementVNode[indx + 1] : null;
+};
+const isForeignObjectElement = (elementName) => "foreignObject" === elementName;
+const isSvgElement = (elementName) => "svg" === elementName || isForeignObjectElement(elementName);
+const isMathElement = (elementName) => "math" === elementName;
+const vnode_isDefaultNamespace = (vnode) => !(vnode[VNodeProps.flags] & VNodeFlags.NAMESPACE_MASK);
+const vnode_getElementNamespaceFlags = (element) => {
+  switch (fastNamespaceURI(element)) {
+    case SVG_NS:
+      return VNodeFlags.NS_svg;
+    case MATH_NS:
+      return VNodeFlags.NS_math;
+    default:
+      return VNodeFlags.NS_html;
+  }
+};
+function vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild) {
+  const { elementNamespace, elementNamespaceFlag } = getNewElementNamespaceData(domParentVNode, newChild);
+  let domChildren = [];
+  if (elementNamespace === HTML_NS) {
+    domChildren = vnode_getDOMChildNodes(journal, newChild);
+  } else {
+    const children = vnode_getDOMChildNodes(journal, newChild, true);
+    for (let i = 0; i < children.length; i++) {
+      const childVNode = children[i];
+      if (vnode_isTextVNode(childVNode)) {
+        domChildren.push(childVNode[TextVNodeProps.node]);
+        continue;
+      }
+      if ((childVNode[VNodeProps.flags] & VNodeFlags.NAMESPACE_MASK) == (domParentVNode[VNodeProps.flags] & VNodeFlags.NAMESPACE_MASK)) {
+        domChildren.push(childVNode[ElementVNodeProps.element]);
+        continue;
+      }
+      const newChildElement = vnode_cloneElementWithNamespace(childVNode, domParentVNode, elementNamespace, elementNamespaceFlag);
+      newChildElement && domChildren.push(newChildElement);
+    }
+  }
+  return domChildren;
+}
+function cloneElementWithNamespace(element, elementName, namespace) {
+  const newElement = element.ownerDocument.createElementNS(namespace, elementName);
+  const attributes = element.attributes;
+  for (const attribute of attributes) {
+    const name = attribute.name;
+    name && ":" !== name && newElement.setAttribute(name, attribute.value);
+  }
+  return newElement;
+}
+function vnode_cloneElementWithNamespace(elementVNode, parentVNode, namespace, namespaceFlag) {
+  ensureElementVNode(elementVNode);
+  let vCursor = elementVNode;
+  let vParent = null;
+  let rootElement = null;
+  let parentElement = null;
+  for (; vCursor; ) {
+    let childElement = null;
+    let newChildElement = null;
+    if (vnode_isElementVNode(vCursor)) {
+      childElement = vCursor[ElementVNodeProps.element];
+      const childElementTag = vnode_getElementName(vCursor);
+      const vCursorParent = vnode_getParent(vCursor);
+      const vCursorDomParent = null == rootElement ? parentVNode : vCursorParent && vnode_getDomParentVNode(vCursorParent);
+      if (vCursorDomParent) {
+        const namespaceData = getNewElementNamespaceData(vCursorDomParent, vnode_getElementName(vCursor));
+        namespace = namespaceData.elementNamespace, namespaceFlag = namespaceData.elementNamespaceFlag;
+      }
+      newChildElement = cloneElementWithNamespace(childElement, childElementTag, namespace), childElement.remove(), null == rootElement && (rootElement = newChildElement), parentElement && parentElement.appendChild(newChildElement);
+      const vFirstChild = vnode_getFirstChild(vCursor);
+      if (vCursor[ElementVNodeProps.element] = newChildElement, vCursor[VNodeProps.flags] &= VNodeFlags.NEGATED_NAMESPACE_MASK, vCursor[VNodeProps.flags] |= namespaceFlag, vFirstChild) {
+        vCursor = vFirstChild, parentElement = newChildElement;
+        continue;
+      }
+      if (shouldIgnoreChildren(childElement)) {
+        const container = getDomContainerFromQContainerElement(childElement);
+        if (container) {
+          const innerContainerFirstVNode = vnode_getFirstChild(container.rootVNode);
+          if (innerContainerFirstVNode) {
+            vCursor = innerContainerFirstVNode, parentElement = newChildElement;
+            continue;
+          }
+        }
+      }
+    }
+    if (vCursor === elementVNode) {
+      return rootElement;
+    }
+    const vNextSibling = vnode_getNextSibling(vCursor);
+    if (vNextSibling) {
+      vCursor = vNextSibling;
+    } else {
+      for (vParent = vnode_getParent(vCursor); vParent; ) {
+        if (vParent === elementVNode) {
+          return rootElement;
+        }
+        const vNextParentSibling = vnode_getNextSibling(vParent);
+        if (vNextParentSibling) {
+          return vCursor = vNextParentSibling, rootElement;
+        }
+        vParent = vnode_getParent(vParent);
+      }
+      if (null == vParent) {
+        return rootElement;
+      }
+    }
+  }
+  return rootElement;
+}
+function isSvg(tagOrVNode) {
+  return "string" == typeof tagOrVNode ? isSvgElement(tagOrVNode) : !!(tagOrVNode[VNodeProps.flags] & VNodeFlags.NS_svg);
+}
+function isMath(tagOrVNode) {
+  return "string" == typeof tagOrVNode ? isMathElement(tagOrVNode) : !!(tagOrVNode[VNodeProps.flags] & VNodeFlags.NS_math);
+}
+function getNewElementNamespaceData(domParentVNode, tagOrVNode) {
+  const parentIsDefaultNamespace = !domParentVNode || !!vnode_getElementName(domParentVNode) && vnode_isDefaultNamespace(domParentVNode);
+  const parentIsForeignObject = !parentIsDefaultNamespace && isForeignObjectElement(vnode_getElementName(domParentVNode));
+  let elementNamespace = HTML_NS;
+  let elementNamespaceFlag = VNodeFlags.NS_html;
+  const isElementVNodeOrString = "string" == typeof tagOrVNode || vnode_isElementVNode(tagOrVNode);
+  if (isElementVNodeOrString && isSvg(tagOrVNode)) {
+    elementNamespace = SVG_NS, elementNamespaceFlag = VNodeFlags.NS_svg;
+  } else if (isElementVNodeOrString && isMath(tagOrVNode)) {
+    elementNamespace = MATH_NS, elementNamespaceFlag = VNodeFlags.NS_math;
+  } else if (domParentVNode && !parentIsForeignObject && !parentIsDefaultNamespace) {
+    elementNamespace = !!(domParentVNode[VNodeProps.flags] & VNodeFlags.NS_svg) ? SVG_NS : !!(domParentVNode[VNodeProps.flags] & VNodeFlags.NS_math) ? MATH_NS : HTML_NS, elementNamespaceFlag = domParentVNode[VNodeProps.flags] & VNodeFlags.NAMESPACE_MASK;
+  }
+  return {
+    elementNamespace,
+    elementNamespaceFlag
+  };
+}
+const executeComponent = (container, renderHost, subscriptionHost, componentQRL, props) => {
+  const iCtx = newInvokeContext(container.$locale$, subscriptionHost || void 0, void 0, "qRender");
+  let componentFn;
+  subscriptionHost && (iCtx.$effectSubscriber$ = getSubscriber(subscriptionHost, EffectProperty.COMPONENT), iCtx.$container$ = container), container.ensureProjectionResolved(renderHost);
+  let isInlineComponent = false;
+  if (null === componentQRL && assertDefined(componentQRL = container.getHostProp(renderHost, "q:renderFn")), isQrl$1(componentQRL)) {
+    (props = props || container.getHostProp(renderHost, "q:props") || EMPTY_OBJ).children && delete props.children, componentFn = componentQRL.getFn(iCtx);
+  } else if (isQwikComponent(componentQRL)) {
+    const qComponentFn = componentQRL;
+    componentFn = () => invokeApply(iCtx, qComponentFn, [props || EMPTY_OBJ, null, 0]);
+  } else {
+    isInlineComponent = true;
+    const inlineComponent = componentQRL;
+    componentFn = () => invokeApply(iCtx, inlineComponent, [props || EMPTY_OBJ]);
+  }
+  const executeComponentWithPromiseExceptionRetry = (retryCount = 0) => safeCall(() => (isInlineComponent || (container.setHostProp(renderHost, "q:seqIdx", null), container.setHostProp(renderHost, ":onIdx", null), container.setHostProp(renderHost, "q:props", props)), vnode_isVNode(renderHost) && clearAllEffects(container, renderHost), componentFn(props)), (jsx2) => {
+    const useOnEvents = container.getHostProp(renderHost, ":on");
+    return useOnEvents ? addUseOnEvents(jsx2, useOnEvents) : jsx2;
+  }, (err) => {
+    if (isPromise(err) && retryCount < 100) {
+      return err.then(() => executeComponentWithPromiseExceptionRetry(retryCount++));
+    }
+    throw err;
+  });
+  return executeComponentWithPromiseExceptionRetry();
+};
+function addUseOnEvents(jsx2, useOnEvents) {
+  const jsxElement = findFirstStringJSX(jsx2);
+  let jsxResult = jsx2;
+  return maybeThen(jsxElement, (jsxElement2) => {
+    let isInvisibleComponent = false;
+    jsxElement2 || (isInvisibleComponent = true);
+    for (const key in useOnEvents) {
+      if (Object.prototype.hasOwnProperty.call(useOnEvents, key)) {
+        if (isInvisibleComponent) {
+          if ("onQvisible$" === key) {
+            const [jsxElement3, jsx3] = addScriptNodeForInvisibleComponents(jsxResult);
+            jsxResult = jsx3, jsxElement3 && addUseOnEvent(jsxElement3, "document:onQinit$", useOnEvents[key]);
+          } else if (key.startsWith("document:") || key.startsWith("window:")) {
+            const [jsxElement3, jsx3] = addScriptNodeForInvisibleComponents(jsxResult);
+            jsxResult = jsx3, jsxElement3 && addUseOnEvent(jsxElement3, key, useOnEvents[key]);
+          } else ;
+        } else {
+          jsxElement2 && addUseOnEvent(jsxElement2, key, useOnEvents[key]);
+        }
+      }
+    }
+    return jsxResult;
+  });
+}
+function addUseOnEvent(jsxElement, key, value) {
+  let props = jsxElement.props;
+  props === EMPTY_OBJ && (props = jsxElement.props = {});
+  let propValue = props[key];
+  void 0 === propValue ? propValue = [] : Array.isArray(propValue) || (propValue = [propValue]), propValue.push(...value), props[key] = propValue;
+}
+function findFirstStringJSX(jsx2) {
+  const queue = [jsx2];
+  for (; queue.length; ) {
+    const jsx3 = queue.shift();
+    if (isJSXNode(jsx3)) {
+      if ("string" == typeof jsx3.type) {
+        return jsx3;
+      }
+      queue.push(jsx3.children);
+    } else if (Array.isArray(jsx3)) {
+      queue.push(...jsx3);
+    } else {
+      if (isPromise(jsx3)) {
+        return maybeThen(jsx3, (jsx4) => findFirstStringJSX(jsx4));
+      }
+      if (isSignal(jsx3)) {
+        return findFirstStringJSX(untrack(() => jsx3.value));
+      }
+    }
+  }
+  return null;
+}
+function addScriptNodeForInvisibleComponents(jsx2) {
+  if (isJSXNode(jsx2)) {
+    const jsxElement = new JSXNodeImpl("script", {}, {
+      type: "placeholder",
+      hidden: ""
+    }, null, 3);
+    return jsx2.type === Slot ? [jsxElement, _jsxSorted(Fragment, null, null, [jsx2, jsxElement], 0, null)] : (null == jsx2.children ? jsx2.children = jsxElement : Array.isArray(jsx2.children) ? jsx2.children.push(jsxElement) : jsx2.children = [jsx2.children, jsxElement], [jsxElement, jsx2]);
+  }
+  if (Array.isArray(jsx2) && jsx2.length) {
+    const [jsxElement, _] = addScriptNodeForInvisibleComponents(jsx2[0]);
+    return [jsxElement, jsx2];
+  }
+  return [null, null];
+}
+const _CONST_PROPS = Symbol("CONST");
+const _VAR_PROPS = Symbol("VAR");
+function isSlotProp(prop) {
+  return !prop.startsWith("q:") && !prop.startsWith(":");
+}
+function isParentSlotProp(prop) {
+  return prop.startsWith(":");
+}
+function escapeHTML(html) {
+  let escapedHTML = "";
+  const length = html.length;
+  let idx = 0;
+  let lastIdx = idx;
+  for (; idx < length; idx++) {
+    const ch = html.charCodeAt(idx);
+    if (60 === ch) {
+      escapedHTML += html.substring(lastIdx, idx) + "&lt;";
+    } else if (62 === ch) {
+      escapedHTML += html.substring(lastIdx, idx) + "&gt;";
+    } else if (38 === ch) {
+      escapedHTML += html.substring(lastIdx, idx) + "&amp;";
+    } else if (34 === ch) {
+      escapedHTML += html.substring(lastIdx, idx) + "&quot;";
+    } else {
+      if (39 !== ch) {
+        continue;
+      }
+      escapedHTML += html.substring(lastIdx, idx) + "&#39;";
+    }
+    lastIdx = idx + 1;
+  }
+  return 0 === lastIdx ? html : escapedHTML + html.substring(lastIdx);
+}
+const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
+  let journal = container.$journal$;
+  const stack2 = [];
+  const asyncQueue = [];
+  let vParent = null;
+  let vCurrent = null;
+  let vNewNode = null;
+  let vSiblings = null;
+  let vSiblingsIdx = -1;
+  let jsxChildren = null;
+  let jsxValue = null;
+  let jsxIdx = 0;
+  let jsxCount = 0;
+  let shouldAdvance = true;
+  return diff(jsxNode, vStartNode), function drainAsyncQueue() {
+    for (; asyncQueue.length; ) {
+      const jsxNode2 = asyncQueue.shift();
+      const vHostNode = asyncQueue.shift();
+      if (isPromise(jsxNode2)) {
+        return jsxNode2.then((jsxNode3) => (diff(jsxNode3, vHostNode), drainAsyncQueue()));
+      }
+      diff(jsxNode2, vHostNode);
+    }
+  }();
+  function diff(jsxNode2, vStartNode2) {
+    for (vParent = vStartNode2, vNewNode = null, vCurrent = vnode_getFirstChild(vStartNode2), stackPush(jsxNode2, true); stack2.length; ) {
+      for (; jsxIdx < jsxCount; ) {
+        if ("string" == typeof jsxValue) {
+          expectText(jsxValue);
+        } else if ("number" == typeof jsxValue) {
+          expectText(String(jsxValue));
+        } else if (jsxValue && "object" == typeof jsxValue) {
+          if (Array.isArray(jsxValue)) {
+            descend(jsxValue, false);
+          } else if (isSignal(jsxValue)) {
+            vCurrent && clearAllEffects(container, vCurrent), expectVirtual(VirtualType.WrappedSignal, null), descend(trackSignalAndAssignHost(jsxValue, vNewNode || vCurrent, EffectProperty.VNODE, container), true);
+          } else if (isPromise(jsxValue)) {
+            expectVirtual(VirtualType.Awaited, null), asyncQueue.push(jsxValue, vNewNode || vCurrent);
+          } else if (isJSXNode(jsxValue)) {
+            const type = jsxValue.type;
+            "string" == typeof type ? (expectNoMoreTextNodes(), expectElement(jsxValue, type), descend(jsxValue.children, true)) : "function" == typeof type && (type === Fragment ? (expectNoMoreTextNodes(), expectVirtual(VirtualType.Fragment, jsxValue.key), descend(jsxValue.children, true)) : type === Slot ? (expectNoMoreTextNodes(), expectSlot() || descend(jsxValue.children, true)) : type === Projection ? (expectProjection(), descend(jsxValue.children, true)) : type === SSRComment || type === SSRRaw ? expectNoMore() : (expectNoMoreTextNodes(), expectComponent(type)));
+          }
+        } else {
+          jsxValue === SkipRender ? journal = [] : expectText("");
+        }
+        advance();
+      }
+      expectNoMore(), ascend();
+    }
+  }
+  function advance() {
+    if (shouldAdvance) {
+      if (jsxIdx++, jsxIdx < jsxCount) {
+        jsxValue = jsxChildren[jsxIdx];
+      } else if (false === stack2[stack2.length - 1]) {
+        return ascend();
+      }
+      null !== vNewNode ? vNewNode = null : advanceToNextSibling();
+    } else {
+      shouldAdvance = true;
+    }
+  }
+  function peekNextSibling() {
+    if (null !== vSiblings) {
+      const idx = vSiblingsIdx + SiblingsArray.NextVNode;
+      return idx < vSiblings.length ? vSiblings[idx] : null;
+    }
+    return vCurrent ? vnode_getNextSibling(vCurrent) : null;
+  }
+  function advanceToNextSibling() {
+    vCurrent = peekNextSibling(), null !== vSiblings && (vSiblingsIdx += SiblingsArray.Size);
+  }
+  function descend(children, descendVNode) {
+    null != children ? (stackPush(children, descendVNode), descendVNode && (vSiblings = null, vSiblingsIdx = -1, vParent = vNewNode || vCurrent, vCurrent = vnode_getFirstChild(vParent), vNewNode = null), shouldAdvance = false) : function() {
+      const vFirstChild = vCurrent && vnode_getFirstChild(vCurrent);
+      if (null !== vFirstChild) {
+        let vChild = vFirstChild;
+        for (; vChild; ) {
+          cleanup(container, vChild), vChild = vnode_getNextSibling(vChild);
+        }
+        vnode_truncate(journal, vCurrent, vFirstChild);
+      }
+    }();
+  }
+  function ascend() {
+    stack2.pop() && (vSiblingsIdx = stack2.pop(), vSiblings = stack2.pop(), vNewNode = stack2.pop(), vCurrent = stack2.pop(), vParent = stack2.pop()), jsxValue = stack2.pop(), jsxCount = stack2.pop(), jsxIdx = stack2.pop(), jsxChildren = stack2.pop(), advance();
+  }
+  function stackPush(children, descendVNode) {
+    stack2.push(jsxChildren, jsxIdx, jsxCount, jsxValue), descendVNode && stack2.push(vParent, vCurrent, vNewNode, vSiblings, vSiblingsIdx), stack2.push(descendVNode), Array.isArray(children) ? (jsxIdx = 0, jsxCount = children.length, jsxChildren = children, jsxValue = jsxCount > 0 ? children[0] : null) : void 0 === children ? (jsxIdx = 0, jsxValue = null, jsxChildren = null, jsxCount = 0) : (jsxIdx = 0, jsxValue = children, jsxChildren = null, jsxCount = 1);
+  }
+  function getInsertBefore() {
+    if (vNewNode) {
+      return vCurrent;
+    }
+    if (null !== vSiblings) {
+      const nextIdx = vSiblingsIdx + SiblingsArray.NextVNode;
+      return nextIdx < vSiblings.length ? vSiblings[nextIdx] : null;
+    }
+    return peekNextSibling();
+  }
+  function expectProjection() {
+    const slotName = jsxValue.key;
+    vCurrent = vnode_getProp(vParent, slotName, (id) => vnode_locate(container.rootVNode, id)), null == vCurrent && (vNewNode = vnode_newVirtual(), vnode_setProp(vNewNode, QSlot, slotName), vnode_setProp(vNewNode, ":", vParent), vnode_setProp(vParent, slotName, vNewNode));
+  }
+  function expectSlot() {
+    const vHost = vnode_getProjectionParentComponent(vParent, container.rootVNode);
+    const slotNameKey = function(vHost2) {
+      const jsxNode2 = jsxValue;
+      const constProps = jsxNode2.constProps;
+      if (constProps && "object" == typeof constProps && "name" in constProps) {
+        const constValue = constProps.name;
+        if (vHost2 && constValue instanceof WrappedSignal) {
+          return trackSignalAndAssignHost(constValue, vHost2, EffectProperty.COMPONENT, container);
+        }
+      }
+      return directGetPropsProxyProp(jsxNode2, "name") || "";
+    }(vHost);
+    const vProjectedNode = vHost ? vnode_getProp(vHost, slotNameKey, null) : null;
+    return null == vProjectedNode ? (vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()), vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), false) : (vProjectedNode === vCurrent || (vnode_insertBefore(journal, vParent, vNewNode = vProjectedNode, vCurrent && getInsertBefore()), vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), isDev), true);
+  }
+  function expectNoMore() {
+    if (null !== vCurrent) {
+      for (; vCurrent; ) {
+        const toRemove = vCurrent;
+        advanceToNextSibling(), cleanup(container, toRemove), vParent === vnode_getParent(toRemove) && vnode_remove(journal, vParent, toRemove, true);
+      }
+    }
+  }
+  function expectNoMoreTextNodes() {
+    for (; null !== vCurrent && vnode_isTextVNode(vCurrent); ) {
+      cleanup(container, vCurrent);
+      const toRemove = vCurrent;
+      advanceToNextSibling(), vnode_remove(journal, vParent, toRemove, true);
+    }
+  }
+  function createNewElement(jsx2, elementName, currentFile) {
+    const element = function(elementName2) {
+      const domParentVNode = vnode_getDomParentVNode(vParent);
+      const { elementNamespace, elementNamespaceFlag } = getNewElementNamespaceData(domParentVNode, elementName2);
+      const element2 = container.document.createElementNS(elementNamespace, elementName2);
+      return vNewNode = vnode_newElement(element2, elementName2), vNewNode[VNodeProps.flags] |= elementNamespaceFlag, element2;
+    }(elementName);
+    const { constProps } = jsx2;
+    let needsQDispatchEventPatch = false;
+    if (constProps) {
+      for (const key2 in constProps) {
+        let value = constProps[key2];
+        if (isJsxPropertyAnEventName(key2)) {
+          const eventName = getEventNameFromJsxProp(key2);
+          const scope = getEventNameScopeFromJsxProp(key2);
+          if (eventName && (vnode_setProp(vNewNode, HANDLER_PREFIX + ":" + scope + ":" + eventName, value), registerQwikLoaderEvent(eventName)), scope) {
+            const htmlEvent = convertEventNameFromJsxPropToHtmlAttr(key2);
+            htmlEvent && vnode_setAttr(journal, vNewNode, htmlEvent, "");
+          }
+          needsQDispatchEventPatch = true;
+        } else {
+          if ("ref" === key2) {
+            if (isSignal(value)) {
+              value.value = element;
+              continue;
+            }
+            if ("function" == typeof value) {
+              value(element);
+              continue;
+            }
+            if (null == value) {
+              continue;
+            }
+            throw qError(QError.invalidRefValue, [currentFile]);
+          }
+          if (isSignal(value)) {
+            const signalData = new SubscriptionData({
+              $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+              $isConst$: true
+            });
+            value = trackSignalAndAssignHost(value, vNewNode, key2, container, signalData);
+          }
+          if (key2 !== dangerouslySetInnerHTML) {
+            if ("textarea" !== elementName || "value" !== key2) {
+              value = serializeAttribute(key2, value, scopedStyleIdPrefix), null != value && element.setAttribute(key2, String(value));
+            } else {
+              if (value && "string" != typeof value) {
+                continue;
+              }
+              element.value = escapeHTML(value || "");
+            }
+          } else {
+            element.innerHTML = value, element.setAttribute("q:container", QContainerValue.HTML);
+          }
+        }
+      }
+    }
+    const key = jsx2.key;
+    key && (element.setAttribute("q:key", key), vnode_setProp(vNewNode, "q:key", key));
+    return !(hasClassAttr(jsx2.varProps) || jsx2.constProps && hasClassAttr(jsx2.constProps)) && scopedStyleIdPrefix && element.setAttribute("class", scopedStyleIdPrefix), vnode_insertBefore(journal, vParent, vNewNode, vCurrent), needsQDispatchEventPatch;
+  }
+  function expectElement(jsx2, elementName) {
+    const isSameElementName = vCurrent && vnode_isElementVNode(vCurrent) && elementName === vnode_getElementName(vCurrent);
+    const jsxKey = jsx2.key;
+    let needsQDispatchEventPatch = false;
+    const currentFile = getFileLocationFromJsx(jsx2.dev);
+    isSameElementName && jsxKey === getKey(vCurrent) || (vNewNode = retrieveChildWithKey(elementName, jsxKey), null === vNewNode ? needsQDispatchEventPatch = createNewElement(jsx2, elementName) : (vnode_insertBefore(journal, vParent, vNewNode, vCurrent), vCurrent = vNewNode, vNewNode = null, null !== vSiblings && (vSiblingsIdx -= SiblingsArray.Size)));
+    const jsxAttrs = [];
+    const props = jsx2.varProps;
+    for (const key in props) {
+      const value = props[key];
+      null != value && mapArray_set(jsxAttrs, key, value, 0);
+    }
+    null !== jsxKey && mapArray_set(jsxAttrs, "q:key", jsxKey, 0);
+    const vNode = vNewNode || vCurrent;
+    if (needsQDispatchEventPatch = function(vnode, srcAttrs, currentFile2) {
+      vnode_ensureElementInflated(vnode);
+      const dstAttrs = vnode_getProps(vnode);
+      let srcIdx = 0;
+      const srcLength = srcAttrs.length;
+      let dstIdx = 0;
+      let dstLength = dstAttrs.length;
+      let srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null;
+      let dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
+      let patchEventDispatch = false;
+      const record = (key, value) => {
+        if (key.startsWith(":")) {
+          vnode_setProp(vnode, key, value);
+        } else {
+          if ("ref" === key) {
+            const element = vnode_getNode(vnode);
+            if (isSignal(value)) {
+              return void (value.value = element);
+            }
+            if ("function" == typeof value) {
+              return void value(element);
+            }
+            if (null == value) {
+              return;
+            }
+            throw qError(QError.invalidRefValue, [currentFile2]);
+          }
+          if (isSignal(value)) {
+            const signalData = new SubscriptionData({
+              $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+              $isConst$: false
+            });
+            value = trackSignalAndAssignHost(value, vnode, key, container, signalData);
+          }
+          vnode_setAttr(journal, vnode, key, serializeAttribute(key, value, scopedStyleIdPrefix)), null === value && (dstLength = dstAttrs.length);
+        }
+      };
+      const recordJsxEvent = (key, value) => {
+        const eventName = getEventNameFromJsxProp(key);
+        const scope = getEventNameScopeFromJsxProp(key);
+        if (eventName && (record(":" + scope + ":" + eventName, value), registerQwikLoaderEvent(eventName)), scope) {
+          const htmlEvent = convertEventNameFromJsxPropToHtmlAttr(key);
+          htmlEvent && record(htmlEvent, "");
+        }
+      };
+      for (; null !== srcKey || null !== dstKey; ) {
+        if (dstKey?.startsWith(HANDLER_PREFIX) || dstKey?.startsWith("q:")) {
+          dstIdx++, dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
+        } else if (null == srcKey) {
+          dstKey && isHtmlAttributeAnEventName(dstKey) ? (patchEventDispatch = true, dstIdx++) : (record(dstKey, null), dstIdx--), dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
+        } else if (null == dstKey) {
+          isJsxPropertyAnEventName(srcKey) ? (patchEventDispatch = true, recordJsxEvent(srcKey, srcAttrs[srcIdx])) : record(srcKey, srcAttrs[srcIdx]), srcIdx++, srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null, dstIdx++, dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
+        } else if (srcKey == dstKey) {
+          const srcValue = srcAttrs[srcIdx++];
+          srcValue !== dstAttrs[dstIdx++] && record(dstKey, srcValue), srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null, dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
+        } else {
+          srcKey < dstKey ? (isJsxPropertyAnEventName(srcKey) ? (patchEventDispatch = true, recordJsxEvent(srcKey, srcAttrs[srcIdx])) : record(srcKey, srcAttrs[srcIdx]), srcIdx++, srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null, dstIdx++, dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null) : (isHtmlAttributeAnEventName(dstKey) ? (patchEventDispatch = true, dstIdx++) : (record(dstKey, null), dstIdx--), dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null);
+        }
+      }
+      return patchEventDispatch;
+    }(vNode, jsxAttrs, currentFile) || needsQDispatchEventPatch, needsQDispatchEventPatch) {
+      const element = vnode_getNode(vNode);
+      element.qDispatchEvent || (element.qDispatchEvent = (event, scope) => {
+        const eventName = event.type;
+        const eventProp = ":" + scope.substring(1) + ":" + eventName;
+        const qrls = [vnode_getProp(vNode, eventProp, null), vnode_getProp(vNode, HANDLER_PREFIX + eventProp, null)];
+        let returnValue = false;
+        return qrls.flat(2).forEach((qrl2) => {
+          if (qrl2) {
+            const value = container.$scheduler$(ChoreType.RUN_QRL, vNode, qrl2, [event, element]);
+            returnValue = returnValue || true === value;
+          }
+        }), returnValue;
+      });
+    }
+  }
+  function registerQwikLoaderEvent(eventName) {
+    const window2 = container.document.defaultView;
+    window2 && (window2.qwikevents || (window2.qwikevents = [])).push(eventName);
+  }
+  function retrieveChildWithKey(nodeName, key) {
+    let vNodeWithKey = null;
+    if (-1 === vSiblingsIdx) {
+      vSiblings = [], vSiblingsIdx = 0;
+      let vNode = vCurrent;
+      for (; vNode; ) {
+        const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
+        const vKey = getKey(vNode) || getComponentHash(vNode, container.$getObjectById$);
+        null === vNodeWithKey && vKey == key && name == nodeName ? vNodeWithKey = vNode : vSiblings.push(name, vKey, vNode), vNode = vnode_getNextSibling(vNode);
+      }
+    } else {
+      for (let idx = vSiblingsIdx; idx < vSiblings.length; idx += SiblingsArray.Size) {
+        if (vSiblings[idx + SiblingsArray.Key] === key && vSiblings[idx + SiblingsArray.Name] === nodeName) {
+          vNodeWithKey = vSiblings[idx + SiblingsArray.VNode], vSiblings?.splice(idx, SiblingsArray.Size);
+          break;
+        }
+      }
+    }
+    return vNodeWithKey;
+  }
+  function expectVirtual(type, jsxKey) {
+    vCurrent && vnode_isVirtualVNode(vCurrent) && getKey(vCurrent) === jsxKey || (null === jsxKey || (vNewNode = retrieveChildWithKey(null, jsxKey), null == vNewNode) ? (vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()), vnode_setProp(vNewNode, "q:key", jsxKey), isDev) : vnode_insertBefore(journal, vParent, vNewNode, vCurrent && getInsertBefore()));
+  }
+  function expectComponent(component) {
+    const componentMeta = component[SERIALIZABLE_STATE];
+    let host = vNewNode || vCurrent;
+    const jsxNode2 = jsxValue;
+    if (componentMeta) {
+      const jsxProps = jsxNode2.props;
+      let shouldRender = false;
+      const [componentQRL] = componentMeta;
+      const componentHash = componentQRL.$hash$;
+      const vNodeComponentHash = getComponentHash(host, container.$getObjectById$);
+      const lookupKey = jsxNode2.key || componentHash;
+      if (lookupKey === (getKey(host) || vNodeComponentHash) ? componentHash === vNodeComponentHash || (insertNewComponent(host, componentQRL, jsxProps), vNewNode && (host = vNewNode, shouldRender = true)) : (vNewNode = retrieveChildWithKey(null, lookupKey), vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : insertNewComponent(host, componentQRL, jsxProps), host = vNewNode, shouldRender = true), host) {
+        const vNodeProps = vnode_getProp(host, "q:props", container.$getObjectById$);
+        shouldRender = shouldRender || propsDiffer(jsxProps, vNodeProps), shouldRender && (host[VNodeProps.flags] &= ~VNodeFlags.Deleted, container.$scheduler$(ChoreType.COMPONENT, host, componentQRL, jsxProps));
+      }
+      !function(children, host2) {
+        const projectionChildren = Array.isArray(children) ? children : [children];
+        const createProjectionJSXNode = (slotName) => new JSXNodeImpl(Projection, EMPTY_OBJ, null, [], 0, slotName);
+        const projections = [];
+        if (host2) {
+          const props = vnode_getProps(host2);
+          for (let i = 0; i < props.length; i += 2) {
+            const prop = props[i];
+            if (isSlotProp(prop)) {
+              const slotName = prop;
+              projections.push(slotName), projections.push(createProjectionJSXNode(slotName));
+            }
+          }
+        }
+        if (0 !== projections.length || null != children) {
+          for (let i = 0; i < projectionChildren.length; i++) {
+            const child = projectionChildren[i];
+            const slotName = String(isJSXNode(child) && directGetPropsProxyProp(child, QSlot) || "");
+            const idx = mapApp_findIndx(projections, slotName, 0);
+            let jsxBucket;
+            idx >= 0 ? jsxBucket = projections[idx + 1] : projections.splice(~idx, 0, slotName, jsxBucket = createProjectionJSXNode(slotName)), false === child || jsxBucket.children.push(child);
+          }
+          for (let i = projections.length - 2; i >= 0; i -= 2) {
+            projections.splice(i, 1);
+          }
+          descend(projections, true);
+        }
+      }(jsxNode2.children, host);
+    } else {
+      const lookupKey = jsxNode2.key;
+      if (lookupKey === getKey(host) || (vNewNode = retrieveChildWithKey(null, lookupKey), vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : function() {
+        vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
+        const jsxNode3 = jsxValue;
+        vnode_setProp(vNewNode, "q:props", jsxNode3.props), jsxNode3.key && vnode_setProp(vNewNode, "q:key", jsxNode3.key);
+      }(), host = vNewNode), host) {
+        let componentHost = host;
+        for (; componentHost && (!vnode_isVirtualVNode(componentHost) || null === vnode_getProp(componentHost, "q:renderFn", null)); ) {
+          componentHost = vnode_getParent(componentHost);
+        }
+        const jsxOutput = executeComponent(container, host, componentHost || container.rootVNode, component, jsxNode2.props);
+        asyncQueue.push(jsxOutput, host);
+      }
+    }
+  }
+  function insertNewComponent(host, componentQRL, jsxProps) {
+    host && clearAllEffects(container, host), vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
+    const jsxNode2 = jsxValue;
+    container.setHostProp(vNewNode, "q:renderFn", componentQRL), container.setHostProp(vNewNode, "q:props", jsxProps), container.setHostProp(vNewNode, "q:key", jsxNode2.key);
+  }
+  function expectText(text) {
+    if (null !== vCurrent) {
+      if (3 === vnode_getType(vCurrent)) {
+        return text !== vnode_getText(vCurrent) ? void vnode_setText(journal, vCurrent, text) : void 0;
+      }
+    }
+    vnode_insertBefore(journal, vParent, vNewNode = vnode_newText(container.document.createTextNode(text), text), vCurrent);
+  }
+};
+function getKey(vNode) {
+  return null == vNode ? null : vnode_getProp(vNode, "q:key", null);
+}
+function getComponentHash(vNode, getObject) {
+  if (null == vNode) {
+    return null;
+  }
+  const qrl2 = vnode_getProp(vNode, "q:renderFn", getObject);
+  return qrl2 ? qrl2.$hash$ : null;
+}
+function Projection() {
+}
+function propsDiffer(src, dst) {
+  if (!src || !dst) {
+    return true;
+  }
+  let srcKeys = removePropsKeys(Object.keys(src), ["children", "q:brefs"]);
+  let dstKeys = removePropsKeys(Object.keys(dst), ["children", "q:brefs"]);
+  if (srcKeys.length !== dstKeys.length) {
+    return true;
+  }
+  srcKeys = srcKeys.sort(), dstKeys = dstKeys.sort();
+  for (let idx = 0; idx < srcKeys.length; idx++) {
+    const srcKey = srcKeys[idx];
+    const dstKey = dstKeys[idx];
+    if (srcKey !== dstKey || src[srcKey] !== dst[dstKey]) {
+      return true;
+    }
+  }
+  return false;
+}
+function removePropsKeys(keys, propKeys) {
+  for (let i = propKeys.length - 1; i >= 0; i--) {
+    const propIdx = keys.indexOf(propKeys[i]);
+    -1 !== propIdx && keys.splice(propIdx, 1);
+  }
+  return keys;
+}
+function cleanup(container, vNode) {
+  let vCursor = vNode;
+  if (vnode_isTextVNode(vNode)) {
+    return;
+  }
+  let vParent = null;
+  for (; ; ) {
+    const type = vCursor[VNodeProps.flags];
+    if (type & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
+      if (clearAllEffects(container, vCursor), markVNodeAsDeleted(vCursor), type & VNodeFlags.Virtual) {
+        const seq = container.getHostProp(vCursor, "q:seq");
+        if (seq) {
+          for (let i = 0; i < seq.length; i++) {
+            const obj = seq[i];
+            if (isTask(obj)) {
+              const task = obj;
+              clearAllEffects(container, task), task.$flags$ & TaskFlags.VISIBLE_TASK ? container.$scheduler$(ChoreType.CLEANUP_VISIBLE, task) : cleanupTask(task);
+            }
+          }
+        }
+      }
+      if (type & VNodeFlags.Virtual && null !== vnode_getProp(vCursor, "q:renderFn", null)) {
+        const attrs = vnode_getProps(vCursor);
+        for (let i = 0; i < attrs.length; i += 2) {
+          const key = attrs[i];
+          if (!isParentSlotProp(key) && isSlotProp(key)) {
+            const value = attrs[i + 1];
+            if (value) {
+              attrs[i + 1] = null;
+              const projection = "string" == typeof value ? vnode_locate(container.rootVNode, value) : value;
+              let projectionChild = vnode_getFirstChild(projection);
+              for (; projectionChild; ) {
+                cleanup(container, projectionChild), projectionChild = vnode_getNextSibling(projectionChild);
+              }
+              cleanupStaleUnclaimedProjection(container.$journal$, projection);
+            }
+          }
+        }
+      }
+      if (type & VNodeFlags.Virtual && null !== vnode_getProp(vCursor, QSlot, null)) {
+        if (vCursor === vNode) {
+          const vFirstChild = vnode_getFirstChild(vCursor);
+          if (vFirstChild) {
+            return void vnode_walkVNode(vFirstChild);
+          }
+        }
+      } else {
+        const vFirstChild = vnode_getFirstChild(vCursor);
+        if (vFirstChild) {
+          vCursor = vFirstChild;
+          continue;
+        }
+      }
+    }
+    if (vCursor === vNode) {
+      return;
+    }
+    const vNextSibling = vnode_getNextSibling(vCursor);
+    if (vNextSibling) {
+      vCursor = vNextSibling;
+    } else {
+      for (vParent = vnode_getParent(vCursor); vParent; ) {
+        if (vParent === vNode) {
+          return;
+        }
+        const vNextParentSibling = vnode_getNextSibling(vParent);
+        if (vNextParentSibling) {
+          vCursor = vNextParentSibling;
+          break;
+        }
+        vParent = vnode_getParent(vParent);
+      }
+      if (null == vParent) {
+        return;
+      }
+    }
   }
 }
-function isSubscriber(value) {
-  return value instanceof Subscriber || value instanceof WrappedSignal;
+function cleanupStaleUnclaimedProjection(journal, projection) {
+  const projectionParent = vnode_getParent(projection);
+  if (projectionParent) {
+    projectionParent[VNodeProps.flags] & VNodeFlags.Element && vnode_getElementName(projectionParent) === QTemplate && vnode_remove(journal, projectionParent, projection, true);
+  }
 }
-var VNodeFlags;
-var VNodeFlagsIndex;
-var VNodeProps;
-var ElementVNodeProps;
-var TextVNodeProps;
-var VirtualVNodeProps;
-!function(VNodeFlags2) {
-  VNodeFlags2[VNodeFlags2.Element = 1] = "Element", VNodeFlags2[VNodeFlags2.Virtual = 2] = "Virtual", VNodeFlags2[VNodeFlags2.ELEMENT_OR_VIRTUAL_MASK = 3] = "ELEMENT_OR_VIRTUAL_MASK", VNodeFlags2[VNodeFlags2.ELEMENT_OR_TEXT_MASK = 5] = "ELEMENT_OR_TEXT_MASK", VNodeFlags2[VNodeFlags2.TYPE_MASK = 7] = "TYPE_MASK", VNodeFlags2[VNodeFlags2.INFLATED_TYPE_MASK = 15] = "INFLATED_TYPE_MASK", VNodeFlags2[VNodeFlags2.Text = 4] = "Text", VNodeFlags2[VNodeFlags2.Inflated = 8] = "Inflated", VNodeFlags2[VNodeFlags2.Resolved = 16] = "Resolved", VNodeFlags2[VNodeFlags2.Deleted = 32] = "Deleted", VNodeFlags2[VNodeFlags2.NAMESPACE_MASK = 192] = "NAMESPACE_MASK", VNodeFlags2[VNodeFlags2.NEGATED_NAMESPACE_MASK = -193] = "NEGATED_NAMESPACE_MASK", VNodeFlags2[VNodeFlags2.NS_html = 0] = "NS_html", VNodeFlags2[VNodeFlags2.NS_svg = 64] = "NS_svg", VNodeFlags2[VNodeFlags2.NS_math = 128] = "NS_math";
-}(VNodeFlags || (VNodeFlags = {})), function(VNodeFlagsIndex2) {
-  VNodeFlagsIndex2[VNodeFlagsIndex2.mask = -256] = "mask", VNodeFlagsIndex2[VNodeFlagsIndex2.negated_mask = 255] = "negated_mask", VNodeFlagsIndex2[VNodeFlagsIndex2.shift = 8] = "shift";
-}(VNodeFlagsIndex || (VNodeFlagsIndex = {})), function(VNodeProps2) {
-  VNodeProps2[VNodeProps2.flags = 0] = "flags", VNodeProps2[VNodeProps2.parent = 1] = "parent", VNodeProps2[VNodeProps2.previousSibling = 2] = "previousSibling", VNodeProps2[VNodeProps2.nextSibling = 3] = "nextSibling";
-}(VNodeProps || (VNodeProps = {})), function(ElementVNodeProps2) {
-  ElementVNodeProps2[ElementVNodeProps2.firstChild = 4] = "firstChild", ElementVNodeProps2[ElementVNodeProps2.lastChild = 5] = "lastChild", ElementVNodeProps2[ElementVNodeProps2.element = 6] = "element", ElementVNodeProps2[ElementVNodeProps2.elementName = 7] = "elementName", ElementVNodeProps2[ElementVNodeProps2.PROPS_OFFSET = 8] = "PROPS_OFFSET";
-}(ElementVNodeProps || (ElementVNodeProps = {})), function(TextVNodeProps2) {
-  TextVNodeProps2[TextVNodeProps2.node = 4] = "node", TextVNodeProps2[TextVNodeProps2.text = 5] = "text";
-}(TextVNodeProps || (TextVNodeProps = {})), function(VirtualVNodeProps2) {
-  VirtualVNodeProps2[VirtualVNodeProps2.firstChild = 4] = "firstChild", VirtualVNodeProps2[VirtualVNodeProps2.lastChild = 5] = "lastChild", VirtualVNodeProps2[VirtualVNodeProps2.PROPS_OFFSET = 6] = "PROPS_OFFSET";
-}(VirtualVNodeProps || (VirtualVNodeProps = {}));
+function markVNodeAsDeleted(vCursor) {
+  vCursor[VNodeProps.flags] |= VNodeFlags.Deleted;
+}
+const HANDLER_PREFIX = ":";
 var SiblingsArray;
 !function(SiblingsArray2) {
   SiblingsArray2[SiblingsArray2.Name = 0] = "Name", SiblingsArray2[SiblingsArray2.Key = 1] = "Key", SiblingsArray2[SiblingsArray2.VNode = 2] = "VNode", SiblingsArray2[SiblingsArray2.Size = 3] = "Size", SiblingsArray2[SiblingsArray2.NextVNode = 5] = "NextVNode";
 }(SiblingsArray || (SiblingsArray = {}));
-var ChoreType;
-!function(ChoreType2) {
-  ChoreType2[ChoreType2.MACRO = 240] = "MACRO", ChoreType2[ChoreType2.MICRO = 15] = "MICRO", ChoreType2[ChoreType2.QRL_RESOLVE = 1] = "QRL_RESOLVE", ChoreType2[ChoreType2.RESOURCE = 2] = "RESOURCE", ChoreType2[ChoreType2.TASK = 3] = "TASK", ChoreType2[ChoreType2.NODE_DIFF = 4] = "NODE_DIFF", ChoreType2[ChoreType2.NODE_PROP = 5] = "NODE_PROP", ChoreType2[ChoreType2.COMPONENT_SSR = 6] = "COMPONENT_SSR", ChoreType2[ChoreType2.COMPONENT = 7] = "COMPONENT", ChoreType2[ChoreType2.RECOMPUTE_AND_SCHEDULE_EFFECTS = 8] = "RECOMPUTE_AND_SCHEDULE_EFFECTS", ChoreType2[ChoreType2.JOURNAL_FLUSH = 16] = "JOURNAL_FLUSH", ChoreType2[ChoreType2.VISIBLE = 32] = "VISIBLE", ChoreType2[ChoreType2.CLEANUP_VISIBLE = 48] = "CLEANUP_VISIBLE", ChoreType2[ChoreType2.WAIT_FOR_ALL = 255] = "WAIT_FOR_ALL";
-}(ChoreType || (ChoreType = {}));
-var TaskFlags;
-!function(TaskFlags2) {
-  TaskFlags2[TaskFlags2.VISIBLE_TASK = 1] = "VISIBLE_TASK", TaskFlags2[TaskFlags2.TASK = 2] = "TASK", TaskFlags2[TaskFlags2.RESOURCE = 4] = "RESOURCE", TaskFlags2[TaskFlags2.DIRTY = 8] = "DIRTY";
-}(TaskFlags || (TaskFlags = {}));
-class Task extends Subscriber {
-  constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
-    super();
-    __publicField(this, "$flags$");
-    __publicField(this, "$index$");
-    __publicField(this, "$el$");
-    __publicField(this, "$qrl$");
-    __publicField(this, "$state$");
-    __publicField(this, "$destroy$");
-    this.$flags$ = $flags$, this.$index$ = $index$, this.$el$ = $el$, this.$qrl$ = $qrl$, this.$state$ = $state$, this.$destroy$ = $destroy$;
+const _createResourceReturn = (opts) => ({
+  __brand: "resource",
+  value: void 0,
+  loading: !isServerPlatform(),
+  _resolved: void 0,
+  _error: void 0,
+  _state: "pending",
+  _timeout: -1,
+  _cache: 0
+});
+const createResourceReturn = (container, opts, initialPromise) => {
+  const result = _createResourceReturn();
+  return result.value = initialPromise, createStore(container, result, StoreFlags.RECURSIVE);
+};
+const runResource = (task, container, host) => {
+  task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
+  const iCtx = newInvokeContext(container.$locale$, host, void 0, "qResource");
+  iCtx.$container$ = container;
+  const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
+  const resource = task.$state$;
+  const cleanups = [];
+  task.$destroy$ = noSerialize(() => {
+    cleanups.forEach((fn) => {
+      try {
+        fn();
+      } catch (err) {
+        container.handleError(err, host);
+      }
+    }), done = true;
+  });
+  const resourceTarget = unwrapStore(resource);
+  const opts = {
+    track: (obj, prop) => {
+      const ctx = newInvokeContext();
+      return ctx.$effectSubscriber$ = getSubscriber(task, EffectProperty.COMPONENT), ctx.$container$ = container, invoke(ctx, () => isFunction(obj) ? obj() : prop ? obj[prop] : isSignal(obj) ? obj.value : obj);
+    },
+    cleanup(fn) {
+      "function" == typeof fn && cleanups.push(fn);
+    },
+    cache(policy) {
+      let milliseconds = 0;
+      milliseconds = "immutable" === policy ? 1 / 0 : policy, resource._cache = milliseconds;
+    },
+    previous: resourceTarget._resolved
+  };
+  let resolve;
+  let reject;
+  let done = false;
+  const setState = (resolved, value) => !done && (done = true, resolved ? (done = true, resource.loading = false, resource._state = "resolved", resource._resolved = value, resource._error = void 0, resolve(value)) : (done = true, resource.loading = false, resource._state = "rejected", resource._error = value, reject(value)), true);
+  cleanups.push(() => {
+    if (true === untrack(() => resource.loading)) {
+      const value = untrack(() => resource._resolved);
+      setState(true, value);
+    }
+  }), invoke(iCtx, () => {
+    resource._state = "pending", resource.loading = !isServerPlatform();
+    (resource.value = new Promise((r, re) => {
+      resolve = r, reject = re;
+    })).catch(ignoreErrorToPreventNodeFromCrashing);
+  });
+  const promise = safeCall(() => Promise.resolve(taskFn(opts)), (value) => {
+    setState(true, value);
+  }, (err) => {
+    if (isPromise(err)) {
+      return err.then(() => runResource(task, container, host));
+    }
+    setState(false, err);
+  });
+  const timeout = resourceTarget._timeout;
+  return timeout > 0 ? Promise.race([promise, delay(timeout).then(() => {
+    setState(false, new Error("timeout")) && cleanupTask(task);
+  })]) : promise;
+};
+const ignoreErrorToPreventNodeFromCrashing = () => {
+};
+const aVNodePath = [];
+const bVNodePath = [];
+const vnode_documentPosition = (a2, b, rootVNode) => {
+  if (a2 === b) {
+    return 0;
+  }
+  let aDepth = -1;
+  let bDepth = -1;
+  for (; a2; ) {
+    a2 = (aVNodePath[++aDepth] = a2)[VNodeProps.parent] || rootVNode && vnode_getProp(a2, ":", (id) => vnode_locate(rootVNode, id));
+  }
+  for (; b; ) {
+    b = (bVNodePath[++bDepth] = b)[VNodeProps.parent] || rootVNode && vnode_getProp(b, ":", (id) => vnode_locate(rootVNode, id));
+  }
+  for (; aDepth >= 0 && bDepth >= 0; ) {
+    if ((a2 = aVNodePath[aDepth]) !== (b = bVNodePath[bDepth])) {
+      let cursor = b;
+      do {
+        if (cursor = vnode_getNextSibling(cursor), cursor === a2) {
+          return 1;
+        }
+      } while (cursor);
+      cursor = b;
+      do {
+        if (cursor = vnode_getPreviousSibling(cursor), cursor === a2) {
+          return -1;
+        }
+      } while (cursor);
+      return rootVNode && vnode_getProp(b, ":", (id) => vnode_locate(rootVNode, id)) ? -1 : 1;
+    }
+    aDepth--, bDepth--;
+  }
+  return aDepth < bDepth ? -1 : 1;
+};
+const aSsrNodePath = [];
+const bSsrNodePath = [];
+const ssrNodeDocumentPosition = (a2, b) => {
+  if (a2 === b) {
+    return 0;
+  }
+  let aDepth = -1;
+  let bDepth = -1;
+  for (; a2; ) {
+    a2 = (aSsrNodePath[++aDepth] = a2).currentComponentNode;
+  }
+  for (; b; ) {
+    b = (bSsrNodePath[++bDepth] = b).currentComponentNode;
+  }
+  for (; aDepth >= 0 && bDepth >= 0; ) {
+    if ((a2 = aSsrNodePath[aDepth]) !== (b = bSsrNodePath[bDepth])) {
+      return 1;
+    }
+    aDepth--, bDepth--;
+  }
+  return aDepth < bDepth ? -1 : 1;
+};
+const getPromise = (chore) => chore.$promise$ || (chore.$promise$ = new Promise((resolve) => {
+  chore.$resolve$ = resolve;
+}));
+const createScheduler = (container, scheduleDrain, journalFlush) => {
+  const choreQueue = [];
+  const qrlRuns = [];
+  let currentChore = null;
+  let drainScheduled = false;
+  return function schedule(type, hostOrTask = null, targetOrQrl = null, payload = null) {
+    const isServer3 = !isDomContainer(container);
+    const isComponentSsr = isServer3 && type === ChoreType.COMPONENT;
+    const runLater = type !== ChoreType.WAIT_FOR_ALL && !isComponentSsr && type !== ChoreType.RUN_QRL;
+    const isTask2 = type === ChoreType.TASK || type === ChoreType.VISIBLE || type === ChoreType.CLEANUP_VISIBLE;
+    const isClientOnly = type === ChoreType.JOURNAL_FLUSH || type === ChoreType.NODE_DIFF || type === ChoreType.NODE_PROP;
+    if (isServer3 && isClientOnly) {
+      return;
+    }
+    isTask2 && (hostOrTask.$flags$ |= TaskFlags.DIRTY);
+    let chore = {
+      $type$: type,
+      $idx$: isTask2 ? hostOrTask.$index$ : "string" == typeof targetOrQrl ? targetOrQrl : 0,
+      $host$: isTask2 ? hostOrTask.$el$ : hostOrTask,
+      $target$: targetOrQrl,
+      $payload$: isTask2 ? hostOrTask : payload,
+      $resolve$: null,
+      $promise$: null,
+      $returnValue$: null,
+      $executed$: false
+    };
+    chore = function(sortedArray, value, rootVNode) {
+      const idx = function(sortedArray2, value2, rootVNode2) {
+        let bottom = 0;
+        let top = sortedArray2.length;
+        for (; bottom < top; ) {
+          const middle = bottom + (top - bottom >> 1);
+          const comp = choreComparator(value2, sortedArray2[middle], rootVNode2);
+          if (comp < 0) {
+            top = middle;
+          } else {
+            if (!(comp > 0)) {
+              return middle;
+            }
+            bottom = middle + 1;
+          }
+        }
+        return ~bottom;
+      }(sortedArray, value, rootVNode);
+      if (idx < 0) {
+        return sortedArray.splice(~idx, 0, value), value;
+      }
+      const existing = sortedArray[idx];
+      existing.$type$ === ChoreType.NODE_DIFF && (existing.$payload$ = value.$payload$);
+      existing.$executed$ && (existing.$executed$ = false);
+      return existing;
+    }(choreQueue, chore, container.rootVNode || null), !drainScheduled && runLater && (drainScheduled = true, schedule(ChoreType.JOURNAL_FLUSH), scheduleDrain()?.catch?.(() => {
+    }));
+    return runLater ? getPromise(chore) : drainUpTo(chore, isServer3);
+  };
+  function drainUpTo(runUptoChore, isServer3) {
+    let maxRetries = 5e3;
+    for (; choreQueue.length; ) {
+      if (maxRetries-- < 0) {
+        throw new Error("drainUpTo: max retries reached");
+      }
+      if (currentChore) {
+        return getPromise(currentChore).then(() => drainUpTo(runUptoChore, isServer3)).catch((e) => {
+          container.handleError(e, currentChore?.$host$);
+        });
+      }
+      const nextChore = choreQueue[0];
+      if (nextChore.$executed$) {
+        if (choreQueue.shift(), nextChore === runUptoChore) {
+          break;
+        }
+      } else {
+        vNodeAlreadyDeleted(nextChore) && nextChore.$type$ !== ChoreType.CLEANUP_VISIBLE ? choreQueue.shift() : executeChore(nextChore, isServer3);
+      }
+    }
+    return runUptoChore.$returnValue$;
+  }
+  function executeChore(chore, isServer3) {
+    const host = chore.$host$;
+    currentChore = chore;
+    let returnValue = null;
+    try {
+      switch (chore.$type$) {
+        case ChoreType.WAIT_FOR_ALL:
+          isServer3 && (drainScheduled = false);
+          break;
+        case ChoreType.JOURNAL_FLUSH:
+          returnValue = journalFlush(), drainScheduled = false;
+          break;
+        case ChoreType.COMPONENT:
+          returnValue = safeCall(() => executeComponent(container, host, host, chore.$target$, chore.$payload$), (jsx2) => {
+            if (isServer3) {
+              return jsx2;
+            }
+            {
+              const styleScopedId = container.getHostProp(host, "q:sstyle");
+              return retryOnPromise(() => vnode_diff(container, jsx2, host, addComponentStylePrefix(styleScopedId)));
+            }
+          }, (err) => container.handleError(err, host));
+          break;
+        case ChoreType.RUN_QRL:
+          {
+            const fn = chore.$target$.getFn();
+            const result = retryOnPromise(() => fn(...chore.$payload$));
+            if (isPromise(result)) {
+              const handled = result.finally(() => {
+                qrlRuns.splice(qrlRuns.indexOf(handled), 1);
+              }).catch((error) => {
+                container.handleError(error, chore.$host$);
+              });
+              return qrlRuns.push(handled), chore.$returnValue$ = handled, chore.$resolve$?.(handled), currentChore = null, void (chore.$executed$ = true);
+            }
+            returnValue = null;
+          }
+          break;
+        case ChoreType.TASK:
+        case ChoreType.VISIBLE:
+          {
+            const payload = chore.$payload$;
+            if (payload.$flags$ & TaskFlags.RESOURCE) {
+              const result = runResource(payload, container, host);
+              returnValue = isServer3 ? result : null;
+            } else {
+              returnValue = runTask(payload, container, host);
+            }
+          }
+          break;
+        case ChoreType.CLEANUP_VISIBLE:
+          cleanupTask(chore.$payload$);
+          break;
+        case ChoreType.NODE_DIFF:
+          {
+            const parentVirtualNode = chore.$target$;
+            let jsx2 = chore.$payload$;
+            isSignal(jsx2) && (jsx2 = jsx2.value), returnValue = retryOnPromise(() => vnode_diff(container, jsx2, parentVirtualNode, null));
+          }
+          break;
+        case ChoreType.NODE_PROP:
+          {
+            const virtualNode = chore.$host$;
+            const payload = chore.$payload$;
+            let value = payload.$value$;
+            isSignal(value) && (value = value.value);
+            const isConst = payload.$isConst$;
+            const journal = container.$journal$;
+            const property = chore.$idx$;
+            const serializedValue = serializeAttribute(property, value, payload.$scopedStyleIdPrefix$);
+            if (isConst) {
+              journal.push(VNodeJournalOpCode.SetAttribute, virtualNode[ElementVNodeProps.element], property, serializedValue);
+            } else {
+              vnode_setAttr(journal, virtualNode, property, serializedValue);
+            }
+          }
+          break;
+        case ChoreType.QRL_RESOLVE:
+          {
+            const target = chore.$target$;
+            returnValue = target.resolved ? null : target.resolve();
+          }
+          break;
+        case ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS: {
+          const target = chore.$target$;
+          const forceRunEffects = target.$forceRunEffects$;
+          if (target.$forceRunEffects$ = false, !target.$effects$?.size) {
+            break;
+          }
+          returnValue = retryOnPromise(() => {
+            (target.$computeIfNeeded$() || forceRunEffects) && triggerEffects(container, target, target.$effects$);
+          });
+        }
+      }
+    } catch (e) {
+      returnValue = Promise.reject(e);
+    }
+    const after = (value, error) => {
+      currentChore = null, chore.$executed$ = true, error ? container.handleError(error, host) : (chore.$returnValue$ = value, chore.$resolve$?.(value));
+    };
+    isPromise(returnValue) ? (chore.$promise$ = returnValue.then(after, (error) => after(void 0, error)), chore.$resolve$?.(chore.$promise$), chore.$resolve$ = void 0) : after(returnValue);
+  }
+  function choreComparator(a2, b, rootVNode) {
+    const macroTypeDiff = (a2.$type$ & ChoreType.MACRO) - (b.$type$ & ChoreType.MACRO);
+    if (0 !== macroTypeDiff) {
+      return macroTypeDiff;
+    }
+    const aHost = a2.$host$;
+    const bHost = b.$host$;
+    if (aHost !== bHost && null !== aHost && null !== bHost) {
+      if (vnode_isVNode(aHost) && vnode_isVNode(bHost)) {
+        const hostDiff = vnode_documentPosition(aHost, bHost, rootVNode);
+        if (0 !== hostDiff) {
+          return hostDiff;
+        }
+      } else {
+        `SERVER: during HTML streaming, re-running tasks on a different host is not allowed.
+          You are attempting to change a state that has already been streamed to the client.
+          This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).
+          Problematic Node: ${aHost.toString()}`;
+        const hostDiff = ssrNodeDocumentPosition(aHost, bHost);
+        if (0 !== hostDiff) {
+          return hostDiff;
+        }
+      }
+    }
+    const microTypeDiff = (a2.$type$ & ChoreType.MICRO) - (b.$type$ & ChoreType.MICRO);
+    if (0 !== microTypeDiff) {
+      return microTypeDiff;
+    }
+    const idxDiff = toNumber(a2.$idx$) - toNumber(b.$idx$);
+    return 0 !== idxDiff ? idxDiff : a2.$target$ !== b.$target$ || a2.$payload$ !== b.$payload$ || b === currentChore ? 1 : 0;
   }
+};
+const toNumber = (value) => "number" == typeof value ? value : -1;
+function vNodeAlreadyDeleted(chore) {
+  return !!(chore.$host$ && vnode_isVNode(chore.$host$) && chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted);
 }
-const isTask = (value) => value instanceof Task;
-const NEEDS_COMPUTATION = Symbol("invalid");
 const throwIfQRLNotResolved = (qrl2) => {
   if (!qrl2.resolved) {
     throw qrl2.resolve();
   }
 };
 const isSignal = (value) => value instanceof Signal;
-class EffectPropData {
+class SubscriptionData {
   constructor(data) {
     __publicField(this, "data");
     this.data = data;
   }
 }
-var EffectSubscriptionsProp;
+var EffectSubscriptionProp;
 var EffectProperty;
-!function(EffectSubscriptionsProp2) {
-  EffectSubscriptionsProp2[EffectSubscriptionsProp2.EFFECT = 0] = "EFFECT", EffectSubscriptionsProp2[EffectSubscriptionsProp2.PROPERTY = 1] = "PROPERTY", EffectSubscriptionsProp2[EffectSubscriptionsProp2.FIRST_BACK_REF_OR_DATA = 2] = "FIRST_BACK_REF_OR_DATA";
-}(EffectSubscriptionsProp || (EffectSubscriptionsProp = {})), function(EffectProperty2) {
+!function(EffectSubscriptionProp2) {
+  EffectSubscriptionProp2[EffectSubscriptionProp2.CONSUMER = 0] = "CONSUMER", EffectSubscriptionProp2[EffectSubscriptionProp2.PROPERTY = 1] = "PROPERTY", EffectSubscriptionProp2[EffectSubscriptionProp2.BACK_REF = 2] = "BACK_REF", EffectSubscriptionProp2[EffectSubscriptionProp2.DATA = 3] = "DATA";
+}(EffectSubscriptionProp || (EffectSubscriptionProp = {})), function(EffectProperty2) {
   EffectProperty2.COMPONENT = ":", EffectProperty2.VNODE = ".";
 }(EffectProperty || (EffectProperty = {}));
 class Signal {
@@ -163,8 +1763,8 @@ class Signal {
       }
       const effectSubscriber = ctx.$effectSubscriber$;
       if (effectSubscriber) {
-        const effects = this.$effects$ || (this.$effects$ = []);
-        ensureContainsEffect(effects, effectSubscriber), ensureContains(effectSubscriber, this), isSubscriber(this) && ensureEffectContainsSubscriber(effectSubscriber[EffectSubscriptionsProp.EFFECT], this, this.$container$);
+        const effects = this.$effects$ || (this.$effects$ = /* @__PURE__ */ new Set());
+        ensureContainsSubscription(effects, effectSubscriber), ensureContainsBackRef(effectSubscriber, this), addQrlToSerializationCtx(effectSubscriber, this.$container$);
       }
     }
     return this.untrackedValue;
@@ -175,7 +1775,7 @@ class Signal {
   valueOf() {
   }
   toString() {
-    return `[${this.constructor.name}${this.$invalid$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (this.$effects$?.map((e) => "\n -> " + pad(qwikDebugToString(e[0]), "    ")).join("\n") || "");
+    return `[${this.constructor.name}${this.$invalid$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map((e) => "\n -> " + pad(qwikDebugToString(e[0]), "    ")).join("\n") || "");
   }
   toJSON() {
     return {
@@ -183,77 +1783,56 @@ class Signal {
     };
   }
 }
-const ensureContains = (array, value) => {
-  -1 === array.indexOf(value) && array.push(value);
-};
-const ensureContainsEffect = (array, effectSubscriptions) => {
-  for (let i = 0; i < array.length; i++) {
-    const existingEffect = array[i];
-    if (existingEffect[0] === effectSubscriptions[0] && existingEffect[1] === effectSubscriptions[1]) {
-      return;
-    }
-  }
-  array.push(effectSubscriptions);
+const ensureContainsSubscription = (array, effectSubscription) => {
+  array.add(effectSubscription);
 };
-const ensureEffectContainsSubscriber = (effect, subscriber, container) => {
-  if (isSubscriber(effect)) {
-    if (effect.$effectDependencies$ || (effect.$effectDependencies$ = []), subscriberExistInSubscribers(effect.$effectDependencies$, subscriber)) {
-      return;
-    }
-    effect.$effectDependencies$.push(subscriber);
-  } else if (vnode_isVNode(effect) && !vnode_isTextVNode(effect)) {
-    let subscribers = vnode_getProp(effect, "q:subs", container ? container.$getObjectById$ : null);
-    if (subscribers || (subscribers = []), subscriberExistInSubscribers(subscribers, subscriber)) {
-      return;
-    }
-    subscribers.push(subscriber), vnode_setProp(effect, "q:subs", subscribers);
-  } else if (isSSRNode(effect)) {
-    let subscribers = effect.getProp("q:subs");
-    if (subscribers || (subscribers = []), subscriberExistInSubscribers(subscribers, subscriber)) {
-      return;
-    }
-    subscribers.push(subscriber), effect.setProp("q:subs", subscribers);
-  }
+const ensureContainsBackRef = (array, value) => {
+  var _a2;
+  array[_a2 = EffectSubscriptionProp.BACK_REF] || (array[_a2] = /* @__PURE__ */ new Set()), array[EffectSubscriptionProp.BACK_REF].add(value);
 };
-const isSSRNode = (effect) => "setProp" in effect && "getProp" in effect && "removeProp" in effect && "id" in effect;
-const subscriberExistInSubscribers = (subscribers, subscriber) => {
-  for (let i = 0; i < subscribers.length; i++) {
-    if (subscribers[i] === subscriber) {
-      return true;
-    }
+const addQrlToSerializationCtx = (effectSubscriber, container) => {
+  if (container && !isDomContainer(container)) {
+    const effect = effectSubscriber[EffectSubscriptionProp.CONSUMER];
+    const property = effectSubscriber[EffectSubscriptionProp.PROPERTY];
+    let qrl2 = null;
+    isTask(effect) ? qrl2 = effect.$qrl$ : effect instanceof ComputedSignal ? qrl2 = effect.$computeQrl$ : property === EffectProperty.COMPONENT && (qrl2 = container.getHostProp(effect, "q:renderFn")), qrl2 && container.serializationCtx.$eventQrls$.add(qrl2);
   }
-  return false;
 };
 const triggerEffects = (container, signal, effects) => {
+  const isBrowser2 = isDomContainer(container);
   if (effects) {
-    const scheduleEffect = (effectSubscriptions) => {
-      const effect = effectSubscriptions[EffectSubscriptionsProp.EFFECT];
-      const property = effectSubscriptions[EffectSubscriptionsProp.PROPERTY];
-      if (isTask(effect)) {
-        effect.$flags$ |= TaskFlags.DIRTY;
+    const scheduleEffect = (effectSubscription) => {
+      const consumer = effectSubscription[EffectSubscriptionProp.CONSUMER];
+      const property = effectSubscription[EffectSubscriptionProp.PROPERTY];
+      if (isTask(consumer)) {
+        consumer.$flags$ |= TaskFlags.DIRTY;
         let choreType = ChoreType.TASK;
-        effect.$flags$ & TaskFlags.VISIBLE_TASK ? choreType = ChoreType.VISIBLE : effect.$flags$ & TaskFlags.RESOURCE && (choreType = ChoreType.RESOURCE), container.$scheduler$(choreType, effect);
-      } else if (effect instanceof Signal) {
-        effect instanceof ComputedSignal && (effect.$computeQrl$.resolved || container.$scheduler$(ChoreType.QRL_RESOLVE, null, effect.$computeQrl$)), effect.$invalidate$();
+        consumer.$flags$ & TaskFlags.VISIBLE_TASK && (choreType = ChoreType.VISIBLE), container.$scheduler$(choreType, consumer);
+      } else if (consumer instanceof Signal) {
+        consumer instanceof ComputedSignal && (consumer.$computeQrl$.resolved || container.$scheduler$(ChoreType.QRL_RESOLVE, null, consumer.$computeQrl$)), consumer.$invalidate$();
       } else if (property === EffectProperty.COMPONENT) {
-        const host = effect;
+        const host = consumer;
         const qrl2 = container.getHostProp(host, "q:renderFn");
         const props = container.getHostProp(host, "q:props");
         container.$scheduler$(ChoreType.COMPONENT, host, qrl2, props);
-      } else if (property === EffectProperty.VNODE) {
-        container.$scheduler$(ChoreType.NODE_DIFF, effect, effect, signal);
-      } else {
-        const effectData = effectSubscriptions[EffectSubscriptionsProp.FIRST_BACK_REF_OR_DATA];
-        if (effectData instanceof EffectPropData) {
-          const payload = {
-            ...effectData.data,
-            $value$: signal
-          };
-          container.$scheduler$(ChoreType.NODE_PROP, effect, property, payload);
+      } else if (isBrowser2) {
+        if (property === EffectProperty.VNODE) {
+          container.$scheduler$(ChoreType.NODE_DIFF, consumer, consumer, signal);
+        } else {
+          const effectData = effectSubscription[EffectSubscriptionProp.DATA];
+          if (effectData instanceof SubscriptionData) {
+            const payload = {
+              ...effectData.data,
+              $value$: signal
+            };
+            container.$scheduler$(ChoreType.NODE_PROP, consumer, property, payload);
+          }
         }
       }
     };
-    effects.forEach(scheduleEffect);
+    for (const effect of effects) {
+      scheduleEffect(effect);
+    }
   }
 };
 class ComputedSignal extends Signal {
@@ -282,7 +1861,7 @@ class ComputedSignal extends Signal {
     throwIfQRLNotResolved(computeQrl);
     const ctx = tryGetInvokeContext();
     const previousEffectSubscription = ctx?.$effectSubscriber$;
-    ctx && (ctx.$effectSubscriber$ = [this, EffectProperty.VNODE]);
+    ctx && (ctx.$effectSubscriber$ = getSubscriber(this, EffectProperty.VNODE));
     try {
       const untrackedValue = computeQrl.getFn(ctx)();
       if (isPromise(untrackedValue)) {
@@ -302,16 +1881,16 @@ class ComputedSignal extends Signal {
     throw qError(QError.computedReadOnly);
   }
 }
-class WrappedSignal extends Signal {
+class WrappedSignal extends (_c = Signal, _b = _EFFECT_BACK_REF, _c) {
   constructor(container, fn, args, fnStr) {
     super(container, NEEDS_COMPUTATION);
     __publicField(this, "$args$");
     __publicField(this, "$func$");
     __publicField(this, "$funcStr$");
     __publicField(this, "$invalid$", true);
-    __publicField(this, "$effectDependencies$", null);
     __publicField(this, "$hostElement$", null);
     __publicField(this, "$forceRunEffects$", false);
+    __publicField(this, _b, null);
     this.$args$ = args, this.$func$ = fn, this.$funcStr$ = fnStr;
   }
   $invalidate$() {
@@ -339,11 +1918,31 @@ class WrappedSignal extends Signal {
     throw qError(QError.wrappedReadOnly);
   }
 }
-const _CONST_PROPS = Symbol("CONST");
-const _VAR_PROPS = Symbol("VAR");
+const version = "2.0.0-alpha.7-dev+a26598a";
+class _SharedContainer {
+  constructor(scheduleDrain, journalFlush, serverData, locale) {
+    __publicField(this, "$version$");
+    __publicField(this, "$scheduler$");
+    __publicField(this, "$storeProxyMap$");
+    __publicField(this, "$locale$");
+    __publicField(this, "$getObjectById$");
+    __publicField(this, "$serverData$");
+    __publicField(this, "$currentUniqueId$", 0);
+    __publicField(this, "$instanceHash$", null);
+    this.$serverData$ = serverData, this.$locale$ = locale, this.$version$ = version, this.$storeProxyMap$ = /* @__PURE__ */ new WeakMap(), this.$getObjectById$ = () => {
+      throw Error("Not implemented");
+    }, this.$scheduler$ = createScheduler(this, scheduleDrain, journalFlush);
+  }
+  trackSignalValue(signal, subscriber, property, data) {
+    return trackSignalAndAssignHost(signal, subscriber, property, this, data);
+  }
+  serializationCtxFactory(NodeConstructor, DomRefConstructor, symbolToChunkResolver, writer, prepVNodeData) {
+    return createSerializationContext(NodeConstructor, DomRefConstructor, symbolToChunkResolver, this.getHostProp.bind(this), this.setHostProp.bind(this), this.$storeProxyMap$, writer, prepVNodeData);
+  }
+}
 const _jsxSorted = (type, varProps, constProps, children, flags, key) => {
   const processed = null == key ? null : String(key);
-  const node = new JSXNodeImpl(type, varProps || {}, null, children, flags, processed);
+  const node = new JSXNodeImpl(type, varProps || {}, constProps || null, children, flags, processed);
   return node;
 };
 const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
@@ -351,9 +1950,10 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
   return sortedProps = varProps ? Object.fromEntries(untrack(() => Object.entries(varProps)).filter((entry) => {
     const attr = entry[0];
     return "children" === attr ? (children ?? (children = entry[1]), false) : "key" === attr ? (key = entry[1], false) : !constProps;
-  }).sort(([a2], [b]) => a2 < b ? -1 : 1)) : EMPTY_OBJ, _jsxSorted(type, sortedProps, constProps, children, flags, key);
+  }).sort(([a2], [b]) => a2 < b ? -1 : 1)) : "string" == typeof type ? EMPTY_OBJ : {}, _jsxSorted(type, sortedProps, constProps, children, flags, key);
 };
 const jsx = (type, props, key) => _jsxSplit(type, props, null, null, 0, null);
+const isPropsProxy = (obj) => obj && void 0 !== obj[_VAR_PROPS];
 class JSXNodeImpl {
   constructor(type, varProps, constProps, children, flags, key = null) {
     __publicField(this, "type");
@@ -370,7 +1970,9 @@ class JSXNodeImpl {
     return this._proxy || (this._proxy = createPropsProxy(this.varProps, this.constProps, this.children)), this._proxy;
   }
 }
+const Virtual = (props) => props.children;
 const isJSXNode = (n) => n instanceof JSXNodeImpl;
+const Fragment = (props) => props.children;
 function createPropsProxy(varProps, constProps, children) {
   return new Proxy({}, new PropsProxyHandler(varProps, constProps, children));
 }
@@ -424,6 +2026,7 @@ class PropsProxyHandler {
     return out;
   }
 }
+const directGetPropsProxyProp = (jsx2, prop) => jsx2.constProps && prop in jsx2.constProps ? jsx2.constProps[prop] : jsx2.varProps[prop];
 const stringifyPath = [];
 function qwikDebugToString(value) {
   if (null === value) {
@@ -441,7 +2044,7 @@ function qwikDebugToString(value) {
   if (isTask(value)) {
     return `Task(${qwikDebugToString(value.$qrl$)})`;
   }
-  if (isQrl$1(value)) {
+  if (isQrl(value)) {
     return `Qrl(${value.$symbol$})`;
   }
   if ("object" == typeof value || "function" == typeof value) {
@@ -486,17 +2089,121 @@ const jsxToString = (value) => {
   }
   return String(value);
 };
+const VNodeDataSeparator = {
+  REFERENCE_CH: "~",
+  REFERENCE: 126,
+  ADVANCE_1_CH: "!",
+  ADVANCE_1: 33,
+  ADVANCE_2_CH: '"',
+  ADVANCE_2: 34,
+  ADVANCE_4_CH: "#",
+  ADVANCE_4: 35,
+  ADVANCE_8_CH: "$",
+  ADVANCE_8: 36,
+  ADVANCE_16_CH: "%",
+  ADVANCE_16: 37,
+  ADVANCE_32_CH: "&",
+  ADVANCE_32: 38,
+  ADVANCE_64_CH: "'",
+  ADVANCE_64: 39,
+  ADVANCE_128_CH: "(",
+  ADVANCE_128: 40,
+  ADVANCE_256_CH: ")",
+  ADVANCE_256: 41,
+  ADVANCE_512_CH: "*",
+  ADVANCE_512: 42,
+  ADVANCE_1024_CH: "+",
+  ADVANCE_1024: 43,
+  ADVANCE_2048_CH: ",",
+  ADVANCE_2048: 44,
+  ADVANCE_4096_CH: "-",
+  ADVANCE_4096: 45,
+  ADVANCE_8192_CH: ".",
+  ADVANCE_8192: 46
+};
+const VNodeDataChar = {
+  OPEN: 123,
+  OPEN_CHAR: "{",
+  CLOSE: 125,
+  CLOSE_CHAR: "}",
+  SCOPED_STYLE: 59,
+  SCOPED_STYLE_CHAR: ";",
+  RENDER_FN: 60,
+  RENDER_FN_CHAR: "<",
+  ID: 61,
+  ID_CHAR: "=",
+  PROPS: 62,
+  PROPS_CHAR: ">",
+  SLOT_REF: 63,
+  SLOT_REF_CHAR: "?",
+  KEY: 64,
+  KEY_CHAR: "@",
+  SEQ: 91,
+  SEQ_CHAR: "[",
+  DON_T_USE: 92,
+  DON_T_USE_CHAR: "\\",
+  CONTEXT: 93,
+  CONTEXT_CHAR: "]",
+  SEQ_IDX: 94,
+  SEQ_IDX_CHAR: "^",
+  BACK_REFS: 96,
+  BACK_REFS_CHAR: "`",
+  SEPARATOR: 124,
+  SEPARATOR_CHAR: "|",
+  SLOT: 126,
+  SLOT_CHAR: "~"
+};
+const mergeMaps = (map1, map2) => {
+  for (const [k, v] of map2) {
+    map1.set(k, v);
+  }
+  return map1;
+};
 var VNodeJournalOpCode;
 !function(VNodeJournalOpCode2) {
   VNodeJournalOpCode2[VNodeJournalOpCode2.SetText = 1] = "SetText", VNodeJournalOpCode2[VNodeJournalOpCode2.SetAttribute = 2] = "SetAttribute", VNodeJournalOpCode2[VNodeJournalOpCode2.HoistStyles = 3] = "HoistStyles", VNodeJournalOpCode2[VNodeJournalOpCode2.Remove = 4] = "Remove", VNodeJournalOpCode2[VNodeJournalOpCode2.Insert = 5] = "Insert";
 }(VNodeJournalOpCode || (VNodeJournalOpCode = {}));
+const vnode_newElement = (element, elementName) => {
+  assertEqual(fastNodeType(element));
+  const vnode = VNodeArray.createElement(VNodeFlags.Element | VNodeFlags.Inflated | -1 << VNodeFlagsIndex.shift, null, null, null, null, null, element, elementName);
+  return assertTrue(vnode_isElementVNode(vnode)), assertFalse(vnode_isTextVNode(vnode)), assertFalse(vnode_isVirtualVNode(vnode)), vnode;
+};
+const vnode_newUnMaterializedElement = (element) => {
+  assertEqual(fastNodeType(element));
+  const vnode = VNodeArray.createElement(VNodeFlags.Element | -1 << VNodeFlagsIndex.shift, null, null, null, void 0, void 0, element, void 0);
+  return assertTrue(vnode_isElementVNode(vnode)), assertFalse(vnode_isTextVNode(vnode)), assertFalse(vnode_isVirtualVNode(vnode)), vnode;
+};
+const vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
+  sharedTextNode && assertEqual(fastNodeType(sharedTextNode));
+  const vnode = VNodeArray.createText(VNodeFlags.Text | -1 << VNodeFlagsIndex.shift, null, previousTextNode, null, sharedTextNode, textContent);
+  return assertFalse(vnode_isElementVNode(vnode)), assertTrue(vnode_isTextVNode(vnode)), assertFalse(vnode_isVirtualVNode(vnode)), vnode;
+};
+const vnode_newText = (textNode, textContent) => {
+  const vnode = VNodeArray.createText(VNodeFlags.Text | VNodeFlags.Inflated | -1 << VNodeFlagsIndex.shift, null, null, null, textNode, textContent);
+  return assertEqual(fastNodeType(textNode)), assertFalse(vnode_isElementVNode(vnode)), assertTrue(vnode_isTextVNode(vnode)), assertFalse(vnode_isVirtualVNode(vnode)), vnode;
+};
+const vnode_newVirtual = () => {
+  const vnode = VNodeArray.createVirtual(VNodeFlags.Virtual | -1 << VNodeFlagsIndex.shift, null, null, null, null, null);
+  return assertFalse(vnode_isElementVNode(vnode)), assertFalse(vnode_isTextVNode(vnode)), assertTrue(vnode_isVirtualVNode(vnode)), vnode;
+};
 const vnode_isVNode = (vNode) => vNode instanceof VNodeArray;
+const vnode_isElementVNode = (vNode) => {
+  return (vNode[VNodeProps.flags] & VNodeFlags.Element) === VNodeFlags.Element;
+};
+const vnode_isElementOrTextVNode = (vNode) => {
+  return !!(vNode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_TEXT_MASK);
+};
 const vnode_isTextVNode = (vNode) => {
   return (vNode[VNodeProps.flags] & VNodeFlags.Text) === VNodeFlags.Text;
 };
+const vnode_isVirtualVNode = (vNode) => {
+  return (vNode[VNodeProps.flags] & VNodeFlags.Virtual) === VNodeFlags.Virtual;
+};
+const ensureTextVNode = (vNode) => (assertTrue(vnode_isTextVNode(vNode), "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)), vNode);
 const ensureElementOrVirtualVNode = (vNode) => {
   assertTrue(!!(vNode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK), "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode));
 };
+const ensureElementVNode = (vNode) => (assertTrue(vnode_isElementVNode(vNode), "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)), vNode);
 const vnode_getNodeTypeName = (vNode) => {
   if (vNode) {
     switch (vNode[VNodeProps.flags] & VNodeFlags.TYPE_MASK) {
@@ -516,6 +2223,7 @@ const vnode_ensureElementInflated = (vnode) => {
     elementVNode[VNodeProps.flags] ^= VNodeFlags.Inflated;
     const element = elementVNode[ElementVNodeProps.element];
     const attributes = element.attributes;
+    const props = vnode_getProps(elementVNode);
     for (let idx = 0; idx < attributes.length; idx++) {
       const attr = attributes[idx];
       const key = attr.name;
@@ -523,46 +2231,519 @@ const vnode_ensureElementInflated = (vnode) => {
         break;
       }
       if (key.startsWith("q:container")) {
-        attr.value === QContainerValue.HTML ? mapArray_set(elementVNode, dangerouslySetInnerHTML, element.innerHTML, ElementVNodeProps.PROPS_OFFSET) : attr.value === QContainerValue.TEXT && "value" in element && mapArray_set(elementVNode, "value", element.value, ElementVNodeProps.PROPS_OFFSET);
+        attr.value === QContainerValue.HTML ? mapArray_set(props, dangerouslySetInnerHTML, element.innerHTML, 0) : attr.value === QContainerValue.TEXT && "value" in element && mapArray_set(props, "value", element.value, 0);
       } else if (!key.startsWith("on:")) {
-        mapArray_set(elementVNode, key, attr.value, ElementVNodeProps.PROPS_OFFSET);
+        mapArray_set(props, key, attr.value, 0);
+      }
+    }
+  }
+};
+function vnode_walkVNode(vNode) {
+  let vCursor = vNode;
+  if (vnode_isTextVNode(vNode)) {
+    return;
+  }
+  let vParent = null;
+  for (; ; ) {
+    const vFirstChild = vnode_getFirstChild(vCursor);
+    if (vFirstChild) {
+      vCursor = vFirstChild;
+      continue;
+    }
+    if (vCursor === vNode) {
+      return;
+    }
+    const vNextSibling = vnode_getNextSibling(vCursor);
+    if (vNextSibling) {
+      vCursor = vNextSibling;
+    } else {
+      for (vParent = vnode_getParent(vCursor); vParent; ) {
+        if (vParent === vNode) {
+          return;
+        }
+        const vNextParentSibling = vnode_getNextSibling(vParent);
+        if (vNextParentSibling) {
+          vCursor = vNextParentSibling;
+          break;
+        }
+        vParent = vnode_getParent(vParent);
+      }
+      if (null == vParent) {
+        return;
+      }
+    }
+  }
+}
+function vnode_getDOMChildNodes(journal, root, isVNode = false, childNodes = []) {
+  if (vnode_isElementOrTextVNode(root)) {
+    return vnode_isTextVNode(root) && vnode_ensureTextInflated(journal, root), childNodes.push(isVNode ? root : vnode_getNode(root)), childNodes;
+  }
+  let vNode = vnode_getFirstChild(root);
+  for (; vNode; ) {
+    vnode_isElementVNode(vNode) ? childNodes.push(isVNode ? vNode : vnode_getNode(vNode)) : vnode_isTextVNode(vNode) ? (vnode_ensureTextInflated(journal, vNode), childNodes.push(isVNode ? vNode : vnode_getNode(vNode))) : vnode_getDOMChildNodes(journal, vNode, !!isVNode, childNodes), vNode = vnode_getNextSibling(vNode);
+  }
+  return childNodes;
+}
+const vnode_getDomSibling = (vNode, nextDirection, descend) => {
+  const childProp = nextDirection ? VirtualVNodeProps.firstChild : VirtualVNodeProps.lastChild;
+  const siblingProp = nextDirection ? VNodeProps.nextSibling : VNodeProps.previousSibling;
+  let cursor = vNode;
+  for (; descend && cursor && vnode_isVirtualVNode(cursor); ) {
+    const child = cursor[childProp];
+    if (!child) {
+      break;
+    }
+    if (child[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_TEXT_MASK) {
+      return child;
+    }
+    cursor = child;
+  }
+  for (; cursor; ) {
+    let sibling = cursor[siblingProp];
+    if (sibling && sibling[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_TEXT_MASK) {
+      return sibling;
+    }
+    if (!sibling) {
+      let virtual = cursor[VNodeProps.parent];
+      if (virtual && !vnode_isVirtualVNode(virtual)) {
+        return null;
+      }
+      for (; virtual && !(sibling = virtual[siblingProp]); ) {
+        if (virtual = virtual[VNodeProps.parent], virtual && !vnode_isVirtualVNode(virtual)) {
+          return null;
+        }
+      }
+      if (!sibling) {
+        return null;
+      }
+      if (vnode_isTextVNode(sibling) && virtual && vnode_isElementVNode(virtual)) {
+        return null;
+      }
+    }
+    for (; sibling; ) {
+      if (cursor = sibling, cursor[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_TEXT_MASK && vnode_getNode(cursor)) {
+        return cursor;
+      }
+      sibling = cursor[childProp];
+    }
+  }
+  return null;
+};
+const vnode_ensureInflatedIfText = (journal, vNode) => {
+  vnode_isTextVNode(vNode) && vnode_ensureTextInflated(journal, vNode);
+};
+const vnode_ensureTextInflated = (journal, vnode) => {
+  const textVNode = ensureTextVNode(vnode);
+  if (!(textVNode[VNodeProps.flags] & VNodeFlags.Inflated)) {
+    const parentNode = vnode_getDomParent(vnode);
+    const sharedTextNode = textVNode[TextVNodeProps.node];
+    const doc = parentNode.ownerDocument;
+    let cursor = vnode_getDomSibling(vnode, false, true);
+    const insertBeforeNode = sharedTextNode || vnode_getDomSibling(vnode, true, true)?.[ElementVNodeProps.element] || null;
+    let lastPreviousTextNode = insertBeforeNode;
+    for (; cursor && vnode_isTextVNode(cursor); ) {
+      if (!(cursor[VNodeProps.flags] & VNodeFlags.Inflated)) {
+        const textNode = doc.createTextNode(cursor[TextVNodeProps.text]);
+        journal.push(VNodeJournalOpCode.Insert, parentNode, lastPreviousTextNode, textNode), lastPreviousTextNode = textNode, cursor[TextVNodeProps.node] = textNode, cursor[VNodeProps.flags] |= VNodeFlags.Inflated;
+      }
+      cursor = vnode_getDomSibling(cursor, false, true);
+    }
+    for (cursor = vnode; cursor && vnode_isTextVNode(cursor); ) {
+      const next = vnode_getDomSibling(cursor, true, true);
+      const isLastNode = !next || !vnode_isTextVNode(next);
+      if (!(cursor[VNodeProps.flags] & VNodeFlags.Inflated)) {
+        if (isLastNode && sharedTextNode) {
+          journal.push(VNodeJournalOpCode.SetText, sharedTextNode, cursor[TextVNodeProps.text]);
+        } else {
+          const textNode = doc.createTextNode(cursor[TextVNodeProps.text]);
+          journal.push(VNodeJournalOpCode.Insert, parentNode, insertBeforeNode, textNode), cursor[TextVNodeProps.node] = textNode;
+        }
+        cursor[VNodeProps.flags] |= VNodeFlags.Inflated;
+      }
+      cursor = next;
+    }
+  }
+};
+const vnode_locate = (rootVNode, id) => {
+  ensureElementVNode(rootVNode);
+  let vNode = rootVNode;
+  const containerElement = rootVNode[ElementVNodeProps.element];
+  const { qVNodeRefs } = containerElement;
+  let elementOffset = -1;
+  let refElement;
+  if ("string" == typeof id ? (elementOffset = parseInt(id), refElement = qVNodeRefs.get(elementOffset)) : refElement = id, vnode_isVNode(refElement)) {
+    vNode = refElement;
+  } else {
+    assertTrue(containerElement.contains(refElement));
+    let parent = refElement;
+    const elementPath = [refElement];
+    for (; parent && parent !== containerElement; ) {
+      parent = parent.parentElement, elementPath.push(parent);
+    }
+    for (let i = elementPath.length - 2; i >= 0; i--) {
+      vNode = vnode_getVNodeForChildNode(vNode, elementPath[i]);
+    }
+    -1 != elementOffset && qVNodeRefs.set(elementOffset, vNode);
+  }
+  if ("string" == typeof id) {
+    const idLength = id.length;
+    let idx = indexOfAlphanumeric(id, idLength);
+    let childIdx = 0;
+    for (; idx < idLength; ) {
+      const ch = id.charCodeAt(idx);
+      childIdx *= 26, ch >= 97 ? childIdx += ch - 97 : (childIdx += ch - 65, vNode = vnode_getChildWithIdx(vNode, childIdx), childIdx = 0), idx++;
+    }
+  }
+  return vNode;
+};
+const vnode_getChildWithIdx = (vNode, childIdx) => {
+  let child = vnode_getFirstChild(vNode);
+  for (assertDefined(); child[VNodeProps.flags] >>> VNodeFlagsIndex.shift !== childIdx; ) {
+    child = vnode_getNextSibling(child);
+  }
+  return child;
+};
+const vNodeStack = [];
+const vnode_getVNodeForChildNode = (vNode, childElement) => {
+  ensureElementVNode(vNode);
+  let child = vnode_getFirstChild(vNode);
+  for (assertDefined(); child && child[ElementVNodeProps.element] !== childElement; ) {
+    if (vnode_isVirtualVNode(child)) {
+      const next = vnode_getNextSibling(child);
+      const firstChild = vnode_getFirstChild(child);
+      firstChild ? (next && vNodeStack.push(next), child = firstChild) : child = next || (vNodeStack.length ? vNodeStack.pop() : null);
+    } else {
+      const next = vnode_getNextSibling(child);
+      child = next || (next || vNodeStack.pop());
+    }
+  }
+  for (; vNodeStack.length; ) {
+    vNodeStack.pop();
+  }
+  return ensureElementVNode(child), assertEqual(child[ElementVNodeProps.element]), child;
+};
+const indexOfAlphanumeric = (id, length) => {
+  let idx = 0;
+  for (; idx < length; ) {
+    if (!(id.charCodeAt(idx) <= 57)) {
+      return idx;
+    }
+    idx++;
+  }
+  return length;
+};
+const parseBoolean = (value) => "false" !== value && Boolean(value);
+const isBooleanAttr = (element, key) => ("allowfullscreen" == key || "async" == key || "autofocus" == key || "autoplay" == key || "checked" == key || "controls" == key || "default" == key || "defer" == key || "disabled" == key || "formnovalidate" == key || "inert" == key || "ismap" == key || "itemscope" == key || "loop" == key || "multiple" == key || "muted" == key || "nomodule" == key || "novalidate" == key || "open" == key || "playsinline" == key || "readonly" == key || "required" == key || "reversed" == key || "selected" == key) && key in element;
+const vnode_applyJournal = (journal) => {
+  let idx = 0;
+  const length = journal.length;
+  for (; idx < length; ) {
+    switch (journal[idx++]) {
+      case VNodeJournalOpCode.SetText:
+        journal[idx++].nodeValue = journal[idx++];
+        break;
+      case VNodeJournalOpCode.SetAttribute:
+        const element = journal[idx++];
+        let key = journal[idx++];
+        "className" === key && (key = "class");
+        const value = journal[idx++];
+        isBooleanAttr(element, key) ? element[key] = parseBoolean(value) : "value" === key && key in element ? element.value = escapeHTML(String(value)) : key === dangerouslySetInnerHTML ? element.innerHTML = value : null == value || false === value ? element.removeAttribute(key) : element.setAttribute(key, String(value));
+        break;
+      case VNodeJournalOpCode.HoistStyles:
+        const document2 = journal[idx++];
+        const head = document2.head;
+        const styles = document2.querySelectorAll(QStylesAllSelector);
+        for (let i = 0; i < styles.length; i++) {
+          head.appendChild(styles[i]);
+        }
+        break;
+      case VNodeJournalOpCode.Remove:
+        const removeParent = journal[idx++];
+        let nodeToRemove;
+        for (; idx < length && "number" != typeof (nodeToRemove = journal[idx]); ) {
+          removeParent.removeChild(nodeToRemove), idx++;
+        }
+        break;
+      case VNodeJournalOpCode.Insert:
+        const insertParent = journal[idx++];
+        const insertBefore = journal[idx++];
+        let newChild;
+        for (; idx < length && "number" != typeof (newChild = journal[idx]); ) {
+          insertParent.insertBefore(newChild, insertBefore), idx++;
+        }
+    }
+  }
+  journal.length = 0;
+};
+const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
+  ensureElementOrVirtualVNode(parent), vnode_isElementVNode(parent) && ensureMaterialized(parent), newChild === insertBefore && (insertBefore = null);
+  let adjustedInsertBefore = null;
+  null == insertBefore ? vnode_isVirtualVNode(parent) && (adjustedInsertBefore = vnode_getDomSibling(parent, true, false)) : adjustedInsertBefore = vnode_isVirtualVNode(insertBefore) ? vnode_getDomSibling(insertBefore, true, true) : insertBefore, adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+  const domParentVNode = vnode_getDomParentVNode(parent);
+  const parentNode = domParentVNode && domParentVNode[ElementVNodeProps.element];
+  if (parentNode) {
+    const domChildren = vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild);
+    domChildren.length && journal.push(VNodeJournalOpCode.Insert, parentNode, vnode_getNode(adjustedInsertBefore), ...domChildren);
+  }
+  const newChildCurrentParent = newChild[VNodeProps.parent];
+  newChildCurrentParent && (newChild[VNodeProps.previousSibling] || newChild[VNodeProps.nextSibling] || vnode_isElementVNode(newChildCurrentParent) && newChildCurrentParent !== parent) && vnode_remove(journal, newChildCurrentParent, newChild, false);
+  const vNext = insertBefore;
+  const vPrevious = vNext ? vNext[VNodeProps.previousSibling] : parent[ElementVNodeProps.lastChild];
+  vNext ? vNext[VNodeProps.previousSibling] = newChild : parent[ElementVNodeProps.lastChild] = newChild, vPrevious ? vPrevious[VNodeProps.nextSibling] = newChild : parent[ElementVNodeProps.firstChild] = newChild, newChild[VNodeProps.previousSibling] = vPrevious, newChild[VNodeProps.nextSibling] = vNext, newChild[VNodeProps.parent] = parent;
+};
+const vnode_getDomParent = (vnode) => (vnode = vnode_getDomParentVNode(vnode)) && vnode[ElementVNodeProps.element];
+const vnode_getDomParentVNode = (vnode) => {
+  for (; vnode && !vnode_isElementVNode(vnode); ) {
+    vnode = vnode[VNodeProps.parent];
+  }
+  return vnode;
+};
+const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
+  assertEqual(vParent, vnode_getParent(vToRemove)), vnode_isTextVNode(vToRemove) && vnode_ensureTextInflated(journal, vToRemove);
+  const vPrevious = vToRemove[VNodeProps.previousSibling];
+  const vNext = vToRemove[VNodeProps.nextSibling];
+  if (vPrevious ? vPrevious[VNodeProps.nextSibling] = vNext : vParent[ElementVNodeProps.firstChild] = vNext, vNext ? vNext[VNodeProps.previousSibling] = vPrevious : vParent[ElementVNodeProps.lastChild] = vPrevious, vToRemove[VNodeProps.previousSibling] = null, vToRemove[VNodeProps.nextSibling] = null, removeDOM) {
+    const domParent = vnode_getDomParent(vParent);
+    if (vnode_getAttr(vParent, dangerouslySetInnerHTML)) {
+      return;
+    }
+    const children = vnode_getDOMChildNodes(journal, vToRemove);
+    domParent && children.length && journal.push(VNodeJournalOpCode.Remove, domParent, ...children);
+  }
+};
+const vnode_truncate = (journal, vParent, vDelete) => {
+  const parent = vnode_getDomParent(vParent);
+  const children = vnode_getDOMChildNodes(journal, vDelete);
+  parent && children.length && journal.push(VNodeJournalOpCode.Remove, parent, ...children);
+  const vPrevious = vDelete[VNodeProps.previousSibling];
+  vPrevious ? vPrevious[VNodeProps.nextSibling] = null : vParent[ElementVNodeProps.firstChild] = null, vParent[ElementVNodeProps.lastChild] = vPrevious;
+};
+const vnode_getElementName = (vnode) => {
+  const elementVNode = ensureElementVNode(vnode);
+  let elementName = elementVNode[ElementVNodeProps.elementName];
+  if (void 0 === elementName) {
+    const element = elementVNode[ElementVNodeProps.element];
+    const nodeName = fastNodeName(element);
+    elementName = elementVNode[ElementVNodeProps.elementName] = nodeName, elementVNode[VNodeProps.flags] |= vnode_getElementNamespaceFlags(element);
+  }
+  return elementName;
+};
+const vnode_getText = (vnode) => {
+  const textVNode = ensureTextVNode(vnode);
+  let text = textVNode[TextVNodeProps.text];
+  return void 0 === text && (text = textVNode[TextVNodeProps.text] = textVNode[TextVNodeProps.node].nodeValue), text;
+};
+const vnode_setText = (journal, textVNode, text) => {
+  vnode_ensureTextInflated(journal, textVNode);
+  journal.push(VNodeJournalOpCode.SetText, textVNode[TextVNodeProps.node], textVNode[TextVNodeProps.text] = text);
+};
+const vnode_getFirstChild = (vnode) => {
+  if (vnode_isTextVNode(vnode)) {
+    return null;
+  }
+  let vFirstChild = vnode[ElementVNodeProps.firstChild];
+  return void 0 === vFirstChild && (vFirstChild = ensureMaterialized(vnode)), vFirstChild;
+};
+const vnode_materialize = (vNode) => {
+  const element = vNode[ElementVNodeProps.element];
+  const firstChild = fastFirstChild(element);
+  const vNodeData = element.ownerDocument?.qVNodeData?.get(element);
+  return materialize(vNode, element, firstChild, vNodeData);
+};
+const materialize = (vNode, element, firstChild, vNodeData) => {
+  if (vNodeData) {
+    if (vNodeData.charCodeAt(0) === VNodeDataChar.SEPARATOR) {
+      const elementVNodeDataStartIdx = 1;
+      let elementVNodeDataEndIdx = 1;
+      for (; vNodeData.charCodeAt(elementVNodeDataEndIdx) !== VNodeDataChar.SEPARATOR; ) {
+        elementVNodeDataEndIdx++;
+      }
+      const elementVNodeData = vNodeData.substring(elementVNodeDataStartIdx, elementVNodeDataEndIdx);
+      vNodeData = vNodeData.substring(elementVNodeDataEndIdx + 1);
+      const vFirstChild = materializeFromDOM(vNode, firstChild, elementVNodeData);
+      if (!vNodeData) {
+        return vFirstChild;
+      }
+    }
+    return materializeFromVNodeData(vNode, vNodeData, element, firstChild);
+  }
+  return materializeFromDOM(vNode, firstChild);
+};
+const ensureMaterialized = (vnode) => {
+  const vParent = ensureElementVNode(vnode);
+  let vFirstChild = vParent[ElementVNodeProps.firstChild];
+  if (void 0 === vFirstChild) {
+    vFirstChild = vParent[VNodeProps.parent] && shouldIgnoreChildren(vParent[ElementVNodeProps.element]) ? vParent[ElementVNodeProps.firstChild] = vParent[ElementVNodeProps.lastChild] = null : vnode_materialize(vParent);
+  }
+  return assertTrue(void 0 !== vParent[ElementVNodeProps.firstChild]), assertTrue(void 0 !== vParent[ElementVNodeProps.lastChild]), vFirstChild;
+};
+let _fastHasAttribute = null;
+const shouldIgnoreChildren = (node) => (_fastHasAttribute || (_fastHasAttribute = node.hasAttribute), _fastHasAttribute.call(node, "q:container"));
+let _fastNodeType = null;
+const fastNodeType = (node) => (_fastNodeType || (_fastNodeType = fastGetter(node, "nodeType")), _fastNodeType.call(node));
+const fastIsTextOrElement = (node) => {
+  const type = fastNodeType(node);
+  return 3 === type || 1 === type;
+};
+let _fastNextSibling = null;
+const fastNextSibling = (node) => {
+  for (_fastNextSibling || (_fastNextSibling = fastGetter(node, "nextSibling")), _fastFirstChild || (_fastFirstChild = fastGetter(node, "firstChild")); node; ) {
+    if (null !== (node = _fastNextSibling.call(node))) {
+      const type = fastNodeType(node);
+      if (3 === type || 1 === type) {
+        break;
+      }
+      if (8 === type) {
+        const nodeValue = node.nodeValue;
+        if (nodeValue?.startsWith(QIgnore)) {
+          return getNodeAfterCommentNode(node, QContainerIsland, _fastNextSibling, _fastFirstChild);
+        }
+        if (node.nodeValue?.startsWith(QContainerIslandEnd)) {
+          return getNodeAfterCommentNode(node, QIgnoreEnd, _fastNextSibling, _fastFirstChild);
+        }
+        if (nodeValue?.startsWith("q:container")) {
+          for (; node && (node = _fastNextSibling.call(node)) && (8 !== fastNodeType(node) || !node.nodeValue?.startsWith("/q:container")); ) {
+          }
+        }
+      }
+    }
+  }
+  return node;
+};
+function getNodeAfterCommentNode(node, commentValue, nextSibling, firstChild) {
+  for (; node; ) {
+    if (node.nodeValue?.startsWith(commentValue)) {
+      return node = nextSibling.call(node) || null;
+    }
+    let nextNode = firstChild.call(node);
+    nextNode || (nextNode = nextSibling.call(node)), nextNode || (nextNode = fastParentNode(node), nextNode && (nextNode = nextSibling.call(nextNode))), node = nextNode;
+  }
+  return null;
+}
+let _fastParentNode = null;
+const fastParentNode = (node) => (_fastParentNode || (_fastParentNode = fastGetter(node, "parentNode")), _fastParentNode.call(node));
+let _fastFirstChild = null;
+const fastFirstChild = (node) => {
+  for (_fastFirstChild || (_fastFirstChild = fastGetter(node, "firstChild")), node = node && _fastFirstChild.call(node); node && !fastIsTextOrElement(node); ) {
+    node = fastNextSibling(node);
+  }
+  return node;
+};
+let _fastNamespaceURI = null;
+const fastNamespaceURI = (element) => (_fastNamespaceURI || (_fastNamespaceURI = fastGetter(element, "namespaceURI")), _fastNamespaceURI.call(element));
+let _fastNodeName = null;
+const fastNodeName = (element) => (_fastNodeName || (_fastNodeName = fastGetter(element, "nodeName")), _fastNodeName.call(element));
+const fastGetter = (prototype, name) => {
+  let getter;
+  for (; prototype && !(getter = Object.getOwnPropertyDescriptor(prototype, name)?.get); ) {
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  return getter || function() {
+    return this[name];
+  };
+};
+const isQStyleElement = (node) => isElement(node) && "STYLE" === node.nodeName && (node.hasAttribute("q:sstyle") || node.hasAttribute(QStyle));
+const materializeFromDOM = (vParent, firstChild, vData) => {
+  let vFirstChild = null;
+  const skipStyleElements = () => {
+    for (; isQStyleElement(child); ) {
+      child = fastNextSibling(child);
+    }
+  };
+  let child = firstChild;
+  skipStyleElements();
+  let vChild = null;
+  for (; child; ) {
+    const nodeType = fastNodeType(child);
+    let vNextChild = null;
+    3 === nodeType ? vNextChild = vnode_newText(child, child.textContent ?? void 0) : 1 === nodeType && (vNextChild = vnode_newUnMaterializedElement(child)), vNextChild && (vNextChild[VNodeProps.parent] = vParent, vChild && (vChild[VNodeProps.nextSibling] = vNextChild), vNextChild[VNodeProps.previousSibling] = vChild, vChild = vNextChild), vFirstChild || (vParent[ElementVNodeProps.firstChild] = vFirstChild = vChild), child = fastNextSibling(child), skipStyleElements();
+  }
+  if (vParent[ElementVNodeProps.lastChild] = vChild || null, vParent[ElementVNodeProps.firstChild] = vFirstChild, vData) {
+    let container = null;
+    processVNodeData$1(vData, (peek, consumeValue) => {
+      if (peek() === VNodeDataChar.ID) {
+        container || (container = getDomContainer(vParent[ElementVNodeProps.element]));
+        const id = consumeValue();
+        container.$setRawState$(parseInt(id), vParent);
+      } else {
+        peek() === VNodeDataChar.BACK_REFS ? (container || (container = getDomContainer(vParent[ElementVNodeProps.element])), setEffectBackRefFromVNodeData(vParent, consumeValue(), container)) : consumeValue();
+      }
+    });
+  }
+  return vFirstChild;
+};
+function setEffectBackRefFromVNodeData(vParent, value, container) {
+  const deserializedSubMap = container.$getObjectById$(value);
+  if (vParent[_EFFECT_BACK_REF]) {
+    mergeMaps(vParent[_EFFECT_BACK_REF], deserializedSubMap);
+  } else {
+    Object.defineProperty(vParent, _EFFECT_BACK_REF, {
+      value: deserializedSubMap
+    });
+  }
+}
+const processVNodeData$1 = (vData, callback) => {
+  let nextToConsumeIdx = 0;
+  let ch = 0;
+  let peekCh = 0;
+  const peek = () => 0 !== peekCh ? peekCh : peekCh = nextToConsumeIdx < vData.length ? vData.charCodeAt(nextToConsumeIdx) : 0;
+  const consume = () => (ch = peek(), peekCh = 0, nextToConsumeIdx++, ch);
+  const consumeValue = () => {
+    consume();
+    const start = nextToConsumeIdx;
+    for (; peek() <= 58 && 0 !== peekCh || 95 === peekCh || peekCh >= 65 && peekCh <= 90 || peekCh >= 97 && peekCh <= 122; ) {
+      consume();
+    }
+    return vData.substring(start, nextToConsumeIdx);
+  };
+  for (; 0 !== peek(); ) {
+    callback(peek, consumeValue, consume, nextToConsumeIdx);
+  }
+};
+const vnode_getNextSibling = (vnode) => vnode[VNodeProps.nextSibling];
+const vnode_getPreviousSibling = (vnode) => vnode[VNodeProps.previousSibling];
+const vnode_setAttr = (journal, vnode, key, value) => {
+  const type = vnode[VNodeProps.flags];
+  if (type & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
+    vnode_ensureElementInflated(vnode);
+    const props = vnode_getProps(vnode);
+    const idx = mapApp_findIndx(props, key, 0);
+    if (idx >= 0) {
+      if (props[idx + 1] != value && type & VNodeFlags.Element) {
+        journal && journal.push(VNodeJournalOpCode.SetAttribute, vnode[ElementVNodeProps.element], key, value);
       }
+      null == value ? props.splice(idx, 2) : props[idx + 1] = value;
+    } else if (null != value && (props.splice(~idx, 0, key, value), type & VNodeFlags.Element)) {
+      journal && journal.push(VNodeJournalOpCode.SetAttribute, vnode[ElementVNodeProps.element], key, value);
     }
   }
 };
-const mapApp_findIndx = (elementVNode, key, start) => {
-  let bottom = start >> 1;
-  let top = elementVNode.length - 2 >> 1;
-  for (; bottom <= top; ) {
-    const mid = bottom + (top - bottom >> 1);
-    const midKey = elementVNode[mid << 1];
-    if (midKey === key) {
-      return mid << 1;
-    }
-    midKey < key ? bottom = mid + 1 : top = mid - 1;
+const vnode_getAttr = (vnode, key) => {
+  if (vnode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
+    vnode_ensureElementInflated(vnode);
+    const props = vnode_getProps(vnode);
+    return mapArray_get(props, key, 0);
   }
-  return ~(bottom << 1);
-};
-const mapArray_set = (elementVNode, key, value, start) => {
-  const indx = mapApp_findIndx(elementVNode, key, start);
-  indx >= 0 ? null == value ? elementVNode.splice(indx, 2) : elementVNode[indx + 1] = value : null != value && elementVNode.splice(~indx, 0, key, value);
+  return null;
 };
 const vnode_getProp = (vnode, key, getObject) => {
   const type = vnode[VNodeProps.flags];
   if (type & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
     type & VNodeFlags.Element && vnode_ensureElementInflated(vnode);
-    const idx = mapApp_findIndx(vnode, key, vnode_getPropStartIndex(vnode));
+    const props = vnode_getProps(vnode);
+    const idx = mapApp_findIndx(props, key, 0);
     if (idx >= 0) {
-      let value = vnode[idx + 1];
-      return "string" == typeof value && getObject && (vnode[idx + 1] = value = getObject(value)), value;
+      let value = props[idx + 1];
+      return "string" == typeof value && getObject && (props[idx + 1] = value = getObject(value)), value;
     }
   }
   return null;
 };
 const vnode_setProp = (vnode, key, value) => {
   ensureElementOrVirtualVNode(vnode);
-  const idx = mapApp_findIndx(vnode, key, vnode_getPropStartIndex(vnode));
-  idx >= 0 ? vnode[idx + 1] = value : null != value && vnode.splice(~idx, 0, key, value);
+  const props = vnode_getProps(vnode);
+  const idx = mapApp_findIndx(props, key, 0);
+  idx >= 0 ? props[idx + 1] = value : null != value && props.splice(~idx, 0, key, value);
 };
 const vnode_getPropStartIndex = (vnode) => {
   const type = vnode[VNodeProps.flags] & VNodeFlags.TYPE_MASK;
@@ -574,21 +2755,124 @@ const vnode_getPropStartIndex = (vnode) => {
   }
   throw qError(QError.invalidVNodeType, [type]);
 };
+const vnode_getProps = (vnode) => vnode[vnode_getPropStartIndex(vnode)];
+const vnode_getParent = (vnode) => vnode[VNodeProps.parent] || null;
+const vnode_getNode = (vnode) => null === vnode || vnode_isVirtualVNode(vnode) ? null : vnode_isElementVNode(vnode) ? vnode[ElementVNodeProps.element] : (assertTrue(vnode_isTextVNode(vnode)), vnode[TextVNodeProps.node]);
+const isNumber = (ch) => 48 <= ch && ch <= 57;
+const isLowercase = (ch) => 97 <= ch && ch <= 122;
+const stack = [];
+function materializeFromVNodeData(vParent, vData, element, child) {
+  let idx = 0;
+  let vFirst = null;
+  let vLast = null;
+  let previousTextNode = null;
+  const addVNode = (node) => {
+    node[VNodeProps.flags] = node[VNodeProps.flags] & VNodeFlagsIndex.negated_mask | idx << VNodeFlagsIndex.shift, idx++, vLast && (vLast[VNodeProps.nextSibling] = node), node[VNodeProps.previousSibling] = vLast, node[VNodeProps.parent] = vParent, vFirst || (vParent[ElementVNodeProps.firstChild] = vFirst = node), vLast = node;
+  };
+  let textIdx = 0;
+  let combinedText = null;
+  let container = null;
+  return processVNodeData$1(vData, (peek, consumeValue, consume, nextToConsumeIdx) => {
+    if (isNumber(peek())) {
+      for (; !isElement(child); ) {
+        if (!(child = fastNextSibling(child))) {
+          throw qError(QError.materializeVNodeDataError, [vData, peek(), nextToConsumeIdx]);
+        }
+      }
+      for (; isQStyleElement(child); ) {
+        child = fastNextSibling(child);
+      }
+      combinedText = null, previousTextNode = null;
+      let value = 0;
+      for (; isNumber(peek()); ) {
+        value *= 10, value += consume() - 48;
+      }
+      for (; value--; ) {
+        addVNode(vnode_newUnMaterializedElement(child)), child = fastNextSibling(child);
+      }
+    } else if (peek() === VNodeDataChar.SCOPED_STYLE) {
+      vnode_setAttr(null, vParent, "q:sstyle", consumeValue());
+    } else if (peek() === VNodeDataChar.RENDER_FN) {
+      vnode_setAttr(null, vParent, "q:renderFn", consumeValue());
+    } else if (peek() === VNodeDataChar.ID) {
+      container || (container = getDomContainer(element));
+      const id = consumeValue();
+      container.$setRawState$(parseInt(id), vParent);
+    } else if (peek() === VNodeDataChar.PROPS) {
+      vnode_setAttr(null, vParent, "q:props", consumeValue());
+    } else if (peek() === VNodeDataChar.SLOT_REF) {
+      vnode_setAttr(null, vParent, "q:sref", consumeValue());
+    } else if (peek() === VNodeDataChar.KEY) {
+      vnode_setAttr(null, vParent, "q:key", consumeValue());
+    } else if (peek() === VNodeDataChar.SEQ) {
+      vnode_setAttr(null, vParent, "q:seq", consumeValue());
+    } else if (peek() === VNodeDataChar.SEQ_IDX) {
+      vnode_setAttr(null, vParent, "q:seqIdx", consumeValue());
+    } else if (peek() === VNodeDataChar.BACK_REFS) {
+      container || (container = getDomContainer(element)), setEffectBackRefFromVNodeData(vParent, consumeValue(), container);
+    } else if (peek() === VNodeDataChar.CONTEXT) {
+      vnode_setAttr(null, vParent, "q:ctx", consumeValue());
+    } else if (peek() === VNodeDataChar.OPEN) {
+      consume(), addVNode(vnode_newVirtual()), stack.push(vParent, vFirst, vLast, previousTextNode, idx), idx = 0, vParent = vLast, vFirst = vLast = null;
+    } else if (peek() === VNodeDataChar.SEPARATOR) {
+      const key = consumeValue();
+      const value = consumeValue();
+      vnode_setAttr(null, vParent, key, value);
+    } else if (peek() === VNodeDataChar.CLOSE) {
+      consume(), vParent[ElementVNodeProps.lastChild] = vLast, idx = stack.pop(), previousTextNode = stack.pop(), vLast = stack.pop(), vFirst = stack.pop(), vParent = stack.pop();
+    } else if (peek() === VNodeDataChar.SLOT) {
+      vnode_setAttr(null, vParent, QSlot, consumeValue());
+    } else {
+      const textNode = child && 3 === fastNodeType(child) ? child : null;
+      null === combinedText && (combinedText = textNode ? textNode.nodeValue : null, textIdx = 0);
+      let length = 0;
+      for (; isLowercase(peek()); ) {
+        length += consume() - 97, length *= 26;
+      }
+      length += consume() - 65;
+      const text = null === combinedText ? "" : combinedText.substring(textIdx, textIdx + length);
+      addVNode(previousTextNode = vnode_newSharedText(previousTextNode, textNode, text)), textIdx += length;
+    }
+  }), vParent[ElementVNodeProps.lastChild] = vLast, vFirst;
+}
+const vnode_getType = (vnode) => {
+  const type = vnode[VNodeProps.flags];
+  if (type & VNodeFlags.Element) {
+    return 1;
+  }
+  if (type & VNodeFlags.Virtual) {
+    return 11;
+  }
+  if (type & VNodeFlags.Text) {
+    return 3;
+  }
+  throw qError(QError.invalidVNodeType, [type]);
+};
+const isElement = (node) => node && "object" == typeof node && 1 === fastNodeType(node);
+const vnode_getProjectionParentComponent = (vHost, rootVNode) => {
+  let projectionDepth = 1;
+  for (; projectionDepth--; ) {
+    for (; vHost && (!vnode_isVirtualVNode(vHost) || null === vnode_getProp(vHost, "q:renderFn", null)); ) {
+      const qSlotParent = vnode_getProp(vHost, ":", (id) => vnode_locate(rootVNode, id));
+      const vProjectionParent = vnode_isVirtualVNode(vHost) && qSlotParent;
+      vProjectionParent && projectionDepth++, vHost = vProjectionParent || vnode_getParent(vHost);
+    }
+    projectionDepth > 0 && (vHost = vnode_getParent(vHost));
+  }
+  return vHost;
+};
 const VNodeArray = class VNode extends Array {
   static createElement(flags, parent, previousSibling, nextSibling, firstChild, lastChild, element, elementName) {
-    const vnode = new VNode(flags, parent, previousSibling, nextSibling);
-    return vnode.push(firstChild, lastChild, element, elementName), vnode;
+    return new VNode(flags, parent, previousSibling, nextSibling, firstChild, lastChild, element, elementName, []);
   }
   static createText(flags, parent, previousSibling, nextSibling, textNode, text) {
-    const vnode = new VNode(flags, parent, previousSibling, nextSibling);
-    return vnode.push(textNode, text), vnode;
+    return new VNode(flags, parent, previousSibling, nextSibling, textNode, text);
   }
   static createVirtual(flags, parent, previousSibling, nextSibling, firstChild, lastChild) {
-    const vnode = new VNode(flags, parent, previousSibling, nextSibling);
-    return vnode.push(firstChild, lastChild), vnode;
+    return new VNode(flags, parent, previousSibling, nextSibling, firstChild, lastChild, []);
   }
-  constructor(flags, parent, previousSibling, nextSibling) {
-    super(), this.push(flags, parent, previousSibling, nextSibling);
+  constructor(flags, parent, previousSibling, nextSibling, ...rest) {
+    super(flags, parent, previousSibling, nextSibling, ...rest);
   }
 };
 let _context;
@@ -616,9 +2900,11 @@ function invokeApply(context, fn, args) {
   return returnValue;
 }
 const newInvokeContextFromTuple = ([element, event, url]) => {
-  const container = element.closest(QContainerSelector);
+  const domContainer = getDomContainer(element);
+  const container = domContainer.element;
+  const vNode = container ? vnode_locate(domContainer.rootVNode, element) : void 0;
   const locale = container?.getAttribute("q:locale") || void 0;
-  return newInvokeContext(locale, void 0, element, event, url);
+  return newInvokeContext(locale, vNode, element, event, url);
 };
 const newInvokeContext = (locale, hostElement, element, event, url) => {
   const ctx = {
@@ -640,18 +2926,1230 @@ const trackSignal = (fn, subscriber, property, container, data) => {
   const previousSubscriber = trackInvocation.$effectSubscriber$;
   const previousContainer = trackInvocation.$container$;
   try {
-    return trackInvocation.$effectSubscriber$ = [subscriber, property], data && trackInvocation.$effectSubscriber$.push(data), trackInvocation.$container$ = container, invoke(trackInvocation, fn);
+    return trackInvocation.$effectSubscriber$ = getSubscriber(subscriber, property, data), trackInvocation.$container$ = container, invoke(trackInvocation, fn);
   } finally {
     trackInvocation.$effectSubscriber$ = previousSubscriber, trackInvocation.$container$ = previousContainer;
   }
 };
+const trackSignalAndAssignHost = (value, host, property, container, data) => (value instanceof WrappedSignal && value.$hostElement$ !== host && host && (value.$hostElement$ = host), trackSignal(() => value.value, host, property, container, data));
+const createContextId = (name) => /* @__PURE__ */ Object.freeze({
+  id: fromCamelToKebabCase(name)
+});
+const ERROR_CONTEXT = /* @__PURE__ */ createContextId("qk-error");
+function processVNodeData(document2) {
+  const vNodeDataMap = document2.qVNodeData || (document2.qVNodeData = /* @__PURE__ */ new WeakMap());
+  const prototype = document2.body;
+  const getAttribute = prototype.getAttribute;
+  const hasAttribute = prototype.hasAttribute;
+  const getNodeType = ((prototype2, name) => {
+    let getter;
+    for (; prototype2 && !(getter = Object.getOwnPropertyDescriptor(prototype2, name)?.get); ) {
+      prototype2 = Object.getPrototypeOf(prototype2);
+    }
+    return getter || function() {
+      return this[name];
+    };
+  })(prototype, "nodeType");
+  const attachVnodeDataAndRefs = (element) => {
+    Array.from(element.querySelectorAll('script[type="qwik/vnode"]')).forEach((script) => {
+      script.setAttribute("type", "x-qwik/vnode");
+      const qContainerElement = script.closest("[q\\:container]");
+      qContainerElement.qVnodeData = script.textContent, qContainerElement.qVNodeRefs = /* @__PURE__ */ new Map();
+    }), element.querySelectorAll("[q\\:shadowroot]").forEach((parent) => {
+      const shadowRoot = parent.shadowRoot;
+      shadowRoot && attachVnodeDataAndRefs(shadowRoot);
+    });
+  };
+  let NodeType;
+  attachVnodeDataAndRefs(document2), function(NodeType2) {
+    NodeType2[NodeType2.CONTAINER_MASK = 1] = "CONTAINER_MASK", NodeType2[NodeType2.ELEMENT = 2] = "ELEMENT", NodeType2[NodeType2.ELEMENT_CONTAINER = 3] = "ELEMENT_CONTAINER", NodeType2[NodeType2.ELEMENT_SHADOW_ROOT = 6] = "ELEMENT_SHADOW_ROOT", NodeType2[NodeType2.COMMENT_SKIP_START = 5] = "COMMENT_SKIP_START", NodeType2[NodeType2.COMMENT_SKIP_END = 8] = "COMMENT_SKIP_END", NodeType2[NodeType2.COMMENT_IGNORE_START = 16] = "COMMENT_IGNORE_START", NodeType2[NodeType2.COMMENT_IGNORE_END = 32] = "COMMENT_IGNORE_END", NodeType2[NodeType2.COMMENT_ISLAND_START = 65] = "COMMENT_ISLAND_START", NodeType2[NodeType2.COMMENT_ISLAND_END = 128] = "COMMENT_ISLAND_END", NodeType2[NodeType2.OTHER = 0] = "OTHER";
+  }(NodeType || (NodeType = {}));
+  const getFastNodeType = (node) => {
+    const nodeType = getNodeType.call(node);
+    if (1 === nodeType) {
+      if (null === getAttribute.call(node, "q:container")) {
+        if (hasAttribute.call(node, "q:shadowroot")) {
+          return NodeType.ELEMENT_SHADOW_ROOT;
+        }
+        return hasAttribute.call(node, ":") ? NodeType.ELEMENT : NodeType.OTHER;
+      }
+      return NodeType.ELEMENT_CONTAINER;
+    }
+    if (8 === nodeType) {
+      const nodeValue = node.nodeValue || "";
+      if (nodeValue.startsWith("q:container-island")) {
+        return NodeType.COMMENT_ISLAND_START;
+      }
+      if (nodeValue.startsWith("q:ignore")) {
+        return NodeType.COMMENT_IGNORE_START;
+      }
+      if (nodeValue.startsWith("q:container")) {
+        return NodeType.COMMENT_SKIP_START;
+      }
+      if (nodeValue.startsWith("/q:container-island")) {
+        return NodeType.COMMENT_ISLAND_END;
+      }
+      if (nodeValue.startsWith("/q:ignore")) {
+        return NodeType.COMMENT_IGNORE_END;
+      }
+      if (nodeValue.startsWith("/q:container")) {
+        return NodeType.COMMENT_SKIP_END;
+      }
+    }
+    return NodeType.OTHER;
+  };
+  const isSeparator = (ch) => VNodeDataSeparator.ADVANCE_1 <= ch && ch <= VNodeDataSeparator.ADVANCE_8192;
+  const findVDataSectionEnd = (vData, start, end) => {
+    let depth = 0;
+    for (; start < end; ) {
+      const ch = vData.charCodeAt(start);
+      if (0 === depth && isSeparator(ch)) {
+        break;
+      }
+      ch === VNodeDataChar.OPEN ? depth++ : ch === VNodeDataChar.CLOSE && depth--, start++;
+    }
+    return start;
+  };
+  const nextSibling = (node) => {
+    for (; node && (node = node.nextSibling) && getFastNodeType(node) === NodeType.OTHER; ) {
+    }
+    return node;
+  };
+  const firstChild = (node) => {
+    for (; node && (node = node.firstChild) && getFastNodeType(node) === NodeType.OTHER; ) {
+    }
+    return node;
+  };
+  const walkContainer = (walker2, containerNode, node, exitNode, vData, qVNodeRefs) => {
+    const vData_length = vData.length;
+    let elementIdx = 0;
+    let vNodeElementIndex = -1;
+    let vData_start = 0;
+    let vData_end = 0;
+    let ch = 0;
+    let needsToStoreRef = -1;
+    let nextNode = null;
+    const howManyElementsToSkip = () => {
+      let elementsToSkip = 0;
+      for (; isSeparator(ch = vData.charCodeAt(vData_start)) && (elementsToSkip += 1 << ch - VNodeDataSeparator.ADVANCE_1, vData_start++, !(vData_start >= vData_length)); ) {
+      }
+      return elementsToSkip;
+    };
+    do {
+      if (node === exitNode) {
+        return;
+      }
+      nextNode = null;
+      const nodeType = node == containerNode ? NodeType.ELEMENT : getFastNodeType(node);
+      if (nodeType === NodeType.ELEMENT_CONTAINER) {
+        const container = node;
+        let cursor = node;
+        for (; cursor && !(nextNode = nextSibling(cursor)); ) {
+          cursor = cursor.parentNode;
+        }
+        walkContainer(walker2, container, node, nextNode, container.qVnodeData || "", container.qVNodeRefs);
+      } else if (nodeType === NodeType.COMMENT_IGNORE_START) {
+        let islandNode = node;
+        do {
+          if (islandNode = walker2.nextNode(), !islandNode) {
+            throw new Error(`Island inside <!--${node?.nodeValue}--> not found!`);
+          }
+        } while (getFastNodeType(islandNode) !== NodeType.COMMENT_ISLAND_START);
+        nextNode = null;
+      } else if (nodeType === NodeType.COMMENT_ISLAND_END) {
+        nextNode = node;
+        do {
+          if (nextNode = walker2.nextNode(), !nextNode) {
+            throw new Error("Ignore block not closed!");
+          }
+        } while (getFastNodeType(nextNode) !== NodeType.COMMENT_IGNORE_END);
+        nextNode = null;
+      } else if (nodeType === NodeType.COMMENT_SKIP_START) {
+        nextNode = node;
+        do {
+          if (nextNode = nextSibling(nextNode), !nextNode) {
+            throw new Error(`<!--${node?.nodeValue}--> not closed!`);
+          }
+        } while (getFastNodeType(nextNode) !== NodeType.COMMENT_SKIP_END);
+        walkContainer(walker2, node, node, nextNode, "", null);
+      } else if (nodeType === NodeType.ELEMENT_SHADOW_ROOT) {
+        nextNode = nextSibling(node);
+        const shadowRootContainer = node;
+        const shadowRoot = shadowRootContainer?.shadowRoot;
+        shadowRoot && walkContainer(document2.createTreeWalker(shadowRoot, 129), null, firstChild(shadowRoot), null, "", null);
+      }
+      if ((nodeType & NodeType.ELEMENT) === NodeType.ELEMENT) {
+        if (vNodeElementIndex < elementIdx) {
+          if (-1 === vNodeElementIndex && (vNodeElementIndex = 0), vData_start = vData_end, vData_start < vData_length) {
+            vNodeElementIndex += howManyElementsToSkip();
+            ch === VNodeDataSeparator.REFERENCE && (needsToStoreRef = vNodeElementIndex, vData_start++, ch = vData_start < vData_length ? vData.charCodeAt(vData_end) : VNodeDataSeparator.ADVANCE_1), vData_end = findVDataSectionEnd(vData, vData_start, vData_length);
+          } else {
+            vNodeElementIndex = Number.MAX_SAFE_INTEGER;
+          }
+        }
+        if (elementIdx === vNodeElementIndex) {
+          needsToStoreRef === elementIdx && qVNodeRefs.set(elementIdx, node);
+          const instructions = vData.substring(vData_start, vData_end);
+          vNodeDataMap.set(node, instructions);
+        }
+        elementIdx++;
+      }
+    } while (node = nextNode || walker2.nextNode());
+  };
+  const walker = document2.createTreeWalker(document2, 129);
+  walkContainer(walker, null, walker.firstChild(), null, "", null);
+}
+function getDomContainer(element) {
+  const qContainerElement = _getQContainerElement(element);
+  if (!qContainerElement) {
+    throw qError(QError.containerNotFound);
+  }
+  return getDomContainerFromQContainerElement(qContainerElement);
+}
+function getDomContainerFromQContainerElement(qContainerElement) {
+  const qElement = qContainerElement;
+  let container = qElement.qContainer;
+  if (!container) {
+    container = new DomContainer(qElement);
+    const containerAttributes = {};
+    if (qElement) {
+      const attrs = qElement.attributes;
+      if (attrs) {
+        for (let index = 0; index < attrs.length; index++) {
+          const attr = attrs[index];
+          ":" !== attr.name && (containerAttributes[attr.name] = attr.value);
+        }
+      }
+    }
+    container.$serverData$ = {
+      containerAttributes
+    }, qElement.setAttribute("q:container", QContainerValue.RESUMED), qElement.qContainer = container;
+  }
+  return container;
+}
+function _getQContainerElement(element) {
+  return (Array.isArray(element) ? vnode_getDomParent(element) : element).closest(QContainerSelector);
+}
+const isDomContainer = (container) => container instanceof DomContainer;
+class DomContainer extends _SharedContainer {
+  constructor(element) {
+    super(() => this.scheduleRender(), () => vnode_applyJournal(this.$journal$), {}, element.getAttribute("q:locale"));
+    __publicField(this, "element");
+    __publicField(this, "qContainer");
+    __publicField(this, "qBase");
+    __publicField(this, "qManifestHash");
+    __publicField(this, "rootVNode");
+    __publicField(this, "document");
+    __publicField(this, "$journal$");
+    __publicField(this, "renderDone", null);
+    __publicField(this, "$rawStateData$");
+    __publicField(this, "$storeProxyMap$", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "$qFuncs$");
+    __publicField(this, "$instanceHash$");
+    __publicField(this, "vNodeLocate", (id) => vnode_locate(this.rootVNode, id));
+    __publicField(this, "$stateData$");
+    __publicField(this, "$styleIds$", null);
+    __publicField(this, "$renderCount$", 0);
+    __publicField(this, "$getObjectById$", (id) => ("string" == typeof id && (id = parseFloat(id)), assertTrue(id < this.$rawStateData$.length / 2, `Invalid reference: ${id} >= ${this.$rawStateData$.length / 2}`), this.$stateData$[id]));
+    if (this.qContainer = element.getAttribute("q:container"), !this.qContainer) {
+      throw qError(QError.elementWithoutContainer);
+    }
+    this.$journal$ = [VNodeJournalOpCode.HoistStyles, element.ownerDocument], this.document = element.ownerDocument, this.element = element, this.qBase = element.getAttribute("q:base"), this.$instanceHash$ = element.getAttribute("q:instance"), this.qManifestHash = element.getAttribute("q:manifest-hash"), this.rootVNode = vnode_newUnMaterializedElement(this.element), this.$rawStateData$ = null, this.$stateData$ = null;
+    const document2 = this.element.ownerDocument;
+    document2.qVNodeData || processVNodeData(document2), this.$rawStateData$ = [], this.$stateData$ = [];
+    const qwikStates = element.querySelectorAll('script[type="qwik/state"]');
+    if (0 !== qwikStates.length) {
+      this.$rawStateData$ = JSON.parse(qwikStates[qwikStates.length - 1].textContent), this.$stateData$ = wrapDeserializerProxy(this, this.$rawStateData$);
+    }
+    this.$qFuncs$ = getQFuncs(document2, this.$instanceHash$) || EMPTY_ARRAY;
+  }
+  $setRawState$(id, vParent) {
+    this.$stateData$[id] = vParent;
+  }
+  parseQRL(qrl2) {
+    return inflateQRL(this, parseQRL(qrl2));
+  }
+  handleError(err, host) {
+    const errorStore = host && this.resolveContext(host, ERROR_CONTEXT);
+    if (!errorStore) {
+      throw err;
+    }
+    errorStore.error = err;
+  }
+  setContext(host, context, value) {
+    let ctx = this.getHostProp(host, "q:ctx");
+    ctx || this.setHostProp(host, "q:ctx", ctx = []), mapArray_set(ctx, context.id, value, 0);
+  }
+  resolveContext(host, contextId) {
+    for (; host; ) {
+      const ctx = this.getHostProp(host, "q:ctx");
+      if (ctx) {
+        const value = mapArray_get(ctx, contextId.id, 0);
+        if (value) {
+          return value;
+        }
+      }
+      host = this.getParentHost(host);
+    }
+  }
+  getParentHost(host) {
+    let vNode = vnode_getParent(host);
+    for (; vNode; ) {
+      if (vnode_isVirtualVNode(vNode)) {
+        if (null !== vnode_getProp(vNode, "q:renderFn", null)) {
+          return vNode;
+        }
+        vNode = vnode_getParent(vNode) || vnode_getProp(vNode, ":", this.vNodeLocate);
+      } else {
+        vNode = vnode_getParent(vNode);
+      }
+    }
+    return null;
+  }
+  setHostProp(host, name, value) {
+    vnode_setProp(host, name, value);
+  }
+  getHostProp(host, name) {
+    const vNode = host;
+    let getObjectById2 = null;
+    switch (name) {
+      case "q:seq":
+      case "q:props":
+      case "q:renderFn":
+      case "q:ctx":
+      case "q:brefs":
+        getObjectById2 = this.$getObjectById$;
+        break;
+      case "q:seqIdx":
+      case ":onIdx":
+        getObjectById2 = parseInt;
+    }
+    return vnode_getProp(vNode, name, getObjectById2);
+  }
+  scheduleRender() {
+    return this.$renderCount$++, this.renderDone || (this.renderDone = getPlatform().nextTick(() => this.processChores())), this.renderDone.finally(() => emitEvent("qrender", {
+      instanceHash: this.$instanceHash$,
+      renderCount: this.$renderCount$
+    }));
+  }
+  processChores() {
+    let renderCount = this.$renderCount$;
+    const result = this.$scheduler$(ChoreType.WAIT_FOR_ALL);
+    if (isPromise(result)) {
+      return result.then(async () => {
+        for (; renderCount !== this.$renderCount$; ) {
+          renderCount = this.$renderCount$, await this.$scheduler$(ChoreType.WAIT_FOR_ALL);
+        }
+        this.renderDone = null;
+      });
+    }
+    renderCount === this.$renderCount$ ? this.renderDone = null : this.processChores();
+  }
+  ensureProjectionResolved(vNode) {
+    if (!(vNode[VNodeProps.flags] & VNodeFlags.Resolved)) {
+      vNode[VNodeProps.flags] |= VNodeFlags.Resolved;
+      const props = vnode_getProps(vNode);
+      for (let i = 0; i < props.length; i += 2) {
+        if (isSlotProp(props[i])) {
+          const value = props[i + 1];
+          "string" == typeof value && (props[i + 1] = this.vNodeLocate(value));
+        }
+      }
+    }
+  }
+  getSyncFn(id) {
+    const fn = this.$qFuncs$[id];
+    return fn;
+  }
+  $appendStyle$(content, styleId, host, scoped) {
+    if (scoped) {
+      const scopedStyleIdsString = this.getHostProp(host, "q:sstyle");
+      const scopedStyleIds = new Set(convertScopedStyleIdsToArray(scopedStyleIdsString));
+      scopedStyleIds.add(styleId), this.setHostProp(host, "q:sstyle", convertStyleIdsToString(scopedStyleIds));
+    }
+    if (null == this.$styleIds$ && (this.$styleIds$ = /* @__PURE__ */ new Set(), this.element.querySelectorAll(QStyleSelector).forEach((style) => {
+      this.$styleIds$.add(style.getAttribute(QStyle));
+    })), !this.$styleIds$.has(styleId)) {
+      this.$styleIds$.add(styleId);
+      const styleElement = this.document.createElement("style");
+      styleElement.setAttribute(QStyle, styleId), styleElement.textContent = content, this.$journal$.push(VNodeJournalOpCode.Insert, this.document.head, null, styleElement);
+    }
+  }
+}
+const deserializedProxyMap = /* @__PURE__ */ new WeakMap();
+const isDeserializerProxy = (value) => "object" == typeof value && null !== value && SERIALIZER_PROXY_UNWRAP in value;
+const SERIALIZER_PROXY_UNWRAP = Symbol("UNWRAP");
+const wrapDeserializerProxy = (container, data) => {
+  if (!Array.isArray(data) || vnode_isVNode(data) || isDeserializerProxy(data)) {
+    return data;
+  }
+  let proxy = deserializedProxyMap.get(data);
+  if (!proxy) {
+    const target = Array(data.length / 2).fill(void 0);
+    proxy = new Proxy(target, new DeserializationHandler(container, data)), deserializedProxyMap.set(data, proxy);
+  }
+  return proxy;
+};
+class DeserializationHandler {
+  constructor($container$, $data$) {
+    __publicField(this, "$container$");
+    __publicField(this, "$data$");
+    __publicField(this, "$length$");
+    this.$container$ = $container$, this.$data$ = $data$, this.$length$ = this.$data$.length / 2;
+  }
+  get(target, property, receiver) {
+    if (property === SERIALIZER_PROXY_UNWRAP) {
+      return target;
+    }
+    const i = "number" == typeof property ? property : "string" == typeof property ? parseInt(property, 10) : NaN;
+    if (Number.isNaN(i) || i < 0 || i >= this.$length$) {
+      return Reflect.get(target, property, receiver);
+    }
+    const idx = 2 * i;
+    const typeId = this.$data$[idx];
+    const value = this.$data$[idx + 1];
+    if (void 0 === typeId) {
+      return value;
+    }
+    const container = this.$container$;
+    let propValue = allocate(container, typeId, value);
+    return typeId >= TypeIds.Error && (propValue = inflate(container, propValue, typeId, value)), Reflect.set(target, property, propValue), this.$data$[idx] = void 0, this.$data$[idx + 1] = propValue, propValue;
+  }
+  has(target, property) {
+    return property === SERIALIZER_PROXY_UNWRAP || Object.prototype.hasOwnProperty.call(target, property);
+  }
+  set(target, property, value, receiver) {
+    if (property === SERIALIZER_PROXY_UNWRAP) {
+      return false;
+    }
+    const out = Reflect.set(target, property, value, receiver);
+    const i = "number" == typeof property ? property : parseInt(property, 10);
+    if (Number.isNaN(i) || i < 0 || i >= this.$data$.length / 2) {
+      return out;
+    }
+    const idx = 2 * i;
+    return this.$data$[idx] = void 0, this.$data$[idx + 1] = value, true;
+  }
+}
+const _eagerDeserializeArray = (container, data) => {
+  const out = Array(data.length / 2);
+  for (let i = 0; i < data.length; i += 2) {
+    out[i / 2] = deserializeData(container, data[i], data[i + 1]);
+  }
+  return out;
+};
+const resolvers = /* @__PURE__ */ new WeakMap();
+const inflate = (container, target, typeId, data) => {
+  if (void 0 === typeId) {
+    return target;
+  }
+  switch (typeId !== TypeIds.Object && Array.isArray(data) && (data = _eagerDeserializeArray(container, data)), typeId) {
+    case TypeIds.Object:
+      for (let i2 = 0; i2 < data.length; i2 += 4) {
+        const key = deserializeData(container, data[i2], data[i2 + 1]);
+        const valType = data[i2 + 2];
+        const valData = data[i2 + 3];
+        valType === TypeIds.RootRef || valType >= TypeIds.Error ? Object.defineProperty(target, key, {
+          get() {
+            const value = deserializeData(container, valType, valData);
+            return target[key] = value, value;
+          },
+          set(value) {
+            Object.defineProperty(target, key, {
+              value,
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+          },
+          enumerable: true,
+          configurable: true
+        }) : target[key] = deserializeData(container, valType, valData);
+      }
+      break;
+    case TypeIds.QRL:
+      inflateQRL(container, target);
+      break;
+    case TypeIds.Task:
+      const task = target;
+      const v = data;
+      task.$qrl$ = inflateQRL(container, v[0]), task.$flags$ = v[1], task.$index$ = v[2], task.$el$ = v[3], task[_EFFECT_BACK_REF] = v[4], task.$state$ = v[5];
+      break;
+    case TypeIds.Resource:
+      const [resolved, result, effects] = data;
+      const resource = target;
+      resolved ? (resource.value = Promise.resolve(result), resource._resolved = result, resource._state = "resolved") : (resource.value = Promise.reject(result), resource._error = result, resource._state = "rejected"), getStoreHandler(target).$effects$ = effects;
+      break;
+    case TypeIds.Component:
+      target[SERIALIZABLE_STATE][0] = data[0];
+      break;
+    case TypeIds.Store:
+    case TypeIds.StoreArray: {
+      const [value, flags, effects2] = data;
+      const store = getOrCreateStore(value, flags, container);
+      getStoreHandler(store).$effects$ = effects2, target = store;
+      break;
+    }
+    case TypeIds.Signal: {
+      const signal = target;
+      const d = data;
+      signal.$untrackedValue$ = d[0], signal.$effects$ = new Set(d.slice(1));
+      break;
+    }
+    case TypeIds.WrappedSignal: {
+      const signal = target;
+      const d = data;
+      signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal[_EFFECT_BACK_REF] = d[2], signal.$untrackedValue$ = d[3], signal.$hostElement$ = d[4], signal.$effects$ = new Set(d.slice(5));
+      break;
+    }
+    case TypeIds.ComputedSignal: {
+      const computed = target;
+      const d = data;
+      computed.$computeQrl$ = d[0], computed.$effects$ = d[1], 3 === d.length ? computed.$untrackedValue$ = d[2] : (computed.$invalid$ = true, computed.$computeQrl$.resolve(), container.$scheduler$?.(ChoreType.QRL_RESOLVE, null, computed.$computeQrl$));
+      break;
+    }
+    case TypeIds.Error: {
+      const d = data;
+      target.message = d[0];
+      const second = d[1];
+      if (second && Array.isArray(second)) {
+        for (let i2 = 0; i2 < second.length; i2++) {
+          target[second[i2++]] = d[i2];
+        }
+        target.stack = d[2];
+      } else {
+        target.stack = second;
+      }
+      break;
+    }
+    case TypeIds.FormData: {
+      const formData = target;
+      const d = data;
+      for (let i2 = 0; i2 < d.length; i2++) {
+        formData.append(d[i2++], d[i2]);
+      }
+      break;
+    }
+    case TypeIds.JSXNode: {
+      const jsx2 = target;
+      const [type, varProps, constProps, children, flags, key] = data;
+      jsx2.type = type, jsx2.varProps = varProps, jsx2.constProps = constProps, jsx2.children = children, jsx2.flags = flags, jsx2.key = key;
+      break;
+    }
+    case TypeIds.Set: {
+      const set = target;
+      const d = data;
+      for (let i2 = 0; i2 < d.length; i2++) {
+        set.add(d[i2]);
+      }
+      break;
+    }
+    case TypeIds.Map: {
+      const map = target;
+      const d = data;
+      for (let i2 = 0; i2 < d.length; i2++) {
+        map.set(d[i2++], d[i2]);
+      }
+      break;
+    }
+    case TypeIds.Promise: {
+      const promise = target;
+      const [resolved2, result2] = data;
+      const [resolve, reject] = resolvers.get(promise);
+      resolved2 ? resolve(result2) : reject(result2);
+      break;
+    }
+    case TypeIds.Uint8Array:
+      const bytes = target;
+      const buf = atob(data);
+      let i = 0;
+      for (const s of buf) {
+        bytes[i++] = s.charCodeAt(0);
+      }
+      break;
+    case TypeIds.PropsProxy:
+      const propsProxy = target;
+      propsProxy[_VAR_PROPS] = 0 === data ? {} : data[0], propsProxy[_CONST_PROPS] = data[1];
+      break;
+    case TypeIds.EffectData: {
+      const effectData = target;
+      effectData.data.$scopedStyleIdPrefix$ = data[0], effectData.data.$isConst$ = data[1];
+      break;
+    }
+    default:
+      throw qError(QError.serializeErrorNotImplemented, [typeId]);
+  }
+  return target;
+};
+const _constants = [void 0, null, true, false, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COMPUTATION, STORE_ARRAY_PROP, Slot, Fragment, NaN, 1 / 0, -1 / 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER - 1, Number.MIN_SAFE_INTEGER];
+const allocate = (container, typeId, value) => {
+  if (void 0 === value) {
+    return typeId;
+  }
+  switch (typeId) {
+    case TypeIds.RootRef:
+      return container.$getObjectById$(value);
+    case TypeIds.Constant:
+      return _constants[value];
+    case TypeIds.Number:
+      return value;
+    case TypeIds.Array:
+      return wrapDeserializerProxy(container, value);
+    case TypeIds.Object:
+      return {};
+    case TypeIds.QRL:
+      return parseQRL(container.$getObjectById$(value));
+    case TypeIds.Task:
+      return new Task(-1, -1, null, null, null, null);
+    case TypeIds.Resource: {
+      const res = createResourceReturn(container, void 0, void 0);
+      return res.loading = false, res;
+    }
+    case TypeIds.URL:
+      return new URL(value);
+    case TypeIds.Date:
+      return new Date(value);
+    case TypeIds.Regex:
+      const idx = value.lastIndexOf("/");
+      return new RegExp(value.slice(1, idx), value.slice(idx + 1));
+    case TypeIds.Error:
+      return new Error();
+    case TypeIds.Component:
+      return componentQrl(null);
+    case TypeIds.Signal:
+      return new Signal(container, 0);
+    case TypeIds.WrappedSignal:
+      return new WrappedSignal(container, null, null, null);
+    case TypeIds.ComputedSignal:
+      return new ComputedSignal(container, null);
+    case TypeIds.Store:
+    case TypeIds.StoreArray:
+      return null;
+    case TypeIds.URLSearchParams:
+      return new URLSearchParams(value);
+    case TypeIds.FormData:
+      return new FormData();
+    case TypeIds.JSXNode:
+      return new JSXNodeImpl(null, null, null, null, -1, null);
+    case TypeIds.BigInt:
+      return BigInt(value);
+    case TypeIds.Set:
+      return /* @__PURE__ */ new Set();
+    case TypeIds.Map:
+      return /* @__PURE__ */ new Map();
+    case TypeIds.String:
+      return value;
+    case TypeIds.Promise:
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res, reject = rej;
+      });
+      return resolvers.set(promise, [resolve, reject]), promise.catch(() => {
+      }), promise;
+    case TypeIds.Uint8Array:
+      const encodedLength = value.length;
+      const rest = 3 & encodedLength;
+      return new Uint8Array(3 * (encodedLength >>> 2) + (rest ? rest - 1 : 0));
+    case TypeIds.PropsProxy:
+      return createPropsProxy(null, null);
+    case TypeIds.VNode:
+      return retrieveVNodeOrDocument(container, value);
+    case TypeIds.RefVNode:
+      const vNode = retrieveVNodeOrDocument(container, value);
+      if (vnode_isVNode(vNode)) {
+        return vnode_getNode(vNode);
+      }
+      throw qError(QError.serializeErrorExpectedVNode, [typeof vNode]);
+    case TypeIds.EffectData:
+      return new SubscriptionData({});
+    default:
+      throw qError(QError.serializeErrorCannotAllocate, [typeId]);
+  }
+};
+function retrieveVNodeOrDocument(container, value) {
+  return value ? container.rootVNode ? vnode_locate(container.rootVNode, value) : void 0 : container.element?.ownerDocument;
+}
+function parseQRL(qrl2) {
+  const hashIdx = qrl2.indexOf("#");
+  const captureStart = qrl2.indexOf("[", hashIdx);
+  const captureEnd = qrl2.indexOf("]", captureStart);
+  const chunk = qrl2.slice(0, hashIdx > -1 ? hashIdx : captureStart);
+  const symbol = captureStart > -1 ? qrl2.slice(hashIdx + 1, captureStart) : qrl2.slice(hashIdx + 1);
+  const captureIds = captureStart > -1 && captureEnd > -1 ? qrl2.slice(captureStart + 1, captureEnd).split(" ").filter((v) => v.length).map((s) => parseInt(s, 10)) : null;
+  let qrlRef = null;
+  if (chunk === QRL_RUNTIME_CHUNK) {
+    const backChannel = globalThis[QRL_RUNTIME_CHUNK];
+    qrlRef = backChannel.get(symbol);
+  }
+  return createQRL(chunk, symbol, qrlRef, null, captureIds, null);
+}
+function inflateQRL(container, qrl2) {
+  const captureIds = qrl2.$capture$;
+  return qrl2.$captureRef$ = captureIds ? captureIds.map((id) => container.$getObjectById$(id)) : null, container.element && qrl2.$setContainer$(container.element), qrl2;
+}
+let isDomRef = () => false;
+const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolToChunkResolver, getProp2, setProp, storeProxyMap, writer, prepVNodeData) => {
+  if (!writer) {
+    const buffer = [];
+    writer = {
+      write: (text) => buffer.push(text),
+      toString: () => buffer.join("")
+    };
+  }
+  const map = /* @__PURE__ */ new Map();
+  const syncFnMap = /* @__PURE__ */ new Map();
+  const syncFns = [];
+  const roots = [];
+  const $wasSeen$ = (obj) => map.get(obj);
+  const $seen$ = (obj) => map.set(obj, -1);
+  const $addRoot$ = (obj) => {
+    let id = map.get(obj);
+    return "number" == typeof id && -1 !== id || (id = roots.length, map.set(obj, id), roots.push(obj)), id;
+  };
+  const isSsrNode2 = NodeConstructor ? (obj) => obj instanceof NodeConstructor : () => false;
+  return isDomRef = DomRefConstructor ? (obj) => obj instanceof DomRefConstructor : () => false, {
+    $serialize$() {
+      serialize(this);
+    },
+    $isSsrNode$: isSsrNode2,
+    $isDomRef$: isDomRef,
+    $symbolToChunkResolver$: symbolToChunkResolver,
+    $wasSeen$,
+    $roots$: roots,
+    $seen$,
+    $hasRootId$: (obj) => {
+      const id = map.get(obj);
+      return void 0 === id || -1 === id ? void 0 : id;
+    },
+    $addRoot$,
+    $getRootId$: (obj) => {
+      const id = map.get(obj);
+      if (!id || -1 === id) {
+        throw qError(QError.serializeErrorMissingRootId, [obj]);
+      }
+      return id;
+    },
+    $syncFns$: syncFns,
+    $addSyncFn$: (funcStr, argCount, fn) => {
+      const isFullFn = null == funcStr;
+      isFullFn && (funcStr = fn.serialized || fn.toString());
+      let id = syncFnMap.get(funcStr);
+      if (void 0 === id) {
+        if (id = syncFns.length, syncFnMap.set(funcStr, id), isFullFn) {
+          syncFns.push(funcStr);
+        } else {
+          let code = "(";
+          for (let i = 0; i < argCount; i++) {
+            code += (0 == i ? "p" : ",p") + i;
+          }
+          syncFns.push(code += ")=>" + funcStr);
+        }
+      }
+      return id;
+    },
+    $writer$: writer,
+    $breakCircularDepsAndAwaitPromises$: async function() {
+      const discoveredValues = [];
+      const promises = [];
+      const visit = (obj) => {
+        if ("function" == typeof obj) {
+          if (isQrl$1(obj)) {
+            obj.$captureRef$ && discoveredValues.push(...obj.$captureRef$);
+          } else if (isQwikComponent(obj)) {
+            const [qrl2] = obj[SERIALIZABLE_STATE];
+            discoveredValues.push(qrl2);
+          }
+        } else if ("object" != typeof obj || null === obj || obj instanceof URL || obj instanceof Date || obj instanceof RegExp || obj instanceof Uint8Array || obj instanceof URLSearchParams || vnode_isVNode(obj) || "undefined" != typeof FormData && obj instanceof FormData || fastSkipSerialize(obj)) ;
+        else if (obj instanceof Error) {
+          discoveredValues.push(...Object.values(obj));
+        } else if (isStore(obj)) {
+          const target = getStoreTarget(obj);
+          const effects = getStoreHandler(obj).$effects$;
+          discoveredValues.push(target, effects);
+          for (const prop in target) {
+            const propValue = target[prop];
+            storeProxyMap.has(propValue) && discoveredValues.push(prop, storeProxyMap.get(propValue));
+          }
+        } else if (obj instanceof Set) {
+          discoveredValues.push(...obj.values());
+        } else if (obj instanceof Map) {
+          obj.forEach((v, k) => {
+            discoveredValues.push(k, v);
+          });
+        } else if (obj instanceof Signal) {
+          const v = obj instanceof WrappedSignal ? obj.untrackedValue : obj instanceof ComputedSignal && (obj.$invalid$ || fastSkipSerialize(obj)) ? NEEDS_COMPUTATION : obj.$untrackedValue$;
+          v !== NEEDS_COMPUTATION && discoveredValues.push(v), obj.$effects$ && discoveredValues.push(...obj.$effects$), obj instanceof WrappedSignal ? (discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues), obj.$args$ && discoveredValues.push(...obj.$args$), obj.$hostElement$ && discoveredValues.push(obj.$hostElement$)) : obj instanceof ComputedSignal && discoveredValues.push(obj.$computeQrl$);
+        } else if (obj instanceof Task) {
+          discoveredValues.push(obj.$el$, obj.$qrl$, obj.$state$), discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues);
+        } else if (isSsrNode2(obj)) {
+          if (discoverValuesForVNodeData(obj.vnodeData, discoveredValues), obj.childrenVNodeData && obj.childrenVNodeData.length) {
+            for (const data of obj.childrenVNodeData) {
+              discoverValuesForVNodeData(data, discoveredValues);
+            }
+          }
+        } else if (isDomRef(obj)) {
+          discoveredValues.push(obj.$ssrNode$.id);
+        } else if (isJSXNode(obj)) {
+          discoveredValues.push(obj.type, obj.props, obj.constProps, obj.children);
+        } else if (Array.isArray(obj)) {
+          discoveredValues.push(...obj);
+        } else if (isQrl$1(obj)) {
+          obj.$captureRef$ && obj.$captureRef$.length && discoveredValues.push(...obj.$captureRef$);
+        } else if (isPropsProxy(obj)) {
+          discoveredValues.push(obj[_VAR_PROPS], obj[_CONST_PROPS]);
+        } else if (isPromise(obj)) {
+          obj.then((value) => {
+            promiseResults.set(obj, [true, value]), discoveredValues.push(value);
+          }, (error) => {
+            promiseResults.set(obj, [false, error]), discoveredValues.push(error);
+          }), promises.push(obj);
+        } else if (obj instanceof SubscriptionData) {
+          discoveredValues.push(obj.data);
+        } else {
+          if (!isObjectLiteral(obj)) {
+            throw qError(QError.serializeErrorUnknownType, [obj]);
+          }
+          Object.entries(obj).forEach(([key, value]) => {
+            discoveredValues.push(key, value);
+          });
+        }
+      };
+      for (const root of roots) {
+        visit(root);
+      }
+      do {
+        for (; discoveredValues.length; ) {
+          const obj = discoveredValues.pop();
+          if (!shouldTrackObj(obj) && !frameworkType(obj)) {
+            continue;
+          }
+          const id = $wasSeen$(obj);
+          void 0 === id ? ($seen$(obj), visit(obj)) : -1 === id && $addRoot$(obj);
+        }
+        await Promise.allSettled(promises), promises.length = 0;
+      } while (discoveredValues.length);
+    },
+    $eventQrls$: /* @__PURE__ */ new Set(),
+    $eventNames$: /* @__PURE__ */ new Set(),
+    $resources$: /* @__PURE__ */ new Set(),
+    $renderSymbols$: /* @__PURE__ */ new Set(),
+    $storeProxyMap$: storeProxyMap,
+    $getProp$: getProp2,
+    $setProp$: setProp,
+    $prepVNodeData$: prepVNodeData
+  };
+};
+const isSsrAttrs = (value) => Array.isArray(value) && value.length > 0;
+const discoverValuesForVNodeData = (vnodeData, discoveredValues) => {
+  for (const value of vnodeData) {
+    if (isSsrAttrs(value)) {
+      for (let i = 1; i < value.length; i += 2) {
+        const attrValue = value[i];
+        "string" != typeof attrValue && discoveredValues.push(attrValue);
+      }
+    }
+  }
+};
+const discoverEffectBackRefs = (effectsBackRefs, discoveredValues) => {
+  if (effectsBackRefs) {
+    let hasBackRefs = false;
+    for (const [, effect] of effectsBackRefs) {
+      if (effect[EffectSubscriptionProp.BACK_REF]) {
+        hasBackRefs = true;
+        break;
+      }
+    }
+    hasBackRefs && discoveredValues.push(effectsBackRefs);
+  }
+};
+const promiseResults = /* @__PURE__ */ new WeakMap();
+function serialize(serializationContext) {
+  const { $writer$, $isSsrNode$, $isDomRef$, $setProp$, $storeProxyMap$ } = serializationContext;
+  let depth = -1;
+  let writeType = false;
+  const output = (type, value) => {
+    if (writeType ? $writer$.write(`${type},`) : writeType = true, "number" == typeof value) {
+      $writer$.write(value.toString());
+    } else if ("string" == typeof value) {
+      const s = JSON.stringify(value);
+      let angleBracketIdx = -1;
+      let lastIdx = 0;
+      for (; -1 !== (angleBracketIdx = s.indexOf("</", lastIdx)); ) {
+        $writer$.write(s.slice(lastIdx, angleBracketIdx)), $writer$.write("<\\/"), lastIdx = angleBracketIdx + 2;
+      }
+      $writer$.write(0 === lastIdx ? s : s.slice(lastIdx));
+    } else {
+      depth++, $writer$.write("[");
+      let separator = false;
+      for (let i = 0; i < value.length; i++) {
+        separator ? $writer$.write(",") : separator = true, writeValue(value[i], i);
+      }
+      $writer$.write("]"), depth--;
+    }
+  };
+  const writeValue = (value, idx) => {
+    if (fastSkipSerialize(value)) {
+      output(TypeIds.Constant, Constants.Undefined);
+    } else if ("bigint" == typeof value) {
+      output(TypeIds.BigInt, value.toString());
+    } else if ("boolean" == typeof value) {
+      output(TypeIds.Constant, value ? Constants.True : Constants.False);
+    } else if ("function" == typeof value) {
+      if (value === Slot) {
+        output(TypeIds.Constant, Constants.Slot);
+      } else if (value === Fragment) {
+        output(TypeIds.Constant, Constants.Fragment);
+      } else if (isQrl$1(value)) {
+        const qrl2 = qrlToString(serializationContext, value);
+        const id = serializationContext.$addRoot$(qrl2);
+        output(TypeIds.QRL, id);
+      } else if (isQwikComponent(value)) {
+        const [qrl2] = value[SERIALIZABLE_STATE];
+        serializationContext.$renderSymbols$.add(qrl2.$symbol$), output(TypeIds.Component, [qrl2]);
+      } else {
+        console.error("Cannot serialize function (ignoring for now): " + value.toString()), output(TypeIds.Constant, Constants.Undefined);
+      }
+    } else if ("number" == typeof value) {
+      Number.isNaN(value) ? output(TypeIds.Constant, Constants.NaN) : Number.isFinite(value) ? value === Number.MAX_SAFE_INTEGER ? output(TypeIds.Constant, Constants.MaxSafeInt) : value === Number.MAX_SAFE_INTEGER - 1 ? output(TypeIds.Constant, Constants.AlmostMaxSafeInt) : value === Number.MIN_SAFE_INTEGER ? output(TypeIds.Constant, Constants.MinSafeInt) : output(TypeIds.Number, value) : output(TypeIds.Constant, value < 0 ? Constants.NegativeInfinity : Constants.PositiveInfinity);
+    } else if ("object" == typeof value) {
+      value === EMPTY_ARRAY ? output(TypeIds.Constant, Constants.EMPTY_ARRAY) : value === EMPTY_OBJ ? output(TypeIds.Constant, Constants.EMPTY_OBJ) : (depth++, null === value ? output(TypeIds.Constant, Constants.Null) : writeObjectValue(value, idx), depth--);
+    } else if ("string" == typeof value) {
+      if (0 === value.length) {
+        output(TypeIds.Constant, Constants.EmptyString);
+      } else {
+        const seen = depth > 1 && serializationContext.$wasSeen$(value);
+        "number" == typeof seen && seen >= 0 ? output(TypeIds.RootRef, seen) : output(TypeIds.String, value);
+      }
+    } else if (void 0 === value) {
+      output(TypeIds.Constant, Constants.Undefined);
+    } else if (value === NEEDS_COMPUTATION) {
+      output(TypeIds.Constant, Constants.NEEDS_COMPUTATION);
+    } else {
+      if (value !== STORE_ARRAY_PROP) {
+        throw qError(QError.serializeErrorUnknownType, [typeof value]);
+      }
+      output(TypeIds.Constant, Constants.STORE_ARRAY_PROP);
+    }
+  };
+  const writeObjectValue = (value, idx) => {
+    const isRootObject = 2 === depth;
+    if (depth > 2) {
+      const seen = serializationContext.$wasSeen$(value);
+      if ("number" == typeof seen && seen >= 0) {
+        return void output(TypeIds.RootRef, seen);
+      }
+    }
+    if (isPropsProxy(value)) {
+      const varProps = value[_VAR_PROPS];
+      const constProps = value[_CONST_PROPS];
+      const out = constProps ? [varProps, constProps] : Object.keys(varProps).length ? [varProps] : 0;
+      output(TypeIds.PropsProxy, out);
+    } else if (value instanceof SubscriptionData) {
+      output(TypeIds.EffectData, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
+    } else if (isStore(value)) {
+      if (isResource(value)) {
+        serializationContext.$resources$.add(value);
+        const res = promiseResults.get(value.value);
+        if (!res) {
+          throw qError(QError.serializeErrorUnvisited, ["resource"]);
+        }
+        output(TypeIds.Resource, [...res, getStoreHandler(value).$effects$]);
+      } else {
+        const storeHandler = getStoreHandler(value);
+        const storeTarget = getStoreTarget(value);
+        const flags = storeHandler.$flags$;
+        const effects = storeHandler.$effects$;
+        const innerStores = [];
+        for (const prop in storeTarget) {
+          const propValue = storeTarget[prop];
+          if ($storeProxyMap$.has(propValue)) {
+            const innerStore = $storeProxyMap$.get(propValue);
+            innerStores.push(innerStore), serializationContext.$addRoot$(innerStore);
+          }
+        }
+        const out = [storeTarget, flags, effects, ...innerStores];
+        for (; null == out[out.length - 1]; ) {
+          out.pop();
+        }
+        output(Array.isArray(storeTarget) ? TypeIds.StoreArray : TypeIds.Store, out);
+      }
+    } else if (isObjectLiteral(value)) {
+      if (Array.isArray(value)) {
+        output(TypeIds.Array, value);
+      } else {
+        const out = [];
+        for (const key in value) {
+          Object.prototype.hasOwnProperty.call(value, key) && !fastSkipSerialize(value[key]) && out.push(key, value[key]);
+        }
+        output(TypeIds.Object, out);
+      }
+    } else if ($isDomRef$(value)) {
+      value.$ssrNode$.vnodeData[0] |= VNodeDataFlag.SERIALIZE, output(TypeIds.RefVNode, value.$ssrNode$.id);
+    } else if (value instanceof Signal) {
+      const v = value instanceof ComputedSignal && (value.$invalid$ || fastSkipSerialize(value.$untrackedValue$)) ? NEEDS_COMPUTATION : value.$untrackedValue$;
+      if (value instanceof WrappedSignal) {
+        output(TypeIds.WrappedSignal, [...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), v, value.$hostElement$, ...value.$effects$ || []]);
+      } else if (value instanceof ComputedSignal) {
+        const out = [value.$computeQrl$, value.$effects$];
+        v !== NEEDS_COMPUTATION && out.push(v), output(TypeIds.ComputedSignal, out);
+      } else {
+        output(TypeIds.Signal, [v, ...value.$effects$ || []]);
+      }
+    } else if (value instanceof URL) {
+      output(TypeIds.URL, value.href);
+    } else if (value instanceof Date) {
+      output(TypeIds.Date, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
+    } else if (value instanceof RegExp) {
+      output(TypeIds.Regex, value.toString());
+    } else if (value instanceof Error) {
+      const out = [value.message];
+      const extraProps = Object.entries(value).flat();
+      extraProps.length && out.push(extraProps), out.push(value.stack), output(TypeIds.Error, out);
+    } else if ($isSsrNode$(value)) {
+      if (isRootObject) {
+        $setProp$(value, "q:id", String(idx)), output(TypeIds.VNode, value.id);
+        const vNodeData = value.vnodeData;
+        if (vNodeData && (serializationContext.$prepVNodeData$?.(vNodeData), vNodeData[0] |= VNodeDataFlag.SERIALIZE), value.childrenVNodeData) {
+          for (const vNodeData2 of value.childrenVNodeData) {
+            vNodeData2[0] |= VNodeDataFlag.SERIALIZE;
+          }
+        }
+      } else {
+        serializationContext.$addRoot$(value), output(TypeIds.RootRef, serializationContext.$roots$.length - 1);
+      }
+    } else if ("undefined" != typeof FormData && value instanceof FormData) {
+      const array = [];
+      value.forEach((value2, key) => {
+        array.push(key, "string" == typeof value2 ? value2 : value2.name);
+      }), output(TypeIds.FormData, array);
+    } else if (value instanceof URLSearchParams) {
+      output(TypeIds.URLSearchParams, value.toString());
+    } else if (value instanceof Set) {
+      output(TypeIds.Set, [...value.values()]);
+    } else if (value instanceof Map) {
+      const combined = [];
+      for (const [k, v] of value.entries()) {
+        combined.push(k, v);
+      }
+      output(TypeIds.Map, combined);
+    } else if (isJSXNode(value)) {
+      output(TypeIds.JSXNode, [value.type, value.varProps, value.constProps, value.children, value.flags, value.key]);
+    } else if (value instanceof Task) {
+      const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$, value[_EFFECT_BACK_REF], value.$state$];
+      for (; null == out[out.length - 1]; ) {
+        out.pop();
+      }
+      output(TypeIds.Task, out);
+    } else if (isPromise(value)) {
+      const res = promiseResults.get(value);
+      if (!res) {
+        throw qError(QError.serializeErrorUnvisited, ["promise"]);
+      }
+      output(TypeIds.Promise, res);
+    } else if (value instanceof Uint8Array) {
+      let buf = "";
+      for (const c of value) {
+        buf += String.fromCharCode(c);
+      }
+      const out = btoa(buf).replace(/=+$/, "");
+      output(TypeIds.Uint8Array, out);
+    } else {
+      if (!vnode_isVNode(value)) {
+        throw qError(QError.serializeErrorUnknownType, [typeof value]);
+      }
+      output(TypeIds.Constant, Constants.Undefined);
+    }
+  };
+  writeValue(serializationContext.$roots$, -1);
+}
+function filterEffectBackRefs(effectBackRef) {
+  let effectBackRefToSerialize = null;
+  if (effectBackRef) {
+    for (const [effectProp, effect] of effectBackRef) {
+      effect[EffectSubscriptionProp.BACK_REF] && (effectBackRefToSerialize || (effectBackRefToSerialize = /* @__PURE__ */ new Map()), effectBackRefToSerialize.set(effectProp, effect));
+    }
+  }
+  return effectBackRefToSerialize;
+}
+function serializeWrappingFn(serializationContext, value) {
+  value.$funcStr$ && "{" === value.$funcStr$[0] && (value.$funcStr$ = `(${value.$funcStr$})`);
+  return [serializationContext.$addSyncFn$(value.$funcStr$, value.$args$.length, value.$func$), value.$args$];
+}
+function qrlToString(serializationContext, value) {
+  let symbol = value.$symbol$;
+  let chunk = value.$chunk$;
+  const platform = getPlatform();
+  if (platform) {
+    const result = platform.chunkForSymbol(symbol, chunk, value.dev?.file);
+    result && (chunk = result[1], symbol = result[0]);
+  }
+  if (isSyncQrl(value)) {
+    chunk = "", symbol = String(serializationContext.$addSyncFn$(null, 0, value.resolved));
+  } else {
+    chunk || (chunk = serializationContext.$symbolToChunkResolver$(value.$hash$));
+    {
+      let backChannel = globalThis[QRL_RUNTIME_CHUNK];
+      backChannel || (backChannel = globalThis[QRL_RUNTIME_CHUNK] = /* @__PURE__ */ new Map()), backChannel.set(value.$symbol$, value._devOnlySymbolRef), chunk || (chunk = QRL_RUNTIME_CHUNK);
+    }
+    if (!chunk) {
+      throw qError(QError.qrlMissingChunk, [value.$symbol$]);
+    }
+    chunk.startsWith("./") && (chunk = chunk.slice(2));
+  }
+  let qrlStringInline = `${chunk}#${symbol}`;
+  if (Array.isArray(value.$captureRef$) && value.$captureRef$.length > 0) {
+    let serializedReferences = "";
+    for (let i = 0; i < value.$captureRef$.length; i++) {
+      i > 0 && (serializedReferences += " "), serializedReferences += serializationContext.$addRoot$(value.$captureRef$[i]);
+    }
+    qrlStringInline += `[${serializedReferences}]`;
+  } else {
+    value.$capture$ && value.$capture$.length > 0 && (qrlStringInline += `[${value.$capture$.join(" ")}]`);
+  }
+  return qrlStringInline;
+}
+function deserializeData(container, typeId, value) {
+  if (void 0 === typeId) {
+    return value;
+  }
+  let propValue = allocate(container, typeId, value);
+  return typeId >= TypeIds.Error && (propValue = inflate(container, propValue, typeId, value)), propValue;
+}
+function shouldTrackObj(obj) {
+  return "object" == typeof obj && null !== obj || "string" == typeof obj && obj.length > 1;
+}
+function isObjectLiteral(obj) {
+  const prototype = Object.getPrototypeOf(obj);
+  return null == prototype || prototype === Object.prototype || prototype === Array.prototype;
+}
+function isResource(value) {
+  return "__brand" in value && "resource" === value.__brand;
+}
+const frameworkType = (obj) => "object" == typeof obj && null !== obj && (obj instanceof Signal || obj instanceof Task || isJSXNode(obj)) || isQrl$1(obj);
+const QRL_RUNTIME_CHUNK = "mock-chunk";
 var TypeIds;
 var Constants;
 !function(TypeIds2) {
   TypeIds2[TypeIds2.RootRef = 0] = "RootRef", TypeIds2[TypeIds2.Constant = 1] = "Constant", TypeIds2[TypeIds2.Number = 2] = "Number", TypeIds2[TypeIds2.String = 3] = "String", TypeIds2[TypeIds2.Array = 4] = "Array", TypeIds2[TypeIds2.URL = 5] = "URL", TypeIds2[TypeIds2.Date = 6] = "Date", TypeIds2[TypeIds2.Regex = 7] = "Regex", TypeIds2[TypeIds2.VNode = 8] = "VNode", TypeIds2[TypeIds2.RefVNode = 9] = "RefVNode", TypeIds2[TypeIds2.BigInt = 10] = "BigInt", TypeIds2[TypeIds2.URLSearchParams = 11] = "URLSearchParams", TypeIds2[TypeIds2.Error = 12] = "Error", TypeIds2[TypeIds2.Object = 13] = "Object", TypeIds2[TypeIds2.Promise = 14] = "Promise", TypeIds2[TypeIds2.Set = 15] = "Set", TypeIds2[TypeIds2.Map = 16] = "Map", TypeIds2[TypeIds2.Uint8Array = 17] = "Uint8Array", TypeIds2[TypeIds2.QRL = 18] = "QRL", TypeIds2[TypeIds2.Task = 19] = "Task", TypeIds2[TypeIds2.Resource = 20] = "Resource", TypeIds2[TypeIds2.Component = 21] = "Component", TypeIds2[TypeIds2.Signal = 22] = "Signal", TypeIds2[TypeIds2.WrappedSignal = 23] = "WrappedSignal", TypeIds2[TypeIds2.ComputedSignal = 24] = "ComputedSignal", TypeIds2[TypeIds2.Store = 25] = "Store", TypeIds2[TypeIds2.StoreArray = 26] = "StoreArray", TypeIds2[TypeIds2.FormData = 27] = "FormData", TypeIds2[TypeIds2.JSXNode = 28] = "JSXNode", TypeIds2[TypeIds2.PropsProxy = 29] = "PropsProxy", TypeIds2[TypeIds2.EffectData = 30] = "EffectData";
 }(TypeIds || (TypeIds = {})), function(Constants2) {
-  Constants2[Constants2.Undefined = 0] = "Undefined", Constants2[Constants2.Null = 1] = "Null", Constants2[Constants2.True = 2] = "True", Constants2[Constants2.False = 3] = "False", Constants2[Constants2.EmptyString = 4] = "EmptyString", Constants2[Constants2.EMPTY_ARRAY = 5] = "EMPTY_ARRAY", Constants2[Constants2.EMPTY_OBJ = 6] = "EMPTY_OBJ", Constants2[Constants2.NEEDS_COMPUTATION = 7] = "NEEDS_COMPUTATION", Constants2[Constants2.Slot = 8] = "Slot", Constants2[Constants2.Fragment = 9] = "Fragment", Constants2[Constants2.NaN = 10] = "NaN", Constants2[Constants2.PositiveInfinity = 11] = "PositiveInfinity", Constants2[Constants2.NegativeInfinity = 12] = "NegativeInfinity", Constants2[Constants2.MaxSafeInt = 13] = "MaxSafeInt", Constants2[Constants2.AlmostMaxSafeInt = 14] = "AlmostMaxSafeInt", Constants2[Constants2.MinSafeInt = 15] = "MinSafeInt";
+  Constants2[Constants2.Undefined = 0] = "Undefined", Constants2[Constants2.Null = 1] = "Null", Constants2[Constants2.True = 2] = "True", Constants2[Constants2.False = 3] = "False", Constants2[Constants2.EmptyString = 4] = "EmptyString", Constants2[Constants2.EMPTY_ARRAY = 5] = "EMPTY_ARRAY", Constants2[Constants2.EMPTY_OBJ = 6] = "EMPTY_OBJ", Constants2[Constants2.NEEDS_COMPUTATION = 7] = "NEEDS_COMPUTATION", Constants2[Constants2.STORE_ARRAY_PROP = 8] = "STORE_ARRAY_PROP", Constants2[Constants2.Slot = 9] = "Slot", Constants2[Constants2.Fragment = 10] = "Fragment", Constants2[Constants2.NaN = 11] = "NaN", Constants2[Constants2.PositiveInfinity = 12] = "PositiveInfinity", Constants2[Constants2.NegativeInfinity = 13] = "NegativeInfinity", Constants2[Constants2.MaxSafeInt = 14] = "MaxSafeInt", Constants2[Constants2.AlmostMaxSafeInt = 15] = "AlmostMaxSafeInt", Constants2[Constants2.MinSafeInt = 16] = "MinSafeInt";
 }(Constants || (Constants = {}));
+const noSerializeSet = /* @__PURE__ */ new WeakSet();
+const fastSkipSerialize = (obj) => noSerializeSet.has(obj);
+const noSerialize = (input) => (null != input && noSerializeSet.add(input), input);
+const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
+  let _containerEl;
+  const qrl2 = async function(...args) {
+    const boundedFn = bindFnToContext.call(this, tryGetInvokeContext());
+    return await boundedFn(...args);
+  };
+  const setContainer = (el) => (_containerEl || (_containerEl = el), _containerEl);
+  function bindFnToContext(currentCtx, beforeFn) {
+    const bound = (...args) => {
+      if (!qrl2.resolved) {
+        return qrl2.resolve().then((fn) => {
+          if (!isFunction(fn)) {
+            throw qError(QError.qrlIsNotFunction);
+          }
+          return bound(...args);
+        });
+      }
+      if (beforeFn && false === beforeFn()) {
+        return;
+      }
+      const context = createOrReuseInvocationContext(currentCtx);
+      const prevQrl = context.$qrl$;
+      const prevEvent = context.$event$;
+      context.$qrl$ = qrl2, context.$event$ || (context.$event$ = this);
+      try {
+        return invoke.call(this, context, symbolRef, ...args);
+      } finally {
+        context.$qrl$ = prevQrl, context.$event$ = prevEvent;
+      }
+    };
+    return bound;
+  }
+  const wrapFn = (fn) => "function" != typeof fn || !capture?.length && !captureRef?.length ? fn : function(...args) {
+    let context = tryGetInvokeContext();
+    if (context) {
+      if (context.$qrl$?.$symbol$ === qrl2.$symbol$) {
+        return fn.apply(this, args);
+      }
+      const prevQrl = context.$qrl$;
+      context.$qrl$ = qrl2;
+      try {
+        return fn.apply(this, args);
+      } finally {
+        context.$qrl$ = prevQrl;
+      }
+    }
+    return context = newInvokeContext(), context.$qrl$ = qrl2, context.$event$ = this, invoke.call(this, context, fn, ...args);
+  };
+  const resolve = async (containerEl) => {
+    if (null !== symbolRef) {
+      return symbolRef;
+    }
+    if (containerEl && setContainer(containerEl), "" === chunk) {
+      const hash2 = _containerEl.getAttribute("q:instance");
+      const qFuncs = getQFuncs(_containerEl.ownerDocument, hash2);
+      return qrl2.resolved = symbolRef = qFuncs[Number(symbol)];
+    }
+    const start = now();
+    const ctx = tryGetInvokeContext();
+    {
+      const imported = getPlatform().importSymbol(_containerEl, chunk, symbol);
+      symbolRef = maybeThen(imported, (ref) => qrl2.resolved = wrapFn(symbolRef = ref));
+    }
+    return "object" == typeof symbolRef && isPromise(symbolRef) && symbolRef.then(() => emitUsedSymbol(symbol, ctx?.$element$, start), (err) => {
+      throw console.error(`qrl ${symbol} failed to load`, err), symbolRef = null, err;
+    }), symbolRef;
+  };
+  const createOrReuseInvocationContext = (invoke2) => null == invoke2 ? newInvokeContext() : isArray(invoke2) ? newInvokeContextFromTuple(invoke2) : invoke2;
+  const hash = getSymbolHash(symbol);
+  return Object.assign(qrl2, {
+    getSymbol: () => symbol,
+    getHash: () => hash,
+    getCaptured: () => captureRef,
+    resolve,
+    $resolveLazy$: (containerEl) => null !== symbolRef ? symbolRef : resolve(containerEl),
+    $setContainer$: setContainer,
+    $chunk$: chunk,
+    $symbol$: symbol,
+    $hash$: hash,
+    getFn: bindFnToContext,
+    $capture$: capture,
+    $captureRef$: captureRef,
+    dev: null,
+    resolved: void 0
+  }), symbolRef && (symbolRef = maybeThen(symbolRef, (resolved) => qrl2.resolved = wrapFn(symbolRef = resolved))), qrl2;
+};
+const EMITTED = /* @__PURE__ */ new Set();
+const emitUsedSymbol = (symbol, element, reqTime) => {
+  EMITTED.has(symbol) || (EMITTED.add(symbol), emitEvent("qsymbol", {
+    symbol,
+    element,
+    reqTime
+  }));
+};
+const emitEvent = (eventName, detail) => {
+  isServerPlatform() || "object" != typeof document || document.dispatchEvent(new CustomEvent(eventName, {
+    bubbles: false,
+    detail
+  }));
+};
+const now = () => isServerPlatform() ? 0 : "object" == typeof performance ? performance.now() : 0;
+const componentQrl = (componentQrl2) => {
+  function QwikComponent(props, key, flags = 0) {
+    const finalKey = componentQrl2.$hash$.slice(0, 4) + ":" + (key || "");
+    const InnerCmp = () => {
+    };
+    return InnerCmp[SERIALIZABLE_STATE] = [componentQrl2], _jsxSplit(InnerCmp, props, null, props.children, flags, finalKey);
+  }
+  return QwikComponent[SERIALIZABLE_STATE] = [componentQrl2], QwikComponent;
+};
+const SERIALIZABLE_STATE = Symbol("serializable-data");
+const isQwikComponent = (component) => "function" == typeof component && void 0 !== component[SERIALIZABLE_STATE];
 const insightsPing = core.sync$(
   () => ((window2, document2, location2, navigator2, performance2, round, JSON_stringify) => {
     var publicApiKey = __QI_KEY__, postUrl = __QI_URL__, getAttribute_s = "getAttribute", querySelector_s = "querySelector", manifest_s = "manifest", manifest_hash_s = `${manifest_s}-hash`, manifestHash_s = `${manifest_s}Hash`, version_s = "version", publicApiKey_s = "publicApiKey", sendBeacon_s = "sendBeacon", symbol_s = "symbol", length_s = "length", addEventListener_s = "addEventListener", route_s = "route", error_s = "error", stack_s = "stack", message_s = "message", symbols_s = `${symbol_s}s`, qVersion = document2[querySelector_s](`[q\\:${version_s}]`)?.[getAttribute_s](`q:${version_s}`) || "unknown", manifestHash = document2[querySelector_s](`[q\\:${manifest_hash_s}]`)?.[getAttribute_s](