@axerity/cli 0.2.6 → 0.3.1

package/dist/server/chunks/{internal-BATRAFHZ.js → internal2-BGg7Milx.js}

@@ -11,7 +11,7 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.0_@typescript-eslin_fe9abfe190d51f22bcd6d74ecb2eafd6/node_modules/@sveltejs/kit/src/runtime/app/paths/internal/server.js
+//#region node_modules/.pnpm/@sveltejs+kit@2.63.0_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.2_@typescript-eslin_9ed2d7f3800a1c77eec55a1d66c8792d/node_modules/@sveltejs/kit/src/runtime/app/paths/internal/server.js
 var base = "";
 var assets = base;
 var app_dir = "_app";
@@ -484,7 +484,7 @@ function set_public_env(environment) {
 	public_env = environment;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/shared/errors.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/shared/errors.js
 /**
 * Cannot use `%name%(...)` unless the `experimental.async` compiler option is `true`
 * @param {string} name
@@ -586,7 +586,7 @@ function server_context_required() {
 	throw error;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/context.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/context.js
 /** @import { SSRContext } from '#server' */
 /** @type {SSRContext | null} */
 var ssr_context = null;
@@ -670,7 +670,7 @@ function get_parent_context(ssr_context) {
 	return null;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/shared/utils.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/shared/utils.js
 var is_array = Array.isArray;
 var index_of = Array.prototype.indexOf;
 var includes = Array.prototype.includes;
@@ -746,7 +746,7 @@ var STALE_REACTION = new class StaleReactionError extends Error {
 	message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
 }();
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/abort-signal.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/abort-signal.js
 /** @type {AbortController | null} */
 var controller = null;
 function abort() {
@@ -765,7 +765,7 @@ function get_render_context() {
 /** @type {AsyncLocalStorage<RenderContext | null> | null} */
 var als = null;
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/constants.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/constants.js
 var HYDRATION_ERROR = {};
 var UNINITIALIZED = Symbol("uninitialized");
 /**
@@ -780,12 +780,12 @@ function unresolved_hydratable(key, stack) {
 	console.warn(`https://svelte.dev/e/unresolved_hydratable`);
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/hydration.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/hydration.js
 var BLOCK_OPEN = `<!--[-->`;
 var BLOCK_CLOSE = `<!--]-->`;
 var EMPTY_COMMENT = `<!---->`;
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/escaping.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/escaping.js
 var ATTR_REGEX = /[&"<]/g;
 var CONTENT_REGEX = /[&<]/g;
 /**
@@ -823,7 +823,7 @@ function clsx$1() {
 	return n;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/shared/attributes.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/shared/attributes.js
 /**
 * `<div translate={false}>` should be rendered as `<div translate="no">` and _not_
 * `<div translate="false">`, which is equivalent to `<div translate="yes">`. There
@@ -1023,7 +1023,7 @@ function svelte_boundary_reset_noop() {
 	console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/hydration.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/hydration.js
 /** @import { TemplateNode } from '#client' */
 /**
 * Use this variable to guard everything related to hydration code so it can be treeshaken out
@@ -1082,7 +1082,7 @@ function skip_nodes(remove = true) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/reactivity/equality.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/reactivity/equality.js
 /** @import { Equals } from '#client' */
 /** @type {Equals} */
 function equals(value) {
@@ -1101,7 +1101,7 @@ function safe_equals(value) {
 	return !safe_not_equal(value, this.v);
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/context.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/context.js
 /** @import { ComponentContext, DevStackEntry, Effect } from '#client' */
 /** @type {ComponentContext | null} */
 var component_context = null;
@@ -1148,7 +1148,7 @@ function is_runes() {
 	return true;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/task.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/task.js
 /** @type {Array<() => void>} */
 var micro_tasks = [];
 function run_micro_tasks() {
@@ -1206,7 +1206,7 @@ function invoke_error_boundary(error, effect) {
 	throw error;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/reactivity/status.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/reactivity/status.js
 /** @import { Derived, Signal } from '#client' */
 var STATUS_MASK = -7169;
 /**
@@ -1225,7 +1225,7 @@ function update_derived_status(derived) {
 	else set_signal_status(derived, MAYBE_DIRTY);
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/reactivity/utils.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/reactivity/utils.js
 /** @import { Derived, Effect, Value } from '#client' */
 /**
 * @param {Value[] | null} deps
@@ -1253,7 +1253,7 @@ function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
 	set_signal_status(effect, CLEAN);
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/store/shared/index.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/store/shared/index.js
 /** @import { Readable, StartStopNotifier, Subscriber, Unsubscriber, Updater, Writable } from '../public.js' */
 /** @import { Stores, StoresValues, SubscribeInvalidateTuple } from '../private.js' */
 /**
@@ -1337,1205 +1337,1209 @@ function writable(value, start = noop) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/reactivity/batch.js
-/** @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;
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/reactivity/create-subscriber.js
 /**
-* This is needed to avoid overwriting inputs
-* @type {Batch | null}
-*/
-var previous_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);
+						}
+					});
+				};
+			});
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/blocks/boundary.js
+/** @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++;
-	/** True as soon as `#process` was called */
-	#started = false;
-	linked = true;
-	/** @type {Batch | null} */
-	#prev = null;
-	/** @type {Batch | null} */
-	#next = null;
-	/** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
-	async_deriveds = /* @__PURE__ */ new Map();
-	/**
-	* The current values of any 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 = [];
+function boundary(node, props, children, transform_error) {
+	new Boundary(node, props, children, transform_error);
+}
+var Boundary = class {
+	/** @type {Boundary | null} */
+	parent;
+	is_pending = false;
 	/**
-	* Deferred effects (which run after async work has completed) that are DIRTY
-	* @type {Set<Effect>}
+	* 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}
 	*/
+	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();
-	/**
-	* Deferred effects that are MAYBE_DIRTY
-	* @type {Set<Effect>}
-	*/
+	/** @type {Set<Effect>} */
 	#maybe_dirty_effects = /* @__PURE__ */ new Set();
 	/**
-	* 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[] }>}
+	* 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}
 	*/
-	#skipped_branches = /* @__PURE__ */ new Map();
+	#effect_pending = null;
+	#effect_pending_subscriber = createSubscriber(() => {
+		this.#effect_pending = source(this.#local_pending_count);
+		return () => {
+			this.#effect_pending = null;
+		};
+	});
 	/**
-	* Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
-	* @type {Set<Effect>}
+	* @param {TemplateNode} node
+	* @param {BoundaryProps} props
+	* @param {((anchor: Node) => void)} children
+	* @param {((error: unknown) => unknown) | undefined} [transform_error]
 	*/
-	#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;
+	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);
 		}
-		return false;
 	}
 	/**
-	* Add an effect to the #skipped_branches map and reset its children
-	* @param {Effect} effect
+	* @param {unknown} error The deserialized error from the server's hydration comment
 	*/
-	skip_effect(effect) {
-		if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
-			d: [],
-			m: []
+	#hydrate_failed_content(error) {
+		const failed = this.#props.failed;
+		if (!failed) return;
+		this.#failed_effect = branch(() => {
+			failed(this.#anchor, () => error, () => () => {});
 		});
-		this.#unskipped_branches.delete(effect);
+	}
+	#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);
+		}
 	}
 	/**
-	* Remove an effect from the #skipped_branches map and reschedule
-	* any tracked dirty/maybe_dirty child effects
+	* @param {Batch} batch
+	*/
+	#resolve(batch) {
+		this.is_pending = false;
+		batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
+	}
+	/**
+	* Defer an effect inside a pending boundary until the boundary resolves
 	* @param {Effect} effect
-	* @param {(e: Effect) => void} callback
 	*/
-	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);
+	defer_effect(effect) {
+		defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
 	}
-	#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);
+	/**
+	* 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());
+	}
+	has_pending_snippet() {
+		return !!this.#props.pending;
+	}
+	/**
+	* @template T
+	* @param {() => T} fn
+	*/
+	#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) {
-			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;
+			handle_error(e);
+			return null;
+		} finally {
+			set_active_effect(previous_effect);
+			set_active_reaction(previous_reaction);
+			set_component_context(previous_ctx);
 		}
-		const earlier_batch = this.#find_earlier_batch();
-		if (earlier_batch) {
-			this.#defer_effects(render_effects);
-			this.#defer_effects(effects);
-			earlier_batch.#merge(this);
+	}
+	/**
+	* Updates the pending count associated with the currently visible pending snippet,
+	* if any, such that we can replace the snippet with content once work is done
+	* @param {1 | -1} d
+	* @param {Batch} batch
+	*/
+	#update_pending_count(d, batch) {
+		if (!this.has_pending_snippet()) {
+			if (this.parent) this.parent.#update_pending_count(d, batch);
 			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();
+		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 (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();
 	}
 	/**
-	* Traverse the effect tree, executing effects or stashing
-	* them for later execution as appropriate
-	* @param {Effect} root
-	* @param {Effect[]} effects
-	* @param {Effect[]} render_effects
+	* 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
 	*/
-	#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;
-			}
-		}
-	}
-	#find_earlier_batch() {
-		var batch = this.#prev;
-		while (batch !== null) {
-			if (!batch.is_fork) {
-				for (const [value, [, is_derived]] of this.current) if (batch.current.has(value) && !is_derived) return batch;
-			}
-			batch = batch.#prev;
-		}
-		return null;
-	}
-	/**
-	* @param {Batch} batch
-	*/
-	#merge(batch) {
-		for (const [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);
-		}
-		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();
-		this.#unlink();
-		this.#deferred?.resolve();
-	}
-	/**
-	* @param {Effect} effect
-	*/
-	register_created_effect(effect) {
-		this.#new_effects.push(effect);
-	}
-	#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);
-			}
-			if (!batch.#started) continue;
-			var others = [...batch.current.keys()].filter((s) => !batch.current.get(s)[1] && !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].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();
-			}
-		}
-	}
-	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
-	*/
-	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);
-		}
-	}
-	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
-	*/
-	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();
-		});
-	}
-	/**
-	* @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);
-	}
-	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();
-			});
-		}
-		return current_batch;
-	}
-	apply() {
-		{
-			batch_values = null;
-			return;
-		}
-	}
-	/**
-	*
-	* @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) && true) return;
-			}
-			if ((flags & 96) !== 0) {
-				if ((flags & 1024) === 0) return;
-				e.f ^= CLEAN;
-			}
-		}
-		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;
-	}
-};
-/**
-* 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) ;
-		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
-* @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();
-			}
-		}
+	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);
+		});
 	}
-	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
-*/
-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);
-		}
+	get_effect_pending() {
+		this.#effect_pending_subscriber();
+		return get(this.#effect_pending);
 	}
-}
-/**
-* @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;
+	/** @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);
+	}
+	/**
+	* @param {unknown} error
+	*/
+	#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());
 		}
+		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);
+			}
+			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 (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);
+		});
 	}
-	checked.set(reaction, false);
-	return false;
-}
+};
+var OBSOLETE = Symbol("obsolete");
 /**
-* @param {Effect} effect
+* @param {Derived} derived
 * @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;
+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]);
 	}
 }
 /**
-* Mark an entire effect tree clean following an error
-* @param {Effect} effect
+* @template T
+* @param {Derived} derived
+* @returns {T}
 */
-function reset_all(effect) {
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_all(e);
-		e = e.next;
+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;
 	}
-}
-//#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/reactivity/create-subscriber.js
-/**
-* 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
-*/
-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);
-						}
-					});
-				};
-			});
+	set_active_effect(parent);
+	try {
+		derived.f &= ~WAS_MARKED;
+		destroy_derived_effects(derived);
+		value = update_reaction(derived);
+	} finally {
+		set_active_effect(prev_active_effect);
+	}
+	return value;
+}
+/**
+* @param {Derived} derived
+* @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);
+				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);
 }
-//#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/blocks/boundary.js
-/** @import { Effect, Source, TemplateNode, } from '#client' */
 /**
-* @typedef {{
-* 	 onerror?: ((error: unknown, reset: () => void) => void) | null;
-*   failed?: ((anchor: Node, error: () => unknown, reset: () => () => void) => void) | null;
-*   pending?: ((anchor: Node) => void) | null;
-* }} BoundaryProps
+* @param {Derived} derived
 */
-var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
+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);
+	}
+}
 /**
-* @param {TemplateNode} node
-* @param {BoundaryProps} props
-* @param {((anchor: Node) => void)} children
-* @param {((error: unknown) => unknown) | undefined} [transform_error]
-* @returns {void}
+* @param {Derived} derived
 */
-function boundary(node, props, children, transform_error) {
-	new Boundary(node, props, children, transform_error);
+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);
 }
-var Boundary = class {
-	/** @type {Boundary | null} */
-	parent;
-	is_pending = false;
+//#endregion
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/reactivity/batch.js
+/** @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;
+/**
+* This is needed to avoid overwriting inputs
+* @type {Batch | null}
+*/
+var previous_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}
+*/
+var batch_values = null;
+/** @type {Effect | null} */
+var last_scheduled_effect = null;
+var is_flushing_sync = false;
+var is_processing = false;
+/**
+* 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}
+*/
+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[] }>}
 	*/
-	#effect_pending = null;
-	#effect_pending_subscriber = createSubscriber(() => {
-		this.#effect_pending = source(this.#local_pending_count);
-		return () => {
-			this.#effect_pending = null;
-		};
-	});
+	#skipped_branches = /* @__PURE__ */ new Map();
 	/**
-	* @param {TemplateNode} node
-	* @param {BoundaryProps} props
-	* @param {((anchor: Node) => void)} children
-	* @param {((error: unknown) => unknown) | undefined} [transform_error]
+	* Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
+	* @type {Set<Effect>}
 	*/
-	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;
+	#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;
 	}
-	#hydrate_resolved_content() {
-		try {
-			this.#main_effect = branch(() => this.#children(this.#anchor));
-		} catch (error) {
-			this.error(error);
+	#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;
 	}
 	/**
-	* @param {unknown} error The deserialized error from the server's hydration comment
+	* Add an effect to the #skipped_branches map and reset its children
+	* @param {Effect} effect
 	*/
-	#hydrate_failed_content(error) {
-		const failed = this.#props.failed;
-		if (!failed) return;
-		this.#failed_effect = branch(() => {
-			failed(this.#anchor, () => error, () => () => {});
+	skip_effect(effect) {
+		if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
+			d: [],
+			m: []
 		});
+		this.#unskipped_branches.delete(effect);
 	}
-	#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);
+	/**
+	* Remove an effect from the #skipped_branches map and reschedule
+	* any tracked dirty/maybe_dirty child effects
+	* @param {Effect} effect
+	* @param {(e: Effect) => void} callback
+	*/
+	unskip_effect(effect, 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);
 	}
-	#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);
+	#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 {Batch} batch
+	* Traverse the effect tree, executing effects or stashing
+	* them for later execution as appropriate
+	* @param {Effect} root
+	* @param {Effect[]} effects
+	* @param {Effect[]} render_effects
 	*/
-	#resolve(batch) {
-		this.is_pending = false;
-		batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_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;
+			}
+		}
+	}
+	#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;
 	}
 	/**
-	* Defer an effect inside a pending boundary until the boundary resolves
-	* @param {Effect} effect
+	* @param {Batch} batch
 	*/
-	defer_effect(effect) {
-		defer_effect(effect, 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();
 	}
 	/**
-	* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
-	* @returns {boolean}
+	* @param {Effect[]} effects
 	*/
-	is_rendered() {
-		return !this.is_pending && (!this.parent || this.parent.is_rendered());
-	}
-	has_pending_snippet() {
-		return !!this.#props.pending;
+	#defer_effects(effects) {
+		for (var i = 0; i < effects.length; i += 1) defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
 	}
 	/**
-	* @template T
-	* @param {() => T} fn
+	* 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]
 	*/
-	#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);
+	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 {
-			Batch.ensure();
-			return fn();
-		} catch (e) {
-			handle_error(e);
-			return null;
+			is_processing = true;
+			current_batch = this;
+			this.#process();
 		} finally {
-			set_active_effect(previous_effect);
-			set_active_reaction(previous_reaction);
-			set_component_context(previous_ctx);
+			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();
+	}
 	/**
-	* 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 {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;
+	register_created_effect(effect) {
+		this.#new_effects.push(effect);
+	}
+	#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();
 			}
 		}
 	}
 	/**
-	* 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 {boolean} blocking
+	* @param {Effect} effect
 	*/
-	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;
+	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);
+		}
+	}
+	/**
+	* @param {boolean} blocking
+	* @param {Effect} effect
+	*/
+	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.#pending_count_update_queued = false;
-			if (this.#effect_pending) internal_set(this.#effect_pending, this.#local_pending_count);
+			this.#decrement_queued = false;
+			if (this.linked) this.flush();
 		});
 	}
-	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);
-	}
 	/**
-	* @param {unknown} error
+	* @param {Set<Effect>} dirty_effects
+	* @param {Set<Effect>} maybe_dirty_effects
 	*/
-	#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());
-		}
-		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);
-			}
-			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;
-				}
+	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);
+	}
+	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();
 			});
-		};
-		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;
+		}
+		return current_batch;
+	}
+	apply() {
+		{
+			batch_values = null;
+			return;
+		}
+	}
+	/**
+	*
+	* @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) && true) return;
 			}
-			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);
-		});
+			if ((flags & 96) !== 0) {
+				if ((flags & 1024) === 0) return;
+				e.f ^= CLEAN;
+			}
+		}
+		this.#roots.push(e);
 	}
-};
-/**
-* @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]);
+	#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 && derived.v !== UNINITIALIZED && (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) ;
+		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);
-				previous_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);
-		if (e.fn !== null) 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 && e.fn !== null) 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;
+	}
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/reactivity/sources.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/reactivity/sources.js
 /** @import { Derived, Effect, Source, Value } from '#client' */
 /** @type {Set<Effect>} */
 var eager_effects = /* @__PURE__ */ new Set();
@@ -2825,7 +2829,7 @@ function proxy(value) {
 	});
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/operations.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/operations.js
 /** @type {Window} */
 var $window;
 /** @type {() => Node | null} */
@@ -2885,7 +2889,7 @@ function clear_text_content(node) {
 	node.textContent = "";
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/elements/bindings/shared.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/elements/bindings/shared.js
 /**
 * @template T
 * @param {() => T} fn
@@ -2903,7 +2907,7 @@ function without_reactive_context(fn) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/reactivity/effects.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/reactivity/effects.js
 /** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
 /**
 * @param {Effect} effect
@@ -3084,7 +3088,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;
@@ -3188,7 +3192,7 @@ function move_effect(effect, fragment) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/runtime.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/runtime.js
 /** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
 var is_updating_effect = false;
 var is_destroying_effect = false;
@@ -3621,7 +3625,7 @@ function is_raw_text_element(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;
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/blocks/html.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/blocks/html.js
 /**
 * @param {string} value
 */
@@ -3629,7 +3633,7 @@ function html(value) {
 	return "<!---->" + String(value ?? "") + "<!---->";
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/index.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/index.js
 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
@@ -3788,7 +3792,7 @@ function derived(fn) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/crypto.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/crypto.js
 var text_encoder;
 var crypto;
 /** @param {string} module_name */
@@ -3813,7 +3817,7 @@ function base64_encode(bytes) {
 	return btoa(binary);
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/renderer.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/renderer.js
 /** @import { Component } from 'svelte' */
 /** @import { Csp, HydratableContext, RenderOutput, SSRContext, SyncRenderOutput, Sha256Source } from './types.js' */
 /** @import { MaybePromise } from '#shared' */
@@ -4488,7 +4492,7 @@ var SSRState = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/hydratable.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/hydratable.js
 /** @import { HydratableLookupEntry } from '#server' */
 /**
 * @template T
@@ -4549,7 +4553,7 @@ function serialization_stack(root_stack, uneval_stack) {
 	return out || "<missing stack trace>";
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/blocks/snippet.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/server/blocks/snippet.js
 /** @import { Snippet } from 'svelte' */
 /** @import { Renderer } from '../renderer' */
 /** @import { Getters } from '#shared' */
@@ -4569,7 +4573,7 @@ function createRawSnippet(fn) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/index-server.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/index-server.js
 /** @import { SSRContext } from '#server' */
 /** @import { Renderer } from './internal/server/renderer.js' */
 var index_server_exports = /* @__PURE__ */ __exportAll({
@@ -4617,7 +4621,7 @@ function fork() {
 async function tick() {}
 async function settled() {}
 
-//#region node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.0_@typescript-eslin_fe9abfe190d51f22bcd6d74ecb2eafd6/node_modules/@sveltejs/kit/src/utils/url.js
+//#region node_modules/.pnpm/@sveltejs+kit@2.63.0_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.2_@typescript-eslin_9ed2d7f3800a1c77eec55a1d66c8792d/node_modules/@sveltejs/kit/src/utils/url.js
 /**
 * Matches a URI scheme. See https://www.rfc-editor.org/rfc/rfc3986#section-3.1
 * @type {RegExp}
@@ -4735,7 +4739,7 @@ function allow_nodejs_console_log(url) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.0_@typescript-eslin_fe9abfe190d51f22bcd6d74ecb2eafd6/node_modules/@sveltejs/kit/src/utils/routing.js
+//#region node_modules/.pnpm/@sveltejs+kit@2.63.0_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.56.2_@typescript-eslin_9ed2d7f3800a1c77eec55a1d66c8792d/node_modules/@sveltejs/kit/src/utils/routing.js
 /**
 * @param {RegExpMatchArray} match
 * @param {import('types').RouteParam[]} params
@@ -4794,13 +4798,14 @@ function find_route(path, routes, matchers) {
 	return null;
 }
 
+//#endregion
 //#region \0virtual:__sveltekit/server
 var read_implementation = null;
 function set_read_implementation(fn) {
 	read_implementation = fn;
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/elements/events.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/elements/events.js
 /**
 * Used on elements, as a map of event type -> event handler,
 * and on events themselves to track which element handled an event
@@ -4883,7 +4888,7 @@ function handle_event_propagation(event) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/template.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/internal/client/dom/template.js
 /**
 * @param {TemplateNode} start
 * @param {TemplateNode | null} end
@@ -5073,7 +5078,7 @@ function unmount(component, options) {
 	return Promise.resolve();
 }
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/legacy/legacy-client.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/legacy/legacy-client.js
 /** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
 /**
 * Takes the component function and returns a Svelte 4 compatible component constructor.
@@ -5198,7 +5203,7 @@ var Svelte4Component = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/svelte@5.56.0_@typescript-eslint+types@8.60.0/node_modules/svelte/src/legacy/legacy-server.js
+//#region node_modules/.pnpm/svelte@5.56.2_@typescript-eslint+types@8.60.1/node_modules/svelte/src/legacy/legacy-server.js
 /** @import { SvelteComponent } from '../index.js' */
 /** @import { Csp } from '#server' */
 /** @typedef {{ head: string, html: string, css: { code: string, map: null }; hashes?: { script: `sha256-${string}`[] } }} LegacyRenderResult */
@@ -5348,7 +5353,7 @@ var options = {
 		app: ({ head, body, assets, nonce, env }) => "<!doctype html>\n<html lang=\"en\">\n	<head>\n		<meta charset=\"utf-8\" />\n		<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n		<meta name=\"text-scale\" content=\"scale\" />\n		<script>\n			(() => {\n				try {\n					const pref = localStorage.getItem('axerity-theme') ?? 'dark';\n					const dark =\n						pref === 'dark' ||\n						(pref === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);\n					document.documentElement.classList.toggle('dark', dark);\n				} catch {}\n			})();\n			(() => {\n				try {\n					const hide = [];\n					for (let i = 0; i < localStorage.length; i++) {\n						const key = localStorage.key(i);\n						if (key && key.indexOf('axerity-banner:') === 0 && localStorage.getItem(key) === '1') {\n							hide.push('[data-banner-key=\"' + key.replace(/\"/g, '\\\\\"') + '\"]');\n						}\n					}\n					if (hide.length) {\n						const style = document.createElement('style');\n						style.textContent = hide.join(',') + '{display:none!important}';\n						document.head.appendChild(style);\n					}\n				} catch {}\n			})();\n		<\/script>\n		" + head + "\n	</head>\n	<body data-sveltekit-preload-data=\"hover\">\n		<div style=\"display: contents\">" + body + "</div>\n	</body>\n</html>\n",
 		error: ({ status, message }) => "<!doctype html>\n<html lang=\"en\">\n	<head>\n		<meta charset=\"utf-8\" />\n		<title>" + message + "</title>\n\n		<style>\n			body {\n				--bg: white;\n				--fg: #222;\n				--divider: #ccc;\n				background: var(--bg);\n				color: var(--fg);\n				font-family:\n					system-ui,\n					-apple-system,\n					BlinkMacSystemFont,\n					'Segoe UI',\n					Roboto,\n					Oxygen,\n					Ubuntu,\n					Cantarell,\n					'Open Sans',\n					'Helvetica Neue',\n					sans-serif;\n				display: flex;\n				align-items: center;\n				justify-content: center;\n				height: 100vh;\n				margin: 0;\n			}\n\n			.error {\n				display: flex;\n				align-items: center;\n				max-width: 32rem;\n				margin: 0 1rem;\n			}\n\n			.status {\n				font-weight: 200;\n				font-size: 3rem;\n				line-height: 1;\n				position: relative;\n				top: -0.05rem;\n			}\n\n			.message {\n				border-left: 1px solid var(--divider);\n				padding: 0 0 0 1rem;\n				margin: 0 0 0 1rem;\n				min-height: 2.5rem;\n				display: flex;\n				align-items: center;\n			}\n\n			.message h1 {\n				font-weight: 400;\n				font-size: 1em;\n				margin: 0;\n			}\n\n			@media (prefers-color-scheme: dark) {\n				body {\n					--bg: #222;\n					--fg: #ddd;\n					--divider: #666;\n				}\n			}\n		</style>\n	</head>\n	<body>\n		<div class=\"error\">\n			<span class=\"status\">" + status + "</span>\n			<div class=\"message\">\n				<h1>" + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
 	},
-	version_hash: "tvtg7n"
+	version_hash: "6acpw3"
 };
 async function get_hooks() {
 	let handle;
@@ -5356,7 +5361,7 @@ async function get_hooks() {
 	let handleError;
 	let handleValidationError;
 	let init;
-	({handle, handleFetch, handleError, handleValidationError, init} = await import('./hooks.server-Bc1rR9Cw.js'));
+	({handle, handleFetch, handleError, handleValidationError, init} = await import('./hooks.server-i3yJ8tQB.js'));
 	let reroute;
 	let transport;
 	return {
@@ -5371,4 +5376,4 @@ async function get_hooks() {
 }
 
 export { attr_class as A, clsx as B, ensure_array_like as C, element as D, attributes as E, attr_style as F, run as G, tick as H, html as I, getContext as J, onDestroy as K, setContext as L, index_server_exports as M, noop as N, is_valid_array_len as O, MAX_ARRAY_INDEX as P, is_valid_array_index as Q, DevalueError as R, is_primitive as S, get_type as T, is_plain_object as U, enumerable_symbols as V, stringify_key as W, stringify_string as X, valid_array_indices as Y, __commonJSMin as _, set_public_env as a, base as b, disable_search as c, decode_pathname as d, read_implementation as e, find_route as f, get_hooks as g, reset as h, assets as i, app_dir as j, readable as k, set_read_implementation as l, make_trackable as m, normalize_path as n, options as o, public_env as p, head as q, resolve as r, set_private_env as s, derived as t, uneval as u, attr as v, writable as w, stringify as x, escape_html as y, spread_props as z };
-//# sourceMappingURL=internal-BATRAFHZ.js.map
+//# sourceMappingURL=internal2-BGg7Milx.js.map