@qwik.dev/core 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/insights/index.qwik.cjs

@@ -1,4260 +1 @@
-"use strict";
-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, _d, _e;
-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.8-dev+66037b5
- * 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);
-  return console.error("%cQWIK ERROR", "", err.message, ...optionalParams, err.stack), asyncThrow && setTimeout(() => {
-    throw err;
-  }, 0), err;
-};
-function assertDefined() {
-}
-function assertEqual() {
-}
-function assertTrue() {
-}
-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.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";
-}(VirtualType || (VirtualType = {}));
-({
-  [VirtualType.Virtual]: "\x1B[34mVirtual\x1B[0m",
-  [VirtualType.Fragment]: "\x1B[34mFragment\x1B[0m",
-  [VirtualType.WrappedSignal]: "\x1B[34mSignal\x1B[0m",
-  [VirtualType.Awaited]: "\x1B[34mAwaited\x1B[0m",
-  [VirtualType.Component]: "\x1B[34mComponent\x1B[0m",
-  [VirtualType.InlineComponent]: "\x1B[34mInlineComponent\x1B[0m",
-  [VirtualType.Projection]: "\x1B[34mProjection\x1B[0m"
-});
-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 = (value) => "function" == typeof value && "function" == typeof value.getSymbol;
-const EMPTY_ARRAY = [];
-const 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_ALL_PROPS = Symbol("store.all");
-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;
-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 && addStoreEffect(target, Array.isArray(target) ? STORE_ALL_PROPS : 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 && addStoreEffect(target, Array.isArray(target) ? STORE_ALL_PROPS : prop, this, effectSubscriber);
-      }
-    }
-    return Object.prototype.hasOwnProperty.call(target, prop);
-  }
-  ownKeys(target) {
-    const ctx = tryGetInvokeContext();
-    const effectSubscriber = ctx?.$effectSubscriber$;
-    return effectSubscriber && addStoreEffect(target, STORE_ALL_PROPS, 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 addStoreEffect(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_ALL_PROPS);
-  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, _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;
-        }
-        if (isStore(obj)) {
-          return addStoreEffect(getStoreTarget(obj), STORE_ALL_PROPS, getStoreHandler(obj), ctx.$effectSubscriber$), obj;
-        }
-        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 = (array, key, start) => {
-  let bottom = start >> 1;
-  let top = array.length - 2 >> 1;
-  for (; bottom <= top; ) {
-    const mid = bottom + (top - bottom >> 1);
-    const midKey = array[mid << 1];
-    if (midKey === key) {
-      return mid << 1;
-    }
-    midKey < key ? bottom = mid + 1 : top = mid - 1;
-  }
-  return ~(bottom << 1);
-};
-const mapArray_set = (array, key, value, start) => {
-  const indx = mapApp_findIndx(array, key, start);
-  indx >= 0 ? null == value ? array.splice(indx, 2) : array[indx + 1] = value : null != value && array.splice(~indx, 0, key, value);
-};
-const mapArray_get = (array, key, start) => {
-  const indx = mapApp_findIndx(array, key, start);
-  return indx >= 0 ? array[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 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)), vCurrent = vCurrent && vCurrent[VNodeProps.flags] & VNodeFlags.Deleted ? null : vCurrent, null == vCurrent && (vNewNode = vnode_newVirtual(), vnode_setProp(vNewNode, QSlot, slotName), vnode_setProp(vNewNode, "q:sparent", 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;
-    if (null == vProjectedNode) {
-      return vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()), vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), false;
-    }
-    if (vProjectedNode === vCurrent) ;
-    else {
-      const parent = vnode_getParent(vProjectedNode);
-      !(!parent || vnode_isElementVNode(parent) && vnode_getElementName(parent) === QTemplate) && vParent !== parent && vnode_remove(journal, parent, vProjectedNode, false), vnode_insertBefore(journal, vParent, vNewNode = vProjectedNode, vCurrent && getInsertBefore()), vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode);
-    }
-    return true;
-  }
-  function expectNoMore() {
-    if (null !== vCurrent) {
-      for (; vCurrent; ) {
-        const toRemove = vCurrent;
-        advanceToNextSibling(), vParent === vnode_getParent(toRemove) && (cleanup(container, 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), 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;
-      const lookupKeysAreEqual = lookupKey === getKey(host);
-      const vNodeComponentHash = getComponentHash(host, container.$getObjectById$);
-      if (lookupKeysAreEqual ? null != vNodeComponentHash && (insertNewInlineComponent(), host = vNewNode) : (vNewNode = retrieveChildWithKey(null, lookupKey), vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : insertNewInlineComponent(), 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 insertNewInlineComponent() {
-    vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
-    const jsxNode2 = jsxValue;
-    vnode_setProp(vNewNode, "q:props", jsxNode2.props), jsxNode2.key && vnode_setProp(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 void markVNodeAsDeleted(vCursor);
-  }
-  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) {
-          if (isSlotProp(attrs[i])) {
-            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 (vnode_isProjection(vCursor)) {
-        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;
-        }
-      }
-    } else {
-      type & VNodeFlags.Text && markVNodeAsDeleted(vCursor);
-    }
-    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 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);
-  }
-}
-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 = {}));
-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, "q:sparent", (id) => vnode_locate(rootVNode, id));
-  }
-  for (; b; ) {
-    b = (bVNodePath[++bDepth] = b)[VNodeProps.parent] || rootVNode && vnode_getProp(b, "q:sparent", (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, "q:sparent", (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);
-}
-var SignalFlags;
-var WrappedSignalFlags;
-!function(SignalFlags2) {
-  SignalFlags2[SignalFlags2.INVALID = 1] = "INVALID";
-}(SignalFlags || (SignalFlags = {})), function(WrappedSignalFlags2) {
-  WrappedSignalFlags2[WrappedSignalFlags2.UNWRAP = 2] = "UNWRAP";
-}(WrappedSignalFlags || (WrappedSignalFlags = {}));
-const throwIfQRLNotResolved = (qrl2) => {
-  if (!qrl2.resolved) {
-    throw qrl2.resolve();
-  }
-};
-const isSignal = (value) => value instanceof Signal;
-class SubscriptionData {
-  constructor(data) {
-    __publicField(this, "data");
-    this.data = data;
-  }
-}
-var EffectSubscriptionProp;
-var EffectProperty;
-!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 {
-  constructor(container, value) {
-    __publicField(this, "$untrackedValue$");
-    __publicField(this, "$effects$", null);
-    __publicField(this, "$container$", null);
-    this.$container$ = container, this.$untrackedValue$ = value;
-  }
-  get untrackedValue() {
-    return this.$untrackedValue$;
-  }
-  set untrackedValue(value) {
-    this.$untrackedValue$ = value;
-  }
-  get value() {
-    const ctx = tryGetInvokeContext();
-    if (ctx) {
-      if (null === this.$container$) {
-        if (!ctx.$container$) {
-          return this.untrackedValue;
-        }
-        this.$container$ = ctx.$container$;
-      } else {
-        assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$);
-      }
-      const effectSubscriber = ctx.$effectSubscriber$;
-      if (effectSubscriber) {
-        const effects = this.$effects$ || (this.$effects$ = /* @__PURE__ */ new Set());
-        ensureContainsSubscription(effects, effectSubscriber), ensureContainsBackRef(effectSubscriber, this), addQrlToSerializationCtx(effectSubscriber, this.$container$);
-      }
-    }
-    return this.untrackedValue;
-  }
-  set value(value) {
-    value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, triggerEffects(this.$container$, this, this.$effects$));
-  }
-  valueOf() {
-  }
-  toString() {
-    return `[${this.constructor.name}${this.$flags$ & SignalFlags.INVALID ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map((e) => "\n -> " + pad(qwikDebugToString(e[0]), "    ")).join("\n") || "");
-  }
-  toJSON() {
-    return {
-      value: this.$untrackedValue$
-    };
-  }
-}
-const ensureContainsSubscription = (array, effectSubscription) => {
-  array.add(effectSubscription);
-};
-const ensureContainsBackRef = (array, value) => {
-  var _a2;
-  array[_a2 = EffectSubscriptionProp.BACK_REF] || (array[_a2] = /* @__PURE__ */ new Set()), array[EffectSubscriptionProp.BACK_REF].add(value);
-};
-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);
-  }
-};
-const triggerEffects = (container, signal, effects) => {
-  const isBrowser2 = isDomContainer(container);
-  if (effects) {
-    const scheduleEffect = (effectSubscription) => {
-      const consumer = effectSubscription[EffectSubscriptionProp.CONSUMER];
-      const property = effectSubscription[EffectSubscriptionProp.PROPERTY];
-      if (isTask(consumer)) {
-        consumer.$flags$ |= TaskFlags.DIRTY;
-        let choreType = ChoreType.TASK;
-        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 = consumer;
-        const qrl2 = container.getHostProp(host, "q:renderFn");
-        const props = container.getHostProp(host, "q:props");
-        container.$scheduler$(ChoreType.COMPONENT, host, qrl2, props);
-      } 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);
-          }
-        }
-      }
-    };
-    for (const effect of effects) {
-      scheduleEffect(effect);
-    }
-  }
-};
-class ComputedSignal extends (_c = Signal, _b = _EFFECT_BACK_REF, _c) {
-  constructor(container, fn, flags = SignalFlags.INVALID) {
-    super(container, NEEDS_COMPUTATION);
-    __publicField(this, "$computeQrl$");
-    __publicField(this, "$flags$");
-    __publicField(this, "$forceRunEffects$", false);
-    __publicField(this, _b, null);
-    this.$computeQrl$ = fn, this.$flags$ = flags;
-  }
-  $invalidate$() {
-    this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = false, this.$container$?.$scheduler$(ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, null, this);
-  }
-  force() {
-    this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = false, triggerEffects(this.$container$, this, this.$effects$);
-  }
-  get untrackedValue() {
-    const didChange = this.$computeIfNeeded$();
-    return didChange && (this.$forceRunEffects$ = didChange), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION), this.$untrackedValue$;
-  }
-  $computeIfNeeded$() {
-    if (!(this.$flags$ & SignalFlags.INVALID)) {
-      return false;
-    }
-    const computeQrl = this.$computeQrl$;
-    throwIfQRLNotResolved(computeQrl);
-    const ctx = tryGetInvokeContext();
-    const previousEffectSubscription = ctx?.$effectSubscriber$;
-    ctx && (ctx.$effectSubscriber$ = getSubscriber(this, EffectProperty.VNODE));
-    try {
-      const untrackedValue = computeQrl.getFn(ctx)();
-      if (isPromise(untrackedValue)) {
-        throw qError(QError.computedNotSync, [computeQrl.dev ? computeQrl.dev.file : "", computeQrl.$hash$]);
-      }
-      this.$flags$ &= ~SignalFlags.INVALID;
-      const didChange = untrackedValue !== this.$untrackedValue$;
-      return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
-    } finally {
-      ctx && (ctx.$effectSubscriber$ = previousEffectSubscription);
-    }
-  }
-  get value() {
-    return super.value;
-  }
-  set value(_) {
-    throw qError(QError.computedReadOnly);
-  }
-}
-class WrappedSignal extends (_e = Signal, _d = _EFFECT_BACK_REF, _e) {
-  constructor(container, fn, args, fnStr, flags = SignalFlags.INVALID | WrappedSignalFlags.UNWRAP) {
-    super(container, NEEDS_COMPUTATION);
-    __publicField(this, "$args$");
-    __publicField(this, "$func$");
-    __publicField(this, "$funcStr$");
-    __publicField(this, "$flags$");
-    __publicField(this, "$hostElement$", null);
-    __publicField(this, "$forceRunEffects$", false);
-    __publicField(this, _d, null);
-    this.$args$ = args, this.$func$ = fn, this.$funcStr$ = fnStr, this.$flags$ = flags;
-  }
-  $invalidate$() {
-    this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = false, this.$container$?.$scheduler$(ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, this.$hostElement$, this);
-  }
-  force() {
-    this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = false, triggerEffects(this.$container$, this, this.$effects$);
-  }
-  get untrackedValue() {
-    const didChange = this.$computeIfNeeded$();
-    return didChange && (this.$forceRunEffects$ = didChange), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION), this.$untrackedValue$;
-  }
-  $computeIfNeeded$() {
-    if (!(this.$flags$ & SignalFlags.INVALID)) {
-      return false;
-    }
-    const untrackedValue = trackSignal(() => this.$func$(...this.$args$), this, EffectProperty.VNODE, this.$container$);
-    const didChange = untrackedValue !== this.$untrackedValue$;
-    return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
-  }
-  get value() {
-    return super.value;
-  }
-  set value(_) {
-    throw qError(QError.wrappedReadOnly);
-  }
-}
-const version = "2.0.0-alpha.8-dev+66037b5";
-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 || {}, constProps || null, children, flags, processed);
-  return node;
-};
-const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
-  let sortedProps;
-  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)) : "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");
-    __publicField(this, "varProps");
-    __publicField(this, "constProps");
-    __publicField(this, "children");
-    __publicField(this, "flags");
-    __publicField(this, "key");
-    __publicField(this, "dev");
-    __publicField(this, "_proxy", null);
-    this.type = type, this.varProps = varProps, this.constProps = constProps, this.children = children, this.flags = flags, this.key = key;
-  }
-  get props() {
-    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));
-}
-class PropsProxyHandler {
-  constructor($varProps$, $constProps$, $children$) {
-    __publicField(this, "$varProps$");
-    __publicField(this, "$constProps$");
-    __publicField(this, "$children$");
-    this.$varProps$ = $varProps$, this.$constProps$ = $constProps$, this.$children$ = $children$;
-  }
-  get(_, prop) {
-    if (prop === _CONST_PROPS) {
-      return this.$constProps$;
-    }
-    if (prop === _VAR_PROPS) {
-      return this.$varProps$;
-    }
-    if (null != this.$children$ && "children" === prop) {
-      return this.$children$;
-    }
-    const value = this.$constProps$ && prop in this.$constProps$ ? this.$constProps$[prop] : this.$varProps$[prop];
-    return value instanceof WrappedSignal && value.$flags$ & WrappedSignalFlags.UNWRAP ? value.value : value;
-  }
-  set(_, prop, value) {
-    return prop === _CONST_PROPS ? (this.$constProps$ = value, true) : prop === _VAR_PROPS ? (this.$varProps$ = value, true) : (this.$constProps$ && prop in this.$constProps$ ? this.$constProps$[prop] = value : this.$varProps$[prop] = value, true);
-  }
-  deleteProperty(_, prop) {
-    if ("string" != typeof prop) {
-      return false;
-    }
-    let didDelete = delete this.$varProps$[prop];
-    return this.$constProps$ && (didDelete = delete this.$constProps$[prop] || didDelete), null != this.$children$ && "children" === prop && (this.$children$ = null), didDelete;
-  }
-  has(_, prop) {
-    return "children" === prop && null != this.$children$ || prop === _CONST_PROPS || prop === _VAR_PROPS || prop in this.$varProps$ || !!this.$constProps$ && prop in this.$constProps$;
-  }
-  getOwnPropertyDescriptor(target, p) {
-    return {
-      configurable: true,
-      enumerable: true,
-      value: "children" === p && null != this.$children$ ? this.$children$ : this.$constProps$ && p in this.$constProps$ ? this.$constProps$[p] : this.$varProps$[p]
-    };
-  }
-  ownKeys() {
-    const out = Object.keys(this.$varProps$);
-    if (null != this.$children$ && -1 === out.indexOf("children") && out.push("children"), this.$constProps$) {
-      for (const key in this.$constProps$) {
-        -1 === out.indexOf(key) && out.push(key);
-      }
-    }
-    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) {
-    return "null";
-  }
-  if (void 0 === value) {
-    return "undefined";
-  }
-  if ("string" == typeof value) {
-    return '"' + value + '"';
-  }
-  if ("number" == typeof value || "boolean" == typeof value) {
-    return String(value);
-  }
-  if (isTask(value)) {
-    return `Task(${qwikDebugToString(value.$qrl$)})`;
-  }
-  if (isQrl(value)) {
-    return `Qrl(${value.$symbol$})`;
-  }
-  if ("object" == typeof value || "function" == typeof value) {
-    if (stringifyPath.includes(value)) {
-      return "*";
-    }
-    try {
-      if (stringifyPath.push(value), Array.isArray(value)) {
-        return vnode_isVNode(value) ? "(" + vnode_getProp(value, "q:type", null) + ")" : value.map(qwikDebugToString);
-      }
-      if (isSignal(value)) {
-        return value instanceof WrappedSignal ? "WrappedSignal" : value instanceof ComputedSignal ? "ComputedSignal" : "Signal";
-      }
-      if (isStore(value)) {
-        return "Store";
-      }
-      if (isJSXNode(value)) {
-        return jsxToString(value);
-      }
-    } finally {
-      stringifyPath.pop();
-    }
-  }
-  return value;
-}
-const pad = (text, prefix) => String(text).split("\n").map((line, idx) => (idx ? prefix : "") + line).join("\n");
-const jsxToString = (value) => {
-  if (isJSXNode(value)) {
-    let type = value.type;
-    "function" == typeof type && (type = type.name || "Component");
-    let str = "<" + value.type;
-    if (value.props) {
-      for (const [key, val] of Object.entries(value.props)) {
-        str += " " + key + "=" + qwikDebugToString(val);
-      }
-      const children = value.children;
-      null != children ? (str += ">", Array.isArray(children) ? children.forEach((child) => {
-        str += jsxToString(child);
-      }) : str += jsxToString(children), str += "</" + value.type + ">") : str += "/>";
-    }
-    return str;
-  }
-  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_PARENT: 63,
-  SLOT_PARENT_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 vnode_isProjection = (vNode) => {
-  return (vNode[VNodeProps.flags] & VNodeFlags.Virtual) === VNodeFlags.Virtual && null !== vnode_getProp(vNode, QSlot, null);
-};
-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) {
-      case VNodeFlags.Element:
-        return "Element";
-      case VNodeFlags.Virtual:
-        return "Virtual";
-      case VNodeFlags.Text:
-        return "Text";
-    }
-  }
-  return "<unknown>";
-};
-const vnode_ensureElementInflated = (vnode) => {
-  if ((vnode[VNodeProps.flags] & VNodeFlags.INFLATED_TYPE_MASK) === VNodeFlags.Element) {
-    const elementVNode = 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;
-      if (":" === key || !key) {
-        break;
-      }
-      if (key.startsWith("q:container")) {
-        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(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 = 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 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 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 props = vnode_getProps(vnode);
-    const idx = mapApp_findIndx(props, key, 0);
-    if (idx >= 0) {
-      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 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;
-  if (type === VNodeFlags.Element) {
-    return ElementVNodeProps.PROPS_OFFSET;
-  }
-  if (type === VNodeFlags.Virtual) {
-    return VirtualVNodeProps.PROPS_OFFSET;
-  }
-  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.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.SLOT_PARENT) {
-      vnode_setProp(vParent, "q:sparent", consumeValue());
-    } 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, "q:sparent", (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) {
-    return new VNode(flags, parent, previousSibling, nextSibling, firstChild, lastChild, element, elementName, []);
-  }
-  static createText(flags, parent, previousSibling, nextSibling, textNode, text) {
-    return new VNode(flags, parent, previousSibling, nextSibling, textNode, text);
-  }
-  static createVirtual(flags, parent, previousSibling, nextSibling, firstChild, lastChild) {
-    return new VNode(flags, parent, previousSibling, nextSibling, firstChild, lastChild, []);
-  }
-  constructor(flags, parent, previousSibling, nextSibling, ...rest) {
-    super(flags, parent, previousSibling, nextSibling, ...rest);
-  }
-};
-let _context;
-const tryGetInvokeContext = () => {
-  if (!_context) {
-    const context = "undefined" != typeof document && document && document.__q_context__;
-    if (!context) {
-      return;
-    }
-    return isArray(context) ? document.__q_context__ = newInvokeContextFromTuple(context) : context;
-  }
-  return _context;
-};
-function invoke(context, fn, ...args) {
-  return invokeApply.call(this, context, fn, args);
-}
-function invokeApply(context, fn, args) {
-  const previousContext = _context;
-  let returnValue;
-  try {
-    _context = context, returnValue = fn.apply(this, args);
-  } finally {
-    _context = previousContext;
-  }
-  return returnValue;
-}
-const newInvokeContextFromTuple = ([element, event, url]) => {
-  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, vNode, element, event, url);
-};
-const newInvokeContext = (locale, hostElement, element, event, url) => {
-  const ctx = {
-    $url$: url,
-    $i$: 0,
-    $hostElement$: hostElement,
-    $element$: element,
-    $event$: event,
-    $qrl$: void 0,
-    $effectSubscriber$: void 0,
-    $locale$: locale || ("object" == typeof event && event && "locale" in event ? event.locale : void 0),
-    $container$: void 0
-  };
-  return ctx;
-};
-const untrack = (fn) => invoke(void 0, fn);
-const trackInvocation = /* @__PURE__ */ newInvokeContext(void 0, void 0, void 0, "qRender");
-const trackSignal = (fn, subscriber, property, container, data) => {
-  const previousSubscriber = trackInvocation.$effectSubscriber$;
-  const previousContainer = trackInvocation.$container$;
-  try {
-    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, "q:sparent", 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.$flags$ = d[4], signal.$hostElement$ = d[5], signal.$effects$ = new Set(d.slice(6));
-      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.$flags$ |= SignalFlags.INVALID, 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_ALL_PROPS, 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.$flags$ & SignalFlags.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 && (discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues), 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) => {
-  effectsBackRefs && 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_ALL_PROPS) {
-        throw qError(QError.serializeErrorUnknownType, [typeof value]);
-      }
-      output(TypeIds.Constant, Constants.STORE_ALL_PROPS);
-    }
-  };
-  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.$flags$ & SignalFlags.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.$flags$, 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.STORE_ALL_PROPS = 8] = "STORE_ALL_PROPS", 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](
-      `q:${manifest_hash_s}`
-    ) || "dev", qSymbols = [], existingSymbols = /* @__PURE__ */ new Set(), flushSymbolIndex = 0, lastReqTime = 0, timeoutID, qRouteChangeTime = performance2.now(), qRouteEl = document2[querySelector_s](`[q\\:${route_s}]`), flush = () => {
-      timeoutID = void 0;
-      if (qSymbols[length_s] > flushSymbolIndex) {
-        var payload = {
-          qVersion,
-          [publicApiKey_s]: publicApiKey,
-          [manifestHash_s]: manifestHash,
-          previousSymbol: flushSymbolIndex == 0 ? void 0 : qSymbols[flushSymbolIndex - 1][symbol_s],
-          [symbols_s]: qSymbols.slice(flushSymbolIndex)
-        };
-        navigator2[sendBeacon_s](postUrl, JSON_stringify(payload));
-        flushSymbolIndex = qSymbols[length_s];
-      }
-    }, debounceFlush = () => {
-      timeoutID != void 0 && clearTimeout(timeoutID);
-      timeoutID = setTimeout(flush, 1e3);
-    };
-    window2.qSymbolTracker = {
-      [symbols_s]: qSymbols,
-      [publicApiKey_s]: publicApiKey
-    };
-    if (qRouteEl) {
-      new MutationObserver((mutations) => {
-        var mutation = mutations.find((m) => m.attributeName === `q:${route_s}`);
-        if (mutation) {
-          qRouteChangeTime = performance2.now();
-        }
-      }).observe(qRouteEl, { attributes: true });
-    }
-    document2[addEventListener_s](
-      "visibilitychange",
-      () => document2.visibilityState === "hidden" && flush()
-    );
-    document2[addEventListener_s](`q${symbol_s}`, (_event) => {
-      var event = _event, detail = event.detail, symbolRequestTime = detail.reqTime, symbolDeliveredTime = event.timeStamp, symbol = detail[symbol_s];
-      if (!existingSymbols.has(symbol)) {
-        existingSymbols.add(symbol);
-        var route = qRouteEl?.[getAttribute_s](`q:${route_s}`) || "/";
-        qSymbols.push({
-          [symbol_s]: symbol,
-          [route_s]: route,
-          delay: round(0 - lastReqTime + symbolRequestTime),
-          latency: round(symbolDeliveredTime - symbolRequestTime),
-          timeline: round(0 - qRouteChangeTime + symbolRequestTime),
-          interaction: !!detail.element
-        });
-        lastReqTime = symbolDeliveredTime;
-        debounceFlush();
-      }
-    });
-    window2[addEventListener_s](error_s, (event) => {
-      var error = event[error_s];
-      if (!(error && typeof error === "object")) {
-        return;
-      }
-      var payload = {
-        url: `${location2}`,
-        [manifestHash_s]: manifestHash,
-        timestamp: (/* @__PURE__ */ new Date()).getTime(),
-        source: event.filename,
-        line: event.lineno,
-        column: event.colno,
-        [message_s]: event[message_s],
-        [error_s]: message_s in error ? error[message_s] : `${error}`,
-        [stack_s]: stack_s in error ? error[stack_s] || "" : ""
-      };
-      navigator2[sendBeacon_s](`${postUrl}${error_s}/`, JSON_stringify(payload));
-    });
-  })(window, document, location, navigator, performance, Math.round, JSON.stringify)
-);
-const Insights = core.component$(
-  ({ publicApiKey, postUrl }) => {
-    if (!__EXPERIMENTAL__.insights) {
-      throw new Error(
-        'Insights is experimental and must be enabled with `experimental: ["insights"]` in the `qwikVite` plugin.'
-      );
-    }
-    if (!publicApiKey) {
-      return null;
-    }
-    return (
-      // the script will set the variables before the qinit event
-      /* @__PURE__ */ jsx("script", {
-        "document:onQInit$": insightsPing,
-        dangerouslySetInnerHTML: `__QI_KEY__=${JSON.stringify(publicApiKey)};__QI_URL__=${JSON.stringify(postUrl || `https://insights.qwik.dev/api/v1/${publicApiKey}/post/`)}`
-      })
-    );
-  }
-);
-exports.Insights = Insights;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const g=require("@qwik.dev/core"),L=require("@qwik.dev/core/jsx-runtime"),T=g.sync$(()=>((r,i,w,_,b,l,y)=>{var h=__QI_KEY__,d=__QI_URL__,E=i.querySelector("[q\\:version]")?.getAttribute("q:version")||"unknown",f=i.querySelector("[q\\:manifest-hash]")?.getAttribute("q:manifest-hash")||"dev",s=[],q=new Set,o=0,v=0,a,p=b.now(),m=i.querySelector("[q\\:route]"),I=()=>{if(a=void 0,s.length>o){var t={qVersion:E,publicApiKey:h,manifestHash:f,previousSymbol:o==0?void 0:s[o-1].symbol,symbols:s.slice(o)};_.sendBeacon(d,y(t)),o=s.length}},k=()=>{a!=null&&clearTimeout(a),a=setTimeout(I,1e3)};r.qSymbolTracker={symbols:s,publicApiKey:h},m&&new MutationObserver(t=>{var e=t.find(n=>n.attributeName==="q:route");e&&(p=b.now())}).observe(m,{attributes:!0}),i.addEventListener("visibilitychange",()=>i.visibilityState==="hidden"&&I()),i.addEventListener("qsymbol",t=>{var e=t,n=e.detail,u=n.reqTime,S=e.timeStamp,c=n.symbol;if(!q.has(c)){q.add(c);var R=m?.getAttribute("q:route")||"/";s.push({symbol:c,route:R,delay:l(0-v+u),latency:l(S-u),timeline:l(0-p+u),interaction:!!n.element}),v=S,k()}}),r.addEventListener("error",t=>{var e=t.error;if(e&&typeof e=="object"){var n={url:`${w}`,manifestHash:f,timestamp:new Date().getTime(),source:t.filename,line:t.lineno,column:t.colno,message:t.message,error:"message"in e?e.message:`${e}`,stack:"stack"in e&&e.stack||""};_.sendBeacon(`${d}error/`,y(n))}})})(window,document,location,navigator,performance,Math.round,JSON.stringify)),$=g.component$(()=>{if(!__EXPERIMENTAL__.insights)throw new Error('Insights is experimental and must be enabled with `experimental: ["insights"]` in the `qwikVite` plugin.');const r=globalThis.__QI_KEY__,i=globalThis.__QI_URL__;return!r||!i?(g.isDev||console.warn("<Insights />: no config from qwikInsights plugin, skipping..."),null):L.jsx("script",{"document:onQInit$":T,dangerouslySetInnerHTML:`__QI_KEY__=${JSON.stringify(r)};__QI_URL__=${JSON.stringify(i)}`})});exports.Insights=$;exports.insightsPing=T;