@nanoforge-dev/editor 0.0.1 → 0.0.2-beta.394e65b

package/dist/server/chunks/{dev-7V6fUCff.js → events-Bhh2w-5S.js}

@@ -1,4 +1,22 @@
-//#region .svelte-kit/adapter-bun/chunks/dev.js
+import { n as __exportAll } from "./chunk-ByNZkrT6.js";
+//#region node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+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() {
+	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;
+}
+//#endregion
+//#region .svelte-kit/adapter-bun/chunks/index-server.js
+var MAX_ARRAY_LEN = 2 ** 32 - 1;
+var MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
 /** @type {Record<string, string>} */
 var escaped = {
 	"<": "\\u003C",
@@ -80,18 +98,29 @@ var is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 function stringify_key(key) {
 	return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
 }
+/** @param {number} n */
+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;
+}
+/** @param {number} n */
+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;
+}
 /** @param {string} s */
-function is_valid_array_index(s) {
+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);
 }
 /**
 * Finds the populated indices of an array.
@@ -99,7 +128,7 @@ function 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])) break;
+	for (var i = keys.length - 1; i >= 0; i--) if (is_valid_array_index_string(keys[i])) break;
 	keys.length = i + 1;
 	return keys;
 }
@@ -667,6 +696,26 @@ function deferred() {
 		reject
 	};
 }
+/**
+* When encountering a situation like `let [a, b, c] = $derived(blah())`,
+* we need to stash an intermediate value that `a`, `b`, and `c` derive
+* from, in case it's an iterable
+* @template T
+* @param {ArrayLike<T> | Iterable<T>} value
+* @param {number} [n]
+* @returns {Array<T>}
+*/
+function to_array(value, n) {
+	if (Array.isArray(value)) return value;
+	if (n === void 0 || !(Symbol.iterator in value)) return Array.from(value);
+	/** @type {T[]} */
+	const array = [];
+	for (const element of value) {
+		array.push(element);
+		if (array.length === n) break;
+	}
+	return array;
+}
 var CLEAN = 1024;
 var DIRTY = 2048;
 var MAYBE_DIRTY = 4096;
@@ -686,13 +735,18 @@ var USER_EFFECT = 1 << 20;
 /**
 * Tells that we marked this derived and its reactions as visited during the "mark as (maybe) dirty"-phase.
 * Will be lifted during execution of the derived and during checking its dirty state (both are necessary
-* because a derived might be checked but not executed).
+* because a derived might be checked but not executed). This is a pure performance optimization flag and
+* should not be used for any other purpose!
 */
 var WAS_MARKED = 65536;
 var REACTION_IS_UPDATING = 1 << 21;
 var ERROR_VALUE = 1 << 23;
 var STATE_SYMBOL = Symbol("$state");
 var LEGACY_PROPS = Symbol("legacy props");
+var ATTRIBUTES_CACHE = Symbol("attributes");
+var CLASS_CACHE = Symbol("class");
+var STYLE_CACHE = Symbol("style");
+var TEXT_CACHE = Symbol("text");
 /** allow users to ignore aborted signal errors if `reason.name === 'StaleReactionError` */
 var STALE_REACTION = new class StaleReactionError extends Error {
 	name = "StaleReactionError";
@@ -765,7 +819,8 @@ function in_webcontainer() {
 	return !!globalThis.process?.versions?.webcontainer;
 }
 var HYDRATION_ERROR = {};
-var UNINITIALIZED = Symbol();
+var UNINITIALIZED = Symbol("uninitialized");
+var ATTACHMENT_KEY = "@attach";
 /**
 * A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
 * 
@@ -801,19 +856,6 @@ function escape_html(value, is_attr) {
 	}
 	return escaped + 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;
-}
 /**
 * `<div translate={false}>` should be rendered as `<div translate="no">` and _not_
 * `<div translate="false">`, which is equivalent to `<div translate="yes">`. There
@@ -839,8 +881,8 @@ function attr(name, value, is_boolean = false) {
 * TODO Svelte 6 revisit this, and likely turn all falsy values into the empty string (what clsx also does)
 * @param  {any} value
 */
-function clsx(value) {
-	if (typeof value === "object") return clsx$1(value);
+function clsx$1(value) {
+	if (typeof value === "object") return clsx(value);
 	else return value ?? "";
 }
 var whitespace = [..." 	\n\r\f\xA0\v"];
@@ -1318,1129 +1360,1295 @@ function writable(value, start = noop) {
 	};
 }
 /**
+* Derived value store by synchronizing one or more readable stores and
+* applying an aggregation function over its input values.
+*
+* @template {Stores} S
+* @template T
+* @overload
+* @param {S} stores
+* @param {(values: StoresValues<S>, set: (value: T) => void, update: (fn: Updater<T>) => void) => Unsubscriber | void} fn
+* @param {T} [initial_value]
+* @returns {Readable<T>}
+*/
+/**
+* Derived value store by synchronizing one or more readable stores and
+* applying an aggregation function over its input values.
+*
+* @template {Stores} S
+* @template T
+* @overload
+* @param {S} stores
+* @param {(values: StoresValues<S>) => T} fn
+* @param {T} [initial_value]
+* @returns {Readable<T>}
+*/
+/**
+* @template {Stores} S
+* @template T
+* @param {S} stores
+* @param {Function} fn
+* @param {T} [initial_value]
+* @returns {Readable<T>}
+*/
+function derived$1(stores, fn, initial_value) {
+	const single = !Array.isArray(stores);
+	/** @type {Array<Readable<any>>} */
+	const stores_array = single ? [stores] : stores;
+	if (!stores_array.every(Boolean)) throw new Error("derived() expects stores as input, got a falsy value");
+	const auto = fn.length < 2;
+	return readable(initial_value, (set, update) => {
+		let started = false;
+		/** @type {T[]} */
+		const values = [];
+		let pending = 0;
+		let cleanup = noop;
+		const sync = () => {
+			if (pending) return;
+			cleanup();
+			const result = fn(single ? values[0] : values, set, update);
+			if (auto) set(result);
+			else cleanup = typeof result === "function" ? result : noop;
+		};
+		const unsubscribers = stores_array.map((store, i) => subscribe_to_store(store, (value) => {
+			values[i] = value;
+			pending &= ~(1 << i);
+			if (started) sync();
+		}, () => {
+			pending |= 1 << i;
+		}));
+		started = true;
+		sync();
+		return function stop() {
+			run_all(unsubscribers);
+			cleanup();
+			started = false;
+		};
+	});
+}
+/**
+* Takes a store and returns a new one derived from the old one that is readable.
+*
+* @template T
+* @param {Readable<T>} store  - store to make readonly
+* @returns {Readable<T>}
+*/
+function readonly(store) {
+	return { subscribe: store.subscribe.bind(store) };
+}
+/**
+* Get the current value from a store by subscribing and immediately unsubscribing.
+*
+* @template T
+* @param {Readable<T>} store
+* @returns {T}
+*/
+function get$1(store) {
+	let value;
+	subscribe_to_store(store, (_) => value = _)();
+	return value;
+}
+/**
 * We set this to `true` when updating a store so that we correctly
 * schedule effects if the update takes place inside a `$:` effect
 */
 var legacy_is_updating_store = false;
-/** @import { Fork } from 'svelte' */
-/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
-/** @type {Set<Batch>} */
-var batches = /* @__PURE__ */ new Set();
-/** @type {Batch | null} */
-var current_batch = null;
 /**
-* When time travelling (i.e. working in one batch, while other batches
-* still have ongoing work), we ignore the real values of affected
-* signals in favour of their values within the batch
-* @type {Map<Value, any> | null}
+* Returns a `subscribe` function that integrates external event-based systems with Svelte's reactivity.
+* It's particularly useful for integrating with web APIs like `MediaQuery`, `IntersectionObserver`, or `WebSocket`.
+*
+* If `subscribe` is called inside an effect (including indirectly, for example inside a getter),
+* the `start` callback will be called with an `update` function. Whenever `update` is called, the effect re-runs.
+*
+* If `start` returns a cleanup function, it will be called when the effect is destroyed.
+*
+* If `subscribe` is called in multiple effects, `start` will only be called once as long as the effects
+* are active, and the returned teardown function will only be called when all effects are destroyed.
+*
+* It's best understood with an example. Here's an implementation of [`MediaQuery`](https://svelte.dev/docs/svelte/svelte-reactivity#MediaQuery):
+*
+* ```js
+* import { createSubscriber } from 'svelte/reactivity';
+* import { on } from 'svelte/events';
+*
+* export class MediaQuery {
+* 	#query;
+* 	#subscribe;
+*
+* 	constructor(query) {
+* 		this.#query = window.matchMedia(`(${query})`);
+*
+* 		this.#subscribe = createSubscriber((update) => {
+* 			// when the `change` event occurs, re-run any effects that read `this.current`
+* 			const off = on(this.#query, 'change', update);
+*
+* 			// stop listening when all the effects are destroyed
+* 			return () => off();
+* 		});
+* 	}
+*
+* 	get current() {
+* 		// This makes the getter reactive, if read in an effect
+* 		this.#subscribe();
+*
+* 		// Return the current state of the query, whether or not we're in an effect
+* 		return this.#query.matches;
+* 	}
+* }
+* ```
+* @param {(update: () => void) => (() => void) | void} start
+* @since 5.7.0
 */
-var batch_values = null;
-/** @type {Effect | null} */
-var last_scheduled_effect = null;
-var is_flushing_sync = false;
-var is_processing = false;
+function createSubscriber(start) {
+	let subscribers = 0;
+	let version = source(0);
+	/** @type {(() => void) | void} */
+	let stop;
+	return () => {
+		if (effect_tracking()) {
+			get(version);
+			render_effect(() => {
+				if (subscribers === 0) stop = untrack(() => start(() => increment(version)));
+				subscribers += 1;
+				return () => {
+					queue_micro_task(() => {
+						subscribers -= 1;
+						if (subscribers === 0) {
+							stop?.();
+							stop = void 0;
+							increment(version);
+						}
+					});
+				};
+			});
+		}
+	};
+}
+/** @import { Effect, Source, TemplateNode, } from '#client' */
 /**
-* During traversal, this is an array. Newly created effects are (if not immediately
-* executed) pushed to this array, rather than going through the scheduling
-* rigamarole that would cause another turn of the flush loop.
-* @type {Effect[] | null}
+* @typedef {{
+* 	 onerror?: ((error: unknown, reset: () => void) => void) | null;
+*   failed?: ((anchor: Node, error: () => unknown, reset: () => () => void) => void) | null;
+*   pending?: ((anchor: Node) => void) | null;
+* }} BoundaryProps
 */
-var collected_effects = null;
+var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
 /**
-* An array of effects that are marked during traversal as a result of a `set`
-* (not `internal_set`) call. These will be added to the next batch and
-* trigger another `batch.process()`
-* @type {Effect[] | null}
-* @deprecated when we get rid of legacy mode and stores, we can get rid of this
+* @param {TemplateNode} node
+* @param {BoundaryProps} props
+* @param {((anchor: Node) => void)} children
+* @param {((error: unknown) => unknown) | undefined} [transform_error]
+* @returns {void}
 */
-var legacy_updates = null;
-var flush_count = 0;
-var uid = 1;
-var Batch = class Batch {
-	id = uid++;
-	/**
-	* 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<Value, [any, boolean]>}
-	*/
-	current = /* @__PURE__ */ new Map();
-	/**
-	* 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<Value, any>}
-	*/
-	previous = /* @__PURE__ */ new Map();
-	/**
-	* 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<(batch: Batch) => void>}
-	*/
-	#commit_callbacks = /* @__PURE__ */ new Set();
-	/**
-	* If a fork is discarded, we need to destroy any effects that are no longer needed
-	* @type {Set<(batch: Batch) => void>}
-	*/
-	#discard_callbacks = /* @__PURE__ */ new Set();
+function boundary(node, props, children, transform_error) {
+	new Boundary(node, props, children, transform_error);
+}
+var Boundary = class {
+	/** @type {Boundary | null} */
+	parent;
+	is_pending = false;
 	/**
-	* Callbacks that should run only when a fork is committed.
-	* @type {Set<(batch: Batch) => void>}
+	* API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
+	* Inherited from parent boundary, or defaults to identity.
+	* @type {(error: unknown) => unknown}
 	*/
-	#fork_commit_callbacks = /* @__PURE__ */ new Set();
+	transform_error;
+	/** @type {TemplateNode} */
+	#anchor;
+	/** @type {TemplateNode | null} */
+	#hydrate_open = hydrating ? hydrate_node : null;
+	/** @type {BoundaryProps} */
+	#props;
+	/** @type {((anchor: Node) => void)} */
+	#children;
+	/** @type {Effect} */
+	#effect;
+	/** @type {Effect | null} */
+	#main_effect = null;
+	/** @type {Effect | null} */
+	#pending_effect = null;
+	/** @type {Effect | null} */
+	#failed_effect = null;
+	/** @type {DocumentFragment | null} */
+	#offscreen_fragment = null;
+	#local_pending_count = 0;
+	#pending_count = 0;
+	#pending_count_update_queued = false;
+	/** @type {Set<Effect>} */
+	#dirty_effects = /* @__PURE__ */ new Set();
+	/** @type {Set<Effect>} */
+	#maybe_dirty_effects = /* @__PURE__ */ new Set();
 	/**
-	* Async effects that are currently in flight
-	* @type {Map<Effect, number>}
+	* A source containing the number of pending async deriveds/expressions.
+	* Only created if `$effect.pending()` is used inside the boundary,
+	* otherwise updating the source results in needless `Batch.ensure()`
+	* calls followed by no-op flushes
+	* @type {Source<number> | null}
 	*/
-	#pending = /* @__PURE__ */ new Map();
+	#effect_pending = null;
+	#effect_pending_subscriber = createSubscriber(() => {
+		this.#effect_pending = source(this.#local_pending_count);
+		return () => {
+			this.#effect_pending = null;
+		};
+	});
 	/**
-	* Async effects that are currently in flight, _not_ inside a pending boundary
-	* @type {Map<Effect, number>}
+	* @param {TemplateNode} node
+	* @param {BoundaryProps} props
+	* @param {((anchor: Node) => void)} children
+	* @param {((error: unknown) => unknown) | undefined} [transform_error]
 	*/
-	#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;
+	constructor(node, props, children, transform_error) {
+		this.#anchor = node;
+		this.#props = props;
+		this.#children = (anchor) => {
+			var effect = active_effect;
+			effect.b = this;
+			effect.f |= 128;
+			children(anchor);
+		};
+		this.parent = active_effect.b;
+		this.transform_error = transform_error ?? this.parent?.transform_error ?? ((e) => e);
+		this.#effect = block(() => {
+			if (hydrating) {
+				const comment = this.#hydrate_open;
+				hydrate_next();
+				const server_rendered_pending = comment.data === "[!";
+				if (comment.data.startsWith("[?")) {
+					const serialized_error = JSON.parse(comment.data.slice(2));
+					this.#hydrate_failed_content(serialized_error);
+				} else if (server_rendered_pending) this.#hydrate_pending_content();
+				else this.#hydrate_resolved_content();
+			} else this.#render();
+		}, flags);
+		if (hydrating) this.#anchor = hydrate_node;
+	}
+	#hydrate_resolved_content() {
+		try {
+			this.#main_effect = branch(() => this.#children(this.#anchor));
+		} catch (error) {
+			this.error(error);
+		}
+	}
 	/**
-	* The root effects that need to be flushed
-	* @type {Effect[]}
+	* @param {unknown} error The deserialized error from the server's hydration comment
 	*/
-	#roots = [];
+	#hydrate_failed_content(error) {
+		const failed = this.#props.failed;
+		if (!failed) return;
+		this.#failed_effect = branch(() => {
+			failed(this.#anchor, () => error, () => () => {});
+		});
+	}
+	#hydrate_pending_content() {
+		const pending = this.#props.pending;
+		if (!pending) return;
+		this.is_pending = true;
+		this.#pending_effect = branch(() => pending(this.#anchor));
+		queue_micro_task(() => {
+			var fragment = this.#offscreen_fragment = document.createDocumentFragment();
+			var anchor = create_text();
+			fragment.append(anchor);
+			this.#main_effect = this.#run(() => {
+				return branch(() => this.#children(anchor));
+			});
+			if (this.#pending_count === 0) {
+				this.#anchor.before(fragment);
+				this.#offscreen_fragment = null;
+				pause_effect(this.#pending_effect, () => {
+					this.#pending_effect = null;
+				});
+				this.#resolve(current_batch);
+			}
+		});
+	}
+	#render() {
+		try {
+			this.is_pending = this.has_pending_snippet();
+			this.#pending_count = 0;
+			this.#local_pending_count = 0;
+			this.#main_effect = branch(() => {
+				this.#children(this.#anchor);
+			});
+			if (this.#pending_count > 0) {
+				var fragment = this.#offscreen_fragment = document.createDocumentFragment();
+				move_effect(this.#main_effect, fragment);
+				const pending = this.#props.pending;
+				this.#pending_effect = branch(() => pending(this.#anchor));
+			} else this.#resolve(current_batch);
+		} catch (error) {
+			this.error(error);
+		}
+	}
 	/**
-	* Effects created while this batch was active.
-	* @type {Effect[]}
+	* @param {Batch} batch
 	*/
-	#new_effects = [];
+	#resolve(batch) {
+		this.is_pending = false;
+		batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
+	}
 	/**
-	* Deferred effects (which run after async work has completed) that are DIRTY
-	* @type {Set<Effect>}
+	* Defer an effect inside a pending boundary until the boundary resolves
+	* @param {Effect} effect
 	*/
-	#dirty_effects = /* @__PURE__ */ new Set();
+	defer_effect(effect) {
+		defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
+	}
 	/**
-	* Deferred effects that are MAYBE_DIRTY
-	* @type {Set<Effect>}
+	* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
+	* @returns {boolean}
 	*/
-	#maybe_dirty_effects = /* @__PURE__ */ new Set();
+	is_rendered() {
+		return !this.is_pending && (!this.parent || this.parent.is_rendered());
+	}
+	has_pending_snippet() {
+		return !!this.#props.pending;
+	}
 	/**
-	* A map of branches that still exist, but will be destroyed when this batch
-	* is committed — we skip over these during `process`.
-	* The value contains child effects that were dirty/maybe_dirty before being reset,
-	* so they can be rescheduled if the branch survives.
-	* @type {Map<Effect, { d: Effect[], m: Effect[] }>}
+	* @template T
+	* @param {() => T} fn
 	*/
-	#skipped_branches = /* @__PURE__ */ new Map();
+	#run(fn) {
+		var previous_effect = active_effect;
+		var previous_reaction = active_reaction;
+		var previous_ctx = component_context;
+		set_active_effect(this.#effect);
+		set_active_reaction(this.#effect);
+		set_component_context(this.#effect.ctx);
+		try {
+			Batch.ensure();
+			return fn();
+		} catch (e) {
+			handle_error(e);
+			return null;
+		} finally {
+			set_active_effect(previous_effect);
+			set_active_reaction(previous_reaction);
+			set_component_context(previous_ctx);
+		}
+	}
 	/**
-	* Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
-	* @type {Set<Effect>}
+	* 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
 	*/
-	#unskipped_branches = /* @__PURE__ */ new Set();
-	is_fork = false;
-	#decrement_queued = false;
-	/** @type {Set<Batch>} */
-	#blockers = /* @__PURE__ */ new Set();
-	#is_deferred() {
-		return this.is_fork || this.#blocking_pending.size > 0;
-	}
-	#is_blocked() {
-		for (const batch of this.#blockers) for (const effect of batch.#blocking_pending.keys()) {
-			var skipped = false;
-			var e = effect;
-			while (e.parent !== null) {
-				if (this.#skipped_branches.has(e)) {
-					skipped = true;
-					break;
-				}
-				e = e.parent;
+	#update_pending_count(d, batch) {
+		if (!this.has_pending_snippet()) {
+			if (this.parent) this.parent.#update_pending_count(d, batch);
+			return;
+		}
+		this.#pending_count += d;
+		if (this.#pending_count === 0) {
+			this.#resolve(batch);
+			if (this.#pending_effect) pause_effect(this.#pending_effect, () => {
+				this.#pending_effect = null;
+			});
+			if (this.#offscreen_fragment) {
+				this.#anchor.before(this.#offscreen_fragment);
+				this.#offscreen_fragment = null;
 			}
-			if (!skipped) return true;
 		}
-		return false;
 	}
 	/**
-	* Add an effect to the #skipped_branches map and reset its children
-	* @param {Effect} effect
+	* Update the source that powers `$effect.pending()` inside this 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
 	*/
-	skip_effect(effect) {
-		if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
-			d: [],
-			m: []
+	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;
+		queue_micro_task(() => {
+			this.#pending_count_update_queued = false;
+			if (this.#effect_pending) internal_set(this.#effect_pending, this.#local_pending_count);
 		});
-		this.#unskipped_branches.delete(effect);
+	}
+	get_effect_pending() {
+		this.#effect_pending_subscriber();
+		return get(this.#effect_pending);
+	}
+	/** @param {unknown} error */
+	error(error) {
+		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.oncommit(() => {
+				this.#handle_error(error);
+			});
+		} else this.#handle_error(error);
 	}
 	/**
-	* 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
+	* @param {unknown} error
 	*/
-	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);
-				callback(e);
-			}
-			for (e of tracked.m) {
-				set_signal_status(e, MAYBE_DIRTY);
-				callback(e);
-			}
+	#handle_error(error) {
+		if (this.#main_effect) {
+			destroy_effect(this.#main_effect);
+			this.#main_effect = null;
 		}
-		this.#unskipped_branches.add(effect);
-	}
-	#process() {
-		if (flush_count++ > 1e3) {
-			batches.delete(this);
-			infinite_loop_guard();
+		if (this.#pending_effect) {
+			destroy_effect(this.#pending_effect);
+			this.#pending_effect = null;
 		}
-		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);
-			}
+		if (this.#failed_effect) {
+			destroy_effect(this.#failed_effect);
+			this.#failed_effect = null;
 		}
-		const roots = this.#roots;
-		this.#roots = [];
-		this.apply();
-		/** @type {Effect[]} */
-		var effects = collected_effects = [];
-		/** @type {Effect[]} */
-		var render_effects = [];
-		/**
-		* @type {Effect[]}
-		* @deprecated when we get rid of legacy mode and stores, we can get rid of this
-		*/
-		var updates = legacy_updates = [];
-		for (const root of roots) try {
-			this.#traverse(root, effects, render_effects);
-		} catch (e) {
-			reset_all(root);
-			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.#is_blocked()) {
-			this.#defer_effects(render_effects);
-			this.#defer_effects(effects);
-			for (const [e, t] of this.#skipped_branches) reset_branch(e, t);
-		} else {
-			if (this.#pending.size === 0) batches.delete(this);
-			this.#dirty_effects.clear();
-			this.#maybe_dirty_effects.clear();
-			for (const fn of this.#commit_callbacks) fn(this);
-			this.#commit_callbacks.clear();
-			flush_queued_effects(render_effects);
-			flush_queued_effects(effects);
-			this.#deferred?.resolve();
-		}
-		var next_batch = current_batch;
-		if (this.#roots.length > 0) {
-			const batch = next_batch ??= this;
-			batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
-		}
-		if (next_batch !== null) {
-			batches.add(next_batch);
-			next_batch.#process();
+		if (hydrating) {
+			set_hydrate_node(this.#hydrate_open);
+			next();
+			set_hydrate_node(skip_nodes());
 		}
-	}
-	/**
-	* Traverse the effect tree, executing effects or stashing
-	* them for later execution as appropriate
-	* @param {Effect} root
-	* @param {Effect[]} effects
-	* @param {Effect[]} render_effects
-	*/
-	#traverse(root, effects, render_effects) {
-		root.f ^= CLEAN;
-		var effect = root.first;
-		while (effect !== null) {
-			var flags = effect.f;
-			var is_branch = (flags & 96) !== 0;
-			if (!(is_branch && (flags & 1024) !== 0 || (flags & 8192) !== 0 || this.#skipped_branches.has(effect)) && effect.fn !== null) {
-				if (is_branch) effect.f ^= CLEAN;
-				else if ((flags & 4) !== 0) effects.push(effect);
-				else if (is_dirty(effect)) {
-					if ((flags & 16) !== 0) this.#maybe_dirty_effects.add(effect);
-					update_effect(effect);
-				}
-				var child = effect.first;
-				if (child !== null) {
-					effect = child;
-					continue;
-				}
-			}
-			while (effect !== null) {
-				var next = effect.next;
-				if (next !== null) {
-					effect = next;
-					break;
-				}
-				effect = effect.parent;
+		var onerror = this.#props.onerror;
+		let failed = this.#props.failed;
+		var did_reset = false;
+		var calling_on_error = false;
+		const reset = () => {
+			if (did_reset) {
+				svelte_boundary_reset_noop();
+				return;
 			}
-		}
-	}
-	/**
-	* @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);
-	}
-	/**
-	* Associate a change to a given source with the current
-	* batch, noting its previous and current values
-	* @param {Value} source
-	* @param {any} value
-	* @param {boolean} [is_derived]
-	*/
-	capture(source, value, is_derived = false) {
-		if (source.v !== UNINITIALIZED && !this.previous.has(source)) this.previous.set(source, source.v);
-		if ((source.f & 8388608) === 0) {
-			this.current.set(source, [value, is_derived]);
-			batch_values?.set(source, value);
-		}
-		if (!this.is_fork) source.v = value;
-	}
-	activate() {
-		current_batch = this;
-	}
-	deactivate() {
-		current_batch = null;
-		batch_values = null;
-	}
-	flush() {
-		try {
-			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();
-		}
-	}
-	discard() {
-		for (const fn of this.#discard_callbacks) fn(this);
-		this.#discard_callbacks.clear();
-		this.#fork_commit_callbacks.clear();
-		batches.delete(this);
-	}
-	/**
-	* @param {Effect} effect
-	*/
-	register_created_effect(effect) {
-		this.#new_effects.push(effect);
-	}
-	#commit() {
-		for (const batch of batches) {
-			var is_earlier = batch.id < this.id;
-			/** @type {Source[]} */
-			var sources = [];
-			for (const [source, [value, is_derived]] of this.current) {
-				if (batch.current.has(source)) {
-					var batch_value = batch.current.get(source)[0];
-					if (is_earlier && value !== batch_value) batch.current.set(source, [value, is_derived]);
-					else continue;
-				}
-				sources.push(source);
+			did_reset = true;
+			if (calling_on_error) svelte_boundary_reset_onerror();
+			if (this.#failed_effect !== null) pause_effect(this.#failed_effect, () => {
+				this.#failed_effect = null;
+			});
+			this.#run(() => {
+				this.#render();
+			});
+		};
+		/** @param {unknown} transformed_error */
+		const handle_error_result = (transformed_error) => {
+			try {
+				calling_on_error = true;
+				onerror?.(transformed_error, reset);
+				calling_on_error = false;
+			} catch (error) {
+				invoke_error_boundary(error, this.#effect && this.#effect.parent);
 			}
-			var others = [...batch.current.keys()].filter((s) => !this.current.has(s));
-			if (others.length === 0) {
-				if (is_earlier) batch.discard();
-			} else if (sources.length > 0) {
-				if (is_earlier) for (const unskipped of this.#unskipped_branches) batch.unskip_effect(unskipped, (e) => {
-					if ((e.f & 4194320) !== 0) batch.schedule(e);
-					else batch.#defer_effects([e]);
-				});
-				batch.activate();
-				/** @type {Set<Value>} */
-				var marked = /* @__PURE__ */ new Set();
-				/** @type {Map<Reaction, boolean>} */
-				var checked = /* @__PURE__ */ new Map();
-				for (var source of sources) mark_effects(source, others, marked, checked);
-				checked = /* @__PURE__ */ new Map();
-				var current_unequal = [...batch.current.keys()].filter((c) => this.current.has(c) ? this.current.get(c)[0] !== c : true);
-				for (const effect of this.#new_effects) if ((effect.f & 155648) === 0 && depends_on(effect, current_unequal, checked)) if ((effect.f & 4194320) !== 0) {
-					set_signal_status(effect, DIRTY);
-					batch.schedule(effect);
-				} else batch.#dirty_effects.add(effect);
-				if (batch.#roots.length > 0) {
-					batch.apply();
-					for (var root of batch.#roots) batch.#traverse(root, [], []);
-					batch.#roots = [];
+			if (failed) this.#failed_effect = this.#run(() => {
+				try {
+					return branch(() => {
+						var effect = active_effect;
+						effect.b = this;
+						effect.f |= 128;
+						failed(this.#anchor, () => transformed_error, () => reset);
+					});
+				} catch (error) {
+					invoke_error_boundary(error, this.#effect.parent);
+					return null;
 				}
-				batch.deactivate();
-			}
-		}
-		for (const batch of batches) if (batch.#blockers.has(this)) {
-			batch.#blockers.delete(this);
-			if (batch.#blockers.size === 0 && !batch.#is_deferred()) {
-				batch.activate();
-				batch.#process();
-			}
-		}
-	}
-	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
-	*/
-	increment(blocking, effect) {
-		let pending_count = this.#pending.get(effect) ?? 0;
-		this.#pending.set(effect, pending_count + 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
-	* @param {boolean} skip - whether to skip updates (because this is triggered by a stale reaction)
-	*/
-	decrement(blocking, effect, skip) {
-		let pending_count = this.#pending.get(effect) ?? 0;
-		if (pending_count === 1) this.#pending.delete(effect);
-		else this.#pending.set(effect, pending_count - 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 || skip) return;
-		this.#decrement_queued = true;
+			});
+		};
 		queue_micro_task(() => {
-			this.#decrement_queued = false;
-			this.flush();
-		});
-	}
-	/**
-	* @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 maybe_dirty_effects) this.#maybe_dirty_effects.add(e);
-		dirty_effects.clear();
-		maybe_dirty_effects.clear();
-	}
-	/** @param {(batch: Batch) => void} fn */
-	oncommit(fn) {
-		this.#commit_callbacks.add(fn);
-	}
-	/** @param {(batch: Batch) => void} fn */
-	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();
-			if (!is_processing) {
-				batches.add(current_batch);
-				if (!is_flushing_sync) queue_micro_task(() => {
-					if (current_batch !== batch) return;
-					batch.flush();
-				});
-			}
-		}
-		return current_batch;
-	}
-	apply() {
-		batch_values = null;
-		return;
-		var intersects, differs;
-	}
-	/**
-	*
-	* @param {Effect} effect
-	*/
-	schedule(effect) {
-		last_scheduled_effect = effect;
-		if (effect.b?.is_pending && (effect.f & 16777228) !== 0 && (effect.f & 32768) === 0) {
-			effect.b.defer_effect(effect);
-			return;
-		}
-		var e = effect;
-		while (e.parent !== null) {
-			e = e.parent;
-			var flags = e.f;
-			if (collected_effects !== null && e === active_effect) {
-				if ((active_reaction === null || (active_reaction.f & 2) === 0) && !legacy_is_updating_store) return;
-			}
-			if ((flags & 96) !== 0) {
-				if ((flags & 1024) === 0) return;
-				e.f ^= CLEAN;
+			/** @type {unknown} */
+			var result;
+			try {
+				result = this.transform_error(error);
+			} catch (e) {
+				invoke_error_boundary(e, this.#effect && this.#effect.parent);
+				return;
 			}
-		}
-		this.#roots.push(e);
+			if (result !== null && typeof result === "object" && typeof result.then === "function")
+ /** @type {any} */ result.then(
+				handle_error_result,
+				/** @param {unknown} e */
+				(e) => invoke_error_boundary(e, this.#effect && this.#effect.parent)
+			);
+			else handle_error_result(result);
+		});
 	}
 };
+var OBSOLETE = Symbol("obsolete");
 /**
-* Synchronously flush any pending updates.
-* Returns void if no callback is provided, otherwise returns the result of calling the callback.
-* @template [T=void]
-* @param {(() => T) | undefined} [fn]
-* @returns {T}
-*/
-function flushSync(fn) {
-	var was_flushing_sync = is_flushing_sync;
-	is_flushing_sync = true;
-	try {
-		var result;
-		if (fn) {
-			if (current_batch !== null && !current_batch.is_fork) current_batch.flush();
-			result = fn();
-		}
-		while (true) {
-			flush_tasks();
-			if (current_batch === null) return result;
-			current_batch.flush();
-		}
-	} finally {
-		is_flushing_sync = was_flushing_sync;
-	}
-}
-function infinite_loop_guard() {
-	try {
-		effect_update_depth_exceeded();
-	} catch (error) {
-		invoke_error_boundary(error, last_scheduled_effect);
-	}
-}
-/** @type {Set<Effect> | null} */
-var eager_block_effects = null;
-/**
-* @param {Array<Effect>} effects
+* @param {Derived} derived
 * @returns {void}
 */
-function flush_queued_effects(effects) {
-	var length = effects.length;
-	if (length === 0) return;
-	var i = 0;
-	while (i < length) {
-		var effect = effects[i++];
-		if ((effect.f & 24576) === 0 && is_dirty(effect)) {
-			eager_block_effects = /* @__PURE__ */ new Set();
-			update_effect(effect);
-			if (effect.deps === null && effect.first === null && effect.nodes === null && effect.teardown === null && effect.ac === null) unlink_effect(effect);
-			if (eager_block_effects?.size > 0) {
-				old_values.clear();
-				for (const e of eager_block_effects) {
-					if ((e.f & 24576) !== 0) continue;
-					/** @type {Effect[]} */
-					const ordered_effects = [e];
-					let ancestor = e.parent;
-					while (ancestor !== null) {
-						if (eager_block_effects.has(ancestor)) {
-							eager_block_effects.delete(ancestor);
-							ordered_effects.push(ancestor);
-						}
-						ancestor = ancestor.parent;
-					}
-					for (let j = ordered_effects.length - 1; j >= 0; j--) {
-						const e = ordered_effects[j];
-						if ((e.f & 24576) !== 0) continue;
-						update_effect(e);
-					}
-				}
-				eager_block_effects.clear();
-			}
-		}
+function destroy_derived_effects(derived) {
+	var effects = derived.effects;
+	if (effects !== null) {
+		derived.effects = null;
+		for (var i = 0; i < effects.length; i += 1) destroy_effect(effects[i]);
 	}
-	eager_block_effects = null;
 }
 /**
-* This is similar to `mark_reactions`, but it only marks async/block effects
-* depending on `value` and at least one of the other `sources`, so that
-* these effects can re-run after another batch has been committed
-* @param {Value} value
-* @param {Source[]} sources
-* @param {Set<Value>} marked
-* @param {Map<Reaction, boolean>} checked
+* @template T
+* @param {Derived} derived
+* @returns {T}
 */
-function mark_effects(value, sources, marked, checked) {
-	if (marked.has(value)) return;
-	marked.add(value);
-	if (value.reactions !== null) for (const reaction of value.reactions) {
-		const flags = reaction.f;
-		if ((flags & 2) !== 0) mark_effects(reaction, sources, marked, checked);
-		else if ((flags & 4194320) !== 0 && (flags & 2048) === 0 && depends_on(reaction, sources, checked)) {
-			set_signal_status(reaction, DIRTY);
-			schedule_effect(reaction);
-		}
+function execute_derived(derived) {
+	var value;
+	var prev_active_effect = active_effect;
+	var parent = derived.parent;
+	if (!is_destroying_effect && parent !== null && derived.v !== UNINITIALIZED && (parent.f & 24576) !== 0) {
+		derived_inert();
+		return derived.v;
 	}
-}
-/**
-* @param {Reaction} reaction
-* @param {Source[]} sources
-* @param {Map<Reaction, boolean>} checked
-*/
-function depends_on(reaction, sources, checked) {
-	const depends = checked.get(reaction);
-	if (depends !== void 0) return depends;
-	if (reaction.deps !== null) for (const dep of reaction.deps) {
-		if (includes.call(sources, dep)) return true;
-		if ((dep.f & 2) !== 0 && depends_on(dep, sources, checked)) {
-			checked.set(dep, true);
-			return true;
-		}
+	set_active_effect(parent);
+	try {
+		derived.f &= ~WAS_MARKED;
+		destroy_derived_effects(derived);
+		value = update_reaction(derived);
+	} finally {
+		set_active_effect(prev_active_effect);
 	}
-	checked.set(reaction, false);
-	return false;
+	return value;
 }
 /**
-* @param {Effect} effect
+* @param {Derived} derived
 * @returns {void}
 */
-function schedule_effect(effect) {
-	/** @type {Batch} */ current_batch.schedule(effect);
+function update_derived(derived) {
+	var value = execute_derived(derived);
+	if (!derived.equals(value)) {
+		derived.wv = increment_write_version();
+		if (!current_batch?.is_fork || derived.deps === null) {
+			if (current_batch !== null) {
+				current_batch.capture(derived, value, true);
+				previous_batch?.capture(derived, value, true);
+			} else derived.v = value;
+			if (derived.deps === null) {
+				set_signal_status(derived, CLEAN);
+				return;
+			}
+		}
+	}
+	if (is_destroying_effect) return;
+	if (batch_values !== null) {
+		if (effect_tracking() || current_batch?.is_fork) batch_values.set(derived, value);
+	} else update_derived_status(derived);
 }
 /**
-* Mark all the effects inside a skipped branch CLEAN, so that
-* they can be correctly rescheduled later. Tracks dirty and maybe_dirty
-* effects so they can be rescheduled if the branch survives.
-* @param {Effect} effect
-* @param {{ d: Effect[], m: Effect[] }} tracked
+* @param {Derived} derived
 */
-function reset_branch(effect, tracked) {
-	if ((effect.f & 32) !== 0 && (effect.f & 1024) !== 0) return;
-	if ((effect.f & 2048) !== 0) tracked.d.push(effect);
-	else if ((effect.f & 4096) !== 0) tracked.m.push(effect);
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_branch(e, tracked);
-		e = e.next;
+function freeze_derived_effects(derived) {
+	if (derived.effects === null) return;
+	for (const e of derived.effects) if (e.teardown || e.ac) {
+		e.teardown?.();
+		e.ac?.abort(STALE_REACTION);
+		if (e.fn !== null) e.teardown = noop;
+		e.ac = null;
+		remove_reactions(e, 0);
+		destroy_effect_children(e);
 	}
 }
 /**
-* Mark an entire effect tree clean following an error
-* @param {Effect} effect
+* @param {Derived} derived
 */
-function reset_all(effect) {
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_all(e);
-		e = e.next;
-	}
+function unfreeze_derived_effects(derived) {
+	if (derived.effects === null) return;
+	for (const e of derived.effects) if (e.teardown && e.fn !== null) update_effect(e);
 }
+/** @import { Fork } from 'svelte' */
+/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
+/** @type {Batch | null} */
+var first_batch = null;
+/** @type {Batch | null} */
+var last_batch = null;
+/** @type {Batch | null} */
+var current_batch = null;
 /**
-* Returns a `subscribe` function that integrates external event-based systems with Svelte's reactivity.
-* It's particularly useful for integrating with web APIs like `MediaQuery`, `IntersectionObserver`, or `WebSocket`.
-*
-* If `subscribe` is called inside an effect (including indirectly, for example inside a getter),
-* the `start` callback will be called with an `update` function. Whenever `update` is called, the effect re-runs.
-*
-* If `start` returns a cleanup function, it will be called when the effect is destroyed.
-*
-* If `subscribe` is called in multiple effects, `start` will only be called once as long as the effects
-* are active, and the returned teardown function will only be called when all effects are destroyed.
-*
-* It's best understood with an example. Here's an implementation of [`MediaQuery`](https://svelte.dev/docs/svelte/svelte-reactivity#MediaQuery):
-*
-* ```js
-* import { createSubscriber } from 'svelte/reactivity';
-* import { on } from 'svelte/events';
-*
-* export class MediaQuery {
-* 	#query;
-* 	#subscribe;
-*
-* 	constructor(query) {
-* 		this.#query = window.matchMedia(`(${query})`);
-*
-* 		this.#subscribe = createSubscriber((update) => {
-* 			// when the `change` event occurs, re-run any effects that read `this.current`
-* 			const off = on(this.#query, 'change', update);
-*
-* 			// stop listening when all the effects are destroyed
-* 			return () => off();
-* 		});
-* 	}
-*
-* 	get current() {
-* 		// This makes the getter reactive, if read in an effect
-* 		this.#subscribe();
-*
-* 		// Return the current state of the query, whether or not we're in an effect
-* 		return this.#query.matches;
-* 	}
-* }
-* ```
-* @param {(update: () => void) => (() => void) | void} start
-* @since 5.7.0
+* This is needed to avoid overwriting inputs
+* @type {Batch | null}
 */
-function createSubscriber(start) {
-	let subscribers = 0;
-	let version = source(0);
-	/** @type {(() => void) | void} */
-	let stop;
-	return () => {
-		if (effect_tracking()) {
-			get(version);
-			render_effect(() => {
-				if (subscribers === 0) stop = untrack(() => start(() => increment(version)));
-				subscribers += 1;
-				return () => {
-					queue_micro_task(() => {
-						subscribers -= 1;
-						if (subscribers === 0) {
-							stop?.();
-							stop = void 0;
-							increment(version);
-						}
-					});
-				};
-			});
-		}
-	};
-}
-/** @import { Effect, Source, TemplateNode, } from '#client' */
+var previous_batch = null;
 /**
-* @typedef {{
-* 	 onerror?: (error: unknown, reset: () => void) => void;
-*   failed?: (anchor: Node, error: () => unknown, reset: () => () => void) => void;
-*   pending?: (anchor: Node) => void;
-* }} BoundaryProps
+* When time travelling (i.e. working in one batch, while other batches
+* still have ongoing work), we ignore the real values of affected
+* signals in favour of their values within the batch
+* @type {Map<Value, any> | null}
 */
-var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
+var batch_values = null;
+/** @type {Effect | null} */
+var last_scheduled_effect = null;
+var is_flushing_sync = false;
+var is_processing = false;
 /**
-* @param {TemplateNode} node
-* @param {BoundaryProps} props
-* @param {((anchor: Node) => void)} children
-* @param {((error: unknown) => unknown) | undefined} [transform_error]
-* @returns {void}
+* During traversal, this is an array. Newly created effects are (if not immediately
+* executed) pushed to this array, rather than going through the scheduling
+* rigamarole that would cause another turn of the flush loop.
+* @type {Effect[] | null}
 */
-function boundary(node, props, children, transform_error) {
-	new Boundary(node, props, children, transform_error);
-}
-var Boundary = class {
-	/** @type {Boundary | null} */
-	parent;
-	is_pending = false;
+var collected_effects = null;
+/**
+* An array of effects that are marked during traversal as a result of a `set`
+* (not `internal_set`) call. These will be added to the next batch and
+* trigger another `batch.process()`
+* @type {Effect[] | null}
+* @deprecated when we get rid of legacy mode and stores, we can get rid of this
+*/
+var legacy_updates = null;
+var flush_count = 0;
+var uid = 1;
+var Batch = 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();
 	/**
-	* API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
-	* Inherited from parent boundary, or defaults to identity.
-	* @type {(error: unknown) => unknown}
+	* 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<Value, [any, boolean]>}
+	*/
+	current = /* @__PURE__ */ new Map();
+	/**
+	* 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<Value, any>}
+	*/
+	previous = /* @__PURE__ */ new Map();
+	/**
+	* 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<(batch: Batch) => void>}
+	*/
+	#commit_callbacks = /* @__PURE__ */ new Set();
+	/**
+	* If a fork is discarded, we need to destroy any effects that are no longer needed
+	* @type {Set<(batch: Batch) => void>}
+	*/
+	#discard_callbacks = /* @__PURE__ */ new Set();
+	/**
+	* The number of async effects that are currently in flight
+	*/
+	#pending = 0;
+	/**
+	* Async effects that are currently in flight, _not_ inside a pending boundary
+	* @type {Map<Effect, number>}
+	*/
+	#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>}
 	*/
-	transform_error;
-	/** @type {TemplateNode} */
-	#anchor;
-	/** @type {TemplateNode | null} */
-	#hydrate_open = hydrating ? hydrate_node : null;
-	/** @type {BoundaryProps} */
-	#props;
-	/** @type {((anchor: Node) => void)} */
-	#children;
-	/** @type {Effect} */
-	#effect;
-	/** @type {Effect | null} */
-	#main_effect = null;
-	/** @type {Effect | null} */
-	#pending_effect = null;
-	/** @type {Effect | null} */
-	#failed_effect = null;
-	/** @type {DocumentFragment | null} */
-	#offscreen_fragment = null;
-	#local_pending_count = 0;
-	#pending_count = 0;
-	#pending_count_update_queued = false;
-	/** @type {Set<Effect>} */
 	#dirty_effects = /* @__PURE__ */ new Set();
-	/** @type {Set<Effect>} */
+	/**
+	* Deferred effects that are MAYBE_DIRTY
+	* @type {Set<Effect>}
+	*/
 	#maybe_dirty_effects = /* @__PURE__ */ new Set();
 	/**
-	* A source containing the number of pending async deriveds/expressions.
-	* Only created if `$effect.pending()` is used inside the boundary,
-	* otherwise updating the source results in needless `Batch.ensure()`
-	* calls followed by no-op flushes
-	* @type {Source<number> | null}
+	* A map of branches that still exist, but will be destroyed when this batch
+	* is committed — we skip over these during `process`.
+	* The value contains child effects that were dirty/maybe_dirty before being reset,
+	* so they can be rescheduled if the branch survives.
+	* @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;
+	constructor() {
+		if (last_batch === null) first_batch = last_batch = this;
+		else {
+			last_batch.#next = this;
+			this.#prev = last_batch;
+		}
+		last_batch = this;
+	}
+	#is_deferred() {
+		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
+	* @param {Effect} effect
 	*/
-	#effect_pending = null;
-	#effect_pending_subscriber = createSubscriber(() => {
-		this.#effect_pending = source(this.#local_pending_count);
-		return () => {
-			this.#effect_pending = null;
-		};
-	});
+	skip_effect(effect) {
+		if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
+			d: [],
+			m: []
+		});
+		this.#unskipped_branches.delete(effect);
+	}
 	/**
-	* @param {TemplateNode} node
-	* @param {BoundaryProps} props
-	* @param {((anchor: Node) => void)} children
-	* @param {((error: unknown) => unknown) | undefined} [transform_error]
+	* 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
 	*/
-	constructor(node, props, children, transform_error) {
-		this.#anchor = node;
-		this.#props = props;
-		this.#children = (anchor) => {
-			var effect = active_effect;
-			effect.b = this;
-			effect.f |= 128;
-			children(anchor);
-		};
-		this.parent = active_effect.b;
-		this.transform_error = transform_error ?? this.parent?.transform_error ?? ((e) => e);
-		this.#effect = block(() => {
-			if (hydrating) {
-				const comment = this.#hydrate_open;
-				hydrate_next();
-				const server_rendered_pending = comment.data === "[!";
-				if (comment.data.startsWith("[?")) {
-					const serialized_error = JSON.parse(comment.data.slice(2));
-					this.#hydrate_failed_content(serialized_error);
-				} else if (server_rendered_pending) this.#hydrate_pending_content();
-				else this.#hydrate_resolved_content();
-			} else this.#render();
-		}, flags);
-		if (hydrating) this.#anchor = hydrate_node;
+	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);
+				callback(e);
+			}
+			for (e of tracked.m) {
+				set_signal_status(e, MAYBE_DIRTY);
+				callback(e);
+			}
+		}
+		this.#unskipped_branches.add(effect);
 	}
-	#hydrate_resolved_content() {
-		try {
-			this.#main_effect = branch(() => this.#children(this.#anchor));
-		} catch (error) {
-			this.error(error);
+	#process() {
+		this.#started = true;
+		if (flush_count++ > 1e3) {
+			this.#unlink();
+			infinite_loop_guard();
+		}
+		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();
+		/** @type {Effect[]} */
+		var effects = collected_effects = [];
+		/** @type {Effect[]} */
+		var render_effects = [];
+		/**
+		* @type {Effect[]}
+		* @deprecated when we get rid of legacy mode and stores, we can get rid of this
+		*/
+		var updates = legacy_updates = [];
+		for (const root of roots) try {
+			this.#traverse(root, effects, render_effects);
+		} catch (e) {
+			reset_all(root);
+			if (!this.#is_deferred()) this.discard();
+			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);
+			if (updates.length > 0)
+ /** @type {Batch} */ current_batch.#process();
+			return;
+		}
+		const earlier_batch = this.#find_earlier_batch();
+		if (earlier_batch) {
+			this.#defer_effects(render_effects);
+			this.#defer_effects(effects);
+			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 = current_batch;
+		if (this.#pending === 0 && (this.#roots.length === 0 || next_batch !== null)) this.#unlink();
+		if (this.#roots.length > 0) if (next_batch !== null) {
+			const batch = next_batch;
+			batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
+		} else next_batch = this;
+		if (next_batch !== null) next_batch.#process();
 	}
 	/**
-	* @param {unknown} error The deserialized error from the server's hydration comment
+	* Traverse the effect tree, executing effects or stashing
+	* them for later execution as appropriate
+	* @param {Effect} root
+	* @param {Effect[]} effects
+	* @param {Effect[]} render_effects
 	*/
-	#hydrate_failed_content(error) {
-		const failed = this.#props.failed;
-		if (!failed) return;
-		this.#failed_effect = branch(() => {
-			failed(this.#anchor, () => error, () => () => {});
-		});
-	}
-	#hydrate_pending_content() {
-		const pending = this.#props.pending;
-		if (!pending) return;
-		this.is_pending = true;
-		this.#pending_effect = branch(() => pending(this.#anchor));
-		queue_micro_task(() => {
-			var fragment = this.#offscreen_fragment = document.createDocumentFragment();
-			var anchor = create_text();
-			fragment.append(anchor);
-			this.#main_effect = this.#run(() => {
-				return branch(() => this.#children(anchor));
-			});
-			if (this.#pending_count === 0) {
-				this.#anchor.before(fragment);
-				this.#offscreen_fragment = null;
-				pause_effect(this.#pending_effect, () => {
-					this.#pending_effect = null;
-				});
-				this.#resolve(current_batch);
+	#traverse(root, effects, render_effects) {
+		root.f ^= CLEAN;
+		var effect = root.first;
+		while (effect !== null) {
+			var flags = effect.f;
+			var is_branch = (flags & 96) !== 0;
+			if (!(is_branch && (flags & 1024) !== 0 || (flags & 8192) !== 0 || this.#skipped_branches.has(effect)) && effect.fn !== null) {
+				if (is_branch) effect.f ^= CLEAN;
+				else if ((flags & 4) !== 0) effects.push(effect);
+				else if (is_dirty(effect)) {
+					if ((flags & 16) !== 0) this.#maybe_dirty_effects.add(effect);
+					update_effect(effect);
+				}
+				var child = effect.first;
+				if (child !== null) {
+					effect = child;
+					continue;
+				}
 			}
-		});
+			while (effect !== null) {
+				var next = effect.next;
+				if (next !== null) {
+					effect = next;
+					break;
+				}
+				effect = effect.parent;
+			}
+		}
 	}
-	#render() {
-		try {
-			this.is_pending = this.has_pending_snippet();
-			this.#pending_count = 0;
-			this.#local_pending_count = 0;
-			this.#main_effect = branch(() => {
-				this.#children(this.#anchor);
-			});
-			if (this.#pending_count > 0) {
-				var fragment = this.#offscreen_fragment = document.createDocumentFragment();
-				move_effect(this.#main_effect, fragment);
-				const pending = this.#props.pending;
-				this.#pending_effect = branch(() => pending(this.#anchor));
-			} else this.#resolve(current_batch);
-		} catch (error) {
-			this.error(error);
+	#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
 	*/
-	#resolve(batch) {
-		this.is_pending = false;
-		batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
+	#merge(batch) {
+		for (const [source, value] of batch.current) {
+			if (!this.previous.has(source) && batch.previous.has(source)) this.previous.set(source, batch.previous.get(source));
+			this.current.set(source, value);
+		}
+		for (const [effect, deferred] of batch.async_deriveds) {
+			const d = this.async_deriveds.get(effect);
+			if (d) deferred.promise.then(d.resolve).catch(d.reject);
+		}
+		batch.async_deriveds.clear();
+		this.transfer_effects(batch.#dirty_effects, batch.#maybe_dirty_effects);
+		/**
+		* mark all effects that depend on `batch.current`, except the
+		* async effects that we just resolved (TODO unless they depend
+		* on values in this batch that are NOT in the later batch?).
+		* Through this we also will populate the correct #skipped_branches,
+		* oncommit callbacks etc, so we don't need to merge them separately.
+		* @param {Value} value
+		*/
+		const mark = (value) => {
+			var reactions = value.reactions;
+			if (reactions === null) return;
+			for (const reaction of reactions) {
+				var flags = reaction.f;
+				if ((flags & 2) !== 0) mark(reaction);
+				else {
+					var effect = reaction;
+					if (flags & 4194320 && !this.async_deriveds.has(effect)) {
+						this.#maybe_dirty_effects.delete(effect);
+						set_signal_status(effect, DIRTY);
+						this.schedule(effect);
+					}
+				}
+			}
+		};
+		for (const source of this.current.keys()) mark(source);
+		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);
+	}
+	/**
+	* Associate a change to a given source with the current
+	* batch, noting its previous and current values
+	* @param {Value} source
+	* @param {any} value
+	* @param {boolean} [is_derived]
+	*/
+	capture(source, value, is_derived = false) {
+		if (source.v !== UNINITIALIZED && !this.previous.has(source)) this.previous.set(source, source.v);
+		if ((source.f & 8388608) === 0) {
+			this.current.set(source, [value, is_derived]);
+			batch_values?.set(source, value);
+		}
+		if (!this.is_fork) source.v = value;
+	}
+	activate() {
+		current_batch = this;
+	}
+	deactivate() {
+		current_batch = null;
+		batch_values = null;
+	}
+	flush() {
+		try {
+			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();
+		}
+	}
+	discard() {
+		for (const fn of this.#discard_callbacks) fn(this);
+		this.#discard_callbacks.clear();
+		for (const deferred of this.async_deriveds.values()) deferred.reject(OBSOLETE);
+		this.#unlink();
+		this.#deferred?.resolve();
 	}
 	/**
-	* Defer an effect inside a pending boundary until the boundary resolves
 	* @param {Effect} effect
 	*/
-	defer_effect(effect) {
-		defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
-	}
-	/**
-	* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
-	* @returns {boolean}
-	*/
-	is_rendered() {
-		return !this.is_pending && (!this.parent || this.parent.is_rendered());
+	register_created_effect(effect) {
+		this.#new_effects.push(effect);
 	}
-	has_pending_snippet() {
-		return !!this.#props.pending;
+	#commit() {
+		for (let batch = first_batch; batch !== null; batch = batch.#next) {
+			var is_earlier = batch.id < this.id;
+			/** @type {Source[]} */
+			var sources = [];
+			for (const [source, [value, is_derived]] of this.current) {
+				if (batch.current.has(source)) {
+					var batch_value = batch.current.get(source)[0];
+					if (is_earlier && value !== batch_value) batch.current.set(source, [value, is_derived]);
+					else continue;
+				}
+				sources.push(source);
+			}
+			if (is_earlier) for (const [effect, deferred] of this.async_deriveds) {
+				const d = batch.async_deriveds.get(effect);
+				if (d) deferred.promise.then(d.resolve).catch(d.reject);
+			}
+			var current = [...batch.current.keys()].filter((source) => !batch.current.get(source)[1]);
+			if (!batch.#started || current.length === 0) continue;
+			var others = current.filter((source) => !this.current.has(source));
+			if (others.length === 0) {
+				if (is_earlier) batch.discard();
+			} else if (sources.length > 0) {
+				if (is_earlier) for (const unskipped of this.#unskipped_branches) batch.unskip_effect(unskipped, (e) => {
+					if ((e.f & 4194320) !== 0) batch.schedule(e);
+					else batch.#defer_effects([e]);
+				});
+				batch.activate();
+				/** @type {Set<Value>} */
+				var marked = /* @__PURE__ */ new Set();
+				/** @type {Map<Reaction, boolean>} */
+				var checked = /* @__PURE__ */ new Map();
+				for (var source of sources) mark_effects(source, others, marked, checked);
+				checked = /* @__PURE__ */ new Map();
+				var current_unequal = [...batch.current].filter(([c, v1]) => {
+					const v2 = this.current.get(c);
+					if (!v2) return true;
+					return v2[0] !== v1[0] || v2[1] !== v1[1];
+				}).map(([c]) => c);
+				if (current_unequal.length > 0) {
+					for (const effect of this.#new_effects) if ((effect.f & 155648) === 0 && depends_on(effect, current_unequal, checked)) if ((effect.f & 4194320) !== 0) {
+						set_signal_status(effect, DIRTY);
+						batch.schedule(effect);
+					} else batch.#dirty_effects.add(effect);
+				}
+				if (batch.#roots.length > 0 && !batch.#decrement_queued) {
+					batch.apply();
+					for (var root of batch.#roots) batch.#traverse(root, [], []);
+					batch.#roots = [];
+				}
+				batch.deactivate();
+			}
+		}
 	}
 	/**
-	* @template T
-	* @param {() => T} fn
+	* @param {boolean} blocking
+	* @param {Effect} effect
 	*/
-	#run(fn) {
-		var previous_effect = active_effect;
-		var previous_reaction = active_reaction;
-		var previous_ctx = component_context;
-		set_active_effect(this.#effect);
-		set_active_reaction(this.#effect);
-		set_component_context(this.#effect.ctx);
-		try {
-			Batch.ensure();
-			return fn();
-		} catch (e) {
-			handle_error(e);
-			return null;
-		} finally {
-			set_active_effect(previous_effect);
-			set_active_reaction(previous_reaction);
-			set_component_context(previous_ctx);
+	increment(blocking, effect) {
+		this.#pending += 1;
+		if (blocking) {
+			let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
+			this.#blocking_pending.set(effect, blocking_pending_count + 1);
 		}
 	}
 	/**
-	* 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
+	* @param {boolean} blocking
+	* @param {Effect} effect
 	*/
-	#update_pending_count(d, batch) {
-		if (!this.has_pending_snippet()) {
-			if (this.parent) this.parent.#update_pending_count(d, batch);
-			return;
-		}
-		this.#pending_count += d;
-		if (this.#pending_count === 0) {
-			this.#resolve(batch);
-			if (this.#pending_effect) pause_effect(this.#pending_effect, () => {
-				this.#pending_effect = null;
-			});
-			if (this.#offscreen_fragment) {
-				this.#anchor.before(this.#offscreen_fragment);
-				this.#offscreen_fragment = null;
-			}
+	decrement(blocking, effect) {
+		this.#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.linked) this.flush();
+		});
 	}
 	/**
-	* Update the source that powers `$effect.pending()` inside this 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
+	* @param {Set<Effect>} dirty_effects
+	* @param {Set<Effect>} maybe_dirty_effects
 	*/
-	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;
-		queue_micro_task(() => {
-			this.#pending_count_update_queued = false;
-			if (this.#effect_pending) internal_set(this.#effect_pending, this.#local_pending_count);
-		});
+	transfer_effects(dirty_effects, maybe_dirty_effects) {
+		for (const e of dirty_effects) this.#dirty_effects.add(e);
+		for (const e of maybe_dirty_effects) this.#maybe_dirty_effects.add(e);
+		dirty_effects.clear();
+		maybe_dirty_effects.clear();
 	}
-	get_effect_pending() {
-		this.#effect_pending_subscriber();
-		return get(this.#effect_pending);
+	/** @param {(batch: Batch) => void} fn */
+	oncommit(fn) {
+		this.#commit_callbacks.add(fn);
 	}
-	/** @param {unknown} error */
-	error(error) {
-		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);
+	/** @param {(batch: Batch) => void} fn */
+	ondiscard(fn) {
+		this.#discard_callbacks.add(fn);
+	}
+	settled() {
+		return (this.#deferred ??= deferred()).promise;
+	}
+	static ensure() {
+		if (current_batch === null) {
+			const batch = current_batch = new Batch();
+			if (!is_processing && !is_flushing_sync) queue_micro_task(() => {
+				if (!batch.#started) batch.flush();
 			});
-		} else this.#handle_error(error);
+		}
+		return current_batch;
+	}
+	apply() {
+		batch_values = null;
 	}
 	/**
-	* @param {unknown} error
+	*
+	* @param {Effect} effect
 	*/
-	#handle_error(error) {
-		if (this.#main_effect) {
-			destroy_effect(this.#main_effect);
-			this.#main_effect = null;
-		}
-		if (this.#pending_effect) {
-			destroy_effect(this.#pending_effect);
-			this.#pending_effect = null;
-		}
-		if (this.#failed_effect) {
-			destroy_effect(this.#failed_effect);
-			this.#failed_effect = null;
-		}
-		if (hydrating) {
-			set_hydrate_node(this.#hydrate_open);
-			next();
-			set_hydrate_node(skip_nodes());
+	schedule(effect) {
+		last_scheduled_effect = effect;
+		if (effect.b?.is_pending && (effect.f & 16777228) !== 0 && (effect.f & 32768) === 0) {
+			effect.b.defer_effect(effect);
+			return;
 		}
-		var onerror = this.#props.onerror;
-		let failed = this.#props.failed;
-		var did_reset = false;
-		var calling_on_error = false;
-		const reset = () => {
-			if (did_reset) {
-				svelte_boundary_reset_noop();
-				return;
-			}
-			did_reset = true;
-			if (calling_on_error) svelte_boundary_reset_onerror();
-			if (this.#failed_effect !== null) pause_effect(this.#failed_effect, () => {
-				this.#failed_effect = null;
-			});
-			this.#run(() => {
-				this.#render();
-			});
-		};
-		/** @param {unknown} transformed_error */
-		const handle_error_result = (transformed_error) => {
-			try {
-				calling_on_error = true;
-				onerror?.(transformed_error, reset);
-				calling_on_error = false;
-			} catch (error) {
-				invoke_error_boundary(error, this.#effect && this.#effect.parent);
+		var e = effect;
+		while (e.parent !== null) {
+			e = e.parent;
+			var flags = e.f;
+			if (collected_effects !== null && e === active_effect) {
+				if ((active_reaction === null || (active_reaction.f & 2) === 0) && !legacy_is_updating_store) return;
 			}
-			if (failed) this.#failed_effect = this.#run(() => {
-				try {
-					return branch(() => {
-						var effect = active_effect;
-						effect.b = this;
-						effect.f |= 128;
-						failed(this.#anchor, () => transformed_error, () => reset);
-					});
-				} catch (error) {
-					invoke_error_boundary(error, this.#effect.parent);
-					return null;
-				}
-			});
-		};
-		queue_micro_task(() => {
-			/** @type {unknown} */
-			var result;
-			try {
-				result = this.transform_error(error);
-			} catch (e) {
-				invoke_error_boundary(e, this.#effect && this.#effect.parent);
-				return;
+			if ((flags & 96) !== 0) {
+				if ((flags & 1024) === 0) return;
+				e.f ^= CLEAN;
 			}
-			if (result !== null && typeof result === "object" && typeof result.then === "function")
- /** @type {any} */ result.then(
-				handle_error_result,
-				/** @param {unknown} e */
-				(e) => invoke_error_boundary(e, this.#effect && this.#effect.parent)
-			);
-			else handle_error_result(result);
-		});
-	}
-};
-/**
-* @param {Derived} derived
-* @returns {void}
-*/
-function destroy_derived_effects(derived) {
-	var effects = derived.effects;
-	if (effects !== null) {
-		derived.effects = null;
-		for (var i = 0; i < effects.length; i += 1) destroy_effect(effects[i]);
+		}
+		this.#roots.push(e);
 	}
-}
+	#unlink() {
+		if (!this.linked) return;
+		var prev = this.#prev;
+		var next = this.#next;
+		if (prev === null) first_batch = next;
+		else prev.#next = next;
+		if (next === null) last_batch = prev;
+		else next.#prev = prev;
+		this.linked = false;
+	}
+};
 /**
-* @template T
-* @param {Derived} derived
+* Synchronously flush any pending updates.
+* Returns void if no callback is provided, otherwise returns the result of calling the callback.
+* @template [T=void]
+* @param {(() => T) | undefined} [fn]
 * @returns {T}
 */
-function execute_derived(derived) {
-	var value;
-	var prev_active_effect = active_effect;
-	var parent = derived.parent;
-	if (!is_destroying_effect && parent !== null && (parent.f & 24576) !== 0) {
-		derived_inert();
-		return derived.v;
-	}
-	set_active_effect(parent);
+function flushSync(fn) {
+	var was_flushing_sync = is_flushing_sync;
+	is_flushing_sync = true;
 	try {
-		derived.f &= ~WAS_MARKED;
-		destroy_derived_effects(derived);
-		value = update_reaction(derived);
+		var result;
+		if (fn) {
+			if (current_batch !== null && !current_batch.is_fork) current_batch.flush();
+			result = fn();
+		}
+		while (true) {
+			flush_tasks();
+			if (current_batch === null) return result;
+			current_batch.flush();
+		}
 	} finally {
-		set_active_effect(prev_active_effect);
+		is_flushing_sync = was_flushing_sync;
+	}
+}
+function infinite_loop_guard() {
+	try {
+		effect_update_depth_exceeded();
+	} catch (error) {
+		invoke_error_boundary(error, last_scheduled_effect);
 	}
-	return value;
 }
+/** @type {Set<Effect> | null} */
+var eager_block_effects = null;
 /**
-* @param {Derived} derived
+* @param {Array<Effect>} effects
 * @returns {void}
 */
-function update_derived(derived) {
-	var value = execute_derived(derived);
-	if (!derived.equals(value)) {
-		derived.wv = increment_write_version();
-		if (!current_batch?.is_fork || derived.deps === null) {
-			if (current_batch !== null) current_batch.capture(derived, value, true);
-			else derived.v = value;
-			if (derived.deps === null) {
-				set_signal_status(derived, CLEAN);
-				return;
+function flush_queued_effects(effects) {
+	var length = effects.length;
+	if (length === 0) return;
+	var i = 0;
+	while (i < length) {
+		var effect = effects[i++];
+		if ((effect.f & 24576) === 0 && is_dirty(effect)) {
+			eager_block_effects = /* @__PURE__ */ new Set();
+			update_effect(effect);
+			if (effect.deps === null && effect.first === null && effect.nodes === null && effect.teardown === null && effect.ac === null) unlink_effect(effect);
+			if (eager_block_effects?.size > 0) {
+				old_values.clear();
+				for (const e of eager_block_effects) {
+					if ((e.f & 24576) !== 0) continue;
+					/** @type {Effect[]} */
+					const ordered_effects = [e];
+					let ancestor = e.parent;
+					while (ancestor !== null) {
+						if (eager_block_effects.has(ancestor)) {
+							eager_block_effects.delete(ancestor);
+							ordered_effects.push(ancestor);
+						}
+						ancestor = ancestor.parent;
+					}
+					for (let j = ordered_effects.length - 1; j >= 0; j--) {
+						const e = ordered_effects[j];
+						if ((e.f & 24576) !== 0) continue;
+						update_effect(e);
+					}
+				}
+				eager_block_effects.clear();
 			}
 		}
 	}
-	if (is_destroying_effect) return;
-	if (batch_values !== null) {
-		if (effect_tracking() || current_batch?.is_fork) batch_values.set(derived, value);
-	} else update_derived_status(derived);
+	eager_block_effects = null;
 }
 /**
-* @param {Derived} derived
+* This is similar to `mark_reactions`, but it only marks async/block effects
+* depending on `value` and at least one of the other `sources`, so that
+* these effects can re-run after another batch has been committed
+* @param {Value} value
+* @param {Source[]} sources
+* @param {Set<Value>} marked
+* @param {Map<Reaction, boolean>} checked
 */
-function freeze_derived_effects(derived) {
-	if (derived.effects === null) return;
-	for (const e of derived.effects) if (e.teardown || e.ac) {
-		e.teardown?.();
-		e.ac?.abort(STALE_REACTION);
-		e.teardown = noop;
-		e.ac = null;
-		remove_reactions(e, 0);
-		destroy_effect_children(e);
+function mark_effects(value, sources, marked, checked) {
+	if (marked.has(value)) return;
+	marked.add(value);
+	if (value.reactions !== null) for (const reaction of value.reactions) {
+		const flags = reaction.f;
+		if ((flags & 2) !== 0) mark_effects(reaction, sources, marked, checked);
+		else if ((flags & 4194320) !== 0 && (flags & 2048) === 0 && depends_on(reaction, sources, checked)) {
+			set_signal_status(reaction, DIRTY);
+			schedule_effect(reaction);
+		}
 	}
 }
 /**
-* @param {Derived} derived
+* @param {Reaction} reaction
+* @param {Source[]} sources
+* @param {Map<Reaction, boolean>} checked
 */
-function unfreeze_derived_effects(derived) {
-	if (derived.effects === null) return;
-	for (const e of derived.effects) if (e.teardown) update_effect(e);
+function depends_on(reaction, sources, checked) {
+	const depends = checked.get(reaction);
+	if (depends !== void 0) return depends;
+	if (reaction.deps !== null) for (const dep of reaction.deps) {
+		if (includes.call(sources, dep)) return true;
+		if ((dep.f & 2) !== 0 && depends_on(dep, sources, checked)) {
+			checked.set(dep, true);
+			return true;
+		}
+	}
+	checked.set(reaction, false);
+	return false;
+}
+/**
+* @param {Effect} effect
+* @returns {void}
+*/
+function schedule_effect(effect) {
+	/** @type {Batch} */ current_batch.schedule(effect);
+}
+/**
+* Mark all the effects inside a skipped branch CLEAN, so that
+* they can be correctly rescheduled later. Tracks dirty and maybe_dirty
+* effects so they can be rescheduled if the branch survives.
+* @param {Effect} effect
+* @param {{ d: Effect[], m: Effect[] }} tracked
+*/
+function reset_branch(effect, tracked) {
+	if ((effect.f & 32) !== 0 && (effect.f & 1024) !== 0) return;
+	if ((effect.f & 2048) !== 0) tracked.d.push(effect);
+	else if ((effect.f & 4096) !== 0) tracked.m.push(effect);
+	set_signal_status(effect, CLEAN);
+	var e = effect.first;
+	while (e !== null) {
+		reset_branch(e, tracked);
+		e = e.next;
+	}
+}
+/**
+* Mark an entire effect tree clean following an error
+* @param {Effect} effect
+*/
+function reset_all(effect) {
+	set_signal_status(effect, CLEAN);
+	var e = effect.first;
+	while (e !== null) {
+		reset_all(e);
+		e = e.next;
+	}
 }
 /** @import { Derived, Effect, Source, Value } from '#client' */
-/** @type {Set<any>} */
+/** @type {Set<Effect>} */
 var eager_effects = /* @__PURE__ */ new Set();
 /** @type {Map<Source, any>} */
 var old_values = /* @__PURE__ */ new Map();
@@ -2466,7 +2674,7 @@ function source(v, stack) {
 * @param {V} v
 * @param {Error | null} [stack]
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*#__NO_SIDE_EFFECTS__*/
 function state(v, stack) {
 	const s = source(v, stack);
 	push_reaction_value(s);
@@ -2478,7 +2686,7 @@ function state(v, stack) {
 * @param {boolean} [immutable]
 * @returns {Source<V>}
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*#__NO_SIDE_EFFECTS__*/
 function mutable_source(initial_value, immutable = false, trackable = true) {
 	const s = source(initial_value);
 	if (!immutable) s.equals = safe_equals;
@@ -2493,7 +2701,7 @@ function mutable_source(initial_value, immutable = false, trackable = true) {
 * @returns {V}
 */
 function set(source, value, should_proxy = false) {
-	if (active_reaction !== null && (!untracking || (active_reaction.f & 131072) !== 0) && is_runes() && (active_reaction.f & 4325394) !== 0 && (current_sources === null || !includes.call(current_sources, source))) state_unsafe_mutation();
+	if (active_reaction !== null && (!untracking || (active_reaction.f & 131072) !== 0) && is_runes() && (active_reaction.f & 4325394) !== 0 && (current_sources === null || !current_sources.has(source))) state_unsafe_mutation();
 	return internal_set(source, should_proxy ? proxy(value) : value, legacy_updates);
 }
 /**
@@ -2525,7 +2733,13 @@ function flush_eager_effects() {
 	eager_effects_deferred = false;
 	for (const effect of eager_effects) {
 		if ((effect.f & 1024) !== 0) set_signal_status(effect, MAYBE_DIRTY);
-		if (is_dirty(effect)) update_effect(effect);
+		let dirty;
+		try {
+			dirty = is_dirty(effect);
+		} catch {
+			dirty = true;
+		}
+		if (dirty) update_effect(effect);
 	}
 	eager_effects.clear();
 }
@@ -2553,11 +2767,12 @@ function mark_reactions(signal, status, updated_during_traversal) {
 		if (!runes && reaction === active_effect) continue;
 		var not_dirty = (flags & DIRTY) === 0;
 		if (not_dirty) set_signal_status(reaction, status);
-		if ((flags & 2) !== 0) {
+		if ((flags & 131072) !== 0) eager_effects.add(reaction);
+		else if ((flags & 2) !== 0) {
 			var derived = reaction;
 			batch_values?.delete(derived);
 			if ((flags & 65536) === 0) {
-				if (flags & 512) reaction.f |= WAS_MARKED;
+				if (flags & 512 && (active_effect === null || (active_effect.f & 2097152) === 0)) reaction.f |= WAS_MARKED;
 				mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
 			}
 		} else if (not_dirty) {
@@ -2746,13 +2961,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;
+		/** @type {any} */ element_prototype[CLASS_CACHE] = void 0;
+		/** @type {any} */ element_prototype[ATTRIBUTES_CACHE] = null;
+		/** @type {any} */ element_prototype[STYLE_CACHE] = void 0;
 		element_prototype.__e = void 0;
 	}
-	if (is_extensible(text_prototype)) text_prototype.__t = void 0;
+	if (is_extensible(text_prototype))
+ /** @type {any} */ text_prototype[TEXT_CACHE] = void 0;
 }
 /**
 * @param {string} value
@@ -2765,7 +2980,7 @@ function create_text(value = "") {
 * @template {Node} N
 * @param {N} node
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*@__NO_SIDE_EFFECTS__*/
 function get_first_child(node) {
 	return first_child_getter.call(node);
 }
@@ -2773,7 +2988,7 @@ function get_first_child(node) {
 * @template {Node} N
 * @param {N} node
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*@__NO_SIDE_EFFECTS__*/
 function get_next_sibling(node) {
 	return next_sibling_getter.call(node);
 }
@@ -2981,7 +3196,7 @@ function destroy_effect(effect, remove_dom = true) {
 		remove_effect_dom(effect.nodes.start, effect.nodes.end);
 		removed = true;
 	}
-	set_signal_status(effect, DESTROYING);
+	effect.f |= DESTROYING;
 	destroy_effect_children(effect, remove_dom && !removed);
 	remove_reactions(effect, 0);
 	var transitions = effect.nodes && effect.nodes.t;
@@ -3061,8 +3276,10 @@ function pause_children(effect, transitions, local) {
 	var child = effect.first;
 	while (child !== null) {
 		var sibling = child.next;
-		var transparent = (child.f & 65536) !== 0 || (child.f & 32) !== 0 && (effect.f & 16) !== 0;
-		pause_children(child, transitions, transparent ? local : false);
+		if ((child.f & 64) === 0) {
+			var transparent = (child.f & 65536) !== 0 || (child.f & 32) !== 0 && (effect.f & 16) !== 0;
+			pause_children(child, transitions, transparent ? local : false);
+		}
 		child = sibling;
 	}
 }
@@ -3110,13 +3327,12 @@ function set_active_effect(effect) {
 /**
 * When sources are created within a reaction, reading and writing
 * them within that reaction should not cause a re-run
-* @type {null | Source[]}
+* @type {null | Set<Source>}
 */
 var current_sources = null;
 /** @param {Value} value */
 function push_reaction_value(value) {
-	if (active_reaction !== null && true) if (current_sources === null) current_sources = [value];
-	else current_sources.push(value);
+	if (active_reaction !== null && true) (current_sources ??= /* @__PURE__ */ new Set()).add(value);
 }
 /**
 * The dependencies of the reaction that is currently being executed. In many cases,
@@ -3181,7 +3397,7 @@ function is_dirty(reaction) {
 function schedule_possible_effect_self_invalidation(signal, effect, root = true) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
-	if (current_sources !== null && includes.call(current_sources, signal)) return;
+	if (current_sources !== null && current_sources.has(signal)) return;
 	for (var i = 0; i < reactions.length; i++) {
 		var reaction = reactions[i];
 		if ((reaction.f & 2) !== 0) schedule_possible_effect_self_invalidation(reaction, effect, false);
@@ -3333,7 +3549,7 @@ function get(signal) {
 	var is_derived = (signal.f & 2) !== 0;
 	captured_signals?.add(signal);
 	if (active_reaction !== null && !untracking) {
-		if (!(active_effect !== null && (active_effect.f & 16384) !== 0) && (current_sources === null || !includes.call(current_sources, signal))) {
+		if (!(active_effect !== null && (active_effect.f & 16384) !== 0) && (current_sources === null || !current_sources.has(signal))) {
 			var deps = active_reaction.deps;
 			if ((active_reaction.f & 2097152) !== 0) {
 				if (signal.rv < read_version) {
@@ -3343,7 +3559,8 @@ function get(signal) {
 					else new_deps.push(signal);
 				}
 			} else {
-				(active_reaction.deps ??= []).push(signal);
+				active_reaction.deps ??= [];
+				if (!includes.call(active_reaction.deps, signal)) active_reaction.deps.push(signal);
 				var reactions = signal.reactions;
 				if (reactions === null) signal.reactions = [active_reaction];
 				else if (!includes.call(reactions, active_reaction)) reactions.push(active_reaction);
@@ -3536,7 +3753,7 @@ var RAW_TEXT_ELEMENTS = [
 function is_raw_text_element(name) {
 	return RAW_TEXT_ELEMENTS.includes(name);
 }
-var REGEX_VALID_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]+)*$/u;
+var REGEX_VALID_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]*)?$/u;
 var 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;
 /**
 * @param {Renderer} renderer
@@ -3582,7 +3799,7 @@ function render(component, options = {}) {
 */
 function attributes(attrs, css_hash, classes, styles, flags = 0) {
 	if (styles) attrs.style = to_style(attrs.style, styles);
-	if (attrs.class) attrs.class = clsx(attrs.class);
+	if (attrs.class) attrs.class = clsx$1(attrs.class);
 	if (css_hash || classes) attrs.class = to_class(attrs.class, css_hash, classes);
 	let attr_str = "";
 	let name;
@@ -3592,7 +3809,7 @@ function attributes(attrs, css_hash, classes, styles, flags = 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;
+		if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
 		var value = attrs[name];
 		var lower = name.toLowerCase();
 		if (lowercase) name = lower;
@@ -3707,6 +3924,16 @@ function once(get_value) {
 	};
 }
 /**
+* Create an unique ID
+* @param {Renderer} renderer
+* @returns {string}
+*/
+function props_id(renderer) {
+	const uid = renderer.global.uid();
+	renderer.push("<!--$" + uid + "-->");
+	return uid;
+}
+/**
 * @template T
 * @param {()=>T} fn
 * @returns {(new_value?: T) => (T | void)}
@@ -4269,7 +4496,10 @@ var Renderer = class Renderer {
 			} catch (error) {
 				const { context, failed, transformError } = item.#boundary;
 				set_ssr_context(context);
-				let transformed = await transformError(error);
+				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));
@@ -4423,7 +4653,252 @@ var SSRState = class {
 		}
 	}
 };
+/** @import { HydratableLookupEntry } from '#server' */
+/**
+* @template T
+* @param {string} key
+* @param {() => T} fn
+* @returns {T}
+*/
+function hydratable(key, fn) {
+	experimental_async_required("hydratable");
+	const { hydratable } = get_render_context();
+	let entry = hydratable.lookup.get(key);
+	if (entry !== void 0) return entry.value;
+	const value = fn();
+	entry = encode(key, value, hydratable.unresolved_promises);
+	hydratable.lookup.set(key, entry);
+	return value;
+}
+/**
+* @param {string} key
+* @param {any} value
+* @param {Map<Promise<any>, string>} [unresolved]
+*/
+function encode(key, value, unresolved) {
+	/** @type {HydratableLookupEntry} */
+	const entry = {
+		value,
+		serialized: ""
+	};
+	let uid = 1;
+	entry.serialized = uneval(entry.value, (value, uneval) => {
+		if (is_promise(value)) {
+			const placeholder = `"${uid++}"`;
+			const p = value.then((v) => {
+				entry.serialized = entry.serialized.replace(placeholder, () => `r(${uneval(v)})`);
+			}).catch((devalue_error) => hydratable_serialization_failed(key, serialization_stack(entry.stack, devalue_error?.stack)));
+			unresolved?.set(p, key);
+			p.catch(() => {}).finally(() => unresolved?.delete(p));
+			(entry.promises ??= []).push(p);
+			return placeholder;
+		}
+	});
+	return entry;
+}
+/**
+* @param {any} value
+* @returns {value is Promise<any>}
+*/
+function is_promise(value) {
+	return Object.prototype.toString.call(value) === "[object Promise]";
+}
+/**
+* @param {string | undefined} root_stack
+* @param {string | undefined} uneval_stack
+*/
+function serialization_stack(root_stack, uneval_stack) {
+	let out = "";
+	if (root_stack) out += root_stack + "\n";
+	if (uneval_stack) out += "Caused by:\n" + uneval_stack + "\n";
+	return out || "<missing stack trace>";
+}
+/** @import { Snippet } from 'svelte' */
+/** @import { Renderer } from '../renderer' */
+/** @import { Getters } from '#shared' */
+/**
+* Create a snippet programmatically
+* @template {unknown[]} Params
+* @param {(...params: Getters<Params>) => {
+*   render: () => string
+*   setup?: (element: Element) => void | (() => void)
+* }} fn
+* @returns {Snippet<Params>}
+*/
+function createRawSnippet(fn) {
+	return (renderer, ...args) => {
+		var getters = args.map((value) => () => value);
+		renderer.push(fn(...getters).render().trim());
+	};
+}
+/** @import { SSRContext } from '#server' */
+/** @import { Renderer } from './internal/server/renderer.js' */
+var index_server_exports = /* @__PURE__ */ __exportAll({
+	afterUpdate: () => noop,
+	beforeUpdate: () => noop,
+	createContext: () => createContext,
+	createEventDispatcher: () => createEventDispatcher,
+	createRawSnippet: () => createRawSnippet,
+	flushSync: () => noop,
+	fork: () => fork,
+	getAbortSignal: () => getAbortSignal,
+	getAllContexts: () => getAllContexts,
+	getContext: () => getContext,
+	hasContext: () => hasContext,
+	hydratable: () => hydratable,
+	hydrate: () => hydrate,
+	mount: () => mount,
+	onDestroy: () => onDestroy,
+	onMount: () => noop,
+	setContext: () => setContext,
+	settled: () => settled,
+	tick: () => tick,
+	unmount: () => unmount,
+	untrack: () => run
+});
+/** @param {() => void} fn */
+function onDestroy(fn) {
+	/** @type {Renderer} */ ssr_context.r.on_destroy(fn);
+}
+function createEventDispatcher() {
+	return noop;
+}
+function mount() {
+	lifecycle_function_unavailable("mount");
+}
+function hydrate() {
+	lifecycle_function_unavailable("hydrate");
+}
+function unmount() {
+	lifecycle_function_unavailable("unmount");
+}
+function fork() {
+	lifecycle_function_unavailable("fork");
+}
+async function tick() {}
+async function settled() {}
+//#endregion
+//#region .svelte-kit/adapter-bun/chunks/events.js
+/**
+* Used on elements, as a map of event type -> event handler,
+* and on events themselves to track which element handled an event
+*/
+var event_symbol = Symbol("events");
+/** @type {Set<string>} */
+var all_registered_events = /* @__PURE__ */ new Set();
+/** @type {Set<(events: Array<string>) => void>} */
+var root_event_handles = /* @__PURE__ */ new Set();
+/**
+* @param {string} event_name
+* @param {EventTarget} dom
+* @param {EventListener} [handler]
+* @param {AddEventListenerOptions} [options]
+*/
+function create_event(event_name, dom, handler, options = {}) {
+	/**
+	* @this {EventTarget}
+	*/
+	function target_handler(event) {
+		if (!options.capture) handle_event_propagation.call(dom, event);
+		if (!event.cancelBubble) return without_reactive_context(() => {
+			return handler?.call(this, event);
+		});
+	}
+	if (event_name.startsWith("pointer") || event_name.startsWith("touch") || event_name === "wheel") queue_micro_task(() => {
+		dom.addEventListener(event_name, target_handler, options);
+	});
+	else dom.addEventListener(event_name, target_handler, options);
+	return target_handler;
+}
+/**
+* Attaches an event handler to an element and returns a function that removes the handler. Using this
+* rather than `addEventListener` will preserve the correct order relative to handlers added declaratively
+* (with attributes like `onclick`), which use event delegation for performance reasons
+*
+* @param {EventTarget} element
+* @param {string} type
+* @param {EventListener} handler
+* @param {AddEventListenerOptions} [options]
+*/
+function on(element, type, handler, options = {}) {
+	var target_handler = create_event(type, element, handler, options);
+	return () => {
+		element.removeEventListener(type, target_handler, options);
+	};
+}
+var last_propagated_event = null;
+/**
+* @this {EventTarget}
+* @param {Event} event
+* @returns {void}
+*/
+function handle_event_propagation(event) {
+	var handler_element = this;
+	var owner_document = handler_element.ownerDocument;
+	var event_name = event.type;
+	var path = event.composedPath?.() || [];
+	var current_target = 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 === 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;
+	}
+	current_target = path[path_idx] || event.target;
+	if (current_target === handler_element) return;
+	define_property(event, "currentTarget", {
+		configurable: true,
+		get() {
+			return current_target || owner_document;
+		}
+	});
+	var previous_reaction = active_reaction;
+	var previous_effect = active_effect;
+	set_active_reaction(null);
+	set_active_effect(null);
+	try {
+		/**
+		* @type {unknown}
+		*/
+		var throw_error;
+		/**
+		* @type {unknown[]}
+		*/
+		var other_errors = [];
+		while (current_target !== null) {
+			if (current_target === handler_element) break;
+			try {
+				var delegated = current_target[event_symbol]?.[event_name];
+				if (delegated != null && (!current_target.disabled || 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) break;
+			path_idx++;
+			current_target = path_idx < path.length ? path[path_idx] : null;
+		}
+		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);
+	}
+}
 //#endregion
-export { render_effect as $, getAllContexts as A, hydration_failed as B, ensure_array_like as C, flushSync as D, experimental_async_required as E, get_type as F, is_primitive as G, init_operations as H, hasContext as I, noop as J, lifecycle_function_unavailable as K, hydratable_serialization_failed as L, get_first_child as M, get_next_sibling as N, get as O, get_render_context as P, render as Q, hydrate_node as R, element as S, escape_html as T, is_passive_event as U, hydration_mismatch as V, is_plain_object as W, push as X, pop as Y, readable as Z, component_root as _, writable as _t, active_reaction as a, set_hydrate_node as at, define_property as b, attr_class as c, ssr_context as ct, bind_props as d, stringify as dt, run as et, boundary as f, stringify_key as ft, component_context as g, valid_array_indices as gt, clsx$1 as h, unsubscribe_stores as ht, active_effect as i, set_active_reaction as it, getContext as j, getAbortSignal as k, attr_style as l, state as lt, clsx as m, uneval as mt, HYDRATION_ERROR as n, setContext as nt, array_from as o, set_hydrating as ot, clear_text_content as p, stringify_string as pt, mutable_source as q, LEGACY_PROPS as r, set_active_effect as rt, attr as s, spread_props as st, DevalueError as t, set as tt, attributes as u, store_get as ut, createContext as v, enumerable_symbols as w, derived as x, create_text as y, hydrating as z };
+export { onDestroy as $, flushSync as A, hydrating as B, define_property as C, clsx as Ct, ensure_array_like as D, element as E, get_first_child as F, is_passive_event as G, hydration_mismatch as H, get_next_sibling as I, is_valid_array_index as J, is_plain_object as K, get_type as L, get$1 as M, getAllContexts as N, enumerable_symbols as O, getContext as P, noop as Q, hasContext as R, create_text as S, writable as St, derived$1 as T, index_server_exports as U, hydration_failed as V, init_operations as W, mount as X, is_valid_array_len as Y, mutable_source as Z, boundary as _, to_array as _t, ATTACHMENT_KEY as a, render as at, component_context as b, unsubscribe_stores as bt, LEGACY_PROPS as c, setContext as ct, array_from as d, spread_props as dt, pop as et, attr as f, store_get as ft, bind_props as g, tick as gt, attributes as h, stringify_string as ht, root_event_handles as i, readonly as it, get as j, escape_html as k, MAX_ARRAY_INDEX as l, set_hydrate_node as lt, attr_style as m, stringify_key as mt, handle_event_propagation as n, push as nt, DevalueError as o, run as ot, attr_class as p, stringify as pt, is_primitive as q, on as r, readable as rt, HYDRATION_ERROR as s, set as st, all_registered_events as t, props_id as tt, active_effect as u, set_hydrating as ut, clear_text_content as v, uneval as vt, derived as w, component_root as x, valid_array_indices as xt, clsx$1 as y, unmount as yt, hydrate_node as z };
 
-//# sourceMappingURL=dev-7V6fUCff.js.map
+//# sourceMappingURL=events-Bhh2w-5S.js.map