mongoku 2.8.1 → 2.9.0

package/build/server/chunks/{url-hmE1zcJ6.js → root-otUAnOAR.js}

@@ -1,6 +1,77 @@
-import { a as async_mode_flag, t as tracing_mode_flag } from './async-lVJA8xJZ.js';
+import { a as async_mode_flag, t as tracing_mode_flag } from './async-DUoD1OpG.js';
+
+// eslint-disable-next-line n/prefer-global/process
+const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
+
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestStore } from 'types' */
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
+
+
+/** @type {RequestStore | null} */
+let sync_store = null;
+
+/** @type {AsyncLocalStorage<RequestStore | null> | null} */
+let als$1;
+
+import('node:async_hooks')
+	.then((hooks) => (als$1 = new hooks.AsyncLocalStorage()))
+	.catch(() => {
+		// can't use AsyncLocalStorage, but can still call getRequestEvent synchronously.
+		// this isn't behind `supports` because it's basically just StackBlitz (i.e.
+		// in-browser usage) that doesn't support it AFAICT
+	});
+
+function get_request_store() {
+	const result = try_get_request_store();
+	if (!result) {
+		let message = 'Could not get the request store.';
+
+		if (als$1) {
+			message += ' This is an internal error.';
+		} else {
+			message +=
+				' In environments without `AsyncLocalStorage`, the request store (used by e.g. remote functions) must be accessed synchronously, not after an `await`.' +
+				' If it was accessed synchronously then this is an internal error.';
+		}
+
+		throw new Error(message);
+	}
+	return result;
+}
+
+function try_get_request_store() {
+	return sync_store ?? als$1?.getStore() ?? null;
+}
+
+/**
+ * @template T
+ * @param {RequestStore | null} store
+ * @param {() => T} fn
+ */
+function with_request_store(store, fn) {
+	try {
+		sync_store = store;
+		return als$1 ? als$1.run(store, fn) : fn();
+	} finally {
+		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
+		// and handle only one request at a time in `src/runtime/server/index.js`.
+		if (!IN_WEBCONTAINER) {
+			sync_store = null;
+		}
+	}
+}
 
 const DEV = false;
+const UNDEFINED = -1;
+const HOLE = -2;
+const NAN = -3;
+const POSITIVE_INFINITY = -4;
+const NEGATIVE_INFINITY = -5;
+const NEGATIVE_ZERO = -6;
+const SPARSE = -7;
+const MAX_ARRAY_LEN = 2 ** 32 - 1;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
 const escaped = {
   "<": "\\u003C",
   "\\": "\\\\",
@@ -28,11 +99,9 @@ class DevalueError extends Error {
   }
 }
 function is_primitive(thing) {
-  return Object(thing) !== thing;
+  return thing === null || typeof thing !== "object" && typeof thing !== "function";
 }
-const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(
-  Object.prototype
-).sort().join("\0");
+const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
 function is_plain_object(thing) {
   const proto = Object.getPrototypeOf(thing);
   return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
@@ -89,91 +158,37 @@ const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 function stringify_key(key) {
   return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
 }
-function is_valid_array_index(s) {
+function is_valid_array_index(n) {
+  if (!Number.isInteger(n)) return false;
+  if (n < 0) return false;
+  if (n > MAX_ARRAY_INDEX) return false;
+  return true;
+}
+function is_valid_array_len(n) {
+  if (!Number.isInteger(n)) return false;
+  if (n < 0) return false;
+  if (n > MAX_ARRAY_LEN) return false;
+  return true;
+}
+function is_valid_array_index_string(s) {
   if (s.length === 0) return false;
   if (s.length > 1 && s.charCodeAt(0) === 48) return false;
   for (let i = 0; i < s.length; i++) {
     const c = s.charCodeAt(i);
     if (c < 48 || c > 57) return false;
   }
-  const n = +s;
-  if (n >= 2 ** 32 - 1) return false;
-  if (n < 0) return false;
-  return true;
+  return is_valid_array_index(+s);
 }
 function valid_array_indices(array) {
   const keys = Object.keys(array);
   for (var i = keys.length - 1; i >= 0; i--) {
-    if (is_valid_array_index(keys[i])) {
+    if (is_valid_array_index_string(keys[i])) {
       break;
     }
   }
   keys.length = i + 1;
   return keys;
 }
-
-// eslint-disable-next-line n/prefer-global/process
-const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
-
-/** @import { RequestEvent } from '@sveltejs/kit' */
-/** @import { RequestStore } from 'types' */
-/** @import { AsyncLocalStorage } from 'node:async_hooks' */
-
-
-/** @type {RequestStore | null} */
-let sync_store = null;
-
-/** @type {AsyncLocalStorage<RequestStore | null> | null} */
-let als$1;
-
-import('node:async_hooks')
-	.then((hooks) => (als$1 = new hooks.AsyncLocalStorage()))
-	.catch(() => {
-		// can't use AsyncLocalStorage, but can still call getRequestEvent synchronously.
-		// this isn't behind `supports` because it's basically just StackBlitz (i.e.
-		// in-browser usage) that doesn't support it AFAICT
-	});
-
-function get_request_store() {
-	const result = try_get_request_store();
-	if (!result) {
-		let message = 'Could not get the request store.';
-
-		if (als$1) {
-			message += ' This is an internal error.';
-		} else {
-			message +=
-				' In environments without `AsyncLocalStorage`, the request store (used by e.g. remote functions) must be accessed synchronously, not after an `await`.' +
-				' If it was accessed synchronously then this is an internal error.';
-		}
-
-		throw new Error(message);
-	}
-	return result;
-}
-
-function try_get_request_store() {
-	return sync_store ?? als$1?.getStore() ?? null;
-}
-
-/**
- * @template T
- * @param {RequestStore | null} store
- * @param {() => T} fn
- */
-function with_request_store(store, fn) {
-	try {
-		sync_store = store;
-		return als$1 ? als$1.run(store, fn) : fn();
-	} finally {
-		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
-		// and handle only one request at a time in `src/runtime/server/index.js`.
-		if (!IN_WEBCONTAINER) {
-			sync_store = null;
-		}
-	}
-}
-
 const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
 const unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
 const reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
@@ -221,9 +236,7 @@ function uneval(value, replacer) {
           break;
         case "Map":
           for (const [key, value2] of thing) {
-            keys.push(
-              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
-            );
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
             walk(value2);
             keys.pop();
           }
@@ -233,12 +246,14 @@ function uneval(value, replacer) {
         case "Uint8ClampedArray":
         case "Int16Array":
         case "Uint16Array":
+        case "Float16Array":
         case "Int32Array":
         case "Uint32Array":
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
         case "BigUint64Array":
+        case "DataView":
           walk(thing.buffer);
           return;
         case "ArrayBuffer":
@@ -254,20 +269,10 @@ function uneval(value, replacer) {
           return;
         default:
           if (!is_plain_object(thing)) {
-            throw new DevalueError(
-              `Cannot stringify arbitrary non-POJOs`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
           if (enumerable_symbols(thing).length > 0) {
-            throw new DevalueError(
-              `Cannot stringify POJOs with symbolic keys`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
           for (const key of Object.keys(thing)) {
             if (key === "__proto__") {
@@ -283,6 +288,8 @@ function uneval(value, replacer) {
             keys.pop();
           }
       }
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
   }
   walk(value);
@@ -290,7 +297,7 @@ function uneval(value, replacer) {
   Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
     names.set(entry[0], get_name(i));
   });
-  function stringify2(thing) {
+  function stringify(thing) {
     if (names.has(thing)) {
       return names.get(thing);
     }
@@ -305,9 +312,11 @@ function uneval(value, replacer) {
       case "Number":
       case "String":
       case "Boolean":
-        return `Object(${stringify2(thing.valueOf())})`;
+      case "BigInt":
+        return `Object(${stringify(thing.valueOf())})`;
       case "RegExp":
-        return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
+        const { source, flags } = thing;
+        return flags ? `new RegExp(${stringify_string(source)},"${flags}")` : `new RegExp(${stringify_string(source)})`;
       case "Date":
         return `new Date(${thing.getTime()})`;
       case "URL":
@@ -320,7 +329,7 @@ function uneval(value, replacer) {
         for (let i = 0; i < thing.length; i += 1) {
           if (i > 0) result += ",";
           if (Object.hasOwn(thing, i)) {
-            result += stringify2(thing[i]);
+            result += stringify(thing[i]);
           } else if (!has_holes) {
             const populated_keys = valid_array_indices(
               /** @type {any[]} */
@@ -331,7 +340,7 @@ function uneval(value, replacer) {
             const hole_cost = thing.length + 2;
             const sparse_cost = 25 + d + population * (d + 2);
             if (hole_cost > sparse_cost) {
-              const entries = populated_keys.map((k) => `${k}:${stringify2(thing[k])}`).join(",");
+              const entries = populated_keys.map((k) => `${k}:${stringify(thing[k])}`).join(",");
               return `Object.assign(Array(${thing.length}),{${entries}})`;
             }
             has_holes = true;
@@ -343,12 +352,13 @@ function uneval(value, replacer) {
       }
       case "Set":
       case "Map":
-        return `new ${type}([${Array.from(thing).map(stringify2).join(",")}])`;
+        return `new ${type}([${Array.from(thing).map(stringify).join(",")}])`;
       case "Int8Array":
       case "Uint8Array":
       case "Uint8ClampedArray":
       case "Int16Array":
       case "Uint16Array":
+      case "Float16Array":
       case "Int32Array":
       case "Uint32Array":
       case "Float32Array":
@@ -356,20 +366,31 @@ function uneval(value, replacer) {
       case "BigInt64Array":
       case "BigUint64Array": {
         let str2 = `new ${type}`;
-        if (counts.get(thing.buffer) === 1) {
+        if (!names.has(thing.buffer)) {
           const array = new thing.constructor(thing.buffer);
           str2 += `([${array}])`;
         } else {
-          str2 += `([${stringify2(thing.buffer)}])`;
+          str2 += `(${stringify(thing.buffer)})`;
         }
-        const a = thing.byteOffset;
-        const b = a + thing.byteLength;
-        if (a > 0 || b !== thing.buffer.byteLength) {
-          const m = +/(\d+)/.exec(type)[1] / 8;
-          str2 += `.subarray(${a / m},${b / m})`;
+        if (thing.byteLength !== thing.buffer.byteLength) {
+          const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+          const end = start + thing.length;
+          str2 += `.subarray(${start},${end})`;
         }
         return str2;
       }
+      case "DataView": {
+        let str2 = `new DataView`;
+        if (!names.has(thing.buffer)) {
+          str2 += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
+        } else {
+          str2 += `(${stringify(thing.buffer)}`;
+        }
+        if (thing.byteLength !== thing.buffer.byteLength) {
+          str2 += `,${thing.startOffset},${thing.byteLength}`;
+        }
+        return str2 + ")";
+      }
       case "ArrayBuffer": {
         const ui8 = new Uint8Array(thing);
         return `new Uint8Array([${ui8.toString()}]).buffer`;
@@ -385,7 +406,7 @@ function uneval(value, replacer) {
         return `${type}.from(${stringify_string(thing.toString())})`;
       default:
         const keys2 = Object.keys(thing);
-        const obj = keys2.map((key) => `${safe_key(key)}:${stringify2(thing[key])}`).join(",");
+        const obj = keys2.map((key) => `${safe_key(key)}:${stringify(thing[key])}`).join(",");
         const proto = Object.getPrototypeOf(thing);
         if (proto === null) {
           return keys2.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
@@ -393,7 +414,7 @@ function uneval(value, replacer) {
         return `{${obj}}`;
     }
   }
-  const str = stringify2(value);
+  const str = stringify(value);
   if (names.size) {
     const params = [];
     const statements = [];
@@ -416,52 +437,96 @@ function uneval(value, replacer) {
         case "Number":
         case "String":
         case "Boolean":
-          values.push(`Object(${stringify2(thing.valueOf())})`);
+        case "BigInt":
+          values.push(`Object(${stringify(thing.valueOf())})`);
           break;
         case "RegExp":
-          values.push(thing.toString());
+          const { source, flags } = thing;
+          const regexp = flags ? `new RegExp(${stringify_string(source)},"${flags}")` : `new RegExp(${stringify_string(source)})`;
+          values.push(regexp);
           break;
         case "Date":
           values.push(`new Date(${thing.getTime()})`);
           break;
+        case "URL":
+          values.push(`new URL(${stringify_string(thing.toString())})`);
+          break;
+        case "URLSearchParams":
+          values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
+          break;
         case "Array":
           values.push(`Array(${thing.length})`);
           thing.forEach((v, i) => {
-            statements.push(`${name}[${i}]=${stringify2(v)}`);
+            statements.push(`${name}[${i}]=${stringify(v)}`);
           });
           break;
         case "Set":
           values.push(`new Set`);
           statements.push(
-            `${name}.${Array.from(thing).map((v) => `add(${stringify2(v)})`).join(".")}`
+            `${name}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`
           );
           break;
         case "Map":
           values.push(`new Map`);
           statements.push(
-            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify2(k)}, ${stringify2(v)})`).join(".")}`
+            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`
           );
           break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Float16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array": {
+          let str2 = `new ${type}`;
+          if (!names.has(thing.buffer)) {
+            const array = new thing.constructor(thing.buffer);
+            str2 += `([${array}])`;
+          } else {
+            str2 += `(${stringify(thing.buffer)})`;
+          }
+          if (thing.byteLength !== thing.buffer.byteLength) {
+            const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+            const end = start + thing.length;
+            str2 += `.subarray(${start},${end})`;
+          }
+          values.push(`{}`);
+          statements.push(`${name}=${str2}`);
+          break;
+        }
+        case "DataView": {
+          let str2 = `new DataView`;
+          if (!names.has(thing.buffer)) {
+            str2 += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
+          } else {
+            str2 += `(${stringify(thing.buffer)}`;
+          }
+          if (thing.byteLength !== thing.buffer.byteLength) {
+            str2 += `,${thing.byteOffset},${thing.byteLength}`;
+          }
+          str2 += ")";
+          values.push(`{}`);
+          statements.push(`${name}=${str2}`);
+          break;
+        }
         case "ArrayBuffer":
-          values.push(
-            `new Uint8Array([${new Uint8Array(thing).join(",")}]).buffer`
-          );
+          values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
           break;
         default:
-          values.push(
-            Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}"
-          );
+          values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
           Object.keys(thing).forEach((key) => {
-            statements.push(
-              `${name}${safe_prop(key)}=${stringify2(thing[key])}`
-            );
+            statements.push(`${name}${safe_prop(key)}=${stringify(thing[key])}`);
           });
       }
     });
     statements.push(`return ${str}`);
-    return `(function(${params.join(",")}){${statements.join(
-      ";"
-    )}}(${values.join(",")}))`;
+    return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
   } else {
     return str;
   }
@@ -487,14 +552,79 @@ function safe_prop(key) {
   return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
 }
 function stringify_primitive(thing) {
-  if (typeof thing === "string") return stringify_string(thing);
+  const type = typeof thing;
+  if (type === "string") return stringify_string(thing);
   if (thing === void 0) return "void 0";
   if (thing === 0 && 1 / thing < 0) return "-0";
   const str = String(thing);
-  if (typeof thing === "number") return str.replace(/^(-)?0\./, "$1.");
-  if (typeof thing === "bigint") return thing + "n";
+  if (type === "number") return str.replace(/^(-)?0\./, "$1.");
+  if (type === "bigint") return thing + "n";
   return str;
 }
+function experimental_async_required(name) {
+  {
+    throw new Error(`https://svelte.dev/e/experimental_async_required`);
+  }
+}
+function lifecycle_outside_component(name) {
+  {
+    throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
+  }
+}
+function async_local_storage_unavailable() {
+  const error = new Error(`async_local_storage_unavailable
+The node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.
+https://svelte.dev/e/async_local_storage_unavailable`);
+  error.name = "Svelte error";
+  throw error;
+}
+function await_invalid() {
+  const error = new Error(`await_invalid
+Encountered asynchronous work while rendering synchronously.
+https://svelte.dev/e/await_invalid`);
+  error.name = "Svelte error";
+  throw error;
+}
+function html_deprecated() {
+  const error = new Error(`html_deprecated
+The \`html\` property of server render results has been deprecated. Use \`body\` instead.
+https://svelte.dev/e/html_deprecated`);
+  error.name = "Svelte error";
+  throw error;
+}
+function hydratable_serialization_failed(key, stack) {
+  const error = new Error(`hydratable_serialization_failed
+Failed to serialize \`hydratable\` data for key \`${key}\`.
+
+\`hydratable\` can serialize anything [\`uneval\` from \`devalue\`](https://npmjs.com/package/uneval) can, plus Promises.
+
+Cause:
+${stack}
+https://svelte.dev/e/hydratable_serialization_failed`);
+  error.name = "Svelte error";
+  throw error;
+}
+function invalid_csp() {
+  const error = new Error(`invalid_csp
+\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.
+https://svelte.dev/e/invalid_csp`);
+  error.name = "Svelte error";
+  throw error;
+}
+function invalid_id_prefix() {
+  const error = new Error(`invalid_id_prefix
+The \`idPrefix\` option cannot include \`--\`.
+https://svelte.dev/e/invalid_id_prefix`);
+  error.name = "Svelte error";
+  throw error;
+}
+function server_context_required() {
+  const error = new Error(`server_context_required
+Could not resolve \`render\` context.
+https://svelte.dev/e/server_context_required`);
+  error.name = "Svelte error";
+  throw error;
+}
 var is_array = Array.isArray;
 var index_of = Array.prototype.indexOf;
 var includes = Array.prototype.includes;
@@ -525,14 +655,187 @@ function deferred() {
   });
   return { promise, resolve, reject };
 }
-function equals(value) {
-  return value === this.v;
+let current_render = null;
+let context = null;
+function get_render_context() {
+  const store = context ?? als?.getStore();
+  if (!store) {
+    server_context_required();
+  }
+  return store;
 }
-function safe_not_equal(a, b) {
-  return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
+async function with_render_context(fn) {
+  context = {
+    hydratable: {
+      lookup: /* @__PURE__ */ new Map(),
+      comparisons: [],
+      unresolved_promises: /* @__PURE__ */ new Map()
+    }
+  };
+  if (in_webcontainer()) {
+    const { promise, resolve } = deferred();
+    const previous_render = current_render;
+    current_render = promise;
+    await previous_render;
+    return fn().finally(resolve);
+  }
+  try {
+    if (als === null) {
+      async_local_storage_unavailable();
+    }
+    return als.run(context, fn);
+  } finally {
+    context = null;
+  }
 }
-function safe_equals(value) {
-  return !safe_not_equal(value, this.v);
+let als = null;
+let als_import = null;
+function init_render_context() {
+  als_import ??= import('node:async_hooks').then((hooks) => {
+    als = new hooks.AsyncLocalStorage();
+  }).then(noop, noop);
+  return als_import;
+}
+function in_webcontainer() {
+  return !!globalThis.process?.versions?.webcontainer;
+}
+
+const internal = new URL("sveltekit-internal://");
+function resolve(base, path) {
+  if (path[0] === "/" && path[1] === "/") return path;
+  let url = new URL(base, internal);
+  url = new URL(path, url);
+  return url.protocol === internal.protocol ? url.pathname + url.search + url.hash : url.href;
+}
+function normalize_path(path, trailing_slash) {
+  if (path === "/" || trailing_slash === "ignore") return path;
+  if (trailing_slash === "never") {
+    return path.endsWith("/") ? path.slice(0, -1) : path;
+  } else if (trailing_slash === "always" && !path.endsWith("/")) {
+    return path + "/";
+  }
+  return path;
+}
+function decode_pathname(pathname) {
+  return pathname.split("%25").map(decodeURI).join("%25");
+}
+function decode_params(params) {
+  for (const key in params) {
+    params[key] = decodeURIComponent(params[key]);
+  }
+  return params;
+}
+function make_trackable(url, callback, search_params_callback, allow_hash = false) {
+  const tracked = new URL(url);
+  Object.defineProperty(tracked, "searchParams", {
+    value: new Proxy(tracked.searchParams, {
+      get(obj, key) {
+        if (key === "get" || key === "getAll" || key === "has") {
+          return (param, ...rest) => {
+            search_params_callback(param);
+            return obj[key](param, ...rest);
+          };
+        }
+        callback();
+        const value = Reflect.get(obj, key);
+        return typeof value === "function" ? value.bind(obj) : value;
+      }
+    }),
+    enumerable: true,
+    configurable: true
+  });
+  const tracked_url_properties = ["href", "pathname", "search", "toString", "toJSON"];
+  if (allow_hash) tracked_url_properties.push("hash");
+  for (const property of tracked_url_properties) {
+    Object.defineProperty(tracked, property, {
+      get() {
+        callback();
+        return url[property];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  {
+    tracked[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+      return inspect(url, opts);
+    };
+    tracked.searchParams[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+      return inspect(url.searchParams, opts);
+    };
+  }
+  if (!allow_hash) {
+    disable_hash(tracked);
+  }
+  return tracked;
+}
+function disable_hash(url) {
+  allow_nodejs_console_log(url);
+  Object.defineProperty(url, "hash", {
+    get() {
+      throw new Error(
+        "Cannot access event.url.hash. Consider using `page.url.hash` inside a component instead"
+      );
+    }
+  });
+}
+function disable_search(url) {
+  allow_nodejs_console_log(url);
+  for (const property of ["search", "searchParams"]) {
+    Object.defineProperty(url, property, {
+      get() {
+        throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+      }
+    });
+  }
+}
+function allow_nodejs_console_log(url) {
+  {
+    url[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+      return inspect(new URL(url), opts);
+    };
+  }
+}
+
+var ssr_context = null;
+function set_ssr_context(v) {
+  ssr_context = v;
+}
+function getContext(key) {
+  const context_map = get_or_init_context_map();
+  const result = (
+    /** @type {T} */
+    context_map.get(key)
+  );
+  return result;
+}
+function setContext(key, context) {
+  get_or_init_context_map().set(key, context);
+  return context;
+}
+function get_or_init_context_map(name) {
+  if (ssr_context === null) {
+    lifecycle_outside_component();
+  }
+  return ssr_context.c ??= new Map(get_parent_context(ssr_context) || void 0);
+}
+function push$1(fn) {
+  ssr_context = { p: ssr_context, c: null, r: null };
+}
+function pop$1() {
+  ssr_context = /** @type {SSRContext} */
+  ssr_context.p;
+}
+function get_parent_context(ssr_context2) {
+  let parent = ssr_context2.p;
+  while (parent !== null) {
+    const context_map = parent.c;
+    if (context_map !== null) {
+      return context_map;
+    }
+    parent = parent.p;
+  }
+  return null;
 }
 const DERIVED = 1 << 1;
 const EFFECT = 1 << 2;
@@ -549,6 +852,7 @@ const MAYBE_DIRTY = 1 << 12;
 const INERT = 1 << 13;
 const DESTROYED = 1 << 14;
 const REACTION_RAN = 1 << 15;
+const DESTROYING = 1 << 25;
 const EFFECT_TRANSPARENT = 1 << 16;
 const EAGER_EFFECT = 1 << 17;
 const HEAD_EFFECT = 1 << 18;
@@ -560,45 +864,19 @@ const ASYNC = 1 << 22;
 const ERROR_VALUE = 1 << 23;
 const STATE_SYMBOL = /* @__PURE__ */ Symbol("$state");
 const LEGACY_PROPS = /* @__PURE__ */ Symbol("legacy props");
+const ATTRIBUTES_CACHE = /* @__PURE__ */ Symbol("attributes");
+const CLASS_CACHE = /* @__PURE__ */ Symbol("class");
+const STYLE_CACHE = /* @__PURE__ */ Symbol("style");
+const TEXT_CACHE = /* @__PURE__ */ Symbol("text");
 const STALE_REACTION = new class StaleReactionError extends Error {
   name = "StaleReactionError";
   message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
 }();
 const COMMENT_NODE = 8;
-function lifecycle_outside_component(name) {
-  {
-    throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
-  }
-}
-function effect_update_depth_exceeded() {
-  {
-    throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
-  }
-}
-function hydration_failed() {
-  {
-    throw new Error(`https://svelte.dev/e/hydration_failed`);
-  }
-}
-function state_descriptors_fixed() {
-  {
-    throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
-  }
-}
-function state_prototype_fixed() {
-  {
-    throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
-  }
-}
-function state_unsafe_mutation() {
-  {
-    throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
-  }
-}
-function svelte_boundary_reset_onerror() {
-  {
-    throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
-  }
+let controller = null;
+function abort() {
+  controller?.abort(STALE_REACTION);
+  controller = null;
 }
 const HYDRATION_START = "[";
 const HYDRATION_START_ELSE = "[!";
@@ -609,47 +887,261 @@ const ELEMENT_IS_NAMESPACED = 1;
 const ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
 const ELEMENT_IS_INPUT = 1 << 2;
 const UNINITIALIZED = /* @__PURE__ */ Symbol();
-function hydration_mismatch(location) {
+function unresolved_hydratable(key, stack) {
   {
-    console.warn(`https://svelte.dev/e/hydration_mismatch`);
+    console.warn(`https://svelte.dev/e/unresolved_hydratable`);
   }
 }
-function svelte_boundary_reset_noop() {
-  {
-    console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
+const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
+const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
+const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
+const EMPTY_COMMENT = `<!---->`;
+const ATTR_REGEX = /[&"<]/g;
+const CONTENT_REGEX = /[&<]/g;
+function escape_html(value, is_attr) {
+  const str = String(value ?? "");
+  const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
+  pattern.lastIndex = 0;
+  let escaped = "";
+  let last = 0;
+  while (pattern.test(str)) {
+    const i = pattern.lastIndex - 1;
+    const ch = str[i];
+    escaped += str.substring(last, i) + (ch === "&" ? "&amp;" : ch === '"' ? "&quot;" : "&lt;");
+    last = i + 1;
   }
+  return escaped + str.substring(last);
 }
-let hydrating = false;
-function set_hydrating(value) {
-  hydrating = value;
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
 }
-let hydrate_node;
-function set_hydrate_node(node) {
-  if (node === null) {
-    hydration_mismatch();
-    throw HYDRATION_ERROR;
-  }
-  return hydrate_node = node;
+function clsx$1() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
 }
-function hydrate_next() {
-  return set_hydrate_node(/* @__PURE__ */ get_next_sibling(hydrate_node));
+const replacements = {
+  translate: /* @__PURE__ */ new Map([
+    [true, "yes"],
+    [false, "no"]
+  ])
+};
+function attr(name, value, is_boolean = false) {
+  if (name === "hidden" && value !== "until-found") {
+    is_boolean = true;
+  }
+  if (value == null || !value && is_boolean) return "";
+  const normalized = has_own_property.call(replacements, name) && replacements[name].get(value) || value;
+  const assignment = is_boolean ? `=""` : `="${escape_html(normalized, true)}"`;
+  return ` ${name}${assignment}`;
 }
-function next(count = 1) {
-  if (hydrating) {
-    var i = count;
-    var node = hydrate_node;
-    while (i--) {
-      node = /** @type {TemplateNode} */
-      /* @__PURE__ */ get_next_sibling(node);
-    }
-    hydrate_node = node;
+function clsx(value) {
+  if (typeof value === "object") {
+    return clsx$1(value);
+  } else {
+    return value ?? "";
   }
 }
-function skip_nodes(remove = true) {
-  var depth = 0;
-  var node = hydrate_node;
-  while (true) {
-    if (node.nodeType === COMMENT_NODE) {
+const whitespace = [..." 	\n\r\f \v\uFEFF"];
+function to_class(value, hash, directives) {
+  var classname = value == null ? "" : "" + value;
+  if (hash) {
+    classname = classname ? classname + " " + hash : hash;
+  }
+  if (directives) {
+    for (var key of Object.keys(directives)) {
+      if (directives[key]) {
+        classname = classname ? classname + " " + key : key;
+      } else if (classname.length) {
+        var len = key.length;
+        var a = 0;
+        while ((a = classname.indexOf(key, a)) >= 0) {
+          var b = a + len;
+          if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) {
+            classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
+          } else {
+            a = b;
+          }
+        }
+      }
+    }
+  }
+  return classname === "" ? null : classname;
+}
+function append_styles(styles, important = false) {
+  var separator = important ? " !important;" : ";";
+  var css = "";
+  for (var key of Object.keys(styles)) {
+    var value = styles[key];
+    if (value != null && value !== "") {
+      css += " " + key + ": " + value + separator;
+    }
+  }
+  return css;
+}
+function to_css_name(name) {
+  if (name[0] !== "-" || name[1] !== "-") {
+    return name.toLowerCase();
+  }
+  return name;
+}
+function to_style(value, styles) {
+  if (styles) {
+    var new_style = "";
+    var normal_styles;
+    var important_styles;
+    if (Array.isArray(styles)) {
+      normal_styles = styles[0];
+      important_styles = styles[1];
+    } else {
+      normal_styles = styles;
+    }
+    if (value) {
+      value = String(value).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
+      var in_str = false;
+      var in_apo = 0;
+      var in_comment = false;
+      var reserved_names = [];
+      if (normal_styles) {
+        reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
+      }
+      if (important_styles) {
+        reserved_names.push(...Object.keys(important_styles).map(to_css_name));
+      }
+      var start_index = 0;
+      var name_index = -1;
+      const len = value.length;
+      for (var i = 0; i < len; i++) {
+        var c = value[i];
+        if (in_comment) {
+          if (c === "/" && value[i - 1] === "*") {
+            in_comment = false;
+          }
+        } else if (in_str) {
+          if (in_str === c) {
+            in_str = false;
+          }
+        } else if (c === "/" && value[i + 1] === "*") {
+          in_comment = true;
+        } else if (c === '"' || c === "'") {
+          in_str = c;
+        } else if (c === "(") {
+          in_apo++;
+        } else if (c === ")") {
+          in_apo--;
+        }
+        if (!in_comment && in_str === false && in_apo === 0) {
+          if (c === ":" && name_index === -1) {
+            name_index = i;
+          } else if (c === ";" || i === len - 1) {
+            if (name_index !== -1) {
+              var name = to_css_name(value.substring(start_index, name_index).trim());
+              if (!reserved_names.includes(name)) {
+                if (c !== ";") {
+                  i++;
+                }
+                var property = value.substring(start_index, i).trim();
+                new_style += " " + property + ";";
+              }
+            }
+            start_index = i + 1;
+            name_index = -1;
+          }
+        }
+      }
+    }
+    if (normal_styles) {
+      new_style += append_styles(normal_styles);
+    }
+    if (important_styles) {
+      new_style += append_styles(important_styles, true);
+    }
+    new_style = new_style.trim();
+    return new_style === "" ? null : new_style;
+  }
+  return value == null ? null : String(value);
+}
+function effect_update_depth_exceeded() {
+  {
+    throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
+  }
+}
+function hydration_failed() {
+  {
+    throw new Error(`https://svelte.dev/e/hydration_failed`);
+  }
+}
+function state_descriptors_fixed() {
+  {
+    throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
+  }
+}
+function state_prototype_fixed() {
+  {
+    throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
+  }
+}
+function state_unsafe_mutation() {
+  {
+    throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
+  }
+}
+function svelte_boundary_reset_onerror() {
+  {
+    throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
+  }
+}
+function derived_inert() {
+  {
+    console.warn(`https://svelte.dev/e/derived_inert`);
+  }
+}
+function hydration_mismatch(location) {
+  {
+    console.warn(`https://svelte.dev/e/hydration_mismatch`);
+  }
+}
+function svelte_boundary_reset_noop() {
+  {
+    console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
+  }
+}
+let hydrating = false;
+function set_hydrating(value) {
+  hydrating = value;
+}
+let hydrate_node;
+function set_hydrate_node(node) {
+  if (node === null) {
+    hydration_mismatch();
+    throw HYDRATION_ERROR;
+  }
+  return hydrate_node = node;
+}
+function hydrate_next() {
+  return set_hydrate_node(/* @__PURE__ */ get_next_sibling(hydrate_node));
+}
+function next(count = 1) {
+  if (hydrating) {
+    var i = count;
+    var node = hydrate_node;
+    while (i--) {
+      node = /** @type {TemplateNode} */
+      /* @__PURE__ */ get_next_sibling(node);
+    }
+    hydrate_node = node;
+  }
+}
+function skip_nodes(remove = true) {
+  var depth = 0;
+  var node = hydrate_node;
+  while (true) {
+    if (node.nodeType === COMMENT_NODE) {
       var data = (
         /** @type {Comment} */
         node.data
@@ -670,11 +1162,20 @@ function skip_nodes(remove = true) {
     node = next2;
   }
 }
+function equals(value) {
+  return value === this.v;
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
+}
+function safe_equals(value) {
+  return !safe_not_equal(value, this.v);
+}
 let component_context = null;
-function set_component_context(context2) {
-  component_context = context2;
+function set_component_context(context) {
+  component_context = context;
 }
-function push$1(props, runes = false, fn) {
+function push(props, runes = false, fn) {
   component_context = {
     p: component_context,
     i: false,
@@ -682,23 +1183,27 @@ function push$1(props, runes = false, fn) {
     e: null,
     s: props,
     x: null,
+    r: (
+      /** @type {Effect} */
+      active_effect
+    ),
     l: null
   };
 }
-function pop$1(component) {
-  var context2 = (
+function pop(component) {
+  var context = (
     /** @type {ComponentContext} */
     component_context
   );
-  var effects = context2.e;
+  var effects = context.e;
   if (effects !== null) {
-    context2.e = null;
+    context.e = null;
     for (var fn of effects) {
       create_user_effect(fn);
     }
   }
-  context2.i = true;
-  component_context = context2.p;
+  context.i = true;
+  component_context = context.p;
   return (
     /** @type {T} */
     {}
@@ -788,30 +1293,52 @@ function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
   clear_marked(effect.deps);
   set_signal_status(effect, CLEAN);
 }
-const batches = /* @__PURE__ */ new Set();
+let first_batch = null;
+let last_batch = null;
 let current_batch = null;
+let previous_batch = null;
 let batch_values = null;
-let queued_root_effects = [];
 let last_scheduled_effect = null;
-let is_flushing = false;
 let is_flushing_sync = false;
+let is_processing = false;
+let collected_effects = null;
+let legacy_updates = null;
+var flush_count = 0;
+let uid = 1;
 class Batch {
+  id = uid++;
+  /** True as soon as `#process` was called */
+  #started = false;
+  linked = true;
+  /** @type {Batch | null} */
+  #prev = null;
+  /** @type {Batch | null} */
+  #next = null;
+  /** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
+  async_deriveds = /* @__PURE__ */ new Map();
   /**
-   * The current values of any sources that are updated in this batch
+   * The current values of any signals that are updated in this batch.
+   * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
    * They keys of this map are identical to `this.#previous`
-   * @type {Map<Source, any>}
+   * @type {Map<Value, [any, boolean]>}
    */
   current = /* @__PURE__ */ new Map();
   /**
-   * The values of any sources that are updated in this batch _before_ those updates took place.
+   * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
    * They keys of this map are identical to `this.#current`
-   * @type {Map<Source, any>}
+   * @type {Map<Value, any>}
    */
   previous = /* @__PURE__ */ new Map();
+  /**
+   * Async effects which this batch doesn't take into account anymore when calculating blockers,
+   * as it has a value for it already.
+   * @type {Set<Effect>}
+   */
+  unblocked = /* @__PURE__ */ new Set();
   /**
    * When the batch is committed (and the DOM is updated), we need to remove old branches
    * and append new ones by calling the functions added inside (if/each/key/etc) blocks
-   * @type {Set<() => void>}
+   * @type {Set<(batch: Batch) => void>}
    */
   #commit_callbacks = /* @__PURE__ */ new Set();
   /**
@@ -819,20 +1346,36 @@ class Batch {
    * @type {Set<(batch: Batch) => void>}
    */
   #discard_callbacks = /* @__PURE__ */ new Set();
+  /**
+   * Callbacks that should run only when a fork is committed.
+   * @type {Set<(batch: Batch) => void>}
+   */
+  #fork_commit_callbacks = /* @__PURE__ */ new Set();
   /**
    * The number of async effects that are currently in flight
    */
   #pending = 0;
   /**
-   * The number of async effects that are currently in flight, _not_ inside a pending boundary
+   * Async effects that are currently in flight, _not_ inside a pending boundary
+   * @type {Map<Effect, number>}
    */
-  #blocking_pending = 0;
+  #blocking_pending = /* @__PURE__ */ new Map();
   /**
    * A deferred that resolves when the batch is committed, used with `settled()`
    * TODO replace with Promise.withResolvers once supported widely enough
    * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
    */
   #deferred = null;
+  /**
+   * The root effects that need to be flushed
+   * @type {Effect[]}
+   */
+  #roots = [];
+  /**
+   * Effects created while this batch was active.
+   * @type {Effect[]}
+   */
+  #new_effects = [];
   /**
    * Deferred effects (which run after async work has completed) that are DIRTY
    * @type {Set<Effect>}
@@ -851,10 +1394,30 @@ class Batch {
    * @type {Map<Effect, { d: Effect[], m: Effect[] }>}
    */
   #skipped_branches = /* @__PURE__ */ new Map();
+  /**
+   * Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
+   * @type {Set<Effect>}
+   */
+  #unskipped_branches = /* @__PURE__ */ new Set();
   is_fork = false;
   #decrement_queued = false;
   #is_deferred() {
-    return this.is_fork || this.#blocking_pending > 0;
+    if (this.is_fork) return true;
+    for (const effect of this.#blocking_pending.keys()) {
+      var e = effect;
+      var skipped = false;
+      while (e.parent !== null) {
+        if (this.#skipped_branches.has(e)) {
+          skipped = true;
+          break;
+        }
+        e = e.parent;
+      }
+      if (!skipped) {
+        return true;
+      }
+    }
+    return false;
   }
   /**
    * Add an effect to the #skipped_branches map and reset its children
@@ -864,58 +1427,118 @@ class Batch {
     if (!this.#skipped_branches.has(effect)) {
       this.#skipped_branches.set(effect, { d: [], m: [] });
     }
+    this.#unskipped_branches.delete(effect);
   }
   /**
    * Remove an effect from the #skipped_branches map and reschedule
    * any tracked dirty/maybe_dirty child effects
    * @param {Effect} effect
+   * @param {(e: Effect) => void} callback
    */
-  unskip_effect(effect) {
+  unskip_effect(effect, callback = (e) => this.schedule(e)) {
     var tracked = this.#skipped_branches.get(effect);
     if (tracked) {
       this.#skipped_branches.delete(effect);
       for (var e of tracked.d) {
         set_signal_status(e, DIRTY);
-        schedule_effect(e);
+        callback(e);
       }
       for (e of tracked.m) {
         set_signal_status(e, MAYBE_DIRTY);
-        schedule_effect(e);
+        callback(e);
       }
     }
+    this.#unskipped_branches.add(effect);
   }
-  /**
-   *
-   * @param {Effect[]} root_effects
-   */
-  process(root_effects) {
-    queued_root_effects = [];
+  #process() {
+    this.#started = true;
+    if (flush_count++ > 1e3) {
+      this.#unlink();
+      infinite_loop_guard();
+    }
+    if (!this.#is_deferred()) {
+      for (const e of this.#dirty_effects) {
+        this.#maybe_dirty_effects.delete(e);
+        set_signal_status(e, DIRTY);
+        this.schedule(e);
+      }
+      for (const e of this.#maybe_dirty_effects) {
+        set_signal_status(e, MAYBE_DIRTY);
+        this.schedule(e);
+      }
+    }
+    const roots = this.#roots;
+    this.#roots = [];
     this.apply();
-    var effects = [];
+    var effects = collected_effects = [];
     var render_effects = [];
-    for (const root2 of root_effects) {
-      this.#traverse_effect_tree(root2, effects, render_effects);
+    var updates = legacy_updates = [];
+    for (const root2 of roots) {
+      try {
+        this.#traverse(root2, effects, render_effects);
+      } catch (e) {
+        reset_all(root2);
+        throw e;
+      }
+    }
+    current_batch = null;
+    if (updates.length > 0) {
+      var batch = Batch.ensure();
+      for (const e of updates) {
+        batch.schedule(e);
+      }
     }
+    collected_effects = null;
+    legacy_updates = null;
     if (this.#is_deferred()) {
       this.#defer_effects(render_effects);
       this.#defer_effects(effects);
       for (const [e, t] of this.#skipped_branches) {
         reset_branch(e, t);
       }
-    } else {
-      for (const fn of this.#commit_callbacks) fn();
-      this.#commit_callbacks.clear();
-      if (this.#pending === 0) {
-        this.#commit();
+      if (updates.length > 0) {
+        /** @type {unknown} */
+        current_batch.#process();
       }
-      current_batch = null;
-      flush_queued_effects(render_effects);
-      flush_queued_effects(effects);
-      this.#dirty_effects.clear();
-      this.#maybe_dirty_effects.clear();
-      this.#deferred?.resolve();
+      return;
+    }
+    const earlier_batch = this.#find_earlier_batch();
+    if (earlier_batch) {
+      earlier_batch.#merge(this);
+      return;
+    }
+    this.#dirty_effects.clear();
+    this.#maybe_dirty_effects.clear();
+    for (const fn of this.#commit_callbacks) fn(this);
+    this.#commit_callbacks.clear();
+    previous_batch = this;
+    flush_queued_effects(render_effects);
+    flush_queued_effects(effects);
+    previous_batch = null;
+    this.#deferred?.resolve();
+    var next_batch = (
+      /** @type {Batch | null} */
+      /** @type {unknown} */
+      current_batch
+    );
+    if (this.linked && this.#pending === 0) {
+      this.#unlink();
+    }
+    if (async_mode_flag && !this.linked) {
+      this.#commit();
+      current_batch = next_batch;
+    }
+    if (this.#roots.length > 0) {
+      if (next_batch === null) {
+        next_batch = this;
+        this.#link();
+      }
+      const batch2 = next_batch;
+      batch2.#roots.push(...this.#roots.filter((r2) => !batch2.#roots.includes(r2)));
+    }
+    if (next_batch !== null) {
+      next_batch.#process();
     }
-    batch_values = null;
   }
   /**
    * Traverse the effect tree, executing effects or stashing
@@ -924,7 +1547,7 @@ class Batch {
    * @param {Effect[]} effects
    * @param {Effect[]} render_effects
    */
-  #traverse_effect_tree(root2, effects, render_effects) {
+  #traverse(root2, effects, render_effects) {
     root2.f ^= CLEAN;
     var effect = root2.first;
     while (effect !== null) {
@@ -959,10 +1582,69 @@ class Batch {
       }
     }
   }
-  /**
-   * @param {Effect[]} effects
-   */
-  #defer_effects(effects) {
+  #find_earlier_batch() {
+    var batch = this.#prev;
+    while (batch !== null) {
+      if (!batch.is_fork) {
+        for (const [value, [, is_derived]] of this.current) {
+          if (batch.current.has(value) && !is_derived) {
+            return batch;
+          }
+        }
+      }
+      batch = batch.#prev;
+    }
+    return null;
+  }
+  /**
+   * @param {Batch} batch
+   */
+  #merge(batch) {
+    for (const [source2, value] of batch.current) {
+      if (!this.previous.has(source2) && batch.previous.has(source2)) {
+        this.previous.set(source2, batch.previous.get(source2));
+      }
+      this.current.set(source2, value);
+    }
+    for (const [effect, deferred2] of batch.async_deriveds) {
+      const d = this.async_deriveds.get(effect);
+      if (d) deferred2.promise.then(d.resolve);
+    }
+    const mark = (value) => {
+      var reactions = value.reactions;
+      if (reactions === null) return;
+      for (const reaction of reactions) {
+        var flags2 = reaction.f;
+        if ((flags2 & DERIVED) !== 0) {
+          mark(
+            /** @type {Derived} */
+            reaction
+          );
+        } else {
+          var effect = (
+            /** @type {Effect} */
+            reaction
+          );
+          if (flags2 & (ASYNC | BLOCK_EFFECT) && !this.async_deriveds.has(effect)) {
+            this.#maybe_dirty_effects.delete(effect);
+            set_signal_status(effect, DIRTY);
+            this.schedule(effect);
+          }
+        }
+      }
+    };
+    for (const source2 of this.current.keys()) {
+      mark(source2);
+    }
+    this.oncommit(() => batch.discard());
+    batch.#unlink();
+    current_batch = this;
+    this.#process();
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #defer_effects(effects) {
     for (var i = 0; i < effects.length; i += 1) {
       defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
     }
@@ -970,132 +1652,186 @@ class Batch {
   /**
    * Associate a change to a given source with the current
    * batch, noting its previous and current values
-   * @param {Source} source
+   * @param {Value} source
    * @param {any} value
+   * @param {boolean} [is_derived]
    */
-  capture(source2, value) {
-    if (value !== UNINITIALIZED && !this.previous.has(source2)) {
-      this.previous.set(source2, value);
+  capture(source2, value, is_derived = false) {
+    if (source2.v !== UNINITIALIZED && !this.previous.has(source2)) {
+      this.previous.set(source2, source2.v);
     }
     if ((source2.f & ERROR_VALUE) === 0) {
-      this.current.set(source2, source2.v);
-      batch_values?.set(source2, source2.v);
+      this.current.set(source2, [value, is_derived]);
+      batch_values?.set(source2, value);
+    }
+    if (!this.is_fork) {
+      source2.v = value;
     }
   }
   activate() {
     current_batch = this;
-    this.apply();
   }
   deactivate() {
-    if (current_batch !== this) return;
     current_batch = null;
     batch_values = null;
   }
   flush() {
-    this.activate();
-    if (queued_root_effects.length > 0) {
-      flush_effects();
-      if (current_batch !== null && current_batch !== this) {
-        return;
-      }
-    } else if (this.#pending === 0) {
-      this.process([]);
+    try {
+      if (DEV) ;
+      is_processing = true;
+      current_batch = this;
+      this.#process();
+    } finally {
+      flush_count = 0;
+      last_scheduled_effect = null;
+      collected_effects = null;
+      legacy_updates = null;
+      is_processing = false;
+      current_batch = null;
+      batch_values = null;
+      old_values.clear();
     }
-    this.deactivate();
   }
   discard() {
     for (const fn of this.#discard_callbacks) fn(this);
     this.#discard_callbacks.clear();
+    this.#fork_commit_callbacks.clear();
+    this.#unlink();
+  }
+  /**
+   * @param {Effect} effect
+   */
+  register_created_effect(effect) {
+    this.#new_effects.push(effect);
   }
   #commit() {
-    if (batches.size > 1) {
-      this.previous.clear();
-      var previous_batch_values = batch_values;
-      var is_earlier = true;
-      for (const batch of batches) {
-        if (batch === this) {
-          is_earlier = false;
-          continue;
-        }
-        const sources = [];
-        for (const [source2, value] of this.current) {
-          if (batch.current.has(source2)) {
-            if (is_earlier && value !== batch.current.get(source2)) {
-              batch.current.set(source2, value);
-            } else {
-              continue;
-            }
+    this.#unlink();
+    for (let batch = first_batch; batch !== null; batch = batch.#next) {
+      var is_earlier = batch.id < this.id;
+      var sources = [];
+      for (const [source3, [value, is_derived]] of this.current) {
+        if (batch.current.has(source3)) {
+          var batch_value = (
+            /** @type {[any, boolean]} */
+            batch.current.get(source3)[0]
+          );
+          if (is_earlier && value !== batch_value) {
+            batch.current.set(source3, [value, is_derived]);
+          } else {
+            continue;
           }
-          sources.push(source2);
         }
-        if (sources.length === 0) {
-          continue;
+        sources.push(source3);
+      }
+      if (is_earlier) {
+        for (const [effect, deferred2] of this.async_deriveds) {
+          const d = batch.async_deriveds.get(effect);
+          if (d) deferred2.promise.then(d.resolve);
+        }
+      }
+      if (!batch.#started) continue;
+      var others = [...batch.current.keys()].filter((s) => !this.current.has(s));
+      if (others.length === 0) {
+        if (is_earlier) {
+          batch.discard();
         }
-        const others = [...batch.current.keys()].filter((s) => !this.current.has(s));
-        if (others.length > 0) {
-          var prev_queued_root_effects = queued_root_effects;
-          queued_root_effects = [];
-          const marked = /* @__PURE__ */ new Set();
-          const checked = /* @__PURE__ */ new Map();
-          for (const source2 of sources) {
-            mark_effects(source2, others, marked, checked);
+      } else if (sources.length > 0) {
+        if (is_earlier) {
+          for (const unskipped of this.#unskipped_branches) {
+            batch.unskip_effect(unskipped, (e) => {
+              if ((e.f & (BLOCK_EFFECT | ASYNC)) !== 0) {
+                batch.schedule(e);
+              } else {
+                batch.#defer_effects([e]);
+              }
+            });
           }
-          if (queued_root_effects.length > 0) {
-            current_batch = batch;
-            batch.apply();
-            for (const root2 of queued_root_effects) {
-              batch.#traverse_effect_tree(root2, [], []);
+        }
+        batch.activate();
+        var marked = /* @__PURE__ */ new Set();
+        var checked = /* @__PURE__ */ new Map();
+        for (var source2 of sources) {
+          mark_effects(source2, others, marked, checked);
+        }
+        checked = /* @__PURE__ */ new Map();
+        var current_unequal = [...batch.current.keys()].filter(
+          (c) => this.current.has(c) ? (
+            /** @type {[any, boolean]} */
+            this.current.get(c)[0] !== c.v
+          ) : true
+        );
+        if (current_unequal.length > 0) {
+          for (const effect of this.#new_effects) {
+            if ((effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 && depends_on(effect, current_unequal, checked)) {
+              if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
+                set_signal_status(effect, DIRTY);
+                batch.schedule(effect);
+              } else {
+                batch.#dirty_effects.add(effect);
+              }
             }
-            batch.deactivate();
           }
-          queued_root_effects = prev_queued_root_effects;
         }
+        if (batch.#roots.length > 0) {
+          batch.apply();
+          for (var root2 of batch.#roots) {
+            batch.#traverse(root2, [], []);
+          }
+          batch.#roots = [];
+        }
+        batch.deactivate();
       }
-      current_batch = null;
-      batch_values = previous_batch_values;
     }
-    this.#skipped_branches.clear();
-    batches.delete(this);
   }
   /**
-   *
    * @param {boolean} blocking
+   * @param {Effect} effect
    */
-  increment(blocking) {
+  increment(blocking, effect) {
     this.#pending += 1;
-    if (blocking) this.#blocking_pending += 1;
+    if (blocking) {
+      let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
+      this.#blocking_pending.set(effect, blocking_pending_count + 1);
+    }
   }
   /**
-   *
    * @param {boolean} blocking
+   * @param {Effect} effect
    */
-  decrement(blocking) {
+  decrement(blocking, effect) {
     this.#pending -= 1;
-    if (blocking) this.#blocking_pending -= 1;
+    if (blocking) {
+      let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
+      if (blocking_pending_count === 1) {
+        this.#blocking_pending.delete(effect);
+      } else {
+        this.#blocking_pending.set(effect, blocking_pending_count - 1);
+      }
+    }
     if (this.#decrement_queued) return;
     this.#decrement_queued = true;
     queue_micro_task(() => {
       this.#decrement_queued = false;
-      if (!this.#is_deferred()) {
-        this.revive();
-      } else if (queued_root_effects.length > 0) {
+      if (this.linked) {
         this.flush();
       }
     });
   }
-  revive() {
-    for (const e of this.#dirty_effects) {
-      this.#maybe_dirty_effects.delete(e);
-      set_signal_status(e, DIRTY);
-      schedule_effect(e);
+  /**
+   * @param {Set<Effect>} dirty_effects
+   * @param {Set<Effect>} maybe_dirty_effects
+   */
+  transfer_effects(dirty_effects, maybe_dirty_effects) {
+    for (const e of dirty_effects) {
+      this.#dirty_effects.add(e);
     }
-    for (const e of this.#maybe_dirty_effects) {
-      set_signal_status(e, MAYBE_DIRTY);
-      schedule_effect(e);
+    for (const e of maybe_dirty_effects) {
+      this.#maybe_dirty_effects.add(e);
     }
-    this.flush();
+    dirty_effects.clear();
+    maybe_dirty_effects.clear();
   }
-  /** @param {() => void} fn */
+  /** @param {(batch: Batch) => void} fn */
   oncommit(fn) {
     this.#commit_callbacks.add(fn);
   }
@@ -1103,35 +1839,113 @@ class Batch {
   ondiscard(fn) {
     this.#discard_callbacks.add(fn);
   }
+  /** @param {(batch: Batch) => void} fn */
+  on_fork_commit(fn) {
+    this.#fork_commit_callbacks.add(fn);
+  }
+  run_fork_commit_callbacks() {
+    for (const fn of this.#fork_commit_callbacks) fn(this);
+    this.#fork_commit_callbacks.clear();
+  }
   settled() {
     return (this.#deferred ??= deferred()).promise;
   }
   static ensure() {
     if (current_batch === null) {
       const batch = current_batch = new Batch();
-      batches.add(current_batch);
-      if (!is_flushing_sync) {
+      batch.#link();
+      if (!is_processing && !is_flushing_sync) {
         queue_micro_task(() => {
-          if (current_batch !== batch) {
-            return;
+          if (!batch.#started) {
+            batch.flush();
           }
-          batch.flush();
         });
       }
     }
     return current_batch;
   }
   apply() {
-    if (!async_mode_flag || !this.is_fork && batches.size === 1) return;
-    batch_values = new Map(this.current);
-    for (const batch of batches) {
-      if (batch === this) continue;
-      for (const [source2, previous] of batch.previous) {
-        if (!batch_values.has(source2)) {
-          batch_values.set(source2, previous);
+    if (!async_mode_flag || !this.is_fork && this.#prev === null && this.#next === null) {
+      batch_values = null;
+      return;
+    }
+    batch_values = /* @__PURE__ */ new Map();
+    for (const [source2, [value]] of this.current) {
+      batch_values.set(source2, value);
+    }
+    for (let batch = first_batch; batch !== null; batch = batch.#next) {
+      if (batch === this || batch.is_fork) continue;
+      var intersects = false;
+      if (batch.id < this.id) {
+        for (const [source2, [, is_derived]] of batch.current) {
+          if (is_derived) continue;
+          if (this.current.has(source2)) {
+            intersects = true;
+            break;
+          }
+        }
+      }
+      if (!intersects) {
+        for (const [source2, previous] of batch.previous) {
+          if (!batch_values.has(source2)) {
+            batch_values.set(source2, previous);
+          }
+        }
+      }
+    }
+  }
+  /**
+   *
+   * @param {Effect} effect
+   */
+  schedule(effect) {
+    last_scheduled_effect = effect;
+    if (effect.b?.is_pending && (effect.f & (EFFECT | RENDER_EFFECT | MANAGED_EFFECT)) !== 0 && (effect.f & REACTION_RAN) === 0) {
+      effect.b.defer_effect(effect);
+      return;
+    }
+    var e = effect;
+    while (e.parent !== null) {
+      e = e.parent;
+      var flags2 = e.f;
+      if (collected_effects !== null && e === active_effect) {
+        if (async_mode_flag) return;
+        if ((active_reaction === null || (active_reaction.f & DERIVED) === 0) && true) {
+          return;
+        }
+      }
+      if ((flags2 & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
+        if ((flags2 & CLEAN) === 0) {
+          return;
         }
+        e.f ^= CLEAN;
       }
     }
+    this.#roots.push(e);
+  }
+  #link() {
+    if (last_batch === null) {
+      first_batch = last_batch = this;
+    } else {
+      last_batch.#next = this;
+      this.#prev = last_batch;
+    }
+    last_batch = this;
+  }
+  #unlink() {
+    var prev = this.#prev;
+    var next2 = this.#next;
+    if (prev === null) {
+      first_batch = next2;
+    } else {
+      prev.#next = next2;
+    }
+    if (next2 === null) {
+      last_batch = prev;
+    } else {
+      next2.#prev = prev;
+    }
+    this.linked = false;
   }
 }
 function flushSync(fn) {
@@ -1142,43 +1956,18 @@ function flushSync(fn) {
     if (fn) ;
     while (true) {
       flush_tasks();
-      if (queued_root_effects.length === 0) {
-        current_batch?.flush();
-        if (queued_root_effects.length === 0) {
-          last_scheduled_effect = null;
-          return (
-            /** @type {T} */
-            result
-          );
-        }
+      if (current_batch === null) {
+        return (
+          /** @type {T} */
+          result
+        );
       }
-      flush_effects();
+      current_batch.flush();
     }
   } finally {
     is_flushing_sync = was_flushing_sync;
   }
 }
-function flush_effects() {
-  is_flushing = true;
-  try {
-    var flush_count = 0;
-    while (queued_root_effects.length > 0) {
-      var batch = Batch.ensure();
-      if (flush_count++ > 1e3) {
-        var updates, entry;
-        if (DEV) ;
-        infinite_loop_guard();
-      }
-      batch.process(queued_root_effects);
-      old_values.clear();
-      if (DEV) ;
-    }
-  } finally {
-    queued_root_effects = [];
-    is_flushing = false;
-    last_scheduled_effect = null;
-  }
-}
 function infinite_loop_guard() {
   try {
     effect_update_depth_exceeded();
@@ -1274,27 +2063,8 @@ function depends_on(reaction, sources, checked) {
   checked.set(reaction, false);
   return false;
 }
-function schedule_effect(signal) {
-  var effect = last_scheduled_effect = signal;
-  var boundary2 = effect.b;
-  if (boundary2?.is_pending && (signal.f & (EFFECT | RENDER_EFFECT | MANAGED_EFFECT)) !== 0 && (signal.f & REACTION_RAN) === 0) {
-    boundary2.defer_effect(signal);
-    return;
-  }
-  while (effect.parent !== null) {
-    effect = effect.parent;
-    var flags2 = effect.f;
-    if (is_flushing && effect === active_effect && (flags2 & BLOCK_EFFECT) !== 0 && (flags2 & HEAD_EFFECT) === 0 && (flags2 & REACTION_RAN) !== 0) {
-      return;
-    }
-    if ((flags2 & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
-      if ((flags2 & CLEAN) === 0) {
-        return;
-      }
-      effect.f ^= CLEAN;
-    }
-  }
-  queued_root_effects.push(effect);
+function schedule_effect(effect) {
+  current_batch.schedule(effect);
 }
 function reset_branch(effect, tracked) {
   if ((effect.f & BRANCH_EFFECT) !== 0 && (effect.f & CLEAN) !== 0) {
@@ -1312,6 +2082,14 @@ function reset_branch(effect, tracked) {
     e = e.next;
   }
 }
+function reset_all(effect) {
+  set_signal_status(effect, CLEAN);
+  var e = effect.first;
+  while (e !== null) {
+    reset_all(e);
+    e = e.next;
+  }
+}
 function createSubscriber(start) {
   let subscribers = 0;
   let version = source(0);
@@ -1469,7 +2247,6 @@ class Boundary {
       var anchor = create_text();
       fragment.append(anchor);
       this.#main_effect = this.#run(() => {
-        Batch.ensure();
         return branch(() => this.#children(anchor));
       });
       if (this.#pending_count === 0) {
@@ -1482,7 +2259,10 @@ class Boundary {
             this.#pending_effect = null;
           }
         );
-        this.#resolve();
+        this.#resolve(
+          /** @type {Batch} */
+          current_batch
+        );
       }
     });
   }
@@ -1503,24 +2283,21 @@ class Boundary {
         );
         this.#pending_effect = branch(() => pending(this.#anchor));
       } else {
-        this.#resolve();
+        this.#resolve(
+          /** @type {Batch} */
+          current_batch
+        );
       }
     } catch (error) {
       this.error(error);
     }
   }
-  #resolve() {
+  /**
+   * @param {Batch} batch
+   */
+  #resolve(batch) {
     this.is_pending = false;
-    for (const e of this.#dirty_effects) {
-      set_signal_status(e, DIRTY);
-      schedule_effect(e);
-    }
-    for (const e of this.#maybe_dirty_effects) {
-      set_signal_status(e, MAYBE_DIRTY);
-      schedule_effect(e);
-    }
-    this.#dirty_effects.clear();
-    this.#maybe_dirty_effects.clear();
+    batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
   }
   /**
    * Defer an effect inside a pending boundary until the boundary resolves
@@ -1551,6 +2328,7 @@ class Boundary {
     set_active_reaction(this.#effect);
     set_component_context(this.#effect.ctx);
     try {
+      Batch.ensure();
       return fn();
     } catch (e) {
       handle_error(e);
@@ -1565,17 +2343,18 @@ class Boundary {
    * Updates the pending count associated with the currently visible pending snippet,
    * if any, such that we can replace the snippet with content once work is done
    * @param {1 | -1} d
+   * @param {Batch} batch
    */
-  #update_pending_count(d) {
+  #update_pending_count(d, batch) {
     if (!this.has_pending_snippet()) {
       if (this.parent) {
-        this.parent.#update_pending_count(d);
+        this.parent.#update_pending_count(d, batch);
       }
       return;
     }
     this.#pending_count += d;
     if (this.#pending_count === 0) {
-      this.#resolve();
+      this.#resolve(batch);
       if (this.#pending_effect) {
         pause_effect(this.#pending_effect, () => {
           this.#pending_effect = null;
@@ -1592,9 +2371,10 @@ class Boundary {
    * and controls when the current `pending` snippet (if any) is removed.
    * Do not call from inside the class
    * @param {1 | -1} d
+   * @param {Batch} batch
    */
-  update_pending_count(d) {
-    this.#update_pending_count(d);
+  update_pending_count(d, batch) {
+    this.#update_pending_count(d, batch);
     this.#local_pending_count += d;
     if (!this.#effect_pending || this.#pending_count_update_queued) return;
     this.#pending_count_update_queued = true;
@@ -1614,11 +2394,24 @@ class Boundary {
   }
   /** @param {unknown} error */
   error(error) {
-    var onerror = this.#props.onerror;
-    let failed = this.#props.failed;
-    if (!onerror && !failed) {
+    if (!this.#props.onerror && !this.#props.failed) {
       throw error;
     }
+    if (current_batch?.is_fork) {
+      if (this.#main_effect) current_batch.skip_effect(this.#main_effect);
+      if (this.#pending_effect) current_batch.skip_effect(this.#pending_effect);
+      if (this.#failed_effect) current_batch.skip_effect(this.#failed_effect);
+      current_batch.on_fork_commit(() => {
+        this.#handle_error(error);
+      });
+    } else {
+      this.#handle_error(error);
+    }
+  }
+  /**
+   * @param {unknown} error
+   */
+  #handle_error(error) {
     if (this.#main_effect) {
       destroy_effect(this.#main_effect);
       this.#main_effect = null;
@@ -1639,6 +2432,8 @@ class Boundary {
       next();
       set_hydrate_node(skip_nodes());
     }
+    var onerror = this.#props.onerror;
+    let failed = this.#props.failed;
     var did_reset = false;
     var calling_on_error = false;
     const reset = () => {
@@ -1656,7 +2451,6 @@ class Boundary {
         });
       }
       this.#run(() => {
-        Batch.ensure();
         this.#render();
       });
     };
@@ -1670,7 +2464,6 @@ class Boundary {
       }
       if (failed) {
         this.#failed_effect = this.#run(() => {
-          Batch.ensure();
           try {
             return branch(() => {
               var effect = (
@@ -1729,23 +2522,15 @@ function destroy_derived_effects(derived2) {
     }
   }
 }
-function get_derived_parent_effect(derived2) {
-  var parent = derived2.parent;
-  while (parent !== null) {
-    if ((parent.f & DERIVED) === 0) {
-      return (parent.f & DESTROYED) === 0 ? (
-        /** @type {Effect} */
-        parent
-      ) : null;
-    }
-    parent = parent.parent;
-  }
-  return null;
-}
 function execute_derived(derived2) {
   var value;
   var prev_active_effect = active_effect;
-  set_active_effect(get_derived_parent_effect(derived2));
+  var parent = derived2.parent;
+  if (!is_destroying_effect && parent !== null && (parent.f & (DESTROYED | INERT)) !== 0) {
+    derived_inert();
+    return derived2.v;
+  }
+  set_active_effect(parent);
   {
     try {
       derived2.f &= ~WAS_MARKED;
@@ -1762,7 +2547,12 @@ function update_derived(derived2) {
   if (!derived2.equals(value)) {
     derived2.wv = increment_write_version();
     if (!current_batch?.is_fork || derived2.deps === null) {
-      derived2.v = value;
+      if (current_batch !== null) {
+        current_batch.capture(derived2, value, true);
+        previous_batch?.capture(derived2, value, true);
+      } else {
+        derived2.v = value;
+      }
       if (derived2.deps === null) {
         set_signal_status(derived2, CLEAN);
         return;
@@ -1837,19 +2627,13 @@ function set(source2, value, should_proxy = false) {
     state_unsafe_mutation();
   }
   let new_value = should_proxy ? proxy(value) : value;
-  return internal_set(source2, new_value);
+  return internal_set(source2, new_value, legacy_updates);
 }
-function internal_set(source2, value) {
+function internal_set(source2, value, updated_during_traversal = null) {
   if (!source2.equals(value)) {
-    var old_value = source2.v;
-    if (is_destroying_effect) {
-      old_values.set(source2, value);
-    } else {
-      old_values.set(source2, old_value);
-    }
-    source2.v = value;
+    old_values.set(source2, is_destroying_effect ? value : source2.v);
     var batch = Batch.ensure();
-    batch.capture(source2, old_value);
+    batch.capture(source2, value);
     if ((source2.f & DERIVED) !== 0) {
       const derived2 = (
         /** @type {Derived} */
@@ -1858,10 +2642,12 @@ function internal_set(source2, value) {
       if ((source2.f & DIRTY) !== 0) {
         execute_derived(derived2);
       }
-      update_derived_status(derived2);
+      if (batch_values === null) {
+        update_derived_status(derived2);
+      }
     }
     source2.wv = increment_write_version();
-    mark_reactions(source2, DIRTY);
+    mark_reactions(source2, DIRTY, updated_during_traversal);
     if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
       if (untracked_writes === null) {
         set_untracked_writes([source2]);
@@ -1881,7 +2667,13 @@ function flush_eager_effects() {
     if ((effect.f & CLEAN) !== 0) {
       set_signal_status(effect, MAYBE_DIRTY);
     }
-    if (is_dirty(effect)) {
+    let dirty;
+    try {
+      dirty = is_dirty(effect);
+    } catch {
+      dirty = true;
+    }
+    if (dirty) {
       update_effect(effect);
     }
   }
@@ -1890,7 +2682,7 @@ function flush_eager_effects() {
 function increment(source2) {
   set(source2, source2.v + 1);
 }
-function mark_reactions(signal, status) {
+function mark_reactions(signal, status, updated_during_traversal) {
   var reactions = signal.reactions;
   if (reactions === null) return;
   var length = reactions.length;
@@ -1901,29 +2693,36 @@ function mark_reactions(signal, status) {
     if (not_dirty) {
       set_signal_status(reaction, status);
     }
-    if ((flags2 & DERIVED) !== 0) {
+    if ((flags2 & EAGER_EFFECT) !== 0) {
+      eager_effects.add(
+        /** @type {Effect} */
+        reaction
+      );
+    } else if ((flags2 & DERIVED) !== 0) {
       var derived2 = (
         /** @type {Derived} */
         reaction
       );
       batch_values?.delete(derived2);
       if ((flags2 & WAS_MARKED) === 0) {
-        if (flags2 & CONNECTED) {
+        if (flags2 & CONNECTED && (active_effect === null || (active_effect.f & REACTION_IS_UPDATING) === 0)) {
           reaction.f |= WAS_MARKED;
         }
-        mark_reactions(derived2, MAYBE_DIRTY);
+        mark_reactions(derived2, MAYBE_DIRTY, updated_during_traversal);
       }
     } else if (not_dirty) {
-      if ((flags2 & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
-        eager_block_effects.add(
-          /** @type {Effect} */
-          reaction
-        );
-      }
-      schedule_effect(
+      var effect = (
         /** @type {Effect} */
         reaction
       );
+      if ((flags2 & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
+        eager_block_effects.add(effect);
+      }
+      if (updated_during_traversal !== null) {
+        updated_during_traversal.push(effect);
+      } else {
+        schedule_effect(effect);
+      }
     }
   }
 }
@@ -2131,14 +2930,13 @@ function init_operations() {
   first_child_getter = get_descriptor(node_prototype, "firstChild").get;
   next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
   if (is_extensible(element_prototype)) {
-    element_prototype.__click = void 0;
-    element_prototype.__className = void 0;
-    element_prototype.__attributes = null;
-    element_prototype.__style = void 0;
+    element_prototype[CLASS_CACHE] = void 0;
+    element_prototype[ATTRIBUTES_CACHE] = null;
+    element_prototype[STYLE_CACHE] = void 0;
     element_prototype.__e = void 0;
   }
   if (is_extensible(text_prototype)) {
-    text_prototype.__t = void 0;
+    text_prototype[TEXT_CACHE] = void 0;
   }
 }
 function create_text(value = "") {
@@ -2183,7 +2981,7 @@ function push_effect(effect, parent_effect) {
     parent_effect.last = effect;
   }
 }
-function create_effect(type, fn, sync) {
+function create_effect(type, fn) {
   var parent = active_effect;
   if (parent !== null && (parent.f & INERT) !== 0) {
     type |= INERT;
@@ -2204,22 +3002,27 @@ function create_effect(type, fn, sync) {
     wv: 0,
     ac: null
   };
-  if (sync) {
+  current_batch?.register_created_effect(effect);
+  var e = effect;
+  if ((type & EFFECT) !== 0) {
+    if (collected_effects !== null) {
+      collected_effects.push(effect);
+    } else {
+      Batch.ensure().schedule(effect);
+    }
+  } else if (fn !== null) {
     try {
       update_effect(effect);
     } catch (e2) {
       destroy_effect(effect);
       throw e2;
     }
-  } else if (fn !== null) {
-    schedule_effect(effect);
-  }
-  var e = effect;
-  if (sync && e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && // either `null`, or a singular child
-  (e.f & EFFECT_PRESERVED) === 0) {
-    e = e.first;
-    if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 0 && e !== null) {
-      e.f |= EFFECT_TRANSPARENT;
+    if (e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && // either `null`, or a singular child
+    (e.f & EFFECT_PRESERVED) === 0) {
+      e = e.first;
+      if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 0 && e !== null) {
+        e.f |= EFFECT_TRANSPARENT;
+      }
     }
   }
   if (e !== null) {
@@ -2241,11 +3044,11 @@ function effect_tracking() {
   return active_reaction !== null && !untracking;
 }
 function create_user_effect(fn) {
-  return create_effect(EFFECT | USER_EFFECT, fn, false);
+  return create_effect(EFFECT | USER_EFFECT, fn);
 }
 function component_root(fn) {
   Batch.ensure();
-  const effect = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn, true);
+  const effect = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn);
   return (options = {}) => {
     return new Promise((fulfil) => {
       if (options.outro) {
@@ -2261,14 +3064,14 @@ function component_root(fn) {
   };
 }
 function render_effect(fn, flags2 = 0) {
-  return create_effect(RENDER_EFFECT | flags2, fn, true);
+  return create_effect(RENDER_EFFECT | flags2, fn);
 }
 function block(fn, flags2 = 0) {
-  var effect = create_effect(BLOCK_EFFECT | flags2, fn, true);
+  var effect = create_effect(BLOCK_EFFECT | flags2, fn);
   return effect;
 }
 function branch(fn) {
-  return create_effect(BRANCH_EFFECT | EFFECT_PRESERVED, fn, true);
+  return create_effect(BRANCH_EFFECT | EFFECT_PRESERVED, fn);
 }
 function execute_effect_teardown(effect) {
   var teardown = effect.teardown;
@@ -2324,9 +3127,9 @@ function destroy_effect(effect, remove_dom = true) {
     );
     removed = true;
   }
+  set_signal_status(effect, DESTROYING);
   destroy_effect_children(effect, remove_dom && !removed);
   remove_reactions(effect, 0);
-  set_signal_status(effect, DESTROYED);
   var transitions = effect.nodes && effect.nodes.t;
   if (transitions !== null) {
     for (const transition of transitions) {
@@ -2334,11 +3137,13 @@ function destroy_effect(effect, remove_dom = true) {
     }
   }
   execute_effect_teardown(effect);
+  effect.f ^= DESTROYING;
+  effect.f |= DESTROYED;
   var parent = effect.parent;
   if (parent !== null && parent.first !== null) {
     unlink_effect(effect);
   }
-  effect.next = effect.prev = effect.teardown = effect.ctx = effect.deps = effect.fn = effect.nodes = effect.ac = null;
+  effect.next = effect.prev = effect.teardown = effect.ctx = effect.deps = effect.fn = effect.nodes = effect.ac = effect.b = null;
 }
 function remove_effect_dom(node, end) {
   while (node !== null) {
@@ -2389,11 +3194,13 @@ function pause_children(effect, transitions, local) {
   var child = effect.first;
   while (child !== null) {
     var sibling = child.next;
-    var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
-    // it means the parent block effect was pruned. In that case,
-    // transparency information was transferred to the branch effect.
-    (child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0;
-    pause_children(child, transitions, transparent ? local : false);
+    if ((child.f & ROOT_EFFECT) === 0) {
+      var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0;
+      pause_children(child, transitions, transparent ? local : false);
+    }
     child = sibling;
   }
 }
@@ -2643,7 +3450,9 @@ function remove_reaction(signal, dependency) {
       derived2.f ^= CONNECTED;
       derived2.f &= ~WAS_MARKED;
     }
-    update_derived_status(derived2);
+    if (derived2.v !== UNINITIALIZED) {
+      update_derived_status(derived2);
+    }
     freeze_derived_effects(derived2);
     remove_reactions(derived2, 0);
   }
@@ -2827,664 +3636,117 @@ const PASSIVE_EVENTS = ["touchstart", "touchmove"];
 function is_passive_event(name) {
   return PASSIVE_EVENTS.includes(name);
 }
-const event_symbol = /* @__PURE__ */ Symbol("events");
-const all_registered_events = /* @__PURE__ */ new Set();
-const root_event_handles = /* @__PURE__ */ new Set();
-let last_propagated_event = null;
-function handle_event_propagation(event) {
-  var handler_element = this;
-  var owner_document = (
-    /** @type {Node} */
-    handler_element.ownerDocument
-  );
-  var event_name = event.type;
-  var path = event.composedPath?.() || [];
-  var current_target = (
-    /** @type {null | Element} */
-    path[0] || event.target
-  );
-  last_propagated_event = event;
-  var path_idx = 0;
-  var handled_at = last_propagated_event === event && event[event_symbol];
-  if (handled_at) {
-    var at_idx = path.indexOf(handled_at);
-    if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
-    window)) {
-      event[event_symbol] = handler_element;
-      return;
-    }
-    var handler_idx = path.indexOf(handler_element);
-    if (handler_idx === -1) {
-      return;
-    }
-    if (at_idx <= handler_idx) {
-      path_idx = at_idx;
-    }
+const INVALID_ATTR_NAME_CHAR_REGEX = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
+function render(component, options = {}) {
+  if (options.csp?.hash && options.csp.nonce) {
+    invalid_csp();
   }
-  current_target = /** @type {Element} */
-  path[path_idx] || event.target;
-  if (current_target === handler_element) return;
-  define_property(event, "currentTarget", {
-    configurable: true,
-    get() {
-      return current_target || owner_document;
-    }
+  return Renderer.render(
+    /** @type {Component<Props>} */
+    component,
+    options
+  );
+}
+function head(hash, renderer, fn) {
+  renderer.head((renderer2) => {
+    renderer2.push(`<!--${hash}-->`);
+    renderer2.child(fn);
+    renderer2.push(EMPTY_COMMENT);
   });
-  var previous_reaction = active_reaction;
-  var previous_effect = active_effect;
-  set_active_reaction(null);
-  set_active_effect(null);
-  try {
-    var throw_error;
-    var other_errors = [];
-    while (current_target !== null) {
-      var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
-      current_target.host || null;
-      try {
-        var delegated = current_target[event_symbol]?.[event_name];
-        if (delegated != null && (!/** @type {any} */
-        current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
-        // -> the target could not have been disabled because it emits the event in the first place
-        event.target === current_target)) {
-          delegated.call(current_target, event);
-        }
-      } catch (error) {
-        if (throw_error) {
-          other_errors.push(error);
-        } else {
-          throw_error = error;
-        }
-      }
-      if (event.cancelBubble || parent_element === handler_element || parent_element === null) {
-        break;
-      }
-      current_target = parent_element;
-    }
-    if (throw_error) {
-      for (let error of other_errors) {
-        queueMicrotask(() => {
-          throw error;
-        });
-      }
-      throw throw_error;
-    }
-  } finally {
-    event[event_symbol] = handler_element;
-    delete event.currentTarget;
-    set_active_reaction(previous_reaction);
-    set_active_effect(previous_effect);
-  }
-}
-function assign_nodes(start, end) {
-  var effect = (
-    /** @type {Effect} */
-    active_effect
-  );
-  if (effect.nodes === null) {
-    effect.nodes = { start, end, a: null, t: null };
-  }
-}
-function mount(component, options) {
-  return _mount(component, options);
-}
-function hydrate(component, options) {
-  init_operations();
-  options.intro = options.intro ?? false;
-  const target = options.target;
-  const was_hydrating = hydrating;
-  const previous_hydrate_node = hydrate_node;
-  try {
-    var anchor = /* @__PURE__ */ get_first_child(target);
-    while (anchor && (anchor.nodeType !== COMMENT_NODE || /** @type {Comment} */
-    anchor.data !== HYDRATION_START)) {
-      anchor = /* @__PURE__ */ get_next_sibling(anchor);
-    }
-    if (!anchor) {
-      throw HYDRATION_ERROR;
-    }
-    set_hydrating(true);
-    set_hydrate_node(
-      /** @type {Comment} */
-      anchor
-    );
-    const instance = _mount(component, { ...options, anchor });
-    set_hydrating(false);
-    return (
-      /**  @type {Exports} */
-      instance
-    );
-  } catch (error) {
-    if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) {
-      throw error;
-    }
-    if (error !== HYDRATION_ERROR) {
-      console.warn("Failed to hydrate: ", error);
-    }
-    if (options.recover === false) {
-      hydration_failed();
-    }
-    init_operations();
-    clear_text_content(target);
-    set_hydrating(false);
-    return mount(component, options);
-  } finally {
-    set_hydrating(was_hydrating);
-    set_hydrate_node(previous_hydrate_node);
-  }
-}
-const listeners = /* @__PURE__ */ new Map();
-function _mount(Component, { target, anchor, props = {}, events, context: context2, intro = true, transformError }) {
-  init_operations();
-  var component = void 0;
-  var unmount2 = component_root(() => {
-    var anchor_node = anchor ?? target.appendChild(create_text());
-    boundary(
-      /** @type {TemplateNode} */
-      anchor_node,
-      {
-        pending: () => {
-        }
-      },
-      (anchor_node2) => {
-        push$1({});
-        var ctx = (
-          /** @type {ComponentContext} */
-          component_context
-        );
-        if (context2) ctx.c = context2;
-        if (events) {
-          props.$$events = events;
-        }
-        if (hydrating) {
-          assign_nodes(
-            /** @type {TemplateNode} */
-            anchor_node2,
-            null
-          );
-        }
-        component = Component(anchor_node2, props) || {};
-        if (hydrating) {
-          active_effect.nodes.end = hydrate_node;
-          if (hydrate_node === null || hydrate_node.nodeType !== COMMENT_NODE || /** @type {Comment} */
-          hydrate_node.data !== HYDRATION_END) {
-            hydration_mismatch();
-            throw HYDRATION_ERROR;
-          }
-        }
-        pop$1();
-      },
-      transformError
-    );
-    var registered_events = /* @__PURE__ */ new Set();
-    var event_handle = (events2) => {
-      for (var i = 0; i < events2.length; i++) {
-        var event_name = events2[i];
-        if (registered_events.has(event_name)) continue;
-        registered_events.add(event_name);
-        var passive = is_passive_event(event_name);
-        for (const node of [target, document]) {
-          var counts = listeners.get(node);
-          if (counts === void 0) {
-            counts = /* @__PURE__ */ new Map();
-            listeners.set(node, counts);
-          }
-          var count = counts.get(event_name);
-          if (count === void 0) {
-            node.addEventListener(event_name, handle_event_propagation, { passive });
-            counts.set(event_name, 1);
-          } else {
-            counts.set(event_name, count + 1);
-          }
-        }
-      }
-    };
-    event_handle(array_from(all_registered_events));
-    root_event_handles.add(event_handle);
-    return () => {
-      for (var event_name of registered_events) {
-        for (const node of [target, document]) {
-          var counts = (
-            /** @type {Map<string, number>} */
-            listeners.get(node)
-          );
-          var count = (
-            /** @type {number} */
-            counts.get(event_name)
-          );
-          if (--count == 0) {
-            node.removeEventListener(event_name, handle_event_propagation);
-            counts.delete(event_name);
-            if (counts.size === 0) {
-              listeners.delete(node);
-            }
-          } else {
-            counts.set(event_name, count);
-          }
-        }
-      }
-      root_event_handles.delete(event_handle);
-      if (anchor_node !== anchor) {
-        anchor_node.parentNode?.removeChild(anchor_node);
-      }
-    };
-  });
-  mounted_components.set(component, unmount2);
-  return component;
-}
-let mounted_components = /* @__PURE__ */ new WeakMap();
-function unmount(component, options) {
-  const fn = mounted_components.get(component);
-  if (fn) {
-    mounted_components.delete(component);
-    return fn(options);
-  }
-  return Promise.resolve();
-}
-const ATTR_REGEX = /[&"<]/g;
-const CONTENT_REGEX = /[&<]/g;
-function escape_html(value, is_attr) {
-  const str = String(value ?? "");
-  const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
-  pattern.lastIndex = 0;
-  let escaped2 = "";
-  let last = 0;
-  while (pattern.test(str)) {
-    const i = pattern.lastIndex - 1;
-    const ch = str[i];
-    escaped2 += str.substring(last, i) + (ch === "&" ? "&amp;" : ch === '"' ? "&quot;" : "&lt;");
-    last = i + 1;
-  }
-  return escaped2 + str.substring(last);
-}
-function r(e) {
-  var t, f, n = "";
-  if ("string" == typeof e || "number" == typeof e) n += e;
-  else if ("object" == typeof e) if (Array.isArray(e)) {
-    var o = e.length;
-    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
-  } else for (f in e) e[f] && (n && (n += " "), n += f);
-  return n;
-}
-function clsx$1() {
-  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
-  return n;
-}
-const replacements = {
-  translate: /* @__PURE__ */ new Map([
-    [true, "yes"],
-    [false, "no"]
-  ])
-};
-function attr(name, value, is_boolean = false) {
-  if (name === "hidden" && value !== "until-found") {
-    is_boolean = true;
-  }
-  if (value == null || !value && is_boolean) return "";
-  const normalized = has_own_property.call(replacements, name) && replacements[name].get(value) || value;
-  const assignment = is_boolean ? `=""` : `="${escape_html(normalized, true)}"`;
-  return ` ${name}${assignment}`;
-}
-function clsx(value) {
-  if (typeof value === "object") {
-    return clsx$1(value);
-  } else {
-    return value ?? "";
-  }
-}
-const whitespace = [..." 	\n\r\f \v\uFEFF"];
-function to_class(value, hash, directives) {
-  var classname = value == null ? "" : "" + value;
-  if (hash) {
-    classname = classname ? classname + " " + hash : hash;
-  }
-  if (directives) {
-    for (var key of Object.keys(directives)) {
-      if (directives[key]) {
-        classname = classname ? classname + " " + key : key;
-      } else if (classname.length) {
-        var len = key.length;
-        var a = 0;
-        while ((a = classname.indexOf(key, a)) >= 0) {
-          var b = a + len;
-          if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) {
-            classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
-          } else {
-            a = b;
-          }
-        }
-      }
-    }
-  }
-  return classname === "" ? null : classname;
-}
-function append_styles(styles, important = false) {
-  var separator = important ? " !important;" : ";";
-  var css = "";
-  for (var key of Object.keys(styles)) {
-    var value = styles[key];
-    if (value != null && value !== "") {
-      css += " " + key + ": " + value + separator;
-    }
-  }
-  return css;
-}
-function to_css_name(name) {
-  if (name[0] !== "-" || name[1] !== "-") {
-    return name.toLowerCase();
-  }
-  return name;
-}
-function to_style(value, styles) {
-  if (styles) {
-    var new_style = "";
-    var normal_styles;
-    var important_styles;
-    if (Array.isArray(styles)) {
-      normal_styles = styles[0];
-      important_styles = styles[1];
-    } else {
-      normal_styles = styles;
-    }
-    if (value) {
-      value = String(value).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
-      var in_str = false;
-      var in_apo = 0;
-      var in_comment = false;
-      var reserved_names = [];
-      if (normal_styles) {
-        reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
-      }
-      if (important_styles) {
-        reserved_names.push(...Object.keys(important_styles).map(to_css_name));
-      }
-      var start_index = 0;
-      var name_index = -1;
-      const len = value.length;
-      for (var i = 0; i < len; i++) {
-        var c = value[i];
-        if (in_comment) {
-          if (c === "/" && value[i - 1] === "*") {
-            in_comment = false;
-          }
-        } else if (in_str) {
-          if (in_str === c) {
-            in_str = false;
-          }
-        } else if (c === "/" && value[i + 1] === "*") {
-          in_comment = true;
-        } else if (c === '"' || c === "'") {
-          in_str = c;
-        } else if (c === "(") {
-          in_apo++;
-        } else if (c === ")") {
-          in_apo--;
-        }
-        if (!in_comment && in_str === false && in_apo === 0) {
-          if (c === ":" && name_index === -1) {
-            name_index = i;
-          } else if (c === ";" || i === len - 1) {
-            if (name_index !== -1) {
-              var name = to_css_name(value.substring(start_index, name_index).trim());
-              if (!reserved_names.includes(name)) {
-                if (c !== ";") {
-                  i++;
-                }
-                var property = value.substring(start_index, i).trim();
-                new_style += " " + property + ";";
-              }
-            }
-            start_index = i + 1;
-            name_index = -1;
-          }
-        }
-      }
-    }
-    if (normal_styles) {
-      new_style += append_styles(normal_styles);
-    }
-    if (important_styles) {
-      new_style += append_styles(important_styles, true);
-    }
-    new_style = new_style.trim();
-    return new_style === "" ? null : new_style;
-  }
-  return value == null ? null : String(value);
-}
-function asClassComponent$1(component) {
-  return class extends Svelte4Component {
-    /** @param {any} options */
-    constructor(options) {
-      super({
-        component,
-        ...options
-      });
-    }
-  };
-}
-class Svelte4Component {
-  /** @type {any} */
-  #events;
-  /** @type {Record<string, any>} */
-  #instance;
-  /**
-   * @param {ComponentConstructorOptions & {
-   *  component: any;
-   * }} options
-   */
-  constructor(options) {
-    var sources = /* @__PURE__ */ new Map();
-    var add_source = (key, value) => {
-      var s = /* @__PURE__ */ mutable_source(value, false, false);
-      sources.set(key, s);
-      return s;
-    };
-    const props = new Proxy(
-      { ...options.props || {}, $$events: {} },
-      {
-        get(target, prop) {
-          return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
-        },
-        has(target, prop) {
-          if (prop === LEGACY_PROPS) return true;
-          get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
-          return Reflect.has(target, prop);
-        },
-        set(target, prop, value) {
-          set(sources.get(prop) ?? add_source(prop, value), value);
-          return Reflect.set(target, prop, value);
-        }
-      }
-    );
-    this.#instance = (options.hydrate ? hydrate : mount)(options.component, {
-      target: options.target,
-      anchor: options.anchor,
-      props,
-      context: options.context,
-      intro: options.intro ?? false,
-      recover: options.recover,
-      transformError: options.transformError
-    });
-    if (!async_mode_flag && (!options?.props?.$$host || options.sync === false)) {
-      flushSync();
-    }
-    this.#events = props.$$events;
-    for (const key of Object.keys(this.#instance)) {
-      if (key === "$set" || key === "$destroy" || key === "$on") continue;
-      define_property(this, key, {
-        get() {
-          return this.#instance[key];
-        },
-        /** @param {any} value */
-        set(value) {
-          this.#instance[key] = value;
-        },
-        enumerable: true
-      });
-    }
-    this.#instance.$set = /** @param {Record<string, any>} next */
-    (next2) => {
-      Object.assign(props, next2);
-    };
-    this.#instance.$destroy = () => {
-      unmount(this.#instance);
-    };
+}
+function attributes(attrs, css_hash, classes, styles, flags2 = 0) {
+  if (styles) {
+    attrs.style = to_style(attrs.style, styles);
   }
-  /** @param {Record<string, any>} props */
-  $set(props) {
-    this.#instance.$set(props);
+  if (attrs.class) {
+    attrs.class = clsx(attrs.class);
   }
-  /**
-   * @param {string} event
-   * @param {(...args: any[]) => any} callback
-   * @returns {any}
-   */
-  $on(event, callback) {
-    this.#events[event] = this.#events[event] || [];
-    const cb = (...args) => callback.call(this, ...args);
-    this.#events[event].push(cb);
-    return () => {
-      this.#events[event] = this.#events[event].filter(
-        /** @param {any} fn */
-        (fn) => fn !== cb
-      );
-    };
+  if (css_hash || classes) {
+    attrs.class = to_class(attrs.class, css_hash, classes);
   }
-  $destroy() {
-    this.#instance.$destroy();
+  let attr_str = "";
+  let name;
+  const is_html = (flags2 & ELEMENT_IS_NAMESPACED) === 0;
+  const lowercase = (flags2 & ELEMENT_PRESERVE_ATTRIBUTE_CASE) === 0;
+  const is_input = (flags2 & ELEMENT_IS_INPUT) !== 0;
+  for (name of Object.keys(attrs)) {
+    if (typeof attrs[name] === "function") continue;
+    if (name[0] === "$" && name[1] === "$") continue;
+    if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
+    var value = attrs[name];
+    var lower = name.toLowerCase();
+    if (lowercase) name = lower;
+    if (lower.length > 2 && lower.startsWith("on")) continue;
+    if (is_input) {
+      if (name === "defaultvalue" || name === "defaultchecked") {
+        name = name === "defaultvalue" ? "value" : "checked";
+        if (attrs[name]) continue;
+      }
+    }
+    attr_str += attr(name, value, is_html && is_boolean_attribute(name));
   }
+  return attr_str;
 }
-const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
-const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
-const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
-const EMPTY_COMMENT = `<!---->`;
-let controller = null;
-function abort() {
-  controller?.abort(STALE_REACTION);
-  controller = null;
-}
-function async_local_storage_unavailable() {
-  const error = new Error(`async_local_storage_unavailable
-The node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.
-https://svelte.dev/e/async_local_storage_unavailable`);
-  error.name = "Svelte error";
-  throw error;
-}
-function await_invalid() {
-  const error = new Error(`await_invalid
-Encountered asynchronous work while rendering synchronously.
-https://svelte.dev/e/await_invalid`);
-  error.name = "Svelte error";
-  throw error;
-}
-function html_deprecated() {
-  const error = new Error(`html_deprecated
-The \`html\` property of server render results has been deprecated. Use \`body\` instead.
-https://svelte.dev/e/html_deprecated`);
-  error.name = "Svelte error";
-  throw error;
-}
-function invalid_csp() {
-  const error = new Error(`invalid_csp
-\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.
-https://svelte.dev/e/invalid_csp`);
-  error.name = "Svelte error";
-  throw error;
-}
-function server_context_required() {
-  const error = new Error(`server_context_required
-Could not resolve \`render\` context.
-https://svelte.dev/e/server_context_required`);
-  error.name = "Svelte error";
-  throw error;
-}
-var ssr_context = null;
-function set_ssr_context(v) {
-  ssr_context = v;
-}
-function getContext(key) {
-  const context_map = get_or_init_context_map();
-  const result = (
-    /** @type {T} */
-    context_map.get(key)
-  );
-  return result;
-}
-function setContext(key, context2) {
-  get_or_init_context_map().set(key, context2);
-  return context2;
-}
-function get_or_init_context_map(name) {
-  if (ssr_context === null) {
-    lifecycle_outside_component();
-  }
-  return ssr_context.c ??= new Map(get_parent_context(ssr_context) || void 0);
+function stringify(value) {
+  return typeof value === "string" ? value : value == null ? "" : value + "";
 }
-function push(fn) {
-  ssr_context = { p: ssr_context, c: null, r: null };
+function attr_class(value, hash, directives) {
+  var result = to_class(value, hash, directives);
+  return result ? ` class="${escape_html(result, true)}"` : "";
 }
-function pop() {
-  ssr_context = /** @type {SSRContext} */
-  ssr_context.p;
+function attr_style(value, directives) {
+  var result = to_style(value, directives);
+  return result ? ` style="${escape_html(result, true)}"` : "";
 }
-function get_parent_context(ssr_context2) {
-  let parent = ssr_context2.p;
-  while (parent !== null) {
-    const context_map = parent.c;
-    if (context_map !== null) {
-      return context_map;
+function bind_props(props_parent, props_now) {
+  for (const key of Object.keys(props_now)) {
+    const initial_value = props_parent[key];
+    const value = props_now[key];
+    if (initial_value === void 0 && value !== void 0 && Object.getOwnPropertyDescriptor(props_parent, key)?.set) {
+      props_parent[key] = value;
     }
-    parent = parent.p;
   }
-  return null;
 }
-function unresolved_hydratable(key, stack) {
-  {
-    console.warn(`https://svelte.dev/e/unresolved_hydratable`);
+function await_block(renderer, promise, pending_fn, then_fn) {
+  if (is_promise(promise)) {
+    renderer.push(BLOCK_OPEN);
+    promise.then(null, noop);
+    if (pending_fn !== null) {
+      pending_fn();
+    }
+  } else if (then_fn !== null) {
+    renderer.push(BLOCK_OPEN_ELSE);
+    then_fn(promise);
   }
 }
-let current_render = null;
-let context = null;
-function get_render_context() {
-  const store = context ?? als?.getStore();
-  if (!store) {
-    server_context_required();
+function ensure_array_like(array_like_or_iterator) {
+  if (array_like_or_iterator) {
+    return array_like_or_iterator.length !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator);
   }
-  return store;
+  return [];
 }
-async function with_render_context(fn) {
-  context = {
-    hydratable: {
-      lookup: /* @__PURE__ */ new Map(),
-      comparisons: [],
-      unresolved_promises: /* @__PURE__ */ new Map()
+function once(get_value) {
+  let value = (
+    /** @type {V} */
+    UNINITIALIZED
+  );
+  return () => {
+    if (value === UNINITIALIZED) {
+      value = get_value();
     }
+    return value;
   };
-  if (in_webcontainer()) {
-    const { promise, resolve } = deferred();
-    const previous_render = current_render;
-    current_render = promise;
-    await previous_render;
-    return fn().finally(resolve);
-  }
-  try {
-    if (als === null) {
-      async_local_storage_unavailable();
-    }
-    return als.run(context, fn);
-  } finally {
-    context = null;
-  }
-}
-let als = null;
-let als_import = null;
-function init_render_context() {
-  als_import ??= import('node:async_hooks').then((hooks) => {
-    als = new hooks.AsyncLocalStorage();
-  }).then(noop, noop);
-  return als_import;
 }
-function in_webcontainer() {
-  return !!globalThis.process?.versions?.webcontainer;
+function derived(fn) {
+  const get_value = ssr_context === null ? fn : once(fn);
+  let updated_value;
+  return function(new_value) {
+    if (arguments.length === 0) {
+      return updated_value ?? get_value();
+    }
+    updated_value = new_value;
+    return updated_value;
+  };
 }
 let text_encoder;
 let crypto;
@@ -3599,12 +3861,12 @@ class Renderer {
   async(blockers, fn) {
     let callback = fn;
     if (blockers.length > 0) {
-      const context2 = ssr_context;
+      const context = ssr_context;
       callback = (renderer) => {
         return Promise.all(blockers).then(() => {
           const previous_context = ssr_context;
           try {
-            set_ssr_context(context2);
+            set_ssr_context(context);
             return fn(renderer);
           } finally {
             set_ssr_context(previous_context);
@@ -3618,13 +3880,13 @@ class Renderer {
    * @param {Array<() => void>} thunks
    */
   run(thunks) {
-    const context2 = ssr_context;
+    const context = ssr_context;
     let promise = Promise.resolve(thunks[0]());
     const promises = [promise];
     for (const fn of thunks.slice(1)) {
       promise = promise.then(() => {
         const previous_context = ssr_context;
-        set_ssr_context(context2);
+        set_ssr_context(context);
         try {
           return fn();
         } finally {
@@ -3741,10 +4003,10 @@ class Renderer {
    * @returns {void}
    */
   component(fn, component_fn) {
-    push();
+    push$1();
     const child = this.child(fn);
     child.#is_component_body = true;
-    pop();
+    pop$1();
   }
   /**
    * @param {Record<string, any>} attrs
@@ -3868,9 +4130,11 @@ class Renderer {
       );
     }
     this.local = other.local;
-    this.#out = other.#out.map((item) => {
-      if (item instanceof Renderer) {
-        item.subsume(item);
+    this.#out = other.#out.map((item, i) => {
+      const current = this.#out[i];
+      if (current instanceof Renderer && item instanceof Renderer) {
+        current.subsume(item);
+        return current;
       }
       return item;
     });
@@ -3891,8 +4155,8 @@ class Renderer {
    */
   static #serialize_failed_boundary(error) {
     var json = JSON.stringify(error);
-    var escaped2 = json.replace(/>/g, "\\u003e").replace(/</g, "\\u003c");
-    return `<!--${HYDRATION_START_FAILED}${escaped2}-->`;
+    var escaped = json.replace(/>/g, "\\u003e").replace(/</g, "\\u003c");
+    return `<!--${HYDRATION_START_FAILED}${escaped}-->`;
   }
   /**
    * Only available on the server and when compiling with the `server` option.
@@ -4089,9 +4353,12 @@ class Renderer {
             content.head += boundary_content.head;
             content.body += boundary_content.body;
           } catch (error) {
-            const { context: context2, failed, transformError } = item.#boundary;
-            set_ssr_context(context2);
-            let transformed = await transformError(error);
+            const { context, failed, transformError } = item.#boundary;
+            set_ssr_context(context);
+            let promise = transformError(error);
+            set_ssr_context(null);
+            let transformed = await promise;
+            set_ssr_context(context);
             const failed_renderer = new Renderer(item.global, item);
             failed_renderer.type = item.type;
             failed_renderer.#out.push(Renderer.#serialize_failed_boundary(transformed));
@@ -4124,6 +4391,9 @@ class Renderer {
    * @returns {Renderer}
    */
   static #open_render(mode, component, options) {
+    if (options.idPrefix?.includes("--")) {
+      invalid_id_prefix();
+    }
     var previous_context = ssr_context;
     try {
       const renderer = new Renderer(
@@ -4134,8 +4404,8 @@ class Renderer {
           options.transformError
         )
       );
-      const context2 = { p: null, c: options.context ?? null, r: renderer };
-      set_ssr_context(context2);
+      const context = { p: null, c: options.context ?? null, r: renderer };
+      set_ssr_context(context);
       renderer.push(BLOCK_OPEN);
       component(renderer, options.props ?? {});
       renderer.push(BLOCK_CLOSE);
@@ -4238,147 +4508,390 @@ class SSRState {
     this.transformError = transformError ?? ((error) => {
       throw error;
     });
-    let uid = 1;
-    this.uid = () => `${id_prefix}s${uid++}`;
+    let uid2 = 1;
+    this.uid = () => `${id_prefix}s${uid2++}`;
   }
   get_title() {
-    return this.#title.value;
-  }
-  /**
-   * Performs a depth-first (lexicographic) comparison using the path. Rejects sets
-   * from earlier than or equal to the current value.
-   * @param {string} value
-   * @param {number[]} path
-   */
-  set_title(value, path) {
-    const current = this.#title.path;
-    let i = 0;
-    let l = Math.min(path.length, current.length);
-    while (i < l && path[i] === current[i]) i += 1;
-    if (path[i] === void 0) return;
-    if (current[i] === void 0 || path[i] > current[i]) {
-      this.#title.path = path;
-      this.#title.value = value;
-    }
-  }
-}
-const INVALID_ATTR_NAME_CHAR_REGEX = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
-function render(component, options = {}) {
-  if (options.csp?.hash && options.csp.nonce) {
-    invalid_csp();
-  }
-  return Renderer.render(
-    /** @type {Component<Props>} */
-    component,
-    options
-  );
-}
-function head(hash, renderer, fn) {
-  renderer.head((renderer2) => {
-    renderer2.push(`<!--${hash}-->`);
-    renderer2.child(fn);
-    renderer2.push(EMPTY_COMMENT);
-  });
-}
-function attributes(attrs, css_hash, classes, styles, flags2 = 0) {
-  if (styles) {
-    attrs.style = to_style(attrs.style, styles);
+    return this.#title.value;
   }
-  if (attrs.class) {
-    attrs.class = clsx(attrs.class);
+  /**
+   * Performs a depth-first (lexicographic) comparison using the path. Rejects sets
+   * from earlier than or equal to the current value.
+   * @param {string} value
+   * @param {number[]} path
+   */
+  set_title(value, path) {
+    const current = this.#title.path;
+    let i = 0;
+    let l = Math.min(path.length, current.length);
+    while (i < l && path[i] === current[i]) i += 1;
+    if (path[i] === void 0) return;
+    if (current[i] === void 0 || path[i] > current[i]) {
+      this.#title.path = path;
+      this.#title.value = value;
+    }
   }
-  if (css_hash || classes) {
-    attrs.class = to_class(attrs.class, css_hash, classes);
+}
+const event_symbol = /* @__PURE__ */ Symbol("events");
+const all_registered_events = /* @__PURE__ */ new Set();
+const root_event_handles = /* @__PURE__ */ new Set();
+let last_propagated_event = null;
+function handle_event_propagation(event) {
+  var handler_element = this;
+  var owner_document = (
+    /** @type {Node} */
+    handler_element.ownerDocument
+  );
+  var event_name = event.type;
+  var path = event.composedPath?.() || [];
+  var current_target = (
+    /** @type {null | Element} */
+    path[0] || event.target
+  );
+  last_propagated_event = event;
+  var path_idx = 0;
+  var handled_at = last_propagated_event === event && event[event_symbol];
+  if (handled_at) {
+    var at_idx = path.indexOf(handled_at);
+    if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
+    window)) {
+      event[event_symbol] = handler_element;
+      return;
+    }
+    var handler_idx = path.indexOf(handler_element);
+    if (handler_idx === -1) {
+      return;
+    }
+    if (at_idx <= handler_idx) {
+      path_idx = at_idx;
+    }
   }
-  let attr_str = "";
-  let name;
-  const is_html = (flags2 & ELEMENT_IS_NAMESPACED) === 0;
-  const lowercase = (flags2 & ELEMENT_PRESERVE_ATTRIBUTE_CASE) === 0;
-  const is_input = (flags2 & ELEMENT_IS_INPUT) !== 0;
-  for (name of Object.keys(attrs)) {
-    if (typeof attrs[name] === "function") continue;
-    if (name[0] === "$" && name[1] === "$") continue;
-    if (INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
-    var value = attrs[name];
-    if (lowercase) {
-      name = name.toLowerCase();
+  current_target = /** @type {Element} */
+  path[path_idx] || event.target;
+  if (current_target === handler_element) return;
+  define_property(event, "currentTarget", {
+    configurable: true,
+    get() {
+      return current_target || owner_document;
     }
-    if (name.length > 2 && name.startsWith("on")) continue;
-    if (is_input) {
-      if (name === "defaultvalue" || name === "defaultchecked") {
-        name = name === "defaultvalue" ? "value" : "checked";
-        if (attrs[name]) continue;
+  });
+  var previous_reaction = active_reaction;
+  var previous_effect = active_effect;
+  set_active_reaction(null);
+  set_active_effect(null);
+  try {
+    var throw_error;
+    var other_errors = [];
+    while (current_target !== null) {
+      var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
+      current_target.host || null;
+      try {
+        var delegated = current_target[event_symbol]?.[event_name];
+        if (delegated != null && (!/** @type {any} */
+        current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+        // -> the target could not have been disabled because it emits the event in the first place
+        event.target === current_target)) {
+          delegated.call(current_target, event);
+        }
+      } catch (error) {
+        if (throw_error) {
+          other_errors.push(error);
+        } else {
+          throw_error = error;
+        }
       }
+      if (event.cancelBubble || parent_element === handler_element || parent_element === null) {
+        break;
+      }
+      current_target = parent_element;
     }
-    attr_str += attr(name, value, is_html && is_boolean_attribute(name));
+    if (throw_error) {
+      for (let error of other_errors) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+      throw throw_error;
+    }
+  } finally {
+    event[event_symbol] = handler_element;
+    delete event.currentTarget;
+    set_active_reaction(previous_reaction);
+    set_active_effect(previous_effect);
   }
-  return attr_str;
-}
-function stringify(value) {
-  return typeof value === "string" ? value : value == null ? "" : value + "";
 }
-function attr_class(value, hash, directives) {
-  var result = to_class(value, hash, directives);
-  return result ? ` class="${escape_html(result, true)}"` : "";
+function assign_nodes(start, end) {
+  var effect = (
+    /** @type {Effect} */
+    active_effect
+  );
+  if (effect.nodes === null) {
+    effect.nodes = { start, end, a: null, t: null };
+  }
 }
-function attr_style(value, directives) {
-  var result = to_style(value, directives);
-  return result ? ` style="${escape_html(result, true)}"` : "";
+function mount(component, options) {
+  return _mount(component, options);
 }
-function bind_props(props_parent, props_now) {
-  for (const key of Object.keys(props_now)) {
-    const initial_value = props_parent[key];
-    const value = props_now[key];
-    if (initial_value === void 0 && value !== void 0 && Object.getOwnPropertyDescriptor(props_parent, key)?.set) {
-      props_parent[key] = value;
+function hydrate(component, options) {
+  init_operations();
+  options.intro = options.intro ?? false;
+  const target = options.target;
+  const was_hydrating = hydrating;
+  const previous_hydrate_node = hydrate_node;
+  try {
+    var anchor = /* @__PURE__ */ get_first_child(target);
+    while (anchor && (anchor.nodeType !== COMMENT_NODE || /** @type {Comment} */
+    anchor.data !== HYDRATION_START)) {
+      anchor = /* @__PURE__ */ get_next_sibling(anchor);
     }
-  }
-}
-function await_block(renderer, promise, pending_fn, then_fn) {
-  if (is_promise(promise)) {
-    renderer.push(BLOCK_OPEN);
-    promise.then(null, noop);
-    if (pending_fn !== null) {
-      pending_fn();
+    if (!anchor) {
+      throw HYDRATION_ERROR;
     }
-  } else if (then_fn !== null) {
-    renderer.push(BLOCK_OPEN_ELSE);
-    then_fn(promise);
+    set_hydrating(true);
+    set_hydrate_node(
+      /** @type {Comment} */
+      anchor
+    );
+    const instance = _mount(component, { ...options, anchor });
+    set_hydrating(false);
+    return (
+      /**  @type {Exports} */
+      instance
+    );
+  } catch (error) {
+    if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) {
+      throw error;
+    }
+    if (error !== HYDRATION_ERROR) {
+      console.warn("Failed to hydrate: ", error);
+    }
+    if (options.recover === false) {
+      hydration_failed();
+    }
+    init_operations();
+    clear_text_content(target);
+    set_hydrating(false);
+    return mount(component, options);
+  } finally {
+    set_hydrating(was_hydrating);
+    set_hydrate_node(previous_hydrate_node);
   }
 }
-function ensure_array_like(array_like_or_iterator) {
-  if (array_like_or_iterator) {
-    return array_like_or_iterator.length !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator);
+const listeners = /* @__PURE__ */ new Map();
+function _mount(Component, { target, anchor, props = {}, events, context, intro = true, transformError }) {
+  init_operations();
+  var component = void 0;
+  var unmount2 = component_root(() => {
+    var anchor_node = anchor ?? target.appendChild(create_text());
+    boundary(
+      /** @type {TemplateNode} */
+      anchor_node,
+      {
+        pending: () => {
+        }
+      },
+      (anchor_node2) => {
+        push({});
+        var ctx = (
+          /** @type {ComponentContext} */
+          component_context
+        );
+        if (context) ctx.c = context;
+        if (events) {
+          props.$$events = events;
+        }
+        if (hydrating) {
+          assign_nodes(
+            /** @type {TemplateNode} */
+            anchor_node2,
+            null
+          );
+        }
+        component = Component(anchor_node2, props) || {};
+        if (hydrating) {
+          active_effect.nodes.end = hydrate_node;
+          if (hydrate_node === null || hydrate_node.nodeType !== COMMENT_NODE || /** @type {Comment} */
+          hydrate_node.data !== HYDRATION_END) {
+            hydration_mismatch();
+            throw HYDRATION_ERROR;
+          }
+        }
+        pop();
+      },
+      transformError
+    );
+    var registered_events = /* @__PURE__ */ new Set();
+    var event_handle = (events2) => {
+      for (var i = 0; i < events2.length; i++) {
+        var event_name = events2[i];
+        if (registered_events.has(event_name)) continue;
+        registered_events.add(event_name);
+        var passive = is_passive_event(event_name);
+        for (const node of [target, document]) {
+          var counts = listeners.get(node);
+          if (counts === void 0) {
+            counts = /* @__PURE__ */ new Map();
+            listeners.set(node, counts);
+          }
+          var count = counts.get(event_name);
+          if (count === void 0) {
+            node.addEventListener(event_name, handle_event_propagation, { passive });
+            counts.set(event_name, 1);
+          } else {
+            counts.set(event_name, count + 1);
+          }
+        }
+      }
+    };
+    event_handle(array_from(all_registered_events));
+    root_event_handles.add(event_handle);
+    return () => {
+      for (var event_name of registered_events) {
+        for (const node of [target, document]) {
+          var counts = (
+            /** @type {Map<string, number>} */
+            listeners.get(node)
+          );
+          var count = (
+            /** @type {number} */
+            counts.get(event_name)
+          );
+          if (--count == 0) {
+            node.removeEventListener(event_name, handle_event_propagation);
+            counts.delete(event_name);
+            if (counts.size === 0) {
+              listeners.delete(node);
+            }
+          } else {
+            counts.set(event_name, count);
+          }
+        }
+      }
+      root_event_handles.delete(event_handle);
+      if (anchor_node !== anchor) {
+        anchor_node.parentNode?.removeChild(anchor_node);
+      }
+    };
+  });
+  mounted_components.set(component, unmount2);
+  return component;
+}
+let mounted_components = /* @__PURE__ */ new WeakMap();
+function unmount(component, options) {
+  const fn = mounted_components.get(component);
+  if (fn) {
+    mounted_components.delete(component);
+    return fn(options);
   }
-  return [];
+  return Promise.resolve();
 }
-function once(get_value) {
-  let value = (
-    /** @type {V} */
-    UNINITIALIZED
-  );
-  return () => {
-    if (value === UNINITIALIZED) {
-      value = get_value();
+function asClassComponent$1(component) {
+  return class extends Svelte4Component {
+    /** @param {any} options */
+    constructor(options) {
+      super({
+        component,
+        ...options
+      });
     }
-    return value;
   };
 }
-function derived(fn) {
-  const get_value = ssr_context === null ? fn : once(fn);
-  let updated_value;
-  return function(new_value) {
-    if (arguments.length === 0) {
-      return updated_value ?? get_value();
+class Svelte4Component {
+  /** @type {any} */
+  #events;
+  /** @type {Record<string, any>} */
+  #instance;
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(options) {
+    var sources = /* @__PURE__ */ new Map();
+    var add_source = (key, value) => {
+      var s = /* @__PURE__ */ mutable_source(value, false, false);
+      sources.set(key, s);
+      return s;
+    };
+    const props = new Proxy(
+      { ...options.props || {}, $$events: {} },
+      {
+        get(target, prop) {
+          return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+        },
+        has(target, prop) {
+          if (prop === LEGACY_PROPS) return true;
+          get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+          return Reflect.has(target, prop);
+        },
+        set(target, prop, value) {
+          set(sources.get(prop) ?? add_source(prop, value), value);
+          return Reflect.set(target, prop, value);
+        }
+      }
+    );
+    this.#instance = (options.hydrate ? hydrate : mount)(options.component, {
+      target: options.target,
+      anchor: options.anchor,
+      props,
+      context: options.context,
+      intro: options.intro ?? false,
+      recover: options.recover,
+      transformError: options.transformError
+    });
+    if (!async_mode_flag && (!options?.props?.$$host || options.sync === false)) {
+      flushSync();
     }
-    updated_value = new_value;
-    return updated_value;
-  };
+    this.#events = props.$$events;
+    for (const key of Object.keys(this.#instance)) {
+      if (key === "$set" || key === "$destroy" || key === "$on") continue;
+      define_property(this, key, {
+        get() {
+          return this.#instance[key];
+        },
+        /** @param {any} value */
+        set(value) {
+          this.#instance[key] = value;
+        },
+        enumerable: true
+      });
+    }
+    this.#instance.$set = /** @param {Record<string, any>} next */
+    (next2) => {
+      Object.assign(props, next2);
+    };
+    this.#instance.$destroy = () => {
+      unmount(this.#instance);
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(props) {
+    this.#instance.$set(props);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(event, callback) {
+    this.#events[event] = this.#events[event] || [];
+    const cb = (...args) => callback.call(this, ...args);
+    this.#events[event].push(cb);
+    return () => {
+      this.#events[event] = this.#events[event].filter(
+        /** @param {any} fn */
+        (fn) => fn !== cb
+      );
+    };
+  }
+  $destroy() {
+    this.#instance.$destroy();
+  }
 }
 function asClassComponent(component) {
   const component_constructor = asClassComponent$1(component);
-  const _render = (props, { context: context2, csp, transformError } = {}) => {
-    const result = render(component, { props, context: context2, csp, transformError });
+  const _render = (props, { context, csp, transformError } = {}) => {
+    const result = render(component, { props, context, csp, transformError });
     const munged = Object.defineProperties(
       /** @type {LegacyRenderResult & PromiseLike<LegacyRenderResult>} */
       {},
@@ -4450,7 +4963,7 @@ function Root($$renderer, $$props) {
     }
     const Pyramid_5 = derived(() => constructors[5]);
     if (constructors[1]) {
-      $$renderer2.push("<!--[-->");
+      $$renderer2.push("<!--[0-->");
       const Pyramid_0 = constructors[0];
       if (Pyramid_0) {
         $$renderer2.push("<!--[-->");
@@ -4460,7 +4973,7 @@ function Root($$renderer, $$props) {
           params: page.params,
           children: ($$renderer3) => {
             if (constructors[2]) {
-              $$renderer3.push("<!--[-->");
+              $$renderer3.push("<!--[0-->");
               const Pyramid_1 = constructors[1];
               if (Pyramid_1) {
                 $$renderer3.push("<!--[-->");
@@ -4470,7 +4983,7 @@ function Root($$renderer, $$props) {
                   params: page.params,
                   children: ($$renderer4) => {
                     if (constructors[3]) {
-                      $$renderer4.push("<!--[-->");
+                      $$renderer4.push("<!--[0-->");
                       const Pyramid_2 = constructors[2];
                       if (Pyramid_2) {
                         $$renderer4.push("<!--[-->");
@@ -4480,7 +4993,7 @@ function Root($$renderer, $$props) {
                           params: page.params,
                           children: ($$renderer5) => {
                             if (constructors[4]) {
-                              $$renderer5.push("<!--[-->");
+                              $$renderer5.push("<!--[0-->");
                               const Pyramid_3 = constructors[3];
                               if (Pyramid_3) {
                                 $$renderer5.push("<!--[-->");
@@ -4490,7 +5003,7 @@ function Root($$renderer, $$props) {
                                   params: page.params,
                                   children: ($$renderer6) => {
                                     if (constructors[5]) {
-                                      $$renderer6.push("<!--[-->");
+                                      $$renderer6.push("<!--[0-->");
                                       const Pyramid_4 = constructors[4];
                                       if (Pyramid_4) {
                                         $$renderer6.push("<!--[-->");
@@ -4516,7 +5029,7 @@ function Root($$renderer, $$props) {
                                         $$renderer6.push("<!--]-->");
                                       }
                                     } else {
-                                      $$renderer6.push("<!--[!-->");
+                                      $$renderer6.push("<!--[-1-->");
                                       const Pyramid_4 = constructors[4];
                                       if (Pyramid_4) {
                                         $$renderer6.push("<!--[-->");
@@ -4537,7 +5050,7 @@ function Root($$renderer, $$props) {
                                 $$renderer5.push("<!--]-->");
                               }
                             } else {
-                              $$renderer5.push("<!--[!-->");
+                              $$renderer5.push("<!--[-1-->");
                               const Pyramid_3 = constructors[3];
                               if (Pyramid_3) {
                                 $$renderer5.push("<!--[-->");
@@ -4558,7 +5071,7 @@ function Root($$renderer, $$props) {
                         $$renderer4.push("<!--]-->");
                       }
                     } else {
-                      $$renderer4.push("<!--[!-->");
+                      $$renderer4.push("<!--[-1-->");
                       const Pyramid_2 = constructors[2];
                       if (Pyramid_2) {
                         $$renderer4.push("<!--[-->");
@@ -4579,7 +5092,7 @@ function Root($$renderer, $$props) {
                 $$renderer3.push("<!--]-->");
               }
             } else {
-              $$renderer3.push("<!--[!-->");
+              $$renderer3.push("<!--[-1-->");
               const Pyramid_1 = constructors[1];
               if (Pyramid_1) {
                 $$renderer3.push("<!--[-->");
@@ -4600,7 +5113,7 @@ function Root($$renderer, $$props) {
         $$renderer2.push("<!--]-->");
       }
     } else {
-      $$renderer2.push("<!--[!-->");
+      $$renderer2.push("<!--[-1-->");
       const Pyramid_0 = constructors[0];
       if (Pyramid_0) {
         $$renderer2.push("<!--[-->");
@@ -4613,109 +5126,12 @@ function Root($$renderer, $$props) {
     }
     $$renderer2.push(`<!--]--> `);
     {
-      $$renderer2.push("<!--[!-->");
+      $$renderer2.push("<!--[-1-->");
     }
     $$renderer2.push(`<!--]-->`);
   });
 }
 const root = asClassComponent(Root);
 
-const internal = new URL("sveltekit-internal://");
-function resolve(base, path) {
-  if (path[0] === "/" && path[1] === "/") return path;
-  let url = new URL(base, internal);
-  url = new URL(path, url);
-  return url.protocol === internal.protocol ? url.pathname + url.search + url.hash : url.href;
-}
-function normalize_path(path, trailing_slash) {
-  if (path === "/" || trailing_slash === "ignore") return path;
-  if (trailing_slash === "never") {
-    return path.endsWith("/") ? path.slice(0, -1) : path;
-  } else if (trailing_slash === "always" && !path.endsWith("/")) {
-    return path + "/";
-  }
-  return path;
-}
-function decode_pathname(pathname) {
-  return pathname.split("%25").map(decodeURI).join("%25");
-}
-function decode_params(params) {
-  for (const key in params) {
-    params[key] = decodeURIComponent(params[key]);
-  }
-  return params;
-}
-function make_trackable(url, callback, search_params_callback, allow_hash = false) {
-  const tracked = new URL(url);
-  Object.defineProperty(tracked, "searchParams", {
-    value: new Proxy(tracked.searchParams, {
-      get(obj, key) {
-        if (key === "get" || key === "getAll" || key === "has") {
-          return (param, ...rest) => {
-            search_params_callback(param);
-            return obj[key](param, ...rest);
-          };
-        }
-        callback();
-        const value = Reflect.get(obj, key);
-        return typeof value === "function" ? value.bind(obj) : value;
-      }
-    }),
-    enumerable: true,
-    configurable: true
-  });
-  const tracked_url_properties = ["href", "pathname", "search", "toString", "toJSON"];
-  if (allow_hash) tracked_url_properties.push("hash");
-  for (const property of tracked_url_properties) {
-    Object.defineProperty(tracked, property, {
-      get() {
-        callback();
-        return url[property];
-      },
-      enumerable: true,
-      configurable: true
-    });
-  }
-  {
-    tracked[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (depth, opts, inspect) => {
-      return inspect(url, opts);
-    };
-    tracked.searchParams[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (depth, opts, inspect) => {
-      return inspect(url.searchParams, opts);
-    };
-  }
-  if (!allow_hash) {
-    disable_hash(tracked);
-  }
-  return tracked;
-}
-function disable_hash(url) {
-  allow_nodejs_console_log(url);
-  Object.defineProperty(url, "hash", {
-    get() {
-      throw new Error(
-        "Cannot access event.url.hash. Consider using `page.url.hash` inside a component instead"
-      );
-    }
-  });
-}
-function disable_search(url) {
-  allow_nodejs_console_log(url);
-  for (const property of ["search", "searchParams"]) {
-    Object.defineProperty(url, property, {
-      get() {
-        throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
-      }
-    });
-  }
-}
-function allow_nodejs_console_log(url) {
-  {
-    url[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (depth, opts, inspect) => {
-      return inspect(new URL(url), opts);
-    };
-  }
-}
-
-export { DEV as A, normalize_path as B, disable_search as C, DevalueError as D, uneval as E, resolve as F, make_trackable as G, get_request_store as H, attr as a, ensure_array_like as b, attr_class as c, derived as d, escape_html as e, clsx as f, getContext as g, head as h, await_block as i, bind_props as j, attr_style as k, is_primitive as l, get_type as m, is_plain_object as n, enumerable_symbols as o, stringify_key as p, stringify_string as q, noop as r, stringify as s, safe_not_equal as t, decode_params as u, valid_array_indices as v, with_request_store as w, try_get_request_store as x, root as y, decode_pathname as z };
-//# sourceMappingURL=url-hmE1zcJ6.js.map
+export { uneval as A, hydratable_serialization_failed as B, noop as C, DevalueError as D, safe_not_equal as E, decode_params as F, try_get_request_store as G, HOLE as H, root as I, decode_pathname as J, DEV as K, normalize_path as L, MAX_ARRAY_INDEX as M, NAN as N, disable_search as O, POSITIVE_INFINITY as P, resolve as Q, make_trackable as R, SPARSE as S, get_request_store as T, UNDEFINED as U, attr as a, ensure_array_like as b, attr_class as c, derived as d, escape_html as e, clsx as f, getContext as g, head as h, await_block as i, bind_props as j, attr_style as k, NEGATIVE_INFINITY as l, NEGATIVE_ZERO as m, is_valid_array_len as n, is_valid_array_index as o, is_primitive as p, get_type as q, is_plain_object as r, stringify as s, enumerable_symbols as t, stringify_key as u, stringify_string as v, with_request_store as w, valid_array_indices as x, experimental_async_required as y, get_render_context as z };
+//# sourceMappingURL=root-otUAnOAR.js.map