@agent-profile/web 0.3.4 → 0.4.0

package/build/server/chunks/dev-BdIdjvaY.js

@@ -1,4692 +0,0 @@
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
-const SPARSE = -7;
-
-// The largest valid value for a JavaScript array's `length` property,
-// and the largest valid array index (one less than the max length).
-const MAX_ARRAY_LEN = 2 ** 32 - 1;
-const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
-
-/** @type {Record<string, string>} */
-const escaped = {
-	'<': '\\u003C',
-	'\\': '\\\\',
-	'\b': '\\b',
-	'\f': '\\f',
-	'\n': '\\n',
-	'\r': '\\r',
-	'\t': '\\t',
-	'\u2028': '\\u2028',
-	'\u2029': '\\u2029'
-};
-
-class DevalueError extends Error {
-	/**
-	 * @param {string} message
-	 * @param {string[]} keys
-	 * @param {any} [value] - The value that failed to be serialized
-	 * @param {any} [root] - The root value being serialized
-	 */
-	constructor(message, keys, value, root) {
-		super(message);
-		this.name = 'DevalueError';
-		this.path = keys.join('');
-		this.value = value;
-		this.root = root;
-	}
-}
-
-/** @param {any} thing */
-function is_primitive(thing) {
-	return thing === null || (typeof thing !== 'object' && typeof thing !== 'function');
-}
-
-const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype)
-	.sort()
-	.join('\0');
-
-/** @param {any} thing */
-function is_plain_object(thing) {
-	const proto = Object.getPrototypeOf(thing);
-
-	return (
-		proto === Object.prototype ||
-		proto === null ||
-		Object.getPrototypeOf(proto) === null ||
-		Object.getOwnPropertyNames(proto).sort().join('\0') === object_proto_names
-	);
-}
-
-/** @param {any} thing */
-function get_type(thing) {
-	return Object.prototype.toString.call(thing).slice(8, -1);
-}
-
-/** @param {string} char */
-function get_escaped_char(char) {
-	switch (char) {
-		case '"':
-			return '\\"';
-		case '<':
-			return '\\u003C';
-		case '\\':
-			return '\\\\';
-		case '\n':
-			return '\\n';
-		case '\r':
-			return '\\r';
-		case '\t':
-			return '\\t';
-		case '\b':
-			return '\\b';
-		case '\f':
-			return '\\f';
-		case '\u2028':
-			return '\\u2028';
-		case '\u2029':
-			return '\\u2029';
-		default:
-			return char < ' ' ? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}` : '';
-	}
-}
-
-/** @param {string} str */
-function stringify_string(str) {
-	let result = '';
-	let last_pos = 0;
-	const len = str.length;
-
-	for (let i = 0; i < len; i += 1) {
-		const char = str[i];
-		const replacement = get_escaped_char(char);
-		if (replacement) {
-			result += str.slice(last_pos, i) + replacement;
-			last_pos = i + 1;
-		}
-	}
-
-	return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
-}
-
-/** @param {Record<string | symbol, any>} object */
-function enumerable_symbols(object) {
-	return Object.getOwnPropertySymbols(object).filter(
-		(symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable
-	);
-}
-
-const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
-
-/** @param {string} key */
-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_string(s) {
-	if (s.length === 0) return false;
-	if (s.length > 1 && s.charCodeAt(0) === 48) return false; // leading zero
-	for (let i = 0; i < s.length; i++) {
-		const c = s.charCodeAt(i);
-		if (c < 48 || c > 57) return false;
-	}
-	// by this point we know it's a string of digits, but it has to be within
-	// the range of valid array indices
-	return is_valid_array_index(+s);
-}
-
-/**
- * Finds the populated indices of an array.
- * @param {unknown[]} array
- */
-function valid_array_indices(array) {
-	const keys = Object.keys(array);
-	for (var i = keys.length - 1; i >= 0; i--) {
-		if (is_valid_array_index_string(keys[i])) {
-			break;
-		}
-	}
-	keys.length = i + 1;
-	return keys;
-}
-
-const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
-const unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
-const reserved =
-	/^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
-
-/**
- * Turn a value into the JavaScript that creates an equivalent value
- * @param {any} value
- * @param {(value: any, uneval: (value: any) => string) => string | void} [replacer]
- */
-function uneval(value, replacer) {
-	const counts = new Map();
-
-	/** @type {string[]} */
-	const keys = [];
-
-	const custom = new Map();
-
-	/** @param {any} thing */
-	function walk(thing) {
-		if (!is_primitive(thing)) {
-			if (counts.has(thing)) {
-				counts.set(thing, counts.get(thing) + 1);
-				return;
-			}
-
-			counts.set(thing, 1);
-
-			if (replacer) {
-				const str = replacer(thing, (value) => uneval(value, replacer));
-
-				if (typeof str === 'string') {
-					custom.set(thing, str);
-					return;
-				}
-			}
-
-			if (typeof thing === 'function') {
-				throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-			}
-
-			const type = get_type(thing);
-
-			switch (type) {
-				case 'Number':
-				case 'BigInt':
-				case 'String':
-				case 'Boolean':
-				case 'Date':
-				case 'RegExp':
-				case 'URL':
-				case 'URLSearchParams':
-					return;
-
-				case 'Array':
-					/** @type {any[]} */ (thing).forEach((value, i) => {
-						keys.push(`[${i}]`);
-						walk(value);
-						keys.pop();
-					});
-					break;
-
-				case 'Set':
-					Array.from(thing).forEach(walk);
-					break;
-
-				case 'Map':
-					for (const [key, value] of thing) {
-						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`);
-						walk(value);
-						keys.pop();
-					}
-					break;
-
-				case 'Int8Array':
-				case 'Uint8Array':
-				case 'Uint8ClampedArray':
-				case 'Int16Array':
-				case 'Uint16Array':
-				case 'Float16Array':
-				case 'Int32Array':
-				case 'Uint32Array':
-				case 'Float32Array':
-				case 'Float64Array':
-				case 'BigInt64Array':
-				case 'BigUint64Array':
-				case 'DataView':
-					walk(thing.buffer);
-					return;
-
-				case 'ArrayBuffer':
-					return;
-
-				case 'Temporal.Duration':
-				case 'Temporal.Instant':
-				case 'Temporal.PlainDate':
-				case 'Temporal.PlainTime':
-				case 'Temporal.PlainDateTime':
-				case 'Temporal.PlainMonthDay':
-				case 'Temporal.PlainYearMonth':
-				case 'Temporal.ZonedDateTime':
-					return;
-
-				default:
-					if (!is_plain_object(thing)) {
-						throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
-					}
-
-					if (enumerable_symbols(thing).length > 0) {
-						throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
-					}
-
-					for (const key of Object.keys(thing)) {
-						if (key === '__proto__') {
-							throw new DevalueError(
-								`Cannot stringify objects with __proto__ keys`,
-								keys,
-								thing,
-								value
-							);
-						}
-
-						keys.push(stringify_key(key));
-						walk(thing[key]);
-						keys.pop();
-					}
-			}
-		} else if (typeof thing === 'symbol') {
-			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
-		}
-	}
-
-	walk(value);
-
-	const names = new Map();
-
-	Array.from(counts)
-		.filter((entry) => entry[1] > 1)
-		.sort((a, b) => b[1] - a[1])
-		.forEach((entry, i) => {
-			names.set(entry[0], get_name(i));
-		});
-
-	/**
-	 * @param {any} thing
-	 * @returns {string}
-	 */
-	function stringify(thing) {
-		if (names.has(thing)) {
-			return names.get(thing);
-		}
-
-		if (is_primitive(thing)) {
-			return stringify_primitive(thing);
-		}
-
-		if (custom.has(thing)) {
-			return custom.get(thing);
-		}
-
-		const type = get_type(thing);
-
-		switch (type) {
-			case 'Number':
-			case 'String':
-			case 'Boolean':
-			case 'BigInt':
-				return `Object(${stringify(thing.valueOf())})`;
-
-			case 'RegExp':
-				const { source, flags } = thing;
-				return flags
-					? `new RegExp(${stringify_string(source)},"${flags}")`
-					: `new RegExp(${stringify_string(source)})`;
-
-			case 'Date':
-				return `new Date(${thing.getTime()})`;
-
-			case 'URL':
-				return `new URL(${stringify_string(thing.toString())})`;
-
-			case 'URLSearchParams':
-				return `new URLSearchParams(${stringify_string(thing.toString())})`;
-
-			case 'Array': {
-				// For dense arrays (no holes), we iterate normally.
-				// When we encounter the first hole, we call Object.keys
-				// to determine the sparseness, then decide between:
-				//   - Array literal with holes: [,"a",,] (default)
-				//   - Object.assign: Object.assign(Array(n),{...}) (for very sparse arrays)
-				// Only the Object.assign path avoids iterating every slot, which
-				// is what protects against the DoS of e.g. `arr[1000000] = 1`.
-				let has_holes = false;
-
-				let result = '[';
-
-				for (let i = 0; i < thing.length; i += 1) {
-					if (i > 0) result += ',';
-
-					if (Object.hasOwn(thing, i)) {
-						result += stringify(thing[i]);
-					} else if (!has_holes) {
-						// Decide between array literal and Object.assign.
-						//
-						// Array literal: holes are consecutive commas.
-						// For example, [, "a", ,] is written as [,"a",,].
-						// Each hole costs 1 char (a comma).
-						//
-						// Object.assign: populated indices are listed explicitly.
-						// For example, [, "a", ,] would be written as
-						// Object.assign(Array(3),{1:"a"}). This avoids paying
-						// per-hole, but has a large fixed overhead for the
-						// "Object.assign(Array(n),{...})" wrapper, and each
-						// element costs extra chars for its index and colon.
-						//
-						// The serialized values are the same size either way, so
-						// the choice comes down to the structural overhead:
-						//
-						//   Array literal overhead:
-						//     1 char per element or hole (comma separators)
-						//     + 2 chars for "[" and "]"
-						//     = L + 2
-						//
-						//   Object.assign overhead:
-						//     "Object.assign(Array(" — 20 chars
-						//     + length              — d chars
-						//     + "),{"               — 3 chars
-						//     + for each populated element:
-						//       index + ":" + ","   — (d + 2) chars
-						//     + "})"                — 2 chars
-						//     = (25 + d) + P * (d + 2)
-						//
-						// where L is the array length, P is the number of
-						// populated elements, and d is the number of digits
-						// in L (an upper bound on the digits in any index).
-						//
-						// Object.assign is cheaper when:
-						//   (25 + d) + P * (d + 2) < L + 2
-						const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
-						const population = populated_keys.length;
-						const d = String(thing.length).length;
-
-						const hole_cost = thing.length + 2;
-						const sparse_cost = 25 + d + population * (d + 2);
-
-						if (hole_cost > sparse_cost) {
-							const entries = populated_keys.map((k) => `${k}:${stringify(thing[k])}`).join(',');
-							return `Object.assign(Array(${thing.length}),{${entries}})`;
-						}
-
-						// Re-process this index as a hole in the array literal
-						has_holes = true;
-						i -= 1;
-					}
-					// else: already decided on array literal, hole is just an empty slot
-					// (the comma separator is all we need — no content for this position)
-				}
-
-				const tail = thing.length === 0 || thing.length - 1 in thing ? '' : ',';
-				return result + tail + ']';
-			}
-
-			case 'Set':
-			case 'Map':
-				return `new ${type}([${Array.from(thing).map(stringify).join(',')}])`;
-
-			case 'Int8Array':
-			case 'Uint8Array':
-			case 'Uint8ClampedArray':
-			case 'Int16Array':
-			case 'Uint16Array':
-			case 'Float16Array':
-			case 'Int32Array':
-			case 'Uint32Array':
-			case 'Float32Array':
-			case 'Float64Array':
-			case 'BigInt64Array':
-			case 'BigUint64Array': {
-				let str = `new ${type}`;
-
-				if (!names.has(thing.buffer)) {
-					const array = new thing.constructor(thing.buffer);
-					str += `([${array}])`;
-				} else {
-					str += `(${stringify(thing.buffer)})`;
-				}
-
-				// handle subarrays
-				if (thing.byteLength !== thing.buffer.byteLength) {
-					const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
-					const end = start + thing.length;
-					str += `.subarray(${start},${end})`;
-				}
-
-				return str;
-			}
-
-			case 'DataView': {
-				let str = `new DataView`;
-
-				if (!names.has(thing.buffer)) {
-					str += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
-				} else {
-					str += `(${stringify(thing.buffer)}`;
-				}
-
-				// handle subviews
-				if (thing.byteLength !== thing.buffer.byteLength) {
-					str += `,${thing.startOffset},${thing.byteLength}`;
-				}
-
-				return str + ')';
-			}
-
-			case 'ArrayBuffer': {
-				const ui8 = new Uint8Array(thing);
-				return `new Uint8Array([${ui8.toString()}]).buffer`;
-			}
-
-			case 'Temporal.Duration':
-			case 'Temporal.Instant':
-			case 'Temporal.PlainDate':
-			case 'Temporal.PlainTime':
-			case 'Temporal.PlainDateTime':
-			case 'Temporal.PlainMonthDay':
-			case 'Temporal.PlainYearMonth':
-			case 'Temporal.ZonedDateTime':
-				return `${type}.from(${stringify_string(thing.toString())})`;
-
-			default:
-				const keys = Object.keys(thing);
-				const obj = keys.map((key) => `${safe_key(key)}:${stringify(thing[key])}`).join(',');
-				const proto = Object.getPrototypeOf(thing);
-				if (proto === null) {
-					return keys.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
-				}
-
-				return `{${obj}}`;
-		}
-	}
-
-	const str = stringify(value);
-
-	if (names.size) {
-		/** @type {string[]} */
-		const params = [];
-
-		/** @type {string[]} */
-		const statements = [];
-
-		/** @type {string[]} */
-		const values = [];
-
-		names.forEach((name, thing) => {
-			params.push(name);
-
-			if (custom.has(thing)) {
-				values.push(/** @type {string} */ (custom.get(thing)));
-				return;
-			}
-
-			if (is_primitive(thing)) {
-				values.push(stringify_primitive(thing));
-				return;
-			}
-
-			const type = get_type(thing);
-
-			switch (type) {
-				case 'Number':
-				case 'String':
-				case 'Boolean':
-				case 'BigInt':
-					values.push(`Object(${stringify(thing.valueOf())})`);
-					break;
-
-				case 'RegExp':
-					const { source, flags } = thing;
-					const regexp = flags
-						? `new RegExp(${stringify_string(source)},"${flags}")`
-						: `new RegExp(${stringify_string(source)})`;
-					values.push(regexp);
-					break;
-
-				case 'Date':
-					values.push(`new Date(${thing.getTime()})`);
-					break;
-
-				case 'URL':
-					values.push(`new URL(${stringify_string(thing.toString())})`);
-					break;
-
-				case 'URLSearchParams':
-					values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
-					break;
-
-				case 'Array':
-					values.push(`Array(${thing.length})`);
-					/** @type {any[]} */ (thing).forEach((v, i) => {
-						statements.push(`${name}[${i}]=${stringify(v)}`);
-					});
-					break;
-
-				case 'Set':
-					values.push(`new Set`);
-					statements.push(
-						`${name}.${Array.from(thing)
-							.map((v) => `add(${stringify(v)})`)
-							.join('.')}`
-					);
-					break;
-
-				case 'Map':
-					values.push(`new Map`);
-					statements.push(
-						`${name}.${Array.from(thing)
-							.map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`)
-							.join('.')}`
-					);
-					break;
-
-				case 'Int8Array':
-				case 'Uint8Array':
-				case 'Uint8ClampedArray':
-				case 'Int16Array':
-				case 'Uint16Array':
-				case 'Float16Array':
-				case 'Int32Array':
-				case 'Uint32Array':
-				case 'Float32Array':
-				case 'Float64Array':
-				case 'BigInt64Array':
-				case 'BigUint64Array': {
-					let str = `new ${type}`;
-
-					if (!names.has(thing.buffer)) {
-						const array = new thing.constructor(thing.buffer);
-						str += `([${array}])`;
-					} else {
-						str += `(${stringify(thing.buffer)})`;
-					}
-
-					// handle subarrays
-					if (thing.byteLength !== thing.buffer.byteLength) {
-						const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
-						const end = start + thing.length;
-						str += `.subarray(${start},${end})`;
-					}
-
-					values.push(`{}`);
-					statements.push(`${name}=${str}`);
-					break;
-				}
-
-				case 'DataView': {
-					let str = `new DataView`;
-
-					if (!names.has(thing.buffer)) {
-						str += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
-					} else {
-						str += `(${stringify(thing.buffer)}`;
-					}
-
-					// handle subviews
-					if (thing.byteLength !== thing.buffer.byteLength) {
-						str += `,${thing.byteOffset},${thing.byteLength}`;
-					}
-
-					str += ')';
-
-					values.push(`{}`);
-					statements.push(`${name}=${str}`);
-					break;
-				}
-
-				case 'ArrayBuffer':
-					values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
-					break;
-
-				default:
-					values.push(Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}');
-					Object.keys(thing).forEach((key) => {
-						statements.push(`${name}${safe_prop(key)}=${stringify(thing[key])}`);
-					});
-			}
-		});
-
-		statements.push(`return ${str}`);
-
-		return `(function(${params.join(',')}){${statements.join(';')}}(${values.join(',')}))`;
-	} else {
-		return str;
-	}
-}
-
-/** @param {number} num */
-function get_name(num) {
-	let name = '';
-
-	do {
-		name = chars[num % chars.length] + name;
-		num = ~~(num / chars.length) - 1;
-	} while (num >= 0);
-
-	return reserved.test(name) ? `${name}0` : name;
-}
-
-/** @param {string} c */
-function escape_unsafe_char(c) {
-	return escaped[c] || c;
-}
-
-/** @param {string} str */
-function escape_unsafe_chars(str) {
-	return str.replace(unsafe_chars, escape_unsafe_char);
-}
-
-/** @param {string} key */
-function safe_key(key) {
-	return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
-}
-
-/** @param {string} key */
-function safe_prop(key) {
-	return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key)
-		? `.${key}`
-		: `[${escape_unsafe_chars(JSON.stringify(key))}]`;
-}
-
-/** @param {any} thing */
-function stringify_primitive(thing) {
-	const type = typeof thing;
-	if (type === 'string') return stringify_string(thing);
-	if (thing === void 0) return 'void 0';
-	if (thing === 0 && 1 / thing < 0) return '-0';
-	const str = String(thing);
-	if (type === 'number') return str.replace(/^(-)?0\./, '$1.');
-	if (type === 'bigint') return thing + 'n';
-	return str;
-}
-
-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}
-
-//#region ../../node_modules/svelte/src/internal/shared/errors.js
-/**
-* Cannot use `%name%(...)` unless the `experimental.async` compiler option is `true`
-* @param {string} name
-* @returns {never}
-*/
-function experimental_async_required(name) {
-	throw new Error(`https://svelte.dev/e/experimental_async_required`);
-}
-/**
-* `%name%(...)` can only be used during component initialisation
-* @param {string} name
-* @returns {never}
-*/
-function lifecycle_outside_component(name) {
-	throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
-}
-/**
-* Context was not set in a parent component
-* @returns {never}
-*/
-function missing_context() {
-	throw new Error(`https://svelte.dev/e/missing_context`);
-}
-/**
-* Encountered asynchronous work while rendering synchronously.
-* @returns {never}
-*/
-function await_invalid() {
-	const error = /* @__PURE__ */ new Error(`await_invalid\nEncountered asynchronous work while rendering synchronously.\nhttps://svelte.dev/e/await_invalid`);
-	error.name = "Svelte error";
-	throw error;
-}
-/**
-* Failed to serialize `hydratable` data for key `%key%`.
-* 
-* `hydratable` can serialize anything [`uneval` from `devalue`](https://npmjs.com/package/uneval) can, plus Promises.
-* 
-* Cause:
-* %stack%
-* @param {string} key
-* @param {string} stack
-* @returns {never}
-*/
-function hydratable_serialization_failed(key, stack) {
-	const error = /* @__PURE__ */ new Error(`hydratable_serialization_failed\nFailed to serialize \`hydratable\` data for key \`${key}\`.
-
-\`hydratable\` can serialize anything [\`uneval\` from \`devalue\`](https://npmjs.com/package/uneval) can, plus Promises.
-
-Cause:
-${stack}\nhttps://svelte.dev/e/hydratable_serialization_failed`);
-	error.name = "Svelte error";
-	throw error;
-}
-/**
-* `csp.nonce` was set while `csp.hash` was `true`. These options cannot be used simultaneously.
-* @returns {never}
-*/
-function invalid_csp() {
-	const error = /* @__PURE__ */ new Error(`invalid_csp\n\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.\nhttps://svelte.dev/e/invalid_csp`);
-	error.name = "Svelte error";
-	throw error;
-}
-/**
-* The `idPrefix` option cannot include `--`.
-* @returns {never}
-*/
-function invalid_id_prefix() {
-	const error = /* @__PURE__ */ new Error(`invalid_id_prefix\nThe \`idPrefix\` option cannot include \`--\`.\nhttps://svelte.dev/e/invalid_id_prefix`);
-	error.name = "Svelte error";
-	throw error;
-}
-/**
-* `%name%(...)` is not available on the server
-* @param {string} name
-* @returns {never}
-*/
-function lifecycle_function_unavailable(name) {
-	const error = /* @__PURE__ */ new Error(`lifecycle_function_unavailable\n\`${name}(...)\` is not available on the server\nhttps://svelte.dev/e/lifecycle_function_unavailable`);
-	error.name = "Svelte error";
-	throw error;
-}
-/**
-* Could not resolve `render` context.
-* @returns {never}
-*/
-function server_context_required() {
-	const error = /* @__PURE__ */ new Error(`server_context_required\nCould not resolve \`render\` context.\nhttps://svelte.dev/e/server_context_required`);
-	error.name = "Svelte error";
-	throw error;
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/context.js
-/** @import { SSRContext } from '#server' */
-/** @type {SSRContext | null} */
-var ssr_context = null;
-/** @param {SSRContext | null} v */
-function set_ssr_context(v) {
-	ssr_context = v;
-}
-/**
-* @template T
-* @returns {[() => T, (context: T) => T]}
-* @since 5.40.0
-*/
-function createContext() {
-	const key = {};
-	return [() => {
-		if (!hasContext(key)) missing_context();
-		return getContext(key);
-	}, (context) => setContext(key, context)];
-}
-/**
-* @template T
-* @param {any} key
-* @returns {T}
-*/
-function getContext(key) {
-	return get_or_init_context_map().get(key);
-}
-/**
-* @template T
-* @param {any} key
-* @param {T} context
-* @returns {T}
-*/
-function setContext(key, context) {
-	get_or_init_context_map().set(key, context);
-	return context;
-}
-/**
-* @param {any} key
-* @returns {boolean}
-*/
-function hasContext(key) {
-	return get_or_init_context_map().has(key);
-}
-/** @returns {Map<any, any>} */
-function getAllContexts() {
-	return get_or_init_context_map();
-}
-/**
-* @param {string} name
-* @returns {Map<unknown, unknown>}
-*/
-function get_or_init_context_map(name) {
-	if (ssr_context === null) lifecycle_outside_component();
-	return ssr_context.c ??= new Map(get_parent_context(ssr_context) || void 0);
-}
-/**
-* @param {Function} [fn]
-*/
-function push$1(fn) {
-	ssr_context = {
-		p: ssr_context,
-		c: null,
-		r: null
-	};
-}
-function pop$1() {
-	ssr_context = ssr_context.p;
-}
-/**
-* @param {SSRContext} ssr_context
-* @returns {Map<unknown, unknown> | null}
-*/
-function get_parent_context(ssr_context) {
-	let parent = ssr_context.p;
-	while (parent !== null) {
-		const context_map = parent.c;
-		if (context_map !== null) return context_map;
-		parent = parent.p;
-	}
-	return null;
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/shared/utils.js
-var is_array = Array.isArray;
-var index_of = Array.prototype.indexOf;
-var includes = Array.prototype.includes;
-var array_from = Array.from;
-var define_property = Object.defineProperty;
-var get_descriptor = Object.getOwnPropertyDescriptor;
-var object_prototype = Object.prototype;
-var array_prototype = Array.prototype;
-var get_prototype_of = Object.getPrototypeOf;
-var is_extensible = Object.isExtensible;
-var has_own_property = Object.prototype.hasOwnProperty;
-var noop = () => {};
-/** @param {Function} fn */
-function run(fn) {
-	return fn();
-}
-/** @param {Array<() => void>} arr */
-function run_all(arr) {
-	for (var i = 0; i < arr.length; i++) arr[i]();
-}
-/**
-* TODO replace with Promise.withResolvers once supported widely enough
-* @template [T=void]
-*/
-function deferred() {
-	/** @type {(value: T) => void} */
-	var resolve;
-	/** @type {(reason: any) => void} */
-	var reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
-		}),
-		resolve,
-		reject
-	};
-}
-var CLEAN = 1024;
-var DIRTY = 2048;
-var MAYBE_DIRTY = 4096;
-var INERT = 8192;
-var DESTROYED = 16384;
-/** Set once a reaction has run for the first time */
-var REACTION_RAN = 32768;
-/** Effect is in the process of getting destroyed. Can be observed in child teardown functions */
-var DESTROYING = 1 << 25;
-/**
-* 'Transparent' effects do not create a transition boundary.
-* This is on a block effect 99% of the time but may also be on a branch effect if its parent block effect was pruned
-*/
-var EFFECT_TRANSPARENT = 65536;
-var EFFECT_PRESERVED = 1 << 19;
-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). 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";
-	message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
-}();
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/abort-signal.js
-/** @type {AbortController | null} */
-var controller = null;
-function abort() {
-	controller?.abort(STALE_REACTION);
-	controller = null;
-}
-function getAbortSignal() {
-	return (controller ??= new AbortController()).signal;
-}
-/** @returns {RenderContext} */
-function get_render_context() {
-	const store = als?.getStore();
-	server_context_required();
-	return store;
-}
-/** @type {AsyncLocalStorage<RenderContext | null> | null} */
-var als = null;
-//#endregion
-//#region ../../node_modules/svelte/src/constants.js
-var HYDRATION_ERROR = {};
-var UNINITIALIZED = Symbol();
-/**
-* A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
-* 
-* The `hydratable` was initialized in:
-* %stack%
-* @param {string} key
-* @param {string} stack
-*/
-function unresolved_hydratable(key, stack) {
-	console.warn(`https://svelte.dev/e/unresolved_hydratable`);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/hydration.js
-var BLOCK_OPEN = `<!--[-->`;
-var BLOCK_CLOSE = `<!--]-->`;
-var EMPTY_COMMENT = `<!---->`;
-//#endregion
-//#region ../../node_modules/svelte/src/escaping.js
-var ATTR_REGEX = /[&"<]/g;
-var CONTENT_REGEX = /[&<]/g;
-/**
-* @template V
-* @param {V} value
-* @param {boolean} [is_attr]
-*/
-function escape_html(value, is_attr) {
-	const str = String(value ?? "");
-	const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
-	pattern.lastIndex = 0;
-	let escaped = "";
-	let last = 0;
-	while (pattern.test(str)) {
-		const i = pattern.lastIndex - 1;
-		const ch = str[i];
-		escaped += str.substring(last, i) + (ch === "&" ? "&amp;" : ch === "\"" ? "&quot;" : "&lt;");
-		last = i + 1;
-	}
-	return escaped + str.substring(last);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/shared/attributes.js
-/**
-* `<div translate={false}>` should be rendered as `<div translate="no">` and _not_
-* `<div translate="false">`, which is equivalent to `<div translate="yes">`. There
-* may be other odd cases that need to be added to this list in future
-* @type {Record<string, Map<any, string>>}
-*/
-var replacements = { translate: new Map([[true, "yes"], [false, "no"]]) };
-/**
-* @template V
-* @param {string} name
-* @param {V} value
-* @param {boolean} [is_boolean]
-* @returns {string}
-*/
-function attr(name, value, is_boolean = false) {
-	if (name === "hidden" && value !== "until-found") is_boolean = true;
-	if (value == null || !value && is_boolean) return "";
-	const normalized = has_own_property.call(replacements, name) && replacements[name].get(value) || value;
-	return ` ${name}${is_boolean ? `=""` : `="${escape_html(normalized, true)}"`}`;
-}
-/**
-* Small wrapper around clsx to preserve Svelte's (weird) handling of falsy values.
-* TODO Svelte 6 revisit this, and likely turn all falsy values into the empty string (what clsx also does)
-* @param  {any} value
-*/
-function clsx$1(value) {
-	if (typeof value === "object") return clsx(value);
-	else return value ?? "";
-}
-var whitespace = [..." 	\n\r\f\xA0\v"];
-/**
-* @param {any} value
-* @param {string | null} [hash]
-* @param {Record<string, boolean>} [directives]
-* @returns {string | null}
-*/
-function to_class(value, hash, directives) {
-	var classname = value == null ? "" : "" + value;
-	if (hash) classname = classname ? classname + " " + hash : hash;
-	if (directives) {
-		for (var key of Object.keys(directives)) if (directives[key]) classname = classname ? classname + " " + key : key;
-		else if (classname.length) {
-			var len = key.length;
-			var a = 0;
-			while ((a = classname.indexOf(key, a)) >= 0) {
-				var b = a + len;
-				if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
-				else a = b;
-			}
-		}
-	}
-	return classname === "" ? null : classname;
-}
-/**
-*
-* @param {Record<string,any>} styles
-* @param {boolean} important
-*/
-function append_styles(styles, important = false) {
-	var separator = important ? " !important;" : ";";
-	var css = "";
-	for (var key of Object.keys(styles)) {
-		var value = styles[key];
-		if (value != null && value !== "") css += " " + key + ": " + value + separator;
-	}
-	return css;
-}
-/**
-* @param {string} name
-* @returns {string}
-*/
-function to_css_name(name) {
-	if (name[0] !== "-" || name[1] !== "-") return name.toLowerCase();
-	return name;
-}
-/**
-* @param {any} value
-* @param {Record<string, any> | [Record<string, any>, Record<string, any>]} [styles]
-* @returns {string | null}
-*/
-function to_style(value, styles) {
-	if (styles) {
-		var new_style = "";
-		/** @type {Record<string,any> | undefined} */
-		var normal_styles;
-		/** @type {Record<string,any> | undefined} */
-		var important_styles;
-		if (Array.isArray(styles)) {
-			normal_styles = styles[0];
-			important_styles = styles[1];
-		} else normal_styles = styles;
-		if (value) {
-			value = String(value).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
-			/** @type {boolean | '"' | "'"} */
-			var in_str = false;
-			var in_apo = 0;
-			var in_comment = false;
-			var reserved_names = [];
-			if (normal_styles) reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
-			if (important_styles) reserved_names.push(...Object.keys(important_styles).map(to_css_name));
-			var start_index = 0;
-			var name_index = -1;
-			const len = value.length;
-			for (var i = 0; i < len; i++) {
-				var c = value[i];
-				if (in_comment) {
-					if (c === "/" && value[i - 1] === "*") in_comment = false;
-				} else if (in_str) {
-					if (in_str === c) in_str = false;
-				} else if (c === "/" && value[i + 1] === "*") in_comment = true;
-				else if (c === "\"" || c === "'") in_str = c;
-				else if (c === "(") in_apo++;
-				else if (c === ")") in_apo--;
-				if (!in_comment && in_str === false && in_apo === 0) {
-					if (c === ":" && name_index === -1) name_index = i;
-					else if (c === ";" || i === len - 1) {
-						if (name_index !== -1) {
-							var name = to_css_name(value.substring(start_index, name_index).trim());
-							if (!reserved_names.includes(name)) {
-								if (c !== ";") i++;
-								var property = value.substring(start_index, i).trim();
-								new_style += " " + property + ";";
-							}
-						}
-						start_index = i + 1;
-						name_index = -1;
-					}
-				}
-			}
-		}
-		if (normal_styles) new_style += append_styles(normal_styles);
-		if (important_styles) new_style += append_styles(important_styles, true);
-		new_style = new_style.trim();
-		return new_style === "" ? null : new_style;
-	}
-	return value == null ? null : String(value);
-}
-/**
-* Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state
-* @returns {never}
-*/
-function effect_update_depth_exceeded() {
-	throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
-}
-/**
-* Failed to hydrate the application
-* @returns {never}
-*/
-function hydration_failed() {
-	throw new Error(`https://svelte.dev/e/hydration_failed`);
-}
-/**
-* Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
-* @returns {never}
-*/
-function state_descriptors_fixed() {
-	throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
-}
-/**
-* Cannot set prototype of `$state` object
-* @returns {never}
-*/
-function state_prototype_fixed() {
-	throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
-}
-/**
-* Updating state inside `$derived(...)`, `$inspect(...)` or a template expression is forbidden. If the value should not be reactive, declare it without `$state`
-* @returns {never}
-*/
-function state_unsafe_mutation() {
-	throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
-}
-/**
-* A `<svelte:boundary>` `reset` function cannot be called while an error is still being handled
-* @returns {never}
-*/
-function svelte_boundary_reset_onerror() {
-	throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
-}
-/**
-* Reading a derived belonging to a now-destroyed effect may result in stale values
-*/
-function derived_inert() {
-	console.warn(`https://svelte.dev/e/derived_inert`);
-}
-/**
-* Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near %location%
-* @param {string | undefined | null} [location]
-*/
-function hydration_mismatch(location) {
-	console.warn(`https://svelte.dev/e/hydration_mismatch`);
-}
-/**
-* A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called
-*/
-function svelte_boundary_reset_noop() {
-	console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
-}
-//#endregion
-//#region ../../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
-* if the user doesn't use the `hydrate` method and these code paths are therefore not needed.
-*/
-var hydrating = false;
-/** @param {boolean} value */
-function set_hydrating(value) {
-	hydrating = value;
-}
-/**
-* The node that is currently being hydrated. This starts out as the first node inside the opening
-* <!--[--> comment, and updates each time a component calls `$.child(...)` or `$.sibling(...)`.
-* When entering a block (e.g. `{#if ...}`), `hydrate_node` is the block opening comment; by the
-* time we leave the block it is the closing comment, which serves as the block's anchor.
-* @type {TemplateNode}
-*/
-var hydrate_node;
-/** @param {TemplateNode | null} node */
-function set_hydrate_node(node) {
-	if (node === null) {
-		hydration_mismatch();
-		throw HYDRATION_ERROR;
-	}
-	return hydrate_node = node;
-}
-function hydrate_next() {
-	return set_hydrate_node(/* @__PURE__ */ get_next_sibling(hydrate_node));
-}
-function next(count = 1) {
-	if (hydrating) {
-		var i = count;
-		var node = hydrate_node;
-		while (i--) node = /* @__PURE__ */ get_next_sibling(node);
-		hydrate_node = node;
-	}
-}
-/**
-* Skips or removes (depending on {@link remove}) all nodes starting at `hydrate_node` up until the next hydration end comment
-* @param {boolean} remove
-*/
-function skip_nodes(remove = true) {
-	var depth = 0;
-	var node = hydrate_node;
-	while (true) {
-		if (node.nodeType === 8) {
-			var data = node.data;
-			if (data === "]") {
-				if (depth === 0) return node;
-				depth -= 1;
-			} else if (data === "[" || data === "[!" || data[0] === "[" && !isNaN(Number(data.slice(1)))) depth += 1;
-		}
-		var next = /* @__PURE__ */ get_next_sibling(node);
-		if (remove) node.remove();
-		node = next;
-	}
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/reactivity/equality.js
-/** @import { Equals } from '#client' */
-/** @type {Equals} */
-function equals(value) {
-	return value === this.v;
-}
-/**
-* @param {unknown} a
-* @param {unknown} b
-* @returns {boolean}
-*/
-function safe_not_equal(a, b) {
-	return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
-}
-/** @type {Equals} */
-function safe_equals(value) {
-	return !safe_not_equal(value, this.v);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/context.js
-/** @import { ComponentContext, DevStackEntry, Effect } from '#client' */
-/** @type {ComponentContext | null} */
-var component_context = null;
-/** @param {ComponentContext | null} context */
-function set_component_context(context) {
-	component_context = context;
-}
-/**
-* @param {Record<string, unknown>} props
-* @param {any} runes
-* @param {Function} [fn]
-* @returns {void}
-*/
-function push(props, runes = false, fn) {
-	component_context = {
-		p: component_context,
-		i: false,
-		c: null,
-		e: null,
-		s: props,
-		x: null,
-		r: active_effect,
-		l: null
-	};
-}
-/**
-* @template {Record<string, any>} T
-* @param {T} [component]
-* @returns {T}
-*/
-function pop(component) {
-	var context = component_context;
-	var effects = context.e;
-	if (effects !== null) {
-		context.e = null;
-		for (var fn of effects) create_user_effect(fn);
-	}
-	context.i = true;
-	component_context = context.p;
-	return {};
-}
-/** @returns {boolean} */
-function is_runes() {
-	return true;
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/dom/task.js
-/** @type {Array<() => void>} */
-var micro_tasks = [];
-function run_micro_tasks() {
-	var tasks = micro_tasks;
-	micro_tasks = [];
-	run_all(tasks);
-}
-/**
-* @param {() => void} fn
-*/
-function queue_micro_task(fn) {
-	if (micro_tasks.length === 0 && !is_flushing_sync) {
-		var tasks = micro_tasks;
-		queueMicrotask(() => {
-			if (tasks === micro_tasks) run_micro_tasks();
-		});
-	}
-	micro_tasks.push(fn);
-}
-/**
-* Synchronously run any queued tasks.
-*/
-function flush_tasks() {
-	while (micro_tasks.length > 0) run_micro_tasks();
-}
-/**
-* @param {unknown} error
-*/
-function handle_error(error) {
-	var effect = active_effect;
-	if (effect === null) {
-		/** @type {Derived} */ active_reaction.f |= ERROR_VALUE;
-		return error;
-	}
-	if ((effect.f & 32768) === 0 && (effect.f & 4) === 0) throw error;
-	invoke_error_boundary(error, effect);
-}
-/**
-* @param {unknown} error
-* @param {Effect | null} effect
-*/
-function invoke_error_boundary(error, effect) {
-	while (effect !== null) {
-		if ((effect.f & 128) !== 0) {
-			if ((effect.f & 32768) === 0) throw error;
-			try {
-				/** @type {Boundary} */ effect.b.error(error);
-				return;
-			} catch (e) {
-				error = e;
-			}
-		}
-		effect = effect.parent;
-	}
-	throw error;
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/reactivity/status.js
-/** @import { Derived, Signal } from '#client' */
-var STATUS_MASK = -7169;
-/**
-* @param {Signal} signal
-* @param {number} status
-*/
-function set_signal_status(signal, status) {
-	signal.f = signal.f & STATUS_MASK | status;
-}
-/**
-* Set a derived's status to CLEAN or MAYBE_DIRTY based on its connection state.
-* @param {Derived} derived
-*/
-function update_derived_status(derived) {
-	if ((derived.f & 512) !== 0 || derived.deps === null) set_signal_status(derived, CLEAN);
-	else set_signal_status(derived, MAYBE_DIRTY);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/reactivity/utils.js
-/** @import { Derived, Effect, Value } from '#client' */
-/**
-* @param {Value[] | null} deps
-*/
-function clear_marked(deps) {
-	if (deps === null) return;
-	for (const dep of deps) {
-		if ((dep.f & 2) === 0 || (dep.f & 65536) === 0) continue;
-		dep.f ^= WAS_MARKED;
-		clear_marked(
-			/** @type {Derived} */
-			dep.deps
-		);
-	}
-}
-/**
-* @param {Effect} effect
-* @param {Set<Effect>} dirty_effects
-* @param {Set<Effect>} maybe_dirty_effects
-*/
-function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
-	if ((effect.f & 2048) !== 0) dirty_effects.add(effect);
-	else if ((effect.f & 4096) !== 0) maybe_dirty_effects.add(effect);
-	clear_marked(effect.deps);
-	set_signal_status(effect, CLEAN);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/store/shared/index.js
-/** @import { Readable, StartStopNotifier, Subscriber, Unsubscriber, Updater, Writable } from '../public.js' */
-/** @import { Stores, StoresValues, SubscribeInvalidateTuple } from '../private.js' */
-/**
-* @type {Array<SubscribeInvalidateTuple<any> | any>}
-*/
-var subscriber_queue = [];
-/**
-* Creates a `Readable` store that allows reading by subscription.
-*
-* @template T
-* @param {T} [value] initial value
-* @param {StartStopNotifier<T>} [start]
-* @returns {Readable<T>}
-*/
-function readable(value, start) {
-	return { subscribe: writable(value, start).subscribe };
-}
-/**
-* Create a `Writable` store that allows both updating and reading by subscription.
-*
-* @template T
-* @param {T} [value] initial value
-* @param {StartStopNotifier<T>} [start]
-* @returns {Writable<T>}
-*/
-function writable(value, start = noop) {
-	/** @type {Unsubscriber | null} */
-	let stop = null;
-	/** @type {Set<SubscribeInvalidateTuple<T>>} */
-	const subscribers = /* @__PURE__ */ new Set();
-	/**
-	* @param {T} new_value
-	* @returns {void}
-	*/
-	function set(new_value) {
-		if (safe_not_equal(value, new_value)) {
-			value = new_value;
-			if (stop) {
-				const run_queue = !subscriber_queue.length;
-				for (const subscriber of subscribers) {
-					subscriber[1]();
-					subscriber_queue.push(subscriber, value);
-				}
-				if (run_queue) {
-					for (let i = 0; i < subscriber_queue.length; i += 2) subscriber_queue[i][0](subscriber_queue[i + 1]);
-					subscriber_queue.length = 0;
-				}
-			}
-		}
-	}
-	/**
-	* @param {Updater<T>} fn
-	* @returns {void}
-	*/
-	function update(fn) {
-		set(fn(value));
-	}
-	/**
-	* @param {Subscriber<T>} run
-	* @param {() => void} [invalidate]
-	* @returns {Unsubscriber}
-	*/
-	function subscribe(run, invalidate = noop) {
-		/** @type {SubscribeInvalidateTuple<T>} */
-		const subscriber = [run, invalidate];
-		subscribers.add(subscriber);
-		if (subscribers.size === 1) stop = start(set, update) || noop;
-		run(value);
-		return () => {
-			subscribers.delete(subscriber);
-			if (subscribers.size === 0 && stop) {
-				stop();
-				stop = null;
-			}
-		};
-	}
-	return {
-		set,
-		update,
-		subscribe
-	};
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/reactivity/batch.js
-/** @import { Fork } from 'svelte' */
-/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
-/** @type {Batch | null} */
-var first_batch = null;
-/** @type {Batch | null} */
-var last_batch = null;
-/** @type {Batch | null} */
-var current_batch = null;
-/**
-* This is needed to avoid overwriting inputs
-* @type {Batch | null}
-*/
-var previous_batch = null;
-/**
-* When time travelling (i.e. working in one batch, while other batches
-* still have ongoing work), we ignore the real values of affected
-* signals in favour of their values within the batch
-* @type {Map<Value, any> | null}
-*/
-var batch_values = null;
-/** @type {Effect | null} */
-var last_scheduled_effect = null;
-var is_flushing_sync = false;
-var is_processing = false;
-/**
-* During traversal, this is an array. Newly created effects are (if not immediately
-* executed) pushed to this array, rather than going through the scheduling
-* rigamarole that would cause another turn of the flush loop.
-* @type {Effect[] | null}
-*/
-var collected_effects = null;
-/**
-* An array of effects that are marked during traversal as a result of a `set`
-* (not `internal_set`) call. These will be added to the next batch and
-* trigger another `batch.process()`
-* @type {Effect[] | null}
-* @deprecated when we get rid of legacy mode and stores, we can get rid of this
-*/
-var legacy_updates = null;
-var flush_count = 0;
-var uid = 1;
-var Batch = class Batch {
-	id = uid++;
-	/** True as soon as `#process` was called */
-	#started = false;
-	linked = true;
-	/** @type {Batch | null} */
-	#prev = null;
-	/** @type {Batch | null} */
-	#next = null;
-	/** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
-	async_deriveds = /* @__PURE__ */ new Map();
-	/**
-	* The current values of any signals that are updated in this batch.
-	* Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
-	* They keys of this map are identical to `this.#previous`
-	* @type {Map<Value, [any, boolean]>}
-	*/
-	current = /* @__PURE__ */ new Map();
-	/**
-	* The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
-	* They keys of this map are identical to `this.#current`
-	* @type {Map<Value, any>}
-	*/
-	previous = /* @__PURE__ */ new Map();
-	/**
-	* Async effects which this batch doesn't take into account anymore when calculating blockers,
-	* as it has a value for it already.
-	* @type {Set<Effect>}
-	*/
-	unblocked = /* @__PURE__ */ new Set();
-	/**
-	* When the batch is committed (and the DOM is updated), we need to remove old branches
-	* and append new ones by calling the functions added inside (if/each/key/etc) blocks
-	* @type {Set<(batch: Batch) => void>}
-	*/
-	#commit_callbacks = /* @__PURE__ */ new Set();
-	/**
-	* If a fork is discarded, we need to destroy any effects that are no longer needed
-	* @type {Set<(batch: Batch) => void>}
-	*/
-	#discard_callbacks = /* @__PURE__ */ new Set();
-	/**
-	* Callbacks that should run only when a fork is committed.
-	* @type {Set<(batch: Batch) => void>}
-	*/
-	#fork_commit_callbacks = /* @__PURE__ */ new Set();
-	/**
-	* The number of async effects that are currently in flight
-	*/
-	#pending = 0;
-	/**
-	* Async effects that are currently in flight, _not_ inside a pending boundary
-	* @type {Map<Effect, number>}
-	*/
-	#blocking_pending = /* @__PURE__ */ new Map();
-	/**
-	* A deferred that resolves when the batch is committed, used with `settled()`
-	* TODO replace with Promise.withResolvers once supported widely enough
-	* @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
-	*/
-	#deferred = null;
-	/**
-	* The root effects that need to be flushed
-	* @type {Effect[]}
-	*/
-	#roots = [];
-	/**
-	* Effects created while this batch was active.
-	* @type {Effect[]}
-	*/
-	#new_effects = [];
-	/**
-	* Deferred effects (which run after async work has completed) that are DIRTY
-	* @type {Set<Effect>}
-	*/
-	#dirty_effects = /* @__PURE__ */ new Set();
-	/**
-	* Deferred effects that are MAYBE_DIRTY
-	* @type {Set<Effect>}
-	*/
-	#maybe_dirty_effects = /* @__PURE__ */ new Set();
-	/**
-	* A map of branches that still exist, but will be destroyed when this batch
-	* is committed — we skip over these during `process`.
-	* The value contains child effects that were dirty/maybe_dirty before being reset,
-	* so they can be rescheduled if the branch survives.
-	* @type {Map<Effect, { d: Effect[], m: Effect[] }>}
-	*/
-	#skipped_branches = /* @__PURE__ */ new Map();
-	/**
-	* Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
-	* @type {Set<Effect>}
-	*/
-	#unskipped_branches = /* @__PURE__ */ new Set();
-	is_fork = false;
-	#decrement_queued = false;
-	#is_deferred() {
-		if (this.is_fork) return true;
-		for (const effect of this.#blocking_pending.keys()) {
-			var e = effect;
-			var skipped = false;
-			while (e.parent !== null) {
-				if (this.#skipped_branches.has(e)) {
-					skipped = true;
-					break;
-				}
-				e = e.parent;
-			}
-			if (!skipped) return true;
-		}
-		return false;
-	}
-	/**
-	* Add an effect to the #skipped_branches map and reset its children
-	* @param {Effect} effect
-	*/
-	skip_effect(effect) {
-		if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
-			d: [],
-			m: []
-		});
-		this.#unskipped_branches.delete(effect);
-	}
-	/**
-	* Remove an effect from the #skipped_branches map and reschedule
-	* any tracked dirty/maybe_dirty child effects
-	* @param {Effect} effect
-	* @param {(e: Effect) => void} callback
-	*/
-	unskip_effect(effect, callback = (e) => this.schedule(e)) {
-		var tracked = this.#skipped_branches.get(effect);
-		if (tracked) {
-			this.#skipped_branches.delete(effect);
-			for (var e of tracked.d) {
-				set_signal_status(e, DIRTY);
-				callback(e);
-			}
-			for (e of tracked.m) {
-				set_signal_status(e, MAYBE_DIRTY);
-				callback(e);
-			}
-		}
-		this.#unskipped_branches.add(effect);
-	}
-	#process() {
-		this.#started = true;
-		if (flush_count++ > 1e3) {
-			this.#unlink();
-			infinite_loop_guard();
-		}
-		if (!this.#is_deferred()) {
-			for (const e of this.#dirty_effects) {
-				this.#maybe_dirty_effects.delete(e);
-				set_signal_status(e, DIRTY);
-				this.schedule(e);
-			}
-			for (const e of this.#maybe_dirty_effects) {
-				set_signal_status(e, MAYBE_DIRTY);
-				this.schedule(e);
-			}
-		}
-		const roots = this.#roots;
-		this.#roots = [];
-		this.apply();
-		/** @type {Effect[]} */
-		var effects = collected_effects = [];
-		/** @type {Effect[]} */
-		var render_effects = [];
-		/**
-		* @type {Effect[]}
-		* @deprecated when we get rid of legacy mode and stores, we can get rid of this
-		*/
-		var updates = legacy_updates = [];
-		for (const root of roots) try {
-			this.#traverse(root, effects, render_effects);
-		} catch (e) {
-			reset_all(root);
-			throw e;
-		}
-		current_batch = null;
-		if (updates.length > 0) {
-			var batch = Batch.ensure();
-			for (const e of updates) batch.schedule(e);
-		}
-		collected_effects = null;
-		legacy_updates = null;
-		if (this.#is_deferred()) {
-			this.#defer_effects(render_effects);
-			this.#defer_effects(effects);
-			for (const [e, t] of this.#skipped_branches) reset_branch(e, t);
-			if (updates.length > 0)
- /** @type {Batch} */ current_batch.#process();
-			return;
-		}
-		const earlier_batch = this.#find_earlier_batch();
-		if (earlier_batch) {
-			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.linked && this.#pending === 0) this.#unlink();
-		if (this.#roots.length > 0) {
-			if (next_batch === null) {
-				next_batch = this;
-				this.#link();
-			}
-			const batch = next_batch;
-			batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
-		}
-		if (next_batch !== null) next_batch.#process();
-	}
-	/**
-	* Traverse the effect tree, executing effects or stashing
-	* them for later execution as appropriate
-	* @param {Effect} root
-	* @param {Effect[]} effects
-	* @param {Effect[]} render_effects
-	*/
-	#traverse(root, effects, render_effects) {
-		root.f ^= CLEAN;
-		var effect = root.first;
-		while (effect !== null) {
-			var flags = effect.f;
-			var is_branch = (flags & 96) !== 0;
-			if (!(is_branch && (flags & 1024) !== 0 || (flags & 8192) !== 0 || this.#skipped_branches.has(effect)) && effect.fn !== null) {
-				if (is_branch) effect.f ^= CLEAN;
-				else if ((flags & 4) !== 0) effects.push(effect);
-				else if (is_dirty(effect)) {
-					if ((flags & 16) !== 0) this.#maybe_dirty_effects.add(effect);
-					update_effect(effect);
-				}
-				var child = effect.first;
-				if (child !== null) {
-					effect = child;
-					continue;
-				}
-			}
-			while (effect !== null) {
-				var next = effect.next;
-				if (next !== null) {
-					effect = next;
-					break;
-				}
-				effect = effect.parent;
-			}
-		}
-	}
-	#find_earlier_batch() {
-		var batch = this.#prev;
-		while (batch !== null) {
-			if (!batch.is_fork) {
-				for (const [value, [, is_derived]] of this.current) if (batch.current.has(value) && !is_derived) return batch;
-			}
-			batch = batch.#prev;
-		}
-		return null;
-	}
-	/**
-	* @param {Batch} batch
-	*/
-	#merge(batch) {
-		for (const [source, value] of batch.current) {
-			if (!this.previous.has(source) && batch.previous.has(source)) this.previous.set(source, batch.previous.get(source));
-			this.current.set(source, value);
-		}
-		for (const [effect, deferred] of batch.async_deriveds) {
-			const d = this.async_deriveds.get(effect);
-			if (d) deferred.promise.then(d.resolve);
-		}
-		/**
-		* mark all effects that depend on `batch.current`, except the
-		* async effects that we just resolved (TODO unless they depend
-		* on values in this batch that are NOT in the later batch?).
-		* Through this we also will populate the correct #skipped_branches,
-		* oncommit callbacks etc, so we don't need to merge them separately.
-		* @param {Value} value
-		*/
-		const mark = (value) => {
-			var reactions = value.reactions;
-			if (reactions === null) return;
-			for (const reaction of reactions) {
-				var flags = reaction.f;
-				if ((flags & 2) !== 0) mark(reaction);
-				else {
-					var effect = reaction;
-					if (flags & 4194320 && !this.async_deriveds.has(effect)) {
-						this.#maybe_dirty_effects.delete(effect);
-						set_signal_status(effect, DIRTY);
-						this.schedule(effect);
-					}
-				}
-			}
-		};
-		for (const source of this.current.keys()) mark(source);
-		this.oncommit(() => batch.discard());
-		batch.#unlink();
-		current_batch = this;
-		this.#process();
-	}
-	/**
-	* @param {Effect[]} effects
-	*/
-	#defer_effects(effects) {
-		for (var i = 0; i < effects.length; i += 1) defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
-	}
-	/**
-	* Associate a change to a given source with the current
-	* batch, noting its previous and current values
-	* @param {Value} source
-	* @param {any} value
-	* @param {boolean} [is_derived]
-	*/
-	capture(source, value, is_derived = false) {
-		if (source.v !== UNINITIALIZED && !this.previous.has(source)) this.previous.set(source, source.v);
-		if ((source.f & 8388608) === 0) {
-			this.current.set(source, [value, is_derived]);
-			batch_values?.set(source, value);
-		}
-		if (!this.is_fork) source.v = value;
-	}
-	activate() {
-		current_batch = this;
-	}
-	deactivate() {
-		current_batch = null;
-		batch_values = null;
-	}
-	flush() {
-		try {
-			is_processing = true;
-			current_batch = this;
-			this.#process();
-		} finally {
-			flush_count = 0;
-			last_scheduled_effect = null;
-			collected_effects = null;
-			legacy_updates = null;
-			is_processing = false;
-			current_batch = null;
-			batch_values = null;
-			old_values.clear();
-		}
-	}
-	discard() {
-		for (const fn of this.#discard_callbacks) fn(this);
-		this.#discard_callbacks.clear();
-		this.#fork_commit_callbacks.clear();
-		this.#unlink();
-	}
-	/**
-	* @param {Effect} effect
-	*/
-	register_created_effect(effect) {
-		this.#new_effects.push(effect);
-	}
-	#commit() {
-		this.#unlink();
-		for (let batch = first_batch; batch !== null; batch = batch.#next) {
-			var is_earlier = batch.id < this.id;
-			/** @type {Source[]} */
-			var sources = [];
-			for (const [source, [value, is_derived]] of this.current) {
-				if (batch.current.has(source)) {
-					var batch_value = batch.current.get(source)[0];
-					if (is_earlier && value !== batch_value) batch.current.set(source, [value, is_derived]);
-					else continue;
-				}
-				sources.push(source);
-			}
-			if (is_earlier) for (const [effect, deferred] of this.async_deriveds) {
-				const d = batch.async_deriveds.get(effect);
-				if (d) deferred.promise.then(d.resolve);
-			}
-			if (!batch.#started) continue;
-			var others = [...batch.current.keys()].filter((s) => !this.current.has(s));
-			if (others.length === 0) {
-				if (is_earlier) batch.discard();
-			} else if (sources.length > 0) {
-				if (is_earlier) for (const unskipped of this.#unskipped_branches) batch.unskip_effect(unskipped, (e) => {
-					if ((e.f & 4194320) !== 0) batch.schedule(e);
-					else batch.#defer_effects([e]);
-				});
-				batch.activate();
-				/** @type {Set<Value>} */
-				var marked = /* @__PURE__ */ new Set();
-				/** @type {Map<Reaction, boolean>} */
-				var checked = /* @__PURE__ */ new Map();
-				for (var source of sources) mark_effects(source, others, marked, checked);
-				checked = /* @__PURE__ */ new Map();
-				var current_unequal = [...batch.current.keys()].filter((c) => this.current.has(c) ? this.current.get(c)[0] !== c.v : true);
-				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.apply();
-					for (var root of batch.#roots) batch.#traverse(root, [], []);
-					batch.#roots = [];
-				}
-				batch.deactivate();
-			}
-		}
-	}
-	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
-	*/
-	increment(blocking, effect) {
-		this.#pending += 1;
-		if (blocking) {
-			let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
-			this.#blocking_pending.set(effect, blocking_pending_count + 1);
-		}
-	}
-	/**
-	* @param {boolean} blocking
-	* @param {Effect} effect
-	*/
-	decrement(blocking, effect) {
-		this.#pending -= 1;
-		if (blocking) {
-			let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
-			if (blocking_pending_count === 1) this.#blocking_pending.delete(effect);
-			else this.#blocking_pending.set(effect, blocking_pending_count - 1);
-		}
-		if (this.#decrement_queued) return;
-		this.#decrement_queued = true;
-		queue_micro_task(() => {
-			this.#decrement_queued = false;
-			if (this.linked) this.flush();
-		});
-	}
-	/**
-	* @param {Set<Effect>} dirty_effects
-	* @param {Set<Effect>} maybe_dirty_effects
-	*/
-	transfer_effects(dirty_effects, maybe_dirty_effects) {
-		for (const e of dirty_effects) this.#dirty_effects.add(e);
-		for (const e of maybe_dirty_effects) this.#maybe_dirty_effects.add(e);
-		dirty_effects.clear();
-		maybe_dirty_effects.clear();
-	}
-	/** @param {(batch: Batch) => void} fn */
-	oncommit(fn) {
-		this.#commit_callbacks.add(fn);
-	}
-	/** @param {(batch: Batch) => void} fn */
-	ondiscard(fn) {
-		this.#discard_callbacks.add(fn);
-	}
-	/** @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();
-			batch.#link();
-			if (!is_processing && !is_flushing_sync) queue_micro_task(() => {
-				if (!batch.#started) batch.flush();
-			});
-		}
-		return current_batch;
-	}
-	apply() {
-		{
-			batch_values = null;
-			return;
-		}
-	}
-	/**
-	*
-	* @param {Effect} effect
-	*/
-	schedule(effect) {
-		last_scheduled_effect = effect;
-		if (effect.b?.is_pending && (effect.f & 16777228) !== 0 && (effect.f & 32768) === 0) {
-			effect.b.defer_effect(effect);
-			return;
-		}
-		var e = effect;
-		while (e.parent !== null) {
-			e = e.parent;
-			var flags = e.f;
-			if (collected_effects !== null && e === active_effect) {
-				if ((active_reaction === null || (active_reaction.f & 2) === 0) && true) return;
-			}
-			if ((flags & 96) !== 0) {
-				if ((flags & 1024) === 0) return;
-				e.f ^= CLEAN;
-			}
-		}
-		this.#roots.push(e);
-	}
-	#link() {
-		if (last_batch === null) first_batch = last_batch = this;
-		else {
-			last_batch.#next = this;
-			this.#prev = last_batch;
-		}
-		last_batch = this;
-	}
-	#unlink() {
-		var prev = this.#prev;
-		var next = this.#next;
-		if (prev === null) first_batch = next;
-		else prev.#next = next;
-		if (next === null) last_batch = prev;
-		else next.#prev = prev;
-		this.linked = false;
-	}
-};
-/**
-* Synchronously flush any pending updates.
-* Returns void if no callback is provided, otherwise returns the result of calling the callback.
-* @template [T=void]
-* @param {(() => T) | undefined} [fn]
-* @returns {T}
-*/
-function flushSync(fn) {
-	var was_flushing_sync = is_flushing_sync;
-	is_flushing_sync = true;
-	try {
-		var result;
-		if (fn) ;
-		while (true) {
-			flush_tasks();
-			if (current_batch === null) return result;
-			current_batch.flush();
-		}
-	} finally {
-		is_flushing_sync = was_flushing_sync;
-	}
-}
-function infinite_loop_guard() {
-	try {
-		effect_update_depth_exceeded();
-	} catch (error) {
-		invoke_error_boundary(error, last_scheduled_effect);
-	}
-}
-/** @type {Set<Effect> | null} */
-var eager_block_effects = null;
-/**
-* @param {Array<Effect>} effects
-* @returns {void}
-*/
-function flush_queued_effects(effects) {
-	var length = effects.length;
-	if (length === 0) return;
-	var i = 0;
-	while (i < length) {
-		var effect = effects[i++];
-		if ((effect.f & 24576) === 0 && is_dirty(effect)) {
-			eager_block_effects = /* @__PURE__ */ new Set();
-			update_effect(effect);
-			if (effect.deps === null && effect.first === null && effect.nodes === null && effect.teardown === null && effect.ac === null) unlink_effect(effect);
-			if (eager_block_effects?.size > 0) {
-				old_values.clear();
-				for (const e of eager_block_effects) {
-					if ((e.f & 24576) !== 0) continue;
-					/** @type {Effect[]} */
-					const ordered_effects = [e];
-					let ancestor = e.parent;
-					while (ancestor !== null) {
-						if (eager_block_effects.has(ancestor)) {
-							eager_block_effects.delete(ancestor);
-							ordered_effects.push(ancestor);
-						}
-						ancestor = ancestor.parent;
-					}
-					for (let j = ordered_effects.length - 1; j >= 0; j--) {
-						const e = ordered_effects[j];
-						if ((e.f & 24576) !== 0) continue;
-						update_effect(e);
-					}
-				}
-				eager_block_effects.clear();
-			}
-		}
-	}
-	eager_block_effects = null;
-}
-/**
-* This is similar to `mark_reactions`, but it only marks async/block effects
-* depending on `value` and at least one of the other `sources`, so that
-* these effects can re-run after another batch has been committed
-* @param {Value} value
-* @param {Source[]} sources
-* @param {Set<Value>} marked
-* @param {Map<Reaction, boolean>} checked
-*/
-function mark_effects(value, sources, marked, checked) {
-	if (marked.has(value)) return;
-	marked.add(value);
-	if (value.reactions !== null) for (const reaction of value.reactions) {
-		const flags = reaction.f;
-		if ((flags & 2) !== 0) mark_effects(reaction, sources, marked, checked);
-		else if ((flags & 4194320) !== 0 && (flags & 2048) === 0 && depends_on(reaction, sources, checked)) {
-			set_signal_status(reaction, DIRTY);
-			schedule_effect(reaction);
-		}
-	}
-}
-/**
-* @param {Reaction} reaction
-* @param {Source[]} sources
-* @param {Map<Reaction, boolean>} checked
-*/
-function depends_on(reaction, sources, checked) {
-	const depends = checked.get(reaction);
-	if (depends !== void 0) return depends;
-	if (reaction.deps !== null) for (const dep of reaction.deps) {
-		if (includes.call(sources, dep)) return true;
-		if ((dep.f & 2) !== 0 && depends_on(dep, sources, checked)) {
-			checked.set(dep, true);
-			return true;
-		}
-	}
-	checked.set(reaction, false);
-	return false;
-}
-/**
-* @param {Effect} effect
-* @returns {void}
-*/
-function schedule_effect(effect) {
-	/** @type {Batch} */ current_batch.schedule(effect);
-}
-/**
-* Mark all the effects inside a skipped branch CLEAN, so that
-* they can be correctly rescheduled later. Tracks dirty and maybe_dirty
-* effects so they can be rescheduled if the branch survives.
-* @param {Effect} effect
-* @param {{ d: Effect[], m: Effect[] }} tracked
-*/
-function reset_branch(effect, tracked) {
-	if ((effect.f & 32) !== 0 && (effect.f & 1024) !== 0) return;
-	if ((effect.f & 2048) !== 0) tracked.d.push(effect);
-	else if ((effect.f & 4096) !== 0) tracked.m.push(effect);
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_branch(e, tracked);
-		e = e.next;
-	}
-}
-/**
-* Mark an entire effect tree clean following an error
-* @param {Effect} effect
-*/
-function reset_all(effect) {
-	set_signal_status(effect, CLEAN);
-	var e = effect.first;
-	while (e !== null) {
-		reset_all(e);
-		e = e.next;
-	}
-}
-//#endregion
-//#region ../../node_modules/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 ../../node_modules/svelte/src/internal/client/dom/blocks/boundary.js
-/** @import { Effect, Source, TemplateNode, } from '#client' */
-/**
-* @typedef {{
-* 	 onerror?: ((error: unknown, reset: () => void) => void) | null;
-*   failed?: ((anchor: Node, error: () => unknown, reset: () => () => void) => void) | null;
-*   pending?: ((anchor: Node) => void) | null;
-* }} BoundaryProps
-*/
-var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
-/**
-* @param {TemplateNode} node
-* @param {BoundaryProps} props
-* @param {((anchor: Node) => void)} children
-* @param {((error: unknown) => unknown) | undefined} [transform_error]
-* @returns {void}
-*/
-function boundary(node, props, children, transform_error) {
-	new Boundary(node, props, children, transform_error);
-}
-var Boundary = class {
-	/** @type {Boundary | null} */
-	parent;
-	is_pending = false;
-	/**
-	* API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
-	* Inherited from parent boundary, or defaults to identity.
-	* @type {(error: unknown) => unknown}
-	*/
-	transform_error;
-	/** @type {TemplateNode} */
-	#anchor;
-	/** @type {TemplateNode | null} */
-	#hydrate_open = hydrating ? hydrate_node : null;
-	/** @type {BoundaryProps} */
-	#props;
-	/** @type {((anchor: Node) => void)} */
-	#children;
-	/** @type {Effect} */
-	#effect;
-	/** @type {Effect | null} */
-	#main_effect = null;
-	/** @type {Effect | null} */
-	#pending_effect = null;
-	/** @type {Effect | null} */
-	#failed_effect = null;
-	/** @type {DocumentFragment | null} */
-	#offscreen_fragment = null;
-	#local_pending_count = 0;
-	#pending_count = 0;
-	#pending_count_update_queued = false;
-	/** @type {Set<Effect>} */
-	#dirty_effects = /* @__PURE__ */ new Set();
-	/** @type {Set<Effect>} */
-	#maybe_dirty_effects = /* @__PURE__ */ new Set();
-	/**
-	* A source containing the number of pending async deriveds/expressions.
-	* Only created if `$effect.pending()` is used inside the boundary,
-	* otherwise updating the source results in needless `Batch.ensure()`
-	* calls followed by no-op flushes
-	* @type {Source<number> | null}
-	*/
-	#effect_pending = null;
-	#effect_pending_subscriber = createSubscriber(() => {
-		this.#effect_pending = source(this.#local_pending_count);
-		return () => {
-			this.#effect_pending = null;
-		};
-	});
-	/**
-	* @param {TemplateNode} node
-	* @param {BoundaryProps} props
-	* @param {((anchor: Node) => void)} children
-	* @param {((error: unknown) => unknown) | undefined} [transform_error]
-	*/
-	constructor(node, props, children, transform_error) {
-		this.#anchor = node;
-		this.#props = props;
-		this.#children = (anchor) => {
-			var effect = active_effect;
-			effect.b = this;
-			effect.f |= 128;
-			children(anchor);
-		};
-		this.parent = active_effect.b;
-		this.transform_error = transform_error ?? this.parent?.transform_error ?? ((e) => e);
-		this.#effect = block(() => {
-			if (hydrating) {
-				const comment = this.#hydrate_open;
-				hydrate_next();
-				const server_rendered_pending = comment.data === "[!";
-				if (comment.data.startsWith("[?")) {
-					const serialized_error = JSON.parse(comment.data.slice(2));
-					this.#hydrate_failed_content(serialized_error);
-				} else if (server_rendered_pending) this.#hydrate_pending_content();
-				else this.#hydrate_resolved_content();
-			} else this.#render();
-		}, flags);
-		if (hydrating) this.#anchor = hydrate_node;
-	}
-	#hydrate_resolved_content() {
-		try {
-			this.#main_effect = branch(() => this.#children(this.#anchor));
-		} catch (error) {
-			this.error(error);
-		}
-	}
-	/**
-	* @param {unknown} error The deserialized error from the server's hydration comment
-	*/
-	#hydrate_failed_content(error) {
-		const failed = this.#props.failed;
-		if (!failed) return;
-		this.#failed_effect = branch(() => {
-			failed(this.#anchor, () => error, () => () => {});
-		});
-	}
-	#hydrate_pending_content() {
-		const pending = this.#props.pending;
-		if (!pending) return;
-		this.is_pending = true;
-		this.#pending_effect = branch(() => pending(this.#anchor));
-		queue_micro_task(() => {
-			var fragment = this.#offscreen_fragment = document.createDocumentFragment();
-			var anchor = create_text();
-			fragment.append(anchor);
-			this.#main_effect = this.#run(() => {
-				return branch(() => this.#children(anchor));
-			});
-			if (this.#pending_count === 0) {
-				this.#anchor.before(fragment);
-				this.#offscreen_fragment = null;
-				pause_effect(this.#pending_effect, () => {
-					this.#pending_effect = null;
-				});
-				this.#resolve(current_batch);
-			}
-		});
-	}
-	#render() {
-		try {
-			this.is_pending = this.has_pending_snippet();
-			this.#pending_count = 0;
-			this.#local_pending_count = 0;
-			this.#main_effect = branch(() => {
-				this.#children(this.#anchor);
-			});
-			if (this.#pending_count > 0) {
-				var fragment = this.#offscreen_fragment = document.createDocumentFragment();
-				move_effect(this.#main_effect, fragment);
-				const pending = this.#props.pending;
-				this.#pending_effect = branch(() => pending(this.#anchor));
-			} else this.#resolve(current_batch);
-		} catch (error) {
-			this.error(error);
-		}
-	}
-	/**
-	* @param {Batch} batch
-	*/
-	#resolve(batch) {
-		this.is_pending = false;
-		batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
-	}
-	/**
-	* Defer an effect inside a pending boundary until the boundary resolves
-	* @param {Effect} effect
-	*/
-	defer_effect(effect) {
-		defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
-	}
-	/**
-	* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
-	* @returns {boolean}
-	*/
-	is_rendered() {
-		return !this.is_pending && (!this.parent || this.parent.is_rendered());
-	}
-	has_pending_snippet() {
-		return !!this.#props.pending;
-	}
-	/**
-	* @template T
-	* @param {() => T} fn
-	*/
-	#run(fn) {
-		var previous_effect = active_effect;
-		var previous_reaction = active_reaction;
-		var previous_ctx = component_context;
-		set_active_effect(this.#effect);
-		set_active_reaction(this.#effect);
-		set_component_context(this.#effect.ctx);
-		try {
-			Batch.ensure();
-			return fn();
-		} catch (e) {
-			handle_error(e);
-			return null;
-		} finally {
-			set_active_effect(previous_effect);
-			set_active_reaction(previous_reaction);
-			set_component_context(previous_ctx);
-		}
-	}
-	/**
-	* Updates the pending count associated with the currently visible pending snippet,
-	* if any, such that we can replace the snippet with content once work is done
-	* @param {1 | -1} d
-	* @param {Batch} batch
-	*/
-	#update_pending_count(d, batch) {
-		if (!this.has_pending_snippet()) {
-			if (this.parent) this.parent.#update_pending_count(d, batch);
-			return;
-		}
-		this.#pending_count += d;
-		if (this.#pending_count === 0) {
-			this.#resolve(batch);
-			if (this.#pending_effect) pause_effect(this.#pending_effect, () => {
-				this.#pending_effect = null;
-			});
-			if (this.#offscreen_fragment) {
-				this.#anchor.before(this.#offscreen_fragment);
-				this.#offscreen_fragment = null;
-			}
-		}
-	}
-	/**
-	* 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
-	*/
-	update_pending_count(d, batch) {
-		this.#update_pending_count(d, batch);
-		this.#local_pending_count += d;
-		if (!this.#effect_pending || this.#pending_count_update_queued) return;
-		this.#pending_count_update_queued = true;
-		queue_micro_task(() => {
-			this.#pending_count_update_queued = false;
-			if (this.#effect_pending) internal_set(this.#effect_pending, this.#local_pending_count);
-		});
-	}
-	get_effect_pending() {
-		this.#effect_pending_subscriber();
-		return get(this.#effect_pending);
-	}
-	/** @param {unknown} error */
-	error(error) {
-		if (!this.#props.onerror && !this.#props.failed) throw error;
-		if (current_batch?.is_fork) {
-			if (this.#main_effect) current_batch.skip_effect(this.#main_effect);
-			if (this.#pending_effect) current_batch.skip_effect(this.#pending_effect);
-			if (this.#failed_effect) current_batch.skip_effect(this.#failed_effect);
-			current_batch.on_fork_commit(() => {
-				this.#handle_error(error);
-			});
-		} else this.#handle_error(error);
-	}
-	/**
-	* @param {unknown} error
-	*/
-	#handle_error(error) {
-		if (this.#main_effect) {
-			destroy_effect(this.#main_effect);
-			this.#main_effect = null;
-		}
-		if (this.#pending_effect) {
-			destroy_effect(this.#pending_effect);
-			this.#pending_effect = null;
-		}
-		if (this.#failed_effect) {
-			destroy_effect(this.#failed_effect);
-			this.#failed_effect = null;
-		}
-		if (hydrating) {
-			set_hydrate_node(this.#hydrate_open);
-			next();
-			set_hydrate_node(skip_nodes());
-		}
-		var onerror = this.#props.onerror;
-		let failed = this.#props.failed;
-		var did_reset = false;
-		var calling_on_error = false;
-		const reset = () => {
-			if (did_reset) {
-				svelte_boundary_reset_noop();
-				return;
-			}
-			did_reset = true;
-			if (calling_on_error) svelte_boundary_reset_onerror();
-			if (this.#failed_effect !== null) pause_effect(this.#failed_effect, () => {
-				this.#failed_effect = null;
-			});
-			this.#run(() => {
-				this.#render();
-			});
-		};
-		/** @param {unknown} transformed_error */
-		const handle_error_result = (transformed_error) => {
-			try {
-				calling_on_error = true;
-				onerror?.(transformed_error, reset);
-				calling_on_error = false;
-			} catch (error) {
-				invoke_error_boundary(error, this.#effect && this.#effect.parent);
-			}
-			if (failed) this.#failed_effect = this.#run(() => {
-				try {
-					return branch(() => {
-						var effect = active_effect;
-						effect.b = this;
-						effect.f |= 128;
-						failed(this.#anchor, () => transformed_error, () => reset);
-					});
-				} catch (error) {
-					invoke_error_boundary(error, this.#effect.parent);
-					return null;
-				}
-			});
-		};
-		queue_micro_task(() => {
-			/** @type {unknown} */
-			var result;
-			try {
-				result = this.transform_error(error);
-			} catch (e) {
-				invoke_error_boundary(e, this.#effect && this.#effect.parent);
-				return;
-			}
-			if (result !== null && typeof result === "object" && typeof result.then === "function")
- /** @type {any} */ result.then(
-				handle_error_result,
-				/** @param {unknown} e */
-				(e) => invoke_error_boundary(e, this.#effect && this.#effect.parent)
-			);
-			else handle_error_result(result);
-		});
-	}
-};
-/**
-* @param {Derived} derived
-* @returns {void}
-*/
-function destroy_derived_effects(derived) {
-	var effects = derived.effects;
-	if (effects !== null) {
-		derived.effects = null;
-		for (var i = 0; i < effects.length; i += 1) destroy_effect(effects[i]);
-	}
-}
-/**
-* @template T
-* @param {Derived} derived
-* @returns {T}
-*/
-function execute_derived(derived) {
-	var value;
-	var prev_active_effect = active_effect;
-	var parent = derived.parent;
-	if (!is_destroying_effect && parent !== null && (parent.f & 24576) !== 0) {
-		derived_inert();
-		return derived.v;
-	}
-	set_active_effect(parent);
-	try {
-		derived.f &= ~WAS_MARKED;
-		destroy_derived_effects(derived);
-		value = update_reaction(derived);
-	} finally {
-		set_active_effect(prev_active_effect);
-	}
-	return value;
-}
-/**
-* @param {Derived} derived
-* @returns {void}
-*/
-function update_derived(derived) {
-	var value = execute_derived(derived);
-	if (!derived.equals(value)) {
-		derived.wv = increment_write_version();
-		if (!current_batch?.is_fork || derived.deps === null) {
-			if (current_batch !== null) {
-				current_batch.capture(derived, value, true);
-				previous_batch?.capture(derived, value, true);
-			} else derived.v = value;
-			if (derived.deps === null) {
-				set_signal_status(derived, CLEAN);
-				return;
-			}
-		}
-	}
-	if (is_destroying_effect) return;
-	if (batch_values !== null) {
-		if (effect_tracking() || current_batch?.is_fork) batch_values.set(derived, value);
-	} else update_derived_status(derived);
-}
-/**
-* @param {Derived} derived
-*/
-function freeze_derived_effects(derived) {
-	if (derived.effects === null) return;
-	for (const e of derived.effects) if (e.teardown || e.ac) {
-		e.teardown?.();
-		e.ac?.abort(STALE_REACTION);
-		e.teardown = noop;
-		e.ac = null;
-		remove_reactions(e, 0);
-		destroy_effect_children(e);
-	}
-}
-/**
-* @param {Derived} derived
-*/
-function unfreeze_derived_effects(derived) {
-	if (derived.effects === null) return;
-	for (const e of derived.effects) if (e.teardown) update_effect(e);
-}
-//#endregion
-//#region ../../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();
-/** @type {Map<Source, any>} */
-var old_values = /* @__PURE__ */ new Map();
-var eager_effects_deferred = false;
-/**
-* @template V
-* @param {V} v
-* @param {Error | null} [stack]
-* @returns {Source<V>}
-*/
-function source(v, stack) {
-	return {
-		f: 0,
-		v,
-		reactions: null,
-		equals,
-		rv: 0,
-		wv: 0
-	};
-}
-/**
-* @template V
-* @param {V} v
-* @param {Error | null} [stack]
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function state(v, stack) {
-	const s = source(v);
-	push_reaction_value(s);
-	return s;
-}
-/**
-* @template V
-* @param {V} initial_value
-* @param {boolean} [immutable]
-* @returns {Source<V>}
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function mutable_source(initial_value, immutable = false, trackable = true) {
-	const s = source(initial_value);
-	if (!immutable) s.equals = safe_equals;
-	return s;
-}
-/**
-* @template V
-* @param {Source<V>} source
-* @param {V} value
-* @param {boolean} [should_proxy]
-* @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();
-	return internal_set(source, should_proxy ? proxy(value) : value, legacy_updates);
-}
-/**
-* @template V
-* @param {Source<V>} source
-* @param {V} value
-* @param {Effect[] | null} [updated_during_traversal]
-* @returns {V}
-*/
-function internal_set(source, value, updated_during_traversal = null) {
-	if (!source.equals(value)) {
-		old_values.set(source, is_destroying_effect ? value : source.v);
-		var batch = Batch.ensure();
-		batch.capture(source, value);
-		if ((source.f & 2) !== 0) {
-			const derived = source;
-			if ((source.f & 2048) !== 0) execute_derived(derived);
-			if (batch_values === null) update_derived_status(derived);
-		}
-		source.wv = increment_write_version();
-		mark_reactions(source, DIRTY, updated_during_traversal);
-		if (active_effect !== null && (active_effect.f & 1024) !== 0 && (active_effect.f & 96) === 0) if (untracked_writes === null) set_untracked_writes([source]);
-		else untracked_writes.push(source);
-		if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) flush_eager_effects();
-	}
-	return value;
-}
-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);
-		let dirty;
-		try {
-			dirty = is_dirty(effect);
-		} catch {
-			dirty = true;
-		}
-		if (dirty) update_effect(effect);
-	}
-	eager_effects.clear();
-}
-/**
-* Silently (without using `get`) increment a source
-* @param {Source<number>} source
-*/
-function increment(source) {
-	set(source, source.v + 1);
-}
-/**
-* @param {Value} signal
-* @param {number} status should be DIRTY or MAYBE_DIRTY
-* @param {Effect[] | null} updated_during_traversal
-* @returns {void}
-*/
-function mark_reactions(signal, status, updated_during_traversal) {
-	var reactions = signal.reactions;
-	if (reactions === null) return;
-	var length = reactions.length;
-	for (var i = 0; i < length; i++) {
-		var reaction = reactions[i];
-		var flags = reaction.f;
-		var not_dirty = (flags & DIRTY) === 0;
-		if (not_dirty) set_signal_status(reaction, status);
-		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 && (active_effect === null || (active_effect.f & 2097152) === 0)) reaction.f |= WAS_MARKED;
-				mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
-			}
-		} else if (not_dirty) {
-			var effect = reaction;
-			if ((flags & 16) !== 0 && eager_block_effects !== null) eager_block_effects.add(effect);
-			if (updated_during_traversal !== null) updated_during_traversal.push(effect);
-			else schedule_effect(effect);
-		}
-	}
-}
-/**
-* @template T
-* @param {T} value
-* @returns {T}
-*/
-function proxy(value) {
-	if (typeof value !== "object" || value === null || STATE_SYMBOL in value) return value;
-	const prototype = get_prototype_of(value);
-	if (prototype !== object_prototype && prototype !== array_prototype) return value;
-	/** @type {Map<any, Source<any>>} */
-	var sources = /* @__PURE__ */ new Map();
-	var is_proxied_array = is_array(value);
-	var version = /* @__PURE__ */ state(0);
-	var parent_version = update_version;
-	/**
-	* Executes the proxy in the context of the reaction it was originally created in, if any
-	* @template T
-	* @param {() => T} fn
-	*/
-	var with_parent = (fn) => {
-		if (update_version === parent_version) return fn();
-		var reaction = active_reaction;
-		var version = update_version;
-		set_active_reaction(null);
-		set_update_version(parent_version);
-		var result = fn();
-		set_active_reaction(reaction);
-		set_update_version(version);
-		return result;
-	};
-	if (is_proxied_array) sources.set("length", /* @__PURE__ */ state(
-		/** @type {any[]} */
-		value.length));
-	return new Proxy(value, {
-		defineProperty(_, prop, descriptor) {
-			if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) state_descriptors_fixed();
-			var s = sources.get(prop);
-			if (s === void 0) with_parent(() => {
-				var s = /* @__PURE__ */ state(descriptor.value);
-				sources.set(prop, s);
-				return s;
-			});
-			else set(s, descriptor.value, true);
-			return true;
-		},
-		deleteProperty(target, prop) {
-			var s = sources.get(prop);
-			if (s === void 0) {
-				if (prop in target) {
-					const s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
-					sources.set(prop, s);
-					increment(version);
-				}
-			} else {
-				set(s, UNINITIALIZED);
-				increment(version);
-			}
-			return true;
-		},
-		get(target, prop, receiver) {
-			if (prop === STATE_SYMBOL) return value;
-			var s = sources.get(prop);
-			var exists = prop in target;
-			if (s === void 0 && (!exists || get_descriptor(target, prop)?.writable)) {
-				s = with_parent(() => {
-					return /* @__PURE__ */ state(proxy(exists ? target[prop] : UNINITIALIZED));
-				});
-				sources.set(prop, s);
-			}
-			if (s !== void 0) {
-				var v = get(s);
-				return v === UNINITIALIZED ? void 0 : v;
-			}
-			return Reflect.get(target, prop, receiver);
-		},
-		getOwnPropertyDescriptor(target, prop) {
-			var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-			if (descriptor && "value" in descriptor) {
-				var s = sources.get(prop);
-				if (s) descriptor.value = get(s);
-			} else if (descriptor === void 0) {
-				var source = sources.get(prop);
-				var value = source?.v;
-				if (source !== void 0 && value !== UNINITIALIZED) return {
-					enumerable: true,
-					configurable: true,
-					value,
-					writable: true
-				};
-			}
-			return descriptor;
-		},
-		has(target, prop) {
-			if (prop === STATE_SYMBOL) return true;
-			var s = sources.get(prop);
-			var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop);
-			if (s !== void 0 || active_effect !== null && (!has || get_descriptor(target, prop)?.writable)) {
-				if (s === void 0) {
-					s = with_parent(() => {
-						return /* @__PURE__ */ state(has ? proxy(target[prop]) : UNINITIALIZED);
-					});
-					sources.set(prop, s);
-				}
-				if (get(s) === UNINITIALIZED) return false;
-			}
-			return has;
-		},
-		set(target, prop, value, receiver) {
-			var s = sources.get(prop);
-			var has = prop in target;
-			if (is_proxied_array && prop === "length") for (var i = value; i < s.v; i += 1) {
-				var other_s = sources.get(i + "");
-				if (other_s !== void 0) set(other_s, UNINITIALIZED);
-				else if (i in target) {
-					other_s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
-					sources.set(i + "", other_s);
-				}
-			}
-			if (s === void 0) {
-				if (!has || get_descriptor(target, prop)?.writable) {
-					s = with_parent(() => /* @__PURE__ */ state(void 0));
-					set(s, proxy(value));
-					sources.set(prop, s);
-				}
-			} else {
-				has = s.v !== UNINITIALIZED;
-				var p = with_parent(() => proxy(value));
-				set(s, p);
-			}
-			var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-			if (descriptor?.set) descriptor.set.call(receiver, value);
-			if (!has) {
-				if (is_proxied_array && typeof prop === "string") {
-					var ls = sources.get("length");
-					var n = Number(prop);
-					if (Number.isInteger(n) && n >= ls.v) set(ls, n + 1);
-				}
-				increment(version);
-			}
-			return true;
-		},
-		ownKeys(target) {
-			get(version);
-			var own_keys = Reflect.ownKeys(target).filter((key) => {
-				var source = sources.get(key);
-				return source === void 0 || source.v !== UNINITIALIZED;
-			});
-			for (var [key, source] of sources) if (source.v !== UNINITIALIZED && !(key in target)) own_keys.push(key);
-			return own_keys;
-		},
-		setPrototypeOf() {
-			state_prototype_fixed();
-		}
-	});
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/dom/operations.js
-/** @type {Window} */
-var $window;
-/** @type {() => Node | null} */
-var first_child_getter;
-/** @type {() => Node | null} */
-var next_sibling_getter;
-/**
-* Initialize these lazily to avoid issues when using the runtime in a server context
-* where these globals are not available while avoiding a separate server entry point
-*/
-function init_operations() {
-	if ($window !== void 0) return;
-	$window = window;
-	var element_prototype = Element.prototype;
-	var node_prototype = Node.prototype;
-	var text_prototype = Text.prototype;
-	first_child_getter = get_descriptor(node_prototype, "firstChild").get;
-	next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
-	if (is_extensible(element_prototype)) {
-		/** @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))
- /** @type {any} */ text_prototype[TEXT_CACHE] = void 0;
-}
-/**
-* @param {string} value
-* @returns {Text}
-*/
-function create_text(value = "") {
-	return document.createTextNode(value);
-}
-/**
-* @template {Node} N
-* @param {N} node
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function get_first_child(node) {
-	return first_child_getter.call(node);
-}
-/**
-* @template {Node} N
-* @param {N} node
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function get_next_sibling(node) {
-	return next_sibling_getter.call(node);
-}
-/**
-* @template {Node} N
-* @param {N} node
-* @returns {void}
-*/
-function clear_text_content(node) {
-	node.textContent = "";
-}
-//#endregion
-//#region ../../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/svelte/src/internal/client/reactivity/effects.js
-/** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
-/**
-* @param {Effect} effect
-* @param {Effect} parent_effect
-*/
-function push_effect(effect, parent_effect) {
-	var parent_last = parent_effect.last;
-	if (parent_last === null) parent_effect.last = parent_effect.first = effect;
-	else {
-		parent_last.next = effect;
-		effect.prev = parent_last;
-		parent_effect.last = effect;
-	}
-}
-/**
-* @param {number} type
-* @param {null | (() => void | (() => void))} fn
-* @returns {Effect}
-*/
-function create_effect(type, fn) {
-	var parent = active_effect;
-	if (parent !== null && (parent.f & 8192) !== 0) type |= INERT;
-	/** @type {Effect} */
-	var effect = {
-		ctx: component_context,
-		deps: null,
-		nodes: null,
-		f: type | DIRTY | 512,
-		first: null,
-		fn,
-		last: null,
-		next: null,
-		parent,
-		b: parent && parent.b,
-		prev: null,
-		teardown: null,
-		wv: 0,
-		ac: null
-	};
-	current_batch?.register_created_effect(effect);
-	/** @type {Effect | null} */
-	var e = effect;
-	if ((type & 4) !== 0) if (collected_effects !== null) collected_effects.push(effect);
-	else Batch.ensure().schedule(effect);
-	else if (fn !== null) {
-		try {
-			update_effect(effect);
-		} catch (e) {
-			destroy_effect(effect);
-			throw e;
-		}
-		if (e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && (e.f & 524288) === 0) {
-			e = e.first;
-			if ((type & 16) !== 0 && (type & 65536) !== 0 && e !== null) e.f |= EFFECT_TRANSPARENT;
-		}
-	}
-	if (e !== null) {
-		e.parent = parent;
-		if (parent !== null) push_effect(e, parent);
-		if (active_reaction !== null && (active_reaction.f & 2) !== 0 && (type & 64) === 0) {
-			var derived = active_reaction;
-			(derived.effects ??= []).push(e);
-		}
-	}
-	return effect;
-}
-/**
-* Internal representation of `$effect.tracking()`
-* @returns {boolean}
-*/
-function effect_tracking() {
-	return active_reaction !== null && !untracking;
-}
-/**
-* @param {() => void | (() => void)} fn
-*/
-function create_user_effect(fn) {
-	return create_effect(4 | USER_EFFECT, fn);
-}
-/**
-* An effect root whose children can transition out
-* @param {() => void} fn
-* @returns {(options?: { outro?: boolean }) => Promise<void>}
-*/
-function component_root(fn) {
-	Batch.ensure();
-	const effect = create_effect(64 | EFFECT_PRESERVED, fn);
-	return (options = {}) => {
-		return new Promise((fulfil) => {
-			if (options.outro) pause_effect(effect, () => {
-				destroy_effect(effect);
-				fulfil(void 0);
-			});
-			else {
-				destroy_effect(effect);
-				fulfil(void 0);
-			}
-		});
-	};
-}
-/**
-* @param {() => void | (() => void)} fn
-* @returns {Effect}
-*/
-function render_effect(fn, flags = 0) {
-	return create_effect(8 | flags, fn);
-}
-/**
-* @param {(() => void)} fn
-* @param {number} flags
-*/
-function block(fn, flags = 0) {
-	return create_effect(16 | flags, fn);
-}
-/**
-* @param {(() => void)} fn
-*/
-function branch(fn) {
-	return create_effect(32 | EFFECT_PRESERVED, fn);
-}
-/**
-* @param {Effect} effect
-*/
-function execute_effect_teardown(effect) {
-	var teardown = effect.teardown;
-	if (teardown !== null) {
-		const previously_destroying_effect = is_destroying_effect;
-		const previous_reaction = active_reaction;
-		set_is_destroying_effect(true);
-		set_active_reaction(null);
-		try {
-			teardown.call(null);
-		} finally {
-			set_is_destroying_effect(previously_destroying_effect);
-			set_active_reaction(previous_reaction);
-		}
-	}
-}
-/**
-* @param {Effect} signal
-* @param {boolean} remove_dom
-* @returns {void}
-*/
-function destroy_effect_children(signal, remove_dom = false) {
-	var effect = signal.first;
-	signal.first = signal.last = null;
-	while (effect !== null) {
-		const controller = effect.ac;
-		if (controller !== null) without_reactive_context(() => {
-			controller.abort(STALE_REACTION);
-		});
-		var next = effect.next;
-		if ((effect.f & 64) !== 0) effect.parent = null;
-		else destroy_effect(effect, remove_dom);
-		effect = next;
-	}
-}
-/**
-* @param {Effect} signal
-* @returns {void}
-*/
-function destroy_block_effect_children(signal) {
-	var effect = signal.first;
-	while (effect !== null) {
-		var next = effect.next;
-		if ((effect.f & 32) === 0) destroy_effect(effect);
-		effect = next;
-	}
-}
-/**
-* @param {Effect} effect
-* @param {boolean} [remove_dom]
-* @returns {void}
-*/
-function destroy_effect(effect, remove_dom = true) {
-	var removed = false;
-	if ((remove_dom || (effect.f & 262144) !== 0) && effect.nodes !== null && effect.nodes.end !== null) {
-		remove_effect_dom(effect.nodes.start, effect.nodes.end);
-		removed = true;
-	}
-	set_signal_status(effect, DESTROYING);
-	destroy_effect_children(effect, remove_dom && !removed);
-	remove_reactions(effect, 0);
-	var transitions = effect.nodes && effect.nodes.t;
-	if (transitions !== null) for (const transition of transitions) transition.stop();
-	execute_effect_teardown(effect);
-	effect.f ^= DESTROYING;
-	effect.f |= DESTROYED;
-	var parent = effect.parent;
-	if (parent !== null && parent.first !== null) unlink_effect(effect);
-	effect.next = effect.prev = effect.teardown = effect.ctx = effect.deps = effect.fn = effect.nodes = effect.ac = effect.b = null;
-}
-/**
-*
-* @param {TemplateNode | null} node
-* @param {TemplateNode} end
-*/
-function remove_effect_dom(node, end) {
-	while (node !== null) {
-		/** @type {TemplateNode | null} */
-		var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
-		node.remove();
-		node = next;
-	}
-}
-/**
-* Detach an effect from the effect tree, freeing up memory and
-* reducing the amount of work that happens on subsequent traversals
-* @param {Effect} effect
-*/
-function unlink_effect(effect) {
-	var parent = effect.parent;
-	var prev = effect.prev;
-	var next = effect.next;
-	if (prev !== null) prev.next = next;
-	if (next !== null) next.prev = prev;
-	if (parent !== null) {
-		if (parent.first === effect) parent.first = next;
-		if (parent.last === effect) parent.last = prev;
-	}
-}
-/**
-* When a block effect is removed, we don't immediately destroy it or yank it
-* out of the DOM, because it might have transitions. Instead, we 'pause' it.
-* It stays around (in memory, and in the DOM) until outro transitions have
-* completed, and if the state change is reversed then we _resume_ it.
-* A paused effect does not update, and the DOM subtree becomes inert.
-* @param {Effect} effect
-* @param {() => void} [callback]
-* @param {boolean} [destroy]
-*/
-function pause_effect(effect, callback, destroy = true) {
-	/** @type {TransitionManager[]} */
-	var transitions = [];
-	pause_children(effect, transitions, true);
-	var fn = () => {
-		if (destroy) destroy_effect(effect);
-		if (callback) callback();
-	};
-	var remaining = transitions.length;
-	if (remaining > 0) {
-		var check = () => --remaining || fn();
-		for (var transition of transitions) transition.out(check);
-	} else fn();
-}
-/**
-* @param {Effect} effect
-* @param {TransitionManager[]} transitions
-* @param {boolean} local
-*/
-function pause_children(effect, transitions, local) {
-	if ((effect.f & 8192) !== 0) return;
-	effect.f ^= INERT;
-	var t = effect.nodes && effect.nodes.t;
-	if (t !== null) {
-		for (const transition of t) if (transition.is_global || local) transitions.push(transition);
-	}
-	var child = effect.first;
-	while (child !== null) {
-		var sibling = child.next;
-		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;
-	}
-}
-/**
-* @param {Effect} effect
-* @param {DocumentFragment} fragment
-*/
-function move_effect(effect, fragment) {
-	if (!effect.nodes) return;
-	/** @type {TemplateNode | null} */
-	var node = effect.nodes.start;
-	var end = effect.nodes.end;
-	while (node !== null) {
-		/** @type {TemplateNode | null} */
-		var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
-		fragment.append(node);
-		node = next;
-	}
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/client/runtime.js
-/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
-var is_updating_effect = false;
-var is_destroying_effect = false;
-/** @param {boolean} value */
-function set_is_destroying_effect(value) {
-	is_destroying_effect = value;
-}
-/** @type {null | Reaction} */
-var active_reaction = null;
-var untracking = false;
-/** @param {null | Reaction} reaction */
-function set_active_reaction(reaction) {
-	active_reaction = reaction;
-}
-/** @type {null | Effect} */
-var active_effect = null;
-/** @param {null | Effect} effect */
-function set_active_effect(effect) {
-	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[]}
-*/
-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);
-}
-/**
-* The dependencies of the reaction that is currently being executed. In many cases,
-* the dependencies are unchanged between runs, and so this will be `null` unless
-* and until a new dependency is accessed — we track this via `skipped_deps`
-* @type {null | Value[]}
-*/
-var new_deps = null;
-var skipped_deps = 0;
-/**
-* Tracks writes that the effect it's executed in doesn't listen to yet,
-* so that the dependency can be added to the effect later on if it then reads it
-* @type {null | Source[]}
-*/
-var untracked_writes = null;
-/** @param {null | Source[]} value */
-function set_untracked_writes(value) {
-	untracked_writes = value;
-}
-/**
-* @type {number} Used by sources and deriveds for handling updates.
-* Version starts from 1 so that unowned deriveds differentiate between a created effect and a run one for tracing
-**/
-var write_version = 1;
-/** @type {number} Used to version each read of a source of derived to avoid duplicating depedencies inside a reaction */
-var read_version = 0;
-var update_version = read_version;
-/** @param {number} value */
-function set_update_version(value) {
-	update_version = value;
-}
-function increment_write_version() {
-	return ++write_version;
-}
-/**
-* Determines whether a derived or effect is dirty.
-* If it is MAYBE_DIRTY, will set the status to CLEAN
-* @param {Reaction} reaction
-* @returns {boolean}
-*/
-function is_dirty(reaction) {
-	var flags = reaction.f;
-	if ((flags & 2048) !== 0) return true;
-	if (flags & 2) reaction.f &= ~WAS_MARKED;
-	if ((flags & 4096) !== 0) {
-		var dependencies = reaction.deps;
-		var length = dependencies.length;
-		for (var i = 0; i < length; i++) {
-			var dependency = dependencies[i];
-			if (is_dirty(dependency)) update_derived(dependency);
-			if (dependency.wv > reaction.wv) return true;
-		}
-		if ((flags & 512) !== 0 && batch_values === null) set_signal_status(reaction, CLEAN);
-	}
-	return false;
-}
-/**
-* @param {Value} signal
-* @param {Effect} effect
-* @param {boolean} [root]
-*/
-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;
-	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);
-		else if (effect === reaction) {
-			if (root) set_signal_status(reaction, DIRTY);
-			else if ((reaction.f & 1024) !== 0) set_signal_status(reaction, MAYBE_DIRTY);
-			schedule_effect(reaction);
-		}
-	}
-}
-/** @param {Reaction} reaction */
-function update_reaction(reaction) {
-	var previous_deps = new_deps;
-	var previous_skipped_deps = skipped_deps;
-	var previous_untracked_writes = untracked_writes;
-	var previous_reaction = active_reaction;
-	var previous_sources = current_sources;
-	var previous_component_context = component_context;
-	var previous_untracking = untracking;
-	var previous_update_version = update_version;
-	var flags = reaction.f;
-	new_deps = null;
-	skipped_deps = 0;
-	untracked_writes = null;
-	active_reaction = (flags & 96) === 0 ? reaction : null;
-	current_sources = null;
-	set_component_context(reaction.ctx);
-	untracking = false;
-	update_version = ++read_version;
-	if (reaction.ac !== null) {
-		without_reactive_context(() => {
-			/** @type {AbortController} */ reaction.ac.abort(STALE_REACTION);
-		});
-		reaction.ac = null;
-	}
-	try {
-		reaction.f |= REACTION_IS_UPDATING;
-		var fn = reaction.fn;
-		var result = fn();
-		reaction.f |= REACTION_RAN;
-		var deps = reaction.deps;
-		var is_fork = current_batch?.is_fork;
-		if (new_deps !== null) {
-			var i;
-			if (!is_fork) remove_reactions(reaction, skipped_deps);
-			if (deps !== null && skipped_deps > 0) {
-				deps.length = skipped_deps + new_deps.length;
-				for (i = 0; i < new_deps.length; i++) deps[skipped_deps + i] = new_deps[i];
-			} else reaction.deps = deps = new_deps;
-			if (effect_tracking() && (reaction.f & 512) !== 0) for (i = skipped_deps; i < deps.length; i++) (deps[i].reactions ??= []).push(reaction);
-		} else if (!is_fork && deps !== null && skipped_deps < deps.length) {
-			remove_reactions(reaction, skipped_deps);
-			deps.length = skipped_deps;
-		}
-		if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & 6146) === 0) for (i = 0; i < untracked_writes.length; i++) schedule_possible_effect_self_invalidation(untracked_writes[i], reaction);
-		if (previous_reaction !== null && previous_reaction !== reaction) {
-			read_version++;
-			if (previous_reaction.deps !== null) for (let i = 0; i < previous_skipped_deps; i += 1) previous_reaction.deps[i].rv = read_version;
-			if (previous_deps !== null) for (const dep of previous_deps) dep.rv = read_version;
-			if (untracked_writes !== null) if (previous_untracked_writes === null) previous_untracked_writes = untracked_writes;
-			else previous_untracked_writes.push(...untracked_writes);
-		}
-		if ((reaction.f & 8388608) !== 0) reaction.f ^= ERROR_VALUE;
-		return result;
-	} catch (error) {
-		return handle_error(error);
-	} finally {
-		reaction.f ^= REACTION_IS_UPDATING;
-		new_deps = previous_deps;
-		skipped_deps = previous_skipped_deps;
-		untracked_writes = previous_untracked_writes;
-		active_reaction = previous_reaction;
-		current_sources = previous_sources;
-		set_component_context(previous_component_context);
-		untracking = previous_untracking;
-		update_version = previous_update_version;
-	}
-}
-/**
-* @template V
-* @param {Reaction} signal
-* @param {Value<V>} dependency
-* @returns {void}
-*/
-function remove_reaction(signal, dependency) {
-	let reactions = dependency.reactions;
-	if (reactions !== null) {
-		var index = index_of.call(reactions, signal);
-		if (index !== -1) {
-			var new_length = reactions.length - 1;
-			if (new_length === 0) reactions = dependency.reactions = null;
-			else {
-				reactions[index] = reactions[new_length];
-				reactions.pop();
-			}
-		}
-	}
-	if (reactions === null && (dependency.f & 2) !== 0 && (new_deps === null || !includes.call(new_deps, dependency))) {
-		var derived = dependency;
-		if ((derived.f & 512) !== 0) {
-			derived.f ^= 512;
-			derived.f &= ~WAS_MARKED;
-		}
-		if (derived.v !== UNINITIALIZED) update_derived_status(derived);
-		freeze_derived_effects(derived);
-		remove_reactions(derived, 0);
-	}
-}
-/**
-* @param {Reaction} signal
-* @param {number} start_index
-* @returns {void}
-*/
-function remove_reactions(signal, start_index) {
-	var dependencies = signal.deps;
-	if (dependencies === null) return;
-	for (var i = start_index; i < dependencies.length; i++) remove_reaction(signal, dependencies[i]);
-}
-/**
-* @param {Effect} effect
-* @returns {void}
-*/
-function update_effect(effect) {
-	var flags = effect.f;
-	if ((flags & 16384) !== 0) return;
-	set_signal_status(effect, CLEAN);
-	var previous_effect = active_effect;
-	var was_updating_effect = is_updating_effect;
-	active_effect = effect;
-	is_updating_effect = true;
-	try {
-		if ((flags & 16777232) !== 0) destroy_block_effect_children(effect);
-		else destroy_effect_children(effect);
-		execute_effect_teardown(effect);
-		var teardown = update_reaction(effect);
-		effect.teardown = typeof teardown === "function" ? teardown : null;
-		effect.wv = write_version;
-	} finally {
-		is_updating_effect = was_updating_effect;
-		active_effect = previous_effect;
-	}
-}
-/**
-* @template V
-* @param {Value<V>} signal
-* @returns {V}
-*/
-function get(signal) {
-	var is_derived = (signal.f & 2) !== 0;
-	if (active_reaction !== null && !untracking) {
-		if (!(active_effect !== null && (active_effect.f & 16384) !== 0) && (current_sources === null || !includes.call(current_sources, signal))) {
-			var deps = active_reaction.deps;
-			if ((active_reaction.f & 2097152) !== 0) {
-				if (signal.rv < read_version) {
-					signal.rv = read_version;
-					if (new_deps === null && deps !== null && deps[skipped_deps] === signal) skipped_deps++;
-					else if (new_deps === null) new_deps = [signal];
-					else new_deps.push(signal);
-				}
-			} else {
-				(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);
-			}
-		}
-	}
-	if (is_destroying_effect && old_values.has(signal)) return old_values.get(signal);
-	if (is_derived) {
-		var derived = signal;
-		if (is_destroying_effect) {
-			var value = derived.v;
-			if ((derived.f & 1024) === 0 && derived.reactions !== null || depends_on_old_values(derived)) value = execute_derived(derived);
-			old_values.set(derived, value);
-			return value;
-		}
-		var should_connect = (derived.f & 512) === 0 && !untracking && active_reaction !== null && (is_updating_effect || (active_reaction.f & 512) !== 0);
-		var is_new = (derived.f & REACTION_RAN) === 0;
-		if (is_dirty(derived)) {
-			if (should_connect) derived.f |= 512;
-			update_derived(derived);
-		}
-		if (should_connect && !is_new) {
-			unfreeze_derived_effects(derived);
-			reconnect(derived);
-		}
-	}
-	if (batch_values?.has(signal)) return batch_values.get(signal);
-	if ((signal.f & 8388608) !== 0) throw signal.v;
-	return signal.v;
-}
-/**
-* (Re)connect a disconnected derived, so that it is notified
-* of changes in `mark_reactions`
-* @param {Derived} derived
-*/
-function reconnect(derived) {
-	derived.f |= 512;
-	if (derived.deps === null) return;
-	for (const dep of derived.deps) {
-		(dep.reactions ??= []).push(derived);
-		if ((dep.f & 2) !== 0 && (dep.f & 512) === 0) {
-			unfreeze_derived_effects(dep);
-			reconnect(dep);
-		}
-	}
-}
-/** @param {Derived} derived */
-function depends_on_old_values(derived) {
-	if (derived.v === UNINITIALIZED) return true;
-	if (derived.deps === null) return false;
-	for (const dep of derived.deps) {
-		if (old_values.has(dep)) return true;
-		if ((dep.f & 2) !== 0 && depends_on_old_values(dep)) return true;
-	}
-	return false;
-}
-/**
-* When used inside a [`$derived`](https://svelte.dev/docs/svelte/$derived) or [`$effect`](https://svelte.dev/docs/svelte/$effect),
-* any state read inside `fn` will not be treated as a dependency.
-*
-* ```ts
-* $effect(() => {
-*   // this will run when `data` changes, but not when `time` changes
-*   save(data, {
-*     timestamp: untrack(() => time)
-*   });
-* });
-* ```
-* @template T
-* @param {() => T} fn
-* @returns {T}
-*/
-function untrack(fn) {
-	var previous_untracking = untracking;
-	try {
-		untracking = true;
-		return fn();
-	} finally {
-		untracking = previous_untracking;
-	}
-}
-//#endregion
-//#region ../../node_modules/svelte/src/store/utils.js
-/** @import { Readable } from './public' */
-/**
-* @template T
-* @param {Readable<T> | null | undefined} store
-* @param {(value: T) => void} run
-* @param {(value: T) => void} [invalidate]
-* @returns {() => void}
-*/
-function subscribe_to_store(store, run, invalidate) {
-	if (store == null) {
-		run(void 0);
-		return noop;
-	}
-	const unsub = untrack(() => store.subscribe(run, invalidate));
-	return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
-}
-/**
-* Attributes that are boolean, i.e. they are present or not present.
-*/
-var DOM_BOOLEAN_ATTRIBUTES = [
-	"allowfullscreen",
-	"async",
-	"autofocus",
-	"autoplay",
-	"checked",
-	"controls",
-	"default",
-	"disabled",
-	"formnovalidate",
-	"indeterminate",
-	"inert",
-	"ismap",
-	"loop",
-	"multiple",
-	"muted",
-	"nomodule",
-	"novalidate",
-	"open",
-	"playsinline",
-	"readonly",
-	"required",
-	"reversed",
-	"seamless",
-	"selected",
-	"webkitdirectory",
-	"defer",
-	"disablepictureinpicture",
-	"disableremoteplayback"
-];
-/**
-* Returns `true` if `name` is a boolean attribute
-* @param {string} name
-*/
-function is_boolean_attribute(name) {
-	return DOM_BOOLEAN_ATTRIBUTES.includes(name);
-}
-/**
-* Subset of delegated events which should be passive by default.
-* These two are already passive via browser defaults on window, document and body.
-* But since
-* - we're delegating them
-* - they happen often
-* - they apply to mobile which is generally less performant
-* we're marking them as passive by default for other elements, too.
-*/
-var PASSIVE_EVENTS = ["touchstart", "touchmove"];
-/**
-* Returns `true` if `name` is a passive event
-* @param {string} name
-*/
-function is_passive_event(name) {
-	return PASSIVE_EVENTS.includes(name);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/blocks/html.js
-/**
-* @param {string} value
-*/
-function html(value) {
-	return "<!---->" + String(value ?? "") + "<!---->";
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/index.js
-var INVALID_ATTR_NAME_CHAR_REGEX = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
-/**
-* Only available on the server and when compiling with the `server` option.
-* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
-* @template {Record<string, any>} Props
-* @param {Component<Props> | ComponentType<SvelteComponent<Props>>} component
-* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} [options]
-* @returns {RenderOutput}
-*/
-function render(component, options = {}) {
-	if (options.csp?.hash && options.csp.nonce) invalid_csp();
-	return Renderer.render(component, options);
-}
-/**
-* @param {string} hash
-* @param {Renderer} renderer
-* @param {(renderer: Renderer) => Promise<void> | void} fn
-* @returns {void}
-*/
-function head(hash, renderer, fn) {
-	renderer.head((renderer) => {
-		renderer.push(`<!--${hash}-->`);
-		renderer.child(fn);
-		renderer.push(EMPTY_COMMENT);
-	});
-}
-/**
-* @param {Record<string, unknown>} attrs
-* @param {string} [css_hash]
-* @param {Record<string, boolean>} [classes]
-* @param {Record<string, string>} [styles]
-* @param {number} [flags]
-* @returns {string}
-*/
-function attributes(attrs, css_hash, classes, styles, flags = 0) {
-	if (styles) attrs.style = to_style(attrs.style, styles);
-	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;
-	const is_html = (flags & 1) === 0;
-	const lowercase = (flags & 2) === 0;
-	const is_input = (flags & 4) !== 0;
-	for (name of Object.keys(attrs)) {
-		if (typeof attrs[name] === "function") continue;
-		if (name[0] === "$" && name[1] === "$") continue;
-		if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
-		var value = attrs[name];
-		var lower = name.toLowerCase();
-		if (lowercase) name = lower;
-		if (lower.length > 2 && lower.startsWith("on")) continue;
-		if (is_input) {
-			if (name === "defaultvalue" || name === "defaultchecked") {
-				name = name === "defaultvalue" ? "value" : "checked";
-				if (attrs[name]) continue;
-			}
-		}
-		attr_str += attr(name, value, is_html && is_boolean_attribute(name));
-	}
-	return attr_str;
-}
-/**
-* @param {unknown} value
-* @returns {string}
-*/
-function stringify(value) {
-	return typeof value === "string" ? value : value == null ? "" : value + "";
-}
-/**
-* @param {any} value
-* @param {string | undefined} [hash]
-* @param {Record<string, boolean>} [directives]
-*/
-function attr_class(value, hash, directives) {
-	var result = to_class(value, hash, directives);
-	return result ? ` class="${escape_html(result, true)}"` : "";
-}
-/**
-* @param {any} value
-* @param {Record<string,any>|[Record<string,any>,Record<string,any>]} [directives]
-*/
-function attr_style(value, directives) {
-	var result = to_style(value, directives);
-	return result ? ` style="${escape_html(result, true)}"` : "";
-}
-/**
-* @template V
-* @param {Record<string, [any, any, any]>} store_values
-* @param {string} store_name
-* @param {Store<V> | null | undefined} store
-* @returns {V}
-*/
-function store_get(store_values, store_name, store) {
-	if (store_name in store_values && store_values[store_name][0] === store) return store_values[store_name][2];
-	store_values[store_name]?.[1]();
-	store_values[store_name] = [
-		store,
-		null,
-		void 0
-	];
-	const unsub = subscribe_to_store(
-		store,
-		/** @param {any} v */
-		(v) => store_values[store_name][2] = v
-	);
-	store_values[store_name][1] = unsub;
-	return store_values[store_name][2];
-}
-/** @param {Record<string, [any, any, any]>} store_values */
-function unsubscribe_stores(store_values) {
-	for (const store_name of Object.keys(store_values)) store_values[store_name][1]();
-}
-/**
-* Legacy mode: If the prop has a fallback and is bound in the
-* parent component, propagate the fallback value upwards.
-* @param {Record<string, unknown>} props_parent
-* @param {Record<string, unknown>} props_now
-*/
-function bind_props(props_parent, props_now) {
-	for (const key of Object.keys(props_now)) {
-		const initial_value = props_parent[key];
-		const value = props_now[key];
-		if (initial_value === void 0 && value !== void 0 && Object.getOwnPropertyDescriptor(props_parent, key)?.set) props_parent[key] = value;
-	}
-}
-/** @param {any} array_like_or_iterator */
-function ensure_array_like(array_like_or_iterator) {
-	if (array_like_or_iterator) return array_like_or_iterator.length !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator);
-	return [];
-}
-/**
-* @template V
-* @param {() => V} get_value
-*/
-function once(get_value) {
-	let value = UNINITIALIZED;
-	return () => {
-		if (value === UNINITIALIZED) value = get_value();
-		return value;
-	};
-}
-/**
-* @template T
-* @param {()=>T} fn
-* @returns {(new_value?: T) => (T | void)}
-*/
-function derived(fn) {
-	const get_value = ssr_context === null ? fn : once(fn);
-	/** @type {T | undefined} */
-	let updated_value;
-	return function(new_value) {
-		if (arguments.length === 0) return updated_value ?? get_value();
-		updated_value = new_value;
-		return updated_value;
-	};
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/crypto.js
-var text_encoder;
-var crypto;
-/** @param {string} module_name */
-var obfuscated_import = (module_name) => import(
-	/* @vite-ignore */
-	module_name
-);
-/** @param {string} data */
-async function sha256(data) {
-	text_encoder ??= new TextEncoder();
-	crypto ??= globalThis.crypto?.subtle?.digest ? globalThis.crypto : (await obfuscated_import("node:crypto")).webcrypto;
-	return base64_encode(await crypto.subtle.digest("SHA-256", text_encoder.encode(data)));
-}
-/**
-* @param {Uint8Array} bytes
-* @returns {string}
-*/
-function base64_encode(bytes) {
-	if (globalThis.Buffer) return globalThis.Buffer.from(bytes).toString("base64");
-	let binary = "";
-	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-	return btoa(binary);
-}
-//#endregion
-//#region ../../node_modules/svelte/src/internal/server/renderer.js
-/** @import { Component } from 'svelte' */
-/** @import { Csp, HydratableContext, RenderOutput, SSRContext, SyncRenderOutput, Sha256Source } from './types.js' */
-/** @import { MaybePromise } from '#shared' */
-/** @typedef {'head' | 'body'} RendererType */
-/** @typedef {{ [key in RendererType]: string }} AccumulatedContent */
-/**
-* @typedef {string | Renderer} RendererItem
-*/
-/**
-* Renderers are basically a tree of `string | Renderer`s, where each `Renderer` in the tree represents
-* work that may or may not have completed. A renderer can be {@link collect}ed to aggregate the
-* content from itself and all of its children, but this will throw if any of the children are
-* performing asynchronous work. To asynchronously collect a renderer, just `await` it.
-*
-* The `string` values within a renderer are always associated with the {@link type} of that renderer. To switch types,
-* call {@link child} with a different `type` argument.
-*/
-var Renderer = class Renderer {
-	/**
-	* The contents of the renderer.
-	* @type {RendererItem[]}
-	*/
-	#out = [];
-	/**
-	* Any `onDestroy` callbacks registered during execution of this renderer.
-	* @type {(() => void)[] | undefined}
-	*/
-	#on_destroy = void 0;
-	/**
-	* Whether this renderer is a component body.
-	* @type {boolean}
-	*/
-	#is_component_body = false;
-	/**
-	* If set, this renderer is an error boundary. When async collection
-	* of the children fails, the failed snippet is rendered instead.
-	* @type {{
-	* 	failed: (renderer: Renderer, error: unknown, reset: () => void) => void;
-	* 	transformError: (error: unknown) => unknown;
-	* 	context: SSRContext | null;
-	* } | null}
-	*/
-	#boundary = null;
-	/**
-	* The type of string content that this renderer is accumulating.
-	* @type {RendererType}
-	*/
-	type;
-	/** @type {Renderer | undefined} */
-	#parent;
-	/**
-	* Asynchronous work associated with this renderer
-	* @type {Promise<void> | undefined}
-	*/
-	promise = void 0;
-	/**
-	* State which is associated with the content tree as a whole.
-	* It will be re-exposed, uncopied, on all children.
-	* @type {SSRState}
-	* @readonly
-	*/
-	global;
-	/**
-	* State that is local to the branch it is declared in.
-	* It will be shallow-copied to all children.
-	*
-	* @type {{ select_value: string | undefined }}
-	*/
-	local;
-	/**
-	* @param {SSRState} global
-	* @param {Renderer | undefined} [parent]
-	*/
-	constructor(global, parent) {
-		this.#parent = parent;
-		this.global = global;
-		this.local = parent ? { ...parent.local } : { select_value: void 0 };
-		this.type = parent ? parent.type : "body";
-	}
-	/**
-	* @param {(renderer: Renderer) => void} fn
-	*/
-	head(fn) {
-		const head = new Renderer(this.global, this);
-		head.type = "head";
-		this.#out.push(head);
-		head.child(fn);
-	}
-	/**
-	* @param {Array<Promise<void>>} blockers
-	* @param {(renderer: Renderer) => void} fn
-	*/
-	async_block(blockers, fn) {
-		this.#out.push(BLOCK_OPEN);
-		this.async(blockers, fn);
-		this.#out.push(BLOCK_CLOSE);
-	}
-	/**
-	* @param {Array<Promise<void>>} blockers
-	* @param {(renderer: Renderer) => void} fn
-	*/
-	async(blockers, fn) {
-		let callback = fn;
-		if (blockers.length > 0) {
-			const context = ssr_context;
-			callback = (renderer) => {
-				return Promise.all(blockers).then(() => {
-					const previous_context = ssr_context;
-					try {
-						set_ssr_context(context);
-						return fn(renderer);
-					} finally {
-						set_ssr_context(previous_context);
-					}
-				});
-			};
-		}
-		this.child(callback);
-	}
-	/**
-	* @param {Array<() => void>} thunks
-	*/
-	run(thunks) {
-		const context = ssr_context;
-		let promise = Promise.resolve(thunks[0]());
-		const promises = [promise];
-		for (const fn of thunks.slice(1)) {
-			promise = promise.then(() => {
-				const previous_context = ssr_context;
-				set_ssr_context(context);
-				try {
-					return fn();
-				} finally {
-					set_ssr_context(previous_context);
-				}
-			});
-			promises.push(promise);
-		}
-		promise.catch(noop);
-		this.promise = promise;
-		return promises;
-	}
-	/**
-	* @param {(renderer: Renderer) => MaybePromise<void>} fn
-	*/
-	child_block(fn) {
-		this.#out.push(BLOCK_OPEN);
-		this.child(fn);
-		this.#out.push(BLOCK_CLOSE);
-	}
-	/**
-	* Create a child renderer. The child renderer inherits the state from the parent,
-	* but has its own content.
-	* @param {(renderer: Renderer) => MaybePromise<void>} fn
-	*/
-	child(fn) {
-		const child = new Renderer(this.global, this);
-		this.#out.push(child);
-		const parent = ssr_context;
-		set_ssr_context({
-			...ssr_context,
-			p: parent,
-			c: null,
-			r: child
-		});
-		const result = fn(child);
-		set_ssr_context(parent);
-		if (result instanceof Promise) {
-			result.catch(noop);
-			result.finally(() => set_ssr_context(null)).catch(noop);
-			if (child.global.mode === "sync") await_invalid();
-			child.promise = result;
-		}
-		return child;
-	}
-	/**
-	* Render children inside an error boundary. If the children throw and the API-level
-	* `transformError` transform handles the error (doesn't re-throw), the `failed` snippet is
-	* rendered instead. Otherwise the error propagates.
-	*
-	* @param {{ failed?: (renderer: Renderer, error: unknown, reset: () => void) => void }} props
-	* @param {(renderer: Renderer) => MaybePromise<void>} children_fn
-	*/
-	boundary(props, children_fn) {
-		const child = new Renderer(this.global, this);
-		this.#out.push(child);
-		const parent_context = ssr_context;
-		if (props.failed) child.#boundary = {
-			failed: props.failed,
-			transformError: this.global.transformError,
-			context: parent_context
-		};
-		set_ssr_context({
-			...ssr_context,
-			p: parent_context,
-			c: null,
-			r: child
-		});
-		try {
-			const result = children_fn(child);
-			set_ssr_context(parent_context);
-			if (result instanceof Promise) {
-				if (child.global.mode === "sync") await_invalid();
-				result.catch(noop);
-				child.promise = result;
-			}
-		} catch (error) {
-			set_ssr_context(parent_context);
-			const failed_snippet = props.failed;
-			if (!failed_snippet) throw error;
-			const result = this.global.transformError(error);
-			child.#out.length = 0;
-			child.#boundary = null;
-			if (result instanceof Promise) {
-				if (this.global.mode === "sync") await_invalid();
-				child.promise = result.then((transformed) => {
-					set_ssr_context(parent_context);
-					child.#out.push(Renderer.#serialize_failed_boundary(transformed));
-					failed_snippet(child, transformed, noop);
-					child.#out.push(BLOCK_CLOSE);
-				});
-				child.promise.catch(noop);
-			} else {
-				child.#out.push(Renderer.#serialize_failed_boundary(result));
-				failed_snippet(child, result, noop);
-				child.#out.push(BLOCK_CLOSE);
-			}
-		}
-	}
-	/**
-	* Create a component renderer. The component renderer inherits the state from the parent,
-	* but has its own content. It is treated as an ordering boundary for ondestroy callbacks.
-	* @param {(renderer: Renderer) => MaybePromise<void>} fn
-	* @param {Function} [component_fn]
-	* @returns {void}
-	*/
-	component(fn, component_fn) {
-		push$1();
-		const child = this.child(fn);
-		child.#is_component_body = true;
-		pop$1();
-	}
-	/**
-	* @param {Record<string, any>} attrs
-	* @param {(renderer: Renderer) => void} fn
-	* @param {string | undefined} [css_hash]
-	* @param {Record<string, boolean> | undefined} [classes]
-	* @param {Record<string, string> | undefined} [styles]
-	* @param {number | undefined} [flags]
-	* @param {boolean | undefined} [is_rich]
-	* @returns {void}
-	*/
-	select(attrs, fn, css_hash, classes, styles, flags, is_rich) {
-		const { value, ...select_attrs } = attrs;
-		this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
-		this.child((renderer) => {
-			renderer.local.select_value = value;
-			fn(renderer);
-		});
-		this.push(`${is_rich ? "<!>" : ""}</select>`);
-	}
-	/**
-	* @param {Record<string, any>} attrs
-	* @param {string | number | boolean | ((renderer: Renderer) => void)} body
-	* @param {string | undefined} [css_hash]
-	* @param {Record<string, boolean> | undefined} [classes]
-	* @param {Record<string, string> | undefined} [styles]
-	* @param {number | undefined} [flags]
-	* @param {boolean | undefined} [is_rich]
-	*/
-	option(attrs, body, css_hash, classes, styles, flags, is_rich) {
-		this.#out.push(`<option${attributes(attrs, css_hash, classes, styles, flags)}`);
-		/**
-		* @param {Renderer} renderer
-		* @param {any} value
-		* @param {{ head?: string, body: any }} content
-		*/
-		const close = (renderer, value, { head, body }) => {
-			if (has_own_property.call(attrs, "value")) value = attrs.value;
-			if (value === this.local.select_value) renderer.#out.push(" selected=\"\"");
-			renderer.#out.push(`>${body}${is_rich ? "<!>" : ""}</option>`);
-			if (head) renderer.head((child) => child.push(head));
-		};
-		if (typeof body === "function") this.child((renderer) => {
-			const r = new Renderer(this.global, this);
-			body(r);
-			if (this.global.mode === "async") return r.#collect_content_async().then((content) => {
-				close(renderer, content.body.replaceAll("<!---->", ""), content);
-			});
-			else {
-				const content = r.#collect_content();
-				close(renderer, content.body.replaceAll("<!---->", ""), content);
-			}
-		});
-		else close(this, body, { body: escape_html(body) });
-	}
-	/**
-	* @param {(renderer: Renderer) => void} fn
-	*/
-	title(fn) {
-		const path = this.get_path();
-		/** @param {string} head */
-		const close = (head) => {
-			this.global.set_title(head, path);
-		};
-		this.child((renderer) => {
-			const r = new Renderer(renderer.global, renderer);
-			fn(r);
-			if (renderer.global.mode === "async") return r.#collect_content_async().then((content) => {
-				close(content.head);
-			});
-			else close(r.#collect_content().head);
-		});
-	}
-	/**
-	* @param {string | (() => Promise<string>)} content
-	*/
-	push(content) {
-		if (typeof content === "function") this.child(async (renderer) => renderer.push(await content()));
-		else this.#out.push(content);
-	}
-	/**
-	* @param {() => void} fn
-	*/
-	on_destroy(fn) {
-		(this.#on_destroy ??= []).push(fn);
-	}
-	/**
-	* @returns {number[]}
-	*/
-	get_path() {
-		return this.#parent ? [...this.#parent.get_path(), this.#parent.#out.indexOf(this)] : [];
-	}
-	/**
-	* @deprecated this is needed for legacy component bindings
-	*/
-	copy() {
-		const copy = new Renderer(this.global, this.#parent);
-		copy.#out = this.#out.map((item) => item instanceof Renderer ? item.copy() : item);
-		copy.promise = this.promise;
-		return copy;
-	}
-	/**
-	* @param {Renderer} other
-	* @deprecated this is needed for legacy component bindings
-	*/
-	subsume(other) {
-		if (this.global.mode !== other.global.mode) throw new Error("invariant: A renderer cannot switch modes. If you're seeing this, there's a compiler bug. File an issue!");
-		this.local = other.local;
-		this.#out = other.#out.map((item, i) => {
-			const current = this.#out[i];
-			if (current instanceof Renderer && item instanceof Renderer) {
-				current.subsume(item);
-				return current;
-			}
-			return item;
-		});
-		this.promise = other.promise;
-		this.type = other.type;
-	}
-	get length() {
-		return this.#out.length;
-	}
-	/**
-	* Creates the hydration comment that marks the start of a failed boundary.
-	* The error is JSON-serialized and embedded inside an HTML comment for the client
-	* to parse during hydration. The JSON is escaped to prevent `-->` or `<!--` sequences
-	* from breaking out of the comment (XSS). Uses unicode escapes which `JSON.parse()`
-	* handles transparently.
-	* @param {unknown} error
-	* @returns {string}
-	*/
-	static #serialize_failed_boundary(error) {
-		return `<!--[?${JSON.stringify(error).replace(/>/g, "\\u003e").replace(/</g, "\\u003c")}-->`;
-	}
-	/**
-	* Only available on the server and when compiling with the `server` option.
-	* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
-	* @template {Record<string, any>} Props
-	* @param {Component<Props>} component
-	* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} [options]
-	* @returns {RenderOutput}
-	*/
-	static render(component, options = {}) {
-		/** @type {AccumulatedContent | undefined} */
-		let sync;
-		const result = {};
-		Object.defineProperties(result, {
-			html: { get: () => {
-				return (sync ??= Renderer.#render(component, options)).body;
-			} },
-			head: { get: () => {
-				return (sync ??= Renderer.#render(component, options)).head;
-			} },
-			body: { get: () => {
-				return (sync ??= Renderer.#render(component, options)).body;
-			} },
-			hashes: { value: { script: "" } },
-			then: { value: (onfulfilled, onrejected) => {
-				{
-					const result = sync ??= Renderer.#render(component, options);
-					const user_result = onfulfilled({
-						head: result.head,
-						body: result.body,
-						html: result.body,
-						hashes: { script: [] }
-					});
-					return Promise.resolve(user_result);
-				}
-			} }
-		});
-		return result;
-	}
-	/**
-	* Collect all of the `onDestroy` callbacks registered during rendering. In an async context, this is only safe to call
-	* after awaiting `collect_async`.
-	*
-	* Child renderers are "porous" and don't affect execution order, but component body renderers
-	* create ordering boundaries. Within a renderer, callbacks run in order until hitting a component boundary.
-	* @returns {Iterable<() => void>}
-	*/
-	*#collect_on_destroy() {
-		for (const component of this.#traverse_components()) yield* component.#collect_ondestroy();
-	}
-	/**
-	* Performs a depth-first search of renderers, yielding the deepest components first, then additional components as we backtrack up the tree.
-	* @returns {Iterable<Renderer>}
-	*/
-	*#traverse_components() {
-		for (const child of this.#out) if (typeof child !== "string") yield* child.#traverse_components();
-		if (this.#is_component_body) yield this;
-	}
-	/**
-	* @returns {Iterable<() => void>}
-	*/
-	*#collect_ondestroy() {
-		if (this.#on_destroy) for (const fn of this.#on_destroy) yield fn;
-		for (const child of this.#out) if (child instanceof Renderer && !child.#is_component_body) yield* child.#collect_ondestroy();
-	}
-	/**
-	* Render a component. Throws if any of the children are performing asynchronous work.
-	*
-	* @template {Record<string, any>} Props
-	* @param {Component<Props>} component
-	* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string }} options
-	* @returns {AccumulatedContent}
-	*/
-	static #render(component, options) {
-		var previous_context = ssr_context;
-		try {
-			const renderer = Renderer.#open_render("sync", component, options);
-			const content = renderer.#collect_content();
-			return Renderer.#close_render(content, renderer);
-		} finally {
-			abort();
-			set_ssr_context(previous_context);
-		}
-	}
-	/**
-	* Render a component.
-	*
-	* @template {Record<string, any>} Props
-	* @param {Component<Props>} component
-	* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} options
-	* @returns {Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>}
-	*/
-	static async #render_async(component, options) {
-		const previous_context = ssr_context;
-		try {
-			const renderer = Renderer.#open_render("async", component, options);
-			const content = await renderer.#collect_content_async();
-			const hydratables = await renderer.#collect_hydratables();
-			if (hydratables !== null) content.head = hydratables + content.head;
-			return Renderer.#close_render(content, renderer);
-		} finally {
-			set_ssr_context(previous_context);
-			abort();
-		}
-	}
-	/**
-	* Collect all of the code from the `out` array and return it as a string, or a promise resolving to a string.
-	* @param {AccumulatedContent} content
-	* @returns {AccumulatedContent}
-	*/
-	#collect_content(content = {
-		head: "",
-		body: ""
-	}) {
-		for (const item of this.#out) if (typeof item === "string") content[this.type] += item;
-		else if (item instanceof Renderer) item.#collect_content(content);
-		return content;
-	}
-	/**
-	* Collect all of the code from the `out` array and return it as a string.
-	* @param {AccumulatedContent} content
-	* @returns {Promise<AccumulatedContent>}
-	*/
-	async #collect_content_async(content = {
-		head: "",
-		body: ""
-	}) {
-		await this.promise;
-		for (const item of this.#out) if (typeof item === "string") content[this.type] += item;
-		else if (item instanceof Renderer) if (item.#boundary) {
-			/** @type {AccumulatedContent} */
-			const boundary_content = {
-				head: "",
-				body: ""
-			};
-			try {
-				await item.#collect_content_async(boundary_content);
-				content.head += boundary_content.head;
-				content.body += boundary_content.body;
-			} catch (error) {
-				const { context, failed, transformError } = item.#boundary;
-				set_ssr_context(context);
-				let promise = transformError(error);
-				set_ssr_context(null);
-				let transformed = await promise;
-				set_ssr_context(context);
-				const failed_renderer = new Renderer(item.global, item);
-				failed_renderer.type = item.type;
-				failed_renderer.#out.push(Renderer.#serialize_failed_boundary(transformed));
-				failed(failed_renderer, transformed, noop);
-				failed_renderer.#out.push(BLOCK_CLOSE);
-				await failed_renderer.#collect_content_async(content);
-			}
-		} else await item.#collect_content_async(content);
-		return content;
-	}
-	async #collect_hydratables() {
-		const ctx = get_render_context().hydratable;
-		for (const [_, key] of ctx.unresolved_promises) unresolved_hydratable(key, ctx.lookup.get(key)?.stack ?? "<missing stack trace>");
-		for (const comparison of ctx.comparisons) await comparison;
-		return await this.#hydratable_block(ctx);
-	}
-	/**
-	* @template {Record<string, any>} Props
-	* @param {'sync' | 'async'} mode
-	* @param {import('svelte').Component<Props>} component
-	* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} options
-	* @returns {Renderer}
-	*/
-	static #open_render(mode, component, options) {
-		if (options.idPrefix?.includes("--")) invalid_id_prefix();
-		var previous_context = ssr_context;
-		try {
-			const renderer = new Renderer(new SSRState(mode, options.idPrefix ? options.idPrefix + "-" : "", options.csp, options.transformError));
-			set_ssr_context({
-				p: null,
-				c: options.context ?? null,
-				r: renderer
-			});
-			renderer.push(BLOCK_OPEN);
-			component(renderer, options.props ?? {});
-			renderer.push(BLOCK_CLOSE);
-			return renderer;
-		} finally {
-			set_ssr_context(previous_context);
-		}
-	}
-	/**
-	* @param {AccumulatedContent} content
-	* @param {Renderer} renderer
-	* @returns {AccumulatedContent & { hashes: { script: Sha256Source[] } }}
-	*/
-	static #close_render(content, renderer) {
-		for (const cleanup of renderer.#collect_on_destroy()) cleanup();
-		let head = content.head + renderer.global.get_title();
-		let body = content.body;
-		for (const { hash, code } of renderer.global.css) head += `<style id="${hash}">${code}</style>`;
-		return {
-			head,
-			body,
-			hashes: { script: renderer.global.csp.script_hashes }
-		};
-	}
-	/**
-	* @param {HydratableContext} ctx
-	*/
-	async #hydratable_block(ctx) {
-		if (ctx.lookup.size === 0) return null;
-		let entries = [];
-		let has_promises = false;
-		for (const [k, v] of ctx.lookup) {
-			if (v.promises) {
-				has_promises = true;
-				for (const p of v.promises) await p;
-			}
-			entries.push(`[${uneval(k)},${v.serialized}]`);
-		}
-		let prelude = `const h = (window.__svelte ??= {}).h ??= new Map();`;
-		if (has_promises) prelude = `const r = (v) => Promise.resolve(v);
-				${prelude}`;
-		const body = `
-			{
-				${prelude}
-
-				for (const [k, v] of [
-					${entries.join(",\n					")}
-				]) {
-					h.set(k, v);
-				}
-			}
-		`;
-		let csp_attr = "";
-		if (this.global.csp.nonce) csp_attr = ` nonce="${this.global.csp.nonce}"`;
-		else if (this.global.csp.hash) {
-			const hash = await sha256(body);
-			this.global.csp.script_hashes.push(`sha256-${hash}`);
-		}
-		return `\n\t\t<script${csp_attr}>${body}<\/script>`;
-	}
-};
-var SSRState = class {
-	/** @readonly @type {Csp & { script_hashes: Sha256Source[] }} */
-	csp;
-	/** @readonly @type {'sync' | 'async'} */
-	mode;
-	/** @readonly @type {() => string} */
-	uid;
-	/** @readonly @type {Set<{ hash: string; code: string }>} */
-	css = /* @__PURE__ */ new Set();
-	/**
-	* `transformError` passed to `render`. Called when an error boundary catches an error.
-	* Throws by default if unset in `render`.
-	* @type {(error: unknown) => unknown}
-	*/
-	transformError;
-	/** @type {{ path: number[], value: string }} */
-	#title = {
-		path: [],
-		value: ""
-	};
-	/**
-	* @param {'sync' | 'async'} mode
-	* @param {string} id_prefix
-	* @param {Csp} csp
-	* @param {((error: unknown) => unknown) | undefined} [transformError]
-	*/
-	constructor(mode, id_prefix = "", csp = { hash: false }, transformError) {
-		this.mode = mode;
-		this.csp = {
-			...csp,
-			script_hashes: []
-		};
-		this.transformError = transformError ?? ((error) => {
-			throw error;
-		});
-		let uid = 1;
-		this.uid = () => `${id_prefix}s${uid++}`;
-	}
-	get_title() {
-		return this.#title.value;
-	}
-	/**
-	* Performs a depth-first (lexicographic) comparison using the path. Rejects sets
-	* from earlier than or equal to the current value.
-	* @param {string} value
-	* @param {number[]} path
-	*/
-	set_title(value, path) {
-		const current = this.#title.path;
-		let i = 0;
-		let l = Math.min(path.length, current.length);
-		while (i < l && path[i] === current[i]) i += 1;
-		if (path[i] === void 0) return;
-		if (current[i] === void 0 || path[i] > current[i]) {
-			this.#title.path = path;
-			this.#title.value = value;
-		}
-	}
-};
-
-export { mutable_source as $, stringify_key as A, stringify_string as B, valid_array_indices as C, DevalueError as D, run as E, setContext as F, hasContext as G, HOLE as H, getAllContexts as I, getAbortSignal as J, createContext as K, ssr_context as L, MAX_ARRAY_INDEX as M, NAN as N, lifecycle_function_unavailable as O, POSITIVE_INFINITY as P, experimental_async_required as Q, get_render_context as R, SPARSE as S, hydratable_serialization_failed as T, UNDEFINED as U, render as V, set as W, LEGACY_PROPS as X, get as Y, flushSync as Z, define_property as _, attr_class as a, init_operations as a0, get_first_child as a1, get_next_sibling as a2, HYDRATION_ERROR as a3, set_hydrating as a4, set_hydrate_node as a5, hydration_failed as a6, clear_text_content as a7, component_root as a8, hydrate_node as a9, create_text as aa, boundary as ab, array_from as ac, is_passive_event as ad, set_active_reaction as ae, set_active_effect as af, active_reaction as ag, active_effect as ah, hydrating as ai, push as aj, component_context as ak, hydration_mismatch as al, pop as am, attr as b, ensure_array_like as c, clsx$1 as d, escape_html as e, derived as f, getContext as g, html as h, head as i, attr_style as j, stringify as k, bind_props as l, uneval as m, noop as n, NEGATIVE_INFINITY as o, NEGATIVE_ZERO as p, is_valid_array_len as q, readable as r, store_get as s, is_valid_array_index as t, unsubscribe_stores as u, is_primitive as v, writable as w, get_type as x, is_plain_object as y, enumerable_symbols as z };
-//# sourceMappingURL=dev-BdIdjvaY.js.map