@kozou/svelte-ui 0.0.1 → 0.1.1

package/build/server/chunks/internal-BrzrGF6g.js

@@ -0,0 +1,1757 @@
+import { createRequire } from 'node:module';
+import { a5 as ssr_context, _ as run$1, a0 as setContext, U as noop$1, C as hasContext, x as getContext, w as getAllContexts, v as getAbortSignal, j as createContext, S as lifecycle_function_unavailable, r as experimental_async_required, A as get_render_context, aa as uneval, E as hydratable_serialization_failed, D as DevalueError, P as is_primitive, B as get_type, O as is_plain_object, p as enumerable_symbols, a8 as stringify_key, a9 as stringify_string, ac as valid_array_indices, R as is_valid_array_len, M as MAX_ARRAY_INDEX, Q as is_valid_array_index, Z as render, $ as set, L as LEGACY_PROPS, t as get, s as flushSync, l as define_property, T as mutable_source, K as init_operations, y as get_first_child, z as get_next_sibling, H as HYDRATION_ERROR, a4 as set_hydrating, a3 as set_hydrate_node, I as hydration_failed, g as clear_text_content, i as component_root, F as hydrate_node, k as create_text, f as boundary, c as array_from, N as is_passive_event, a2 as set_active_reaction, a1 as set_active_effect, b as active_reaction, a as active_effect, m as derived, G as hydrating, W as push, h as component_context, J as hydration_mismatch, V as pop } from './dev-yFiAtg5l.js';
+import { H as HttpError, S as SvelteKitError } from './index-DBqjc0Yf.js';
+import 'clsx';
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	__defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(__defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) , mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/runtime/app/paths/internal/server.js
+var base = "";
+var assets = base;
+var app_dir = "_app";
+var initial = {
+	base,
+	assets
+};
+/**
+* @param {{ base: string, assets: string }} paths
+*/
+function override(paths) {
+	base = paths.base;
+	assets = paths.assets;
+}
+function reset() {
+	base = initial.base;
+	assets = initial.assets;
+}
+/**
+* `$env/dynamic/public`
+* @type {Record<string, string>}
+*/
+var public_env = {};
+/** @type {(environment: Record<string, string>) => void} */
+function set_private_env(environment) {}
+/** @type {(environment: Record<string, string>) => void} */
+function set_public_env(environment) {
+	public_env = environment;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/hydratable.js
+/** @import { HydratableLookupEntry } from '#server' */
+/**
+* @template T
+* @param {string} key
+* @param {() => T} fn
+* @returns {T}
+*/
+function hydratable(key, fn) {
+	experimental_async_required();
+	const { hydratable } = get_render_context();
+	let entry = hydratable.lookup.get(key);
+	if (entry !== void 0) return entry.value;
+	const value = fn();
+	entry = encode(key, value, hydratable.unresolved_promises);
+	hydratable.lookup.set(key, entry);
+	return value;
+}
+/**
+* @param {string} key
+* @param {any} value
+* @param {Map<Promise<any>, string>} [unresolved]
+*/
+function encode(key, value, unresolved) {
+	/** @type {HydratableLookupEntry} */
+	const entry = {
+		value,
+		serialized: ""
+	};
+	let uid = 1;
+	entry.serialized = uneval(entry.value, (value, uneval) => {
+		if (is_promise(value)) {
+			const placeholder = `"${uid++}"`;
+			const p = value.then((v) => {
+				entry.serialized = entry.serialized.replace(placeholder, () => `r(${uneval(v)})`);
+			}).catch((devalue_error) => hydratable_serialization_failed(key, serialization_stack(entry.stack, devalue_error?.stack)));
+			p.catch(() => {}).finally(() => unresolved?.delete(p));
+			(entry.promises ??= []).push(p);
+			return placeholder;
+		}
+	});
+	return entry;
+}
+/**
+* @param {any} value
+* @returns {value is Promise<any>}
+*/
+function is_promise(value) {
+	return Object.prototype.toString.call(value) === "[object Promise]";
+}
+/**
+* @param {string | undefined} root_stack
+* @param {string | undefined} uneval_stack
+*/
+function serialization_stack(root_stack, uneval_stack) {
+	let out = "";
+	if (root_stack) out += root_stack + "\n";
+	if (uneval_stack) out += "Caused by:\n" + uneval_stack + "\n";
+	return out || "<missing stack trace>";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/server/blocks/snippet.js
+/** @import { Snippet } from 'svelte' */
+/** @import { Renderer } from '../renderer' */
+/** @import { Getters } from '#shared' */
+/**
+* Create a snippet programmatically
+* @template {unknown[]} Params
+* @param {(...params: Getters<Params>) => {
+*   render: () => string
+*   setup?: (element: Element) => void | (() => void)
+* }} fn
+* @returns {Snippet<Params>}
+*/
+function createRawSnippet(fn) {
+	return (renderer, ...args) => {
+		var getters = args.map((value) => () => value);
+		renderer.push(fn(...getters).render().trim());
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/index-server.js
+/** @import { SSRContext } from '#server' */
+/** @import { Renderer } from './internal/server/renderer.js' */
+var index_server_exports = /* @__PURE__ */ __exportAll({
+	afterUpdate: () => noop$1,
+	beforeUpdate: () => noop$1,
+	createContext: () => createContext,
+	createEventDispatcher: () => createEventDispatcher,
+	createRawSnippet: () => createRawSnippet,
+	flushSync: () => noop$1,
+	fork: () => fork,
+	getAbortSignal: () => getAbortSignal,
+	getAllContexts: () => getAllContexts,
+	getContext: () => getContext,
+	hasContext: () => hasContext,
+	hydratable: () => hydratable,
+	hydrate: () => hydrate$1,
+	mount: () => mount$1,
+	onDestroy: () => onDestroy,
+	onMount: () => noop$1,
+	setContext: () => setContext,
+	settled: () => settled,
+	tick: () => tick,
+	unmount: () => unmount$1,
+	untrack: () => run$1
+});
+/** @param {() => void} fn */
+function onDestroy(fn) {
+	/** @type {Renderer} */ ssr_context.r.on_destroy(fn);
+}
+function createEventDispatcher() {
+	return noop$1;
+}
+function mount$1() {
+	lifecycle_function_unavailable("mount");
+}
+function hydrate$1() {
+	lifecycle_function_unavailable("hydrate");
+}
+function unmount$1() {
+	lifecycle_function_unavailable("unmount");
+}
+function fork() {
+	lifecycle_function_unavailable("fork");
+}
+async function tick() {}
+async function settled() {}
+
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/utils/functions.js
+function noop() {}
+/**
+* @template T
+* @param {() => T} fn
+*/
+function once(fn) {
+	let done = false;
+	/** @type T */
+	let result;
+	return () => {
+		if (done) return result;
+		done = true;
+		return result = fn();
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_native(base64) {
+	return Uint8Array.fromBase64(base64).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString("base64");
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_buffer(base64) {
+	return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = "";
+	const chunk_size = 32768;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
+	return btoa(binary);
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_legacy(base64) {
+	const binary_string = atob(base64);
+	const len = binary_string.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binary_string.charCodeAt(i);
+	return array.buffer;
+}
+var native = typeof Uint8Array.fromBase64 === "function";
+var buffer = typeof process === "object" && process.versions?.node !== void 0;
+var encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+var decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/parse.js
+/**
+* Revive a value serialized with `devalue.stringify`
+* @param {string} serialized
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function parse(serialized, revivers) {
+	return unflatten(JSON.parse(serialized), revivers);
+}
+/**
+* Revive a value flattened with `devalue.stringify`
+* @param {number | any[]} parsed
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function unflatten(parsed, revivers) {
+	if (typeof parsed === "number") return hydrate(parsed, true);
+	if (!Array.isArray(parsed) || parsed.length === 0) throw new Error("Invalid input");
+	const values = parsed;
+	const hydrated = Array(values.length);
+	/**
+	* A set of values currently being hydrated with custom revivers,
+	* used to detect invalid cyclical dependencies
+	* @type {Set<number> | null}
+	*/
+	let hydrating = null;
+	/**
+	* @param {number} index
+	* @returns {any}
+	*/
+	function hydrate(index, standalone = false) {
+		if (index === -1) return void 0;
+		if (index === -3) return NaN;
+		if (index === -4) return Infinity;
+		if (index === -5) return -Infinity;
+		if (index === -6) return -0;
+		if (standalone || typeof index !== "number") throw new Error(`Invalid input`);
+		if (index in hydrated) return hydrated[index];
+		const value = values[index];
+		if (!value || typeof value !== "object") hydrated[index] = value;
+		else if (Array.isArray(value)) if (typeof value[0] === "string") {
+			const type = value[0];
+			const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : void 0;
+			if (reviver) {
+				let i = value[1];
+				if (typeof i !== "number") i = values.push(value[1]) - 1;
+				hydrating ??= /* @__PURE__ */ new Set();
+				if (hydrating.has(i)) throw new Error("Invalid circular reference");
+				hydrating.add(i);
+				hydrated[index] = reviver(hydrate(i));
+				hydrating.delete(i);
+				return hydrated[index];
+			}
+			switch (type) {
+				case "Date":
+					hydrated[index] = new Date(value[1]);
+					break;
+				case "Set":
+					const set = /* @__PURE__ */ new Set();
+					hydrated[index] = set;
+					for (let i = 1; i < value.length; i += 1) set.add(hydrate(value[i]));
+					break;
+				case "Map":
+					const map = /* @__PURE__ */ new Map();
+					hydrated[index] = map;
+					for (let i = 1; i < value.length; i += 2) map.set(hydrate(value[i]), hydrate(value[i + 1]));
+					break;
+				case "RegExp":
+					hydrated[index] = new RegExp(value[1], value[2]);
+					break;
+				case "Object": {
+					const wrapped_index = value[1];
+					if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") throw new Error("Invalid input");
+					hydrated[index] = Object(hydrate(wrapped_index));
+					break;
+				}
+				case "BigInt":
+					hydrated[index] = BigInt(value[1]);
+					break;
+				case "null":
+					const obj = Object.create(null);
+					hydrated[index] = obj;
+					for (let i = 1; i < value.length; i += 2) {
+						if (value[i] === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+						obj[value[i]] = hydrate(value[i + 1]);
+					}
+					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": {
+					if (values[value[1]][0] !== "ArrayBuffer") throw new Error("Invalid data");
+					const TypedArrayConstructor = globalThis[type];
+					const buffer = hydrate(value[1]);
+					hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer, value[2], value[3]) : new TypedArrayConstructor(buffer);
+					break;
+				}
+				case "ArrayBuffer": {
+					const base64 = value[1];
+					if (typeof base64 !== "string") throw new Error("Invalid ArrayBuffer encoding");
+					hydrated[index] = decode64(base64);
+					break;
+				}
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime": {
+					const temporalName = type.slice(9);
+					hydrated[index] = Temporal[temporalName].from(value[1]);
+					break;
+				}
+				case "URL":
+					hydrated[index] = new URL(value[1]);
+					break;
+				case "URLSearchParams":
+					hydrated[index] = new URLSearchParams(value[1]);
+					break;
+				default: throw new Error(`Unknown type ${type}`);
+			}
+		} else if (value[0] === -7) {
+			const len = value[1];
+			if (!is_valid_array_len(len)) throw new Error("Invalid input");
+			/** @type {any[]} */
+			const array = [];
+			hydrated[index] = array;
+			array[MAX_ARRAY_INDEX] = void 0;
+			delete array[MAX_ARRAY_INDEX];
+			for (let i = 2; i < value.length; i += 2) {
+				const idx = value[i];
+				if (!is_valid_array_index(idx) || idx >= len) throw new Error("Invalid input");
+				array[idx] = hydrate(value[i + 1]);
+			}
+			array.length = len;
+		} else {
+			const array = new Array(value.length);
+			hydrated[index] = array;
+			for (let i = 0; i < value.length; i += 1) {
+				const n = value[i];
+				if (n === -2) continue;
+				array[i] = hydrate(n);
+			}
+		}
+		else {
+			/** @type {Record<string, any>} */
+			const object = {};
+			hydrated[index] = object;
+			for (const key of Object.keys(value)) {
+				if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+				const n = value[key];
+				object[key] = hydrate(n);
+			}
+		}
+		return hydrated[index];
+	}
+	return hydrate(0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/stringify.js
+/**
+* Turn a value into a JSON string that can be parsed with `devalue.parse`
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function stringify$1(value, reducers) {
+	const stringified = run(false, value, reducers);
+	return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+/**
+* @param {boolean} async
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function run(async, value, reducers) {
+	/** @type {any[]} */
+	const stringified = [];
+	/** @type {Map<any, number>} */
+	const indexes = /* @__PURE__ */ new Map();
+	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
+	const custom = [];
+	if (reducers) for (const key of Object.getOwnPropertyNames(reducers)) custom.push({
+		key,
+		fn: reducers[key]
+	});
+	/** @type {string[]} */
+	const keys = [];
+	let p = 0;
+	/**
+	* @param {any} thing
+	* @param {number} [index]
+	*/
+	function flatten(thing, index) {
+		if (thing === void 0) return -1;
+		if (Number.isNaN(thing)) return -3;
+		if (thing === Infinity) return -4;
+		if (thing === -Infinity) return -5;
+		if (thing === 0 && 1 / thing < 0) return -6;
+		if (indexes.has(thing)) return indexes.get(thing);
+		index ??= p++;
+		indexes.set(thing, index);
+		for (const { key, fn } of custom) {
+			const value = fn(thing);
+			if (value) {
+				stringified[index] = `["${key}",${flatten(value)}]`;
+				return index;
+			}
+		}
+		if (typeof thing === "function") throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		else if (typeof thing === "symbol") throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+		/** @type {string | Promise<any>} */
+		let str = "";
+		if (is_primitive(thing)) str = stringify_primitive(thing);
+		else if (typeof thing.then === "function") {
+			throw new DevalueError(`Cannot stringify a Promise or thenable — use stringifyAsync instead`, keys, thing, value);
+		} else {
+			const type = get_type(thing);
+			switch (type) {
+				case "Number":
+				case "String":
+				case "Boolean":
+				case "BigInt":
+					str = `["Object",${flatten(thing.valueOf())}]`;
+					break;
+				case "Date":
+					str = `["Date","${!isNaN(thing.getDate()) ? thing.toISOString() : ""}"]`;
+					break;
+				case "URL":
+					str = `["URL",${stringify_string(thing.toString())}]`;
+					break;
+				case "URLSearchParams":
+					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					break;
+				case "RegExp":
+					const { source, flags } = thing;
+					str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+					break;
+				case "Array": {
+					let mostly_dense = false;
+					str = "[";
+					for (let i = 0; i < thing.length; i += 1) {
+						if (i > 0) str += ",";
+						if (Object.hasOwn(thing, i)) {
+							keys.push(`[${i}]`);
+							str += flatten(thing[i]);
+							keys.pop();
+						} else if (mostly_dense) str += -2;
+						else {
+							const populated_keys = valid_array_indices(thing);
+							const population = populated_keys.length;
+							const d = String(thing.length).length;
+							if ((thing.length - population) * 3 > 4 + d + population * (d + 1)) {
+								str = "[-7," + thing.length;
+								for (let j = 0; j < populated_keys.length; j++) {
+									const key = populated_keys[j];
+									keys.push(`[${key}]`);
+									str += "," + key + "," + flatten(thing[key]);
+									keys.pop();
+								}
+								break;
+							} else {
+								mostly_dense = true;
+								str += -2;
+							}
+						}
+					}
+					str += "]";
+					break;
+				}
+				case "Set":
+					str = "[\"Set\"";
+					for (const value of thing) str += `,${flatten(value)}`;
+					str += "]";
+					break;
+				case "Map":
+					str = "[\"Map\"";
+					for (const [key, value] of thing) {
+						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+						str += `,${flatten(key)},${flatten(value)}`;
+						keys.pop();
+					}
+					str += "]";
+					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": {
+					/** @type {import("./types.js").TypedArray} */
+					const typedArray = thing;
+					str = "[\"" + type + "\"," + flatten(typedArray.buffer);
+					if (typedArray.byteLength !== typedArray.buffer.byteLength) str += `,${typedArray.byteOffset},${typedArray.length}`;
+					str += "]";
+					break;
+				}
+				case "ArrayBuffer":
+					str = `["ArrayBuffer","${encode64(thing)}"]`;
+					break;
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					str = `["${type}",${stringify_string(thing.toString())}]`;
+					break;
+				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);
+					if (Object.getPrototypeOf(thing) === null) {
+						str = "[\"null\"";
+						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));
+							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "]";
+					} else {
+						str = "{";
+						let started = false;
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							if (started) str += ",";
+							started = true;
+							keys.push(stringify_key(key));
+							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "}";
+					}
+			}
+		}
+		stringified[index] = str;
+		return index;
+	}
+	const index = flatten(value);
+	if (index < 0) return `${index}`;
+	return stringified;
+}
+/**
+* @param {any} thing
+* @returns {string}
+*/
+function stringify_primitive(thing) {
+	const type = typeof thing;
+	if (type === "string") return stringify_string(thing);
+	if (thing === void 0) return (-1).toString();
+	if (thing === 0 && 1 / thing < 0) return (-6).toString();
+	if (type === "bigint") return `["BigInt","${thing}"]`;
+	return String(thing);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/runtime/utils.js
+var text_encoder = new TextEncoder();
+/**
+* Like node's path.relative, but without using node
+* @param {string} from
+* @param {string} to
+*/
+function get_relative_path(from, to) {
+	const from_parts = from.split(/[/\\]/);
+	const to_parts = to.split(/[/\\]/);
+	from_parts.pop();
+	while (from_parts[0] === to_parts[0]) {
+		from_parts.shift();
+		to_parts.shift();
+	}
+	let i = from_parts.length;
+	while (i--) from_parts[i] = "..";
+	return from_parts.concat(to_parts).join("/");
+}
+/**
+* @param {Uint8Array} bytes
+* @returns {string}
+*/
+function base64_encode(bytes) {
+	if (globalThis.Buffer) return globalThis.Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+}
+/**
+* @param {string} encoded
+* @returns {Uint8Array}
+*/
+function base64_decode(encoded) {
+	if (globalThis.Buffer) {
+		const buffer = globalThis.Buffer.from(encoded, "base64");
+		return new Uint8Array(buffer);
+	}
+	const binary = atob(encoded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/utils/error.js
+/**
+* @param {unknown} err
+* @return {Error}
+*/
+function coalesce_to_error(err) {
+	return err instanceof Error || err && err.name && err.message ? err : new Error(JSON.stringify(err));
+}
+/**
+* This is an identity function that exists to make TypeScript less
+* paranoid about people throwing things that aren't errors, which
+* frankly is not something we should care about
+* @param {unknown} error
+*/
+function normalize_error(error) {
+	return error;
+}
+/**
+* @param {unknown} error
+*/
+function get_status(error) {
+	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+}
+/**
+* @param {unknown} error
+*/
+function get_message(error) {
+	return error instanceof SvelteKitError ? error.text : "Internal Error";
+}
+var INVALIDATED_PARAM = "x-sveltekit-invalidated";
+var TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
+/**
+* Try to `devalue.stringify` the data object using the provided transport encoders.
+* @param {any} data
+* @param {Transport} transport
+*/
+function stringify(data, transport) {
+	return stringify$1(data, Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode])));
+}
+var remote_object = "__skrao";
+var remote_map = "__skram";
+var remote_set = "__skras";
+/** @param {Transport} transport */
+function create_remote_arg_revivers(transport) {
+	const remote_fns_revivers = {
+		/** @type {(value: unknown) => unknown} */
+		[remote_object]: (value) => value,
+		/** @type {(value: unknown) => Map<unknown, unknown>} */
+		[remote_map]: (value) => {
+			if (!Array.isArray(value)) throw new Error("Invalid data for Map reviver");
+			const map = /* @__PURE__ */ new Map();
+			for (const item of value) {
+				if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || typeof item[1] !== "string") throw new Error("Invalid data for Map reviver");
+				const [key, val] = item;
+				map.set(parse$1(key), parse$1(val));
+			}
+			return map;
+		},
+		/** @type {(value: unknown) => Set<unknown>} */
+		[remote_set]: (value) => {
+			if (!Array.isArray(value)) throw new Error("Invalid data for Set reviver");
+			const set = /* @__PURE__ */ new Set();
+			for (const item of value) {
+				if (typeof item !== "string") throw new Error("Invalid data for Set reviver");
+				set.add(parse$1(item));
+			}
+			return set;
+		}
+	};
+	const all_revivers = {
+		...Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode])),
+		...remote_fns_revivers
+	};
+	/** @type {(data: string) => unknown} */
+	const parse$1 = (data) => parse(data, all_revivers);
+	return all_revivers;
+}
+/**
+* Parses the argument (if any) for a remote function
+* @param {string} string
+* @param {Transport} transport
+*/
+function parse_remote_arg(string, transport) {
+	if (!string) return void 0;
+	return parse(new TextDecoder().decode(base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))), create_remote_arg_revivers(transport));
+}
+/**
+* @param {string} id
+* @param {string} payload
+*/
+function create_remote_key(id, payload) {
+	return id + "/" + payload;
+}
+/**
+* @param {string} key
+* @returns {{ id: string; payload: string }}
+*/
+function split_remote_key(key) {
+	const i = key.lastIndexOf("/");
+	if (i === -1) throw new Error(`Invalid remote key: ${key}`);
+	return {
+		id: key.slice(0, i),
+		payload: key.slice(i + 1)
+	};
+}
+
+// eslint-disable-next-line n/prefer-global/process
+const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
+
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestStore } from 'types' */
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
+
+
+/** @type {RequestStore | null} */
+let sync_store = null;
+
+/** @type {AsyncLocalStorage<RequestStore | null> | null} */
+let als;
+
+import('node:async_hooks')
+	.then((hooks) => (als = new hooks.AsyncLocalStorage()))
+	.catch(() => {
+		// can't use AsyncLocalStorage, but can still call getRequestEvent synchronously.
+		// this isn't behind `supports` because it's basically just StackBlitz (i.e.
+		// in-browser usage) that doesn't support it AFAICT
+	});
+
+/**
+ * @template T
+ * @param {RequestStore | null} store
+ * @param {() => T} fn
+ */
+function with_request_store(store, fn) {
+	try {
+		sync_store = store;
+		return als ? als.run(store, fn) : fn();
+	} finally {
+		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
+		// and handle only one request at a time in `src/runtime/server/index.js`.
+		if (!IN_WEBCONTAINER) {
+			sync_store = null;
+		}
+	}
+}
+
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/utils/array.js
+/**
+* Removes nullish values from an array.
+*
+* @template T
+* @param {Array<T>} arr
+*/
+function compact(arr) {
+	return arr.filter(
+		/** @returns {val is NonNullable<T>} */
+		(val) => val != null
+	);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/runtime/pathname.js
+var DATA_SUFFIX = "/__data.json";
+var HTML_DATA_SUFFIX = ".html__data.json";
+/** @param {string} pathname */
+function has_data_suffix(pathname) {
+	return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
+}
+/** @param {string} pathname */
+function add_data_suffix(pathname) {
+	if (pathname.endsWith(".html")) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
+	return pathname.replace(/\/$/, "") + DATA_SUFFIX;
+}
+/** @param {string} pathname */
+function strip_data_suffix(pathname) {
+	if (pathname.endsWith(HTML_DATA_SUFFIX)) return pathname.slice(0, -16) + ".html";
+	return pathname.slice(0, -12);
+}
+var ROUTE_SUFFIX = "/__route.js";
+/**
+* @param {string} pathname
+* @returns {boolean}
+*/
+function has_resolution_suffix(pathname) {
+	return pathname.endsWith(ROUTE_SUFFIX);
+}
+/**
+* Convert a regular URL to a route to send to SvelteKit's server-side route resolution endpoint
+* @param {string} pathname
+* @returns {string}
+*/
+function add_resolution_suffix(pathname) {
+	return pathname.replace(/\/$/, "") + ROUTE_SUFFIX;
+}
+/**
+* @param {string} pathname
+* @returns {string}
+*/
+function strip_resolution_suffix(pathname) {
+	return pathname.slice(0, -11);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/runtime/telemetry/noop.js
+/**
+* @type {Span}
+*/
+var noop_span = {
+	spanContext() {
+		return noop_span_context;
+	},
+	setAttribute() {
+		return this;
+	},
+	setAttributes() {
+		return this;
+	},
+	addEvent() {
+		return this;
+	},
+	setStatus() {
+		return this;
+	},
+	updateName() {
+		return this;
+	},
+	end() {
+		return this;
+	},
+	isRecording() {
+		return false;
+	},
+	recordException() {
+		return this;
+	},
+	addLink() {
+		return this;
+	},
+	addLinks() {
+		return this;
+	}
+};
+/**
+* @type {SpanContext}
+*/
+var noop_span_context = {
+	traceId: "",
+	spanId: "",
+	traceFlags: 0
+};
+var internal = new URL("sveltekit-internal://");
+/**
+* @param {string} base
+* @param {string} path
+*/
+function resolve(base, path) {
+	if (path[0] === "/" && path[1] === "/") return path;
+	let url = new URL(base, internal);
+	url = new URL(path, url);
+	return url.protocol === internal.protocol ? url.pathname + url.search + url.hash : url.href;
+}
+/**
+* @param {string} path
+* @param {import('types').TrailingSlash} trailing_slash
+*/
+function normalize_path(path, trailing_slash) {
+	if (path === "/" || trailing_slash === "ignore") return path;
+	if (trailing_slash === "never") return path.endsWith("/") ? path.slice(0, -1) : path;
+	else if (trailing_slash === "always" && !path.endsWith("/")) return path + "/";
+	return path;
+}
+/**
+* Decode pathname excluding %25 to prevent further double decoding of params
+* @param {string} pathname
+*/
+function decode_pathname(pathname) {
+	return pathname.split("%25").map(decodeURI).join("%25");
+}
+/** @param {Record<string, string>} params */
+function decode_params(params) {
+	for (const key in params) params[key] = decodeURIComponent(params[key]);
+	return params;
+}
+/**
+* @param {URL} url
+* @param {() => void} callback
+* @param {(search_param: string) => void} search_params_callback
+* @param {boolean} [allow_hash]
+*/
+function make_trackable(url, callback, search_params_callback, allow_hash = false) {
+	const tracked = new URL(url);
+	Object.defineProperty(tracked, "searchParams", {
+		value: new Proxy(tracked.searchParams, { get(obj, key) {
+			if (key === "get" || key === "getAll" || key === "has") return (param, ...rest) => {
+				search_params_callback(param);
+				return obj[key](param, ...rest);
+			};
+			callback();
+			const value = Reflect.get(obj, key);
+			return typeof value === "function" ? value.bind(obj) : value;
+		} }),
+		enumerable: true,
+		configurable: true
+	});
+	/**
+	* URL properties that could change during the lifetime of the page,
+	* which excludes things like `origin`
+	*/
+	const tracked_url_properties = [
+		"href",
+		"pathname",
+		"search",
+		"toString",
+		"toJSON"
+	];
+	if (allow_hash) tracked_url_properties.push("hash");
+	for (const property of tracked_url_properties) Object.defineProperty(tracked, property, {
+		get() {
+			callback();
+			return url[property];
+		},
+		enumerable: true,
+		configurable: true
+	});
+	tracked[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(url, opts);
+	};
+	tracked.searchParams[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(url.searchParams, opts);
+	};
+	if (!allow_hash) disable_hash(tracked);
+	return tracked;
+}
+/**
+* Disallow access to `url.hash` on the server and in `load`
+* @param {URL} url
+*/
+function disable_hash(url) {
+	allow_nodejs_console_log(url);
+	Object.defineProperty(url, "hash", { get() {
+		throw new Error("Cannot access event.url.hash. Consider using `page.url.hash` inside a component instead");
+	} });
+}
+/**
+* Disallow access to `url.search` and `url.searchParams` during prerendering
+* @param {URL} url
+*/
+function disable_search(url) {
+	allow_nodejs_console_log(url);
+	for (const property of ["search", "searchParams"]) Object.defineProperty(url, property, { get() {
+		throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+	} });
+}
+/**
+* Allow URL to be console logged, bypassing disabled properties.
+* @param {URL} url
+*/
+function allow_nodejs_console_log(url) {
+	url[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(new URL(url), opts);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/utils/hash.js
+/**
+* Hash using djb2
+* @param {import('types').StrictBody[]} values
+*/
+function hash(...values) {
+	let hash = 5381;
+	for (const value of values) if (typeof value === "string") {
+		let i = value.length;
+		while (i) hash = hash * 33 ^ value.charCodeAt(--i);
+	} else if (ArrayBuffer.isView(value)) {
+		const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+		let i = buffer.length;
+		while (i) hash = hash * 33 ^ buffer[--i];
+	} else throw new TypeError("value must be a string or TypedArray");
+	return (hash >>> 0).toString(36);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/utils/routing.js
+/**
+* @param {RegExpMatchArray} match
+* @param {import('types').RouteParam[]} params
+* @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+*/
+function exec(match, params, matchers) {
+	/** @type {Record<string, string>} */
+	const result = {};
+	const values = match.slice(1);
+	const values_needing_match = values.filter((value) => value !== void 0);
+	let buffered = 0;
+	for (let i = 0; i < params.length; i += 1) {
+		const param = params[i];
+		let value = values[i - buffered];
+		if (param.chained && param.rest && buffered) {
+			value = values.slice(i - buffered, i + 1).filter((s) => s).join("/");
+			buffered = 0;
+		}
+		if (value === void 0) if (param.rest) value = "";
+		else continue;
+		if (!param.matcher || matchers[param.matcher](value)) {
+			result[param.name] = value;
+			const next_param = params[i + 1];
+			const next_value = values[i + 1];
+			if (next_param && !next_param.rest && next_param.optional && next_value && param.chained) buffered = 0;
+			if (!next_param && !next_value && Object.keys(result).length === values_needing_match.length) buffered = 0;
+			continue;
+		}
+		if (param.optional && param.chained) {
+			buffered++;
+			continue;
+		}
+		return;
+	}
+	if (buffered) return;
+	return result;
+}
+/**
+* Find the first route that matches the given path
+* @template {{pattern: RegExp, params: import('types').RouteParam[]}} Route
+* @param {string} path - The decoded pathname to match
+* @param {Route[]} routes
+* @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+* @returns {{ route: Route, params: Record<string, string> } | null}
+*/
+function find_route(path, routes, matchers) {
+	for (const route of routes) {
+		const match = route.pattern.exec(path);
+		if (!match) continue;
+		const matched = exec(match, route.params, matchers);
+		if (matched) return {
+			route,
+			params: decode_params(matched)
+		};
+	}
+	return null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.61.1_@sveltejs+vite-plugin-svelte@7.1.2_svelte@5.55.9_@typescript-eslin_692b2477997906027053802989c8d7b8/node_modules/@sveltejs/kit/src/utils/exports.js
+/**
+* @param {Set<string>} expected
+*/
+function validator(expected) {
+	/**
+	* @param {any} module
+	* @param {string} [file]
+	*/
+	function validate(module, file) {
+		if (!module) return;
+		for (const key in module) {
+			if (key[0] === "_" || expected.has(key)) continue;
+			const values = [...expected.values()];
+			const hint = hint_for_supported_files(key, file?.slice(file.lastIndexOf("."))) ?? `valid exports are ${values.join(", ")}, or anything with a '_' prefix`;
+			throw new Error(`Invalid export '${key}'${file ? ` in ${file}` : ""} (${hint})`);
+		}
+	}
+	return validate;
+}
+/**
+* @param {string} key
+* @param {string} ext
+* @returns {string | void}
+*/
+function hint_for_supported_files(key, ext = ".js") {
+	const supported_files = [];
+	if (valid_layout_exports.has(key)) supported_files.push(`+layout${ext}`);
+	if (valid_page_exports.has(key)) supported_files.push(`+page${ext}`);
+	if (valid_layout_server_exports.has(key)) supported_files.push(`+layout.server${ext}`);
+	if (valid_page_server_exports.has(key)) supported_files.push(`+page.server${ext}`);
+	if (valid_server_exports.has(key)) supported_files.push(`+server${ext}`);
+	if (supported_files.length > 0) return `'${key}' is a valid export in ${supported_files.slice(0, -1).join(", ")}${supported_files.length > 1 ? " or " : ""}${supported_files.at(-1)}`;
+}
+var valid_layout_exports = new Set([
+	"load",
+	"prerender",
+	"csr",
+	"ssr",
+	"trailingSlash",
+	"config"
+]);
+var valid_page_exports = new Set([...valid_layout_exports, "entries"]);
+var valid_layout_server_exports = new Set([...valid_layout_exports]);
+var valid_page_server_exports = new Set([
+	...valid_layout_server_exports,
+	"actions",
+	"entries"
+]);
+var valid_server_exports = new Set([
+	"GET",
+	"POST",
+	"PATCH",
+	"PUT",
+	"DELETE",
+	"OPTIONS",
+	"HEAD",
+	"fallback",
+	"prerender",
+	"trailingSlash",
+	"config",
+	"entries"
+]);
+var validate_layout_exports = validator(valid_layout_exports);
+var validate_page_exports = validator(valid_page_exports);
+var validate_layout_server_exports = validator(valid_layout_server_exports);
+var validate_page_server_exports = validator(valid_page_server_exports);
+
+//#region \0virtual:__sveltekit/server
+var read_implementation = null;
+function set_read_implementation(fn) {
+	read_implementation = fn;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/elements/events.js
+/**
+* Used on elements, as a map of event type -> event handler,
+* and on events themselves to track which element handled an event
+*/
+var event_symbol = Symbol("events");
+/** @type {Set<string>} */
+var all_registered_events = /* @__PURE__ */ new Set();
+/** @type {Set<(events: Array<string>) => void>} */
+var root_event_handles = /* @__PURE__ */ new Set();
+var last_propagated_event = null;
+/**
+* @this {EventTarget}
+* @param {Event} event
+* @returns {void}
+*/
+function handle_event_propagation(event) {
+	var handler_element = this;
+	var owner_document = handler_element.ownerDocument;
+	var event_name = event.type;
+	var path = event.composedPath?.() || [];
+	var current_target = path[0] || event.target;
+	last_propagated_event = event;
+	var path_idx = 0;
+	var handled_at = last_propagated_event === event && event[event_symbol];
+	if (handled_at) {
+		var at_idx = path.indexOf(handled_at);
+		if (at_idx !== -1 && (handler_element === document || handler_element === window)) {
+			event[event_symbol] = handler_element;
+			return;
+		}
+		var handler_idx = path.indexOf(handler_element);
+		if (handler_idx === -1) return;
+		if (at_idx <= handler_idx) path_idx = at_idx;
+	}
+	current_target = path[path_idx] || event.target;
+	if (current_target === handler_element) return;
+	define_property(event, "currentTarget", {
+		configurable: true,
+		get() {
+			return current_target || owner_document;
+		}
+	});
+	var previous_reaction = active_reaction;
+	var previous_effect = active_effect;
+	set_active_reaction(null);
+	set_active_effect(null);
+	try {
+		/**
+		* @type {unknown}
+		*/
+		var throw_error;
+		/**
+		* @type {unknown[]}
+		*/
+		var other_errors = [];
+		while (current_target !== null) {
+			/** @type {null | Element} */
+			var parent_element = current_target.assignedSlot || current_target.parentNode || current_target.host || null;
+			try {
+				var delegated = current_target[event_symbol]?.[event_name];
+				if (delegated != null && (!current_target.disabled || event.target === current_target)) delegated.call(current_target, event);
+			} catch (error) {
+				if (throw_error) other_errors.push(error);
+				else throw_error = error;
+			}
+			if (event.cancelBubble || parent_element === handler_element || parent_element === null) break;
+			current_target = parent_element;
+		}
+		if (throw_error) {
+			for (let error of other_errors) queueMicrotask(() => {
+				throw error;
+			});
+			throw throw_error;
+		}
+	} finally {
+		event[event_symbol] = handler_element;
+		delete event.currentTarget;
+		set_active_reaction(previous_reaction);
+		set_active_effect(previous_effect);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/internal/client/dom/template.js
+/**
+* @param {TemplateNode} start
+* @param {TemplateNode | null} end
+*/
+function assign_nodes(start, end) {
+	var effect = active_effect;
+	if (effect.nodes === null) effect.nodes = {
+		start,
+		end,
+		a: null,
+		t: null
+	};
+}
+/**
+* Mounts a component to the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component.
+* Transitions will play during the initial render unless the `intro` option is set to `false`.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
+* @param {MountOptions<Props>} options
+* @returns {Exports}
+*/
+function mount(component, options) {
+	return _mount(component, options);
+}
+/**
+* Hydrates a component on the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
+* @param {{} extends Props ? {
+* 		target: Document | Element | ShadowRoot;
+* 		props?: Props;
+* 		events?: Record<string, (e: any) => any>;
+*  	context?: Map<any, any>;
+* 		intro?: boolean;
+* 		recover?: boolean;
+*		transformError?: (error: unknown) => unknown;
+* 	} : {
+* 		target: Document | Element | ShadowRoot;
+* 		props: Props;
+* 		events?: Record<string, (e: any) => any>;
+*  	context?: Map<any, any>;
+* 		intro?: boolean;
+* 		recover?: boolean;
+*		transformError?: (error: unknown) => unknown;
+* 	}} options
+* @returns {Exports}
+*/
+function hydrate(component, options) {
+	init_operations();
+	options.intro = options.intro ?? false;
+	const target = options.target;
+	const was_hydrating = hydrating;
+	const previous_hydrate_node = hydrate_node;
+	try {
+		var anchor = /* @__PURE__ */ get_first_child(target);
+		while (anchor && (anchor.nodeType !== 8 || anchor.data !== "[")) anchor = /* @__PURE__ */ get_next_sibling(anchor);
+		if (!anchor) throw HYDRATION_ERROR;
+		set_hydrating(true);
+		set_hydrate_node(anchor);
+		const instance = _mount(component, {
+			...options,
+			anchor
+		});
+		set_hydrating(false);
+		return instance;
+	} catch (error) {
+		if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) throw error;
+		if (error !== HYDRATION_ERROR) console.warn("Failed to hydrate: ", error);
+		if (options.recover === false) hydration_failed();
+		init_operations();
+		clear_text_content(target);
+		set_hydrating(false);
+		return mount(component, options);
+	} finally {
+		set_hydrating(was_hydrating);
+		set_hydrate_node(previous_hydrate_node);
+	}
+}
+/** @type {Map<EventTarget, Map<string, number>>} */
+var listeners = /* @__PURE__ */ new Map();
+/**
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<any>> | Component<any>} Component
+* @param {MountOptions} options
+* @returns {Exports}
+*/
+function _mount(Component, { target, anchor, props = {}, events, context, intro = true, transformError }) {
+	init_operations();
+	/** @type {Exports} */
+	var component = void 0;
+	var unmount = component_root(() => {
+		var anchor_node = anchor ?? target.appendChild(create_text());
+		boundary(anchor_node, { pending: () => {} }, (anchor_node) => {
+			push({});
+			var ctx = component_context;
+			if (context) ctx.c = context;
+			if (events)
+ /** @type {any} */ props.$$events = events;
+			if (hydrating) assign_nodes(anchor_node, null);
+			component = Component(anchor_node, props) || {};
+			if (hydrating) {
+				/** @type {Effect & { nodes: EffectNodes }} */ active_effect.nodes.end = hydrate_node;
+				if (hydrate_node === null || hydrate_node.nodeType !== 8 || hydrate_node.data !== "]") {
+					hydration_mismatch();
+					throw HYDRATION_ERROR;
+				}
+			}
+			pop();
+		}, transformError);
+		/** @type {Set<string>} */
+		var registered_events = /* @__PURE__ */ new Set();
+		/** @param {Array<string>} events */
+		var event_handle = (events) => {
+			for (var i = 0; i < events.length; i++) {
+				var event_name = events[i];
+				if (registered_events.has(event_name)) continue;
+				registered_events.add(event_name);
+				var passive = is_passive_event(event_name);
+				for (const node of [target, document]) {
+					var counts = listeners.get(node);
+					if (counts === void 0) {
+						counts = /* @__PURE__ */ new Map();
+						listeners.set(node, counts);
+					}
+					var count = counts.get(event_name);
+					if (count === void 0) {
+						node.addEventListener(event_name, handle_event_propagation, { passive });
+						counts.set(event_name, 1);
+					} else counts.set(event_name, count + 1);
+				}
+			}
+		};
+		event_handle(array_from(all_registered_events));
+		root_event_handles.add(event_handle);
+		return () => {
+			for (var event_name of registered_events) for (const node of [target, document]) {
+				var counts = listeners.get(node);
+				var count = counts.get(event_name);
+				if (--count == 0) {
+					node.removeEventListener(event_name, handle_event_propagation);
+					counts.delete(event_name);
+					if (counts.size === 0) listeners.delete(node);
+				} else counts.set(event_name, count);
+			}
+			root_event_handles.delete(event_handle);
+			if (anchor_node !== anchor) anchor_node.parentNode?.removeChild(anchor_node);
+		};
+	});
+	mounted_components.set(component, unmount);
+	return component;
+}
+/**
+* References of the components that were mounted or hydrated.
+* Uses a `WeakMap` to avoid memory leaks.
+*/
+var mounted_components = /* @__PURE__ */ new WeakMap();
+/**
+* Unmounts a component that was previously mounted using `mount` or `hydrate`.
+*
+* Since 5.13.0, if `options.outro` is `true`, [transitions](https://svelte.dev/docs/svelte/transition) will play before the component is removed from the DOM.
+*
+* Returns a `Promise` that resolves after transitions have completed if `options.outro` is true, or immediately otherwise (prior to 5.13.0, returns `void`).
+*
+* ```js
+* import { mount, unmount } from 'svelte';
+* import App from './App.svelte';
+*
+* const app = mount(App, { target: document.body });
+*
+* // later...
+* unmount(app, { outro: true });
+* ```
+* @param {Record<string, any>} component
+* @param {{ outro?: boolean }} [options]
+* @returns {Promise<void>}
+*/
+function unmount(component, options) {
+	const fn = mounted_components.get(component);
+	if (fn) {
+		mounted_components.delete(component);
+		return fn(options);
+	}
+	return Promise.resolve();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/legacy/legacy-client.js
+/** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
+/**
+* Takes the component function and returns a Svelte 4 compatible component constructor.
+*
+* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @template {Record<string, any>} Events
+* @template {Record<string, any>} Slots
+*
+* @param {SvelteComponent<Props, Events, Slots> | Component<Props>} component
+* @returns {ComponentType<SvelteComponent<Props, Events, Slots> & Exports>}
+*/
+function asClassComponent$1(component) {
+	return class extends Svelte4Component {
+		/** @param {any} options */
+		constructor(options) {
+			super({
+				component,
+				...options
+			});
+		}
+	};
+}
+/**
+* Support using the component as both a class and function during the transition period
+* @typedef  {{new (o: ComponentConstructorOptions): SvelteComponent;(...args: Parameters<Component<Record<string, any>>>): ReturnType<Component<Record<string, any>, Record<string, any>>>;}} LegacyComponentType
+*/
+var Svelte4Component = class {
+	/** @type {any} */
+	#events;
+	/** @type {Record<string, any>} */
+	#instance;
+	/**
+	* @param {ComponentConstructorOptions & {
+	*  component: any;
+	* }} options
+	*/
+	constructor(options) {
+		var sources = /* @__PURE__ */ new Map();
+		/**
+		* @param {string | symbol} key
+		* @param {unknown} value
+		*/
+		var add_source = (key, value) => {
+			var s = /* @__PURE__ */ mutable_source(value, false, false);
+			sources.set(key, s);
+			return s;
+		};
+		const props = new Proxy({
+			...options.props || {},
+			$$events: {}
+		}, {
+			get(target, prop) {
+				return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+			},
+			has(target, prop) {
+				if (prop === LEGACY_PROPS) return true;
+				get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+				return Reflect.has(target, prop);
+			},
+			set(target, prop, value) {
+				set(sources.get(prop) ?? add_source(prop, value), value);
+				return Reflect.set(target, prop, value);
+			}
+		});
+		this.#instance = (options.hydrate ? hydrate : mount)(options.component, {
+			target: options.target,
+			anchor: options.anchor,
+			props,
+			context: options.context,
+			intro: options.intro ?? false,
+			recover: options.recover,
+			transformError: options.transformError
+		});
+		if ((!options?.props?.$$host || options.sync === false)) flushSync();
+		this.#events = props.$$events;
+		for (const key of Object.keys(this.#instance)) {
+			if (key === "$set" || key === "$destroy" || key === "$on") continue;
+			define_property(this, key, {
+				get() {
+					return this.#instance[key];
+				},
+				/** @param {any} value */
+				set(value) {
+					this.#instance[key] = value;
+				},
+				enumerable: true
+			});
+		}
+		this.#instance.$set = (next) => {
+			Object.assign(props, next);
+		};
+		this.#instance.$destroy = () => {
+			unmount(this.#instance);
+		};
+	}
+	/** @param {Record<string, any>} props */
+	$set(props) {
+		this.#instance.$set(props);
+	}
+	/**
+	* @param {string} event
+	* @param {(...args: any[]) => any} callback
+	* @returns {any}
+	*/
+	$on(event, callback) {
+		this.#events[event] = this.#events[event] || [];
+		/** @param {any[]} args */
+		const cb = (...args) => callback.call(this, ...args);
+		this.#events[event].push(cb);
+		return () => {
+			this.#events[event] = this.#events[event].filter(
+				/** @param {any} fn */
+				(fn) => fn !== cb
+			);
+		};
+	}
+	$destroy() {
+		this.#instance.$destroy();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.60.0/node_modules/svelte/src/legacy/legacy-server.js
+/** @import { SvelteComponent } from '../index.js' */
+/** @import { Csp } from '#server' */
+/** @typedef {{ head: string, html: string, css: { code: string, map: null }; hashes?: { script: `sha256-${string}`[] } }} LegacyRenderResult */
+/**
+* Takes a Svelte 5 component and returns a Svelte 4 compatible component constructor.
+*
+* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @template {Record<string, any>} Events
+* @template {Record<string, any>} Slots
+*
+* @param {SvelteComponent<Props, Events, Slots>} component
+* @returns {typeof SvelteComponent<Props, Events, Slots> & Exports}
+*/
+function asClassComponent(component) {
+	const component_constructor = asClassComponent$1(component);
+	/** @type {(props?: {}, opts?: { $$slots?: {}; context?: Map<any, any>; csp?: Csp; transformError?: (error: unknown) => unknown }) => LegacyRenderResult & PromiseLike<LegacyRenderResult> } */
+	const _render = (props, { context, csp, transformError } = {}) => {
+		const result = render(component, {
+			props,
+			context,
+			csp,
+			transformError
+		});
+		const munged = Object.defineProperties({}, {
+			css: { value: {
+				code: "",
+				map: null
+			} },
+			head: { get: () => result.head },
+			html: { get: () => result.body },
+			then: { 
+			/**
+			* 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: LegacyRenderResult) => TResult1 } onfulfilled
+			* @param { (reason: unknown) => TResult2 } onrejected
+			*/
+value: (onfulfilled, onrejected) => {
+				{
+					const user_result = onfulfilled({
+						css: munged.css,
+						head: munged.head,
+						html: munged.html
+					});
+					return Promise.resolve(user_result);
+				}
+			} }
+		});
+		return munged;
+	};
+	component_constructor.render = _render;
+	return component_constructor;
+}
+//#endregion
+//#region .svelte-kit/generated/root.svelte
+function Root($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { stores, page, constructors, components = [], form, data_0 = null, data_1 = null } = $$props;
+		setContext("__svelte__", stores);
+		stores.page.set(page);
+		const Pyramid_1 = derived(() => constructors[1]);
+		if (constructors[1]) {
+			$$renderer.push("<!--[0-->");
+			const Pyramid_0 = constructors[0];
+			if (Pyramid_0) {
+				$$renderer.push("<!--[-->");
+				Pyramid_0($$renderer, {
+					data: data_0,
+					form,
+					params: page.params,
+					children: ($$renderer) => {
+						if (Pyramid_1()) {
+							$$renderer.push("<!--[-->");
+							Pyramid_1()($$renderer, {
+								data: data_1,
+								form,
+								params: page.params
+							});
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+					},
+					$$slots: { default: true }
+				});
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		} else {
+			$$renderer.push("<!--[-1-->");
+			const Pyramid_0 = constructors[0];
+			if (Pyramid_0) {
+				$$renderer.push("<!--[-->");
+				Pyramid_0($$renderer, {
+					data: data_0,
+					form,
+					params: page.params
+				});
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		$$renderer.push(`<!--]--> `);
+		$$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+	});
+}
+//#endregion
+//#region .svelte-kit/generated/server/internal.js
+var options = {
+	app_template_contains_nonce: false,
+	async: false,
+	csp: {
+		"mode": "auto",
+		"directives": {
+			"upgrade-insecure-requests": false,
+			"block-all-mixed-content": false
+		},
+		"reportOnly": {
+			"upgrade-insecure-requests": false,
+			"block-all-mixed-content": false
+		}
+	},
+	csrf_check_origin: true,
+	csrf_trusted_origins: [],
+	embedded: false,
+	env_public_prefix: "PUBLIC_",
+	env_private_prefix: "",
+	hash_routing: false,
+	hooks: null,
+	preload_strategy: "modulepreload",
+	root: asClassComponent(Root),
+	service_worker: false,
+	service_worker_options: void 0,
+	server_error_boundaries: false,
+	templates: {
+		app: ({ head, body, assets, nonce, env }) => "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <link rel=\"icon\" href=\"" + assets + "/favicon.png\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    " + head + "\n  </head>\n  <body data-sveltekit-preload-data=\"hover\">\n    <div style=\"display: contents\">" + body + "</div>\n  </body>\n</html>\n",
+		error: ({ status, message }) => "<!doctype html>\n<html lang=\"en\">\n	<head>\n		<meta charset=\"utf-8\" />\n		<title>" + message + "</title>\n\n		<style>\n			body {\n				--bg: white;\n				--fg: #222;\n				--divider: #ccc;\n				background: var(--bg);\n				color: var(--fg);\n				font-family:\n					system-ui,\n					-apple-system,\n					BlinkMacSystemFont,\n					'Segoe UI',\n					Roboto,\n					Oxygen,\n					Ubuntu,\n					Cantarell,\n					'Open Sans',\n					'Helvetica Neue',\n					sans-serif;\n				display: flex;\n				align-items: center;\n				justify-content: center;\n				height: 100vh;\n				margin: 0;\n			}\n\n			.error {\n				display: flex;\n				align-items: center;\n				max-width: 32rem;\n				margin: 0 1rem;\n			}\n\n			.status {\n				font-weight: 200;\n				font-size: 3rem;\n				line-height: 1;\n				position: relative;\n				top: -0.05rem;\n			}\n\n			.message {\n				border-left: 1px solid var(--divider);\n				padding: 0 0 0 1rem;\n				margin: 0 0 0 1rem;\n				min-height: 2.5rem;\n				display: flex;\n				align-items: center;\n			}\n\n			.message h1 {\n				font-weight: 400;\n				font-size: 1em;\n				margin: 0;\n			}\n\n			@media (prefers-color-scheme: dark) {\n				body {\n					--bg: #222;\n					--fg: #ddd;\n					--divider: #666;\n				}\n			}\n		</style>\n	</head>\n	<body>\n		<div class=\"error\">\n			<span class=\"status\">" + status + "</span>\n			<div class=\"message\">\n				<h1>" + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
+	},
+	version_hash: "16i0po3"
+};
+async function get_hooks() {
+	let handle;
+	let handleFetch;
+	let handleError;
+	let handleValidationError;
+	let init;
+	({handle, handleFetch, handleError, handleValidationError, init} = await import('./hooks.server-BBW_dqIs.js'));
+	let reroute;
+	let transport;
+	return {
+		handle,
+		handleFetch,
+		handleError,
+		handleValidationError,
+		init,
+		reroute,
+		transport
+	};
+}
+
+export { validate_page_exports as $, normalize_error as A, normalize_path as B, onDestroy as C, once as D, options as E, override as F, parse as G, parse_remote_arg as H, INVALIDATED_PARAM as I, public_env as J, read_implementation as K, reset as L, resolve as M, set_private_env as N, set_public_env as O, set_read_implementation as P, split_remote_key as Q, stringify as R, stringify$1 as S, TRAILING_SLASH_PARAM as T, strip_data_suffix as U, strip_resolution_suffix as V, text_encoder as W, tick as X, validate_layout_exports as Y, validate_layout_server_exports as Z, __commonJSMin as _, __exportAll as a, validate_page_server_exports as a0, with_request_store as a1, __require as b, __toESM as c, add_data_suffix as d, add_resolution_suffix as e, app_dir as f, assets as g, base as h, base64_encode as i, coalesce_to_error as j, compact as k, create_remote_key as l, decode_pathname as m, disable_search as n, find_route as o, get_hooks as p, get_message as q, get_relative_path as r, get_status as s, has_data_suffix as t, has_resolution_suffix as u, hash as v, index_server_exports as w, make_trackable as x, noop as y, noop_span as z };
+//# sourceMappingURL=internal-BrzrGF6g.js.map