@pie-element/venn-classification 0.1.1-next.3 → 0.1.1-next.4

package/dist/delivery/index.js

@@ -1,16 +1,16 @@
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/disclose-version.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/disclose-version.js
 if (typeof window !== "undefined") {
 	var _window$__svelte, _window;
 	((_window$__svelte = (_window = window).__svelte ?? (_window.__svelte = {})).v ?? (_window$__svelte.v = /* @__PURE__ */ new Set())).add("5");
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/constants.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/constants.js
 var HYDRATION_ERROR = {};
 var UNINITIALIZED = Symbol("uninitialized");
 var NAMESPACE_SVG = "http://www.w3.org/2000/svg";
 var NAMESPACE_MATHML = "http://www.w3.org/1998/Math/MathML";
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/shared/utils.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/shared/utils.js
 var is_array = Array.isArray;
 var index_of = Array.prototype.indexOf;
 var includes = Array.prototype.includes;
@@ -67,7 +67,7 @@ function to_array(value, n) {
 	return array;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -77,7 +77,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -89,13 +89,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -156,7 +156,7 @@ function lifecycle_outside_component(name) {
 	throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/errors.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/errors.js
 /**
 * Cannot create a `$derived(...)` with an `await` expression outside of an effect tree
 * @returns {never}
@@ -267,7 +267,7 @@ function svelte_boundary_reset_noop() {
 	console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/hydration.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/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
@@ -346,7 +346,7 @@ function read_hydration_instruction(node) {
 	return node.data;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/equality.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/equality.js
 /** @import { Equals } from '#client' */
 /** @type {Equals} */
 function equals(value) {
@@ -365,13 +365,13 @@ function safe_equals(value) {
 	return !safe_not_equal(value, this.v);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/flags/index.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/flags/index.js
 /** True if experimental.async=true */
 var async_mode_flag = false;
 /** True if we're not certain that we only have Svelte 5 code in the compilation */
 var legacy_mode_flag = false;
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/context.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/context.js
 /** @import { ComponentContext, DevStackEntry, Effect } from '#client' */
 /** @type {ComponentContext | null} */
 var component_context = null;
@@ -423,7 +423,7 @@ function is_runes() {
 	return !legacy_mode_flag || component_context !== null && component_context.l === null;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/task.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/task.js
 /** @type {Array<() => void>} */
 var micro_tasks = [];
 function run_micro_tasks() {
@@ -466,6 +466,7 @@ function handle_error(error) {
 * @param {Effect | null} effect
 */
 function invoke_error_boundary(error, effect) {
+	if (effect !== null && (effect.f & 16384) !== 0) return;
 	while (effect !== null) {
 		if ((effect.f & 128) !== 0) {
 			if ((effect.f & 32768) === 0) throw error;
@@ -481,7 +482,7 @@ function invoke_error_boundary(error, effect) {
 	throw error;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/status.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/status.js
 /** @import { Derived, Signal } from '#client' */
 var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
 /**
@@ -500,7 +501,7 @@ function update_derived_status(derived) {
 	else set_signal_status(derived, MAYBE_DIRTY);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/utils.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/utils.js
 /** @import { Derived, Effect, Value } from '#client' */
 /**
 * @param {Value[] | null} deps
@@ -528,7 +529,7 @@ function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
 	set_signal_status(effect, CLEAN);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/store.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/store.js
 /**
 * We set this to `true` when updating a store so that we correctly
 * schedule effects if the update takes place inside a `$:` effect
@@ -558,1460 +559,1501 @@ function capture_store_binding(fn) {
 	}
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/checkPrivateRedeclaration.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/bindings/shared.js
+/**
+* @template T
+* @param {() => T} fn
+*/
+function without_reactive_context(fn) {
+	var previous_reaction = active_reaction;
+	var previous_effect = active_effect;
+	set_active_reaction(null);
+	set_active_effect(null);
+	try {
+		return fn();
+	} finally {
+		set_active_reaction(previous_reaction);
+		set_active_effect(previous_effect);
+	}
+}
+//#endregion
+//#region ../../../node_modules/.bun/svelte@5.56.8/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);
+						}
+					});
+				};
+			});
+		}
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/checkPrivateRedeclaration.js
 function _checkPrivateRedeclaration(e, t) {
 	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateMethodInitSpec.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateMethodInitSpec.js
 function _classPrivateMethodInitSpec(e, a) {
 	_checkPrivateRedeclaration(e, a), a.add(e);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateFieldInitSpec.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateFieldInitSpec.js
 function _classPrivateFieldInitSpec(e, t, a) {
 	_checkPrivateRedeclaration(e, t), t.set(e, a);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/assertClassBrand.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/assertClassBrand.js
 function _assertClassBrand(e, t, n) {
 	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
 	throw new TypeError("Private element is not present on this object");
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateFieldSet2.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateFieldSet2.js
 function _classPrivateFieldSet2(s, a, r) {
 	return s.set(_assertClassBrand(s, a), r), r;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateFieldGet2.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateFieldGet2.js
 function _classPrivateFieldGet2(s, a) {
 	return s.get(_assertClassBrand(s, a));
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/batch.js
-/** @import { Fork } from 'svelte' */
-/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
-var _Batch;
-/** @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;
+//#region ../../../node_modules/.bun/svelte@5.56.8/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 _started = /* @__PURE__ */ new WeakMap();
-var _prev = /* @__PURE__ */ new WeakMap();
-var _next = /* @__PURE__ */ new WeakMap();
-var _commit_callbacks = /* @__PURE__ */ new WeakMap();
-var _discard_callbacks = /* @__PURE__ */ new WeakMap();
-var _pending = /* @__PURE__ */ new WeakMap();
-var _blocking_pending = /* @__PURE__ */ new WeakMap();
-var _deferred = /* @__PURE__ */ new WeakMap();
-var _roots = /* @__PURE__ */ new WeakMap();
-var _new_effects = /* @__PURE__ */ new WeakMap();
+function boundary(node, props, children, transform_error) {
+	new Boundary(node, props, children, transform_error);
+}
+var _anchor = /* @__PURE__ */ new WeakMap();
+var _hydrate_open = /* @__PURE__ */ new WeakMap();
+var _props = /* @__PURE__ */ new WeakMap();
+var _children = /* @__PURE__ */ new WeakMap();
+var _effect = /* @__PURE__ */ new WeakMap();
+var _main_effect = /* @__PURE__ */ new WeakMap();
+var _pending_effect = /* @__PURE__ */ new WeakMap();
+var _failed_effect = /* @__PURE__ */ new WeakMap();
+var _offscreen_fragment = /* @__PURE__ */ new WeakMap();
+var _local_pending_count = /* @__PURE__ */ new WeakMap();
+var _pending_count = /* @__PURE__ */ new WeakMap();
+var _pending_count_update_queued = /* @__PURE__ */ new WeakMap();
 var _dirty_effects$1 = /* @__PURE__ */ new WeakMap();
 var _maybe_dirty_effects$1 = /* @__PURE__ */ new WeakMap();
-var _skipped_branches = /* @__PURE__ */ new WeakMap();
-var _unskipped_branches = /* @__PURE__ */ new WeakMap();
-var _decrement_queued = /* @__PURE__ */ new WeakMap();
-var _Batch_brand = /* @__PURE__ */ new WeakSet();
-var Batch = class Batch {
-	constructor() {
-		_classPrivateMethodInitSpec(this, _Batch_brand);
-		_defineProperty(this, "id", uid++);
-		_classPrivateFieldInitSpec(this, _started, false);
-		_defineProperty(this, "linked", true);
-		_classPrivateFieldInitSpec(this, _prev, null);
-		_classPrivateFieldInitSpec(this, _next, null);
-		_defineProperty(
-			this,
-			/** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
-			"async_deriveds",
-			/* @__PURE__ */ new Map()
-		);
+var _effect_pending = /* @__PURE__ */ new WeakMap();
+var _effect_pending_subscriber = /* @__PURE__ */ new WeakMap();
+var _Boundary_brand = /* @__PURE__ */ new WeakSet();
+var Boundary = class {
+	/**
+	* @param {TemplateNode} node
+	* @param {BoundaryProps} props
+	* @param {((anchor: Node) => void)} children
+	* @param {((error: unknown) => unknown) | undefined} [transform_error]
+	*/
+	constructor(node, props, children, transform_error) {
+		_classPrivateMethodInitSpec(this, _Boundary_brand);
 		_defineProperty(
 			this,
-			/**
-			* 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()
+			/** @type {Boundary | null} */
+			"parent",
+			void 0
 		);
+		_defineProperty(this, "is_pending", false);
 		_defineProperty(
 			this,
 			/**
-			* 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>}
+			* 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}
 			*/
-			"previous",
-			/* @__PURE__ */ new Map()
+			"transform_error",
+			void 0
 		);
-		_classPrivateFieldInitSpec(this, _commit_callbacks, /* @__PURE__ */ new Set());
-		_classPrivateFieldInitSpec(this, _discard_callbacks, /* @__PURE__ */ new Set());
-		_classPrivateFieldInitSpec(this, _pending, 0);
-		_classPrivateFieldInitSpec(this, _blocking_pending, /* @__PURE__ */ new Map());
-		_classPrivateFieldInitSpec(this, _deferred, null);
-		_classPrivateFieldInitSpec(this, _roots, []);
-		_classPrivateFieldInitSpec(this, _new_effects, []);
+		_classPrivateFieldInitSpec(this, _anchor, void 0);
+		_classPrivateFieldInitSpec(this, _hydrate_open, hydrating ? hydrate_node : null);
+		_classPrivateFieldInitSpec(this, _props, void 0);
+		_classPrivateFieldInitSpec(this, _children, void 0);
+		_classPrivateFieldInitSpec(this, _effect, void 0);
+		_classPrivateFieldInitSpec(this, _main_effect, null);
+		_classPrivateFieldInitSpec(this, _pending_effect, null);
+		_classPrivateFieldInitSpec(this, _failed_effect, null);
+		_classPrivateFieldInitSpec(this, _offscreen_fragment, null);
+		_classPrivateFieldInitSpec(this, _local_pending_count, 0);
+		_classPrivateFieldInitSpec(this, _pending_count, 0);
+		_classPrivateFieldInitSpec(this, _pending_count_update_queued, false);
 		_classPrivateFieldInitSpec(this, _dirty_effects$1, /* @__PURE__ */ new Set());
 		_classPrivateFieldInitSpec(this, _maybe_dirty_effects$1, /* @__PURE__ */ new Set());
-		_classPrivateFieldInitSpec(this, _skipped_branches, /* @__PURE__ */ new Map());
-		_classPrivateFieldInitSpec(this, _unskipped_branches, /* @__PURE__ */ new Set());
-		_defineProperty(this, "is_fork", false);
-		_classPrivateFieldInitSpec(this, _decrement_queued, false);
-		if (last_batch === null) first_batch = last_batch = this;
-		else {
-			_classPrivateFieldSet2(_next, last_batch, this);
-			_classPrivateFieldSet2(_prev, this, last_batch);
-		}
-		last_batch = this;
-	}
-	/**
-	* Add an effect to the #skipped_branches map and reset its children
-	* @param {Effect} effect
-	*/
-	skip_effect(effect) {
-		if (!_classPrivateFieldGet2(_skipped_branches, this).has(effect)) _classPrivateFieldGet2(_skipped_branches, this).set(effect, {
-			d: [],
-			m: []
-		});
-		_classPrivateFieldGet2(_unskipped_branches, this).delete(effect);
+		_classPrivateFieldInitSpec(this, _effect_pending, null);
+		_classPrivateFieldInitSpec(this, _effect_pending_subscriber, createSubscriber(() => {
+			_classPrivateFieldSet2(_effect_pending, this, source(_classPrivateFieldGet2(_local_pending_count, this)));
+			return () => {
+				_classPrivateFieldSet2(_effect_pending, this, null);
+			};
+		}));
+		_classPrivateFieldSet2(_anchor, this, node);
+		_classPrivateFieldSet2(_props, this, props);
+		_classPrivateFieldSet2(_children, this, (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);
+		_classPrivateFieldSet2(_effect, this, block(() => {
+			if (hydrating) {
+				const comment = _classPrivateFieldGet2(_hydrate_open, this);
+				hydrate_next();
+				const server_rendered_pending = comment.data === "[!";
+				if (comment.data.startsWith("[?")) {
+					const serialized_error = JSON.parse(comment.data.slice(2));
+					_assertClassBrand(_Boundary_brand, this, _hydrate_failed_content).call(this, serialized_error);
+				} else if (server_rendered_pending) _assertClassBrand(_Boundary_brand, this, _hydrate_pending_content).call(this);
+				else _assertClassBrand(_Boundary_brand, this, _hydrate_resolved_content).call(this);
+			} else _assertClassBrand(_Boundary_brand, this, _render).call(this);
+		}, flags));
+		if (hydrating) _classPrivateFieldSet2(_anchor, this, hydrate_node);
 	}
 	/**
-	* Remove an effect from the #skipped_branches map and reschedule
-	* any tracked dirty/maybe_dirty child 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 = _classPrivateFieldGet2(_skipped_branches, this).get(effect);
-		if (tracked) {
-			_classPrivateFieldGet2(_skipped_branches, this).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);
-			}
-		}
-		_classPrivateFieldGet2(_unskipped_branches, this).add(effect);
-	}
-	/**
-	* 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;
-			_assertClassBrand(_Batch_brand, this, _process).call(this);
-		} 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 _classPrivateFieldGet2(_discard_callbacks, this)) fn(this);
-		_classPrivateFieldGet2(_discard_callbacks, this).clear();
-		_assertClassBrand(_Batch_brand, this, _unlink).call(this);
-		_classPrivateFieldGet2(_deferred, this)?.resolve();
+	defer_effect(effect) {
+		defer_effect(effect, _classPrivateFieldGet2(_dirty_effects$1, this), _classPrivateFieldGet2(_maybe_dirty_effects$1, this));
 	}
 	/**
-	* @param {Effect} effect
+	* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
+	* @returns {boolean}
 	*/
-	register_created_effect(effect) {
-		_classPrivateFieldGet2(_new_effects, this).push(effect);
+	is_rendered() {
+		return !this.is_pending && (!this.parent || this.parent.is_rendered());
 	}
-	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
-	*/
-	increment(blocking, effect) {
-		_classPrivateFieldSet2(_pending, this, _classPrivateFieldGet2(_pending, this) + 1);
-		if (blocking) {
-			let blocking_pending_count = _classPrivateFieldGet2(_blocking_pending, this).get(effect) ?? 0;
-			_classPrivateFieldGet2(_blocking_pending, this).set(effect, blocking_pending_count + 1);
-		}
+	has_pending_snippet() {
+		return !!_classPrivateFieldGet2(_props, this).pending;
 	}
 	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
+	* Update the source that powers `$effect.pending()` inside this boundary,
+	* and controls when the current `pending` snippet (if any) is removed.
+	* Do not call from inside the class
+	* @param {1 | -1} d
+	* @param {Batch} batch
 	*/
-	decrement(blocking, effect) {
-		_classPrivateFieldSet2(_pending, this, _classPrivateFieldGet2(_pending, this) - 1);
-		if (blocking) {
-			let blocking_pending_count = _classPrivateFieldGet2(_blocking_pending, this).get(effect) ?? 0;
-			if (blocking_pending_count === 1) _classPrivateFieldGet2(_blocking_pending, this).delete(effect);
-			else _classPrivateFieldGet2(_blocking_pending, this).set(effect, blocking_pending_count - 1);
-		}
-		if (_classPrivateFieldGet2(_decrement_queued, this)) return;
-		_classPrivateFieldSet2(_decrement_queued, this, true);
+	update_pending_count(d, batch) {
+		_assertClassBrand(_Boundary_brand, this, _update_pending_count).call(this, d, batch);
+		_classPrivateFieldSet2(_local_pending_count, this, _classPrivateFieldGet2(_local_pending_count, this) + d);
+		if (!_classPrivateFieldGet2(_effect_pending, this) || _classPrivateFieldGet2(_pending_count_update_queued, this)) return;
+		_classPrivateFieldSet2(_pending_count_update_queued, this, true);
 		queue_micro_task(() => {
-			_classPrivateFieldSet2(_decrement_queued, this, false);
-			if (this.linked) this.flush();
+			_classPrivateFieldSet2(_pending_count_update_queued, this, false);
+			if (_classPrivateFieldGet2(_effect_pending, this)) internal_set(_classPrivateFieldGet2(_effect_pending, this), _classPrivateFieldGet2(_local_pending_count, this));
 		});
 	}
-	/**
-	* @param {Set<Effect>} dirty_effects
-	* @param {Set<Effect>} maybe_dirty_effects
-	*/
-	transfer_effects(dirty_effects, maybe_dirty_effects) {
-		for (const e of dirty_effects) _classPrivateFieldGet2(_dirty_effects$1, this).add(e);
-		for (const e of maybe_dirty_effects) _classPrivateFieldGet2(_maybe_dirty_effects$1, this).add(e);
-		dirty_effects.clear();
-		maybe_dirty_effects.clear();
-	}
-	/** @param {(batch: Batch) => void} fn */
-	oncommit(fn) {
-		_classPrivateFieldGet2(_commit_callbacks, this).add(fn);
-	}
-	/** @param {(batch: Batch) => void} fn */
-	ondiscard(fn) {
-		_classPrivateFieldGet2(_discard_callbacks, this).add(fn);
-	}
-	settled() {
-		return (_classPrivateFieldGet2(_deferred, this) ?? _classPrivateFieldSet2(_deferred, this, deferred())).promise;
+	get_effect_pending() {
+		_classPrivateFieldGet2(_effect_pending_subscriber, this).call(this);
+		return get(_classPrivateFieldGet2(_effect_pending, this));
 	}
-	static ensure() {
-		if (current_batch === null) {
-			const batch = current_batch = new Batch();
-			if (!is_processing && !is_flushing_sync) queue_micro_task(() => {
-				if (!_classPrivateFieldGet2(_started, batch)) batch.flush();
+	/** @param {unknown} error */
+	error(error) {
+		if (!_classPrivateFieldGet2(_props, this).onerror && !_classPrivateFieldGet2(_props, this).failed) throw error;
+		if (current_batch?.is_fork) {
+			if (_classPrivateFieldGet2(_main_effect, this)) current_batch.skip_effect(_classPrivateFieldGet2(_main_effect, this));
+			if (_classPrivateFieldGet2(_pending_effect, this)) current_batch.skip_effect(_classPrivateFieldGet2(_pending_effect, this));
+			if (_classPrivateFieldGet2(_failed_effect, this)) current_batch.skip_effect(_classPrivateFieldGet2(_failed_effect, this));
+			current_batch.oncommit(() => {
+				_assertClassBrand(_Boundary_brand, this, _handle_error).call(this, error);
 			});
-		}
-		return current_batch;
+		} else _assertClassBrand(_Boundary_brand, this, _handle_error).call(this, error);
 	}
-	apply() {
-		if (!async_mode_flag || !this.is_fork && _classPrivateFieldGet2(_prev, this) === null && _classPrivateFieldGet2(_next, this) === null) {
-			batch_values = null;
-			return;
-		}
-		batch_values = /* @__PURE__ */ new Map();
-		for (const [source, [value]] of this.current) batch_values.set(source, value);
-		for (let batch = first_batch; batch !== null; batch = _classPrivateFieldGet2(_next, batch)) {
-			if (batch === this || batch.is_fork) continue;
-			var intersects = false;
-			if (batch.id < this.id) for (const [source, [, is_derived]] of batch.current) {
-				if (is_derived) continue;
-				if (this.current.has(source)) {
-					intersects = true;
-					break;
-				}
-			}
-			if (!intersects) {
-				for (const [source, previous] of batch.previous) if (!batch_values.has(source)) batch_values.set(source, previous);
-			}
-		}
+};
+function _hydrate_resolved_content() {
+	try {
+		_classPrivateFieldSet2(_main_effect, this, branch(() => _classPrivateFieldGet2(_children, this).call(this, _classPrivateFieldGet2(_anchor, this))));
+	} catch (error) {
+		this.error(error);
 	}
-	/**
-	*
-	* @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);
+}
+/**
+* @param {unknown} error The deserialized error from the server's hydration comment
+*/
+function _hydrate_failed_content(error) {
+	const failed = _classPrivateFieldGet2(_props, this).failed;
+	const { reset, invoke_onerror } = _assertClassBrand(_Boundary_brand, this, _create_reset).call(this, error);
+	queue_micro_task(invoke_onerror);
+	if (!failed) return;
+	_classPrivateFieldSet2(_failed_effect, this, branch(() => {
+		failed(_classPrivateFieldGet2(_anchor, this), () => error, () => reset);
+	}));
+}
+/**
+* Creates the `reset` function for a failed boundary, along with a function
+* that invokes `onerror` with it (if provided)
+* @param {unknown} error
+* @returns {{ reset: () => void, invoke_onerror: () => void }}
+*/
+function _create_reset(error) {
+	var did_reset = false;
+	var calling_on_error = false;
+	const reset = () => {
+		if (did_reset) {
+			svelte_boundary_reset_noop();
 			return;
 		}
-		var e = effect;
-		while (e.parent !== null) {
-			e = e.parent;
-			var flags = e.f;
-			if (collected_effects !== null && e === active_effect) {
-				if (async_mode_flag) return;
-				if ((active_reaction === null || (active_reaction.f & 2) === 0) && !legacy_is_updating_store) return;
-			}
-			if ((flags & 96) !== 0) {
-				if ((flags & 1024) === 0) return;
-				e.f ^= CLEAN;
-			}
+		did_reset = true;
+		if (calling_on_error) svelte_boundary_reset_onerror();
+		if (_classPrivateFieldGet2(_failed_effect, this) !== null) pause_effect(_classPrivateFieldGet2(_failed_effect, this), () => {
+			_classPrivateFieldSet2(_failed_effect, this, null);
+		});
+		_assertClassBrand(_Boundary_brand, this, _run).call(this, () => {
+			_assertClassBrand(_Boundary_brand, this, _render).call(this);
+		});
+	};
+	const invoke_onerror = () => {
+		try {
+			calling_on_error = true;
+			_classPrivateFieldGet2(_props, this).onerror?.(error, reset);
+			calling_on_error = false;
+		} catch (err) {
+			invoke_error_boundary(err, _classPrivateFieldGet2(_effect, this) && _classPrivateFieldGet2(_effect, this).parent);
 		}
-		_classPrivateFieldGet2(_roots, this).push(e);
-	}
-};
-_Batch = Batch;
-function _is_deferred() {
-	if (this.is_fork) return true;
-	for (const effect of _classPrivateFieldGet2(_blocking_pending, this).keys()) {
-		var e = effect;
-		var skipped = false;
-		while (e.parent !== null) {
-			if (_classPrivateFieldGet2(_skipped_branches, this).has(e)) {
-				skipped = true;
-				break;
-			}
-			e = e.parent;
+	};
+	return {
+		reset,
+		invoke_onerror
+	};
+}
+function _hydrate_pending_content() {
+	const pending = _classPrivateFieldGet2(_props, this).pending;
+	if (!pending) return;
+	this.is_pending = true;
+	_classPrivateFieldSet2(_pending_effect, this, branch(() => pending(_classPrivateFieldGet2(_anchor, this))));
+	queue_micro_task(() => {
+		var fragment = _classPrivateFieldSet2(_offscreen_fragment, this, document.createDocumentFragment());
+		var anchor = create_text();
+		fragment.append(anchor);
+		_classPrivateFieldSet2(_main_effect, this, _assertClassBrand(_Boundary_brand, this, _run).call(this, () => {
+			return branch(() => _classPrivateFieldGet2(_children, this).call(this, anchor));
+		}));
+		if (_classPrivateFieldGet2(_pending_count, this) === 0) {
+			_classPrivateFieldGet2(_anchor, this).before(fragment);
+			_classPrivateFieldSet2(_offscreen_fragment, this, null);
+			pause_effect(_classPrivateFieldGet2(_pending_effect, this), () => {
+				_classPrivateFieldSet2(_pending_effect, this, null);
+			});
+			_assertClassBrand(_Boundary_brand, this, _resolve).call(this, current_batch);
 		}
-		if (!skipped) return true;
-	}
-	return false;
+	});
 }
-function _process() {
-	_classPrivateFieldSet2(_started, this, true);
-	if (flush_count++ > 1e3) {
-		_assertClassBrand(_Batch_brand, this, _unlink).call(this);
-		infinite_loop_guard();
-	}
-	for (const e of _classPrivateFieldGet2(_dirty_effects$1, this)) {
-		_classPrivateFieldGet2(_maybe_dirty_effects$1, this).delete(e);
-		set_signal_status(e, DIRTY);
-		this.schedule(e);
-	}
-	for (const e of _classPrivateFieldGet2(_maybe_dirty_effects$1, this)) {
-		set_signal_status(e, MAYBE_DIRTY);
-		this.schedule(e);
+function _render() {
+	try {
+		this.is_pending = this.has_pending_snippet();
+		_classPrivateFieldSet2(_pending_count, this, 0);
+		_classPrivateFieldSet2(_local_pending_count, this, 0);
+		_classPrivateFieldSet2(_main_effect, this, branch(() => {
+			_classPrivateFieldGet2(_children, this).call(this, _classPrivateFieldGet2(_anchor, this));
+		}));
+		if (_classPrivateFieldGet2(_pending_count, this) > 0) {
+			var fragment = _classPrivateFieldSet2(_offscreen_fragment, this, document.createDocumentFragment());
+			move_effect(_classPrivateFieldGet2(_main_effect, this), fragment);
+			const pending = _classPrivateFieldGet2(_props, this).pending;
+			_classPrivateFieldSet2(_pending_effect, this, branch(() => pending(_classPrivateFieldGet2(_anchor, this))));
+		} else _assertClassBrand(_Boundary_brand, this, _resolve).call(this, current_batch);
+	} catch (error) {
+		this.error(error);
 	}
-	const roots = _classPrivateFieldGet2(_roots, this);
-	_classPrivateFieldSet2(_roots, this, []);
-	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 {
-		_assertClassBrand(_Batch_brand, this, _traverse).call(this, root, effects, render_effects);
+}
+/**
+* @param {Batch} batch
+*/
+function _resolve(batch) {
+	this.is_pending = false;
+	batch.transfer_effects(_classPrivateFieldGet2(_dirty_effects$1, this), _classPrivateFieldGet2(_maybe_dirty_effects$1, this));
+}
+/**
+* @template T
+* @param {() => T} fn
+*/
+function _run(fn) {
+	var previous_effect = active_effect;
+	var previous_reaction = active_reaction;
+	var previous_ctx = component_context;
+	set_active_effect(_classPrivateFieldGet2(_effect, this));
+	set_active_reaction(_classPrivateFieldGet2(_effect, this));
+	set_component_context(_classPrivateFieldGet2(_effect, this).ctx);
+	try {
+		Batch.ensure();
+		return fn();
 	} catch (e) {
-		reset_all(root);
-		if (!_assertClassBrand(_Batch_brand, this, _is_deferred).call(this)) 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 (_assertClassBrand(_Batch_brand, this, _is_deferred).call(this)) {
-		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, render_effects);
-		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, effects);
-		for (const [e, t] of _classPrivateFieldGet2(_skipped_branches, this)) reset_branch(e, t);
-		if (updates.length > 0)
- /** @type {Batch} */ _assertClassBrand(_Batch_brand, current_batch, _process).call(current_batch);
-		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 = _assertClassBrand(_Batch_brand, this, _find_earlier_batch).call(this);
-	if (earlier_batch) {
-		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, render_effects);
-		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, effects);
-		_assertClassBrand(_Batch_brand, earlier_batch, _merge).call(earlier_batch, 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
+*/
+function _update_pending_count(d, batch) {
+	if (!this.has_pending_snippet()) {
+		if (this.parent) {
+			var _this$parent;
+			_assertClassBrand(_Boundary_brand, _this$parent = this.parent, _update_pending_count).call(_this$parent, d, batch);
+		}
 		return;
 	}
-	_classPrivateFieldGet2(_dirty_effects$1, this).clear();
-	_classPrivateFieldGet2(_maybe_dirty_effects$1, this).clear();
-	for (const fn of _classPrivateFieldGet2(_commit_callbacks, this)) fn(this);
-	_classPrivateFieldGet2(_commit_callbacks, this).clear();
-	previous_batch = this;
-	flush_queued_effects(render_effects);
-	flush_queued_effects(effects);
-	previous_batch = null;
-	_classPrivateFieldGet2(_deferred, this)?.resolve();
-	var next_batch = current_batch;
-	if (_classPrivateFieldGet2(_pending, this) === 0 && (_classPrivateFieldGet2(_roots, this).length === 0 || next_batch !== null)) {
-		_assertClassBrand(_Batch_brand, this, _unlink).call(this);
-		if (async_mode_flag) {
-			_assertClassBrand(_Batch_brand, this, _commit$1).call(this);
-			current_batch = next_batch;
+	_classPrivateFieldSet2(_pending_count, this, _classPrivateFieldGet2(_pending_count, this) + d);
+	if (_classPrivateFieldGet2(_pending_count, this) === 0) {
+		_assertClassBrand(_Boundary_brand, this, _resolve).call(this, batch);
+		if (_classPrivateFieldGet2(_pending_effect, this)) pause_effect(_classPrivateFieldGet2(_pending_effect, this), () => {
+			_classPrivateFieldSet2(_pending_effect, this, null);
+		});
+		if (_classPrivateFieldGet2(_offscreen_fragment, this)) {
+			_classPrivateFieldGet2(_anchor, this).before(_classPrivateFieldGet2(_offscreen_fragment, this));
+			_classPrivateFieldSet2(_offscreen_fragment, this, null);
 		}
 	}
-	if (_classPrivateFieldGet2(_roots, this).length > 0) if (next_batch !== null) {
-		const batch = next_batch;
-		_classPrivateFieldGet2(_roots, batch).push(..._classPrivateFieldGet2(_roots, this).filter((r) => !_classPrivateFieldGet2(_roots, batch).includes(r)));
-	} else next_batch = this;
-	if (next_batch !== null) _assertClassBrand(_Batch_brand, next_batch, _process).call(next_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
+* @param {unknown} error
 */
-function _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 || _classPrivateFieldGet2(_skipped_branches, this).has(effect)) && effect.fn !== null) {
-			if (is_branch) effect.f ^= CLEAN;
-			else if ((flags & 4) !== 0) effects.push(effect);
-			else if (async_mode_flag && (flags & 16777224) !== 0) render_effects.push(effect);
-			else if (is_dirty(effect)) {
-				if ((flags & 16) !== 0) _classPrivateFieldGet2(_maybe_dirty_effects$1, this).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;
-		}
+function _handle_error(error) {
+	if (_classPrivateFieldGet2(_main_effect, this)) {
+		destroy_effect(_classPrivateFieldGet2(_main_effect, this));
+		_classPrivateFieldSet2(_main_effect, this, null);
 	}
-}
-function _find_earlier_batch() {
-	var batch = _classPrivateFieldGet2(_prev, this);
-	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 = _classPrivateFieldGet2(_prev, batch);
+	if (_classPrivateFieldGet2(_pending_effect, this)) {
+		destroy_effect(_classPrivateFieldGet2(_pending_effect, this));
+		_classPrivateFieldSet2(_pending_effect, this, null);
 	}
-	return null;
+	if (_classPrivateFieldGet2(_failed_effect, this)) {
+		destroy_effect(_classPrivateFieldGet2(_failed_effect, this));
+		_classPrivateFieldSet2(_failed_effect, this, null);
+	}
+	if (hydrating) {
+		set_hydrate_node(_classPrivateFieldGet2(_hydrate_open, this));
+		next();
+		set_hydrate_node(skip_nodes());
+	}
+	let failed = _classPrivateFieldGet2(_props, this).failed;
+	/** @param {unknown} transformed_error */
+	const handle_error_result = (transformed_error) => {
+		const { reset, invoke_onerror } = _assertClassBrand(_Boundary_brand, this, _create_reset).call(this, transformed_error);
+		invoke_onerror();
+		if (failed) _classPrivateFieldSet2(_failed_effect, this, _assertClassBrand(_Boundary_brand, this, _run).call(this, () => {
+			try {
+				return branch(() => {
+					var effect = active_effect;
+					effect.b = this;
+					effect.f |= 128;
+					failed(_classPrivateFieldGet2(_anchor, this), () => transformed_error, () => reset);
+				});
+			} catch (error) {
+				invoke_error_boundary(error, _classPrivateFieldGet2(_effect, this).parent);
+				return null;
+			}
+		}));
+	};
+	queue_micro_task(() => {
+		/** @type {unknown} */
+		var result;
+		try {
+			result = this.transform_error(error);
+		} catch (e) {
+			invoke_error_boundary(e, _classPrivateFieldGet2(_effect, this) && _classPrivateFieldGet2(_effect, this).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, _classPrivateFieldGet2(_effect, this) && _classPrivateFieldGet2(_effect, this).parent)
+		);
+		else handle_error_result(result);
+	});
 }
+//#endregion
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/async.js
+/** @import { Blocker, Effect, Source, Value } from '#client' */
 /**
-* @param {Batch} batch
+* @param {Blocker[]} blockers
+* @param {Array<() => any>} sync
+* @param {Array<() => Promise<any>>} async
+* @param {(values: Value[]) => any} fn
 */
-function _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);
+function flatten(blockers, sync, async, fn) {
+	const d = is_runes() ? derived : derived_safe_equal;
+	var pending = blockers.filter((b) => !b.settled);
+	var deriveds = sync.map(d);
+	if (async.length === 0 && pending.length === 0) {
+		fn(deriveds);
+		return;
 	}
-	this.transfer_effects(_classPrivateFieldGet2(_dirty_effects$1, batch), _classPrivateFieldGet2(_maybe_dirty_effects$1, batch));
+	var parent = active_effect;
+	var restore = capture();
+	var blocker_promise = pending.length === 1 ? pending[0].promise : pending.length > 1 ? Promise.all(pending.map((b) => b.promise)) : null;
 	/**
-	* 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
+	* @param {Source[]} async
 	*/
-	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)) {
-					_classPrivateFieldGet2(_maybe_dirty_effects$1, this).delete(effect);
-					set_signal_status(effect, DIRTY);
-					this.schedule(effect);
-				}
-			}
+	function finish(async) {
+		if ((parent.f & 16384) !== 0) return;
+		restore();
+		try {
+			fn([...deriveds, ...async]);
+		} catch (error) {
+			invoke_error_boundary(error, parent);
+		}
+		unset_context();
+	}
+	var decrement_pending = increment_pending();
+	if (async.length === 0) {
+		/** @type {Promise<any>} */ blocker_promise.then(() => finish([])).finally(decrement_pending);
+		return;
+	}
+	function run() {
+		Promise.all(async.map((expression) => /* @__PURE__ */ async_derived(expression))).then(finish).catch((error) => invoke_error_boundary(error, parent)).finally(decrement_pending);
+	}
+	if (blocker_promise) blocker_promise.then(() => {
+		restore();
+		run();
+		unset_context();
+	});
+	else run();
+}
+/**
+* Captures the current effect context so that we can restore it after
+* some asynchronous work has happened (so that e.g. `await a + b`
+* causes `b` to be registered as a dependency).
+*/
+function capture() {
+	var previous_effect = active_effect;
+	var previous_reaction = active_reaction;
+	var previous_component_context = component_context;
+	var previous_batch = current_batch;
+	return function restore(activate_batch = true) {
+		set_active_effect(previous_effect);
+		set_active_reaction(previous_reaction);
+		set_component_context(previous_component_context);
+		if (activate_batch && (previous_effect.f & 16384) === 0) {
+			previous_batch?.activate();
+			previous_batch?.apply();
 		}
 	};
-	for (const source of this.current.keys()) mark(source);
-	this.oncommit(() => batch.discard());
-	_assertClassBrand(_Batch_brand, batch, _unlink).call(batch);
-	current_batch = this;
-	_assertClassBrand(_Batch_brand, this, _process).call(this);
 }
+function unset_context(deactivate_batch = true) {
+	set_active_effect(null);
+	set_active_reaction(null);
+	set_component_context(null);
+	if (deactivate_batch) current_batch?.deactivate();
+}
+/**
+* @returns {(skip?: boolean) => void}
+*/
+function increment_pending() {
+	var effect = active_effect;
+	var boundary = effect.b;
+	var batch = current_batch;
+	var blocking = !!boundary?.is_rendered();
+	boundary?.update_pending_count(1, batch);
+	batch.increment(blocking, effect);
+	return () => {
+		boundary?.update_pending_count(-1, batch);
+		batch.decrement(blocking, effect);
+	};
+}
+/**
+* @template V
+* @param {() => V} fn
+* @returns {Derived<V>}
+*/
+/*#__NO_SIDE_EFFECTS__*/
+function derived(fn) {
+	var flags = 2 | DIRTY;
+	if (active_effect !== null) active_effect.f |= EFFECT_PRESERVED;
+	return {
+		ctx: component_context,
+		deps: null,
+		effects: null,
+		equals,
+		f: flags,
+		fn,
+		reactions: null,
+		rv: 0,
+		v: UNINITIALIZED,
+		wv: 0,
+		parent: active_effect,
+		ac: null
+	};
+}
+var OBSOLETE = Symbol("obsolete");
 /**
-* @param {Effect[]} effects
+* @template V
+* @param {() => V | Promise<V>} fn
+* @param {string} [label]
+* @param {string} [location] If provided, print a warning if the value is not read immediately after update
+* @returns {Promise<Source<V>>}
 */
-function _defer_effects(effects) {
-	for (var i = 0; i < effects.length; i += 1) defer_effect(effects[i], _classPrivateFieldGet2(_dirty_effects$1, this), _classPrivateFieldGet2(_maybe_dirty_effects$1, this));
-}
-function _commit$1() {
-	for (let batch = first_batch; batch !== null; batch = _classPrivateFieldGet2(_next, batch)) {
-		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);
+/*#__NO_SIDE_EFFECTS__*/
+function async_derived(fn, label, location) {
+	let parent = active_effect;
+	if (parent === null) async_derived_orphan();
+	var promise = void 0;
+	var signal = source(UNINITIALIZED);
+	var should_suspend = !active_reaction;
+	/** @type {Set<ReturnType<typeof deferred<V>>>} */
+	var deferreds = /* @__PURE__ */ new Set();
+	async_effect(() => {
+		var effect = active_effect;
+		/** @type {ReturnType<typeof deferred<V>>} */
+		var d = deferred();
+		promise = d.promise;
+		try {
+			Promise.resolve(fn()).then(d.resolve, (e) => {
+				if (e !== STALE_REACTION) d.reject(e);
+			}).finally(unset_context);
+		} catch (error) {
+			d.reject(error);
+			unset_context();
 		}
-		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 batch = current_batch;
+		if (should_suspend) {
+			if ((effect.f & 32768) !== 0) var decrement_pending = increment_pending();
+			if (parent.b?.is_rendered()) batch.async_deriveds.get(effect)?.reject(OBSOLETE);
+			else for (const d of deferreds.values()) d.reject(OBSOLETE);
+			deferreds.add(d);
+			batch.async_deriveds.set(effect, d);
 		}
-		if (!_classPrivateFieldGet2(_started, batch)) 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 _classPrivateFieldGet2(_unskipped_branches, this)) batch.unskip_effect(unskipped, (e) => {
-				if ((e.f & 4194320) !== 0) batch.schedule(e);
-				else _assertClassBrand(_Batch_brand, batch, _defer_effects).call(batch, [e]);
-			});
+		/**
+		* @param {any} value
+		* @param {unknown} error
+		*/
+		const handler = (value, error = void 0) => {
+			decrement_pending?.();
+			deferreds.delete(d);
+			if (error === OBSOLETE) return;
 			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 _classPrivateFieldGet2(_new_effects, this)) 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 _classPrivateFieldGet2(_dirty_effects$1, batch).add(effect);
-			}
-			if (_classPrivateFieldGet2(_roots, batch).length > 0 && !_classPrivateFieldGet2(_decrement_queued, batch)) {
-				batch.apply();
-				for (var root of _classPrivateFieldGet2(_roots, batch)) _assertClassBrand(_Batch_brand, batch, _traverse).call(batch, root, [], []);
-				_classPrivateFieldSet2(_roots, batch, []);
+			if (error) {
+				signal.f |= ERROR_VALUE;
+				internal_set(signal, error);
+			} else {
+				if ((signal.f & 8388608) !== 0) signal.f ^= ERROR_VALUE;
+				internal_set(signal, value);
 			}
 			batch.deactivate();
+		};
+		d.promise.then(handler, (e) => handler(null, e || "unknown"));
+	});
+	teardown(() => {
+		for (const d of deferreds) d.reject(OBSOLETE);
+	});
+	return new Promise((fulfil) => {
+		/** @param {Promise<V>} p */
+		function next(p) {
+			function go() {
+				if (p === promise) fulfil(signal);
+				else next(promise);
+			}
+			p.then(go, go);
 		}
-	}
-}
-function _unlink() {
-	if (!this.linked) return;
-	var prev = _classPrivateFieldGet2(_prev, this);
-	var next = _classPrivateFieldGet2(_next, this);
-	if (prev === null) first_batch = next;
-	else _classPrivateFieldSet2(_next, prev, next);
-	if (next === null) last_batch = prev;
-	else _classPrivateFieldSet2(_prev, next, prev);
-	this.linked = false;
+		next(promise);
+	});
 }
 /**
-* 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}
+* @template V
+* @param {() => V} fn
+* @returns {Derived<V>}
 */
-function flushSync(fn) {
-	var was_flushing_sync = is_flushing_sync;
-	is_flushing_sync = true;
-	try {
-		var result;
-		if (fn) {
-			if (current_batch !== null && !current_batch.is_fork) current_batch.flush();
-			result = fn();
-		}
-		while (true) {
-			flush_tasks();
-			if (current_batch === null) return result;
-			current_batch.flush();
-		}
-	} finally {
-		is_flushing_sync = was_flushing_sync;
-	}
-}
-function infinite_loop_guard() {
-	try {
-		effect_update_depth_exceeded();
-	} catch (error) {
-		invoke_error_boundary(error, last_scheduled_effect);
-	}
+/*#__NO_SIDE_EFFECTS__*/
+function user_derived(fn) {
+	const d = /* @__PURE__ */ derived(fn);
+	if (!async_mode_flag) push_reaction_value(d);
+	return d;
 }
-/** @type {Set<Effect> | null} */
-var eager_block_effects = null;
 /**
-* @param {Array<Effect>} effects
-* @returns {void}
+* @template V
+* @param {() => V} fn
+* @returns {Derived<V>}
 */
-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();
-			}
-		}
-	}
-	eager_block_effects = null;
+/*#__NO_SIDE_EFFECTS__*/
+function derived_safe_equal(fn) {
+	const signal = /* @__PURE__ */ derived(fn);
+	signal.equals = safe_equals;
+	return signal;
 }
 /**
-* 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
+* @param {Derived} derived
+* @returns {void}
 */
-function mark_effects(value, sources, marked, checked) {
-	if (marked.has(value)) return;
-	marked.add(value);
-	if (value.reactions !== null) for (const reaction of value.reactions) {
-		const flags = reaction.f;
-		if ((flags & 2) !== 0) mark_effects(reaction, sources, marked, checked);
-		else if ((flags & 4194320) !== 0 && (flags & 2048) === 0 && depends_on(reaction, sources, checked)) {
-			set_signal_status(reaction, DIRTY);
-			schedule_effect(reaction);
-		}
+function 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]);
 	}
 }
 /**
-* @param {Reaction} reaction
-* @param {Source[]} sources
-* @param {Map<Reaction, boolean>} checked
+* @template T
+* @param {Derived} derived
+* @returns {T}
 */
-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;
-		}
+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);
+	try {
+		derived.f &= ~WAS_MARKED;
+		destroy_derived_effects(derived);
+		value = update_reaction(derived);
+	} finally {
+		set_active_effect(prev_active_effect);
 	}
-	checked.set(reaction, false);
-	return false;
+	return value;
 }
 /**
-* @param {Effect} effect
+* @param {Derived} derived
 * @returns {void}
 */
-function schedule_effect(effect) {
-	/** @type {Batch} */ current_batch.schedule(effect);
+function update_derived(derived) {
+	var value = execute_derived(derived);
+	if (!derived.equals(value)) {
+		derived.wv = increment_write_version();
+		if (!current_batch?.is_fork || derived.deps === null) {
+			if (current_batch !== null) {
+				current_batch.capture(derived, value, true);
+				previous_batch?.capture(derived, value, true);
+			} else derived.v = value;
+			if (derived.deps === null) {
+				set_signal_status(derived, CLEAN);
+				return;
+			}
+		}
+	}
+	if (is_destroying_effect) return;
+	if (batch_values !== null) {
+		if (effect_tracking() || current_batch?.is_fork) batch_values.set(derived, value);
+	} else update_derived_status(derived);
 }
 /**
-* Mark all the effects inside a skipped branch CLEAN, so that
-* they can be correctly rescheduled later. Tracks dirty and maybe_dirty
-* effects so they can be rescheduled if the branch survives.
-* @param {Effect} effect
-* @param {{ d: Effect[], m: Effect[] }} tracked
+* @param {Derived} derived
 */
-function reset_branch(effect, tracked) {
-	if ((effect.f & 32) !== 0 && (effect.f & 1024) !== 0) return;
-	if ((effect.f & 2048) !== 0) tracked.d.push(effect);
-	else if ((effect.f & 4096) !== 0) tracked.m.push(effect);
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_branch(e, tracked);
-		e = e.next;
+function freeze_derived_effects(derived) {
+	if (derived.effects === null) return;
+	for (const e of derived.effects) if (e.teardown || e.ac) {
+		e.teardown?.();
+		if (e.ac !== null) without_reactive_context(() => {
+			/** @type {AbortController} */ e.ac.abort(STALE_REACTION);
+			e.ac = null;
+		});
+		if (e.fn !== null) e.teardown = noop;
+		remove_reactions(e, 0);
+		destroy_effect_children(e);
 	}
 }
 /**
-* Mark an entire effect tree clean following an error
-* @param {Effect} effect
+* @param {Derived} derived
 */
-function reset_all(effect) {
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_all(e);
-		e = e.next;
-	}
+function unfreeze_derived_effects(derived) {
+	if (derived.effects === null) return;
+	for (const e of derived.effects) if (e.teardown && e.fn !== null) update_effect(e);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/reactivity/create-subscriber.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/batch.js
+/** @import { Fork } from 'svelte' */
+/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
+var _Batch;
+/** @type {Batch | null} */
+var first_batch = null;
+/** @type {Batch | null} */
+var last_batch = null;
+/** @type {Batch | null} */
+var current_batch = null;
 /**
-* Returns a `subscribe` function that integrates external event-based systems with Svelte's reactivity.
-* It's particularly useful for integrating with web APIs like `MediaQuery`, `IntersectionObserver`, or `WebSocket`.
-*
-* If `subscribe` is called inside an effect (including indirectly, for example inside a getter),
-* the `start` callback will be called with an `update` function. Whenever `update` is called, the effect re-runs.
-*
-* If `start` returns a cleanup function, it will be called when the effect is destroyed.
-*
-* If `subscribe` is called in multiple effects, `start` will only be called once as long as the effects
-* are active, and the returned teardown function will only be called when all effects are destroyed.
-*
-* It's best understood with an example. Here's an implementation of [`MediaQuery`](https://svelte.dev/docs/svelte/svelte-reactivity#MediaQuery):
-*
-* ```js
-* import { createSubscriber } from 'svelte/reactivity';
-* import { on } from 'svelte/events';
-*
-* export class MediaQuery {
-* 	#query;
-* 	#subscribe;
-*
-* 	constructor(query) {
-* 		this.#query = window.matchMedia(`(${query})`);
-*
-* 		this.#subscribe = createSubscriber((update) => {
-* 			// when the `change` event occurs, re-run any effects that read `this.current`
-* 			const off = on(this.#query, 'change', update);
-*
-* 			// stop listening when all the effects are destroyed
-* 			return () => off();
-* 		});
-* 	}
-*
-* 	get current() {
-* 		// This makes the getter reactive, if read in an effect
-* 		this.#subscribe();
-*
-* 		// Return the current state of the query, whether or not we're in an effect
-* 		return this.#query.matches;
-* 	}
-* }
-* ```
-* @param {(update: () => void) => (() => void) | void} start
-* @since 5.7.0
+* This is needed to avoid overwriting inputs
+* @type {Batch | null}
 */
-function createSubscriber(start) {
-	let subscribers = 0;
-	let version = source(0);
-	/** @type {(() => void) | void} */
-	let stop;
-	return () => {
-		if (effect_tracking()) {
-			get(version);
-			render_effect(() => {
-				if (subscribers === 0) stop = untrack(() => start(() => increment(version)));
-				subscribers += 1;
-				return () => {
-					queue_micro_task(() => {
-						subscribers -= 1;
-						if (subscribers === 0) {
-							stop?.();
-							stop = void 0;
-							increment(version);
-						}
-					});
-				};
-			});
-		}
-	};
-}
-//#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/blocks/boundary.js
-/** @import { Effect, Source, TemplateNode, } from '#client' */
+var previous_batch = null;
 /**
-* @typedef {{
-* 	 onerror?: ((error: unknown, reset: () => void) => void) | null;
-*   failed?: ((anchor: Node, error: () => unknown, reset: () => () => void) => void) | null;
-*   pending?: ((anchor: Node) => void) | null;
-* }} BoundaryProps
+* When time travelling (i.e. working in one batch, while other batches
+* still have ongoing work), we ignore the real values of affected
+* signals in favour of their values within the batch
+* @type {Map<Value, any> | null}
 */
-var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
+var batch_values = null;
+/** @type {Effect | null} */
+var last_scheduled_effect = null;
+var is_flushing_sync = false;
+var is_processing = false;
 /**
-* @param {TemplateNode} node
-* @param {BoundaryProps} props
-* @param {((anchor: Node) => void)} children
-* @param {((error: unknown) => unknown) | undefined} [transform_error]
-* @returns {void}
+* During traversal, this is an array. Newly created effects are (if not immediately
+* executed) pushed to this array, rather than going through the scheduling
+* rigamarole that would cause another turn of the flush loop.
+* @type {Effect[] | null}
 */
-function boundary(node, props, children, transform_error) {
-	new Boundary(node, props, children, transform_error);
-}
-var _anchor = /* @__PURE__ */ new WeakMap();
-var _hydrate_open = /* @__PURE__ */ new WeakMap();
-var _props = /* @__PURE__ */ new WeakMap();
-var _children = /* @__PURE__ */ new WeakMap();
-var _effect = /* @__PURE__ */ new WeakMap();
-var _main_effect = /* @__PURE__ */ new WeakMap();
-var _pending_effect = /* @__PURE__ */ new WeakMap();
-var _failed_effect = /* @__PURE__ */ new WeakMap();
-var _offscreen_fragment = /* @__PURE__ */ new WeakMap();
-var _local_pending_count = /* @__PURE__ */ new WeakMap();
-var _pending_count = /* @__PURE__ */ new WeakMap();
-var _pending_count_update_queued = /* @__PURE__ */ new WeakMap();
+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 _started = /* @__PURE__ */ new WeakMap();
+var _prev = /* @__PURE__ */ new WeakMap();
+var _next = /* @__PURE__ */ new WeakMap();
+var _commit_callbacks = /* @__PURE__ */ new WeakMap();
+var _discard_callbacks = /* @__PURE__ */ new WeakMap();
+var _pending = /* @__PURE__ */ new WeakMap();
+var _blocking_pending = /* @__PURE__ */ new WeakMap();
+var _deferred = /* @__PURE__ */ new WeakMap();
+var _roots = /* @__PURE__ */ new WeakMap();
+var _new_effects = /* @__PURE__ */ new WeakMap();
 var _dirty_effects = /* @__PURE__ */ new WeakMap();
 var _maybe_dirty_effects = /* @__PURE__ */ new WeakMap();
-var _effect_pending = /* @__PURE__ */ new WeakMap();
-var _effect_pending_subscriber = /* @__PURE__ */ new WeakMap();
-var _Boundary_brand = /* @__PURE__ */ new WeakSet();
-var Boundary = class {
-	/**
-	* @param {TemplateNode} node
-	* @param {BoundaryProps} props
-	* @param {((anchor: Node) => void)} children
-	* @param {((error: unknown) => unknown) | undefined} [transform_error]
-	*/
-	constructor(node, props, children, transform_error) {
-		_classPrivateMethodInitSpec(this, _Boundary_brand);
+var _skipped_branches = /* @__PURE__ */ new WeakMap();
+var _unskipped_branches = /* @__PURE__ */ new WeakMap();
+var _decrement_queued = /* @__PURE__ */ new WeakMap();
+var _Batch_brand = /* @__PURE__ */ new WeakSet();
+var Batch = class Batch {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _Batch_brand);
+		_defineProperty(this, "id", uid++);
+		_classPrivateFieldInitSpec(this, _started, false);
+		_defineProperty(this, "linked", true);
+		_classPrivateFieldInitSpec(this, _prev, null);
+		_classPrivateFieldInitSpec(this, _next, null);
 		_defineProperty(
 			this,
-			/** @type {Boundary | null} */
-			"parent",
-			void 0
+			/** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
+			"async_deriveds",
+			/* @__PURE__ */ new Map()
 		);
-		_defineProperty(this, "is_pending", false);
 		_defineProperty(
 			this,
 			/**
-			* 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]>}
 			*/
-			"transform_error",
-			void 0
+			"current",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* 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()
 		);
-		_classPrivateFieldInitSpec(this, _anchor, void 0);
-		_classPrivateFieldInitSpec(this, _hydrate_open, hydrating ? hydrate_node : null);
-		_classPrivateFieldInitSpec(this, _props, void 0);
-		_classPrivateFieldInitSpec(this, _children, void 0);
-		_classPrivateFieldInitSpec(this, _effect, void 0);
-		_classPrivateFieldInitSpec(this, _main_effect, null);
-		_classPrivateFieldInitSpec(this, _pending_effect, null);
-		_classPrivateFieldInitSpec(this, _failed_effect, null);
-		_classPrivateFieldInitSpec(this, _offscreen_fragment, null);
-		_classPrivateFieldInitSpec(this, _local_pending_count, 0);
-		_classPrivateFieldInitSpec(this, _pending_count, 0);
-		_classPrivateFieldInitSpec(this, _pending_count_update_queued, false);
+		_classPrivateFieldInitSpec(this, _commit_callbacks, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _discard_callbacks, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _pending, 0);
+		_classPrivateFieldInitSpec(this, _blocking_pending, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _deferred, null);
+		_classPrivateFieldInitSpec(this, _roots, []);
+		_classPrivateFieldInitSpec(this, _new_effects, []);
 		_classPrivateFieldInitSpec(this, _dirty_effects, /* @__PURE__ */ new Set());
 		_classPrivateFieldInitSpec(this, _maybe_dirty_effects, /* @__PURE__ */ new Set());
-		_classPrivateFieldInitSpec(this, _effect_pending, null);
-		_classPrivateFieldInitSpec(this, _effect_pending_subscriber, createSubscriber(() => {
-			_classPrivateFieldSet2(_effect_pending, this, source(_classPrivateFieldGet2(_local_pending_count, this)));
-			return () => {
-				_classPrivateFieldSet2(_effect_pending, this, null);
-			};
-		}));
-		_classPrivateFieldSet2(_anchor, this, node);
-		_classPrivateFieldSet2(_props, this, props);
-		_classPrivateFieldSet2(_children, this, (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);
-		_classPrivateFieldSet2(_effect, this, block(() => {
-			if (hydrating) {
-				const comment = _classPrivateFieldGet2(_hydrate_open, this);
-				hydrate_next();
-				const server_rendered_pending = comment.data === "[!";
-				if (comment.data.startsWith("[?")) {
-					const serialized_error = JSON.parse(comment.data.slice(2));
-					_assertClassBrand(_Boundary_brand, this, _hydrate_failed_content).call(this, serialized_error);
-				} else if (server_rendered_pending) _assertClassBrand(_Boundary_brand, this, _hydrate_pending_content).call(this);
-				else _assertClassBrand(_Boundary_brand, this, _hydrate_resolved_content).call(this);
-			} else _assertClassBrand(_Boundary_brand, this, _render).call(this);
-		}, flags));
-		if (hydrating) _classPrivateFieldSet2(_anchor, this, hydrate_node);
+		_classPrivateFieldInitSpec(this, _skipped_branches, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _unskipped_branches, /* @__PURE__ */ new Set());
+		_defineProperty(this, "is_fork", false);
+		_classPrivateFieldInitSpec(this, _decrement_queued, false);
+		if (last_batch === null) first_batch = last_batch = this;
+		else {
+			_classPrivateFieldSet2(_next, last_batch, this);
+			_classPrivateFieldSet2(_prev, this, last_batch);
+		}
+		last_batch = this;
 	}
 	/**
-	* Defer an effect inside a pending boundary until the boundary resolves
+	* Add an effect to the #skipped_branches map and reset its children
 	* @param {Effect} effect
 	*/
-	defer_effect(effect) {
-		defer_effect(effect, _classPrivateFieldGet2(_dirty_effects, this), _classPrivateFieldGet2(_maybe_dirty_effects, this));
+	skip_effect(effect) {
+		if (!_classPrivateFieldGet2(_skipped_branches, this).has(effect)) _classPrivateFieldGet2(_skipped_branches, this).set(effect, {
+			d: [],
+			m: []
+		});
+		_classPrivateFieldGet2(_unskipped_branches, this).delete(effect);
 	}
 	/**
-	* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
-	* @returns {boolean}
+	* 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
 	*/
-	is_rendered() {
-		return !this.is_pending && (!this.parent || this.parent.is_rendered());
-	}
-	has_pending_snippet() {
-		return !!_classPrivateFieldGet2(_props, this).pending;
+	unskip_effect(effect, callback = (e) => this.schedule(e)) {
+		var tracked = _classPrivateFieldGet2(_skipped_branches, this).get(effect);
+		if (tracked) {
+			_classPrivateFieldGet2(_skipped_branches, this).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);
+			}
+		}
+		_classPrivateFieldGet2(_unskipped_branches, this).add(effect);
 	}
 	/**
-	* Update the source that powers `$effect.pending()` inside this boundary,
-	* and controls when the current `pending` snippet (if any) is removed.
-	* Do not call from inside the class
-	* @param {1 | -1} d
-	* @param {Batch} batch
+	* 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]
 	*/
-	update_pending_count(d, batch) {
-		_assertClassBrand(_Boundary_brand, this, _update_pending_count).call(this, d, batch);
-		_classPrivateFieldSet2(_local_pending_count, this, _classPrivateFieldGet2(_local_pending_count, this) + d);
-		if (!_classPrivateFieldGet2(_effect_pending, this) || _classPrivateFieldGet2(_pending_count_update_queued, this)) return;
-		_classPrivateFieldSet2(_pending_count_update_queued, this, true);
-		queue_micro_task(() => {
-			_classPrivateFieldSet2(_pending_count_update_queued, this, false);
-			if (_classPrivateFieldGet2(_effect_pending, this)) internal_set(_classPrivateFieldGet2(_effect_pending, this), _classPrivateFieldGet2(_local_pending_count, this));
-		});
-	}
-	get_effect_pending() {
-		_classPrivateFieldGet2(_effect_pending_subscriber, this).call(this);
-		return get(_classPrivateFieldGet2(_effect_pending, this));
+	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;
 	}
-	/** @param {unknown} error */
-	error(error) {
-		if (!_classPrivateFieldGet2(_props, this).onerror && !_classPrivateFieldGet2(_props, this).failed) throw error;
-		if (current_batch?.is_fork) {
-			if (_classPrivateFieldGet2(_main_effect, this)) current_batch.skip_effect(_classPrivateFieldGet2(_main_effect, this));
-			if (_classPrivateFieldGet2(_pending_effect, this)) current_batch.skip_effect(_classPrivateFieldGet2(_pending_effect, this));
-			if (_classPrivateFieldGet2(_failed_effect, this)) current_batch.skip_effect(_classPrivateFieldGet2(_failed_effect, this));
-			current_batch.oncommit(() => {
-				_assertClassBrand(_Boundary_brand, this, _handle_error).call(this, error);
-			});
-		} else _assertClassBrand(_Boundary_brand, this, _handle_error).call(this, error);
+	activate() {
+		current_batch = this;
 	}
-};
-function _hydrate_resolved_content() {
-	try {
-		_classPrivateFieldSet2(_main_effect, this, branch(() => _classPrivateFieldGet2(_children, this).call(this, _classPrivateFieldGet2(_anchor, this))));
-	} catch (error) {
-		this.error(error);
+	deactivate() {
+		current_batch = null;
+		batch_values = null;
 	}
-}
-/**
-* @param {unknown} error The deserialized error from the server's hydration comment
-*/
-function _hydrate_failed_content(error) {
-	const failed = _classPrivateFieldGet2(_props, this).failed;
-	if (!failed) return;
-	_classPrivateFieldSet2(_failed_effect, this, branch(() => {
-		failed(_classPrivateFieldGet2(_anchor, this), () => error, () => () => {});
-	}));
-}
-function _hydrate_pending_content() {
-	const pending = _classPrivateFieldGet2(_props, this).pending;
-	if (!pending) return;
-	this.is_pending = true;
-	_classPrivateFieldSet2(_pending_effect, this, branch(() => pending(_classPrivateFieldGet2(_anchor, this))));
-	queue_micro_task(() => {
-		var fragment = _classPrivateFieldSet2(_offscreen_fragment, this, document.createDocumentFragment());
-		var anchor = create_text();
-		fragment.append(anchor);
-		_classPrivateFieldSet2(_main_effect, this, _assertClassBrand(_Boundary_brand, this, _run).call(this, () => {
-			return branch(() => _classPrivateFieldGet2(_children, this).call(this, anchor));
-		}));
-		if (_classPrivateFieldGet2(_pending_count, this) === 0) {
-			_classPrivateFieldGet2(_anchor, this).before(fragment);
-			_classPrivateFieldSet2(_offscreen_fragment, this, null);
-			pause_effect(_classPrivateFieldGet2(_pending_effect, this), () => {
-				_classPrivateFieldSet2(_pending_effect, this, null);
-			});
-			_assertClassBrand(_Boundary_brand, this, _resolve).call(this, current_batch);
+	flush() {
+		try {
+			is_processing = true;
+			current_batch = this;
+			_assertClassBrand(_Batch_brand, this, _process).call(this);
+		} 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();
 		}
-	});
-}
-function _render() {
-	try {
-		this.is_pending = this.has_pending_snippet();
-		_classPrivateFieldSet2(_pending_count, this, 0);
-		_classPrivateFieldSet2(_local_pending_count, this, 0);
-		_classPrivateFieldSet2(_main_effect, this, branch(() => {
-			_classPrivateFieldGet2(_children, this).call(this, _classPrivateFieldGet2(_anchor, this));
-		}));
-		if (_classPrivateFieldGet2(_pending_count, this) > 0) {
-			var fragment = _classPrivateFieldSet2(_offscreen_fragment, this, document.createDocumentFragment());
-			move_effect(_classPrivateFieldGet2(_main_effect, this), fragment);
-			const pending = _classPrivateFieldGet2(_props, this).pending;
-			_classPrivateFieldSet2(_pending_effect, this, branch(() => pending(_classPrivateFieldGet2(_anchor, this))));
-		} else _assertClassBrand(_Boundary_brand, this, _resolve).call(this, current_batch);
-	} catch (error) {
-		this.error(error);
 	}
-}
-/**
-* @param {Batch} batch
-*/
-function _resolve(batch) {
-	this.is_pending = false;
-	batch.transfer_effects(_classPrivateFieldGet2(_dirty_effects, this), _classPrivateFieldGet2(_maybe_dirty_effects, this));
-}
-/**
-* @template T
-* @param {() => T} fn
-*/
-function _run(fn) {
-	var previous_effect = active_effect;
-	var previous_reaction = active_reaction;
-	var previous_ctx = component_context;
-	set_active_effect(_classPrivateFieldGet2(_effect, this));
-	set_active_reaction(_classPrivateFieldGet2(_effect, this));
-	set_component_context(_classPrivateFieldGet2(_effect, this).ctx);
-	try {
-		Batch.ensure();
-		return fn();
-	} catch (e) {
-		handle_error(e);
-		return null;
-	} finally {
-		set_active_effect(previous_effect);
-		set_active_reaction(previous_reaction);
-		set_component_context(previous_ctx);
+	discard() {
+		for (const fn of _classPrivateFieldGet2(_discard_callbacks, this)) fn(this);
+		_classPrivateFieldGet2(_discard_callbacks, this).clear();
+		for (const deferred of this.async_deriveds.values()) deferred.reject(OBSOLETE);
+		_assertClassBrand(_Batch_brand, this, _unlink).call(this);
+		_classPrivateFieldGet2(_deferred, this)?.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
-*/
-function _update_pending_count(d, batch) {
-	if (!this.has_pending_snippet()) {
-		if (this.parent) {
-			var _this$parent;
-			_assertClassBrand(_Boundary_brand, _this$parent = this.parent, _update_pending_count).call(_this$parent, d, batch);
+	/**
+	* @param {Effect} effect
+	*/
+	register_created_effect(effect) {
+		_classPrivateFieldGet2(_new_effects, this).push(effect);
+	}
+	/**
+	* @param {boolean} blocking
+	* @param {Effect} effect
+	*/
+	increment(blocking, effect) {
+		_classPrivateFieldSet2(_pending, this, _classPrivateFieldGet2(_pending, this) + 1);
+		if (blocking) {
+			let blocking_pending_count = _classPrivateFieldGet2(_blocking_pending, this).get(effect) ?? 0;
+			_classPrivateFieldGet2(_blocking_pending, this).set(effect, blocking_pending_count + 1);
 		}
-		return;
 	}
-	_classPrivateFieldSet2(_pending_count, this, _classPrivateFieldGet2(_pending_count, this) + d);
-	if (_classPrivateFieldGet2(_pending_count, this) === 0) {
-		_assertClassBrand(_Boundary_brand, this, _resolve).call(this, batch);
-		if (_classPrivateFieldGet2(_pending_effect, this)) pause_effect(_classPrivateFieldGet2(_pending_effect, this), () => {
-			_classPrivateFieldSet2(_pending_effect, this, null);
-		});
-		if (_classPrivateFieldGet2(_offscreen_fragment, this)) {
-			_classPrivateFieldGet2(_anchor, this).before(_classPrivateFieldGet2(_offscreen_fragment, this));
-			_classPrivateFieldSet2(_offscreen_fragment, this, null);
+	/**
+	* @param {boolean} blocking
+	* @param {Effect} effect
+	*/
+	decrement(blocking, effect) {
+		_classPrivateFieldSet2(_pending, this, _classPrivateFieldGet2(_pending, this) - 1);
+		if (blocking) {
+			let blocking_pending_count = _classPrivateFieldGet2(_blocking_pending, this).get(effect) ?? 0;
+			if (blocking_pending_count === 1) _classPrivateFieldGet2(_blocking_pending, this).delete(effect);
+			else _classPrivateFieldGet2(_blocking_pending, this).set(effect, blocking_pending_count - 1);
 		}
+		if (_classPrivateFieldGet2(_decrement_queued, this)) return;
+		_classPrivateFieldSet2(_decrement_queued, this, true);
+		queue_micro_task(() => {
+			_classPrivateFieldSet2(_decrement_queued, this, false);
+			if (this.linked) this.flush();
+		});
 	}
-}
-/**
-* @param {unknown} error
-*/
-function _handle_error(error) {
-	if (_classPrivateFieldGet2(_main_effect, this)) {
-		destroy_effect(_classPrivateFieldGet2(_main_effect, this));
-		_classPrivateFieldSet2(_main_effect, this, null);
+	/**
+	* @param {Set<Effect>} dirty_effects
+	* @param {Set<Effect>} maybe_dirty_effects
+	*/
+	transfer_effects(dirty_effects, maybe_dirty_effects) {
+		for (const e of dirty_effects) _classPrivateFieldGet2(_dirty_effects, this).add(e);
+		for (const e of maybe_dirty_effects) _classPrivateFieldGet2(_maybe_dirty_effects, this).add(e);
+		dirty_effects.clear();
+		maybe_dirty_effects.clear();
 	}
-	if (_classPrivateFieldGet2(_pending_effect, this)) {
-		destroy_effect(_classPrivateFieldGet2(_pending_effect, this));
-		_classPrivateFieldSet2(_pending_effect, this, null);
+	/** @param {(batch: Batch) => void} fn */
+	oncommit(fn) {
+		_classPrivateFieldGet2(_commit_callbacks, this).add(fn);
 	}
-	if (_classPrivateFieldGet2(_failed_effect, this)) {
-		destroy_effect(_classPrivateFieldGet2(_failed_effect, this));
-		_classPrivateFieldSet2(_failed_effect, this, null);
+	/** @param {(batch: Batch) => void} fn */
+	ondiscard(fn) {
+		_classPrivateFieldGet2(_discard_callbacks, this).add(fn);
 	}
-	if (hydrating) {
-		set_hydrate_node(_classPrivateFieldGet2(_hydrate_open, this));
-		next();
-		set_hydrate_node(skip_nodes());
+	settled() {
+		return (_classPrivateFieldGet2(_deferred, this) ?? _classPrivateFieldSet2(_deferred, this, deferred())).promise;
 	}
-	var onerror = _classPrivateFieldGet2(_props, this).onerror;
-	let failed = _classPrivateFieldGet2(_props, this).failed;
-	var did_reset = false;
-	var calling_on_error = false;
-	const reset = () => {
-		if (did_reset) {
-			svelte_boundary_reset_noop();
-			return;
+	static ensure() {
+		if (current_batch === null) {
+			const batch = current_batch = new Batch();
+			if (!is_processing && !is_flushing_sync) queue_micro_task(() => {
+				if (!_classPrivateFieldGet2(_started, batch)) batch.flush();
+			});
 		}
-		did_reset = true;
-		if (calling_on_error) svelte_boundary_reset_onerror();
-		if (_classPrivateFieldGet2(_failed_effect, this) !== null) pause_effect(_classPrivateFieldGet2(_failed_effect, this), () => {
-			_classPrivateFieldSet2(_failed_effect, this, null);
-		});
-		_assertClassBrand(_Boundary_brand, this, _run).call(this, () => {
-			_assertClassBrand(_Boundary_brand, this, _render).call(this);
-		});
-	};
-	/** @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, _classPrivateFieldGet2(_effect, this) && _classPrivateFieldGet2(_effect, this).parent);
+		return current_batch;
+	}
+	apply() {
+		if (!async_mode_flag || !this.is_fork && _classPrivateFieldGet2(_prev, this) === null && _classPrivateFieldGet2(_next, this) === null) {
+			batch_values = null;
+			return;
 		}
-		if (failed) _classPrivateFieldSet2(_failed_effect, this, _assertClassBrand(_Boundary_brand, this, _run).call(this, () => {
-			try {
-				return branch(() => {
-					var effect = active_effect;
-					effect.b = this;
-					effect.f |= 128;
-					failed(_classPrivateFieldGet2(_anchor, this), () => transformed_error, () => reset);
-				});
-			} catch (error) {
-				invoke_error_boundary(error, _classPrivateFieldGet2(_effect, this).parent);
-				return null;
+		batch_values = /* @__PURE__ */ new Map();
+		for (const [source, [value]] of this.current) batch_values.set(source, value);
+		for (let batch = first_batch; batch !== null; batch = _classPrivateFieldGet2(_next, batch)) {
+			if (batch === this || batch.is_fork) continue;
+			var intersects = false;
+			if (batch.id < this.id) for (const [source, [, is_derived]] of batch.current) {
+				if (is_derived) continue;
+				if (this.current.has(source)) {
+					intersects = true;
+					break;
+				}
 			}
-		}));
-	};
-	queue_micro_task(() => {
-		/** @type {unknown} */
-		var result;
-		try {
-			result = this.transform_error(error);
-		} catch (e) {
-			invoke_error_boundary(e, _classPrivateFieldGet2(_effect, this) && _classPrivateFieldGet2(_effect, this).parent);
+			if (!intersects) {
+				for (const [source, previous] of batch.previous) if (!batch_values.has(source)) batch_values.set(source, previous);
+			}
+		}
+	}
+	/**
+	*
+	* @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;
 		}
-		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, _classPrivateFieldGet2(_effect, this) && _classPrivateFieldGet2(_effect, this).parent)
-		);
-		else handle_error_result(result);
-	});
+		var e = effect;
+		while (e.parent !== null) {
+			e = e.parent;
+			var flags = e.f;
+			if (collected_effects !== null && e === active_effect) {
+				if (async_mode_flag) return;
+				if ((active_reaction === null || (active_reaction.f & 2) === 0) && !legacy_is_updating_store) return;
+			}
+			if ((flags & 96) !== 0) {
+				if ((flags & 1024) === 0) return;
+				e.f ^= CLEAN;
+			}
+		}
+		_classPrivateFieldGet2(_roots, this).push(e);
+	}
+};
+_Batch = Batch;
+function _is_deferred() {
+	if (this.is_fork) return true;
+	for (const effect of _classPrivateFieldGet2(_blocking_pending, this).keys()) {
+		var e = effect;
+		var skipped = false;
+		while (e.parent !== null) {
+			if (_classPrivateFieldGet2(_skipped_branches, this).has(e)) {
+				skipped = true;
+				break;
+			}
+			e = e.parent;
+		}
+		if (!skipped) return true;
+	}
+	return false;
 }
-//#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/async.js
-/** @import { Blocker, Effect, Source, Value } from '#client' */
-/**
-* @param {Blocker[]} blockers
-* @param {Array<() => any>} sync
-* @param {Array<() => Promise<any>>} async
-* @param {(values: Value[]) => any} fn
-*/
-function flatten(blockers, sync, async, fn) {
-	const d = is_runes() ? derived : derived_safe_equal;
-	var pending = blockers.filter((b) => !b.settled);
-	var deriveds = sync.map(d);
-	if (async.length === 0 && pending.length === 0) {
-		fn(deriveds);
-		return;
+function _process() {
+	_classPrivateFieldSet2(_started, this, true);
+	if (flush_count++ > 1e3) {
+		_assertClassBrand(_Batch_brand, this, _unlink).call(this);
+		infinite_loop_guard();
 	}
-	var parent = active_effect;
-	var restore = capture();
-	var blocker_promise = pending.length === 1 ? pending[0].promise : pending.length > 1 ? Promise.all(pending.map((b) => b.promise)) : null;
+	for (const e of _classPrivateFieldGet2(_dirty_effects, this)) {
+		_classPrivateFieldGet2(_maybe_dirty_effects, this).delete(e);
+		set_signal_status(e, DIRTY);
+		this.schedule(e);
+	}
+	for (const e of _classPrivateFieldGet2(_maybe_dirty_effects, this)) {
+		set_signal_status(e, MAYBE_DIRTY);
+		this.schedule(e);
+	}
+	const roots = _classPrivateFieldGet2(_roots, this);
+	_classPrivateFieldSet2(_roots, this, []);
+	this.apply();
+	/** @type {Effect[]} */
+	var effects = collected_effects = [];
+	/** @type {Effect[]} */
+	var render_effects = [];
 	/**
-	* @param {Source[]} async
+	* @type {Effect[]}
+	* @deprecated when we get rid of legacy mode and stores, we can get rid of this
 	*/
-	function finish(async) {
-		if ((parent.f & 16384) !== 0) return;
-		restore();
-		try {
-			fn([...deriveds, ...async]);
-		} catch (error) {
-			invoke_error_boundary(error, parent);
-		}
-		unset_context();
+	var updates = legacy_updates = [];
+	for (const root of roots) try {
+		_assertClassBrand(_Batch_brand, this, _traverse).call(this, root, effects, render_effects);
+	} catch (e) {
+		reset_all(root);
+		if (!_assertClassBrand(_Batch_brand, this, _is_deferred).call(this)) 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 (_assertClassBrand(_Batch_brand, this, _is_deferred).call(this)) {
+		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, render_effects);
+		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, effects);
+		for (const [e, t] of _classPrivateFieldGet2(_skipped_branches, this)) reset_branch(e, t);
+		if (updates.length > 0)
+ /** @type {Batch} */ _assertClassBrand(_Batch_brand, current_batch, _process).call(current_batch);
+		return;
 	}
-	var decrement_pending = increment_pending();
-	if (async.length === 0) {
-		/** @type {Promise<any>} */ blocker_promise.then(() => finish([])).finally(decrement_pending);
+	const earlier_batch = _assertClassBrand(_Batch_brand, this, _find_earlier_batch).call(this);
+	if (earlier_batch) {
+		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, render_effects);
+		_assertClassBrand(_Batch_brand, this, _defer_effects).call(this, effects);
+		_assertClassBrand(_Batch_brand, earlier_batch, _merge).call(earlier_batch, this);
 		return;
 	}
-	function run() {
-		Promise.all(async.map((expression) => /* @__PURE__ */ async_derived(expression))).then(finish).catch((error) => invoke_error_boundary(error, parent)).finally(decrement_pending);
+	_classPrivateFieldGet2(_dirty_effects, this).clear();
+	_classPrivateFieldGet2(_maybe_dirty_effects, this).clear();
+	for (const fn of _classPrivateFieldGet2(_commit_callbacks, this)) fn(this);
+	_classPrivateFieldGet2(_commit_callbacks, this).clear();
+	previous_batch = this;
+	flush_queued_effects(render_effects);
+	flush_queued_effects(effects);
+	previous_batch = null;
+	_classPrivateFieldGet2(_deferred, this)?.resolve();
+	var next_batch = current_batch;
+	if (_classPrivateFieldGet2(_pending, this) === 0 && (_classPrivateFieldGet2(_roots, this).length === 0 || next_batch !== null)) {
+		_assertClassBrand(_Batch_brand, this, _unlink).call(this);
+		if (async_mode_flag) {
+			_assertClassBrand(_Batch_brand, this, _commit$1).call(this);
+			current_batch = next_batch;
+		}
 	}
-	if (blocker_promise) blocker_promise.then(() => {
-		restore();
-		run();
-		unset_context();
-	});
-	else run();
+	if (_classPrivateFieldGet2(_roots, this).length > 0) if (next_batch !== null) {
+		const batch = next_batch;
+		_classPrivateFieldGet2(_roots, batch).push(..._classPrivateFieldGet2(_roots, this).filter((r) => !_classPrivateFieldGet2(_roots, batch).includes(r)));
+	} else next_batch = this;
+	if (next_batch !== null) _assertClassBrand(_Batch_brand, next_batch, _process).call(next_batch);
 }
 /**
-* Captures the current effect context so that we can restore it after
-* some asynchronous work has happened (so that e.g. `await a + b`
-* causes `b` to be registered as a dependency).
+* Traverse the effect tree, executing effects or stashing
+* them for later execution as appropriate
+* @param {Effect} root
+* @param {Effect[]} effects
+* @param {Effect[]} render_effects
 */
-function capture() {
-	var previous_effect = active_effect;
-	var previous_reaction = active_reaction;
-	var previous_component_context = component_context;
-	var previous_batch = current_batch;
-	return function restore(activate_batch = true) {
-		set_active_effect(previous_effect);
-		set_active_reaction(previous_reaction);
-		set_component_context(previous_component_context);
-		if (activate_batch && (previous_effect.f & 16384) === 0) {
-			previous_batch?.activate();
-			previous_batch?.apply();
+function _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 || _classPrivateFieldGet2(_skipped_branches, this).has(effect)) && effect.fn !== null) {
+			if (is_branch) effect.f ^= CLEAN;
+			else if ((flags & 4) !== 0) effects.push(effect);
+			else if (async_mode_flag && (flags & 16777224) !== 0) render_effects.push(effect);
+			else if (is_dirty(effect)) {
+				if ((flags & 16) !== 0) _classPrivateFieldGet2(_maybe_dirty_effects, this).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;
+		}
+	}
 }
-function unset_context(deactivate_batch = true) {
-	set_active_effect(null);
-	set_active_reaction(null);
-	set_component_context(null);
-	if (deactivate_batch) current_batch?.deactivate();
+function _find_earlier_batch() {
+	var batch = _classPrivateFieldGet2(_prev, this);
+	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 = _classPrivateFieldGet2(_prev, batch);
+	}
+	return null;
 }
 /**
-* @returns {(skip?: boolean) => void}
+* @param {Batch} batch
 */
-function increment_pending() {
-	var effect = active_effect;
-	var boundary = effect.b;
-	var batch = current_batch;
-	var blocking = !!boundary?.is_rendered();
-	boundary?.update_pending_count(1, batch);
-	batch.increment(blocking, effect);
-	return () => {
-		boundary?.update_pending_count(-1, batch);
-		batch.decrement(blocking, effect);
+function _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(_classPrivateFieldGet2(_dirty_effects, batch), _classPrivateFieldGet2(_maybe_dirty_effects, batch));
+	/**
+	* 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;
+		if ((value.f & 2) !== 0 && (value.f & 6144) === 0) 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)) {
+					_classPrivateFieldGet2(_maybe_dirty_effects, this).delete(effect);
+					set_signal_status(effect, DIRTY);
+					this.schedule(effect);
+				}
+			}
+		}
 	};
+	for (const source of this.current.keys()) mark(source);
+	this.oncommit(() => batch.discard());
+	_assertClassBrand(_Batch_brand, batch, _unlink).call(batch);
+	current_batch = this;
+	_assertClassBrand(_Batch_brand, this, _process).call(this);
 }
 /**
-* @template V
-* @param {() => V} fn
-* @returns {Derived<V>}
+* @param {Effect[]} effects
 */
-/*#__NO_SIDE_EFFECTS__*/
-function derived(fn) {
-	var flags = 2 | DIRTY;
-	if (active_effect !== null) active_effect.f |= EFFECT_PRESERVED;
-	return {
-		ctx: component_context,
-		deps: null,
-		effects: null,
-		equals,
-		f: flags,
-		fn,
-		reactions: null,
-		rv: 0,
-		v: UNINITIALIZED,
-		wv: 0,
-		parent: active_effect,
-		ac: null
-	};
+function _defer_effects(effects) {
+	for (var i = 0; i < effects.length; i += 1) defer_effect(effects[i], _classPrivateFieldGet2(_dirty_effects, this), _classPrivateFieldGet2(_maybe_dirty_effects, this));
 }
-var OBSOLETE = Symbol("obsolete");
-/**
-* @template V
-* @param {() => V | Promise<V>} fn
-* @param {string} [label]
-* @param {string} [location] If provided, print a warning if the value is not read immediately after update
-* @returns {Promise<Source<V>>}
-*/
-/*#__NO_SIDE_EFFECTS__*/
-function async_derived(fn, label, location) {
-	let parent = active_effect;
-	if (parent === null) async_derived_orphan();
-	var promise = void 0;
-	var signal = source(UNINITIALIZED);
-	var should_suspend = !active_reaction;
-	/** @type {Set<ReturnType<typeof deferred<V>>>} */
-	var deferreds = /* @__PURE__ */ new Set();
-	async_effect(() => {
-		var effect = active_effect;
-		/** @type {ReturnType<typeof deferred<V>>} */
-		var d = deferred();
-		promise = d.promise;
-		try {
-			Promise.resolve(fn()).then(d.resolve, (e) => {
-				if (e !== STALE_REACTION) d.reject(e);
-			}).finally(unset_context);
-		} catch (error) {
-			d.reject(error);
-			unset_context();
+function _commit$1() {
+	for (let batch = first_batch; batch !== null; batch = _classPrivateFieldGet2(_next, batch)) {
+		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);
 		}
-		var batch = current_batch;
-		if (should_suspend) {
-			if ((effect.f & 32768) !== 0) var decrement_pending = increment_pending();
-			if (parent.b?.is_rendered()) batch.async_deriveds.get(effect)?.reject(OBSOLETE);
-			else for (const d of deferreds.values()) d.reject(OBSOLETE);
-			deferreds.add(d);
-			batch.async_deriveds.set(effect, d);
+		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);
 		}
-		/**
-		* @param {any} value
-		* @param {unknown} error
-		*/
-		const handler = (value, error = void 0) => {
-			decrement_pending?.();
-			deferreds.delete(d);
-			if (error === OBSOLETE) return;
+		var current = [...batch.current.keys()].filter((source) => !batch.current.get(source)[1]);
+		if (!_classPrivateFieldGet2(_started, batch) || 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 _classPrivateFieldGet2(_unskipped_branches, this)) batch.unskip_effect(unskipped, (e) => {
+				if ((e.f & 4194320) !== 0) batch.schedule(e);
+				else _assertClassBrand(_Batch_brand, batch, _defer_effects).call(batch, [e]);
+			});
 			batch.activate();
-			if (error) {
-				signal.f |= ERROR_VALUE;
-				internal_set(signal, error);
-			} else {
-				if ((signal.f & 8388608) !== 0) signal.f ^= ERROR_VALUE;
-				internal_set(signal, value);
+			/** @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 _classPrivateFieldGet2(_new_effects, this)) 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 _classPrivateFieldGet2(_dirty_effects, batch).add(effect);
 			}
-			batch.deactivate();
-		};
-		d.promise.then(handler, (e) => handler(null, e || "unknown"));
-	});
-	teardown(() => {
-		for (const d of deferreds) d.reject(OBSOLETE);
-	});
-	return new Promise((fulfil) => {
-		/** @param {Promise<V>} p */
-		function next(p) {
-			function go() {
-				if (p === promise) fulfil(signal);
-				else next(promise);
+			if (_classPrivateFieldGet2(_roots, batch).length > 0 && !_classPrivateFieldGet2(_decrement_queued, batch)) {
+				batch.apply();
+				for (var root of _classPrivateFieldGet2(_roots, batch)) _assertClassBrand(_Batch_brand, batch, _traverse).call(batch, root, [], []);
+				_classPrivateFieldSet2(_roots, batch, []);
 			}
-			p.then(go, go);
+			batch.deactivate();
 		}
-		next(promise);
-	});
+	}
 }
-/**
-* @template V
-* @param {() => V} fn
-* @returns {Derived<V>}
-*/
-/*#__NO_SIDE_EFFECTS__*/
-function user_derived(fn) {
-	const d = /* @__PURE__ */ derived(fn);
-	if (!async_mode_flag) push_reaction_value(d);
-	return d;
+function _unlink() {
+	if (!this.linked) return;
+	var prev = _classPrivateFieldGet2(_prev, this);
+	var next = _classPrivateFieldGet2(_next, this);
+	if (prev === null) first_batch = next;
+	else _classPrivateFieldSet2(_next, prev, next);
+	if (next === null) last_batch = prev;
+	else _classPrivateFieldSet2(_prev, next, prev);
+	this.linked = false;
 }
 /**
-* @template V
-* @param {() => V} fn
-* @returns {Derived<V>}
+* 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}
 */
-/*#__NO_SIDE_EFFECTS__*/
-function derived_safe_equal(fn) {
-	const signal = /* @__PURE__ */ derived(fn);
-	signal.equals = safe_equals;
-	return signal;
+function flushSync(fn) {
+	var was_flushing_sync = is_flushing_sync;
+	is_flushing_sync = true;
+	try {
+		var result;
+		if (fn) {
+			if (current_batch !== null && !current_batch.is_fork) current_batch.flush();
+			result = fn();
+		}
+		while (true) {
+			flush_tasks();
+			if (current_batch === null) return result;
+			current_batch.flush();
+		}
+	} finally {
+		is_flushing_sync = was_flushing_sync;
+	}
+}
+function infinite_loop_guard() {
+	try {
+		effect_update_depth_exceeded();
+	} catch (error) {
+		invoke_error_boundary(error, last_scheduled_effect);
+	}
 }
+/** @type {Set<Effect> | null} */
+var eager_block_effects = null;
 /**
-* @param {Derived} derived
+* @param {Array<Effect>} effects
 * @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]);
+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();
+			}
+		}
 	}
+	eager_block_effects = null;
 }
 /**
-* @template T
-* @param {Derived} derived
-* @returns {T}
+* 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 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);
-	try {
-		derived.f &= ~WAS_MARKED;
-		destroy_derived_effects(derived);
-		value = update_reaction(derived);
-	} finally {
-		set_active_effect(prev_active_effect);
+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);
+		}
 	}
-	return value;
 }
 /**
-* @param {Derived} derived
-* @returns {void}
+* @param {Reaction} reaction
+* @param {Source[]} sources
+* @param {Map<Reaction, boolean>} checked
 */
-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 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;
 		}
 	}
-	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);
+	checked.set(reaction, false);
+	return false;
 }
 /**
-* @param {Derived} derived
+* @param {Effect} effect
+* @returns {void}
 */
-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 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;
 	}
 }
 /**
-* @param {Derived} derived
+* Mark an entire effect tree clean following an error
+* @param {Effect} effect
 */
-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 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/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/sources.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/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();
@@ -2309,19 +2351,8 @@ function proxy(value) {
 		}
 	});
 }
-new Set([
-	"copyWithin",
-	"fill",
-	"pop",
-	"push",
-	"reverse",
-	"shift",
-	"sort",
-	"splice",
-	"unshift"
-]);
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/operations.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/operations.js
 /** @import { Effect, TemplateNode } from '#client' */
 /** @type {Window} */
 var $window;
@@ -2499,25 +2530,7 @@ function merge_text_nodes(text) {
 	}
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/bindings/shared.js
-/**
-* @template T
-* @param {() => T} fn
-*/
-function without_reactive_context(fn) {
-	var previous_reaction = active_reaction;
-	var previous_effect = active_effect;
-	set_active_reaction(null);
-	set_active_effect(null);
-	try {
-		return fn();
-	} finally {
-		set_active_reaction(previous_reaction);
-		set_active_effect(previous_effect);
-	}
-}
-//#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/reactivity/effects.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/reactivity/effects.js
 /** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
 /**
 * @param {'$effect' | '$effect.pre' | '$inspect'} rune
@@ -2903,15 +2916,18 @@ function move_effect(effect, fragment) {
 	}
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/legacy.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/legacy.js
 /**
 * @type {Set<Value> | null}
 * @deprecated
 */
 var captured_signals = null;
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/runtime.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/runtime.js
 /** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
+/**
+* True if updating in an effect context that is reactive (i.e. not branch/root effects)
+*/
 var is_updating_effect = false;
 var is_destroying_effect = false;
 /** @param {boolean} value */
@@ -3112,6 +3128,11 @@ function remove_reaction(signal, dependency) {
 			derived.f &= ~WAS_MARKED;
 		}
 		if (derived.v !== UNINITIALIZED) update_derived_status(derived);
+		if (derived.ac !== null) without_reactive_context(() => {
+			/** @type {AbortController} */ derived.ac.abort(STALE_REACTION);
+			derived.ac = null;
+			set_signal_status(derived, DIRTY);
+		});
 		freeze_derived_effects(derived);
 		remove_reactions(derived, 0);
 	}
@@ -3137,7 +3158,7 @@ function update_effect(effect) {
 	var previous_effect = active_effect;
 	var was_updating_effect = is_updating_effect;
 	active_effect = effect;
-	is_updating_effect = true;
+	is_updating_effect = (flags & 96) === 0;
 	try {
 		if ((flags & 16777232) !== 0) destroy_block_effect_children(effect);
 		else destroy_effect_children(effect);
@@ -3266,7 +3287,7 @@ function untrack(fn) {
 	}
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/events.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/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
@@ -3406,7 +3427,7 @@ function handle_event_propagation(event) {
 	}
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/reconciler.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/reconciler.js
 var policy = globalThis?.window?.trustedTypes && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", { 
 /** @param {string} html */
 createHTML: (html) => {
@@ -3425,7 +3446,7 @@ function create_fragment_from_html(html) {
 	return elem.content;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/template.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/template.js
 /** @import { Effect, EffectNodes, TemplateNode } from '#client' */
 /** @import { TemplateStructure } from './types' */
 /**
@@ -3575,9 +3596,8 @@ function is_passive_event(name) {
 * @returns {void}
 */
 function set_text(text, value) {
-	var _text;
 	var str = value == null ? "" : typeof value === "object" ? `${value}` : value;
-	if (str !== ((_text = text)[TEXT_CACHE] ?? (_text[TEXT_CACHE] = text.nodeValue))) {
+	if (str !== (text[TEXT_CACHE] ?? (text[TEXT_CACHE] = text.nodeValue))) {
 		/** @type {any} */ text[TEXT_CACHE] = str;
 		text.nodeValue = `${str}`;
 	}
@@ -3758,7 +3778,7 @@ function unmount(component, options) {
 	return Promise.resolve();
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/blocks/branches.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/blocks/branches.js
 /** @import { Effect, TemplateNode } from '#client' */
 var _batches = /* @__PURE__ */ new WeakMap();
 var _onscreen = /* @__PURE__ */ new WeakMap();
@@ -3881,7 +3901,7 @@ var BranchManager = class {
 	}
 };
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/blocks/snippet.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/blocks/snippet.js
 /** @import { Snippet } from 'svelte' */
 /** @import { TemplateNode } from '#client' */
 /** @import { Getters } from '#shared' */
@@ -3934,7 +3954,7 @@ function init_update_callbacks(context) {
 	});
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/blocks/if.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/blocks/if.js
 /** @import { TemplateNode } from '#client' */
 /**
 * @param {TemplateNode} node
@@ -3980,7 +4000,7 @@ function if_block(node, fn, elseif = false) {
 	}, flags);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/blocks/each.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/blocks/each.js
 /** @import { EachItem, EachOutroGroup, EachState, Effect, EffectNodes, MaybeSource, Source, TemplateNode, TransitionManager, Value } from '#client' */
 /** @import { Batch } from '../../reactivity/batch.js'; */
 /**
@@ -4452,7 +4472,7 @@ function html(node, get_value, is_controlled = false, svg = false, mathml = fals
 	});
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/css.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/css.js
 /**
 * @param {Node} anchor
 * @param {{ hash: string, code: string }} css
@@ -4470,7 +4490,7 @@ function append_styles$1(anchor, css) {
 	});
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/shared/attributes.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/shared/attributes.js
 var whitespace = [..." 	\n\r\f\xA0\v"];
 /**
 * @param {any} value
@@ -4580,7 +4600,7 @@ function to_style(value, styles) {
 	return value == null ? null : String(value);
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/class.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/class.js
 /**
 * @param {Element} dom
 * @param {boolean | number} is_html
@@ -4605,7 +4625,7 @@ function set_class(dom, is_html, value, hash, prev_classes, next_classes) {
 	return next_classes;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/style.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/style.js
 /**
 * @param {Element & ElementCSSInlineStyle} dom
 * @param {Record<string, any>} prev
@@ -4639,7 +4659,7 @@ function set_style(dom, value, prev_styles, next_styles) {
 	return next_styles;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/attributes.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/attributes.js
 /** @import { Blocker, Effect } from '#client' */
 var IS_CUSTOM_ELEMENT = Symbol("is custom element");
 var IS_HTML = Symbol("is html");
@@ -4670,8 +4690,7 @@ function set_attribute(element, attribute, value, skip_warning) {
 * @param {Element} element
 */
 function get_attributes(element) {
-	var _element;
-	return (_element = element)[ATTRIBUTES_CACHE] ?? (_element[ATTRIBUTES_CACHE] = {
+	return element[ATTRIBUTES_CACHE] ?? (element[ATTRIBUTES_CACHE] = {
 		[IS_CUSTOM_ELEMENT]: element.nodeName.includes("-"),
 		[IS_HTML]: element.namespaceURI === "http://www.w3.org/1999/xhtml"
 	});
@@ -4695,7 +4714,7 @@ function get_setters(element) {
 	return setters;
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/bindings/size.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/bindings/size.js
 var _ResizeObserverSingleton;
 var _listeners = /* @__PURE__ */ new WeakMap();
 var _observer = /* @__PURE__ */ new WeakMap();
@@ -4747,7 +4766,7 @@ function _getObserver() {
 }
 _defineProperty(ResizeObserverSingleton, "entries", /* @__PURE__ */ new WeakMap());
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/bindings/this.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/bindings/this.js
 /** @import { ComponentContext, Effect } from '#client' */
 /**
 * @param {any} bound_value
@@ -4889,7 +4908,7 @@ function prop(props, key, flags, fallback) {
 	});
 }
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/legacy/legacy-client.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/legacy/legacy-client.js
 /** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
 /**
 * Takes the same options as a Svelte 4 component and the component function and returns a Svelte 4 compatible component.
@@ -5008,7 +5027,7 @@ var Svelte4Component = class {
 	}
 };
 //#endregion
-//#region ../../../node_modules/.bun/svelte@5.56.1/node_modules/svelte/src/internal/client/dom/elements/custom-element.js
+//#region ../../../node_modules/.bun/svelte@5.56.8/node_modules/svelte/src/internal/client/dom/elements/custom-element.js
 /**
 * @typedef {Object} CustomElementPropDefinition
 * @property {string} [attribute]
@@ -5294,7 +5313,8 @@ function create_custom_element(Component, props_definition, slots, exports, shad
 }
 //#endregion
 //#region ../../lib-svelte/delivery-events/dist/index2.js
-var _e, _e2;
+var _e;
+var _e2;
 var e$1 = (_e = class e extends CustomEvent {
 	constructor(t, n, r) {
 		super(e.TYPE, {
@@ -5307,7 +5327,8 @@ var e$1 = (_e = class e extends CustomEvent {
 			}
 		}), this.component = t, this.complete = n;
 	}
-}, _e.TYPE = "model-set", _e), t$2 = (_e2 = class e extends CustomEvent {
+}, _e.TYPE = "model-set", _e);
+var t$2 = (_e2 = class e extends CustomEvent {
 	constructor(t, n) {
 		super(e.TYPE, {
 			bubbles: !0,
@@ -5343,11 +5364,11 @@ function r$1({ sourceEl: t, fallbackSelector: r, component: i, complete: a, sess
 }
 //#endregion
 //#region ../../shared/math-rendering-mathjax/dist/index.js
-var e = "https://cdn.jsdelivr.net/npm/mathjax@4/tex-chtml.js", t = null;
-function n(n) {
-	return typeof window > "u" || window.MathJax?.typesetPromise ? Promise.resolve() : t || (t = new Promise((t, r) => {
-		let { useSingleDollar: i = !1, accessibility: a = !0, loadFonts: o = !0, srcUrl: s } = n, c = {
-			loader: { load: a ? ["a11y/assistive-mml"] : [] },
+var e = null;
+function t(t) {
+	return typeof window > "u" || window.MathJax?.typesetPromise ? Promise.resolve() : e || (e = new Promise((e, n) => {
+		let { useSingleDollar: r = !1, accessibility: i = !0, loadFonts: a = !0, srcUrl: o } = t, s = {
+			loader: { load: i ? ["a11y/assistive-mml"] : [] },
 			tex: {
 				packages: [
 					"base",
@@ -5362,27 +5383,27 @@ function n(n) {
 				}
 			},
 			options: {
-				enableMenu: a,
-				enableExplorer: a,
-				enableAssistiveMml: a
+				enableMenu: i,
+				enableExplorer: i,
+				enableAssistiveMml: i
 			},
 			startup: {
 				ready: () => {
-					window.MathJax?.startup.defaultReady && (window.MathJax.startup.defaultReady(), t());
+					window.MathJax?.startup.defaultReady && (window.MathJax.startup.defaultReady(), e());
 				},
 				defaultReady: () => {}
 			}
 		};
-		i && c.tex && (c.tex.inlineMath = [["$", "$"], ["\\(", "\\)"]], c.tex.processEscapes = !0), o || (c.chtml = { fontURL: "" }), window.MathJax = c;
-		let l = document.createElement("script");
-		l.src = s || e, l.async = !0, l.onload = () => {
-			setTimeout(t, 100);
-		}, l.onerror = () => {
-			r(/* @__PURE__ */ Error("Failed to load MathJax"));
-		}, document.head.appendChild(l);
-	}), t);
-}
-function r() {
+		r && s.tex && (s.tex.inlineMath = [["$", "$"], ["\\(", "\\)"]], s.tex.processEscapes = !0), a || (s.chtml = { fontURL: "" }), window.MathJax = s;
+		let c = document.createElement("script");
+		c.src = o || "https://cdn.jsdelivr.net/npm/mathjax@4/tex-chtml.js", c.async = !0, c.onload = () => {
+			setTimeout(e, 100);
+		}, c.onerror = () => {
+			n(/* @__PURE__ */ Error("Failed to load MathJax"));
+		}, document.head.appendChild(c);
+	}), e);
+}
+function n() {
 	let e = window.MathJax?.startup?.document;
 	if (typeof e?.assistiveMml == "function") try {
 		e.assistiveMml().updateDocument?.();
@@ -5390,33 +5411,33 @@ function r() {
 		console.warn("[mathjax-renderer] Failed to attach assistive MathML:", e);
 	}
 }
-function i(e = {}) {
-	return async (t) => {
-		if (await n(e), !window.MathJax?.typesetPromise) {
+function r(e = {}) {
+	return async (r) => {
+		if (await t(e), !window.MathJax?.typesetPromise) {
 			console.warn("[mathjax-renderer] MathJax not loaded or missing typesetPromise.");
 			return;
 		}
-		await window.MathJax.typesetPromise([t]), r();
+		await window.MathJax.typesetPromise([r]), n();
 	};
 }
-var o = "@pie-lib/math-rendering", s = null;
-function c() {
-	return s || (s = i({
+var a = null;
+function o() {
+	return a || (a = r({
 		accessibility: !0,
 		useSingleDollar: !0
-	})), s;
+	})), a;
 }
-function l() {
+function s() {
 	if (typeof window > "u") return null;
-	let e = window[o];
+	let e = window["@pie-lib/math-rendering"];
 	return typeof e?.renderMath == "function" ? e : null;
 }
-var u = async (e) => {
+var c = async (e) => {
 	if (typeof window > "u") return;
 	let t = typeof e == "string", n;
 	t ? (n = document.createElement("div"), n.innerHTML = e) : n = e || document.body;
-	let r = l();
-	return r ? await r.renderMath?.(n) : await c()(n), t ? n.innerHTML : void 0;
+	let r = s();
+	return r ? await r.renderMath?.(n) : await o()(n), t ? n.innerHTML : void 0;
 };
 //#endregion
 //#region src/delivery/tile-accessible-name.ts
@@ -5438,7 +5459,7 @@ var root_3$1 = /* @__PURE__ */ from_html(`<span class="badge badge-incorrect sve
 var root_4$1 = /* @__PURE__ */ from_html(`<button type="button"><span><!> <!></span> <!></button>`);
 var $$css$2 = {
 	hash: "svelte-1hgaksk",
-	code: ".venn-tile.svelte-1hgaksk {position:relative;display:inline-flex;align-items:center;justify-content:center;min-width:64px;min-height:44px;padding:8px 14px;border:1.5px solid #334155;border-radius:10px;background:#ffffff;color:#0f172a;font-size:14px;font-weight:500;box-shadow:0 1px 2px rgba(15, 23, 42, 0.06);cursor:grab;touch-action:none;user-select:none;transition:box-shadow 120ms ease, transform 120ms ease, background 120ms ease;}.venn-tile.svelte-1hgaksk:focus-visible,\n  .venn-tile.focused.svelte-1hgaksk {outline:2px solid #2563eb;outline-offset:2px;}.venn-tile.svelte-1hgaksk:hover:not(:disabled) {background:#f8fafc;}.venn-tile.held.svelte-1hgaksk {cursor:grabbing;box-shadow:0 6px 18px rgba(15, 23, 42, 0.18);transform:translateY(-1px);background:#eef2ff;}.venn-tile.invisible.svelte-1hgaksk {visibility:hidden;}.venn-tile.ghost.svelte-1hgaksk {pointer-events:none;cursor:grabbing;box-shadow:0 10px 24px rgba(15, 23, 42, 0.22);transform:rotate(-1.5deg);background:#ffffff;opacity:0.96;}.venn-tile.correct.svelte-1hgaksk {border-color:#0ea449;}.venn-tile.incorrect.svelte-1hgaksk {border-color:#bf0d00;}.venn-tile.svelte-1hgaksk:disabled {cursor:default;}.tile-body.svelte-1hgaksk {display:inline-flex;flex-direction:row;align-items:center;justify-content:center;gap:8px;pointer-events:none;max-width:220px;}.tile-body-image.svelte-1hgaksk {flex-direction:column;gap:4px;}.tile-img.svelte-1hgaksk {width:40px;height:40px;object-fit:contain;flex-shrink:0;}.tile-label.svelte-1hgaksk {pointer-events:none;text-align:center;line-height:1.25;word-break:break-word;}.tile-label-below.svelte-1hgaksk {font-size:12px;font-weight:600;}.badge.svelte-1hgaksk {position:absolute;top:-8px;right:-8px;width:20px;height:20px;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;color:#ffffff;}.badge-correct.svelte-1hgaksk {background:#0ea449;}.badge-incorrect.svelte-1hgaksk {background:#bf0d00;}\n  @media (prefers-reduced-motion: reduce) {.venn-tile.svelte-1hgaksk {transition:none;}\n  }"
+	code: ".venn-tile.svelte-1hgaksk {position:relative;display:inline-flex;align-items:center;justify-content:center;min-width:64px;min-height:44px;padding:8px 14px;border:1.5px solid #334155;border-radius:10px;background:#ffffff;color:#0f172a;font-size:14px;font-weight:500;box-shadow:0 1px 2px rgba(15, 23, 42, 0.06);cursor:grab;touch-action:none;user-select:none;transition:box-shadow 120ms ease, transform 120ms ease, background 120ms ease;}.venn-tile.svelte-1hgaksk:focus-visible,\n  .venn-tile.focused.svelte-1hgaksk {outline:2px solid var(--vc-focus-ring, #1565c0);outline-offset:2px;}.venn-tile.svelte-1hgaksk:hover:not(:disabled) {background:#f8fafc;}.venn-tile.held.svelte-1hgaksk {cursor:grabbing;box-shadow:0 6px 18px rgba(15, 23, 42, 0.18);transform:translateY(-1px);background:#eef2ff;}.venn-tile.invisible.svelte-1hgaksk {visibility:hidden;}.venn-tile.ghost.svelte-1hgaksk {pointer-events:none;cursor:grabbing;box-shadow:0 10px 24px rgba(15, 23, 42, 0.22);transform:rotate(-1.5deg);background:#ffffff;opacity:0.96;}.venn-tile.correct.svelte-1hgaksk {border-color:#0ea449;}.venn-tile.incorrect.svelte-1hgaksk {border-color:#bf0d00;}.venn-tile.svelte-1hgaksk:disabled {cursor:default;}.tile-body.svelte-1hgaksk {display:inline-flex;flex-direction:row;align-items:center;justify-content:center;gap:8px;pointer-events:none;max-width:220px;}.tile-body-image.svelte-1hgaksk {flex-direction:column;gap:4px;}.tile-img.svelte-1hgaksk {width:40px;height:40px;object-fit:contain;flex-shrink:0;}.tile-label.svelte-1hgaksk {pointer-events:none;text-align:center;line-height:1.25;word-break:break-word;}.tile-label-below.svelte-1hgaksk {font-size:12px;font-weight:600;}.badge.svelte-1hgaksk {position:absolute;top:-8px;right:-8px;width:20px;height:20px;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;color:#ffffff;}.badge-correct.svelte-1hgaksk {background:#0ea449;}.badge-incorrect.svelte-1hgaksk {background:#bf0d00;}\n  @media (prefers-reduced-motion: reduce) {.venn-tile.svelte-1hgaksk {transition:none;}\n  }"
 };
 function Tile($$anchor, $$props) {
 	push($$props, true);
@@ -5649,7 +5670,7 @@ create_custom_element(Tile, {
 var root$1 = /* @__PURE__ */ from_html(`<div role="region" data-region-key="tray"><div class="tray-label svelte-1ogsh8s"> </div> <div class="tray-items svelte-1ogsh8s"><!></div></div>`);
 var $$css$1 = {
 	hash: "svelte-1ogsh8s",
-	code: ".venn-tray.svelte-1ogsh8s {border:1.5px dashed #94a3b8;border-radius:12px;padding:14px 16px;background:#f8fafc;min-height:120px;transition:background 120ms ease, border-color 120ms ease;}.venn-tray.drop-target.svelte-1ogsh8s {background:#e0f2fe;border-color:#0ea5e9;}.venn-tray.focused.svelte-1ogsh8s {outline:2px solid #2563eb;outline-offset:2px;}.tray-label.svelte-1ogsh8s {font-size:12px;font-weight:600;color:#475569;text-transform:uppercase;letter-spacing:0.05em;margin-bottom:8px;}.tray-items.svelte-1ogsh8s {display:flex;flex-wrap:wrap;gap:10px;}\n  @media (prefers-reduced-motion: reduce) {.venn-tray.svelte-1ogsh8s {transition:none;}\n  }"
+	code: ".venn-tray.svelte-1ogsh8s {border:1.5px dashed #94a3b8;border-radius:12px;padding:14px 16px;background:#f8fafc;min-height:120px;transition:background 120ms ease, border-color 120ms ease;}.venn-tray.drop-target.svelte-1ogsh8s {background:#e0f2fe;border-color:#0ea5e9;}.venn-tray.focused.svelte-1ogsh8s {outline:2px solid var(--vc-focus-ring, #1565c0);outline-offset:2px;}.tray-label.svelte-1ogsh8s {font-size:12px;font-weight:600;color:#475569;text-transform:uppercase;letter-spacing:0.05em;margin-bottom:8px;}.tray-items.svelte-1ogsh8s {display:flex;flex-wrap:wrap;gap:10px;}\n  @media (prefers-reduced-motion: reduce) {.venn-tray.svelte-1ogsh8s {transition:none;}\n  }"
 };
 function Tray($$anchor, $$props) {
 	push($$props, true);
@@ -5856,7 +5877,7 @@ function makeGridSlot(center, slotsPerRow) {
 * compose accessible names, and `model.regionLabels` for overrides).
 */
 function buildLayout2Set(model, geometry = defaultGeometry2Set()) {
-	if (!model.circles || model.circles.length !== 2) throw new Error(`buildLayout2Set requires exactly 2 circles (got ${model.circles?.length ?? 0})`);
+	if (model.circles?.length !== 2) throw new Error(`buildLayout2Set requires exactly 2 circles (got ${model.circles?.length ?? 0})`);
 	const [c0, c1] = geometry.circles;
 	const regions = enumerateRegions(2);
 	const circleBottom = Math.max(c0.cy + c0.r, c1.cy + c1.r);
@@ -6051,12 +6072,6 @@ function groupTilesByRegion(model, session) {
 	}
 	return groups;
 }
-new Set([
-	"$$slots",
-	"$$events",
-	"$$legacy",
-	"$$host"
-]);
 var root = /* @__PURE__ */ from_html(`<div class="venn-prompt prose svelte-gkcqor"></div>`);
 var root_1 = /* @__PURE__ */ from_svg(`<svg class="toggle-icon svelte-gkcqor" preserveAspectRatio="xMinYMin meet" version="1.1" viewBox="-283 359 34 35" aria-hidden="true"><circle cx="-266" cy="375.9" r="14" fill="#bce2ff"></circle><path d="M-280.5,375.9c0-8,6.5-14.5,14.5-14.5s14.5,6.5,14.5,14.5s-6.5,14.5-14.5,14.5S-280.5,383.9-280.5,375.9z M-279.5,375.9c0,7.4,6.1,13.5,13.5,13.5c7.4,0,13.5-6.1,13.5-13.5s-6.1-13.5-13.5-13.5C-273.4,362.4-279.5,368.5-279.5,375.9z" fill="#bce2ff"></path><polygon points="-265.4,383.1 -258.6,377.2 -261.2,374.2 -264.3,376.9 -268.9,368.7 -272.4,370.6" fill="#1a9cff"></polygon></svg>`);
 var root_2 = /* @__PURE__ */ from_svg(`<svg class="toggle-icon svelte-gkcqor" preserveAspectRatio="xMinYMin meet" version="1.1" viewBox="-129.5 127 34 35" aria-hidden="true"><path style="fill: #D0CAC5; stroke: #E6E3E0; stroke-width: 0.75; stroke-miterlimit: 10;" d="M-112.9,160.4c-8.5,0-15.5-6.9-15.5-15.5c0-8.5,6.9-15.5,15.5-15.5s15.5,6.9,15.5,15.5 C-97.4,153.5-104.3,160.4-112.9,160.4z"></path><path style="fill: #B3ABA4; stroke: #CDC7C2; stroke-width: 0.5; stroke-miterlimit: 10;" d="M-113.2,159c-8,0-14.5-6.5-14.5-14.5s6.5-14.5,14.5-14.5s14.5,6.5,14.5,14.5S-105.2,159-113.2,159z"></path><circle cx="-114.2" cy="143.5" r="14" fill="white"></circle><path d="M-114.2,158c-8,0-14.5-6.5-14.5-14.5s6.5-14.5,14.5-14.5s14.5,6.5,14.5,14.5S-106.2,158-114.2,158z M-114.2,130c-7.4,0-13.5,6.1-13.5,13.5s6.1,13.5,13.5,13.5s13.5-6.1,13.5-13.5S-106.8,130-114.2,130z" fill="#bce2ff"></path><polygon points="-114.8,150.7 -121.6,144.8 -119,141.8 -115.9,144.5 -111.3,136.3 -107.8,138.2" fill="#1a9cff"></polygon></svg>`);
@@ -6074,7 +6089,7 @@ var root_13 = /* @__PURE__ */ from_html(`<div class="drag-ghost svelte-gkcqor"><
 var root_14 = /* @__PURE__ */ from_html(`<div class="venn-root svelte-gkcqor"><!> <!> <div class="venn-diagram svelte-gkcqor"><svg preserveAspectRatio="xMidYMid meet" aria-hidden="true" class="svelte-gkcqor"><defs><mask id="venn-mask-left-only" maskUnits="userSpaceOnUse" x="0" y="0"><rect x="0" y="0" fill="black"></rect><circle fill="white"></circle><circle fill="black"></circle></mask><mask id="venn-mask-right-only" maskUnits="userSpaceOnUse" x="0" y="0"><rect x="0" y="0" fill="black"></rect><circle fill="white"></circle><circle fill="black"></circle></mask><clipPath id="venn-clip-left" clipPathUnits="userSpaceOnUse"><circle></circle></clipPath><mask id="venn-mask-outside" maskUnits="userSpaceOnUse" x="0" y="0"><rect x="0" y="0" fill="white"></rect><circle fill="black"></circle><circle fill="black"></circle></mask></defs><rect x="1" y="1" fill="#ffffff" stroke="#cbd5e1" stroke-width="1.5" rx="12"></rect><!><!><!><!><!><!><!><line x1="16" stroke="#cbd5e1" stroke-width="1" stroke-dasharray="4 6"></line></svg> <div class="region-labels svelte-gkcqor" aria-hidden="false"></div> <div class="placed-tiles svelte-gkcqor"></div></div> <!> <!> <div class="sr-only svelte-gkcqor" aria-live="polite" aria-atomic="true"></div></div>`);
 var $$css = {
 	hash: "svelte-gkcqor",
-	code: ".venn-root.svelte-gkcqor {display:flex;flex-direction:column;gap:16px;padding:16px;color:#0f172a;font-family:system-ui, -apple-system, Segoe UI, Roboto, sans-serif;}.venn-prompt.svelte-gkcqor {font-size:16px;line-height:1.5;}.venn-prompt.svelte-gkcqor p {margin:0 0 8px 0;}.toggle-correct.svelte-gkcqor {align-self:center;display:inline-flex;align-items:center;gap:8px;margin:0 0 4px 0;padding:0;background:transparent;border:0;color:inherit;font:inherit;font-size:14px;cursor:pointer;user-select:none;}.toggle-correct.svelte-gkcqor:focus-visible {outline:2px solid #2563eb;outline-offset:2px;border-radius:2px;}.toggle-icon.svelte-gkcqor {width:25px;height:25px;flex-shrink:0;}.toggle-label.svelte-gkcqor {line-height:1.2;}.toggle-correct.svelte-gkcqor:hover .toggle-label:where(.svelte-gkcqor),\n  .toggle-correct.svelte-gkcqor:focus-visible .toggle-label:where(.svelte-gkcqor) {text-decoration:underline;}.venn-diagram.svelte-gkcqor {position:relative;width:100%;\n    /*\n     * Keep the diagram \"smart\" about vertical space: it should not monopolise\n     * the viewport and force the tray below the fold.\n     *   - aspect-ratio preserves the 3:2 geometry the SVG is tuned for\n     *   - max-width keeps the diagram from dominating wide layouts\n     *   - max-height (viewport-relative) shrinks it further in short windows\n     *     so the prompt, toggle, and tray remain in view without scrolling\n     *     whenever possible. The SVG uses preserveAspectRatio=\"xMidYMid meet\",\n     *     so when max-height wins the width reduces in lockstep.\n     */max-width:720px;aspect-ratio:900 / 540;max-height:min(60vh, 430px);margin:0 auto;}.venn-diagram.svelte-gkcqor svg:where(.svelte-gkcqor) {width:100%;height:100%;display:block;}.placed-tiles.svelte-gkcqor,\n  .region-labels.svelte-gkcqor {position:absolute;inset:0;pointer-events:none;}.tile-wrapper.svelte-gkcqor {position:absolute;transform:translate(-50%, -50%);pointer-events:auto;}.region-aria.svelte-gkcqor {position:absolute;width:1px;height:1px;transform:translate(-50%, -50%);opacity:0;pointer-events:none;}.sr-only.svelte-gkcqor {position:absolute;width:1px;height:1px;padding:0;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border:0;}.drag-ghost.svelte-gkcqor {position:fixed;top:0;left:0;transform:translate(-50%, -50%);pointer-events:none;z-index:1000;}"
+	code: ".venn-root.svelte-gkcqor {display:flex;flex-direction:column;gap:16px;padding:16px;color:#0f172a;font-family:system-ui, -apple-system, Segoe UI, Roboto, sans-serif;--vc-focus-ring: var(\n      --pie-focus-outline,\n      var(--pie-button-focus-outline, var(--pie-focus-checked-border, #1565c0))\n    );}.venn-prompt.svelte-gkcqor {font-size:16px;line-height:1.5;}.venn-prompt.svelte-gkcqor p {margin:0 0 8px 0;}.toggle-correct.svelte-gkcqor {align-self:center;display:inline-flex;align-items:center;gap:8px;margin:0 0 4px 0;padding:0;background:transparent;border:0;color:inherit;font:inherit;font-size:14px;cursor:pointer;user-select:none;}.toggle-correct.svelte-gkcqor:focus-visible {outline:2px solid var(--vc-focus-ring, #1565c0);outline-offset:2px;border-radius:2px;}.toggle-icon.svelte-gkcqor {width:25px;height:25px;flex-shrink:0;}.toggle-label.svelte-gkcqor {line-height:1.2;}.toggle-correct.svelte-gkcqor:hover .toggle-label:where(.svelte-gkcqor),\n  .toggle-correct.svelte-gkcqor:focus-visible .toggle-label:where(.svelte-gkcqor) {text-decoration:underline;}.venn-diagram.svelte-gkcqor {position:relative;width:100%;\n    /*\n     * Keep the diagram \"smart\" about vertical space: it should not monopolise\n     * the viewport and force the tray below the fold.\n     *   - aspect-ratio preserves the 3:2 geometry the SVG is tuned for\n     *   - max-width keeps the diagram from dominating wide layouts\n     *   - max-height (viewport-relative) shrinks it further in short windows\n     *     so the prompt, toggle, and tray remain in view without scrolling\n     *     whenever possible. The SVG uses preserveAspectRatio=\"xMidYMid meet\",\n     *     so when max-height wins the width reduces in lockstep.\n     */max-width:720px;aspect-ratio:900 / 540;max-height:min(60vh, 430px);margin:0 auto;}.venn-diagram.svelte-gkcqor svg:where(.svelte-gkcqor) {width:100%;height:100%;display:block;}.placed-tiles.svelte-gkcqor,\n  .region-labels.svelte-gkcqor {position:absolute;inset:0;pointer-events:none;}.tile-wrapper.svelte-gkcqor {position:absolute;transform:translate(-50%, -50%);pointer-events:auto;}.region-aria.svelte-gkcqor {position:absolute;width:1px;height:1px;transform:translate(-50%, -50%);opacity:0;pointer-events:none;}.sr-only.svelte-gkcqor {position:absolute;width:1px;height:1px;padding:0;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border:0;}.drag-ghost.svelte-gkcqor {position:fixed;top:0;left:0;transform:translate(-50%, -50%);pointer-events:none;z-index:1000;}"
 };
 function VennClassification($$anchor, $$props) {
 	push($$props, true);
@@ -6282,7 +6297,7 @@ function VennClassification($$anchor, $$props) {
 	function typeset() {
 		if (!containerEl) return;
 		try {
-			u(containerEl);
+			c(containerEl);
 		} catch (err) {
 			console.warn("venn-classification: MathJax render failed", err);
 		}