@nanoforge-dev/editor 0.0.1 → 0.0.2-beta.4555742

package/dist/server/chunks/{dev-7V6fUCff.js → events-DeYJGjCt.js}

@@ -1,4 +1,22 @@
-//#region .svelte-kit/adapter-bun/chunks/dev.js
+import { n as __exportAll } from "./chunk-ByNZkrT6.js";
+//#region node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+	var t, f, n = "";
+	if ("string" == typeof e || "number" == typeof e) n += e;
+	else if ("object" == typeof e) if (Array.isArray(e)) {
+		var o = e.length;
+		for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+	} else for (f in e) e[f] && (n && (n += " "), n += f);
+	return n;
+}
+function clsx() {
+	for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+	return n;
+}
+//#endregion
+//#region .svelte-kit/adapter-bun/chunks/index-server.js
+var MAX_ARRAY_LEN = 2 ** 32 - 1;
+var MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
 /** @type {Record<string, string>} */
 var escaped = {
 	"<": "\\u003C",
@@ -80,18 +98,29 @@ var is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 function stringify_key(key) {
 	return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
 }
+/** @param {number} n */
+function is_valid_array_index(n) {
+	if (!Number.isInteger(n)) return false;
+	if (n < 0) return false;
+	if (n > MAX_ARRAY_INDEX) return false;
+	return true;
+}
+/** @param {number} n */
+function is_valid_array_len(n) {
+	if (!Number.isInteger(n)) return false;
+	if (n < 0) return false;
+	if (n > MAX_ARRAY_LEN) return false;
+	return true;
+}
 /** @param {string} s */
-function is_valid_array_index(s) {
+function is_valid_array_index_string(s) {
 	if (s.length === 0) return false;
 	if (s.length > 1 && s.charCodeAt(0) === 48) return false;
 	for (let i = 0; i < s.length; i++) {
 		const c = s.charCodeAt(i);
 		if (c < 48 || c > 57) return false;
 	}
-	const n = +s;
-	if (n >= 2 ** 32 - 1) return false;
-	if (n < 0) return false;
-	return true;
+	return is_valid_array_index(+s);
 }
 /**
 * Finds the populated indices of an array.
@@ -99,7 +128,7 @@ function is_valid_array_index(s) {
 */
 function valid_array_indices(array) {
 	const keys = Object.keys(array);
-	for (var i = keys.length - 1; i >= 0; i--) if (is_valid_array_index(keys[i])) break;
+	for (var i = keys.length - 1; i >= 0; i--) if (is_valid_array_index_string(keys[i])) break;
 	keys.length = i + 1;
 	return keys;
 }
@@ -667,6 +696,26 @@ function deferred() {
 		reject
 	};
 }
+/**
+* When encountering a situation like `let [a, b, c] = $derived(blah())`,
+* we need to stash an intermediate value that `a`, `b`, and `c` derive
+* from, in case it's an iterable
+* @template T
+* @param {ArrayLike<T> | Iterable<T>} value
+* @param {number} [n]
+* @returns {Array<T>}
+*/
+function to_array(value, n) {
+	if (Array.isArray(value)) return value;
+	if (n === void 0 || !(Symbol.iterator in value)) return Array.from(value);
+	/** @type {T[]} */
+	const array = [];
+	for (const element of value) {
+		array.push(element);
+		if (array.length === n) break;
+	}
+	return array;
+}
 var CLEAN = 1024;
 var DIRTY = 2048;
 var MAYBE_DIRTY = 4096;
@@ -686,13 +735,18 @@ var USER_EFFECT = 1 << 20;
 /**
 * Tells that we marked this derived and its reactions as visited during the "mark as (maybe) dirty"-phase.
 * Will be lifted during execution of the derived and during checking its dirty state (both are necessary
-* because a derived might be checked but not executed).
+* because a derived might be checked but not executed). This is a pure performance optimization flag and
+* should not be used for any other purpose!
 */
 var WAS_MARKED = 65536;
 var REACTION_IS_UPDATING = 1 << 21;
 var ERROR_VALUE = 1 << 23;
 var STATE_SYMBOL = Symbol("$state");
 var LEGACY_PROPS = Symbol("legacy props");
+var ATTRIBUTES_CACHE = Symbol("attributes");
+var CLASS_CACHE = Symbol("class");
+var STYLE_CACHE = Symbol("style");
+var TEXT_CACHE = Symbol("text");
 /** allow users to ignore aborted signal errors if `reason.name === 'StaleReactionError` */
 var STALE_REACTION = new class StaleReactionError extends Error {
 	name = "StaleReactionError";
@@ -765,7 +819,8 @@ function in_webcontainer() {
 	return !!globalThis.process?.versions?.webcontainer;
 }
 var HYDRATION_ERROR = {};
-var UNINITIALIZED = Symbol();
+var UNINITIALIZED = Symbol("uninitialized");
+var ATTACHMENT_KEY = "@attach";
 /**
 * A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
 * 
@@ -801,19 +856,6 @@ function escape_html(value, is_attr) {
 	}
 	return escaped + str.substring(last);
 }
-function r(e) {
-	var t, f, n = "";
-	if ("string" == typeof e || "number" == typeof e) n += e;
-	else if ("object" == typeof e) if (Array.isArray(e)) {
-		var o = e.length;
-		for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
-	} else for (f in e) e[f] && (n && (n += " "), n += f);
-	return n;
-}
-function clsx$1() {
-	for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
-	return n;
-}
 /**
 * `<div translate={false}>` should be rendered as `<div translate="no">` and _not_
 * `<div translate="false">`, which is equivalent to `<div translate="yes">`. There
@@ -839,8 +881,8 @@ function attr(name, value, is_boolean = false) {
 * TODO Svelte 6 revisit this, and likely turn all falsy values into the empty string (what clsx also does)
 * @param  {any} value
 */
-function clsx(value) {
-	if (typeof value === "object") return clsx$1(value);
+function clsx$1(value) {
+	if (typeof value === "object") return clsx(value);
 	else return value ?? "";
 }
 var whitespace = [..." 	\n\r\f\xA0\v"];
@@ -1318,17 +1360,113 @@ function writable(value, start = noop) {
 	};
 }
 /**
+* Derived value store by synchronizing one or more readable stores and
+* applying an aggregation function over its input values.
+*
+* @template {Stores} S
+* @template T
+* @overload
+* @param {S} stores
+* @param {(values: StoresValues<S>, set: (value: T) => void, update: (fn: Updater<T>) => void) => Unsubscriber | void} fn
+* @param {T} [initial_value]
+* @returns {Readable<T>}
+*/
+/**
+* Derived value store by synchronizing one or more readable stores and
+* applying an aggregation function over its input values.
+*
+* @template {Stores} S
+* @template T
+* @overload
+* @param {S} stores
+* @param {(values: StoresValues<S>) => T} fn
+* @param {T} [initial_value]
+* @returns {Readable<T>}
+*/
+/**
+* @template {Stores} S
+* @template T
+* @param {S} stores
+* @param {Function} fn
+* @param {T} [initial_value]
+* @returns {Readable<T>}
+*/
+function derived$1(stores, fn, initial_value) {
+	const single = !Array.isArray(stores);
+	/** @type {Array<Readable<any>>} */
+	const stores_array = single ? [stores] : stores;
+	if (!stores_array.every(Boolean)) throw new Error("derived() expects stores as input, got a falsy value");
+	const auto = fn.length < 2;
+	return readable(initial_value, (set, update) => {
+		let started = false;
+		/** @type {T[]} */
+		const values = [];
+		let pending = 0;
+		let cleanup = noop;
+		const sync = () => {
+			if (pending) return;
+			cleanup();
+			const result = fn(single ? values[0] : values, set, update);
+			if (auto) set(result);
+			else cleanup = typeof result === "function" ? result : noop;
+		};
+		const unsubscribers = stores_array.map((store, i) => subscribe_to_store(store, (value) => {
+			values[i] = value;
+			pending &= ~(1 << i);
+			if (started) sync();
+		}, () => {
+			pending |= 1 << i;
+		}));
+		started = true;
+		sync();
+		return function stop() {
+			run_all(unsubscribers);
+			cleanup();
+			started = false;
+		};
+	});
+}
+/**
+* Takes a store and returns a new one derived from the old one that is readable.
+*
+* @template T
+* @param {Readable<T>} store  - store to make readonly
+* @returns {Readable<T>}
+*/
+function readonly(store) {
+	return { subscribe: store.subscribe.bind(store) };
+}
+/**
+* Get the current value from a store by subscribing and immediately unsubscribing.
+*
+* @template T
+* @param {Readable<T>} store
+* @returns {T}
+*/
+function get$1(store) {
+	let value;
+	subscribe_to_store(store, (_) => value = _)();
+	return value;
+}
+/**
 * We set this to `true` when updating a store so that we correctly
 * schedule effects if the update takes place inside a `$:` effect
 */
 var legacy_is_updating_store = false;
 /** @import { Fork } from 'svelte' */
 /** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
-/** @type {Set<Batch>} */
-var batches = /* @__PURE__ */ new Set();
+/** @type {Batch | null} */
+var 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
@@ -1358,6 +1496,15 @@ var flush_count = 0;
 var uid = 1;
 var Batch = class Batch {
 	id = uid++;
+	/** True as soon as `#process` was called */
+	#started = false;
+	linked = true;
+	/** @type {Batch | null} */
+	#prev = null;
+	/** @type {Batch | null} */
+	#next = null;
+	/** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
+	async_deriveds = /* @__PURE__ */ new Map();
 	/**
 	* The current values of any signals that are updated in this batch.
 	* Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
@@ -1383,15 +1530,9 @@ var Batch = class Batch {
 	*/
 	#discard_callbacks = /* @__PURE__ */ new Set();
 	/**
-	* Callbacks that should run only when a fork is committed.
-	* @type {Set<(batch: Batch) => void>}
-	*/
-	#fork_commit_callbacks = /* @__PURE__ */ new Set();
-	/**
-	* Async effects that are currently in flight
-	* @type {Map<Effect, number>}
+	* The number of async effects that are currently in flight
 	*/
-	#pending = /* @__PURE__ */ new Map();
+	#pending = 0;
 	/**
 	* Async effects that are currently in flight, _not_ inside a pending boundary
 	* @type {Map<Effect, number>}
@@ -1438,15 +1579,19 @@ var Batch = class Batch {
 	#unskipped_branches = /* @__PURE__ */ new Set();
 	is_fork = false;
 	#decrement_queued = false;
-	/** @type {Set<Batch>} */
-	#blockers = /* @__PURE__ */ new Set();
-	#is_deferred() {
-		return this.is_fork || this.#blocking_pending.size > 0;
+	constructor() {
+		if (last_batch === null) first_batch = last_batch = this;
+		else {
+			last_batch.#next = this;
+			this.#prev = last_batch;
+		}
+		last_batch = this;
 	}
-	#is_blocked() {
-		for (const batch of this.#blockers) for (const effect of batch.#blocking_pending.keys()) {
-			var skipped = false;
+	#is_deferred() {
+		if (this.is_fork) return true;
+		for (const effect of this.#blocking_pending.keys()) {
 			var e = effect;
+			var skipped = false;
 			while (e.parent !== null) {
 				if (this.#skipped_branches.has(e)) {
 					skipped = true;
@@ -1491,20 +1636,19 @@ var Batch = class Batch {
 		this.#unskipped_branches.add(effect);
 	}
 	#process() {
+		this.#started = true;
 		if (flush_count++ > 1e3) {
-			batches.delete(this);
+			this.#unlink();
 			infinite_loop_guard();
 		}
-		if (!this.#is_deferred()) {
-			for (const e of this.#dirty_effects) {
-				this.#maybe_dirty_effects.delete(e);
-				set_signal_status(e, DIRTY);
-				this.schedule(e);
-			}
-			for (const e of this.#maybe_dirty_effects) {
-				set_signal_status(e, MAYBE_DIRTY);
-				this.schedule(e);
-			}
+		for (const e of this.#dirty_effects) {
+			this.#maybe_dirty_effects.delete(e);
+			set_signal_status(e, DIRTY);
+			this.schedule(e);
+		}
+		for (const e of this.#maybe_dirty_effects) {
+			set_signal_status(e, MAYBE_DIRTY);
+			this.schedule(e);
 		}
 		const roots = this.#roots;
 		this.#roots = [];
@@ -1522,6 +1666,7 @@ var Batch = class Batch {
 			this.#traverse(root, effects, render_effects);
 		} catch (e) {
 			reset_all(root);
+			if (!this.#is_deferred()) this.discard();
 			throw e;
 		}
 		current_batch = null;
@@ -1531,29 +1676,37 @@ var Batch = class Batch {
 		}
 		collected_effects = null;
 		legacy_updates = null;
-		if (this.#is_deferred() || this.#is_blocked()) {
+		if (this.#is_deferred()) {
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
 			for (const [e, t] of this.#skipped_branches) reset_branch(e, t);
-		} else {
-			if (this.#pending.size === 0) batches.delete(this);
-			this.#dirty_effects.clear();
-			this.#maybe_dirty_effects.clear();
-			for (const fn of this.#commit_callbacks) fn(this);
-			this.#commit_callbacks.clear();
-			flush_queued_effects(render_effects);
-			flush_queued_effects(effects);
-			this.#deferred?.resolve();
+			if (updates.length > 0)
+ /** @type {Batch} */ current_batch.#process();
+			return;
 		}
+		const earlier_batch = this.#find_earlier_batch();
+		if (earlier_batch) {
+			this.#defer_effects(render_effects);
+			this.#defer_effects(effects);
+			earlier_batch.#merge(this);
+			return;
+		}
+		this.#dirty_effects.clear();
+		this.#maybe_dirty_effects.clear();
+		for (const fn of this.#commit_callbacks) fn(this);
+		this.#commit_callbacks.clear();
+		previous_batch = this;
+		flush_queued_effects(render_effects);
+		flush_queued_effects(effects);
+		previous_batch = null;
+		this.#deferred?.resolve();
 		var next_batch = current_batch;
-		if (this.#roots.length > 0) {
-			const batch = next_batch ??= this;
+		if (this.#pending === 0 && (this.#roots.length === 0 || next_batch !== null)) this.#unlink();
+		if (this.#roots.length > 0) if (next_batch !== null) {
+			const batch = next_batch;
 			batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
-		}
-		if (next_batch !== null) {
-			batches.add(next_batch);
-			next_batch.#process();
-		}
+		} else next_batch = this;
+		if (next_batch !== null) next_batch.#process();
 	}
 	/**
 	* Traverse the effect tree, executing effects or stashing
@@ -1591,6 +1744,59 @@ var Batch = class Batch {
 			}
 		}
 	}
+	#find_earlier_batch() {
+		var batch = this.#prev;
+		while (batch !== null) {
+			if (!batch.is_fork) {
+				for (const [value, [, is_derived]] of this.current) if (batch.current.has(value) && !is_derived) return batch;
+			}
+			batch = batch.#prev;
+		}
+		return null;
+	}
+	/**
+	* @param {Batch} batch
+	*/
+	#merge(batch) {
+		for (const [source, value] of batch.current) {
+			if (!this.previous.has(source) && batch.previous.has(source)) this.previous.set(source, batch.previous.get(source));
+			this.current.set(source, value);
+		}
+		for (const [effect, deferred] of batch.async_deriveds) {
+			const d = this.async_deriveds.get(effect);
+			if (d) deferred.promise.then(d.resolve).catch(d.reject);
+		}
+		this.transfer_effects(batch.#dirty_effects, batch.#maybe_dirty_effects);
+		/**
+		* mark all effects that depend on `batch.current`, except the
+		* async effects that we just resolved (TODO unless they depend
+		* on values in this batch that are NOT in the later batch?).
+		* Through this we also will populate the correct #skipped_branches,
+		* oncommit callbacks etc, so we don't need to merge them separately.
+		* @param {Value} value
+		*/
+		const mark = (value) => {
+			var reactions = value.reactions;
+			if (reactions === null) return;
+			for (const reaction of reactions) {
+				var flags = reaction.f;
+				if ((flags & 2) !== 0) mark(reaction);
+				else {
+					var effect = reaction;
+					if (flags & 4194320 && !this.async_deriveds.has(effect)) {
+						this.#maybe_dirty_effects.delete(effect);
+						set_signal_status(effect, DIRTY);
+						this.schedule(effect);
+					}
+				}
+			}
+		};
+		for (const source of this.current.keys()) mark(source);
+		this.oncommit(() => batch.discard());
+		batch.#unlink();
+		current_batch = this;
+		this.#process();
+	}
 	/**
 	* @param {Effect[]} effects
 	*/
@@ -1638,8 +1844,8 @@ var Batch = class Batch {
 	discard() {
 		for (const fn of this.#discard_callbacks) fn(this);
 		this.#discard_callbacks.clear();
-		this.#fork_commit_callbacks.clear();
-		batches.delete(this);
+		this.#unlink();
+		this.#deferred?.resolve();
 	}
 	/**
 	* @param {Effect} effect
@@ -1648,7 +1854,7 @@ var Batch = class Batch {
 		this.#new_effects.push(effect);
 	}
 	#commit() {
-		for (const batch of batches) {
+		for (let batch = first_batch; batch !== null; batch = batch.#next) {
 			var is_earlier = batch.id < this.id;
 			/** @type {Source[]} */
 			var sources = [];
@@ -1660,7 +1866,12 @@ var Batch = class Batch {
 				}
 				sources.push(source);
 			}
-			var others = [...batch.current.keys()].filter((s) => !this.current.has(s));
+			if (is_earlier) for (const [effect, deferred] of this.async_deriveds) {
+				const d = batch.async_deriveds.get(effect);
+				if (d) deferred.promise.then(d.resolve).catch(d.reject);
+			}
+			if (!batch.#started) continue;
+			var others = [...batch.current.keys()].filter((s) => !batch.current.get(s)[1] && !this.current.has(s));
 			if (others.length === 0) {
 				if (is_earlier) batch.discard();
 			} else if (sources.length > 0) {
@@ -1675,12 +1886,18 @@ var Batch = class Batch {
 				var checked = /* @__PURE__ */ new Map();
 				for (var source of sources) mark_effects(source, others, marked, checked);
 				checked = /* @__PURE__ */ new Map();
-				var current_unequal = [...batch.current.keys()].filter((c) => this.current.has(c) ? this.current.get(c)[0] !== c : true);
-				for (const effect of this.#new_effects) if ((effect.f & 155648) === 0 && depends_on(effect, current_unequal, checked)) if ((effect.f & 4194320) !== 0) {
-					set_signal_status(effect, DIRTY);
-					batch.schedule(effect);
-				} else batch.#dirty_effects.add(effect);
-				if (batch.#roots.length > 0) {
+				var current_unequal = [...batch.current].filter(([c, v1]) => {
+					const v2 = this.current.get(c);
+					if (!v2) return true;
+					return v2[0] !== v1[0] || v2[1] !== v1[1];
+				}).map(([c]) => c);
+				if (current_unequal.length > 0) {
+					for (const effect of this.#new_effects) if ((effect.f & 155648) === 0 && depends_on(effect, current_unequal, checked)) if ((effect.f & 4194320) !== 0) {
+						set_signal_status(effect, DIRTY);
+						batch.schedule(effect);
+					} else batch.#dirty_effects.add(effect);
+				}
+				if (batch.#roots.length > 0 && !batch.#decrement_queued) {
 					batch.apply();
 					for (var root of batch.#roots) batch.#traverse(root, [], []);
 					batch.#roots = [];
@@ -1688,21 +1905,13 @@ var Batch = class Batch {
 				batch.deactivate();
 			}
 		}
-		for (const batch of batches) if (batch.#blockers.has(this)) {
-			batch.#blockers.delete(this);
-			if (batch.#blockers.size === 0 && !batch.#is_deferred()) {
-				batch.activate();
-				batch.#process();
-			}
-		}
 	}
 	/**
 	* @param {boolean} blocking
 	* @param {Effect} effect
 	*/
 	increment(blocking, effect) {
-		let pending_count = this.#pending.get(effect) ?? 0;
-		this.#pending.set(effect, pending_count + 1);
+		this.#pending += 1;
 		if (blocking) {
 			let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
 			this.#blocking_pending.set(effect, blocking_pending_count + 1);
@@ -1711,22 +1920,19 @@ var Batch = class Batch {
 	/**
 	* @param {boolean} blocking
 	* @param {Effect} effect
-	* @param {boolean} skip - whether to skip updates (because this is triggered by a stale reaction)
 	*/
-	decrement(blocking, effect, skip) {
-		let pending_count = this.#pending.get(effect) ?? 0;
-		if (pending_count === 1) this.#pending.delete(effect);
-		else this.#pending.set(effect, pending_count - 1);
+	decrement(blocking, effect) {
+		this.#pending -= 1;
 		if (blocking) {
 			let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
 			if (blocking_pending_count === 1) this.#blocking_pending.delete(effect);
 			else this.#blocking_pending.set(effect, blocking_pending_count - 1);
 		}
-		if (this.#decrement_queued || skip) return;
+		if (this.#decrement_queued) return;
 		this.#decrement_queued = true;
 		queue_micro_task(() => {
 			this.#decrement_queued = false;
-			this.flush();
+			if (this.linked) this.flush();
 		});
 	}
 	/**
@@ -1747,34 +1953,20 @@ var Batch = class Batch {
 	ondiscard(fn) {
 		this.#discard_callbacks.add(fn);
 	}
-	/** @param {(batch: Batch) => void} fn */
-	on_fork_commit(fn) {
-		this.#fork_commit_callbacks.add(fn);
-	}
-	run_fork_commit_callbacks() {
-		for (const fn of this.#fork_commit_callbacks) fn(this);
-		this.#fork_commit_callbacks.clear();
-	}
 	settled() {
 		return (this.#deferred ??= deferred()).promise;
 	}
 	static ensure() {
 		if (current_batch === null) {
 			const batch = current_batch = new Batch();
-			if (!is_processing) {
-				batches.add(current_batch);
-				if (!is_flushing_sync) queue_micro_task(() => {
-					if (current_batch !== batch) return;
-					batch.flush();
-				});
-			}
+			if (!is_processing && !is_flushing_sync) queue_micro_task(() => {
+				if (!batch.#started) batch.flush();
+			});
 		}
 		return current_batch;
 	}
 	apply() {
 		batch_values = null;
-		return;
-		var intersects, differs;
 	}
 	/**
 	*
@@ -1800,6 +1992,16 @@ var Batch = class Batch {
 		}
 		this.#roots.push(e);
 	}
+	#unlink() {
+		if (!this.linked) return;
+		var prev = this.#prev;
+		var next = this.#next;
+		if (prev === null) first_batch = next;
+		else prev.#next = next;
+		if (next === null) last_batch = prev;
+		else next.#prev = prev;
+		this.linked = false;
+	}
 };
 /**
 * Synchronously flush any pending updates.
@@ -2025,9 +2227,9 @@ function createSubscriber(start) {
 /** @import { Effect, Source, TemplateNode, } from '#client' */
 /**
 * @typedef {{
-* 	 onerror?: (error: unknown, reset: () => void) => void;
-*   failed?: (anchor: Node, error: () => unknown, reset: () => () => void) => void;
-*   pending?: (anchor: Node) => void;
+* 	 onerror?: ((error: unknown, reset: () => void) => void) | null;
+*   failed?: ((anchor: Node, error: () => unknown, reset: () => () => void) => void) | null;
+*   pending?: ((anchor: Node) => void) | null;
 * }} BoundaryProps
 */
 var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
@@ -2276,7 +2478,7 @@ var Boundary = class {
 			if (this.#main_effect) current_batch.skip_effect(this.#main_effect);
 			if (this.#pending_effect) current_batch.skip_effect(this.#pending_effect);
 			if (this.#failed_effect) current_batch.skip_effect(this.#failed_effect);
-			current_batch.on_fork_commit(() => {
+			current_batch.oncommit(() => {
 				this.#handle_error(error);
 			});
 		} else this.#handle_error(error);
@@ -2382,7 +2584,7 @@ function execute_derived(derived) {
 	var value;
 	var prev_active_effect = active_effect;
 	var parent = derived.parent;
-	if (!is_destroying_effect && parent !== null && (parent.f & 24576) !== 0) {
+	if (!is_destroying_effect && parent !== null && derived.v !== UNINITIALIZED && (parent.f & 24576) !== 0) {
 		derived_inert();
 		return derived.v;
 	}
@@ -2405,8 +2607,10 @@ function update_derived(derived) {
 	if (!derived.equals(value)) {
 		derived.wv = increment_write_version();
 		if (!current_batch?.is_fork || derived.deps === null) {
-			if (current_batch !== null) current_batch.capture(derived, value, true);
-			else derived.v = value;
+			if (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;
@@ -2426,7 +2630,7 @@ function freeze_derived_effects(derived) {
 	for (const e of derived.effects) if (e.teardown || e.ac) {
 		e.teardown?.();
 		e.ac?.abort(STALE_REACTION);
-		e.teardown = noop;
+		if (e.fn !== null) e.teardown = noop;
 		e.ac = null;
 		remove_reactions(e, 0);
 		destroy_effect_children(e);
@@ -2437,10 +2641,10 @@ function freeze_derived_effects(derived) {
 */
 function unfreeze_derived_effects(derived) {
 	if (derived.effects === null) return;
-	for (const e of derived.effects) if (e.teardown) update_effect(e);
+	for (const e of derived.effects) if (e.teardown && e.fn !== null) update_effect(e);
 }
 /** @import { Derived, Effect, Source, Value } from '#client' */
-/** @type {Set<any>} */
+/** @type {Set<Effect>} */
 var eager_effects = /* @__PURE__ */ new Set();
 /** @type {Map<Source, any>} */
 var old_values = /* @__PURE__ */ new Map();
@@ -2466,7 +2670,7 @@ function source(v, stack) {
 * @param {V} v
 * @param {Error | null} [stack]
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*#__NO_SIDE_EFFECTS__*/
 function state(v, stack) {
 	const s = source(v, stack);
 	push_reaction_value(s);
@@ -2478,7 +2682,7 @@ function state(v, stack) {
 * @param {boolean} [immutable]
 * @returns {Source<V>}
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*#__NO_SIDE_EFFECTS__*/
 function mutable_source(initial_value, immutable = false, trackable = true) {
 	const s = source(initial_value);
 	if (!immutable) s.equals = safe_equals;
@@ -2493,7 +2697,7 @@ function mutable_source(initial_value, immutable = false, trackable = true) {
 * @returns {V}
 */
 function set(source, value, should_proxy = false) {
-	if (active_reaction !== null && (!untracking || (active_reaction.f & 131072) !== 0) && is_runes() && (active_reaction.f & 4325394) !== 0 && (current_sources === null || !includes.call(current_sources, source))) state_unsafe_mutation();
+	if (active_reaction !== null && (!untracking || (active_reaction.f & 131072) !== 0) && is_runes() && (active_reaction.f & 4325394) !== 0 && (current_sources === null || !current_sources.has(source))) state_unsafe_mutation();
 	return internal_set(source, should_proxy ? proxy(value) : value, legacy_updates);
 }
 /**
@@ -2525,7 +2729,13 @@ function flush_eager_effects() {
 	eager_effects_deferred = false;
 	for (const effect of eager_effects) {
 		if ((effect.f & 1024) !== 0) set_signal_status(effect, MAYBE_DIRTY);
-		if (is_dirty(effect)) update_effect(effect);
+		let dirty;
+		try {
+			dirty = is_dirty(effect);
+		} catch {
+			dirty = true;
+		}
+		if (dirty) update_effect(effect);
 	}
 	eager_effects.clear();
 }
@@ -2553,11 +2763,12 @@ function mark_reactions(signal, status, updated_during_traversal) {
 		if (!runes && reaction === active_effect) continue;
 		var not_dirty = (flags & DIRTY) === 0;
 		if (not_dirty) set_signal_status(reaction, status);
-		if ((flags & 2) !== 0) {
+		if ((flags & 131072) !== 0) eager_effects.add(reaction);
+		else if ((flags & 2) !== 0) {
 			var derived = reaction;
 			batch_values?.delete(derived);
 			if ((flags & 65536) === 0) {
-				if (flags & 512) reaction.f |= WAS_MARKED;
+				if (flags & 512 && (active_effect === null || (active_effect.f & 2097152) === 0)) reaction.f |= WAS_MARKED;
 				mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
 			}
 		} else if (not_dirty) {
@@ -2746,13 +2957,13 @@ function init_operations() {
 	first_child_getter = get_descriptor(node_prototype, "firstChild").get;
 	next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
 	if (is_extensible(element_prototype)) {
-		element_prototype.__click = void 0;
-		element_prototype.__className = void 0;
-		element_prototype.__attributes = null;
-		element_prototype.__style = void 0;
+		/** @type {any} */ element_prototype[CLASS_CACHE] = void 0;
+		/** @type {any} */ element_prototype[ATTRIBUTES_CACHE] = null;
+		/** @type {any} */ element_prototype[STYLE_CACHE] = void 0;
 		element_prototype.__e = void 0;
 	}
-	if (is_extensible(text_prototype)) text_prototype.__t = void 0;
+	if (is_extensible(text_prototype))
+ /** @type {any} */ text_prototype[TEXT_CACHE] = void 0;
 }
 /**
 * @param {string} value
@@ -2765,7 +2976,7 @@ function create_text(value = "") {
 * @template {Node} N
 * @param {N} node
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*@__NO_SIDE_EFFECTS__*/
 function get_first_child(node) {
 	return first_child_getter.call(node);
 }
@@ -2773,7 +2984,7 @@ function get_first_child(node) {
 * @template {Node} N
 * @param {N} node
 */
-/* @__NO_SIDE_EFFECTS__ */
+/*@__NO_SIDE_EFFECTS__*/
 function get_next_sibling(node) {
 	return next_sibling_getter.call(node);
 }
@@ -2981,7 +3192,7 @@ function destroy_effect(effect, remove_dom = true) {
 		remove_effect_dom(effect.nodes.start, effect.nodes.end);
 		removed = true;
 	}
-	set_signal_status(effect, DESTROYING);
+	effect.f |= DESTROYING;
 	destroy_effect_children(effect, remove_dom && !removed);
 	remove_reactions(effect, 0);
 	var transitions = effect.nodes && effect.nodes.t;
@@ -3061,8 +3272,10 @@ function pause_children(effect, transitions, local) {
 	var child = effect.first;
 	while (child !== null) {
 		var sibling = child.next;
-		var transparent = (child.f & 65536) !== 0 || (child.f & 32) !== 0 && (effect.f & 16) !== 0;
-		pause_children(child, transitions, transparent ? local : false);
+		if ((child.f & 64) === 0) {
+			var transparent = (child.f & 65536) !== 0 || (child.f & 32) !== 0 && (effect.f & 16) !== 0;
+			pause_children(child, transitions, transparent ? local : false);
+		}
 		child = sibling;
 	}
 }
@@ -3110,13 +3323,12 @@ function set_active_effect(effect) {
 /**
 * When sources are created within a reaction, reading and writing
 * them within that reaction should not cause a re-run
-* @type {null | Source[]}
+* @type {null | Set<Source>}
 */
 var current_sources = null;
 /** @param {Value} value */
 function push_reaction_value(value) {
-	if (active_reaction !== null && true) if (current_sources === null) current_sources = [value];
-	else current_sources.push(value);
+	if (active_reaction !== null && true) (current_sources ??= /* @__PURE__ */ new Set()).add(value);
 }
 /**
 * The dependencies of the reaction that is currently being executed. In many cases,
@@ -3181,7 +3393,7 @@ function is_dirty(reaction) {
 function schedule_possible_effect_self_invalidation(signal, effect, root = true) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
-	if (current_sources !== null && includes.call(current_sources, signal)) return;
+	if (current_sources !== null && current_sources.has(signal)) return;
 	for (var i = 0; i < reactions.length; i++) {
 		var reaction = reactions[i];
 		if ((reaction.f & 2) !== 0) schedule_possible_effect_self_invalidation(reaction, effect, false);
@@ -3333,7 +3545,7 @@ function get(signal) {
 	var is_derived = (signal.f & 2) !== 0;
 	captured_signals?.add(signal);
 	if (active_reaction !== null && !untracking) {
-		if (!(active_effect !== null && (active_effect.f & 16384) !== 0) && (current_sources === null || !includes.call(current_sources, signal))) {
+		if (!(active_effect !== null && (active_effect.f & 16384) !== 0) && (current_sources === null || !current_sources.has(signal))) {
 			var deps = active_reaction.deps;
 			if ((active_reaction.f & 2097152) !== 0) {
 				if (signal.rv < read_version) {
@@ -3343,7 +3555,8 @@ function get(signal) {
 					else new_deps.push(signal);
 				}
 			} else {
-				(active_reaction.deps ??= []).push(signal);
+				active_reaction.deps ??= [];
+				if (!includes.call(active_reaction.deps, signal)) active_reaction.deps.push(signal);
 				var reactions = signal.reactions;
 				if (reactions === null) signal.reactions = [active_reaction];
 				else if (!includes.call(reactions, active_reaction)) reactions.push(active_reaction);
@@ -3536,7 +3749,7 @@ var RAW_TEXT_ELEMENTS = [
 function is_raw_text_element(name) {
 	return RAW_TEXT_ELEMENTS.includes(name);
 }
-var REGEX_VALID_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]+)*$/u;
+var REGEX_VALID_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]*)?$/u;
 var INVALID_ATTR_NAME_CHAR_REGEX = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
 /**
 * @param {Renderer} renderer
@@ -3582,7 +3795,7 @@ function render(component, options = {}) {
 */
 function attributes(attrs, css_hash, classes, styles, flags = 0) {
 	if (styles) attrs.style = to_style(attrs.style, styles);
-	if (attrs.class) attrs.class = clsx(attrs.class);
+	if (attrs.class) attrs.class = clsx$1(attrs.class);
 	if (css_hash || classes) attrs.class = to_class(attrs.class, css_hash, classes);
 	let attr_str = "";
 	let name;
@@ -3592,7 +3805,7 @@ function attributes(attrs, css_hash, classes, styles, flags = 0) {
 	for (name of Object.keys(attrs)) {
 		if (typeof attrs[name] === "function") continue;
 		if (name[0] === "$" && name[1] === "$") continue;
-		if (INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
+		if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
 		var value = attrs[name];
 		var lower = name.toLowerCase();
 		if (lowercase) name = lower;
@@ -3707,6 +3920,16 @@ function once(get_value) {
 	};
 }
 /**
+* Create an unique ID
+* @param {Renderer} renderer
+* @returns {string}
+*/
+function props_id(renderer) {
+	const uid = renderer.global.uid();
+	renderer.push("<!--$" + uid + "-->");
+	return uid;
+}
+/**
 * @template T
 * @param {()=>T} fn
 * @returns {(new_value?: T) => (T | void)}
@@ -4269,7 +4492,10 @@ var Renderer = class Renderer {
 			} catch (error) {
 				const { context, failed, transformError } = item.#boundary;
 				set_ssr_context(context);
-				let transformed = await transformError(error);
+				let promise = transformError(error);
+				set_ssr_context(null);
+				let transformed = await promise;
+				set_ssr_context(context);
 				const failed_renderer = new Renderer(item.global, item);
 				failed_renderer.type = item.type;
 				failed_renderer.#out.push(Renderer.#serialize_failed_boundary(transformed));
@@ -4423,7 +4649,252 @@ var SSRState = class {
 		}
 	}
 };
+/** @import { HydratableLookupEntry } from '#server' */
+/**
+* @template T
+* @param {string} key
+* @param {() => T} fn
+* @returns {T}
+*/
+function hydratable(key, fn) {
+	experimental_async_required("hydratable");
+	const { hydratable } = get_render_context();
+	let entry = hydratable.lookup.get(key);
+	if (entry !== void 0) return entry.value;
+	const value = fn();
+	entry = encode(key, value, hydratable.unresolved_promises);
+	hydratable.lookup.set(key, entry);
+	return value;
+}
+/**
+* @param {string} key
+* @param {any} value
+* @param {Map<Promise<any>, string>} [unresolved]
+*/
+function encode(key, value, unresolved) {
+	/** @type {HydratableLookupEntry} */
+	const entry = {
+		value,
+		serialized: ""
+	};
+	let uid = 1;
+	entry.serialized = uneval(entry.value, (value, uneval) => {
+		if (is_promise(value)) {
+			const placeholder = `"${uid++}"`;
+			const p = value.then((v) => {
+				entry.serialized = entry.serialized.replace(placeholder, () => `r(${uneval(v)})`);
+			}).catch((devalue_error) => hydratable_serialization_failed(key, serialization_stack(entry.stack, devalue_error?.stack)));
+			unresolved?.set(p, key);
+			p.catch(() => {}).finally(() => unresolved?.delete(p));
+			(entry.promises ??= []).push(p);
+			return placeholder;
+		}
+	});
+	return entry;
+}
+/**
+* @param {any} value
+* @returns {value is Promise<any>}
+*/
+function is_promise(value) {
+	return Object.prototype.toString.call(value) === "[object Promise]";
+}
+/**
+* @param {string | undefined} root_stack
+* @param {string | undefined} uneval_stack
+*/
+function serialization_stack(root_stack, uneval_stack) {
+	let out = "";
+	if (root_stack) out += root_stack + "\n";
+	if (uneval_stack) out += "Caused by:\n" + uneval_stack + "\n";
+	return out || "<missing stack trace>";
+}
+/** @import { Snippet } from 'svelte' */
+/** @import { Renderer } from '../renderer' */
+/** @import { Getters } from '#shared' */
+/**
+* Create a snippet programmatically
+* @template {unknown[]} Params
+* @param {(...params: Getters<Params>) => {
+*   render: () => string
+*   setup?: (element: Element) => void | (() => void)
+* }} fn
+* @returns {Snippet<Params>}
+*/
+function createRawSnippet(fn) {
+	return (renderer, ...args) => {
+		var getters = args.map((value) => () => value);
+		renderer.push(fn(...getters).render().trim());
+	};
+}
+/** @import { SSRContext } from '#server' */
+/** @import { Renderer } from './internal/server/renderer.js' */
+var index_server_exports = /* @__PURE__ */ __exportAll({
+	afterUpdate: () => noop,
+	beforeUpdate: () => noop,
+	createContext: () => createContext,
+	createEventDispatcher: () => createEventDispatcher,
+	createRawSnippet: () => createRawSnippet,
+	flushSync: () => noop,
+	fork: () => fork,
+	getAbortSignal: () => getAbortSignal,
+	getAllContexts: () => getAllContexts,
+	getContext: () => getContext,
+	hasContext: () => hasContext,
+	hydratable: () => hydratable,
+	hydrate: () => hydrate,
+	mount: () => mount,
+	onDestroy: () => onDestroy,
+	onMount: () => noop,
+	setContext: () => setContext,
+	settled: () => settled,
+	tick: () => tick,
+	unmount: () => unmount,
+	untrack: () => run
+});
+/** @param {() => void} fn */
+function onDestroy(fn) {
+	/** @type {Renderer} */ ssr_context.r.on_destroy(fn);
+}
+function createEventDispatcher() {
+	return noop;
+}
+function mount() {
+	lifecycle_function_unavailable("mount");
+}
+function hydrate() {
+	lifecycle_function_unavailable("hydrate");
+}
+function unmount() {
+	lifecycle_function_unavailable("unmount");
+}
+function fork() {
+	lifecycle_function_unavailable("fork");
+}
+async function tick() {}
+async function settled() {}
+//#endregion
+//#region .svelte-kit/adapter-bun/chunks/events.js
+/**
+* Used on elements, as a map of event type -> event handler,
+* and on events themselves to track which element handled an event
+*/
+var event_symbol = Symbol("events");
+/** @type {Set<string>} */
+var all_registered_events = /* @__PURE__ */ new Set();
+/** @type {Set<(events: Array<string>) => void>} */
+var root_event_handles = /* @__PURE__ */ new Set();
+/**
+* @param {string} event_name
+* @param {EventTarget} dom
+* @param {EventListener} [handler]
+* @param {AddEventListenerOptions} [options]
+*/
+function create_event(event_name, dom, handler, options = {}) {
+	/**
+	* @this {EventTarget}
+	*/
+	function target_handler(event) {
+		if (!options.capture) handle_event_propagation.call(dom, event);
+		if (!event.cancelBubble) return without_reactive_context(() => {
+			return handler?.call(this, event);
+		});
+	}
+	if (event_name.startsWith("pointer") || event_name.startsWith("touch") || event_name === "wheel") queue_micro_task(() => {
+		dom.addEventListener(event_name, target_handler, options);
+	});
+	else dom.addEventListener(event_name, target_handler, options);
+	return target_handler;
+}
+/**
+* Attaches an event handler to an element and returns a function that removes the handler. Using this
+* rather than `addEventListener` will preserve the correct order relative to handlers added declaratively
+* (with attributes like `onclick`), which use event delegation for performance reasons
+*
+* @param {EventTarget} element
+* @param {string} type
+* @param {EventListener} handler
+* @param {AddEventListenerOptions} [options]
+*/
+function on(element, type, handler, options = {}) {
+	var target_handler = create_event(type, element, handler, options);
+	return () => {
+		element.removeEventListener(type, target_handler, options);
+	};
+}
+var last_propagated_event = null;
+/**
+* @this {EventTarget}
+* @param {Event} event
+* @returns {void}
+*/
+function handle_event_propagation(event) {
+	var handler_element = this;
+	var owner_document = handler_element.ownerDocument;
+	var event_name = event.type;
+	var path = event.composedPath?.() || [];
+	var current_target = path[0] || event.target;
+	last_propagated_event = event;
+	var path_idx = 0;
+	var handled_at = last_propagated_event === event && event[event_symbol];
+	if (handled_at) {
+		var at_idx = path.indexOf(handled_at);
+		if (at_idx !== -1 && (handler_element === document || handler_element === window)) {
+			event[event_symbol] = handler_element;
+			return;
+		}
+		var handler_idx = path.indexOf(handler_element);
+		if (handler_idx === -1) return;
+		if (at_idx <= handler_idx) path_idx = at_idx;
+	}
+	current_target = path[path_idx] || event.target;
+	if (current_target === handler_element) return;
+	define_property(event, "currentTarget", {
+		configurable: true,
+		get() {
+			return current_target || owner_document;
+		}
+	});
+	var previous_reaction = active_reaction;
+	var previous_effect = active_effect;
+	set_active_reaction(null);
+	set_active_effect(null);
+	try {
+		/**
+		* @type {unknown}
+		*/
+		var throw_error;
+		/**
+		* @type {unknown[]}
+		*/
+		var other_errors = [];
+		while (current_target !== null) {
+			if (current_target === handler_element) break;
+			try {
+				var delegated = current_target[event_symbol]?.[event_name];
+				if (delegated != null && (!current_target.disabled || event.target === current_target)) delegated.call(current_target, event);
+			} catch (error) {
+				if (throw_error) other_errors.push(error);
+				else throw_error = error;
+			}
+			if (event.cancelBubble) break;
+			path_idx++;
+			current_target = path_idx < path.length ? path[path_idx] : null;
+		}
+		if (throw_error) {
+			for (let error of other_errors) queueMicrotask(() => {
+				throw error;
+			});
+			throw throw_error;
+		}
+	} finally {
+		event[event_symbol] = handler_element;
+		delete event.currentTarget;
+		set_active_reaction(previous_reaction);
+		set_active_effect(previous_effect);
+	}
+}
 //#endregion
-export { render_effect as $, getAllContexts as A, hydration_failed as B, ensure_array_like as C, flushSync as D, experimental_async_required as E, get_type as F, is_primitive as G, init_operations as H, hasContext as I, noop as J, lifecycle_function_unavailable as K, hydratable_serialization_failed as L, get_first_child as M, get_next_sibling as N, get as O, get_render_context as P, render as Q, hydrate_node as R, element as S, escape_html as T, is_passive_event as U, hydration_mismatch as V, is_plain_object as W, push as X, pop as Y, readable as Z, component_root as _, writable as _t, active_reaction as a, set_hydrate_node as at, define_property as b, attr_class as c, ssr_context as ct, bind_props as d, stringify as dt, run as et, boundary as f, stringify_key as ft, component_context as g, valid_array_indices as gt, clsx$1 as h, unsubscribe_stores as ht, active_effect as i, set_active_reaction as it, getContext as j, getAbortSignal as k, attr_style as l, state as lt, clsx as m, uneval as mt, HYDRATION_ERROR as n, setContext as nt, array_from as o, set_hydrating as ot, clear_text_content as p, stringify_string as pt, mutable_source as q, LEGACY_PROPS as r, set_active_effect as rt, attr as s, spread_props as st, DevalueError as t, set as tt, attributes as u, store_get as ut, createContext as v, enumerable_symbols as w, derived as x, create_text as y, hydrating as z };
+export { onDestroy as $, flushSync as A, hydrating as B, define_property as C, clsx as Ct, ensure_array_like as D, element as E, get_first_child as F, is_passive_event as G, hydration_mismatch as H, get_next_sibling as I, is_valid_array_index as J, is_plain_object as K, get_type as L, get$1 as M, getAllContexts as N, enumerable_symbols as O, getContext as P, noop as Q, hasContext as R, create_text as S, writable as St, derived$1 as T, index_server_exports as U, hydration_failed as V, init_operations as W, mount as X, is_valid_array_len as Y, mutable_source as Z, boundary as _, to_array as _t, ATTACHMENT_KEY as a, render as at, component_context as b, unsubscribe_stores as bt, LEGACY_PROPS as c, setContext as ct, array_from as d, spread_props as dt, pop as et, attr as f, store_get as ft, bind_props as g, tick as gt, attributes as h, stringify_string as ht, root_event_handles as i, readonly as it, get as j, escape_html as k, MAX_ARRAY_INDEX as l, set_hydrate_node as lt, attr_style as m, stringify_key as mt, handle_event_propagation as n, push as nt, DevalueError as o, run as ot, attr_class as p, stringify as pt, is_primitive as q, on as r, readable as rt, HYDRATION_ERROR as s, set as st, all_registered_events as t, props_id as tt, active_effect as u, set_hydrating as ut, clear_text_content as v, uneval as vt, derived as w, component_root as x, valid_array_indices as xt, clsx$1 as y, unmount as yt, hydrate_node as z };
 
-//# sourceMappingURL=dev-7V6fUCff.js.map
+//# sourceMappingURL=events-DeYJGjCt.js.map