@recombine-ai/bosun 0.18.0 → 0.20.0

package/build/server/chunks/index-Do08hKbr.js

@@ -1,4065 +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;
-}
-
-const browser = false;
-
-function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx$1(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
-
-const DERIVED = 1 << 1;
-const EFFECT = 1 << 2;
-const RENDER_EFFECT = 1 << 3;
-const MANAGED_EFFECT = 1 << 24;
-const BLOCK_EFFECT = 1 << 4;
-const BRANCH_EFFECT = 1 << 5;
-const ROOT_EFFECT = 1 << 6;
-const BOUNDARY_EFFECT = 1 << 7;
-const CONNECTED = 1 << 9;
-const CLEAN = 1 << 10;
-const DIRTY = 1 << 11;
-const MAYBE_DIRTY = 1 << 12;
-const INERT = 1 << 13;
-const DESTROYED = 1 << 14;
-const REACTION_RAN = 1 << 15;
-const DESTROYING = 1 << 25;
-const EFFECT_TRANSPARENT = 1 << 16;
-const EAGER_EFFECT = 1 << 17;
-const HEAD_EFFECT = 1 << 18;
-const EFFECT_PRESERVED = 1 << 19;
-const USER_EFFECT = 1 << 20;
-const WAS_MARKED = 1 << 16;
-const REACTION_IS_UPDATING = 1 << 21;
-const ASYNC = 1 << 22;
-const ERROR_VALUE = 1 << 23;
-const STATE_SYMBOL = Symbol("$state");
-const LEGACY_PROPS = Symbol("legacy props");
-const ATTRIBUTES_CACHE = Symbol("attributes");
-const CLASS_CACHE = Symbol("class");
-const STYLE_CACHE = Symbol("style");
-const TEXT_CACHE = Symbol("text");
-const STALE_REACTION = new class StaleReactionError extends Error {
-  name = "StaleReactionError";
-  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
-}();
-const COMMENT_NODE = 8;
-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;
-const noop = () => {
-};
-function run(fn) {
-  return fn();
-}
-function run_all(arr) {
-  for (var i = 0; i < arr.length; i++) {
-    arr[i]();
-  }
-}
-function deferred() {
-  var resolve;
-  var reject;
-  var promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-function fallback(value, fallback2, lazy = false) {
-  return value === void 0 ? lazy ? (
-    /** @type {() => V} */
-    fallback2()
-  ) : (
-    /** @type {V} */
-    fallback2
-  ) : value;
-}
-function equals(value) {
-  return value === this.v;
-}
-function safe_not_equal(a, b) {
-  return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
-}
-function safe_equals(value) {
-  return !safe_not_equal(value, this.v);
-}
-function lifecycle_outside_component(name) {
-  {
-    throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
-  }
-}
-function missing_context() {
-  {
-    throw new Error(`https://svelte.dev/e/missing_context`);
-  }
-}
-function effect_update_depth_exceeded() {
-  {
-    throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
-  }
-}
-function hydration_failed() {
-  {
-    throw new Error(`https://svelte.dev/e/hydration_failed`);
-  }
-}
-function state_descriptors_fixed() {
-  {
-    throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
-  }
-}
-function state_prototype_fixed() {
-  {
-    throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
-  }
-}
-function state_unsafe_mutation() {
-  {
-    throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
-  }
-}
-function svelte_boundary_reset_onerror() {
-  {
-    throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
-  }
-}
-let tracing_mode_flag = false;
-const HYDRATION_START = "[";
-const HYDRATION_START_ELSE = "[!";
-const HYDRATION_START_FAILED = "[?";
-const HYDRATION_END = "]";
-const HYDRATION_ERROR = {};
-const ELEMENT_IS_NAMESPACED = 1;
-const ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
-const ELEMENT_IS_INPUT = 1 << 2;
-const UNINITIALIZED = Symbol("uninitialized");
-let component_context = null;
-function set_component_context(context) {
-  component_context = context;
-}
-function push$1(props, runes = false, fn) {
-  component_context = {
-    p: component_context,
-    i: false,
-    c: null,
-    e: null,
-    s: props,
-    x: null,
-    r: (
-      /** @type {Effect} */
-      active_effect
-    ),
-    l: null
-  };
-}
-function pop$1(component) {
-  var context = (
-    /** @type {ComponentContext} */
-    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 (
-    /** @type {T} */
-    {}
-  );
-}
-function is_runes() {
-  return true;
-}
-let micro_tasks = [];
-function run_micro_tasks() {
-  var tasks = micro_tasks;
-  micro_tasks = [];
-  run_all(tasks);
-}
-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);
-}
-function flush_tasks() {
-  while (micro_tasks.length > 0) {
-    run_micro_tasks();
-  }
-}
-function derived_inert() {
-  {
-    console.warn(`https://svelte.dev/e/derived_inert`);
-  }
-}
-function hydration_mismatch(location) {
-  {
-    console.warn(`https://svelte.dev/e/hydration_mismatch`);
-  }
-}
-function svelte_boundary_reset_noop() {
-  {
-    console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
-  }
-}
-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;
-  }
-  var sources = /* @__PURE__ */ new Map();
-  var is_proxied_array = is_array(value);
-  var version = /* @__PURE__ */ state(0);
-  var parent_version = update_version;
-  var with_parent = (fn) => {
-    if (update_version === parent_version) {
-      return fn();
-    }
-    var reaction = active_reaction;
-    var version2 = update_version;
-    set_active_reaction(null);
-    set_update_version(parent_version);
-    var result = fn();
-    set_active_reaction(reaction);
-    set_update_version(version2);
-    return result;
-  };
-  if (is_proxied_array) {
-    sources.set("length", /* @__PURE__ */ state(
-      /** @type {any[]} */
-      value.length
-    ));
-  }
-  return new Proxy(
-    /** @type {any} */
-    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 s2 = /* @__PURE__ */ state(descriptor.value);
-            sources.set(prop, s2);
-            return s2;
-          });
-        } 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 s2 = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
-            sources.set(prop, s2);
-            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(() => {
-            var p = proxy(exists ? target[prop] : UNINITIALIZED);
-            var s2 = /* @__PURE__ */ state(p);
-            return s2;
-          });
-          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 source2 = sources.get(prop);
-          var value2 = source2?.v;
-          if (source2 !== void 0 && value2 !== UNINITIALIZED) {
-            return {
-              enumerable: true,
-              configurable: true,
-              value: value2,
-              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(() => {
-              var p = has ? proxy(target[prop]) : UNINITIALIZED;
-              var s2 = /* @__PURE__ */ state(p);
-              return s2;
-            });
-            sources.set(prop, s);
-          }
-          var value2 = get(s);
-          if (value2 === UNINITIALIZED) {
-            return false;
-          }
-        }
-        return has;
-      },
-      set(target, prop, value2, receiver) {
-        var s = sources.get(prop);
-        var has = prop in target;
-        if (is_proxied_array && prop === "length") {
-          for (var i = value2; i < /** @type {Source<number>} */
-          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(value2));
-            sources.set(prop, s);
-          }
-        } else {
-          has = s.v !== UNINITIALIZED;
-          var p = with_parent(() => proxy(value2));
-          set(s, p);
-        }
-        var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-        if (descriptor?.set) {
-          descriptor.set.call(receiver, value2);
-        }
-        if (!has) {
-          if (is_proxied_array && typeof prop === "string") {
-            var ls = (
-              /** @type {Source<number>} */
-              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((key2) => {
-          var source3 = sources.get(key2);
-          return source3 === void 0 || source3.v !== UNINITIALIZED;
-        });
-        for (var [key, source2] of sources) {
-          if (source2.v !== UNINITIALIZED && !(key in target)) {
-            own_keys.push(key);
-          }
-        }
-        return own_keys;
-      },
-      setPrototypeOf() {
-        state_prototype_fixed();
-      }
-    }
-  );
-}
-var $window;
-var first_child_getter;
-var next_sibling_getter;
-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)) {
-    element_prototype[CLASS_CACHE] = void 0;
-    element_prototype[ATTRIBUTES_CACHE] = null;
-    element_prototype[STYLE_CACHE] = void 0;
-    element_prototype.__e = void 0;
-  }
-  if (is_extensible(text_prototype)) {
-    text_prototype[TEXT_CACHE] = void 0;
-  }
-}
-function create_text(value = "") {
-  return document.createTextNode(value);
-}
-// @__NO_SIDE_EFFECTS__
-function get_first_child(node) {
-  return (
-    /** @type {TemplateNode | null} */
-    first_child_getter.call(node)
-  );
-}
-// @__NO_SIDE_EFFECTS__
-function get_next_sibling(node) {
-  return (
-    /** @type {TemplateNode | null} */
-    next_sibling_getter.call(node)
-  );
-}
-function clear_text_content(node) {
-  node.textContent = "";
-}
-function handle_error(error) {
-  var effect = active_effect;
-  if (effect === null) {
-    active_reaction.f |= ERROR_VALUE;
-    return error;
-  }
-  if ((effect.f & REACTION_RAN) === 0 && (effect.f & EFFECT) === 0) {
-    throw error;
-  }
-  invoke_error_boundary(error, effect);
-}
-function invoke_error_boundary(error, effect) {
-  if (effect !== null && (effect.f & DESTROYED) !== 0) {
-    return;
-  }
-  while (effect !== null) {
-    if ((effect.f & BOUNDARY_EFFECT) !== 0) {
-      if ((effect.f & REACTION_RAN) === 0) {
-        throw error;
-      }
-      try {
-        effect.b.error(error);
-        return;
-      } catch (e) {
-        error = e;
-      }
-    }
-    effect = effect.parent;
-  }
-  throw error;
-}
-const STATUS_MASK = -7169;
-function set_signal_status(signal, status) {
-  signal.f = signal.f & STATUS_MASK | status;
-}
-function update_derived_status(derived2) {
-  if ((derived2.f & CONNECTED) !== 0 || derived2.deps === null) {
-    set_signal_status(derived2, CLEAN);
-  } else {
-    set_signal_status(derived2, MAYBE_DIRTY);
-  }
-}
-function clear_marked(deps) {
-  if (deps === null) return;
-  for (const dep of deps) {
-    if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) {
-      continue;
-    }
-    dep.f ^= WAS_MARKED;
-    clear_marked(
-      /** @type {Derived} */
-      dep.deps
-    );
-  }
-}
-function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
-  if ((effect.f & DIRTY) !== 0) {
-    dirty_effects.add(effect);
-  } else if ((effect.f & MAYBE_DIRTY) !== 0) {
-    maybe_dirty_effects.add(effect);
-  }
-  clear_marked(effect.deps);
-  set_signal_status(effect, CLEAN);
-}
-function subscribe_to_store(store, run2, invalidate) {
-  if (store == null) {
-    run2(void 0);
-    return noop;
-  }
-  const unsub = untrack(
-    () => store.subscribe(
-      run2,
-      // @ts-expect-error
-      invalidate
-    )
-  );
-  return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
-}
-const OBSOLETE = Symbol("obsolete");
-function destroy_derived_effects(derived2) {
-  var effects = derived2.effects;
-  if (effects !== null) {
-    derived2.effects = null;
-    for (var i = 0; i < effects.length; i += 1) {
-      destroy_effect(
-        /** @type {Effect} */
-        effects[i]
-      );
-    }
-  }
-}
-function execute_derived(derived2) {
-  var value;
-  var prev_active_effect = active_effect;
-  var parent = derived2.parent;
-  if (!is_destroying_effect && parent !== null && derived2.v !== UNINITIALIZED && // if it was never evaluated before, it's guaranteed to fail downstream, so we try to execute instead
-  (parent.f & (DESTROYED | INERT)) !== 0) {
-    derived_inert();
-    return derived2.v;
-  }
-  set_active_effect(parent);
-  {
-    try {
-      derived2.f &= ~WAS_MARKED;
-      destroy_derived_effects(derived2);
-      value = update_reaction(derived2);
-    } finally {
-      set_active_effect(prev_active_effect);
-    }
-  }
-  return value;
-}
-function update_derived(derived2) {
-  var value = execute_derived(derived2);
-  if (!derived2.equals(value)) {
-    derived2.wv = increment_write_version();
-    if (!current_batch?.is_fork || derived2.deps === null) {
-      if (current_batch !== null) {
-        current_batch.capture(derived2, value, true);
-        previous_batch?.capture(derived2, value, true);
-      } else {
-        derived2.v = value;
-      }
-      if (derived2.deps === null) {
-        set_signal_status(derived2, CLEAN);
-        return;
-      }
-    }
-  }
-  if (is_destroying_effect) {
-    return;
-  }
-  if (batch_values !== null) {
-    if (effect_tracking() || current_batch?.is_fork) {
-      batch_values.set(derived2, value);
-    }
-  } else {
-    update_derived_status(derived2);
-  }
-}
-function freeze_derived_effects(derived2) {
-  if (derived2.effects === null) return;
-  for (const e of derived2.effects) {
-    if (e.teardown || e.ac) {
-      e.teardown?.();
-      e.ac?.abort(STALE_REACTION);
-      if (e.fn !== null) e.teardown = noop;
-      e.ac = null;
-      remove_reactions(e, 0);
-      destroy_effect_children(e);
-    }
-  }
-}
-function unfreeze_derived_effects(derived2) {
-  if (derived2.effects === null) return;
-  for (const e of derived2.effects) {
-    if (e.teardown && e.fn !== null) {
-      update_effect(e);
-    }
-  }
-}
-let first_batch = null;
-let last_batch = null;
-let current_batch = null;
-let previous_batch = null;
-let batch_values = null;
-let last_scheduled_effect = null;
-let is_flushing_sync = false;
-let is_processing = false;
-let collected_effects = null;
-let legacy_updates = null;
-var flush_count = 0;
-let uid = 1;
-class Batch {
-  id = uid++;
-  /** True as soon as `#process` was called */
-  #started = false;
-  linked = true;
-  /** @type {Batch | null} */
-  #prev = null;
-  /** @type {Batch | null} */
-  #next = null;
-  /** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
-  async_deriveds = /* @__PURE__ */ new Map();
-  /**
-   * The current values of any signals that are updated in this batch.
-   * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
-   * They keys of this map are identical to `this.#previous`
-   * @type {Map<Value, [any, boolean]>}
-   */
-  current = /* @__PURE__ */ new Map();
-  /**
-   * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
-   * They keys of this map are identical to `this.#current`
-   * @type {Map<Value, any>}
-   */
-  previous = /* @__PURE__ */ new Map();
-  /**
-   * When the batch is committed (and the DOM is updated), we need to remove old branches
-   * and append new ones by calling the functions added inside (if/each/key/etc) blocks
-   * @type {Set<(batch: Batch) => void>}
-   */
-  #commit_callbacks = /* @__PURE__ */ new Set();
-  /**
-   * If a fork is discarded, we need to destroy any effects that are no longer needed
-   * @type {Set<(batch: Batch) => void>}
-   */
-  #discard_callbacks = /* @__PURE__ */ new Set();
-  /**
-   * The number of async effects that are currently in flight
-   */
-  #pending = 0;
-  /**
-   * Async effects that are currently in flight, _not_ inside a pending boundary
-   * @type {Map<Effect, number>}
-   */
-  #blocking_pending = /* @__PURE__ */ new Map();
-  /**
-   * A deferred that resolves when the batch is committed, used with `settled()`
-   * TODO replace with Promise.withResolvers once supported widely enough
-   * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
-   */
-  #deferred = null;
-  /**
-   * The root effects that need to be flushed
-   * @type {Effect[]}
-   */
-  #roots = [];
-  /**
-   * Effects created while this batch was active.
-   * @type {Effect[]}
-   */
-  #new_effects = [];
-  /**
-   * 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;
-  constructor() {
-    if (last_batch === null) {
-      first_batch = last_batch = this;
-    } else {
-      last_batch.#next = this;
-      this.#prev = last_batch;
-    }
-    last_batch = this;
-  }
-  #is_deferred() {
-    if (this.is_fork) return true;
-    for (const effect of this.#blocking_pending.keys()) {
-      var e = effect;
-      var skipped = false;
-      while (e.parent !== null) {
-        if (this.#skipped_branches.has(e)) {
-          skipped = true;
-          break;
-        }
-        e = e.parent;
-      }
-      if (!skipped) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Add an effect to the #skipped_branches map and reset its children
-   * @param {Effect} effect
-   */
-  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();
-    }
-    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();
-    var effects = collected_effects = [];
-    var render_effects = [];
-    var updates = legacy_updates = [];
-    for (const root of roots) {
-      try {
-        this.#traverse(root, effects, render_effects);
-      } catch (e) {
-        reset_all(root);
-        if (!this.#is_deferred()) this.discard();
-        throw e;
-      }
-    }
-    current_batch = null;
-    if (updates.length > 0) {
-      var batch = Batch.ensure();
-      for (const e of updates) {
-        batch.schedule(e);
-      }
-    }
-    collected_effects = null;
-    legacy_updates = null;
-    if (this.#is_deferred()) {
-      this.#defer_effects(render_effects);
-      this.#defer_effects(effects);
-      for (const [e, t] of this.#skipped_branches) {
-        reset_branch(e, t);
-      }
-      if (updates.length > 0) {
-        /** @type {unknown} */
-        current_batch.#process();
-      }
-      return;
-    }
-    const earlier_batch = this.#find_earlier_batch();
-    if (earlier_batch) {
-      this.#defer_effects(render_effects);
-      this.#defer_effects(effects);
-      earlier_batch.#merge(this);
-      return;
-    }
-    this.#dirty_effects.clear();
-    this.#maybe_dirty_effects.clear();
-    for (const fn of this.#commit_callbacks) fn(this);
-    this.#commit_callbacks.clear();
-    previous_batch = this;
-    flush_queued_effects(render_effects);
-    flush_queued_effects(effects);
-    previous_batch = null;
-    this.#deferred?.resolve();
-    var next_batch = (
-      /** @type {Batch | null} */
-      /** @type {unknown} */
-      current_batch
-    );
-    if (this.#pending === 0 && (this.#roots.length === 0 || next_batch !== null)) {
-      this.#unlink();
-    }
-    if (this.#roots.length > 0) {
-      if (next_batch !== null) {
-        const batch2 = next_batch;
-        batch2.#roots.push(...this.#roots.filter((r) => !batch2.#roots.includes(r)));
-      } else {
-        next_batch = this;
-      }
-    }
-    if (next_batch !== null) {
-      next_batch.#process();
-    }
-  }
-  /**
-   * Traverse the effect tree, executing effects or stashing
-   * them for later execution as appropriate
-   * @param {Effect} root
-   * @param {Effect[]} effects
-   * @param {Effect[]} render_effects
-   */
-  #traverse(root, effects, render_effects) {
-    root.f ^= CLEAN;
-    var effect = root.first;
-    while (effect !== null) {
-      var flags = effect.f;
-      var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
-      var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
-      var skip = is_skippable_branch || (flags & INERT) !== 0 || this.#skipped_branches.has(effect);
-      if (!skip && effect.fn !== null) {
-        if (is_branch) {
-          effect.f ^= CLEAN;
-        } else if ((flags & EFFECT) !== 0) {
-          effects.push(effect);
-        } else if (is_dirty(effect)) {
-          if ((flags & BLOCK_EFFECT) !== 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 [source2, value] of batch.current) {
-      if (!this.previous.has(source2) && batch.previous.has(source2)) {
-        this.previous.set(source2, batch.previous.get(source2));
-      }
-      this.current.set(source2, value);
-    }
-    for (const [effect, deferred2] of batch.async_deriveds) {
-      const d = this.async_deriveds.get(effect);
-      if (d) deferred2.promise.then(d.resolve).catch(d.reject);
-    }
-    batch.async_deriveds.clear();
-    this.transfer_effects(batch.#dirty_effects, batch.#maybe_dirty_effects);
-    const mark = (value) => {
-      var reactions = value.reactions;
-      if (reactions === null) return;
-      for (const reaction of reactions) {
-        var flags = reaction.f;
-        if ((flags & DERIVED) !== 0) {
-          mark(
-            /** @type {Derived} */
-            reaction
-          );
-        } else {
-          var effect = (
-            /** @type {Effect} */
-            reaction
-          );
-          if (flags & (ASYNC | BLOCK_EFFECT) && !this.async_deriveds.has(effect)) {
-            this.#maybe_dirty_effects.delete(effect);
-            set_signal_status(effect, DIRTY);
-            this.schedule(effect);
-          }
-        }
-      }
-    };
-    for (const source2 of this.current.keys()) {
-      mark(source2);
-    }
-    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(source2, value, is_derived = false) {
-    if (source2.v !== UNINITIALIZED && !this.previous.has(source2)) {
-      this.previous.set(source2, source2.v);
-    }
-    if ((source2.f & ERROR_VALUE) === 0) {
-      this.current.set(source2, [value, is_derived]);
-      batch_values?.set(source2, value);
-    }
-    if (!this.is_fork) {
-      source2.v = value;
-    }
-  }
-  activate() {
-    current_batch = this;
-  }
-  deactivate() {
-    current_batch = null;
-    batch_values = null;
-  }
-  flush() {
-    try {
-      if (browser) ;
-      is_processing = true;
-      current_batch = this;
-      this.#process();
-    } finally {
-      flush_count = 0;
-      last_scheduled_effect = null;
-      collected_effects = null;
-      legacy_updates = null;
-      is_processing = false;
-      current_batch = null;
-      batch_values = null;
-      old_values.clear();
-    }
-  }
-  discard() {
-    for (const fn of this.#discard_callbacks) fn(this);
-    this.#discard_callbacks.clear();
-    for (const deferred2 of this.async_deriveds.values()) {
-      deferred2.reject(OBSOLETE);
-    }
-    this.#unlink();
-    this.#deferred?.resolve();
-  }
-  /**
-   * @param {Effect} effect
-   */
-  register_created_effect(effect) {
-    this.#new_effects.push(effect);
-  }
-  #commit() {
-    for (let batch = first_batch; batch !== null; batch = batch.#next) {
-      var is_earlier = batch.id < this.id;
-      var sources = [];
-      for (const [source3, [value, is_derived]] of this.current) {
-        if (batch.current.has(source3)) {
-          var batch_value = (
-            /** @type {[any, boolean]} */
-            batch.current.get(source3)[0]
-          );
-          if (is_earlier && value !== batch_value) {
-            batch.current.set(source3, [value, is_derived]);
-          } else {
-            continue;
-          }
-        }
-        sources.push(source3);
-      }
-      if (is_earlier) {
-        for (const [effect, deferred2] of this.async_deriveds) {
-          const d = batch.async_deriveds.get(effect);
-          if (d) deferred2.promise.then(d.resolve).catch(d.reject);
-        }
-      }
-      var current = [...batch.current.keys()].filter(
-        (source3) => !/** @type {[any, boolean]} */
-        batch.current.get(source3)[1]
-      );
-      if (!batch.#started || current.length === 0) continue;
-      var others = current.filter((source3) => !this.current.has(source3));
-      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 & (BLOCK_EFFECT | ASYNC)) !== 0) {
-                batch.schedule(e);
-              } else {
-                batch.#defer_effects([e]);
-              }
-            });
-          }
-        }
-        batch.activate();
-        var marked = /* @__PURE__ */ new Set();
-        var checked = /* @__PURE__ */ new Map();
-        for (var source2 of sources) {
-          mark_effects(source2, others, marked, checked);
-        }
-        checked = /* @__PURE__ */ new Map();
-        var current_unequal = [...batch.current].filter(([c, v1]) => {
-          const v2 = this.current.get(c);
-          if (!v2) return true;
-          return v2[0] !== v1[0] || v2[1] !== v1[1];
-        }).map(([c]) => c);
-        if (current_unequal.length > 0) {
-          for (const effect of this.#new_effects) {
-            if ((effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 && depends_on(effect, current_unequal, checked)) {
-              if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
-                set_signal_status(effect, DIRTY);
-                batch.schedule(effect);
-              } else {
-                batch.#dirty_effects.add(effect);
-              }
-            }
-          }
-        }
-        if (batch.#roots.length > 0 && !batch.#decrement_queued) {
-          batch.apply();
-          for (var root of batch.#roots) {
-            batch.#traverse(root, [], []);
-          }
-          batch.#roots = [];
-        }
-        batch.deactivate();
-      }
-    }
-  }
-  /**
-   * @param {boolean} blocking
-   * @param {Effect} effect
-   */
-  increment(blocking, effect) {
-    this.#pending += 1;
-    if (blocking) {
-      let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
-      this.#blocking_pending.set(effect, blocking_pending_count + 1);
-    }
-  }
-  /**
-   * @param {boolean} blocking
-   * @param {Effect} effect
-   */
-  decrement(blocking, effect) {
-    this.#pending -= 1;
-    if (blocking) {
-      let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
-      if (blocking_pending_count === 1) {
-        this.#blocking_pending.delete(effect);
-      } else {
-        this.#blocking_pending.set(effect, blocking_pending_count - 1);
-      }
-    }
-    if (this.#decrement_queued) return;
-    this.#decrement_queued = true;
-    queue_micro_task(() => {
-      this.#decrement_queued = false;
-      if (this.linked) {
-        this.flush();
-      }
-    });
-  }
-  /**
-   * @param {Set<Effect>} dirty_effects
-   * @param {Set<Effect>} maybe_dirty_effects
-   */
-  transfer_effects(dirty_effects, maybe_dirty_effects) {
-    for (const e of dirty_effects) {
-      this.#dirty_effects.add(e);
-    }
-    for (const e of maybe_dirty_effects) {
-      this.#maybe_dirty_effects.add(e);
-    }
-    dirty_effects.clear();
-    maybe_dirty_effects.clear();
-  }
-  /** @param {(batch: Batch) => void} fn */
-  oncommit(fn) {
-    this.#commit_callbacks.add(fn);
-  }
-  /** @param {(batch: Batch) => void} fn */
-  ondiscard(fn) {
-    this.#discard_callbacks.add(fn);
-  }
-  settled() {
-    return (this.#deferred ??= deferred()).promise;
-  }
-  static ensure() {
-    if (current_batch === null) {
-      const batch = current_batch = new Batch();
-      if (!is_processing && !is_flushing_sync) {
-        queue_micro_task(() => {
-          if (!batch.#started) {
-            batch.flush();
-          }
-        });
-      }
-    }
-    return current_batch;
-  }
-  apply() {
-    {
-      batch_values = null;
-      return;
-    }
-  }
-  /**
-   *
-   * @param {Effect} effect
-   */
-  schedule(effect) {
-    last_scheduled_effect = effect;
-    if (effect.b?.is_pending && (effect.f & (EFFECT | RENDER_EFFECT | MANAGED_EFFECT)) !== 0 && (effect.f & REACTION_RAN) === 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 & DERIVED) === 0) && true) {
-          return;
-        }
-      }
-      if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
-        if ((flags & CLEAN) === 0) {
-          return;
-        }
-        e.f ^= CLEAN;
-      }
-    }
-    this.#roots.push(e);
-  }
-  #unlink() {
-    if (!this.linked) return;
-    var prev = this.#prev;
-    var next = this.#next;
-    if (prev === null) {
-      first_batch = next;
-    } else {
-      prev.#next = next;
-    }
-    if (next === null) {
-      last_batch = prev;
-    } else {
-      next.#prev = prev;
-    }
-    this.linked = false;
-  }
-}
-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 (
-          /** @type {T} */
-          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);
-  }
-}
-let eager_block_effects = null;
-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 & (DESTROYED | INERT)) === 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 & (DESTROYED | INERT)) !== 0) continue;
-          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 e2 = ordered_effects[j];
-            if ((e2.f & (DESTROYED | INERT)) !== 0) continue;
-            update_effect(e2);
-          }
-        }
-        eager_block_effects.clear();
-      }
-    }
-  }
-  eager_block_effects = null;
-}
-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 & DERIVED) !== 0) {
-        mark_effects(
-          /** @type {Derived} */
-          reaction,
-          sources,
-          marked,
-          checked
-        );
-      } else if ((flags & (ASYNC | BLOCK_EFFECT)) !== 0 && (flags & DIRTY) === 0 && depends_on(reaction, sources, checked)) {
-        set_signal_status(reaction, DIRTY);
-        schedule_effect(
-          /** @type {Effect} */
-          reaction
-        );
-      }
-    }
-  }
-}
-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 & DERIVED) !== 0 && depends_on(
-        /** @type {Derived} */
-        dep,
-        sources,
-        checked
-      )) {
-        checked.set(
-          /** @type {Derived} */
-          dep,
-          true
-        );
-        return true;
-      }
-    }
-  }
-  checked.set(reaction, false);
-  return false;
-}
-function schedule_effect(effect) {
-  current_batch.schedule(effect);
-}
-function reset_branch(effect, tracked) {
-  if ((effect.f & BRANCH_EFFECT) !== 0 && (effect.f & CLEAN) !== 0) {
-    return;
-  }
-  if ((effect.f & DIRTY) !== 0) {
-    tracked.d.push(effect);
-  } else if ((effect.f & MAYBE_DIRTY) !== 0) {
-    tracked.m.push(effect);
-  }
-  set_signal_status(effect, CLEAN);
-  var e = effect.first;
-  while (e !== null) {
-    reset_branch(e, tracked);
-    e = e.next;
-  }
-}
-function reset_all(effect) {
-  set_signal_status(effect, CLEAN);
-  var e = effect.first;
-  while (e !== null) {
-    reset_all(e);
-    e = e.next;
-  }
-}
-let eager_effects = /* @__PURE__ */ new Set();
-const old_values = /* @__PURE__ */ new Map();
-let eager_effects_deferred = false;
-function source(v, stack) {
-  var signal = {
-    f: 0,
-    // TODO ideally we could skip this altogether, but it causes type errors
-    v,
-    reactions: null,
-    equals,
-    rv: 0,
-    wv: 0
-  };
-  return signal;
-}
-// @__NO_SIDE_EFFECTS__
-function state(v, stack) {
-  const s = source(v);
-  push_reaction_value(s);
-  return s;
-}
-// @__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;
-}
-function set(source2, value, should_proxy = false) {
-  if (active_reaction !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
-  // to ensure we error if state is set inside an inspect effect
-  (!untracking || (active_reaction.f & EAGER_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | EAGER_EFFECT)) !== 0 && (current_sources === null || !current_sources.has(source2))) {
-    state_unsafe_mutation();
-  }
-  let new_value = should_proxy ? proxy(value) : value;
-  return internal_set(source2, new_value, legacy_updates);
-}
-function internal_set(source2, value, updated_during_traversal = null) {
-  if (!source2.equals(value)) {
-    old_values.set(source2, is_destroying_effect ? value : source2.v);
-    var batch = Batch.ensure();
-    batch.capture(source2, value);
-    if ((source2.f & DERIVED) !== 0) {
-      const derived2 = (
-        /** @type {Derived} */
-        source2
-      );
-      if ((source2.f & DIRTY) !== 0) {
-        execute_derived(derived2);
-      }
-      if (batch_values === null) {
-        update_derived_status(derived2);
-      }
-    }
-    source2.wv = increment_write_version();
-    mark_reactions(source2, DIRTY, updated_during_traversal);
-    if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
-      if (untracked_writes === null) {
-        set_untracked_writes([source2]);
-      } else {
-        untracked_writes.push(source2);
-      }
-    }
-    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 & CLEAN) !== 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();
-}
-function increment(source2) {
-  set(source2, source2.v + 1);
-}
-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 & EAGER_EFFECT) !== 0) {
-      eager_effects.add(
-        /** @type {Effect} */
-        reaction
-      );
-    } else if ((flags & DERIVED) !== 0) {
-      var derived2 = (
-        /** @type {Derived} */
-        reaction
-      );
-      batch_values?.delete(derived2);
-      if ((flags & WAS_MARKED) === 0) {
-        if (flags & CONNECTED && (active_effect === null || (active_effect.f & REACTION_IS_UPDATING) === 0)) {
-          reaction.f |= WAS_MARKED;
-        }
-        mark_reactions(derived2, MAYBE_DIRTY, updated_during_traversal);
-      }
-    } else if (not_dirty) {
-      var effect = (
-        /** @type {Effect} */
-        reaction
-      );
-      if ((flags & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
-        eager_block_effects.add(effect);
-      }
-      if (updated_during_traversal !== null) {
-        updated_during_traversal.push(effect);
-      } else {
-        schedule_effect(effect);
-      }
-    }
-  }
-}
-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);
-  }
-}
-let is_updating_effect = false;
-let is_destroying_effect = false;
-function set_is_destroying_effect(value) {
-  is_destroying_effect = value;
-}
-let active_reaction = null;
-let untracking = false;
-function set_active_reaction(reaction) {
-  active_reaction = reaction;
-}
-let active_effect = null;
-function set_active_effect(effect) {
-  active_effect = effect;
-}
-let current_sources = null;
-function push_reaction_value(value) {
-  if (active_reaction !== null && true) {
-    (current_sources ??= /* @__PURE__ */ new Set()).add(value);
-  }
-}
-let new_deps = null;
-let skipped_deps = 0;
-let untracked_writes = null;
-function set_untracked_writes(value) {
-  untracked_writes = value;
-}
-let write_version = 1;
-let read_version = 0;
-let update_version = read_version;
-function set_update_version(value) {
-  update_version = value;
-}
-function increment_write_version() {
-  return ++write_version;
-}
-function is_dirty(reaction) {
-  var flags = reaction.f;
-  if ((flags & DIRTY) !== 0) {
-    return true;
-  }
-  if (flags & DERIVED) {
-    reaction.f &= ~WAS_MARKED;
-  }
-  if ((flags & MAYBE_DIRTY) !== 0) {
-    var dependencies = (
-      /** @type {Value[]} */
-      reaction.deps
-    );
-    var length = dependencies.length;
-    for (var i = 0; i < length; i++) {
-      var dependency = dependencies[i];
-      if (is_dirty(
-        /** @type {Derived} */
-        dependency
-      )) {
-        update_derived(
-          /** @type {Derived} */
-          dependency
-        );
-      }
-      if (dependency.wv > reaction.wv) {
-        return true;
-      }
-    }
-    if ((flags & CONNECTED) !== 0 && // During time traveling we don't want to reset the status so that
-    // traversal of the graph in the other batches still happens
-    batch_values === null) {
-      set_signal_status(reaction, CLEAN);
-    }
-  }
-  return false;
-}
-function schedule_possible_effect_self_invalidation(signal, effect, root = true) {
-  var reactions = signal.reactions;
-  if (reactions === null) return;
-  if (current_sources !== null && current_sources.has(signal)) {
-    return;
-  }
-  for (var i = 0; i < reactions.length; i++) {
-    var reaction = reactions[i];
-    if ((reaction.f & DERIVED) !== 0) {
-      schedule_possible_effect_self_invalidation(
-        /** @type {Derived} */
-        reaction,
-        effect,
-        false
-      );
-    } else if (effect === reaction) {
-      if (root) {
-        set_signal_status(reaction, DIRTY);
-      } else if ((reaction.f & CLEAN) !== 0) {
-        set_signal_status(reaction, MAYBE_DIRTY);
-      }
-      schedule_effect(
-        /** @type {Effect} */
-        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 = /** @type {null | Value[]} */
-  null;
-  skipped_deps = 0;
-  untracked_writes = null;
-  active_reaction = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
-  current_sources = null;
-  set_component_context(reaction.ctx);
-  untracking = false;
-  update_version = ++read_version;
-  if (reaction.ac !== null) {
-    without_reactive_context(() => {
-      reaction.ac.abort(STALE_REACTION);
-    });
-    reaction.ac = null;
-  }
-  try {
-    reaction.f |= REACTION_IS_UPDATING;
-    var fn = (
-      /** @type {Function} */
-      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 & CONNECTED) !== 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 & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0) {
-      for (i = 0; i < /** @type {Source[]} */
-      untracked_writes.length; i++) {
-        schedule_possible_effect_self_invalidation(
-          untracked_writes[i],
-          /** @type {Effect} */
-          reaction
-        );
-      }
-    }
-    if (previous_reaction !== null && previous_reaction !== reaction) {
-      read_version++;
-      if (previous_reaction.deps !== null) {
-        for (let i2 = 0; i2 < previous_skipped_deps; i2 += 1) {
-          previous_reaction.deps[i2].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(.../** @type {Source[]} */
-          untracked_writes);
-        }
-      }
-    }
-    if ((reaction.f & ERROR_VALUE) !== 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;
-  }
-}
-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 & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
-  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
-  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
-  (new_deps === null || !includes.call(new_deps, dependency))) {
-    var derived2 = (
-      /** @type {Derived} */
-      dependency
-    );
-    if ((derived2.f & CONNECTED) !== 0) {
-      derived2.f ^= CONNECTED;
-      derived2.f &= ~WAS_MARKED;
-    }
-    if (derived2.v !== UNINITIALIZED) {
-      update_derived_status(derived2);
-    }
-    freeze_derived_effects(derived2);
-    remove_reactions(derived2, 0);
-  }
-}
-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]);
-  }
-}
-function update_effect(effect) {
-  var flags = effect.f;
-  if ((flags & DESTROYED) !== 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 & (BLOCK_EFFECT | MANAGED_EFFECT)) !== 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;
-    var dep;
-    if (browser && tracing_mode_flag && (effect.f & DIRTY) !== 0 && effect.deps !== null) ;
-  } finally {
-    is_updating_effect = was_updating_effect;
-    active_effect = previous_effect;
-  }
-}
-function get(signal) {
-  var flags = signal.f;
-  var is_derived = (flags & DERIVED) !== 0;
-  if (active_reaction !== null && !untracking) {
-    var destroyed = active_effect !== null && (active_effect.f & DESTROYED) !== 0;
-    if (!destroyed && (current_sources === null || !current_sources.has(signal))) {
-      var deps = active_reaction.deps;
-      if ((active_reaction.f & REACTION_IS_UPDATING) !== 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 ??= [];
-        if (!includes.call(active_reaction.deps, signal)) {
-          active_reaction.deps.push(signal);
-        }
-        var reactions = signal.reactions;
-        if (reactions === null) {
-          signal.reactions = [active_reaction];
-        } else if (!includes.call(reactions, active_reaction)) {
-          reactions.push(active_reaction);
-        }
-      }
-    }
-  }
-  if (is_destroying_effect && old_values.has(signal)) {
-    return old_values.get(signal);
-  }
-  if (is_derived) {
-    var derived2 = (
-      /** @type {Derived} */
-      signal
-    );
-    if (is_destroying_effect) {
-      var value = derived2.v;
-      if ((derived2.f & CLEAN) === 0 && derived2.reactions !== null || depends_on_old_values(derived2)) {
-        value = execute_derived(derived2);
-      }
-      old_values.set(derived2, value);
-      return value;
-    }
-    var should_connect = (derived2.f & CONNECTED) === 0 && !untracking && active_reaction !== null && (is_updating_effect || (active_reaction.f & CONNECTED) !== 0);
-    var is_new = (derived2.f & REACTION_RAN) === 0;
-    if (is_dirty(derived2)) {
-      if (should_connect) {
-        derived2.f |= CONNECTED;
-      }
-      update_derived(derived2);
-    }
-    if (should_connect && !is_new) {
-      unfreeze_derived_effects(derived2);
-      reconnect(derived2);
-    }
-  }
-  if (batch_values?.has(signal)) {
-    return batch_values.get(signal);
-  }
-  if ((signal.f & ERROR_VALUE) !== 0) {
-    throw signal.v;
-  }
-  return signal.v;
-}
-function reconnect(derived2) {
-  derived2.f |= CONNECTED;
-  if (derived2.deps === null) return;
-  for (const dep of derived2.deps) {
-    (dep.reactions ??= []).push(derived2);
-    if ((dep.f & DERIVED) !== 0 && (dep.f & CONNECTED) === 0) {
-      unfreeze_derived_effects(
-        /** @type {Derived} */
-        dep
-      );
-      reconnect(
-        /** @type {Derived} */
-        dep
-      );
-    }
-  }
-}
-function depends_on_old_values(derived2) {
-  if (derived2.v === UNINITIALIZED) return true;
-  if (derived2.deps === null) return false;
-  for (const dep of derived2.deps) {
-    if (old_values.has(dep)) {
-      return true;
-    }
-    if ((dep.f & DERIVED) !== 0 && depends_on_old_values(
-      /** @type {Derived} */
-      dep
-    )) {
-      return true;
-    }
-  }
-  return false;
-}
-function untrack(fn) {
-  var previous_untracking = untracking;
-  try {
-    untracking = true;
-    return fn();
-  } finally {
-    untracking = previous_untracking;
-  }
-}
-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;
-  }
-}
-function create_effect(type, fn) {
-  var parent = active_effect;
-  if (parent !== null && (parent.f & INERT) !== 0) {
-    type |= INERT;
-  }
-  var effect = {
-    ctx: component_context,
-    deps: null,
-    nodes: null,
-    f: type | DIRTY | CONNECTED,
-    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);
-  var e = effect;
-  if ((type & EFFECT) !== 0) {
-    if (collected_effects !== null) {
-      collected_effects.push(effect);
-    } else {
-      Batch.ensure().schedule(effect);
-    }
-  } else if (fn !== null) {
-    try {
-      update_effect(effect);
-    } catch (e2) {
-      destroy_effect(effect);
-      throw e2;
-    }
-    if (e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && // either `null`, or a singular child
-    (e.f & EFFECT_PRESERVED) === 0) {
-      e = e.first;
-      if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 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 & DERIVED) !== 0 && (type & ROOT_EFFECT) === 0) {
-      var derived2 = (
-        /** @type {Derived} */
-        active_reaction
-      );
-      (derived2.effects ??= []).push(e);
-    }
-  }
-  return effect;
-}
-function effect_tracking() {
-  return active_reaction !== null && !untracking;
-}
-function create_user_effect(fn) {
-  return create_effect(EFFECT | USER_EFFECT, fn);
-}
-function component_root(fn) {
-  Batch.ensure();
-  const effect = create_effect(ROOT_EFFECT | 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);
-      }
-    });
-  };
-}
-function render_effect(fn, flags = 0) {
-  return create_effect(RENDER_EFFECT | flags, fn);
-}
-function block(fn, flags = 0) {
-  var effect = create_effect(BLOCK_EFFECT | flags, fn);
-  return effect;
-}
-function branch(fn) {
-  return create_effect(BRANCH_EFFECT | EFFECT_PRESERVED, fn);
-}
-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);
-    }
-  }
-}
-function destroy_effect_children(signal, remove_dom = false) {
-  var effect = signal.first;
-  signal.first = signal.last = null;
-  while (effect !== null) {
-    const controller2 = effect.ac;
-    if (controller2 !== null) {
-      without_reactive_context(() => {
-        controller2.abort(STALE_REACTION);
-      });
-    }
-    var next = effect.next;
-    if ((effect.f & ROOT_EFFECT) !== 0) {
-      effect.parent = null;
-    } else {
-      destroy_effect(effect, remove_dom);
-    }
-    effect = next;
-  }
-}
-function destroy_block_effect_children(signal) {
-  var effect = signal.first;
-  while (effect !== null) {
-    var next = effect.next;
-    if ((effect.f & BRANCH_EFFECT) === 0) {
-      destroy_effect(effect);
-    }
-    effect = next;
-  }
-}
-function destroy_effect(effect, remove_dom = true) {
-  var removed = false;
-  if ((remove_dom || (effect.f & HEAD_EFFECT) !== 0) && effect.nodes !== null && effect.nodes.end !== null) {
-    remove_effect_dom(
-      effect.nodes.start,
-      /** @type {TemplateNode} */
-      effect.nodes.end
-    );
-    removed = true;
-  }
-  effect.f |= 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;
-}
-function remove_effect_dom(node, end) {
-  while (node !== null) {
-    var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
-    node.remove();
-    node = next;
-  }
-}
-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;
-  }
-}
-function pause_effect(effect, callback, destroy = true) {
-  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();
-  }
-}
-function pause_children(effect, transitions, local) {
-  if ((effect.f & INERT) !== 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 & ROOT_EFFECT) === 0) {
-      var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
-      // it means the parent block effect was pruned. In that case,
-      // transparency information was transferred to the branch effect.
-      (child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0;
-      pause_children(child, transitions, transparent ? local : false);
-    }
-    child = sibling;
-  }
-}
-function move_effect(effect, fragment) {
-  if (!effect.nodes) return;
-  var node = effect.nodes.start;
-  var end = effect.nodes.end;
-  while (node !== null) {
-    var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
-    fragment.append(node);
-    node = next;
-  }
-}
-const 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"
-];
-function is_boolean_attribute(name) {
-  return DOM_BOOLEAN_ATTRIBUTES.includes(name);
-}
-const PASSIVE_EVENTS = ["touchstart", "touchmove"];
-function is_passive_event(name) {
-  return PASSIVE_EVENTS.includes(name);
-}
-const ATTR_REGEX = /[&"<]/g;
-const CONTENT_REGEX = /[&<]/g;
-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);
-}
-const replacements = {
-  translate: /* @__PURE__ */ new Map([
-    [true, "yes"],
-    [false, "no"]
-  ])
-};
-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;
-  const assignment = is_boolean ? `=""` : `="${escape_html(normalized, true)}"`;
-  return ` ${name}${assignment}`;
-}
-function clsx(value) {
-  if (typeof value === "object") {
-    return clsx$1(value);
-  } else {
-    return value ?? "";
-  }
-}
-const whitespace = [..." 	\n\r\f \v\uFEFF"];
-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;
-}
-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;
-}
-function to_css_name(name) {
-  if (name[0] !== "-" || name[1] !== "-") {
-    return name.toLowerCase();
-  }
-  return name;
-}
-function to_style(value, styles) {
-  if (styles) {
-    var new_style = "";
-    var normal_styles;
-    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();
-      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);
-}
-const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
-const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
-const EMPTY_COMMENT = `<!---->`;
-let controller = null;
-function abort() {
-  controller?.abort(STALE_REACTION);
-  controller = null;
-}
-function await_invalid() {
-  const error = new Error(`await_invalid
-Encountered asynchronous work while rendering synchronously.
-https://svelte.dev/e/await_invalid`);
-  error.name = "Svelte error";
-  throw error;
-}
-function invalid_csp() {
-  const error = new Error(`invalid_csp
-\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.
-https://svelte.dev/e/invalid_csp`);
-  error.name = "Svelte error";
-  throw error;
-}
-function invalid_id_prefix() {
-  const error = new Error(`invalid_id_prefix
-The \`idPrefix\` option cannot include \`--\`.
-https://svelte.dev/e/invalid_id_prefix`);
-  error.name = "Svelte error";
-  throw error;
-}
-function lifecycle_function_unavailable(name) {
-  const error = new Error(`lifecycle_function_unavailable
-\`${name}(...)\` is not available on the server
-https://svelte.dev/e/lifecycle_function_unavailable`);
-  error.name = "Svelte error";
-  throw error;
-}
-function server_context_required() {
-  const error = new Error(`server_context_required
-Could not resolve \`render\` context.
-https://svelte.dev/e/server_context_required`);
-  error.name = "Svelte error";
-  throw error;
-}
-var ssr_context = null;
-function set_ssr_context(v) {
-  ssr_context = v;
-}
-function createContext() {
-  const key = {};
-  return [
-    () => {
-      if (!hasContext(key)) {
-        missing_context();
-      }
-      return getContext(key);
-    },
-    (context) => setContext(key, context)
-  ];
-}
-function getContext(key) {
-  const context_map = get_or_init_context_map();
-  const result = (
-    /** @type {T} */
-    context_map.get(key)
-  );
-  return result;
-}
-function setContext(key, context) {
-  get_or_init_context_map().set(key, context);
-  return context;
-}
-function hasContext(key) {
-  return get_or_init_context_map().has(key);
-}
-function getAllContexts() {
-  return get_or_init_context_map();
-}
-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);
-}
-function push(fn) {
-  ssr_context = { p: ssr_context, c: null, r: null };
-}
-function pop() {
-  ssr_context = /** @type {SSRContext} */
-  ssr_context.p;
-}
-function get_parent_context(ssr_context2) {
-  let parent = ssr_context2.p;
-  while (parent !== null) {
-    const context_map = parent.c;
-    if (context_map !== null) {
-      return context_map;
-    }
-    parent = parent.p;
-  }
-  return null;
-}
-function unresolved_hydratable(key, stack) {
-  {
-    console.warn(`https://svelte.dev/e/unresolved_hydratable`);
-  }
-}
-function get_render_context() {
-  const store = als?.getStore();
-  {
-    server_context_required();
-  }
-  return store;
-}
-let als = null;
-let text_encoder;
-let crypto;
-const obfuscated_import = (module_name) => import(
-  /* @vite-ignore */
-  module_name
-);
-async function sha256(data) {
-  text_encoder ??= new TextEncoder();
-  crypto ??= globalThis.crypto?.subtle?.digest ? globalThis.crypto : (
-    // @ts-ignore - we don't install node types in the prod build
-    // don't use import('node:crypto') directly because static analysers will think we rely on node when we don't
-    (await obfuscated_import("node:crypto")).webcrypto
-  );
-  const hash_buffer = await crypto.subtle.digest("SHA-256", text_encoder.encode(data));
-  return base64_encode(hash_buffer);
-}
-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);
-}
-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 head2 = new Renderer(this.global, this);
-    head2.type = "head";
-    this.#out.push(head2);
-    head2.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 = /** @type {Promise<unknown>} */
-        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();
-    const child = this.child(fn);
-    child.#is_component_body = true;
-    pop();
-  }
-  /**
-   * @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)}`);
-    const close = (renderer, value, { head: head2, body: body2 }) => {
-      if (has_own_property.call(attrs, "value")) {
-        value = attrs.value;
-      }
-      if (value === this.local.select_value) {
-        renderer.#out.push(' selected=""');
-      }
-      renderer.#out.push(`>${body2}${is_rich ? "<!>" : ""}</option>`);
-      if (head2) {
-        renderer.head((child) => child.push(head2));
-      }
-    };
-    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();
-    const close = (head2) => {
-      this.global.set_title(head2, 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 {
-        const content = r.#collect_content();
-        close(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) {
-    var json = JSON.stringify(error);
-    var escaped = json.replace(/>/g, "\\u003e").replace(/</g, "\\u003c");
-    return `<!--${HYDRATION_START_FAILED}${escaped}-->`;
-  }
-  /**
-   * 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 = {}) {
-    let sync;
-    const result = (
-      /** @type {RenderOutput} */
-      {}
-    );
-    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: (
-          /**
-           * this is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
-           *
-           * @template TResult1
-           * @template [TResult2=never]
-           * @param { (value: SyncRenderOutput) => TResult1 } onfulfilled
-           * @param { (reason: unknown) => TResult2 } onrejected
-           */
-          (onfulfilled, onrejected) => {
-            {
-              const result2 = sync ??= Renderer.#render(component, options);
-              const user_result = onfulfilled({
-                head: result2.head,
-                body: result2.body,
-                html: result2.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) {
-          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
-        )
-      );
-      const context = { p: null, c: options.context ?? null, r: renderer };
-      set_ssr_context(context);
-      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 head2 = content.head + renderer.global.get_title();
-    let body = content.body;
-    for (const { hash, code } of renderer.global.css) {
-      head2 += `<style id="${hash}">${code}</style>`;
-    }
-    return {
-      head: head2,
-      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 `
-		<script${csp_attr}>${body}<\/script>`;
-  }
-}
-class SSRState {
-  /** @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 uid2 = 1;
-    this.uid = () => `${id_prefix}s${uid2++}`;
-  }
-  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;
-    }
-  }
-}
-const 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;
-function render(component, options = {}) {
-  if (options.csp?.hash && options.csp.nonce) {
-    invalid_csp();
-  }
-  return Renderer.render(
-    /** @type {Component<Props>} */
-    component,
-    options
-  );
-}
-function head(hash, renderer, fn) {
-  renderer.head((renderer2) => {
-    renderer2.push(`<!--${hash}-->`);
-    renderer2.child(fn);
-    renderer2.push(EMPTY_COMMENT);
-  });
-}
-function attributes(attrs, css_hash, classes, styles, flags = 0) {
-  if (styles) {
-    attrs.style = to_style(attrs.style, styles);
-  }
-  if (attrs.class) {
-    attrs.class = clsx(attrs.class);
-  }
-  if (css_hash || classes) {
-    attrs.class = to_class(attrs.class, css_hash, classes);
-  }
-  let attr_str = "";
-  let name;
-  const is_html = (flags & ELEMENT_IS_NAMESPACED) === 0;
-  const lowercase = (flags & ELEMENT_PRESERVE_ATTRIBUTE_CASE) === 0;
-  const is_input = (flags & ELEMENT_IS_INPUT) !== 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;
-}
-function spread_props(props) {
-  const merged_props = {};
-  let key;
-  for (let i = 0; i < props.length; i++) {
-    const obj = props[i];
-    if (obj == null) continue;
-    for (key of Object.keys(obj)) {
-      const desc = Object.getOwnPropertyDescriptor(obj, key);
-      if (desc) {
-        Object.defineProperty(merged_props, key, desc);
-      } else {
-        merged_props[key] = obj[key];
-      }
-    }
-  }
-  return merged_props;
-}
-function stringify(value) {
-  return typeof value === "string" ? value : value == null ? "" : value + "";
-}
-function attr_class(value, hash, directives) {
-  var result = to_class(value, hash, directives);
-  return result ? ` class="${escape_html(result, true)}"` : "";
-}
-function attr_style(value, directives) {
-  var result = to_style(value, directives);
-  return result ? ` style="${escape_html(result, true)}"` : "";
-}
-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];
-}
-function unsubscribe_stores(store_values) {
-  for (const store_name of Object.keys(store_values)) {
-    store_values[store_name][1]();
-  }
-}
-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;
-    }
-  }
-}
-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 [];
-}
-function once(get_value) {
-  let value = (
-    /** @type {V} */
-    UNINITIALIZED
-  );
-  return () => {
-    if (value === UNINITIALIZED) {
-      value = get_value();
-    }
-    return value;
-  };
-}
-function derived(fn) {
-  const get_value = ssr_context === null ? fn : once(fn);
-  let updated_value;
-  return function(new_value) {
-    if (arguments.length === 0) {
-      return updated_value ?? get_value();
-    }
-    updated_value = new_value;
-    return updated_value;
-  };
-}
-
-export { set_active_effect as $, set as A, get as B, flushSync as C, DevalueError as D, define_property as E, mutable_source as F, init_operations as G, HOLE as H, get_first_child as I, COMMENT_NODE as J, HYDRATION_START as K, LEGACY_PROPS as L, MAX_ARRAY_INDEX as M, NAN as N, get_next_sibling as O, POSITIVE_INFINITY as P, HYDRATION_ERROR as Q, hydration_failed as R, SPARSE as S, clear_text_content as T, UNDEFINED as U, hydration_mismatch as V, component_root as W, create_text as X, array_from as Y, is_passive_event as Z, set_active_reaction as _, NEGATIVE_INFINITY as a, active_reaction as a0, active_effect as a1, setContext as a2, BOUNDARY_EFFECT as a3, block as a4, branch as a5, queue_micro_task as a6, pause_effect as a7, current_batch as a8, move_effect as a9, createContext as aA, getContext as aB, store_get as aC, unsubscribe_stores as aD, hasContext as aE, getAllContexts as aF, spread_props as aG, clsx$1 as aH, ssr_context as aI, lifecycle_function_unavailable as aJ, fallback as aK, defer_effect as aa, set_component_context as ab, Batch as ac, handle_error as ad, component_context as ae, internal_set as af, destroy_effect as ag, invoke_error_boundary as ah, effect_tracking as ai, render_effect as aj, HYDRATION_END as ak, HYDRATION_START_ELSE as al, svelte_boundary_reset_onerror as am, source as an, untrack as ao, increment as ap, HYDRATION_START_FAILED as aq, svelte_boundary_reset_noop as ar, push$1 as as, pop$1 as at, EFFECT_TRANSPARENT as au, EFFECT_PRESERVED as av, without_reactive_context as aw, noop as ax, subscribe_to_store as ay, safe_not_equal as az, NEGATIVE_ZERO as b, is_valid_array_index as c, is_primitive as d, is_plain_object as e, enumerable_symbols as f, get_type as g, stringify_string as h, is_valid_array_len as i, browser as j, escape_html as k, derived as l, attr as m, stringify as n, attr_class as o, ensure_array_like as p, attributes as q, run as r, stringify_key as s, clsx as t, uneval as u, valid_array_indices as v, bind_props as w, head as x, attr_style as y, render as z };
-//# sourceMappingURL=index-Do08hKbr.js.map