added phobos section

.gi

@@ -0,0 +1,36 @@
+# build folder
+dist/
+build/
+
+# logs
+logs/
+.cache
+.DS_Store
+npm-debug.log
+yarn-debug.log
+yarn-error.log
+
+# process data
+.pid
+pids
+.pid-lock
+
+# Coverage & Test
+coverage
+.nyc_output
+
+# Dependency folder
+node_modules
+bower_components
+jspm_packages
+
+# Environment files
+.dot
+# Editor and other files
+.idea
+typing
+internal
+.vscode
+*.tgz
+.eslintcache
+.svelte-kit

.gitea/workflows/ci.yaml

@@ -1,43 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-defaults:
-  run:
-    shell: /bin/sh -e {0} 
-  
-env:
-  PATH: /run/current-system/sw/bin:/run/wrappers/bin:/usr/bin:/bin
-
-jobs:
-  build:
-    runs-on: homelab
-    steps:
-      - name: Configure git
-        run: git config --global --add safe.directory /servers/site
-      
-      - name: Create repo
-        run: |
-          [ ! -d /servers/site ] && git clone https://git.jeremyjanella.com/jjanella/site.git /servers/site || true
-        
-      - name: Pull
-        working-directory: /servers/site
-        run: git pull origin main
-      
-      - name: Build
-        working-directory: /servers/site
-        run: |
-          nix develop --command cargo build --release 2>&1
-
-      - name: Restart site
-        working-directory: /servers/site
-        run: |
-          pkill site || true
-          setsid ./target/release/site > server.log 2>&1 &
-          sleep 1
-          pgrep site && echo "Site is running!"
-

.gitignore

@@ -1,5 +0,0 @@
-# Dont commit compiled binaries
-/target
-
-# For nixos direnv
-.envrc

.npmrc

@@ -0,0 +1 @@
+engine-strict=true

.svelte-kit/ambient.d.ts

@@ -0,0 +1,279 @@
+
+// this file is generated — do not edit it
+
+
+/// <reference types="@sveltejs/kit" />
+
+/**
+ * Environment variables [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env`. Like [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private), this module cannot be imported into client-side code. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://svelte.dev/docs/kit/configuration#env) (if configured).
+ * 
+ * _Unlike_ [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private), the values exported from this module are statically injected into your bundle at build time, enabling optimisations like dead code elimination.
+ * 
+ * ```ts
+ * import { API_KEY } from '$env/static/private';
+ * ```
+ * 
+ * Note that all environment variables referenced in your code should be declared (for example in an `.env` file), even if they don't have a value until the app is deployed:
+ * 
+ * ```
+ * MY_FEATURE_FLAG=""
+ * ```
+ * 
+ * You can override `.env` values from the command line like so:
+ * 
+ * ```bash
+ * MY_FEATURE_FLAG="enabled" npm run dev
+ * ```
+ */
+declare module '$env/static/private' {
+	export const SHELL: string;
+	export const npm_command: string;
+	export const SESSION_MANAGER: string;
+	export const npm_config_userconfig: string;
+	export const QT_SCREEN_SCALE_FACTORS: string;
+	export const COLORTERM: string;
+	export const XDG_CONFIG_DIRS: string;
+	export const npm_config_cache: string;
+	export const XDG_SESSION_PATH: string;
+	export const XDG_MENU_PREFIX: string;
+	export const TERM_PROGRAM_VERSION: string;
+	export const ICEAUTHORITY: string;
+	export const NODE: string;
+	export const LC_ADDRESS: string;
+	export const LC_NAME: string;
+	export const MEMORY_PRESSURE_WRITE: string;
+	export const COLOR: string;
+	export const npm_config_local_prefix: string;
+	export const DESKTOP_SESSION: string;
+	export const LC_MONETARY: string;
+	export const GTK_RC_FILES: string;
+	export const NO_AT_BRIDGE: string;
+	export const npm_config_globalconfig: string;
+	export const EDITOR: string;
+	export const GTK_MODULES: string;
+	export const XDG_SEAT: string;
+	export const PWD: string;
+	export const LOGNAME: string;
+	export const XDG_SESSION_DESKTOP: string;
+	export const XDG_SESSION_TYPE: string;
+	export const npm_config_init_module: string;
+	export const SYSTEMD_EXEC_PID: string;
+	export const _: string;
+	export const XAUTHORITY: string;
+	export const VSCODE_GIT_ASKPASS_NODE: string;
+	export const MOTD_SHOWN: string;
+	export const GTK2_RC_FILES: string;
+	export const HOME: string;
+	export const LANG: string;
+	export const LC_PAPER: string;
+	export const XDG_CURRENT_DESKTOP: string;
+	export const npm_package_version: string;
+	export const MEMORY_PRESSURE_WATCH: string;
+	export const GIT_ASKPASS: string;
+	export const XDG_SEAT_PATH: string;
+	export const INVOCATION_ID: string;
+	export const MANAGERPID: string;
+	export const INIT_CWD: string;
+	export const CHROME_DESKTOP: string;
+	export const KDE_SESSION_UID: string;
+	export const npm_lifecycle_script: string;
+	export const VSCODE_GIT_ASKPASS_EXTRA_ARGS: string;
+	export const npm_config_npm_version: string;
+	export const XDG_SESSION_CLASS: string;
+	export const LC_IDENTIFICATION: string;
+	export const TERM: string;
+	export const npm_package_name: string;
+	export const npm_config_prefix: string;
+	export const USER: string;
+	export const VSCODE_GIT_IPC_HANDLE: string;
+	export const QT_WAYLAND_RECONNECT: string;
+	export const KDE_SESSION_VERSION: string;
+	export const PAM_KWALLET5_LOGIN: string;
+	export const DISPLAY: string;
+	export const npm_lifecycle_event: string;
+	export const GSK_RENDERER: string;
+	export const SHLVL: string;
+	export const LC_TELEPHONE: string;
+	export const LC_MEASUREMENT: string;
+	export const XDG_VTNR: string;
+	export const XDG_SESSION_ID: string;
+	export const MANAGERPIDFDID: string;
+	export const npm_config_user_agent: string;
+	export const ROCM_PATH: string;
+	export const npm_execpath: string;
+	export const XDG_RUNTIME_DIR: string;
+	export const MKLROOT: string;
+	export const DEBUGINFOD_URLS: string;
+	export const npm_package_json: string;
+	export const LC_TIME: string;
+	export const VSCODE_GIT_ASKPASS_MAIN: string;
+	export const JOURNAL_STREAM: string;
+	export const XDG_DATA_DIRS: string;
+	export const KDE_FULL_SESSION: string;
+	export const GDK_BACKEND: string;
+	export const npm_config_noproxy: string;
+	export const BROWSER: string;
+	export const PATH: string;
+	export const npm_config_node_gyp: string;
+	export const ORIGINAL_XDG_CURRENT_DESKTOP: string;
+	export const DBUS_SESSION_BUS_ADDRESS: string;
+	export const npm_config_global_prefix: string;
+	export const KDE_APPLICATIONS_AS_SCOPE: string;
+	export const MAIL: string;
+	export const npm_node_execpath: string;
+	export const npm_config_engine_strict: string;
+	export const LC_NUMERIC: string;
+	export const TERM_PROGRAM: string;
+	export const NODE_ENV: string;
+}
+
+/**
+ * Similar to [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private), except that it only includes environment variables that begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) (which defaults to `PUBLIC_`), and can therefore safely be exposed to client-side code.
+ * 
+ * Values are replaced statically at build time.
+ * 
+ * ```ts
+ * import { PUBLIC_BASE_URL } from '$env/static/public';
+ * ```
+ */
+declare module '$env/static/public' {
+	
+}
+
+/**
+ * This module provides access to runtime environment variables, as defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/main/packages/adapter-node) (or running [`vite preview`](https://svelte.dev/docs/kit/cli)), this is equivalent to `process.env`. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://svelte.dev/docs/kit/configuration#env) (if configured).
+ * 
+ * This module cannot be imported into client-side code.
+ * 
+ * Dynamic environment variables cannot be used during prerendering.
+ * 
+ * ```ts
+ * import { env } from '$env/dynamic/private';
+ * console.log(env.DEPLOYMENT_SPECIFIC_VARIABLE);
+ * ```
+ * 
+ * > In `dev`, `$env/dynamic` always includes environment variables from `.env`. In `prod`, this behavior will depend on your adapter.
+ */
+declare module '$env/dynamic/private' {
+	export const env: {
+		SHELL: string;
+		npm_command: string;
+		SESSION_MANAGER: string;
+		npm_config_userconfig: string;
+		QT_SCREEN_SCALE_FACTORS: string;
+		COLORTERM: string;
+		XDG_CONFIG_DIRS: string;
+		npm_config_cache: string;
+		XDG_SESSION_PATH: string;
+		XDG_MENU_PREFIX: string;
+		TERM_PROGRAM_VERSION: string;
+		ICEAUTHORITY: string;
+		NODE: string;
+		LC_ADDRESS: string;
+		LC_NAME: string;
+		MEMORY_PRESSURE_WRITE: string;
+		COLOR: string;
+		npm_config_local_prefix: string;
+		DESKTOP_SESSION: string;
+		LC_MONETARY: string;
+		GTK_RC_FILES: string;
+		NO_AT_BRIDGE: string;
+		npm_config_globalconfig: string;
+		EDITOR: string;
+		GTK_MODULES: string;
+		XDG_SEAT: string;
+		PWD: string;
+		LOGNAME: string;
+		XDG_SESSION_DESKTOP: string;
+		XDG_SESSION_TYPE: string;
+		npm_config_init_module: string;
+		SYSTEMD_EXEC_PID: string;
+		_: string;
+		XAUTHORITY: string;
+		VSCODE_GIT_ASKPASS_NODE: string;
+		MOTD_SHOWN: string;
+		GTK2_RC_FILES: string;
+		HOME: string;
+		LANG: string;
+		LC_PAPER: string;
+		XDG_CURRENT_DESKTOP: string;
+		npm_package_version: string;
+		MEMORY_PRESSURE_WATCH: string;
+		GIT_ASKPASS: string;
+		XDG_SEAT_PATH: string;
+		INVOCATION_ID: string;
+		MANAGERPID: string;
+		INIT_CWD: string;
+		CHROME_DESKTOP: string;
+		KDE_SESSION_UID: string;
+		npm_lifecycle_script: string;
+		VSCODE_GIT_ASKPASS_EXTRA_ARGS: string;
+		npm_config_npm_version: string;
+		XDG_SESSION_CLASS: string;
+		LC_IDENTIFICATION: string;
+		TERM: string;
+		npm_package_name: string;
+		npm_config_prefix: string;
+		USER: string;
+		VSCODE_GIT_IPC_HANDLE: string;
+		QT_WAYLAND_RECONNECT: string;
+		KDE_SESSION_VERSION: string;
+		PAM_KWALLET5_LOGIN: string;
+		DISPLAY: string;
+		npm_lifecycle_event: string;
+		GSK_RENDERER: string;
+		SHLVL: string;
+		LC_TELEPHONE: string;
+		LC_MEASUREMENT: string;
+		XDG_VTNR: string;
+		XDG_SESSION_ID: string;
+		MANAGERPIDFDID: string;
+		npm_config_user_agent: string;
+		ROCM_PATH: string;
+		npm_execpath: string;
+		XDG_RUNTIME_DIR: string;
+		MKLROOT: string;
+		DEBUGINFOD_URLS: string;
+		npm_package_json: string;
+		LC_TIME: string;
+		VSCODE_GIT_ASKPASS_MAIN: string;
+		JOURNAL_STREAM: string;
+		XDG_DATA_DIRS: string;
+		KDE_FULL_SESSION: string;
+		GDK_BACKEND: string;
+		npm_config_noproxy: string;
+		BROWSER: string;
+		PATH: string;
+		npm_config_node_gyp: string;
+		ORIGINAL_XDG_CURRENT_DESKTOP: string;
+		DBUS_SESSION_BUS_ADDRESS: string;
+		npm_config_global_prefix: string;
+		KDE_APPLICATIONS_AS_SCOPE: string;
+		MAIL: string;
+		npm_node_execpath: string;
+		npm_config_engine_strict: string;
+		LC_NUMERIC: string;
+		TERM_PROGRAM: string;
+		NODE_ENV: string;
+		[key: `PUBLIC_${string}`]: undefined;
+		[key: `${string}`]: string | undefined;
+	}
+}
+
+/**
+ * Similar to [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private), but only includes variables that begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) (which defaults to `PUBLIC_`), and can therefore safely be exposed to client-side code.
+ * 
+ * Note that public dynamic environment variables must all be sent from the server to the client, causing larger network requests — when possible, use `$env/static/public` instead.
+ * 
+ * Dynamic environment variables cannot be used during prerendering.
+ * 
+ * ```ts
+ * import { env } from '$env/dynamic/public';
+ * console.log(env.PUBLIC_DEPLOYMENT_SPECIFIC_VARIABLE);
+ * ```
+ */
+declare module '$env/dynamic/public' {
+	export const env: {
+		[key: `PUBLIC_${string}`]: string | undefined;
+	}
+}

.svelte-kit/generated/client-optimized/app.js

@@ -0,0 +1,28 @@
+export { matchers } from './matchers.js';
+
+export const nodes = [
+	() => import('./nodes/0'),
+	() => import('./nodes/1'),
+	() => import('./nodes/2')
+];
+
+export const server_loads = [];
+
+export const dictionary = {
+		"/": [2]
+	};
+
+export const hooks = {
+	handleError: (({ error }) => { console.error(error) }),
+	
+	reroute: (() => {}),
+	transport: {}
+};
+
+export const decoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.decode]));
+
+export const hash = false;
+
+export const decode = (type, value) => decoders[type](value);
+
+export { default as root } from '../root.js';

.svelte-kit/generated/client-optimized/matchers.js

@@ -0,0 +1 @@
+export const matchers = {};

.svelte-kit/generated/client-optimized/nodes/0.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../node_modules/@sveltejs/kit/src/runtime/components/svelte-5/layout.svelte";

.svelte-kit/generated/client-optimized/nodes/1.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../node_modules/@sveltejs/kit/src/runtime/components/svelte-5/error.svelte";

.svelte-kit/generated/client-optimized/nodes/2.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../src/routes/+page.svelte";

.svelte-kit/generated/client/app.js

@@ -0,0 +1,28 @@
+export { matchers } from './matchers.js';
+
+export const nodes = [
+	() => import('./nodes/0'),
+	() => import('./nodes/1'),
+	() => import('./nodes/2')
+];
+
+export const server_loads = [];
+
+export const dictionary = {
+		"/": [2]
+	};
+
+export const hooks = {
+	handleError: (({ error }) => { console.error(error) }),
+	
+	reroute: (() => {}),
+	transport: {}
+};
+
+export const decoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.decode]));
+
+export const hash = false;
+
+export const decode = (type, value) => decoders[type](value);
+
+export { default as root } from '../root.js';

.svelte-kit/generated/client/matchers.js

@@ -0,0 +1 @@
+export const matchers = {};

.svelte-kit/generated/client/nodes/0.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../node_modules/@sveltejs/kit/src/runtime/components/svelte-5/layout.svelte";

.svelte-kit/generated/client/nodes/1.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../node_modules/@sveltejs/kit/src/runtime/components/svelte-5/error.svelte";

.svelte-kit/generated/client/nodes/2.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../src/routes/+page.svelte";

.svelte-kit/generated/root.js

@@ -0,0 +1,3 @@
+import { asClassComponent } from 'svelte/legacy';
+import Root from './root.svelte';
+export default asClassComponent(Root);

.svelte-kit/generated/root.svelte

@@ -0,0 +1,66 @@
+<!-- This file is generated by @sveltejs/kit — do not edit it! -->
+<svelte:options runes={true} />
+<script>
+	import { setContext, onMount, tick } from 'svelte';
+	import { browser } from '$app/environment';
+
+	// stores
+	let { stores, page, constructors, components = [], form, data_0 = null, data_1 = null } = $props();
+
+	if (!browser) {
+		setContext('__svelte__', stores);
+	}
+
+	if (browser) {
+		$effect.pre(() => stores.page.set(page));
+	} else {
+		stores.page.set(page);
+	}
+	$effect(() => {
+		stores;page;constructors;components;form;data_0;data_1;
+		stores.page.notify();
+	});
+
+	let mounted = $state(false);
+	let navigated = $state(false);
+	let title = $state(null);
+
+	onMount(() => {
+		const unsubscribe = stores.page.subscribe(() => {
+			if (mounted) {
+				navigated = true;
+				tick().then(() => {
+					title = document.title || 'untitled page';
+				});
+			}
+		});
+
+		mounted = true;
+		return unsubscribe;
+	});
+
+	const Pyramid_1=$derived(constructors[1])
+</script>
+
+{#if constructors[1]}
+	{@const Pyramid_0 = constructors[0]}
+							<!-- svelte-ignore binding_property_non_reactive -->
+							<Pyramid_0 bind:this={components[0]} data={data_0} {form}>
+								<!-- svelte-ignore binding_property_non_reactive -->
+										<Pyramid_1 bind:this={components[1]} data={data_1} {form} />
+							</Pyramid_0>
+	
+{:else}
+	{@const Pyramid_0 = constructors[0]}
+	<!-- svelte-ignore binding_property_non_reactive -->
+	<Pyramid_0 bind:this={components[0]} data={data_0} {form} />
+	
+{/if}
+
+{#if mounted}
+	<div id="svelte-announcer" aria-live="assertive" aria-atomic="true" style="position: absolute; left: 0; top: 0; clip: rect(0 0 0 0); clip-path: inset(50%); overflow: hidden; white-space: nowrap; width: 1px; height: 1px">
+		{#if navigated}
+			{title}
+		{/if}
+	</div>
+{/if}

.svelte-kit/generated/server/internal.js

@@ -0,0 +1,48 @@
+
+import root from '../root.js';
+import { set_building, set_prerendering } from '__sveltekit/environment';
+import { set_assets } from '__sveltekit/paths';
+import { set_manifest, set_read_implementation } from '__sveltekit/server';
+import { set_private_env, set_public_env, set_safe_public_env } from '../../../node_modules/@sveltejs/kit/src/runtime/shared-server.js';
+
+export const options = {
+	app_template_contains_nonce: 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,
+	embedded: false,
+	env_public_prefix: 'PUBLIC_',
+	env_private_prefix: '',
+	hash_routing: false,
+	hooks: null, // added lazily, via `get_hooks`
+	preload_strategy: "modulepreload",
+	root,
+	service_worker: 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        <link rel=\"stylesheet\" href=\"src/style.css\"\n        " + head + "\n    </head>\n    <body id=\"background\" data-sveltekit-preload-data=\"hover\">\n        <div class=\"background\">" + body + "</div>\n    </body>\n</html>\n\n",
+		error: ({ status, message }) => "<!doctype html>\n<html lang=\"en\">\n\t<head>\n\t\t<meta charset=\"utf-8\" />\n\t\t<title>" + message + "</title>\n\n\t\t<style>\n\t\t\tbody {\n\t\t\t\t--bg: white;\n\t\t\t\t--fg: #222;\n\t\t\t\t--divider: #ccc;\n\t\t\t\tbackground: var(--bg);\n\t\t\t\tcolor: var(--fg);\n\t\t\t\tfont-family:\n\t\t\t\t\tsystem-ui,\n\t\t\t\t\t-apple-system,\n\t\t\t\t\tBlinkMacSystemFont,\n\t\t\t\t\t'Segoe UI',\n\t\t\t\t\tRoboto,\n\t\t\t\t\tOxygen,\n\t\t\t\t\tUbuntu,\n\t\t\t\t\tCantarell,\n\t\t\t\t\t'Open Sans',\n\t\t\t\t\t'Helvetica Neue',\n\t\t\t\t\tsans-serif;\n\t\t\t\tdisplay: flex;\n\t\t\t\talign-items: center;\n\t\t\t\tjustify-content: center;\n\t\t\t\theight: 100vh;\n\t\t\t\tmargin: 0;\n\t\t\t}\n\n\t\t\t.error {\n\t\t\t\tdisplay: flex;\n\t\t\t\talign-items: center;\n\t\t\t\tmax-width: 32rem;\n\t\t\t\tmargin: 0 1rem;\n\t\t\t}\n\n\t\t\t.status {\n\t\t\t\tfont-weight: 200;\n\t\t\t\tfont-size: 3rem;\n\t\t\t\tline-height: 1;\n\t\t\t\tposition: relative;\n\t\t\t\ttop: -0.05rem;\n\t\t\t}\n\n\t\t\t.message {\n\t\t\t\tborder-left: 1px solid var(--divider);\n\t\t\t\tpadding: 0 0 0 1rem;\n\t\t\t\tmargin: 0 0 0 1rem;\n\t\t\t\tmin-height: 2.5rem;\n\t\t\t\tdisplay: flex;\n\t\t\t\talign-items: center;\n\t\t\t}\n\n\t\t\t.message h1 {\n\t\t\t\tfont-weight: 400;\n\t\t\t\tfont-size: 1em;\n\t\t\t\tmargin: 0;\n\t\t\t}\n\n\t\t\t@media (prefers-color-scheme: dark) {\n\t\t\t\tbody {\n\t\t\t\t\t--bg: #222;\n\t\t\t\t\t--fg: #ddd;\n\t\t\t\t\t--divider: #666;\n\t\t\t\t}\n\t\t\t}\n\t\t</style>\n\t</head>\n\t<body>\n\t\t<div class=\"error\">\n\t\t\t<span class=\"status\">" + status + "</span>\n\t\t\t<div class=\"message\">\n\t\t\t\t<h1>" + message + "</h1>\n\t\t\t</div>\n\t\t</div>\n\t</body>\n</html>\n"
+	},
+	version_hash: "1jkp56i"
+};
+
+export async function get_hooks() {
+	let handle;
+	let handleFetch;
+	let handleError;
+	let init;
+	
+
+	let reroute;
+	let transport;
+	
+
+	return {
+		handle,
+		handleFetch,
+		handleError,
+		init,
+		reroute,
+		transport
+	};
+}
+
+export { set_assets, set_building, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation, set_safe_public_env };

.svelte-kit/non-ambient.d.ts

@@ -0,0 +1,25 @@
+
+// this file is generated — do not edit it
+
+
+declare module "svelte/elements" {
+	export interface HTMLAttributes<T> {
+		'data-sveltekit-keepfocus'?: true | '' | 'off' | undefined | null;
+		'data-sveltekit-noscroll'?: true | '' | 'off' | undefined | null;
+		'data-sveltekit-preload-code'?:
+			| true
+			| ''
+			| 'eager'
+			| 'viewport'
+			| 'hover'
+			| 'tap'
+			| 'off'
+			| undefined
+			| null;
+		'data-sveltekit-preload-data'?: true | '' | 'hover' | 'tap' | 'off' | undefined | null;
+		'data-sveltekit-reload'?: true | '' | 'off' | undefined | null;
+		'data-sveltekit-replacestate'?: true | '' | 'off' | undefined | null;
+	}
+}
+
+export {};

.svelte-kit/output/client/.vite/manifest.json

@@ -0,0 +1,115 @@
+{
+  ".svelte-kit/generated/client-optimized/app.js": {
+    "file": "_app/immutable/entry/app.BQgSTnW6.js",
+    "name": "entry/app",
+    "src": ".svelte-kit/generated/client-optimized/app.js",
+    "isEntry": true,
+    "imports": [
+      "_w9TiaPO3.js",
+      "_Dp6gZg7-.js",
+      "_Zxz7OfLJ.js",
+      "_B3yT6szo.js"
+    ],
+    "dynamicImports": [
+      ".svelte-kit/generated/client-optimized/nodes/0.js",
+      ".svelte-kit/generated/client-optimized/nodes/1.js",
+      ".svelte-kit/generated/client-optimized/nodes/2.js"
+    ]
+  },
+  ".svelte-kit/generated/client-optimized/nodes/0.js": {
+    "file": "_app/immutable/nodes/0.pSvET1Gs.js",
+    "name": "nodes/0",
+    "src": ".svelte-kit/generated/client-optimized/nodes/0.js",
+    "isEntry": true,
+    "isDynamicEntry": true,
+    "imports": [
+      "_Zxz7OfLJ.js",
+      "_w9TiaPO3.js"
+    ]
+  },
+  ".svelte-kit/generated/client-optimized/nodes/1.js": {
+    "file": "_app/immutable/nodes/1.CHdn8i-6.js",
+    "name": "nodes/1",
+    "src": ".svelte-kit/generated/client-optimized/nodes/1.js",
+    "isEntry": true,
+    "isDynamicEntry": true,
+    "imports": [
+      "_Zxz7OfLJ.js",
+      "_CZFlbmy6.js",
+      "_w9TiaPO3.js",
+      "_Dp6gZg7-.js",
+      "_BHfX2tkW.js"
+    ]
+  },
+  ".svelte-kit/generated/client-optimized/nodes/2.js": {
+    "file": "_app/immutable/nodes/2.Bd-zYXpb.js",
+    "name": "nodes/2",
+    "src": ".svelte-kit/generated/client-optimized/nodes/2.js",
+    "isEntry": true,
+    "isDynamicEntry": true,
+    "imports": [
+      "_Zxz7OfLJ.js",
+      "_CZFlbmy6.js",
+      "_w9TiaPO3.js",
+      "_CEUsAAFn.js"
+    ]
+  },
+  "_B3yT6szo.js": {
+    "file": "_app/immutable/chunks/B3yT6szo.js",
+    "name": "index-client",
+    "imports": [
+      "_w9TiaPO3.js"
+    ]
+  },
+  "_BHfX2tkW.js": {
+    "file": "_app/immutable/chunks/BHfX2tkW.js",
+    "name": "entry",
+    "imports": [
+      "_w9TiaPO3.js",
+      "_B3yT6szo.js"
+    ]
+  },
+  "_CEUsAAFn.js": {
+    "file": "_app/immutable/chunks/CEUsAAFn.js",
+    "name": "svelte-head",
+    "imports": [
+      "_w9TiaPO3.js"
+    ]
+  },
+  "_CZFlbmy6.js": {
+    "file": "_app/immutable/chunks/CZFlbmy6.js",
+    "name": "legacy",
+    "imports": [
+      "_w9TiaPO3.js"
+    ]
+  },
+  "_Dp6gZg7-.js": {
+    "file": "_app/immutable/chunks/Dp6gZg7-.js",
+    "name": "render",
+    "imports": [
+      "_w9TiaPO3.js",
+      "_CEUsAAFn.js",
+      "_Zxz7OfLJ.js"
+    ]
+  },
+  "_Zxz7OfLJ.js": {
+    "file": "_app/immutable/chunks/Zxz7OfLJ.js",
+    "name": "disclose-version",
+    "imports": [
+      "_w9TiaPO3.js"
+    ]
+  },
+  "_w9TiaPO3.js": {
+    "file": "_app/immutable/chunks/w9TiaPO3.js",
+    "name": "runtime"
+  },
+  "node_modules/@sveltejs/kit/src/runtime/client/entry.js": {
+    "file": "_app/immutable/entry/start.XpYumUTw.js",
+    "name": "entry/start",
+    "src": "node_modules/@sveltejs/kit/src/runtime/client/entry.js",
+    "isEntry": true,
+    "imports": [
+      "_BHfX2tkW.js"
+    ]
+  }
+}

.svelte-kit/output/client/_app/immutable/chunks/B3yT6szo.js

@@ -0,0 +1 @@
+import{m as t,o,u as c,p as u}from"./w9TiaPO3.js";function l(n){throw new Error("https://svelte.dev/e/lifecycle_outside_component")}function r(n){t===null&&l(),o&&t.l!==null?a(t).m.push(n):c(()=>{const e=u(n);if(typeof e=="function")return e})}function a(n){var e=n.l;return e.u??(e.u={a:[],b:[],m:[]})}export{r as o};

.svelte-kit/output/client/_app/immutable/chunks/CEUsAAFn.js

@@ -0,0 +1 @@
+import{c as _,b as o,H as f,h as a,a as c,g as d,s as i,d as s,f as r,i as u}from"./w9TiaPO3.js";let e;function g(){e=void 0}function p(h){let t=null,l=a;var n;if(a){for(t=r,e===void 0&&(e=u(document.head));e!==null&&(e.nodeType!==8||e.data!==c);)e=d(e);e===null?i(!1):e=s(d(e))}a||(n=document.head.appendChild(_()));try{o(()=>h(n),f)}finally{l&&(i(!0),e=r,s(t))}}export{p as h,g as r};

.svelte-kit/output/client/_app/immutable/chunks/CZFlbmy6.js

@@ -0,0 +1 @@
+import{e}from"./w9TiaPO3.js";e();

.svelte-kit/output/client/_app/immutable/chunks/Dp6gZg7-.js

@@ -0,0 +1 @@
+import{q as C,r as R,t as A,v as H,w as M,x as I,y as b,i as P,a as Y,g as j,z as T,s as g,d as D,A as q,f as p,B,C as $,D as z,F,G,I as J,c as K,j as W,J as Q,h as E,K as U,m as X}from"./w9TiaPO3.js";import{r as Z}from"./CEUsAAFn.js";import{b as x}from"./Zxz7OfLJ.js";const rr=["touchstart","touchmove"];function er(r){return rr.includes(r)}const tr=new Set,O=new Set;function m(r){var N;var e=this,s=e.ownerDocument,c=r.type,o=((N=r.composedPath)==null?void 0:N.call(r))||[],t=o[0]||r.target,d=0,_=r.__root;if(_){var u=o.indexOf(_);if(u!==-1&&(e===document||e===window)){r.__root=e;return}var h=o.indexOf(e);if(h===-1)return;u<=h&&(d=u)}if(t=o[d]||r.target,t!==e){C(r,"currentTarget",{configurable:!0,get(){return t||s}});var w=M,i=I;R(null),A(null);try{for(var a,n=[];t!==null;){var f=t.assignedSlot||t.parentNode||t.host||null;try{var l=t["__"+c];if(l!==void 0&&!t.disabled)if(H(l)){var[V,...k]=l;V.apply(t,[r,...k])}else l.call(t,r)}catch(y){a?n.push(y):a=y}if(r.cancelBubble||f===e||f===null)break;t=f}if(a){for(let y of n)queueMicrotask(()=>{throw y});throw a}}finally{r.__root=e,delete r.currentTarget,R(w),A(i)}}}function or(r,e){var s=e==null?"":typeof e=="object"?e+"":e;s!==(r.__t??(r.__t=r.nodeValue))&&(r.__t=s,r.nodeValue=s==null?"":s+"")}function ar(r,e){return L(r,e)}function fr(r,e){b(),e.intro=e.intro??!1;const s=e.target,c=E,o=p;try{for(var t=P(s);t&&(t.nodeType!==8||t.data!==Y);)t=j(t);if(!t)throw T;g(!0),D(t),q();const d=L(r,{...e,anchor:t});if(p===null||p.nodeType!==8||p.data!==B)throw $(),T;return g(!1),d}catch(d){if(d===T)return e.recover===!1&&z(),b(),F(s),g(!1),ar(r,e);throw d}finally{g(c),D(o),Z()}}const v=new Map;function L(r,{target:e,anchor:s,props:c={},events:o,context:t,intro:d=!0}){b();var _=new Set,u=i=>{for(var a=0;a<i.length;a++){var n=i[a];if(!_.has(n)){_.add(n);var f=er(n);e.addEventListener(n,m,{passive:f});var l=v.get(n);l===void 0?(document.addEventListener(n,m,{passive:f}),v.set(n,1)):v.set(n,l+1)}}};u(G(tr)),O.add(u);var h=void 0,w=J(()=>{var i=s??e.appendChild(K());return W(()=>{if(t){Q({});var a=X;a.c=t}o&&(c.$$events=o),E&&x(i,null),h=r(i,c)||{},E&&(I.nodes_end=p),t&&U()}),()=>{var f;for(var a of _){e.removeEventListener(a,m);var n=v.get(a);--n===0?(document.removeEventListener(a,m),v.delete(a)):v.set(a,n)}O.delete(u),i!==s&&((f=i.parentNode)==null||f.removeChild(i))}});return S.set(h,w),h}let S=new WeakMap;function dr(r,e){const s=S.get(r);return s?(S.delete(r),s(e)):Promise.resolve()}export{fr as h,ar as m,or as s,dr as u};

.svelte-kit/output/client/_app/immutable/chunks/Zxz7OfLJ.js

@@ -0,0 +1 @@
+import{c as i,i as f,x as u,a0 as v,a1 as p,h as s,f as o,A as h,d as E}from"./w9TiaPO3.js";function T(n){var t=document.createElement("template");return t.innerHTML=n,t.content}function r(n,t){var e=u;e.nodes_start===null&&(e.nodes_start=n,e.nodes_end=t)}function w(n,t){var e=(t&v)!==0,_=(t&p)!==0,a,c=!n.startsWith("<!>");return()=>{if(s)return r(o,null),o;a===void 0&&(a=T(c?n:"<!>"+n),e||(a=f(a)));var d=_?document.importNode(a,!0):a.cloneNode(!0);if(e){var m=f(d),l=d.lastChild;r(m,l)}else r(d,d);return d}}function x(n=""){if(!s){var t=i(n+"");return r(t,t),t}var e=o;return e.nodeType!==3&&(e.before(e=i()),E(e)),r(e,e),e}function M(){if(s)return r(o,null),o;var n=document.createDocumentFragment(),t=document.createComment(""),e=i();return n.append(t,e),r(t,e),n}function N(n,t){if(s){u.nodes_end=o,h();return}n!==null&&n.before(t)}const g="5";typeof window<"u"&&(window.__svelte||(window.__svelte={v:new Set})).v.add(g);export{N as a,r as b,M as c,x as d,w as t};

.svelte-kit/output/client/_app/immutable/entry/start.XpYumUTw.js

@@ -0,0 +1 @@
+import{l as o,a as r}from"../chunks/BHfX2tkW.js";export{o as load_css,r as start};

.svelte-kit/output/client/_app/immutable/nodes/0.pSvET1Gs.js

@@ -0,0 +1 @@
+import{c as s,a as f}from"../chunks/Zxz7OfLJ.js";import{b as i,E as p,j as c,n as d,k as m,h,f as l,l as u}from"../chunks/w9TiaPO3.js";function v(t,e,...a){var n=t,o=d,r;i(()=>{o!==(o=e())&&(r&&(m(r),r=null),r=c(()=>o(n,...a)))},p),h&&(n=l)}function E(t,e){var a=s(),n=u(a);v(n,()=>e.children),f(t,a)}export{E as component};

.svelte-kit/output/client/_app/immutable/nodes/1.CHdn8i-6.js

@@ -0,0 +1 @@
+import{a as b,t as k}from"../chunks/Zxz7OfLJ.js";import"../chunks/CZFlbmy6.js";import{V as x,u as i,m as $,p as y,W as l,X as v,Y as E,N as J,Z as K,J as N,l as R,_ as S,K as U,S as m,U as g,R as V}from"../chunks/w9TiaPO3.js";import{s as d}from"../chunks/Dp6gZg7-.js";import{u as W,s as X,p as s}from"../chunks/BHfX2tkW.js";function Y(n=!1){const e=$,t=e.l.u;if(!t)return;let a=()=>J(e.s);if(n){let o=0,r={};const p=K(()=>{let u=!1;const c=e.s;for(const f in c)c[f]!==r[f]&&(r[f]=c[f],u=!0);return u&&o++,o});a=()=>v(p)}t.b.length&&x(()=>{_(e,a),l(t.b)}),i(()=>{const o=y(()=>t.m.map(E));return()=>{for(const r of o)typeof r=="function"&&r()}}),t.a.length&&i(()=>{_(e,a),l(t.a)})}function _(n,e){if(n.l.s)for(const t of n.l.s)v(t);e()}const Z={get data(){return s.data},get error(){return s.error},get form(){return s.form},get params(){return s.params},get route(){return s.route},get state(){return s.state},get status(){return s.status},get url(){return s.url}};X.updated.check;const h=Z;var j=k("<h1> </h1> <p> </p>",1);function C(n,e){N(e,!1),Y();var t=j(),a=R(t),o=m(a,!0);g(a);var r=V(a,2),p=m(r,!0);g(r),S(()=>{var u;d(o,h.status),d(p,(u=h.error)==null?void 0:u.message)}),b(n,t),U()}export{C as component};

.svelte-kit/output/client/_app/version.json

@@ -0,0 +1 @@
+{"version":"1741895723022"}

.svelte-kit/output/server/.vite/manifest.json

@@ -0,0 +1,70 @@
+{
+  ".svelte-kit/generated/server/internal.js": {
+    "file": "internal.js",
+    "name": "internal",
+    "src": ".svelte-kit/generated/server/internal.js",
+    "isEntry": true,
+    "imports": [
+      "_internal.js"
+    ]
+  },
+  "_equality.js": {
+    "file": "chunks/equality.js",
+    "name": "equality"
+  },
+  "_exports.js": {
+    "file": "chunks/exports.js",
+    "name": "exports",
+    "imports": [
+      "_equality.js"
+    ]
+  },
+  "_index.js": {
+    "file": "chunks/index.js",
+    "name": "index"
+  },
+  "_internal.js": {
+    "file": "chunks/internal.js",
+    "name": "internal",
+    "imports": [
+      "_equality.js",
+      "_index.js"
+    ]
+  },
+  "node_modules/@sveltejs/kit/src/runtime/components/svelte-5/error.svelte": {
+    "file": "entries/fallbacks/error.svelte.js",
+    "name": "entries/fallbacks/error.svelte",
+    "src": "node_modules/@sveltejs/kit/src/runtime/components/svelte-5/error.svelte",
+    "isEntry": true,
+    "imports": [
+      "_index.js",
+      "_equality.js",
+      "_exports.js"
+    ]
+  },
+  "node_modules/@sveltejs/kit/src/runtime/components/svelte-5/layout.svelte": {
+    "file": "entries/fallbacks/layout.svelte.js",
+    "name": "entries/fallbacks/layout.svelte",
+    "src": "node_modules/@sveltejs/kit/src/runtime/components/svelte-5/layout.svelte",
+    "isEntry": true
+  },
+  "node_modules/@sveltejs/kit/src/runtime/server/index.js": {
+    "file": "index.js",
+    "name": "index",
+    "src": "node_modules/@sveltejs/kit/src/runtime/server/index.js",
+    "isEntry": true,
+    "imports": [
+      "_internal.js",
+      "_exports.js"
+    ]
+  },
+  "src/routes/+page.svelte": {
+    "file": "entries/pages/_page.svelte.js",
+    "name": "entries/pages/_page.svelte",
+    "src": "src/routes/+page.svelte",
+    "isEntry": true,
+    "imports": [
+      "_index.js"
+    ]
+  }
+}

.svelte-kit/output/server/chunks/equality.js

@@ -0,0 +1,27 @@
+var is_array = Array.isArray;
+var index_of = Array.prototype.indexOf;
+var array_from = Array.from;
+var define_property = Object.defineProperty;
+var get_descriptor = Object.getOwnPropertyDescriptor;
+const noop = () => {
+};
+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);
+}
+export {
+  is_array as a,
+  array_from as b,
+  safe_not_equal as c,
+  define_property as d,
+  equals as e,
+  get_descriptor as g,
+  index_of as i,
+  noop as n,
+  safe_equals as s
+};

.svelte-kit/output/server/chunks/exports.js

@@ -0,0 +1,229 @@
+import { n as noop, c as safe_not_equal } from "./equality.js";
+import "clsx";
+const internal = new URL("sveltekit-internal://");
+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;
+}
+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;
+}
+function decode_pathname(pathname) {
+  return pathname.split("%25").map(decodeURI).join("%25");
+}
+function decode_params(params) {
+  for (const key in params) {
+    params[key] = decodeURIComponent(params[key]);
+  }
+  return params;
+}
+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) => {
+            search_params_callback(param);
+            return obj[key](param);
+          };
+        }
+        callback();
+        const value = Reflect.get(obj, key);
+        return typeof value === "function" ? value.bind(obj) : value;
+      }
+    }),
+    enumerable: true,
+    configurable: true
+  });
+  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;
+}
+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"
+      );
+    }
+  });
+}
+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`);
+      }
+    });
+  }
+}
+function allow_nodejs_console_log(url) {
+  {
+    url[Symbol.for("nodejs.util.inspect.custom")] = (depth, opts, inspect) => {
+      return inspect(new URL(url), opts);
+    };
+  }
+}
+const subscriber_queue = [];
+function readable(value, start) {
+  return {
+    subscribe: writable(value, start).subscribe
+  };
+}
+function writable(value, start = noop) {
+  let stop = null;
+  const subscribers = /* @__PURE__ */ new Set();
+  function set(new_value) {
+    if (safe_not_equal(value, new_value)) {
+      value = new_value;
+      if (stop) {
+        const run_queue = !subscriber_queue.length;
+        for (const subscriber of subscribers) {
+          subscriber[1]();
+          subscriber_queue.push(subscriber, value);
+        }
+        if (run_queue) {
+          for (let i = 0; i < subscriber_queue.length; i += 2) {
+            subscriber_queue[i][0](subscriber_queue[i + 1]);
+          }
+          subscriber_queue.length = 0;
+        }
+      }
+    }
+  }
+  function update(fn) {
+    set(fn(
+      /** @type {T} */
+      value
+    ));
+  }
+  function subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) {
+      stop = start(set, update) || noop;
+    }
+    run(
+      /** @type {T} */
+      value
+    );
+    return () => {
+      subscribers.delete(subscriber);
+      if (subscribers.size === 0 && stop) {
+        stop();
+        stop = null;
+      }
+    };
+  }
+  return { set, update, subscribe };
+}
+function validator(expected) {
+  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;
+}
+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)}`;
+  }
+}
+const valid_layout_exports = /* @__PURE__ */ new Set([
+  "load",
+  "prerender",
+  "csr",
+  "ssr",
+  "trailingSlash",
+  "config"
+]);
+const valid_page_exports = /* @__PURE__ */ new Set([...valid_layout_exports, "entries"]);
+const valid_layout_server_exports = /* @__PURE__ */ new Set([...valid_layout_exports]);
+const valid_page_server_exports = /* @__PURE__ */ new Set([...valid_layout_server_exports, "actions", "entries"]);
+const valid_server_exports = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PATCH",
+  "PUT",
+  "DELETE",
+  "OPTIONS",
+  "HEAD",
+  "fallback",
+  "prerender",
+  "trailingSlash",
+  "config",
+  "entries"
+]);
+const validate_layout_exports = validator(valid_layout_exports);
+const validate_page_exports = validator(valid_page_exports);
+const validate_layout_server_exports = validator(valid_layout_server_exports);
+const validate_page_server_exports = validator(valid_page_server_exports);
+const validate_server_exports = validator(valid_server_exports);
+export {
+  decode_params as a,
+  resolve as b,
+  decode_pathname as c,
+  disable_search as d,
+  validate_layout_exports as e,
+  validate_page_server_exports as f,
+  validate_page_exports as g,
+  validate_server_exports as h,
+  make_trackable as m,
+  normalize_path as n,
+  readable as r,
+  validate_layout_server_exports as v,
+  writable as w
+};

.svelte-kit/output/server/chunks/index.js

@@ -0,0 +1,109 @@
+import "clsx";
+const HYDRATION_START = "[";
+const HYDRATION_END = "]";
+const HYDRATION_ERROR = {};
+function lifecycle_outside_component(name) {
+  {
+    throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
+  }
+}
+var current_component = null;
+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 get_or_init_context_map(name) {
+  if (current_component === null) {
+    lifecycle_outside_component();
+  }
+  return current_component.c ??= new Map(get_parent_context(current_component) || void 0);
+}
+function push(fn) {
+  current_component = { p: current_component, c: null, d: null };
+}
+function pop() {
+  var component = (
+    /** @type {Component} */
+    current_component
+  );
+  var ondestroy = component.d;
+  if (ondestroy) {
+    on_destroy.push(...ondestroy);
+  }
+  current_component = component.p;
+}
+function get_parent_context(component_context) {
+  let parent = component_context.p;
+  while (parent !== null) {
+    const context_map = parent.c;
+    if (context_map !== null) {
+      return context_map;
+    }
+    parent = parent.p;
+  }
+  return null;
+}
+const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
+const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
+let on_destroy = [];
+function render(component, options = {}) {
+  const payload = { out: "", css: /* @__PURE__ */ new Set(), head: { title: "", out: "" } };
+  const prev_on_destroy = on_destroy;
+  on_destroy = [];
+  payload.out += BLOCK_OPEN;
+  if (options.context) {
+    push();
+    current_component.c = options.context;
+  }
+  component(payload, options.props ?? {}, {}, {});
+  if (options.context) {
+    pop();
+  }
+  payload.out += BLOCK_CLOSE;
+  for (const cleanup of on_destroy) cleanup();
+  on_destroy = prev_on_destroy;
+  let head2 = payload.head.out + payload.head.title;
+  for (const { hash, code } of payload.css) {
+    head2 += `<style id="${hash}">${code}</style>`;
+  }
+  return {
+    head: head2,
+    html: payload.out,
+    body: payload.out
+  };
+}
+function head(payload, fn) {
+  const head_payload = payload.head;
+  head_payload.out += BLOCK_OPEN;
+  fn(head_payload);
+  head_payload.out += BLOCK_CLOSE;
+}
+function bind_props(props_parent, props_now) {
+  for (const key in 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;
+    }
+  }
+}
+export {
+  HYDRATION_ERROR as H,
+  HYDRATION_START as a,
+  HYDRATION_END as b,
+  pop as c,
+  bind_props as d,
+  getContext as g,
+  head as h,
+  push as p,
+  render as r,
+  setContext as s
+};

.svelte-kit/output/server/entries/fallbacks/error.svelte.js

@@ -0,0 +1,132 @@
+import "clsx";
+import { g as getContext, c as pop, p as push } from "../../chunks/index.js";
+import { n as noop } from "../../chunks/equality.js";
+import { w as writable } from "../../chunks/exports.js";
+const CONTENT_REGEX = /[&<]/g;
+function escape_html(value, is_attr) {
+  const str = String(value ?? "");
+  const pattern = 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 SNAPSHOT_KEY = "sveltekit:snapshot";
+const SCROLL_KEY = "sveltekit:scroll";
+function notifiable_store(value) {
+  const store = writable(value);
+  let ready = true;
+  function notify() {
+    ready = true;
+    store.update((val) => val);
+  }
+  function set(new_value) {
+    ready = false;
+    store.set(new_value);
+  }
+  function subscribe(run) {
+    let old_value;
+    return store.subscribe((new_value) => {
+      if (old_value === void 0 || ready && new_value !== old_value) {
+        run(old_value = new_value);
+      }
+    });
+  }
+  return { notify, set, subscribe };
+}
+function create_updated_store() {
+  const { set, subscribe } = writable(false);
+  {
+    return {
+      subscribe,
+      // eslint-disable-next-line @typescript-eslint/require-await
+      check: async () => false
+    };
+  }
+}
+let updated;
+const is_legacy = noop.toString().includes("$$") || /function \w+\(\) \{\}/.test(noop.toString());
+if (is_legacy) {
+  ({
+    data: {},
+    form: null,
+    error: null,
+    params: {},
+    route: { id: null },
+    state: {},
+    status: -1,
+    url: new URL("https://example.com")
+  });
+  updated = { current: false };
+} else {
+  updated = new class Updated {
+    current = false;
+  }();
+}
+function get(key, parse = JSON.parse) {
+  try {
+    return parse(sessionStorage[key]);
+  } catch {
+  }
+}
+get(SCROLL_KEY) ?? {};
+get(SNAPSHOT_KEY) ?? {};
+const stores = {
+  url: /* @__PURE__ */ notifiable_store({}),
+  page: /* @__PURE__ */ notifiable_store({}),
+  navigating: /* @__PURE__ */ writable(
+    /** @type {import('@sveltejs/kit').Navigation | null} */
+    null
+  ),
+  updated: /* @__PURE__ */ create_updated_store()
+};
+({
+  get current() {
+    return updated.current;
+  },
+  check: stores.updated.check
+});
+function context() {
+  return getContext("__request__");
+}
+const page$1 = {
+  get data() {
+    return context().page.data;
+  },
+  get error() {
+    return context().page.error;
+  },
+  get form() {
+    return context().page.form;
+  },
+  get params() {
+    return context().page.params;
+  },
+  get route() {
+    return context().page.route;
+  },
+  get state() {
+    return context().page.state;
+  },
+  get status() {
+    return context().page.status;
+  },
+  get url() {
+    return context().page.url;
+  }
+};
+const page = page$1;
+function Error$1($$payload, $$props) {
+  push();
+  $$payload.out += `<h1>${escape_html(page.status)}</h1> <p>${escape_html(page.error?.message)}</p>`;
+  pop();
+}
+export {
+  Error$1 as default
+};

.svelte-kit/output/server/entries/fallbacks/layout.svelte.js

@@ -0,0 +1,9 @@
+import "clsx";
+function Layout($$payload, $$props) {
+  let { children } = $$props;
+  children($$payload);
+  $$payload.out += `<!---->`;
+}
+export {
+  Layout as default
+};

.svelte-kit/output/server/internal.js

@@ -0,0 +1,13 @@
+import { i, e, l, m, n, q, f, h, k, j } from "./chunks/internal.js";
+export {
+  i as get_hooks,
+  e as options,
+  l as set_assets,
+  m as set_building,
+  n as set_manifest,
+  q as set_prerendering,
+  f as set_private_env,
+  h as set_public_env,
+  k as set_read_implementation,
+  j as set_safe_public_env
+};

.svelte-kit/output/server/manifest-full.js

@@ -0,0 +1,36 @@
+export const manifest = (() => {
+function __memo(fn) {
+	let value;
+	return () => value ??= (value = fn());
+}
+
+return {
+	appDir: "_app",
+	appPath: "_app",
+	assets: new Set(["favicon.png"]),
+	mimeTypes: {".png":"image/png"},
+	_: {
+		client: {start:"_app/immutable/entry/start.XpYumUTw.js",app:"_app/immutable/entry/app.BQgSTnW6.js",imports:["_app/immutable/entry/start.XpYumUTw.js","_app/immutable/chunks/BHfX2tkW.js","_app/immutable/chunks/w9TiaPO3.js","_app/immutable/chunks/B3yT6szo.js","_app/immutable/entry/app.BQgSTnW6.js","_app/immutable/chunks/w9TiaPO3.js","_app/immutable/chunks/Dp6gZg7-.js","_app/immutable/chunks/CEUsAAFn.js","_app/immutable/chunks/Zxz7OfLJ.js","_app/immutable/chunks/B3yT6szo.js"],stylesheets:[],fonts:[],uses_env_dynamic_public:false},
+		nodes: [
+			__memo(() => import('./nodes/0.js')),
+			__memo(() => import('./nodes/1.js')),
+			__memo(() => import('./nodes/2.js'))
+		],
+		routes: [
+			{
+				id: "/",
+				pattern: /^\/$/,
+				params: [],
+				page: { layouts: [0,], errors: [1,], leaf: 2 },
+				endpoint: null
+			}
+		],
+		prerendered_routes: new Set([]),
+		matchers: async () => {
+			
+			return {  };
+		},
+		server_assets: {}
+	}
+}
+})();

.svelte-kit/output/server/manifest.js

@@ -0,0 +1,36 @@
+export const manifest = (() => {
+function __memo(fn) {
+	let value;
+	return () => value ??= (value = fn());
+}
+
+return {
+	appDir: "_app",
+	appPath: "_app",
+	assets: new Set(["favicon.png"]),
+	mimeTypes: {".png":"image/png"},
+	_: {
+		client: {start:"_app/immutable/entry/start.XpYumUTw.js",app:"_app/immutable/entry/app.BQgSTnW6.js",imports:["_app/immutable/entry/start.XpYumUTw.js","_app/immutable/chunks/BHfX2tkW.js","_app/immutable/chunks/w9TiaPO3.js","_app/immutable/chunks/B3yT6szo.js","_app/immutable/entry/app.BQgSTnW6.js","_app/immutable/chunks/w9TiaPO3.js","_app/immutable/chunks/Dp6gZg7-.js","_app/immutable/chunks/CEUsAAFn.js","_app/immutable/chunks/Zxz7OfLJ.js","_app/immutable/chunks/B3yT6szo.js"],stylesheets:[],fonts:[],uses_env_dynamic_public:false},
+		nodes: [
+			__memo(() => import('./nodes/0.js')),
+			__memo(() => import('./nodes/1.js')),
+			__memo(() => import('./nodes/2.js'))
+		],
+		routes: [
+			{
+				id: "/",
+				pattern: /^\/$/,
+				params: [],
+				page: { layouts: [0,], errors: [1,], leaf: 2 },
+				endpoint: null
+			}
+		],
+		prerendered_routes: new Set([]),
+		matchers: async () => {
+			
+			return {  };
+		},
+		server_assets: {}
+	}
+}
+})();

.svelte-kit/output/server/nodes/0.js

@@ -0,0 +1,8 @@
+
+
+export const index = 0;
+let component_cache;
+export const component = async () => component_cache ??= (await import('../entries/fallbacks/layout.svelte.js')).default;
+export const imports = ["_app/immutable/nodes/0.pSvET1Gs.js","_app/immutable/chunks/Zxz7OfLJ.js","_app/immutable/chunks/w9TiaPO3.js"];
+export const stylesheets = [];
+export const fonts = [];

.svelte-kit/output/server/nodes/1.js

@@ -0,0 +1,8 @@
+
+
+export const index = 1;
+let component_cache;
+export const component = async () => component_cache ??= (await import('../entries/fallbacks/error.svelte.js')).default;
+export const imports = ["_app/immutable/nodes/1.CHdn8i-6.js","_app/immutable/chunks/Zxz7OfLJ.js","_app/immutable/chunks/w9TiaPO3.js","_app/immutable/chunks/CZFlbmy6.js","_app/immutable/chunks/Dp6gZg7-.js","_app/immutable/chunks/CEUsAAFn.js","_app/immutable/chunks/BHfX2tkW.js","_app/immutable/chunks/B3yT6szo.js"];
+export const stylesheets = [];
+export const fonts = [];

.svelte-kit/output/server/nodes/2.js

@@ -0,0 +1,8 @@
+
+
+export const index = 2;
+let component_cache;
+export const component = async () => component_cache ??= (await import('../entries/pages/_page.svelte.js')).default;
+export const imports = ["_app/immutable/nodes/2.Bd-zYXpb.js","_app/immutable/chunks/Zxz7OfLJ.js","_app/immutable/chunks/w9TiaPO3.js","_app/immutable/chunks/CZFlbmy6.js","_app/immutable/chunks/CEUsAAFn.js"];
+export const stylesheets = [];
+export const fonts = [];

.svelte-kit/tsconfig.json

@@ -0,0 +1,49 @@
+{
+	"compilerOptions": {
+		"paths": {
+			"$lib": [
+				"../src/lib"
+			],
+			"$lib/*": [
+				"../src/lib/*"
+			]
+		},
+		"rootDirs": [
+			"..",
+			"./types"
+		],
+		"verbatimModuleSyntax": true,
+		"isolatedModules": true,
+		"lib": [
+			"esnext",
+			"DOM",
+			"DOM.Iterable"
+		],
+		"moduleResolution": "bundler",
+		"module": "esnext",
+		"noEmit": true,
+		"target": "esnext"
+	},
+	"include": [
+		"ambient.d.ts",
+		"non-ambient.d.ts",
+		"./types/**/$types.d.ts",
+		"../vite.config.js",
+		"../vite.config.ts",
+		"../src/**/*.js",
+		"../src/**/*.ts",
+		"../src/**/*.svelte",
+		"../tests/**/*.js",
+		"../tests/**/*.ts",
+		"../tests/**/*.svelte"
+	],
+	"exclude": [
+		"../node_modules/**",
+		"../src/service-worker.js",
+		"../src/service-worker/**/*.js",
+		"../src/service-worker.ts",
+		"../src/service-worker/**/*.ts",
+		"../src/service-worker.d.ts",
+		"../src/service-worker/**/*.d.ts"
+	]
+}

.svelte-kit/types/route_meta_data.json

@@ -0,0 +1,3 @@
+{
+	"/": []
+}

.svelte-kit/types/src/routes/$types.d.ts

@@ -0,0 +1,24 @@
+import type * as Kit from '@sveltejs/kit';
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+// @ts-ignore
+type MatcherParam<M> = M extends (param : string) => param is infer U ? U extends string ? U : string : string;
+type RouteParams = {  };
+type RouteId = '/';
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
+type EnsureDefined<T> = T extends null | undefined ? {} : T;
+type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
+export type Snapshot<T = any> = Kit.Snapshot<T>;
+type PageParentData = EnsureDefined<LayoutData>;
+type LayoutRouteId = RouteId | "/" | null
+type LayoutParams = RouteParams & {  }
+type LayoutParentData = EnsureDefined<{}>;
+
+export type PageServerData = null;
+export type PageData = Expand<PageParentData>;
+export type PageProps = { data: PageData }
+export type LayoutServerData = null;
+export type LayoutData = Expand<LayoutParentData>;
+export type LayoutProps = { data: LayoutData; children: import("svelte").Snippet }

Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "site"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-axum = "0.8.8"
-markdown = "1.0.0"
-pulldown-cmark = "0.13.0"
-tokio = { version = "1.49.0", features = ["macros", "rt-multi-thread"] }
-tower-http = { version = "0.5", features = ["fs"] }
-askama = "0.14.0"
-serde_json = "1.0.149"
-serde = "1.0.228"
-typst = "0.14.2"
-typst-html = "0.14.2"
-regex = "1.12.2"

README.md

@@ -0,0 +1,38 @@
+# sv
+
+Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+## Building
+
+To create a production version of your app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

container-config.nix

@@ -1,11 +0,0 @@
-{ pkgs ? import <nixpkgs> { }
-, pkgsLinux ? import <nixpkgs> { system = "x86_64-linux"; }
-}:
-
-
-pkgs.dockerTools.buildImage {
-  name = "site";
-  config = {
-    Cmd = [ "${pkgsLinux.hello}/bin/hello" ];
-  };
-}

flake.lock

@@ -1,100 +0,0 @@
-{
-  "nodes": {
-    "fenix": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rust-analyzer-src": "rust-analyzer-src"
-      },
-      "locked": {
-        "lastModified": 1779612045,
-        "narHash": "sha256-+7lfNVnmXJDkiRYHd5NoNwYoyUcc0LcXPaIJqjO7VWM=",
-        "owner": "nix-community",
-        "repo": "fenix",
-        "rev": "d7be747f0a65af378de515fc3cee131bf99a008f",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "fenix",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1779508470,
-        "narHash": "sha256-Ap9KJX+5xHIn3bPIpfNgT6MEXdAECECwo4/rmlQD74M=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "29916453413845e54a65b8a1cf996842300cd299",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "fenix": "fenix",
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "rust-analyzer-src": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1779569060,
-        "narHash": "sha256-NSnk5D+3KEfRdbgPijs33N2RAKSG6A74SwfnynLcouo=",
-        "owner": "rust-lang",
-        "repo": "rust-analyzer",
-        "rev": "987ea33645ab1c709b1df6823038abcb2fe8973e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "rust-lang",
-        "ref": "nightly",
-        "repo": "rust-analyzer",
-        "type": "github"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,42 +0,0 @@
-{
-  description = "Rust development environment";
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-    fenix = {
-      url = "github:nix-community/fenix";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-  outputs = { self, nixpkgs, flake-utils, fenix }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = nixpkgs.legacyPackages.${system};
-        toolchain = fenix.packages.${system}.fromToolchainFile {
-          file = ./rust-toolchain.toml;
-          sha256 = "sha256-gh/xTkxKHL4eiRXzWv8KP7vfjSk61Iq48x47BEDFgfk=";
-        };
-      in
-      {
-        devShells.default = pkgs.mkShell rec {
-          nativeBuildInputs = [ pkgs.pkg-config ];
-          buildInputs = with pkgs; [
-            toolchain
-            clang
-            llvmPackages.bintools
-            typst
-          ];
-          LIBCLANG_PATH = pkgs.lib.makeLibraryPath [ pkgs.llvmPackages_latest.libclang.lib ];
-          RUSTFLAGS = (builtins.map (a: ''-L ${a}/lib'') []);
-          LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath (buildInputs ++ nativeBuildInputs);
-          BINDGEN_EXTRA_CLANG_ARGS =
-            (builtins.map (a: ''-I"${a}/include"'') [ pkgs.glibc.dev ])
-            ++ [
-              ''-I"${pkgs.llvmPackages_latest.libclang.lib}/lib/clang/${pkgs.llvmPackages_latest.libclang.version}/include"''
-              ''-I"${pkgs.glib.dev}/include/glib-2.0"''
-              ''-I${pkgs.glib.out}/lib/glib-2.0/include/''
-            ];
-        };
-      }
-    );
-}

node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

node_modules/.bin/esbuild

@@ -0,0 +1 @@
+../esbuild/bin/esbuild

node_modules/.bin/nanoid

@@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs

node_modules/.bin/rollup

@@ -0,0 +1 @@
+../rollup/dist/bin/rollup

node_modules/.bin/svelte-check

@@ -0,0 +1 @@
+../svelte-check/bin/svelte-check

node_modules/.bin/svelte-kit

@@ -0,0 +1 @@
+../@sveltejs/kit/svelte-kit.js

node_modules/.bin/tsc

@@ -0,0 +1 @@
+../typescript/bin/tsc

node_modules/.bin/tsserver

@@ -0,0 +1 @@
+../typescript/bin/tsserver

node_modules/.bin/vite

@@ -0,0 +1 @@
+../vite/bin/vite.js

node_modules/.package-lock.json

@@ -0,0 +1,812 @@
+{
+	"name": "site",
+	"version": "0.0.1",
+	"lockfileVersion": 3,
+	"requires": true,
+	"packages": {
+		"node_modules/@ampproject/remapping": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
+			"integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@jridgewell/gen-mapping": "^0.3.5",
+				"@jridgewell/trace-mapping": "^0.3.24"
+			},
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/@esbuild/linux-x64": {
+			"version": "0.25.0",
+			"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.0.tgz",
+			"integrity": "sha512-9yl91rHw/cpwMCNytUDxwj2XjFpxML0y9HAOH9pNVQDpQrBxHy01Dx+vaMu0N1CKa/RzBD2hB4u//nfc+Sd3Cw==",
+			"cpu": [
+				"x64"
+			],
+			"dev": true,
+			"license": "MIT",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/@jridgewell/gen-mapping": {
+			"version": "0.3.8",
+			"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
+			"integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/set-array": "^1.2.1",
+				"@jridgewell/sourcemap-codec": "^1.4.10",
+				"@jridgewell/trace-mapping": "^0.3.24"
+			},
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/@jridgewell/resolve-uri": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+			"integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/@jridgewell/set-array": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
+			"integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/@jridgewell/sourcemap-codec": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+			"integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@jridgewell/trace-mapping": {
+			"version": "0.3.25",
+			"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+			"integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/resolve-uri": "^3.1.0",
+				"@jridgewell/sourcemap-codec": "^1.4.14"
+			}
+		},
+		"node_modules/@polka/url": {
+			"version": "1.0.0-next.28",
+			"resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.28.tgz",
+			"integrity": "sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@rollup/rollup-linux-x64-gnu": {
+			"version": "4.32.1",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.32.1.tgz",
+			"integrity": "sha512-WQFLZ9c42ECqEjwg/GHHsouij3pzLXkFdz0UxHa/0OM12LzvX7DzedlY0SIEly2v18YZLRhCRoHZDxbBSWoGYg==",
+			"cpu": [
+				"x64"
+			],
+			"dev": true,
+			"license": "MIT",
+			"optional": true,
+			"os": [
+				"linux"
+			]
+		},
+		"node_modules/@rollup/rollup-linux-x64-musl": {
+			"version": "4.32.1",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.32.1.tgz",
+			"integrity": "sha512-BLoiyHDOWoS3uccNSADMza6V6vCNiphi94tQlVIL5de+r6r/CCQuNnerf+1g2mnk2b6edp5dk0nhdZ7aEjOBsA==",
+			"cpu": [
+				"x64"
+			],
+			"dev": true,
+			"license": "MIT",
+			"optional": true,
+			"os": [
+				"linux"
+			]
+		},
+		"node_modules/@sveltejs/adapter-auto": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/@sveltejs/adapter-auto/-/adapter-auto-4.0.0.tgz",
+			"integrity": "sha512-kmuYSQdD2AwThymQF0haQhM8rE5rhutQXG4LNbnbShwhMO4qQGnKaaTy+88DuNSuoQDi58+thpq8XpHc1+oEKQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"import-meta-resolve": "^4.1.0"
+			},
+			"peerDependencies": {
+				"@sveltejs/kit": "^2.0.0"
+			}
+		},
+		"node_modules/@sveltejs/kit": {
+			"version": "2.17.3",
+			"resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.17.3.tgz",
+			"integrity": "sha512-GcNaPDr0ti4O/TonPewkML2DG7UVXkSxPN3nPMlpmx0Rs4b2kVP4gymz98WEHlfzPXdd4uOOT1Js26DtieTNBQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/cookie": "^0.6.0",
+				"cookie": "^0.6.0",
+				"devalue": "^5.1.0",
+				"esm-env": "^1.2.2",
+				"import-meta-resolve": "^4.1.0",
+				"kleur": "^4.1.5",
+				"magic-string": "^0.30.5",
+				"mrmime": "^2.0.0",
+				"sade": "^1.8.1",
+				"set-cookie-parser": "^2.6.0",
+				"sirv": "^3.0.0"
+			},
+			"bin": {
+				"svelte-kit": "svelte-kit.js"
+			},
+			"engines": {
+				"node": ">=18.13"
+			},
+			"peerDependencies": {
+				"@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0",
+				"svelte": "^4.0.0 || ^5.0.0-next.0",
+				"vite": "^5.0.3 || ^6.0.0"
+			}
+		},
+		"node_modules/@sveltejs/vite-plugin-svelte": {
+			"version": "5.0.3",
+			"resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-5.0.3.tgz",
+			"integrity": "sha512-MCFS6CrQDu1yGwspm4qtli0e63vaPCehf6V7pIMP15AsWgMKrqDGCPFF/0kn4SP0ii4aySu4Pa62+fIRGFMjgw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@sveltejs/vite-plugin-svelte-inspector": "^4.0.1",
+				"debug": "^4.4.0",
+				"deepmerge": "^4.3.1",
+				"kleur": "^4.1.5",
+				"magic-string": "^0.30.15",
+				"vitefu": "^1.0.4"
+			},
+			"engines": {
+				"node": "^18.0.0 || ^20.0.0 || >=22"
+			},
+			"peerDependencies": {
+				"svelte": "^5.0.0",
+				"vite": "^6.0.0"
+			}
+		},
+		"node_modules/@sveltejs/vite-plugin-svelte-inspector": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte-inspector/-/vite-plugin-svelte-inspector-4.0.1.tgz",
+			"integrity": "sha512-J/Nmb2Q2y7mck2hyCX4ckVHcR5tu2J+MtBEQqpDrrgELZ2uvraQcK/ioCV61AqkdXFgriksOKIceDcQmqnGhVw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"debug": "^4.3.7"
+			},
+			"engines": {
+				"node": "^18.0.0 || ^20.0.0 || >=22"
+			},
+			"peerDependencies": {
+				"@sveltejs/vite-plugin-svelte": "^5.0.0",
+				"svelte": "^5.0.0",
+				"vite": "^6.0.0"
+			}
+		},
+		"node_modules/@types/cookie": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.6.0.tgz",
+			"integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@types/estree": {
+			"version": "1.0.6",
+			"resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
+			"integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/acorn": {
+			"version": "8.14.0",
+			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
+			"integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
+			"dev": true,
+			"license": "MIT",
+			"bin": {
+				"acorn": "bin/acorn"
+			},
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/acorn-typescript": {
+			"version": "1.4.13",
+			"resolved": "https://registry.npmjs.org/acorn-typescript/-/acorn-typescript-1.4.13.tgz",
+			"integrity": "sha512-xsc9Xv0xlVfwp2o7sQ+GCQ1PgbkdcpWdTzrwXxO3xDMTAywVS3oXVOcOHuRjAPkS4P9b+yc/qNF15460v+jp4Q==",
+			"dev": true,
+			"license": "MIT",
+			"peerDependencies": {
+				"acorn": ">=8.9.0"
+			}
+		},
+		"node_modules/aria-query": {
+			"version": "5.3.2",
+			"resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz",
+			"integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/axobject-query": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz",
+			"integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/chokidar": {
+			"version": "4.0.3",
+			"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+			"integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"readdirp": "^4.0.1"
+			},
+			"engines": {
+				"node": ">= 14.16.0"
+			},
+			"funding": {
+				"url": "https://paulmillr.com/funding/"
+			}
+		},
+		"node_modules/clsx": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+			"integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/cookie": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
+			"integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/debug": {
+			"version": "4.4.0",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+			"integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"peerDependenciesMeta": {
+				"supports-color": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/deepmerge": {
+			"version": "4.3.1",
+			"resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+			"integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/devalue": {
+			"version": "5.1.1",
+			"resolved": "https://registry.npmjs.org/devalue/-/devalue-5.1.1.tgz",
+			"integrity": "sha512-maua5KUiapvEwiEAe+XnlZ3Rh0GD+qI1J/nb9vrJc3muPXvcF/8gXYTWF76+5DAqHyDUtOIImEuo0YKE9mshVw==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/esbuild": {
+			"version": "0.25.0",
+			"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.0.tgz",
+			"integrity": "sha512-BXq5mqc8ltbaN34cDqWuYKyNhX8D/Z0J1xdtdQ8UcIIIyJyz+ZMKUt58tF3SrZ85jcfN/PZYhjR5uDQAYNVbuw==",
+			"dev": true,
+			"hasInstallScript": true,
+			"license": "MIT",
+			"bin": {
+				"esbuild": "bin/esbuild"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"optionalDependencies": {
+				"@esbuild/aix-ppc64": "0.25.0",
+				"@esbuild/android-arm": "0.25.0",
+				"@esbuild/android-arm64": "0.25.0",
+				"@esbuild/android-x64": "0.25.0",
+				"@esbuild/darwin-arm64": "0.25.0",
+				"@esbuild/darwin-x64": "0.25.0",
+				"@esbuild/freebsd-arm64": "0.25.0",
+				"@esbuild/freebsd-x64": "0.25.0",
+				"@esbuild/linux-arm": "0.25.0",
+				"@esbuild/linux-arm64": "0.25.0",
+				"@esbuild/linux-ia32": "0.25.0",
+				"@esbuild/linux-loong64": "0.25.0",
+				"@esbuild/linux-mips64el": "0.25.0",
+				"@esbuild/linux-ppc64": "0.25.0",
+				"@esbuild/linux-riscv64": "0.25.0",
+				"@esbuild/linux-s390x": "0.25.0",
+				"@esbuild/linux-x64": "0.25.0",
+				"@esbuild/netbsd-arm64": "0.25.0",
+				"@esbuild/netbsd-x64": "0.25.0",
+				"@esbuild/openbsd-arm64": "0.25.0",
+				"@esbuild/openbsd-x64": "0.25.0",
+				"@esbuild/sunos-x64": "0.25.0",
+				"@esbuild/win32-arm64": "0.25.0",
+				"@esbuild/win32-ia32": "0.25.0",
+				"@esbuild/win32-x64": "0.25.0"
+			}
+		},
+		"node_modules/esm-env": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
+			"integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/esrap": {
+			"version": "1.4.3",
+			"resolved": "https://registry.npmjs.org/esrap/-/esrap-1.4.3.tgz",
+			"integrity": "sha512-Xddc1RsoFJ4z9nR7W7BFaEPIp4UXoeQ0+077UdWLxbafMQFyU79sQJMk7kxNgRwQ9/aVgaKacCHC2pUACGwmYw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/sourcemap-codec": "^1.4.15"
+			}
+		},
+		"node_modules/fdir": {
+			"version": "6.4.3",
+			"resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.3.tgz",
+			"integrity": "sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw==",
+			"dev": true,
+			"license": "MIT",
+			"peerDependencies": {
+				"picomatch": "^3 || ^4"
+			},
+			"peerDependenciesMeta": {
+				"picomatch": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/import-meta-resolve": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-4.1.0.tgz",
+			"integrity": "sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==",
+			"dev": true,
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/is-reference": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
+			"integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.6"
+			}
+		},
+		"node_modules/kleur": {
+			"version": "4.1.5",
+			"resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",
+			"integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/locate-character": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz",
+			"integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/magic-string": {
+			"version": "0.30.17",
+			"resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+			"integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/sourcemap-codec": "^1.5.0"
+			}
+		},
+		"node_modules/mri": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
+			"integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/mrmime": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.0.tgz",
+			"integrity": "sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/ms": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+			"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/nanoid": {
+			"version": "3.3.8",
+			"resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
+			"integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
+			"dev": true,
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"bin": {
+				"nanoid": "bin/nanoid.cjs"
+			},
+			"engines": {
+				"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+			}
+		},
+		"node_modules/picocolors": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+			"integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/postcss": {
+			"version": "8.5.3",
+			"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
+			"integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
+			"dev": true,
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/postcss/"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/postcss"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"nanoid": "^3.3.8",
+				"picocolors": "^1.1.1",
+				"source-map-js": "^1.2.1"
+			},
+			"engines": {
+				"node": "^10 || ^12 || >=14"
+			}
+		},
+		"node_modules/readdirp": {
+			"version": "4.1.1",
+			"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.1.tgz",
+			"integrity": "sha512-h80JrZu/MHUZCyHu5ciuoI0+WxsCxzxJTILn6Fs8rxSnFPh+UVHYfeIxK1nVGugMqkfC4vJcBOYbkfkwYK0+gw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14.18.0"
+			},
+			"funding": {
+				"type": "individual",
+				"url": "https://paulmillr.com/funding/"
+			}
+		},
+		"node_modules/rollup": {
+			"version": "4.32.1",
+			"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.32.1.tgz",
+			"integrity": "sha512-z+aeEsOeEa3mEbS1Tjl6sAZ8NE3+AalQz1RJGj81M+fizusbdDMoEJwdJNHfaB40Scr4qNu+welOfes7maKonA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "1.0.6"
+			},
+			"bin": {
+				"rollup": "dist/bin/rollup"
+			},
+			"engines": {
+				"node": ">=18.0.0",
+				"npm": ">=8.0.0"
+			},
+			"optionalDependencies": {
+				"@rollup/rollup-android-arm-eabi": "4.32.1",
+				"@rollup/rollup-android-arm64": "4.32.1",
+				"@rollup/rollup-darwin-arm64": "4.32.1",
+				"@rollup/rollup-darwin-x64": "4.32.1",
+				"@rollup/rollup-freebsd-arm64": "4.32.1",
+				"@rollup/rollup-freebsd-x64": "4.32.1",
+				"@rollup/rollup-linux-arm-gnueabihf": "4.32.1",
+				"@rollup/rollup-linux-arm-musleabihf": "4.32.1",
+				"@rollup/rollup-linux-arm64-gnu": "4.32.1",
+				"@rollup/rollup-linux-arm64-musl": "4.32.1",
+				"@rollup/rollup-linux-loongarch64-gnu": "4.32.1",
+				"@rollup/rollup-linux-powerpc64le-gnu": "4.32.1",
+				"@rollup/rollup-linux-riscv64-gnu": "4.32.1",
+				"@rollup/rollup-linux-s390x-gnu": "4.32.1",
+				"@rollup/rollup-linux-x64-gnu": "4.32.1",
+				"@rollup/rollup-linux-x64-musl": "4.32.1",
+				"@rollup/rollup-win32-arm64-msvc": "4.32.1",
+				"@rollup/rollup-win32-ia32-msvc": "4.32.1",
+				"@rollup/rollup-win32-x64-msvc": "4.32.1",
+				"fsevents": "~2.3.2"
+			}
+		},
+		"node_modules/sade": {
+			"version": "1.8.1",
+			"resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz",
+			"integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"mri": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/set-cookie-parser": {
+			"version": "2.7.1",
+			"resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.1.tgz",
+			"integrity": "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/sirv": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.0.tgz",
+			"integrity": "sha512-BPwJGUeDaDCHihkORDchNyyTvWFhcusy1XMmhEVTQTwGeybFbp8YEmB+njbPnth1FibULBSBVwCQni25XlCUDg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@polka/url": "^1.0.0-next.24",
+				"mrmime": "^2.0.0",
+				"totalist": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/source-map-js": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+			"integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+			"dev": true,
+			"license": "BSD-3-Clause",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/svelte": {
+			"version": "5.19.6",
+			"resolved": "https://registry.npmjs.org/svelte/-/svelte-5.19.6.tgz",
+			"integrity": "sha512-6ydekB3qyqUal+UhfMjmVOjRGtxysR8vuiMhi2nwuBtPJWnctVlsGspjVFB05qmR+TXI1emuqtZt81c0XiFleA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@ampproject/remapping": "^2.3.0",
+				"@jridgewell/sourcemap-codec": "^1.5.0",
+				"@types/estree": "^1.0.5",
+				"acorn": "^8.12.1",
+				"acorn-typescript": "^1.4.13",
+				"aria-query": "^5.3.1",
+				"axobject-query": "^4.1.0",
+				"clsx": "^2.1.1",
+				"esm-env": "^1.2.1",
+				"esrap": "^1.4.3",
+				"is-reference": "^3.0.3",
+				"locate-character": "^3.0.0",
+				"magic-string": "^0.30.11",
+				"zimmerframe": "^1.1.2"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/svelte-check": {
+			"version": "4.1.4",
+			"resolved": "https://registry.npmjs.org/svelte-check/-/svelte-check-4.1.4.tgz",
+			"integrity": "sha512-v0j7yLbT29MezzaQJPEDwksybTE2Ups9rUxEXy92T06TiA0cbqcO8wAOwNUVkFW6B0hsYHA+oAX3BS8b/2oHtw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/trace-mapping": "^0.3.25",
+				"chokidar": "^4.0.1",
+				"fdir": "^6.2.0",
+				"picocolors": "^1.0.0",
+				"sade": "^1.7.4"
+			},
+			"bin": {
+				"svelte-check": "bin/svelte-check"
+			},
+			"engines": {
+				"node": ">= 18.0.0"
+			},
+			"peerDependencies": {
+				"svelte": "^4.0.0 || ^5.0.0-next.0",
+				"typescript": ">=5.0.0"
+			}
+		},
+		"node_modules/totalist": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz",
+			"integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/typescript": {
+			"version": "5.7.3",
+			"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
+			"integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"bin": {
+				"tsc": "bin/tsc",
+				"tsserver": "bin/tsserver"
+			},
+			"engines": {
+				"node": ">=14.17"
+			}
+		},
+		"node_modules/vite": {
+			"version": "6.2.0",
+			"resolved": "https://registry.npmjs.org/vite/-/vite-6.2.0.tgz",
+			"integrity": "sha512-7dPxoo+WsT/64rDcwoOjk76XHj+TqNTIvHKcuMQ1k4/SeHDaQt5GFAeLYzrimZrMpn/O6DtdI03WUjdxuPM0oQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"esbuild": "^0.25.0",
+				"postcss": "^8.5.3",
+				"rollup": "^4.30.1"
+			},
+			"bin": {
+				"vite": "bin/vite.js"
+			},
+			"engines": {
+				"node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/vitejs/vite?sponsor=1"
+			},
+			"optionalDependencies": {
+				"fsevents": "~2.3.3"
+			},
+			"peerDependencies": {
+				"@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+				"jiti": ">=1.21.0",
+				"less": "*",
+				"lightningcss": "^1.21.0",
+				"sass": "*",
+				"sass-embedded": "*",
+				"stylus": "*",
+				"sugarss": "*",
+				"terser": "^5.16.0",
+				"tsx": "^4.8.1",
+				"yaml": "^2.4.2"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				},
+				"jiti": {
+					"optional": true
+				},
+				"less": {
+					"optional": true
+				},
+				"lightningcss": {
+					"optional": true
+				},
+				"sass": {
+					"optional": true
+				},
+				"sass-embedded": {
+					"optional": true
+				},
+				"stylus": {
+					"optional": true
+				},
+				"sugarss": {
+					"optional": true
+				},
+				"terser": {
+					"optional": true
+				},
+				"tsx": {
+					"optional": true
+				},
+				"yaml": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/vitefu": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.0.5.tgz",
+			"integrity": "sha512-h4Vflt9gxODPFNGPwp4zAMZRpZR7eslzwH2c5hn5kNZ5rhnKyRJ50U+yGCdc2IRaBs8O4haIgLNGrV5CrpMsCA==",
+			"dev": true,
+			"license": "MIT",
+			"workspaces": [
+				"tests/deps/*",
+				"tests/projects/*"
+			],
+			"peerDependencies": {
+				"vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0"
+			},
+			"peerDependenciesMeta": {
+				"vite": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/zimmerframe": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.2.tgz",
+			"integrity": "sha512-rAbqEGa8ovJy4pyBxZM70hg4pE6gDgaQ0Sl9M3enG3I0d6H4XSAM3GeNGLKnsBpuijUow064sf7ww1nutC5/3w==",
+			"dev": true,
+			"license": "MIT"
+		}
+	}
+}

node_modules/.svelte2tsx-language-server-files/svelte-native-jsx.d.ts

@@ -0,0 +1,32 @@
+declare namespace svelteNative.JSX {
+
+    // Every namespace eligible for use needs to implement the following two functions
+    function mapElementTag(
+        tag: string
+    ): any;
+
+    function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+        element: Key | undefined | null, attrs: Elements[Key]
+    ): any;
+    function createElement<Elements extends IntrinsicElements, Key extends keyof Elements, T>(
+        element: Key | undefined | null, attrEnhancers: T, attrs: Elements[Key] & T
+    ): any;
+
+
+    /* svelte specific */
+    interface ElementClass {
+        $$prop_def: any;
+    }
+
+    interface ElementAttributesProperty {
+        $$prop_def: any; // specify the property name to use
+    }
+
+    // Add empty IntrinsicAttributes to prevent fallback to the one in the JSX namespace
+    interface IntrinsicAttributes {
+    }
+
+    interface IntrinsicElements {
+        [name: string]: { [name: string]: any };
+    }
+}

node_modules/.svelte2tsx-language-server-files/svelte-shims-v4.d.ts

@@ -0,0 +1,287 @@
+// Whenever a ambient declaration changes, its number should be increased
+// This way, we avoid the situation where multiple ambient versions of svelte2tsx
+// are loaded and their declarations conflict each other
+// See https://github.com/sveltejs/language-tools/issues/1059 for an example bug that stems from it
+// If you change anything in this file, think about whether or not it should be backported to svelte-shims.d.ts
+
+type AConstructorTypeOf<T, U extends any[] = any[]> = new (...args: U) => T;
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void
+} | void
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionReturnType = SvelteTransitionConfig | (() => SvelteTransitionConfig)
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteWithOptionalProps<Props, Keys extends keyof Props> = Omit<Props, Keys> & Partial<Pick<Props, Keys>>;
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAllProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SveltePropsAnyFallback<Props> = {[K in keyof Props]: Props[K] extends never ? never : Props[K] extends undefined ? any : Props[K]}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlotsAnyFallback<Slots> = {[K in keyof Slots]: {[S in keyof Slots[K]]: Slots[K][S] extends undefined ? any : Slots[K][S]}}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteRestProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlots = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteStore<T> = { subscribe: (run: (value: T) => any, invalidate?: any) => any }
+
+// Forces TypeScript to look into the type which results in a better representation of it
+// which helps for error messages and is necessary for d.ts file transformation so that
+// no ambient type references are left in the output
+/** @internal PRIVATE API, DO NOT USE */
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+/** @internal PRIVATE API, DO NOT USE */
+type KeysMatching<Obj, V> = {[K in keyof Obj]-?: Obj[K] extends V ? K : never}[keyof Obj]
+/** @internal PRIVATE API, DO NOT USE */
+declare type __sveltets_2_CustomEvents<T> = {[K in KeysMatching<T, CustomEvent>]: T[K] extends CustomEvent ? T[K]['detail']: T[K]}
+
+declare function __sveltets_2_ensureRightProps<Props>(props: Props): {};
+declare function __sveltets_2_instanceOf<T = any>(type: AConstructorTypeOf<T>): T;
+declare function __sveltets_2_allPropsType(): SvelteAllProps
+declare function __sveltets_2_restPropsType(): SvelteRestProps
+declare function __sveltets_2_slotsType<Slots, Key extends keyof Slots>(slots: Slots): Record<Key, boolean>;
+
+// Overload of the following two functions is necessary.
+// An empty array of optionalProps makes OptionalProps type any, which means we lose the prop typing.
+// optionalProps need to be first or its type cannot be infered correctly.
+
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SveltePropsAnyFallback<Props>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SveltePropsAnyFallback<Props> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+
+
+declare function __sveltets_2_with_any<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<Props & SvelteAllProps>, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+
+declare function __sveltets_2_with_any_event<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Props, events: Events & {[evt: string]: CustomEvent<any>;}, slots: Slots, exports?: Exports, bindings?: Bindings }
+
+declare function __sveltets_2_store_get<T = any>(store: SvelteStore<T>): T
+declare function __sveltets_2_store_get<Store extends SvelteStore<any> | undefined | null>(store: Store): Store extends SvelteStore<infer T> ? T : Store;
+declare function __sveltets_2_any(dummy: any): any;
+declare function __sveltets_2_invalidate<T>(getValue: () => T): T
+
+declare function __sveltets_2_mapWindowEvent<K extends keyof HTMLBodyElementEventMap>(
+    event: K
+): HTMLBodyElementEventMap[K];
+declare function __sveltets_2_mapBodyEvent<K extends keyof WindowEventMap>(
+    event: K
+): WindowEventMap[K];
+declare function __sveltets_2_mapElementEvent<K extends keyof HTMLElementEventMap>(
+    event: K
+): HTMLElementEventMap[K];
+
+declare function __sveltets_2_bubbleEventDef<Events, K extends keyof Events>(
+    events: Events, eventKey: K
+): Events[K];
+declare function __sveltets_2_bubbleEventDef(
+    events: any, eventKey: string
+): any;
+
+declare const __sveltets_2_customEvent: CustomEvent<any>;
+declare function __sveltets_2_toEventTypings<Typings>(): {[Key in keyof Typings]: CustomEvent<Typings[Key]>};
+
+declare function __sveltets_2_unionType<T1, T2>(t1: T1, t2: T2): T1 | T2;
+declare function __sveltets_2_unionType<T1, T2, T3>(t1: T1, t2: T2, t3: T3): T1 | T2 | T3;
+declare function __sveltets_2_unionType<T1, T2, T3, T4>(t1: T1, t2: T2, t3: T3, t4: T4): T1 | T2 | T3 | T4;
+declare function __sveltets_2_unionType(...types: any[]): any;
+
+declare function __sveltets_2_createSvelte2TsxComponent<Props extends {}, Events extends {}, Slots extends {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): typeof import("svelte").SvelteComponent<Props, Events, Slots>;
+
+declare function __sveltets_2_unwrapArr<T>(arr: ArrayLike<T>): T
+declare function __sveltets_2_unwrapPromiseLike<T>(promise: PromiseLike<T> | T): T
+
+// v2
+declare function __sveltets_2_createCreateSlot<Slots = Record<string, Record<string, any>>>(): <SlotName extends keyof Slots>(slotName: SlotName, attrs: Slots[SlotName]) => Record<string, any>;
+declare function __sveltets_2_createComponentAny(props: Record<string, any>): import("svelte").SvelteComponent<any, any, any>;
+
+declare function __sveltets_2_any(...dummy: any[]): any;
+declare function __sveltets_2_empty(...dummy: any[]): {};
+declare function __sveltets_2_union<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(t1:T1,t2?:T2,t3?:T3,t4?:T4,t5?:T5,t6?:T6,t7?:T7,t8?:T8,t9?:T9,t10?:T10): T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10;
+declare function __sveltets_2_nonNullable<T>(type: T): NonNullable<T>;
+
+declare function __sveltets_2_cssProp(prop: Record<string, any>): {};
+
+// @ts-ignore Svelte v3/v4 don't have this
+declare function __sveltets_2_ensureSnippet(val: ReturnType<import('svelte').Snippet> | undefined | null): any;
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+declare var __sveltets_2_AnimationMove: { from: DOMRect, to: DOMRect }
+declare function __sveltets_2_ensureAnimation(animationCall: __sveltets_2_SvelteAnimationReturnType): {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void,
+    $$_attributes?: Record<string, any>,
+} | void
+declare function __sveltets_2_ensureAction<T extends __sveltets_2_SvelteActionReturnType>(actionCall: T): T extends  {$$_attributes?: any} ? T['$$_attributes'] : {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionReturnType = __sveltets_2_SvelteTransitionConfig | (() => __sveltets_2_SvelteTransitionConfig)
+declare function __sveltets_2_ensureTransition(transitionCall: __sveltets_2_SvelteTransitionReturnType): {};
+
+// Includes undefined and null for all types as all usages also allow these
+declare function __sveltets_2_ensureType<T>(type: AConstructorTypeOf<T>, el: T | undefined | null): {};
+declare function __sveltets_2_ensureType<T1, T2>(type1: AConstructorTypeOf<T1>, type2: AConstructorTypeOf<T2>, el: T1 | T2 | undefined | null): {};
+
+// The following is necessary because there are two clashing errors that can't be solved at the same time
+// when using Svelte2TsxComponent, more precisely the event typings in
+// __sveltets_2_ensureComponent<T extends new (..) => _SvelteComponent<any,||any||<-this,any>>(type: T): T;
+// If we type it as "any", we have an error when using sth like {a: CustomEvent<any>}
+// If we type it as "{}", we have an error when using sth like {[evt: string]: CustomEvent<any>}
+// If we type it as "unknown", we get all kinds of follow up errors which we want to avoid
+// Therefore introduce two more base classes just for this case.
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT
+ */
+declare type ATypedSvelteComponent = {
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$prop_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$events_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$slot_def: any;
+
+    $on(event: string, handler: any): () => void;
+}
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT.
+ * 
+ * If you're looking for the type of a Svelte Component, use `SvelteComponent` and `ComponentType` instead:
+ *
+ * ```ts
+ * import type { ComponentType, SvelteComponent } from "svelte";
+ * let myComponentConstructor: ComponentType<SvelteComponent> = ..;
+ * ```
+ */
+declare type ConstructorOfATypedSvelteComponent = new (args: {target: any, props?: any}) => ATypedSvelteComponent
+// Usage note: Cannot properly transform generic function components to class components due to TypeScript limitations
+declare function __sveltets_2_ensureComponent<
+    T extends
+        | ConstructorOfATypedSvelteComponent
+        | (typeof import('svelte') extends { mount: any }
+              ? // @ts-ignore svelte.Component doesn't exist in Svelte 4
+                import('svelte').Component<any, any, any>
+              : never)
+        | null
+        | undefined
+>(
+    type: T
+): NonNullable<
+    T extends ConstructorOfATypedSvelteComponent
+        ? T
+        : typeof import('svelte') extends { mount: any }
+          ? // @ts-ignore svelte.Component doesn't exist in Svelte 4
+            T extends import('svelte').Component<
+                infer Props extends Record<string, any>,
+                infer Exports extends Record<string, any>,
+                infer Bindings extends string
+            >
+              ? new (
+                    options: import('svelte').ComponentConstructorOptions<Props>
+                ) => import('svelte').SvelteComponent<Props, Props['$$events'], Props['$$slots']> &
+                    Exports & { $$bindings: Bindings }
+              : never
+          : never
+>;
+
+declare function __sveltets_2_ensureArray<T extends ArrayLike<unknown> | Iterable<unknown>>(array: T): T extends ArrayLike<infer U> ? U[] : T extends Iterable<infer U> ? Iterable<U> : any[];
+
+type __sveltets_2_PropsWithChildren<Props, Slots> = Props &
+    (Slots extends { default: any }
+        // This is unfortunate because it means "accepts no props" turns into "accepts any prop"
+        // but the alternative is non-fixable type errors because of the way TypeScript index
+        // signatures work (they will always take precedence and make an impossible-to-satisfy children type).
+        ? Props extends Record<string, never>
+        ? any
+        : { children?: any }
+        : {});
+declare function __sveltets_2_runes_constructor<Props extends {}>(render: {props: Props }): import("svelte").ComponentConstructorOptions<Props>;
+
+declare function __sveltets_2_get_set_binding<T>(get: (() => T) | null | undefined, set: (t: T) => void): T;
+
+declare function __sveltets_$$bindings<Bindings extends string[]>(...bindings: Bindings): Bindings[number];
+
+declare function __sveltets_2_fn_component<
+    Props extends Record<string, any>, Exports extends Record<string, any>, Bindings extends string
+    // @ts-ignore Svelte 5 only
+>(klass: {props: Props, exports?: Exports, bindings?: Bindings }): import('svelte').Component<Props, Exports, Bindings>;
+
+interface __sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & { $$bindings?: Bindings } & Exports;
+    (internal: unknown, props: Props extends Record<string, never> ? {$$events?: Events, $$slots?: Slots} : Props & {$$events?: Events, $$slots?: Slots}): Exports & { $set?: any, $on?: any };
+    z_$$bindings?: Bindings;
+}
+
+declare function __sveltets_2_isomorphic_component<
+    Props extends Record<string, any>, Events extends Record<string, any>, Slots extends Record<string, any>, Exports extends Record<string, any>, Bindings extends string
+>(klass: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }): __sveltets_2_IsomorphicComponent<Props, Events, Slots, Exports, Bindings>;
+
+declare function __sveltets_2_isomorphic_component_slots<
+    Props extends Record<string, any>, Events extends Record<string, any>, Slots extends Record<string, any>, Exports extends Record<string, any>, Bindings extends string
+>(klass: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }): __sveltets_2_IsomorphicComponent<__sveltets_2_PropsWithChildren<Props, Slots>, Events, Slots, Exports, Bindings>;

node_modules/.vite/_svelte_metadata.json

@@ -0,0 +1 @@
+{"compilerOptions":{"css":"external","dev":true,"hmr":true},"configFile":false,"extensions":[".svelte"],"preprocess":[{"name":"vite-preprocess","style":"async ({ attributes, content, filename = '' }) => {\n\t\tconst ext = attributes.lang ? `.${attributes.lang}` : '.css';\n\t\tif (attributes.lang && !isCSSRequest(ext)) return;\n\t\tif (!cssTransform) {\n\t\t\tcssTransform = createCssTransform(style, config).then((t) => (cssTransform = t));\n\t\t}\n\t\tconst transform = await cssTransform;\n\t\tconst suffix = `${lang_sep}${ext}`;\n\t\tconst moduleId = `${filename}${suffix}`;\n\t\tconst { code, map, deps } = await transform(content, moduleId);\n\t\tremoveLangSuffix(map, suffix);\n\t\tmapToRelative(map, filename);\n\t\tconst dependencies = deps ? Array.from(deps).filter((d) => !d.endsWith(suffix)) : undefined;\n\t\treturn {\n\t\t\tcode,\n\t\t\tmap: map ?? undefined,\n\t\t\tdependencies\n\t\t};\n\t}"},{"script":"({ content, filename }) => {\n\t\tif (!filename) return;\n\n\t\tconst basename = path.basename(filename);\n\t\tif (basename.startsWith('+page.') || basename.startsWith('+layout.')) {\n\t\t\tconst match = content.match(options_regex);\n\t\t\tif (match) {\n\t\t\t\tconst fixed = basename.replace('.svelte', '(.server).js/ts');\n\n\t\t\t\tconst message =\n\t\t\t\t\t`\\n${colors.bold().red(path.relative('.', filename))}\\n` +\n\t\t\t\t\t`\\`${match[1]}\\` will be ignored — move it to ${fixed} instead. See https://svelte.dev/docs/kit/page-options for more information.`;\n\n\t\t\t\tif (!warned.has(message)) {\n\t\t\t\t\tconsole.log(message);\n\t\t\t\t\twarned.add(message);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}","markup":"({ content, filename }) => {\n\t\tif (!filename) return;\n\n\t\tconst basename = path.basename(filename);\n\t\tconst has_children =\n\t\t\tcontent.includes('<slot') || (isSvelte5Plus() && content.includes('{@render'));\n\n\t\tif (basename.startsWith('+layout.') && !has_children) {\n\t\t\tconst message =\n\t\t\t\t`\\n${colors.bold().red(path.relative('.', filename))}\\n` +\n\t\t\t\t`\\`<slot />\\`${isSvelte5Plus() ? ' or `{@render ...}` tag' : ''}` +\n\t\t\t\t' missing — inner content will not be rendered';\n\n\t\t\tif (!warned.has(message)) {\n\t\t\t\tconsole.log(message);\n\t\t\t\twarned.add(message);\n\t\t\t}\n\t\t}\n\t}"}]}

node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,148 @@
+{
+  "hash": "59b8483d",
+  "configHash": "128179c4",
+  "lockfileHash": "a4492988",
+  "browserHash": "ccebbd50",
+  "optimized": {
+    "svelte": {
+      "src": "../../svelte/src/index-client.js",
+      "file": "svelte.js",
+      "fileHash": "7e88f53b",
+      "needsInterop": false
+    },
+    "svelte/animate": {
+      "src": "../../svelte/src/animate/index.js",
+      "file": "svelte_animate.js",
+      "fileHash": "e0aef126",
+      "needsInterop": false
+    },
+    "svelte/easing": {
+      "src": "../../svelte/src/easing/index.js",
+      "file": "svelte_easing.js",
+      "fileHash": "48603420",
+      "needsInterop": false
+    },
+    "svelte/internal": {
+      "src": "../../svelte/src/internal/index.js",
+      "file": "svelte_internal.js",
+      "fileHash": "0e075b60",
+      "needsInterop": true
+    },
+    "svelte/internal/client": {
+      "src": "../../svelte/src/internal/client/index.js",
+      "file": "svelte_internal_client.js",
+      "fileHash": "7ef89f43",
+      "needsInterop": false
+    },
+    "svelte/internal/disclose-version": {
+      "src": "../../svelte/src/internal/disclose-version.js",
+      "file": "svelte_internal_disclose-version.js",
+      "fileHash": "3762321e",
+      "needsInterop": false
+    },
+    "svelte/internal/flags/legacy": {
+      "src": "../../svelte/src/internal/flags/legacy.js",
+      "file": "svelte_internal_flags_legacy.js",
+      "fileHash": "23f9f177",
+      "needsInterop": false
+    },
+    "svelte/internal/flags/tracing": {
+      "src": "../../svelte/src/internal/flags/tracing.js",
+      "file": "svelte_internal_flags_tracing.js",
+      "fileHash": "543c3929",
+      "needsInterop": false
+    },
+    "svelte/legacy": {
+      "src": "../../svelte/src/legacy/legacy-client.js",
+      "file": "svelte_legacy.js",
+      "fileHash": "fef1e3b8",
+      "needsInterop": false
+    },
+    "svelte/motion": {
+      "src": "../../svelte/src/motion/index.js",
+      "file": "svelte_motion.js",
+      "fileHash": "0eb7fefe",
+      "needsInterop": false
+    },
+    "svelte/reactivity": {
+      "src": "../../svelte/src/reactivity/index-client.js",
+      "file": "svelte_reactivity.js",
+      "fileHash": "ff2358ad",
+      "needsInterop": false
+    },
+    "svelte/reactivity/window": {
+      "src": "../../svelte/src/reactivity/window/index.js",
+      "file": "svelte_reactivity_window.js",
+      "fileHash": "9eebd751",
+      "needsInterop": false
+    },
+    "svelte/store": {
+      "src": "../../svelte/src/store/index-client.js",
+      "file": "svelte_store.js",
+      "fileHash": "3830be79",
+      "needsInterop": false
+    },
+    "svelte/transition": {
+      "src": "../../svelte/src/transition/index.js",
+      "file": "svelte_transition.js",
+      "fileHash": "451a25c5",
+      "needsInterop": false
+    },
+    "svelte/events": {
+      "src": "../../svelte/src/events/index.js",
+      "file": "svelte_events.js",
+      "fileHash": "0566e234",
+      "needsInterop": false
+    },
+    "clsx": {
+      "src": "../../clsx/dist/clsx.mjs",
+      "file": "clsx.js",
+      "fileHash": "029a0cae",
+      "needsInterop": false
+    },
+    "devalue": {
+      "src": "../../devalue/index.js",
+      "file": "devalue.js",
+      "fileHash": "af3a9384",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-RJCGZ5WE": {
+      "file": "chunk-RJCGZ5WE.js"
+    },
+    "chunk-MAVRAI4X": {
+      "file": "chunk-MAVRAI4X.js"
+    },
+    "chunk-QKODC7H5": {
+      "file": "chunk-QKODC7H5.js"
+    },
+    "chunk-7RQDXF5S": {
+      "file": "chunk-7RQDXF5S.js"
+    },
+    "chunk-YERFD2CZ": {
+      "file": "chunk-YERFD2CZ.js"
+    },
+    "chunk-X4Y3PAQF": {
+      "file": "chunk-X4Y3PAQF.js"
+    },
+    "chunk-U7P2NEEE": {
+      "file": "chunk-U7P2NEEE.js"
+    },
+    "chunk-YGTFLEU5": {
+      "file": "chunk-YGTFLEU5.js"
+    },
+    "chunk-QCBUMAKQ": {
+      "file": "chunk-QCBUMAKQ.js"
+    },
+    "chunk-X4XZK27Q": {
+      "file": "chunk-X4XZK27Q.js"
+    },
+    "chunk-RVAV4ZRS": {
+      "file": "chunk-RVAV4ZRS.js"
+    },
+    "chunk-UGBVNEQM": {
+      "file": "chunk-UGBVNEQM.js"
+    }
+  }
+}

node_modules/.vite/deps/chunk-7RQDXF5S.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/chunk-MAVRAI4X.js

@@ -0,0 +1,35 @@
+import {
+  createSubscriber
+} from "./chunk-QKODC7H5.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-UGBVNEQM.js";
+
+// node_modules/svelte/src/reactivity/reactive-value.js
+var _fn, _subscribe;
+var ReactiveValue = class {
+  /**
+   *
+   * @param {() => T} fn
+   * @param {(update: () => void) => void} onsubscribe
+   */
+  constructor(fn, onsubscribe) {
+    __privateAdd(this, _fn);
+    __privateAdd(this, _subscribe);
+    __privateSet(this, _fn, fn);
+    __privateSet(this, _subscribe, createSubscriber(onsubscribe));
+  }
+  get current() {
+    __privateGet(this, _subscribe).call(this);
+    return __privateGet(this, _fn).call(this);
+  }
+};
+_fn = new WeakMap();
+_subscribe = new WeakMap();
+
+export {
+  ReactiveValue
+};
+//# sourceMappingURL=chunk-MAVRAI4X.js.map

node_modules/.vite/deps/chunk-MAVRAI4X.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../svelte/src/reactivity/reactive-value.js"],
+  "sourcesContent": ["import { createSubscriber } from './create-subscriber.js';\n\n/**\n * @template T\n */\nexport class ReactiveValue {\n\t#fn;\n\t#subscribe;\n\n\t/**\n\t *\n\t * @param {() => T} fn\n\t * @param {(update: () => void) => void} onsubscribe\n\t */\n\tconstructor(fn, onsubscribe) {\n\t\tthis.#fn = fn;\n\t\tthis.#subscribe = createSubscriber(onsubscribe);\n\t}\n\n\tget current() {\n\t\tthis.#subscribe();\n\t\treturn this.#fn();\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;AAAA;AAKO,IAAM,gBAAN,MAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAS1B,YAAY,IAAI,aAAa;AAR7B;AACA;AAQC,uBAAK,KAAM;AACX,uBAAK,YAAa,iBAAiB,WAAW;AAAA,EAC/C;AAAA,EAEA,IAAI,UAAU;AACb,uBAAK,YAAL;AACA,WAAO,mBAAK,KAAL;AAAA,EACR;AACD;AAjBC;AACA;",
+  "names": []
+}

node_modules/.vite/deps/chunk-QKODC7H5.js

@@ -0,0 +1,47 @@
+import {
+  effect_tracking,
+  get,
+  render_effect,
+  set,
+  source,
+  tick,
+  untrack
+} from "./chunk-QCBUMAKQ.js";
+
+// node_modules/svelte/src/reactivity/utils.js
+function increment(source2) {
+  set(source2, source2.v + 1);
+}
+
+// node_modules/svelte/src/reactivity/create-subscriber.js
+function createSubscriber(start) {
+  let subscribers = 0;
+  let version = source(0);
+  let stop;
+  return () => {
+    if (effect_tracking()) {
+      get(version);
+      render_effect(() => {
+        if (subscribers === 0) {
+          stop = untrack(() => start(() => increment(version)));
+        }
+        subscribers += 1;
+        return () => {
+          tick().then(() => {
+            subscribers -= 1;
+            if (subscribers === 0) {
+              stop == null ? void 0 : stop();
+              stop = void 0;
+            }
+          });
+        };
+      });
+    }
+  };
+}
+
+export {
+  increment,
+  createSubscriber
+};
+//# sourceMappingURL=chunk-QKODC7H5.js.map

node_modules/.vite/deps/chunk-QKODC7H5.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../svelte/src/reactivity/utils.js", "../../svelte/src/reactivity/create-subscriber.js"],
+  "sourcesContent": ["/** @import { Source } from '#client' */\nimport { set } from '../internal/client/reactivity/sources.js';\n\n/** @param {Source<number>} source */\nexport function increment(source) {\n\tset(source, source.v + 1);\n}\n", "import { get, tick, untrack } from '../internal/client/runtime.js';\nimport { effect_tracking, render_effect } from '../internal/client/reactivity/effects.js';\nimport { source } from '../internal/client/reactivity/sources.js';\nimport { increment } from './utils.js';\n\n/**\n * Returns a `subscribe` function that, if called in an effect (including expressions in the template),\n * calls its `start` callback with an `update` function. Whenever `update` is called, the effect re-runs.\n *\n * If `start` returns a function, it will be called when the effect is destroyed.\n *\n * If `subscribe` is called in multiple effects, `start` will only be called once as long as the effects\n * are active, and the returned teardown function will only be called when all effects are destroyed.\n *\n * It's best understood with an example. Here's an implementation of [`MediaQuery`](https://svelte.dev/docs/svelte/svelte-reactivity#MediaQuery):\n *\n * ```js\n * import { createSubscriber } from 'svelte/reactivity';\n * import { on } from 'svelte/events';\n *\n * export class MediaQuery {\n * \t#query;\n * \t#subscribe;\n *\n * \tconstructor(query) {\n * \t\tthis.#query = window.matchMedia(`(${query})`);\n *\n * \t\tthis.#subscribe = createSubscriber((update) => {\n * \t\t\t// when the `change` event occurs, re-run any effects that read `this.current`\n * \t\t\tconst off = on(this.#query, 'change', update);\n *\n * \t\t\t// stop listening when all the effects are destroyed\n * \t\t\treturn () => off();\n * \t\t});\n * \t}\n *\n * \tget current() {\n * \t\tthis.#subscribe();\n *\n * \t\t// Return the current state of the query, whether or not we're in an effect\n * \t\treturn this.#query.matches;\n * \t}\n * }\n * ```\n * @param {(update: () => void) => (() => void) | void} start\n * @since 5.7.0\n */\nexport function createSubscriber(start) {\n\tlet subscribers = 0;\n\tlet version = source(0);\n\t/** @type {(() => void) | void} */\n\tlet stop;\n\n\treturn () => {\n\t\tif (effect_tracking()) {\n\t\t\tget(version);\n\n\t\t\trender_effect(() => {\n\t\t\t\tif (subscribers === 0) {\n\t\t\t\t\tstop = untrack(() => start(() => increment(version)));\n\t\t\t\t}\n\n\t\t\t\tsubscribers += 1;\n\n\t\t\t\treturn () => {\n\t\t\t\t\ttick().then(() => {\n\t\t\t\t\t\t// Only count down after timeout, else we would reach 0 before our own render effect reruns,\n\t\t\t\t\t\t// but reach 1 again when the tick callback of the prior teardown runs. That would mean we\n\t\t\t\t\t\t// re-subcribe unnecessarily and create a memory leak because the old subscription is never cleaned up.\n\t\t\t\t\t\tsubscribers -= 1;\n\n\t\t\t\t\t\tif (subscribers === 0) {\n\t\t\t\t\t\t\tstop?.();\n\t\t\t\t\t\t\tstop = undefined;\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t};\n\t\t\t});\n\t\t}\n\t};\n}\n"],
+  "mappings": ";;;;;;;;;;;AAIO,SAAS,UAAUA,SAAQ;AACjC,MAAIA,SAAQA,QAAO,IAAI,CAAC;AACzB;;;ACyCO,SAAS,iBAAiB,OAAO;AACvC,MAAI,cAAc;AAClB,MAAI,UAAU,OAAO,CAAC;AAEtB,MAAI;AAEJ,SAAO,MAAM;AACZ,QAAI,gBAAgB,GAAG;AACtB,UAAI,OAAO;AAEX,oBAAc,MAAM;AACnB,YAAI,gBAAgB,GAAG;AACtB,iBAAO,QAAQ,MAAM,MAAM,MAAM,UAAU,OAAO,CAAC,CAAC;AAAA,QACrD;AAEA,uBAAe;AAEf,eAAO,MAAM;AACZ,eAAK,EAAE,KAAK,MAAM;AAIjB,2BAAe;AAEf,gBAAI,gBAAgB,GAAG;AACtB;AACA,qBAAO;AAAA,YACR;AAAA,UACD,CAAC;AAAA,QACF;AAAA,MACD,CAAC;AAAA,IACF;AAAA,EACD;AACD;",
+  "names": ["source"]
+}

node_modules/.vite/deps/chunk-RJCGZ5WE.js

@@ -0,0 +1,665 @@
+import {
+  ReactiveValue
+} from "./chunk-MAVRAI4X.js";
+import {
+  increment
+} from "./chunk-QKODC7H5.js";
+import {
+  active_reaction,
+  derived,
+  get,
+  on,
+  set,
+  set_active_reaction,
+  source
+} from "./chunk-QCBUMAKQ.js";
+import {
+  true_default
+} from "./chunk-X4XZK27Q.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __superGet
+} from "./chunk-UGBVNEQM.js";
+
+// node_modules/svelte/src/reactivity/date.js
+var inited = false;
+var _time, _deriveds, _reaction, _SvelteDate_instances, init_fn;
+var _SvelteDate = class _SvelteDate extends Date {
+  /** @param {any[]} params */
+  constructor(...params) {
+    super(...params);
+    __privateAdd(this, _SvelteDate_instances);
+    __privateAdd(this, _time, source(super.getTime()));
+    /** @type {Map<keyof Date, Source<unknown>>} */
+    __privateAdd(this, _deriveds, /* @__PURE__ */ new Map());
+    __privateAdd(this, _reaction, active_reaction);
+    if (!inited) __privateMethod(this, _SvelteDate_instances, init_fn).call(this);
+  }
+};
+_time = new WeakMap();
+_deriveds = new WeakMap();
+_reaction = new WeakMap();
+_SvelteDate_instances = new WeakSet();
+init_fn = function() {
+  inited = true;
+  var proto = _SvelteDate.prototype;
+  var date_proto = Date.prototype;
+  var methods = (
+    /** @type {Array<keyof Date & string>} */
+    Object.getOwnPropertyNames(date_proto)
+  );
+  for (const method of methods) {
+    if (method.startsWith("get") || method.startsWith("to") || method === "valueOf") {
+      proto[method] = function(...args) {
+        if (args.length > 0) {
+          get(__privateGet(this, _time));
+          return date_proto[method].apply(this, args);
+        }
+        var d = __privateGet(this, _deriveds).get(method);
+        if (d === void 0) {
+          const reaction = active_reaction;
+          set_active_reaction(__privateGet(this, _reaction));
+          d = derived(() => {
+            get(__privateGet(this, _time));
+            return date_proto[method].apply(this, args);
+          });
+          __privateGet(this, _deriveds).set(method, d);
+          set_active_reaction(reaction);
+        }
+        return get(d);
+      };
+    }
+    if (method.startsWith("set")) {
+      proto[method] = function(...args) {
+        var result = date_proto[method].apply(this, args);
+        set(__privateGet(this, _time), date_proto.getTime.call(this));
+        return result;
+      };
+    }
+  }
+};
+var SvelteDate = _SvelteDate;
+
+// node_modules/svelte/src/reactivity/set.js
+var read_methods = ["forEach", "isDisjointFrom", "isSubsetOf", "isSupersetOf"];
+var set_like_methods = ["difference", "intersection", "symmetricDifference", "union"];
+var inited2 = false;
+var _sources, _version, _size, _SvelteSet_instances, init_fn2;
+var _SvelteSet = class _SvelteSet extends Set {
+  /**
+   * @param {Iterable<T> | null | undefined} [value]
+   */
+  constructor(value) {
+    super();
+    __privateAdd(this, _SvelteSet_instances);
+    /** @type {Map<T, Source<boolean>>} */
+    __privateAdd(this, _sources, /* @__PURE__ */ new Map());
+    __privateAdd(this, _version, source(0));
+    __privateAdd(this, _size, source(0));
+    if (true_default) value = new Set(value);
+    if (value) {
+      for (var element of value) {
+        super.add(element);
+      }
+      __privateGet(this, _size).v = super.size;
+    }
+    if (!inited2) __privateMethod(this, _SvelteSet_instances, init_fn2).call(this);
+  }
+  /** @param {T} value */
+  has(value) {
+    var has = super.has(value);
+    var sources = __privateGet(this, _sources);
+    var s = sources.get(value);
+    if (s === void 0) {
+      if (!has) {
+        get(__privateGet(this, _version));
+        return false;
+      }
+      s = source(true);
+      sources.set(value, s);
+    }
+    get(s);
+    return has;
+  }
+  /** @param {T} value */
+  add(value) {
+    if (!super.has(value)) {
+      super.add(value);
+      set(__privateGet(this, _size), super.size);
+      increment(__privateGet(this, _version));
+    }
+    return this;
+  }
+  /** @param {T} value */
+  delete(value) {
+    var deleted = super.delete(value);
+    var sources = __privateGet(this, _sources);
+    var s = sources.get(value);
+    if (s !== void 0) {
+      sources.delete(value);
+      set(s, false);
+    }
+    if (deleted) {
+      set(__privateGet(this, _size), super.size);
+      increment(__privateGet(this, _version));
+    }
+    return deleted;
+  }
+  clear() {
+    if (super.size === 0) {
+      return;
+    }
+    super.clear();
+    var sources = __privateGet(this, _sources);
+    for (var s of sources.values()) {
+      set(s, false);
+    }
+    sources.clear();
+    set(__privateGet(this, _size), 0);
+    increment(__privateGet(this, _version));
+  }
+  keys() {
+    return this.values();
+  }
+  values() {
+    get(__privateGet(this, _version));
+    return super.values();
+  }
+  entries() {
+    get(__privateGet(this, _version));
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    return this.keys();
+  }
+  get size() {
+    return get(__privateGet(this, _size));
+  }
+};
+_sources = new WeakMap();
+_version = new WeakMap();
+_size = new WeakMap();
+_SvelteSet_instances = new WeakSet();
+// We init as part of the first instance so that we can treeshake this class
+init_fn2 = function() {
+  inited2 = true;
+  var proto = _SvelteSet.prototype;
+  var set_proto = Set.prototype;
+  for (const method of read_methods) {
+    proto[method] = function(...v) {
+      get(__privateGet(this, _version));
+      return set_proto[method].apply(this, v);
+    };
+  }
+  for (const method of set_like_methods) {
+    proto[method] = function(...v) {
+      get(__privateGet(this, _version));
+      var set2 = (
+        /** @type {Set<T>} */
+        set_proto[method].apply(this, v)
+      );
+      return new _SvelteSet(set2);
+    };
+  }
+};
+var SvelteSet = _SvelteSet;
+
+// node_modules/svelte/src/reactivity/map.js
+var _sources2, _version2, _size2, _SvelteMap_instances, read_all_fn;
+var _SvelteMap = class _SvelteMap extends Map {
+  /**
+   * @param {Iterable<readonly [K, V]> | null | undefined} [value]
+   */
+  constructor(value) {
+    super();
+    __privateAdd(this, _SvelteMap_instances);
+    /** @type {Map<K, Source<number>>} */
+    __privateAdd(this, _sources2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _version2, source(0));
+    __privateAdd(this, _size2, source(0));
+    if (true_default) value = new Map(value);
+    if (value) {
+      for (var [key, v] of value) {
+        super.set(key, v);
+      }
+      __privateGet(this, _size2).v = super.size;
+    }
+  }
+  /** @param {K} key */
+  has(key) {
+    var sources = __privateGet(this, _sources2);
+    var s = sources.get(key);
+    if (s === void 0) {
+      var ret = super.get(key);
+      if (ret !== void 0) {
+        s = source(0);
+        sources.set(key, s);
+      } else {
+        get(__privateGet(this, _version2));
+        return false;
+      }
+    }
+    get(s);
+    return true;
+  }
+  /**
+   * @param {(value: V, key: K, map: Map<K, V>) => void} callbackfn
+   * @param {any} [this_arg]
+   */
+  forEach(callbackfn, this_arg) {
+    __privateMethod(this, _SvelteMap_instances, read_all_fn).call(this);
+    super.forEach(callbackfn, this_arg);
+  }
+  /** @param {K} key */
+  get(key) {
+    var sources = __privateGet(this, _sources2);
+    var s = sources.get(key);
+    if (s === void 0) {
+      var ret = super.get(key);
+      if (ret !== void 0) {
+        s = source(0);
+        sources.set(key, s);
+      } else {
+        get(__privateGet(this, _version2));
+        return void 0;
+      }
+    }
+    get(s);
+    return super.get(key);
+  }
+  /**
+   * @param {K} key
+   * @param {V} value
+   * */
+  set(key, value) {
+    var _a;
+    var sources = __privateGet(this, _sources2);
+    var s = sources.get(key);
+    var prev_res = super.get(key);
+    var res = super.set(key, value);
+    var version = __privateGet(this, _version2);
+    if (s === void 0) {
+      sources.set(key, source(0));
+      set(__privateGet(this, _size2), super.size);
+      increment(version);
+    } else if (prev_res !== value) {
+      increment(s);
+      var v_reactions = version.reactions === null ? null : new Set(version.reactions);
+      var needs_version_increase = v_reactions === null || !((_a = s.reactions) == null ? void 0 : _a.every(
+        (r) => (
+          /** @type {NonNullable<typeof v_reactions>} */
+          v_reactions.has(r)
+        )
+      ));
+      if (needs_version_increase) {
+        increment(version);
+      }
+    }
+    return res;
+  }
+  /** @param {K} key */
+  delete(key) {
+    var sources = __privateGet(this, _sources2);
+    var s = sources.get(key);
+    var res = super.delete(key);
+    if (s !== void 0) {
+      sources.delete(key);
+      set(__privateGet(this, _size2), super.size);
+      set(s, -1);
+      increment(__privateGet(this, _version2));
+    }
+    return res;
+  }
+  clear() {
+    if (super.size === 0) {
+      return;
+    }
+    super.clear();
+    var sources = __privateGet(this, _sources2);
+    set(__privateGet(this, _size2), 0);
+    for (var s of sources.values()) {
+      set(s, -1);
+    }
+    increment(__privateGet(this, _version2));
+    sources.clear();
+  }
+  keys() {
+    get(__privateGet(this, _version2));
+    return super.keys();
+  }
+  values() {
+    __privateMethod(this, _SvelteMap_instances, read_all_fn).call(this);
+    return super.values();
+  }
+  entries() {
+    __privateMethod(this, _SvelteMap_instances, read_all_fn).call(this);
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    get(__privateGet(this, _size2));
+    return super.size;
+  }
+};
+_sources2 = new WeakMap();
+_version2 = new WeakMap();
+_size2 = new WeakMap();
+_SvelteMap_instances = new WeakSet();
+read_all_fn = function() {
+  get(__privateGet(this, _version2));
+  var sources = __privateGet(this, _sources2);
+  if (__privateGet(this, _size2).v !== sources.size) {
+    for (var key of __superGet(_SvelteMap.prototype, this, "keys").call(this)) {
+      if (!sources.has(key)) {
+        sources.set(key, source(0));
+      }
+    }
+  }
+  for (var [, s] of __privateGet(this, _sources2)) {
+    get(s);
+  }
+};
+var SvelteMap = _SvelteMap;
+
+// node_modules/svelte/src/reactivity/url-search-params.js
+var REPLACE = Symbol();
+var _version3, _url, _updating, _SvelteURLSearchParams_instances, update_url_fn;
+var SvelteURLSearchParams = class extends URLSearchParams {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _SvelteURLSearchParams_instances);
+    __privateAdd(this, _version3, source(0));
+    __privateAdd(this, _url, get_current_url());
+    __privateAdd(this, _updating, false);
+  }
+  /**
+   * @param {URLSearchParams} params
+   */
+  [REPLACE](params) {
+    if (__privateGet(this, _updating)) return;
+    __privateSet(this, _updating, true);
+    for (const key of [...super.keys()]) {
+      super.delete(key);
+    }
+    for (const [key, value] of params) {
+      super.append(key, value);
+    }
+    increment(__privateGet(this, _version3));
+    __privateSet(this, _updating, false);
+  }
+  /**
+   * @param {string} name
+   * @param {string} value
+   * @returns {void}
+   */
+  append(name, value) {
+    super.append(name, value);
+    __privateMethod(this, _SvelteURLSearchParams_instances, update_url_fn).call(this);
+    increment(__privateGet(this, _version3));
+  }
+  /**
+   * @param {string} name
+   * @param {string=} value
+   * @returns {void}
+   */
+  delete(name, value) {
+    var has_value = super.has(name, value);
+    super.delete(name, value);
+    if (has_value) {
+      __privateMethod(this, _SvelteURLSearchParams_instances, update_url_fn).call(this);
+      increment(__privateGet(this, _version3));
+    }
+  }
+  /**
+   * @param {string} name
+   * @returns {string|null}
+   */
+  get(name) {
+    get(__privateGet(this, _version3));
+    return super.get(name);
+  }
+  /**
+   * @param {string} name
+   * @returns {string[]}
+   */
+  getAll(name) {
+    get(__privateGet(this, _version3));
+    return super.getAll(name);
+  }
+  /**
+   * @param {string} name
+   * @param {string=} value
+   * @returns {boolean}
+   */
+  has(name, value) {
+    get(__privateGet(this, _version3));
+    return super.has(name, value);
+  }
+  keys() {
+    get(__privateGet(this, _version3));
+    return super.keys();
+  }
+  /**
+   * @param {string} name
+   * @param {string} value
+   * @returns {void}
+   */
+  set(name, value) {
+    var previous = super.getAll(name).join("");
+    super.set(name, value);
+    if (previous !== super.getAll(name).join("")) {
+      __privateMethod(this, _SvelteURLSearchParams_instances, update_url_fn).call(this);
+      increment(__privateGet(this, _version3));
+    }
+  }
+  sort() {
+    super.sort();
+    __privateMethod(this, _SvelteURLSearchParams_instances, update_url_fn).call(this);
+    increment(__privateGet(this, _version3));
+  }
+  toString() {
+    get(__privateGet(this, _version3));
+    return super.toString();
+  }
+  values() {
+    get(__privateGet(this, _version3));
+    return super.values();
+  }
+  entries() {
+    get(__privateGet(this, _version3));
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    get(__privateGet(this, _version3));
+    return super.size;
+  }
+};
+_version3 = new WeakMap();
+_url = new WeakMap();
+_updating = new WeakMap();
+_SvelteURLSearchParams_instances = new WeakSet();
+update_url_fn = function() {
+  if (!__privateGet(this, _url) || __privateGet(this, _updating)) return;
+  __privateSet(this, _updating, true);
+  const search = this.toString();
+  __privateGet(this, _url).search = search && `?${search}`;
+  __privateSet(this, _updating, false);
+};
+
+// node_modules/svelte/src/reactivity/url.js
+var current_url = null;
+function get_current_url() {
+  return current_url;
+}
+var _protocol, _username, _password, _hostname, _port, _pathname, _hash, _search, _searchParams;
+var SvelteURL = class extends URL {
+  /**
+   * @param {string | URL} url
+   * @param {string | URL} [base]
+   */
+  constructor(url, base) {
+    url = new URL(url, base);
+    super(url);
+    __privateAdd(this, _protocol, source(super.protocol));
+    __privateAdd(this, _username, source(super.username));
+    __privateAdd(this, _password, source(super.password));
+    __privateAdd(this, _hostname, source(super.hostname));
+    __privateAdd(this, _port, source(super.port));
+    __privateAdd(this, _pathname, source(super.pathname));
+    __privateAdd(this, _hash, source(super.hash));
+    __privateAdd(this, _search, source(super.search));
+    __privateAdd(this, _searchParams);
+    current_url = this;
+    __privateSet(this, _searchParams, new SvelteURLSearchParams(url.searchParams));
+    current_url = null;
+  }
+  get hash() {
+    return get(__privateGet(this, _hash));
+  }
+  set hash(value) {
+    super.hash = value;
+    set(__privateGet(this, _hash), super.hash);
+  }
+  get host() {
+    get(__privateGet(this, _hostname));
+    get(__privateGet(this, _port));
+    return super.host;
+  }
+  set host(value) {
+    super.host = value;
+    set(__privateGet(this, _hostname), super.hostname);
+    set(__privateGet(this, _port), super.port);
+  }
+  get hostname() {
+    return get(__privateGet(this, _hostname));
+  }
+  set hostname(value) {
+    super.hostname = value;
+    set(__privateGet(this, _hostname), super.hostname);
+  }
+  get href() {
+    get(__privateGet(this, _protocol));
+    get(__privateGet(this, _username));
+    get(__privateGet(this, _password));
+    get(__privateGet(this, _hostname));
+    get(__privateGet(this, _port));
+    get(__privateGet(this, _pathname));
+    get(__privateGet(this, _hash));
+    get(__privateGet(this, _search));
+    return super.href;
+  }
+  set href(value) {
+    super.href = value;
+    set(__privateGet(this, _protocol), super.protocol);
+    set(__privateGet(this, _username), super.username);
+    set(__privateGet(this, _password), super.password);
+    set(__privateGet(this, _hostname), super.hostname);
+    set(__privateGet(this, _port), super.port);
+    set(__privateGet(this, _pathname), super.pathname);
+    set(__privateGet(this, _hash), super.hash);
+    set(__privateGet(this, _search), super.search);
+    __privateGet(this, _searchParams)[REPLACE](super.searchParams);
+  }
+  get password() {
+    return get(__privateGet(this, _password));
+  }
+  set password(value) {
+    super.password = value;
+    set(__privateGet(this, _password), super.password);
+  }
+  get pathname() {
+    return get(__privateGet(this, _pathname));
+  }
+  set pathname(value) {
+    super.pathname = value;
+    set(__privateGet(this, _pathname), super.pathname);
+  }
+  get port() {
+    return get(__privateGet(this, _port));
+  }
+  set port(value) {
+    super.port = value;
+    set(__privateGet(this, _port), super.port);
+  }
+  get protocol() {
+    return get(__privateGet(this, _protocol));
+  }
+  set protocol(value) {
+    super.protocol = value;
+    set(__privateGet(this, _protocol), super.protocol);
+  }
+  get search() {
+    return get(__privateGet(this, _search));
+  }
+  set search(value) {
+    super.search = value;
+    set(__privateGet(this, _search), value);
+    __privateGet(this, _searchParams)[REPLACE](super.searchParams);
+  }
+  get username() {
+    return get(__privateGet(this, _username));
+  }
+  set username(value) {
+    super.username = value;
+    set(__privateGet(this, _username), super.username);
+  }
+  get origin() {
+    get(__privateGet(this, _protocol));
+    get(__privateGet(this, _hostname));
+    get(__privateGet(this, _port));
+    return super.origin;
+  }
+  get searchParams() {
+    return __privateGet(this, _searchParams);
+  }
+  toString() {
+    return this.href;
+  }
+  toJSON() {
+    return this.href;
+  }
+};
+_protocol = new WeakMap();
+_username = new WeakMap();
+_password = new WeakMap();
+_hostname = new WeakMap();
+_port = new WeakMap();
+_pathname = new WeakMap();
+_hash = new WeakMap();
+_search = new WeakMap();
+_searchParams = new WeakMap();
+
+// node_modules/svelte/src/reactivity/media-query.js
+var parenthesis_regex = /\(.+\)/;
+var MediaQuery = class extends ReactiveValue {
+  /**
+   * @param {string} query A media query string
+   * @param {boolean} [fallback] Fallback value for the server
+   */
+  constructor(query, fallback) {
+    let final_query = parenthesis_regex.test(query) ? query : `(${query})`;
+    const q = window.matchMedia(final_query);
+    super(
+      () => q.matches,
+      (update) => on(q, "change", update)
+    );
+  }
+};
+
+export {
+  SvelteDate,
+  SvelteSet,
+  SvelteMap,
+  SvelteURLSearchParams,
+  SvelteURL,
+  MediaQuery
+};
+//# sourceMappingURL=chunk-RJCGZ5WE.js.map

node_modules/.vite/deps/chunk-RVAV4ZRS.js

@@ -0,0 +1,17 @@
+// node_modules/svelte/src/internal/flags/index.js
+var legacy_mode_flag = false;
+var tracing_mode_flag = false;
+function enable_legacy_mode_flag() {
+  legacy_mode_flag = true;
+}
+function enable_tracing_mode_flag() {
+  tracing_mode_flag = true;
+}
+
+export {
+  legacy_mode_flag,
+  tracing_mode_flag,
+  enable_legacy_mode_flag,
+  enable_tracing_mode_flag
+};
+//# sourceMappingURL=chunk-RVAV4ZRS.js.map

node_modules/.vite/deps/chunk-RVAV4ZRS.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../svelte/src/internal/flags/index.js"],
+  "sourcesContent": ["export let legacy_mode_flag = false;\nexport let tracing_mode_flag = false;\n\nexport function enable_legacy_mode_flag() {\n\tlegacy_mode_flag = true;\n}\n\nexport function enable_tracing_mode_flag() {\n\ttracing_mode_flag = true;\n}\n"],
+  "mappings": ";AAAO,IAAI,mBAAmB;AACvB,IAAI,oBAAoB;AAExB,SAAS,0BAA0B;AACzC,qBAAmB;AACpB;AAEO,SAAS,2BAA2B;AAC1C,sBAAoB;AACrB;",
+  "names": []
+}

node_modules/.vite/deps/chunk-U7P2NEEE.js

@@ -0,0 +1,21 @@
+// node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var clsx_default = clsx;
+
+export {
+  clsx,
+  clsx_default
+};
+//# sourceMappingURL=chunk-U7P2NEEE.js.map

node_modules/.vite/deps/chunk-U7P2NEEE.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../clsx/dist/clsx.mjs"],
+  "sourcesContent": ["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}export function clsx(){for(var e,t,f=0,n=\"\",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=\" \"),n+=t);return n}export default clsx;"],
+  "mappings": ";AAAA,SAAS,EAAE,GAAE;AAAC,MAAI,GAAE,GAAE,IAAE;AAAG,MAAG,YAAU,OAAO,KAAG,YAAU,OAAO,EAAE,MAAG;AAAA,WAAU,YAAU,OAAO,EAAE,KAAG,MAAM,QAAQ,CAAC,GAAE;AAAC,QAAI,IAAE,EAAE;AAAO,SAAI,IAAE,GAAE,IAAE,GAAE,IAAI,GAAE,CAAC,MAAI,IAAE,EAAE,EAAE,CAAC,CAAC,OAAK,MAAI,KAAG,MAAK,KAAG;AAAA,EAAE,MAAM,MAAI,KAAK,EAAE,GAAE,CAAC,MAAI,MAAI,KAAG,MAAK,KAAG;AAAG,SAAO;AAAC;AAAQ,SAAS,OAAM;AAAC,WAAQ,GAAE,GAAE,IAAE,GAAE,IAAE,IAAG,IAAE,UAAU,QAAO,IAAE,GAAE,IAAI,EAAC,IAAE,UAAU,CAAC,OAAK,IAAE,EAAE,CAAC,OAAK,MAAI,KAAG,MAAK,KAAG;AAAG,SAAO;AAAC;AAAC,IAAO,eAAQ;",
+  "names": []
+}

node_modules/.vite/deps/chunk-UGBVNEQM.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+
+export {
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __superGet
+};

node_modules/.vite/deps/chunk-UGBVNEQM.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/chunk-X4XZK27Q.js

@@ -0,0 +1,151 @@
+// node_modules/esm-env/true.js
+var true_default = true;
+
+// node_modules/svelte/src/internal/client/warnings.js
+var bold = "font-weight: bold";
+var normal = "font-weight: normal";
+function assignment_value_stale(property, location) {
+  if (true_default) {
+    console.warn(`%c[svelte] assignment_value_stale
+%cAssignment to \`${property}\` property (${location}) will evaluate to the right-hand side, not the value of \`${property}\` following the assignment. This may result in unexpected behaviour.
+https://svelte.dev/e/assignment_value_stale`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/assignment_value_stale`);
+  }
+}
+function binding_property_non_reactive(binding, location) {
+  if (true_default) {
+    console.warn(`%c[svelte] binding_property_non_reactive
+%c${location ? `\`${binding}\` (${location}) is binding to a non-reactive property` : `\`${binding}\` is binding to a non-reactive property`}
+https://svelte.dev/e/binding_property_non_reactive`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/binding_property_non_reactive`);
+  }
+}
+function console_log_state(method) {
+  if (true_default) {
+    console.warn(`%c[svelte] console_log_state
+%cYour \`console.${method}\` contained \`$state\` proxies. Consider using \`$inspect(...)\` or \`$state.snapshot(...)\` instead
+https://svelte.dev/e/console_log_state`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/console_log_state`);
+  }
+}
+function event_handler_invalid(handler, suggestion) {
+  if (true_default) {
+    console.warn(`%c[svelte] event_handler_invalid
+%c${handler} should be a function. Did you mean to ${suggestion}?
+https://svelte.dev/e/event_handler_invalid`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/event_handler_invalid`);
+  }
+}
+function hydration_attribute_changed(attribute, html, value) {
+  if (true_default) {
+    console.warn(`%c[svelte] hydration_attribute_changed
+%cThe \`${attribute}\` attribute on \`${html}\` changed its value between server and client renders. The client value, \`${value}\`, will be ignored in favour of the server value
+https://svelte.dev/e/hydration_attribute_changed`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/hydration_attribute_changed`);
+  }
+}
+function hydration_html_changed(location) {
+  if (true_default) {
+    console.warn(`%c[svelte] hydration_html_changed
+%c${location ? `The value of an \`{@html ...}\` block ${location} changed between server and client renders. The client value will be ignored in favour of the server value` : "The value of an `{@html ...}` block changed between server and client renders. The client value will be ignored in favour of the server value"}
+https://svelte.dev/e/hydration_html_changed`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/hydration_html_changed`);
+  }
+}
+function hydration_mismatch(location) {
+  if (true_default) {
+    console.warn(`%c[svelte] hydration_mismatch
+%c${location ? `Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near ${location}` : "Hydration failed because the initial UI does not match what was rendered on the server"}
+https://svelte.dev/e/hydration_mismatch`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/hydration_mismatch`);
+  }
+}
+function invalid_raw_snippet_render() {
+  if (true_default) {
+    console.warn(`%c[svelte] invalid_raw_snippet_render
+%cThe \`render\` function passed to \`createRawSnippet\` should return HTML for a single element
+https://svelte.dev/e/invalid_raw_snippet_render`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/invalid_raw_snippet_render`);
+  }
+}
+function legacy_recursive_reactive_block(filename) {
+  if (true_default) {
+    console.warn(`%c[svelte] legacy_recursive_reactive_block
+%cDetected a migrated \`$:\` reactive block in \`${filename}\` that both accesses and updates the same reactive value. This may cause recursive updates when converted to an \`$effect\`.
+https://svelte.dev/e/legacy_recursive_reactive_block`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/legacy_recursive_reactive_block`);
+  }
+}
+function lifecycle_double_unmount() {
+  if (true_default) {
+    console.warn(`%c[svelte] lifecycle_double_unmount
+%cTried to unmount a component that was not mounted
+https://svelte.dev/e/lifecycle_double_unmount`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/lifecycle_double_unmount`);
+  }
+}
+function ownership_invalid_binding(parent, child, owner) {
+  if (true_default) {
+    console.warn(`%c[svelte] ownership_invalid_binding
+%c${parent} passed a value to ${child} with \`bind:\`, but the value is owned by ${owner}. Consider creating a binding between ${owner} and ${parent}
+https://svelte.dev/e/ownership_invalid_binding`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/ownership_invalid_binding`);
+  }
+}
+function ownership_invalid_mutation(component, owner) {
+  if (true_default) {
+    console.warn(`%c[svelte] ownership_invalid_mutation
+%c${component ? `${component} mutated a value owned by ${owner}. This is strongly discouraged. Consider passing values to child components with \`bind:\`, or use a callback instead` : "Mutating a value outside the component that created it is strongly discouraged. Consider passing values to child components with `bind:`, or use a callback instead"}
+https://svelte.dev/e/ownership_invalid_mutation`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/ownership_invalid_mutation`);
+  }
+}
+function state_proxy_equality_mismatch(operator) {
+  if (true_default) {
+    console.warn(`%c[svelte] state_proxy_equality_mismatch
+%cReactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`${operator}\` will produce unexpected results
+https://svelte.dev/e/state_proxy_equality_mismatch`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/state_proxy_equality_mismatch`);
+  }
+}
+function transition_slide_display(value) {
+  if (true_default) {
+    console.warn(`%c[svelte] transition_slide_display
+%cThe \`slide\` transition does not work correctly for elements with \`display: ${value}\`
+https://svelte.dev/e/transition_slide_display`, bold, normal);
+  } else {
+    console.warn(`https://svelte.dev/e/transition_slide_display`);
+  }
+}
+
+export {
+  true_default,
+  assignment_value_stale,
+  binding_property_non_reactive,
+  console_log_state,
+  event_handler_invalid,
+  hydration_attribute_changed,
+  hydration_html_changed,
+  hydration_mismatch,
+  invalid_raw_snippet_render,
+  legacy_recursive_reactive_block,
+  lifecycle_double_unmount,
+  ownership_invalid_binding,
+  ownership_invalid_mutation,
+  state_proxy_equality_mismatch,
+  transition_slide_display
+};
+//# sourceMappingURL=chunk-X4XZK27Q.js.map

node_modules/.vite/deps/chunk-YERFD2CZ.js

@@ -0,0 +1,148 @@
+// node_modules/svelte/src/easing/index.js
+function linear(t) {
+  return t;
+}
+function backInOut(t) {
+  const s = 1.70158 * 1.525;
+  if ((t *= 2) < 1) return 0.5 * (t * t * ((s + 1) * t - s));
+  return 0.5 * ((t -= 2) * t * ((s + 1) * t + s) + 2);
+}
+function backIn(t) {
+  const s = 1.70158;
+  return t * t * ((s + 1) * t - s);
+}
+function backOut(t) {
+  const s = 1.70158;
+  return --t * t * ((s + 1) * t + s) + 1;
+}
+function bounceOut(t) {
+  const a = 4 / 11;
+  const b = 8 / 11;
+  const c = 9 / 10;
+  const ca = 4356 / 361;
+  const cb = 35442 / 1805;
+  const cc = 16061 / 1805;
+  const t2 = t * t;
+  return t < a ? 7.5625 * t2 : t < b ? 9.075 * t2 - 9.9 * t + 3.4 : t < c ? ca * t2 - cb * t + cc : 10.8 * t * t - 20.52 * t + 10.72;
+}
+function bounceInOut(t) {
+  return t < 0.5 ? 0.5 * (1 - bounceOut(1 - t * 2)) : 0.5 * bounceOut(t * 2 - 1) + 0.5;
+}
+function bounceIn(t) {
+  return 1 - bounceOut(1 - t);
+}
+function circInOut(t) {
+  if ((t *= 2) < 1) return -0.5 * (Math.sqrt(1 - t * t) - 1);
+  return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
+}
+function circIn(t) {
+  return 1 - Math.sqrt(1 - t * t);
+}
+function circOut(t) {
+  return Math.sqrt(1 - --t * t);
+}
+function cubicInOut(t) {
+  return t < 0.5 ? 4 * t * t * t : 0.5 * Math.pow(2 * t - 2, 3) + 1;
+}
+function cubicIn(t) {
+  return t * t * t;
+}
+function cubicOut(t) {
+  const f = t - 1;
+  return f * f * f + 1;
+}
+function elasticInOut(t) {
+  return t < 0.5 ? 0.5 * Math.sin(13 * Math.PI / 2 * 2 * t) * Math.pow(2, 10 * (2 * t - 1)) : 0.5 * Math.sin(-13 * Math.PI / 2 * (2 * t - 1 + 1)) * Math.pow(2, -10 * (2 * t - 1)) + 1;
+}
+function elasticIn(t) {
+  return Math.sin(13 * t * Math.PI / 2) * Math.pow(2, 10 * (t - 1));
+}
+function elasticOut(t) {
+  return Math.sin(-13 * (t + 1) * Math.PI / 2) * Math.pow(2, -10 * t) + 1;
+}
+function expoInOut(t) {
+  return t === 0 || t === 1 ? t : t < 0.5 ? 0.5 * Math.pow(2, 20 * t - 10) : -0.5 * Math.pow(2, 10 - t * 20) + 1;
+}
+function expoIn(t) {
+  return t === 0 ? t : Math.pow(2, 10 * (t - 1));
+}
+function expoOut(t) {
+  return t === 1 ? t : 1 - Math.pow(2, -10 * t);
+}
+function quadInOut(t) {
+  t /= 0.5;
+  if (t < 1) return 0.5 * t * t;
+  t--;
+  return -0.5 * (t * (t - 2) - 1);
+}
+function quadIn(t) {
+  return t * t;
+}
+function quadOut(t) {
+  return -t * (t - 2);
+}
+function quartInOut(t) {
+  return t < 0.5 ? 8 * Math.pow(t, 4) : -8 * Math.pow(t - 1, 4) + 1;
+}
+function quartIn(t) {
+  return Math.pow(t, 4);
+}
+function quartOut(t) {
+  return Math.pow(t - 1, 3) * (1 - t) + 1;
+}
+function quintInOut(t) {
+  if ((t *= 2) < 1) return 0.5 * t * t * t * t * t;
+  return 0.5 * ((t -= 2) * t * t * t * t + 2);
+}
+function quintIn(t) {
+  return t * t * t * t * t;
+}
+function quintOut(t) {
+  return --t * t * t * t * t + 1;
+}
+function sineInOut(t) {
+  return -0.5 * (Math.cos(Math.PI * t) - 1);
+}
+function sineIn(t) {
+  const v = Math.cos(t * Math.PI * 0.5);
+  if (Math.abs(v) < 1e-14) return 1;
+  else return 1 - v;
+}
+function sineOut(t) {
+  return Math.sin(t * Math.PI / 2);
+}
+
+export {
+  linear,
+  backInOut,
+  backIn,
+  backOut,
+  bounceOut,
+  bounceInOut,
+  bounceIn,
+  circInOut,
+  circIn,
+  circOut,
+  cubicInOut,
+  cubicIn,
+  cubicOut,
+  elasticInOut,
+  elasticIn,
+  elasticOut,
+  expoInOut,
+  expoIn,
+  expoOut,
+  quadInOut,
+  quadIn,
+  quadOut,
+  quartInOut,
+  quartIn,
+  quartOut,
+  quintInOut,
+  quintIn,
+  quintOut,
+  sineInOut,
+  sineIn,
+  sineOut
+};
+//# sourceMappingURL=chunk-YERFD2CZ.js.map

node_modules/.vite/deps/chunk-YGTFLEU5.js

@@ -0,0 +1,897 @@
+import {
+  DIRTY,
+  FILENAME,
+  HEAD_EFFECT,
+  HYDRATION_END,
+  HYDRATION_ERROR,
+  HYDRATION_START,
+  LEGACY_PROPS,
+  MAYBE_DIRTY,
+  TEMPLATE_FRAGMENT,
+  TEMPLATE_USE_IMPORT_NODE,
+  active_effect,
+  all_registered_events,
+  array_from,
+  block,
+  branch,
+  clear_text_content,
+  component_context,
+  component_root,
+  create_text,
+  define_property,
+  dev_current_component_function,
+  flush_sync,
+  get,
+  get_first_child,
+  get_next_sibling,
+  handle_event_propagation,
+  hydrate_next,
+  hydrate_node,
+  hydrating,
+  hydration_failed,
+  init_operations,
+  is_array,
+  lifecycle_outside_component,
+  mutable_source,
+  noop,
+  on,
+  pop,
+  push,
+  root_event_handles,
+  set,
+  set_hydrate_node,
+  set_hydrating,
+  set_signal_status,
+  user_pre_effect
+} from "./chunk-QCBUMAKQ.js";
+import {
+  hydration_mismatch,
+  legacy_recursive_reactive_block,
+  lifecycle_double_unmount,
+  true_default
+} from "./chunk-X4XZK27Q.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-UGBVNEQM.js";
+
+// node_modules/svelte/src/internal/client/dom/blocks/svelte-head.js
+var head_anchor;
+function reset_head_anchor() {
+  head_anchor = void 0;
+}
+function head(render_fn) {
+  let previous_hydrate_node = null;
+  let was_hydrating = hydrating;
+  var anchor;
+  if (hydrating) {
+    previous_hydrate_node = hydrate_node;
+    if (head_anchor === void 0) {
+      head_anchor = /** @type {TemplateNode} */
+      get_first_child(document.head);
+    }
+    while (head_anchor !== null && (head_anchor.nodeType !== 8 || /** @type {Comment} */
+    head_anchor.data !== HYDRATION_START)) {
+      head_anchor = /** @type {TemplateNode} */
+      get_next_sibling(head_anchor);
+    }
+    if (head_anchor === null) {
+      set_hydrating(false);
+    } else {
+      head_anchor = set_hydrate_node(
+        /** @type {TemplateNode} */
+        get_next_sibling(head_anchor)
+      );
+    }
+  }
+  if (!hydrating) {
+    anchor = document.head.appendChild(create_text());
+  }
+  try {
+    block(() => render_fn(anchor), HEAD_EFFECT);
+  } finally {
+    if (was_hydrating) {
+      set_hydrating(true);
+      head_anchor = hydrate_node;
+      set_hydrate_node(
+        /** @type {TemplateNode} */
+        previous_hydrate_node
+      );
+    }
+  }
+}
+
+// node_modules/svelte/src/internal/client/dom/reconciler.js
+function create_fragment_from_html(html) {
+  var elem = document.createElement("template");
+  elem.innerHTML = html;
+  return elem.content;
+}
+
+// node_modules/svelte/src/internal/client/dom/template.js
+function assign_nodes(start, end) {
+  var effect = (
+    /** @type {Effect} */
+    active_effect
+  );
+  if (effect.nodes_start === null) {
+    effect.nodes_start = start;
+    effect.nodes_end = end;
+  }
+}
+function template(content, flags) {
+  var is_fragment = (flags & TEMPLATE_FRAGMENT) !== 0;
+  var use_import_node = (flags & TEMPLATE_USE_IMPORT_NODE) !== 0;
+  var node;
+  var has_start = !content.startsWith("<!>");
+  return () => {
+    if (hydrating) {
+      assign_nodes(hydrate_node, null);
+      return hydrate_node;
+    }
+    if (node === void 0) {
+      node = create_fragment_from_html(has_start ? content : "<!>" + content);
+      if (!is_fragment) node = /** @type {Node} */
+      get_first_child(node);
+    }
+    var clone = (
+      /** @type {TemplateNode} */
+      use_import_node ? document.importNode(node, true) : node.cloneNode(true)
+    );
+    if (is_fragment) {
+      var start = (
+        /** @type {TemplateNode} */
+        get_first_child(clone)
+      );
+      var end = (
+        /** @type {TemplateNode} */
+        clone.lastChild
+      );
+      assign_nodes(start, end);
+    } else {
+      assign_nodes(clone, clone);
+    }
+    return clone;
+  };
+}
+function template_with_script(content, flags) {
+  var fn = template(content, flags);
+  return () => run_scripts(
+    /** @type {Element | DocumentFragment} */
+    fn()
+  );
+}
+function ns_template(content, flags, ns = "svg") {
+  var has_start = !content.startsWith("<!>");
+  var is_fragment = (flags & TEMPLATE_FRAGMENT) !== 0;
+  var wrapped = `<${ns}>${has_start ? content : "<!>" + content}</${ns}>`;
+  var node;
+  return () => {
+    if (hydrating) {
+      assign_nodes(hydrate_node, null);
+      return hydrate_node;
+    }
+    if (!node) {
+      var fragment = (
+        /** @type {DocumentFragment} */
+        create_fragment_from_html(wrapped)
+      );
+      var root = (
+        /** @type {Element} */
+        get_first_child(fragment)
+      );
+      if (is_fragment) {
+        node = document.createDocumentFragment();
+        while (get_first_child(root)) {
+          node.appendChild(
+            /** @type {Node} */
+            get_first_child(root)
+          );
+        }
+      } else {
+        node = /** @type {Element} */
+        get_first_child(root);
+      }
+    }
+    var clone = (
+      /** @type {TemplateNode} */
+      node.cloneNode(true)
+    );
+    if (is_fragment) {
+      var start = (
+        /** @type {TemplateNode} */
+        get_first_child(clone)
+      );
+      var end = (
+        /** @type {TemplateNode} */
+        clone.lastChild
+      );
+      assign_nodes(start, end);
+    } else {
+      assign_nodes(clone, clone);
+    }
+    return clone;
+  };
+}
+function svg_template_with_script(content, flags) {
+  var fn = ns_template(content, flags);
+  return () => run_scripts(
+    /** @type {Element | DocumentFragment} */
+    fn()
+  );
+}
+function mathml_template(content, flags) {
+  return ns_template(content, flags, "math");
+}
+function run_scripts(node) {
+  if (hydrating) return node;
+  const is_fragment = node.nodeType === 11;
+  const scripts = (
+    /** @type {HTMLElement} */
+    node.tagName === "SCRIPT" ? [
+      /** @type {HTMLScriptElement} */
+      node
+    ] : node.querySelectorAll("script")
+  );
+  const effect = (
+    /** @type {Effect} */
+    active_effect
+  );
+  for (const script of scripts) {
+    const clone = document.createElement("script");
+    for (var attribute of script.attributes) {
+      clone.setAttribute(attribute.name, attribute.value);
+    }
+    clone.textContent = script.textContent;
+    if (is_fragment ? node.firstChild === script : node === script) {
+      effect.nodes_start = clone;
+    }
+    if (is_fragment ? node.lastChild === script : node === script) {
+      effect.nodes_end = clone;
+    }
+    script.replaceWith(clone);
+  }
+  return node;
+}
+function text(value = "") {
+  if (!hydrating) {
+    var t = create_text(value + "");
+    assign_nodes(t, t);
+    return t;
+  }
+  var node = hydrate_node;
+  if (node.nodeType !== 3) {
+    node.before(node = create_text());
+    set_hydrate_node(node);
+  }
+  assign_nodes(node, node);
+  return node;
+}
+function comment() {
+  if (hydrating) {
+    assign_nodes(hydrate_node, null);
+    return hydrate_node;
+  }
+  var frag = document.createDocumentFragment();
+  var start = document.createComment("");
+  var anchor = create_text();
+  frag.append(start, anchor);
+  assign_nodes(start, anchor);
+  return frag;
+}
+function append(anchor, dom) {
+  if (hydrating) {
+    active_effect.nodes_end = hydrate_node;
+    hydrate_next();
+    return;
+  }
+  if (anchor === null) {
+    return;
+  }
+  anchor.before(
+    /** @type {Node} */
+    dom
+  );
+}
+
+// node_modules/svelte/src/utils.js
+var regex_return_characters = /\r/g;
+function hash(str) {
+  str = str.replace(regex_return_characters, "");
+  let hash2 = 5381;
+  let i = str.length;
+  while (i--) hash2 = (hash2 << 5) - hash2 ^ str.charCodeAt(i);
+  return (hash2 >>> 0).toString(36);
+}
+var VOID_ELEMENT_NAMES = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+function is_void(name) {
+  return VOID_ELEMENT_NAMES.includes(name) || name.toLowerCase() === "!doctype";
+}
+function is_capture_event(name) {
+  return name.endsWith("capture") && name !== "gotpointercapture" && name !== "lostpointercapture";
+}
+var DELEGATED_EVENTS = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function is_delegated(event_name) {
+  return DELEGATED_EVENTS.includes(event_name);
+}
+var DOM_BOOLEAN_ATTRIBUTES = [
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "indeterminate",
+  "inert",
+  "ismap",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "seamless",
+  "selected",
+  "webkitdirectory",
+  "defer",
+  "disablepictureinpicture",
+  "disableremoteplayback"
+];
+var ATTRIBUTE_ALIASES = {
+  // no `class: 'className'` because we handle that separately
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  playsinline: "playsInline",
+  readonly: "readOnly",
+  defaultvalue: "defaultValue",
+  defaultchecked: "defaultChecked",
+  srcobject: "srcObject",
+  novalidate: "noValidate",
+  allowfullscreen: "allowFullscreen",
+  disablepictureinpicture: "disablePictureInPicture",
+  disableremoteplayback: "disableRemotePlayback"
+};
+function normalize_attribute(name) {
+  name = name.toLowerCase();
+  return ATTRIBUTE_ALIASES[name] ?? name;
+}
+var DOM_PROPERTIES = [
+  ...DOM_BOOLEAN_ATTRIBUTES,
+  "formNoValidate",
+  "isMap",
+  "noModule",
+  "playsInline",
+  "readOnly",
+  "value",
+  "volume",
+  "defaultValue",
+  "defaultChecked",
+  "srcObject",
+  "noValidate",
+  "allowFullscreen",
+  "disablePictureInPicture",
+  "disableRemotePlayback"
+];
+var PASSIVE_EVENTS = ["touchstart", "touchmove"];
+function is_passive_event(name) {
+  return PASSIVE_EVENTS.includes(name);
+}
+var RAW_TEXT_ELEMENTS = (
+  /** @type {const} */
+  ["textarea", "script", "style", "title"]
+);
+function is_raw_text_element(name) {
+  return RAW_TEXT_ELEMENTS.includes(
+    /** @type {RAW_TEXT_ELEMENTS[number]} */
+    name
+  );
+}
+function sanitize_location(location) {
+  return location == null ? void 0 : location.replace(/\//g, "/​");
+}
+
+// node_modules/svelte/src/internal/client/render.js
+var should_intro = true;
+function set_should_intro(value) {
+  should_intro = value;
+}
+function set_text(text2, value) {
+  var str = value == null ? "" : typeof value === "object" ? value + "" : value;
+  if (str !== (text2.__t ?? (text2.__t = text2.nodeValue))) {
+    text2.__t = str;
+    text2.nodeValue = str == null ? "" : str + "";
+  }
+}
+function mount(component, options) {
+  return _mount(component, options);
+}
+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 = (
+      /** @type {TemplateNode} */
+      get_first_child(target)
+    );
+    while (anchor && (anchor.nodeType !== 8 || /** @type {Comment} */
+    anchor.data !== HYDRATION_START)) {
+      anchor = /** @type {TemplateNode} */
+      get_next_sibling(anchor);
+    }
+    if (!anchor) {
+      throw HYDRATION_ERROR;
+    }
+    set_hydrating(true);
+    set_hydrate_node(
+      /** @type {Comment} */
+      anchor
+    );
+    hydrate_next();
+    const instance = _mount(component, { ...options, anchor });
+    if (hydrate_node === null || hydrate_node.nodeType !== 8 || /** @type {Comment} */
+    hydrate_node.data !== HYDRATION_END) {
+      hydration_mismatch();
+      throw HYDRATION_ERROR;
+    }
+    set_hydrating(false);
+    return (
+      /**  @type {Exports} */
+      instance
+    );
+  } catch (error) {
+    if (error === HYDRATION_ERROR) {
+      if (options.recover === false) {
+        hydration_failed();
+      }
+      init_operations();
+      clear_text_content(target);
+      set_hydrating(false);
+      return mount(component, options);
+    }
+    throw error;
+  } finally {
+    set_hydrating(was_hydrating);
+    set_hydrate_node(previous_hydrate_node);
+    reset_head_anchor();
+  }
+}
+var document_listeners = /* @__PURE__ */ new Map();
+function _mount(Component, { target, anchor, props = {}, events, context, intro = true }) {
+  init_operations();
+  var registered_events = /* @__PURE__ */ new Set();
+  var event_handle = (events2) => {
+    for (var i = 0; i < events2.length; i++) {
+      var event_name = events2[i];
+      if (registered_events.has(event_name)) continue;
+      registered_events.add(event_name);
+      var passive2 = is_passive_event(event_name);
+      target.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
+      var n = document_listeners.get(event_name);
+      if (n === void 0) {
+        document.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
+        document_listeners.set(event_name, 1);
+      } else {
+        document_listeners.set(event_name, n + 1);
+      }
+    }
+  };
+  event_handle(array_from(all_registered_events));
+  root_event_handles.add(event_handle);
+  var component = void 0;
+  var unmount2 = component_root(() => {
+    var anchor_node = anchor ?? target.appendChild(create_text());
+    branch(() => {
+      if (context) {
+        push({});
+        var ctx = (
+          /** @type {ComponentContext} */
+          component_context
+        );
+        ctx.c = context;
+      }
+      if (events) {
+        props.$$events = events;
+      }
+      if (hydrating) {
+        assign_nodes(
+          /** @type {TemplateNode} */
+          anchor_node,
+          null
+        );
+      }
+      should_intro = intro;
+      component = Component(anchor_node, props) || {};
+      should_intro = true;
+      if (hydrating) {
+        active_effect.nodes_end = hydrate_node;
+      }
+      if (context) {
+        pop();
+      }
+    });
+    return () => {
+      var _a;
+      for (var event_name of registered_events) {
+        target.removeEventListener(event_name, handle_event_propagation);
+        var n = (
+          /** @type {number} */
+          document_listeners.get(event_name)
+        );
+        if (--n === 0) {
+          document.removeEventListener(event_name, handle_event_propagation);
+          document_listeners.delete(event_name);
+        } else {
+          document_listeners.set(event_name, n);
+        }
+      }
+      root_event_handles.delete(event_handle);
+      if (anchor_node !== anchor) {
+        (_a = anchor_node.parentNode) == null ? void 0 : _a.removeChild(anchor_node);
+      }
+    };
+  });
+  mounted_components.set(component, unmount2);
+  return component;
+}
+var mounted_components = /* @__PURE__ */ new WeakMap();
+function unmount(component, options) {
+  const fn = mounted_components.get(component);
+  if (fn) {
+    mounted_components.delete(component);
+    return fn(options);
+  }
+  if (true_default) {
+    lifecycle_double_unmount();
+  }
+  return Promise.resolve();
+}
+
+// node_modules/svelte/src/internal/client/dom/legacy/event-modifiers.js
+function trusted(fn) {
+  return function(...args) {
+    var event = (
+      /** @type {Event} */
+      args[0]
+    );
+    if (event.isTrusted) {
+      fn == null ? void 0 : fn.apply(this, args);
+    }
+  };
+}
+function self(fn) {
+  return function(...args) {
+    var event = (
+      /** @type {Event} */
+      args[0]
+    );
+    if (event.target === this) {
+      fn == null ? void 0 : fn.apply(this, args);
+    }
+  };
+}
+function stopPropagation(fn) {
+  return function(...args) {
+    var event = (
+      /** @type {Event} */
+      args[0]
+    );
+    event.stopPropagation();
+    return fn == null ? void 0 : fn.apply(this, args);
+  };
+}
+function once(fn) {
+  var ran = false;
+  return function(...args) {
+    if (ran) return;
+    ran = true;
+    return fn == null ? void 0 : fn.apply(this, args);
+  };
+}
+function stopImmediatePropagation(fn) {
+  return function(...args) {
+    var event = (
+      /** @type {Event} */
+      args[0]
+    );
+    event.stopImmediatePropagation();
+    return fn == null ? void 0 : fn.apply(this, args);
+  };
+}
+function preventDefault(fn) {
+  return function(...args) {
+    var event = (
+      /** @type {Event} */
+      args[0]
+    );
+    event.preventDefault();
+    return fn == null ? void 0 : fn.apply(this, args);
+  };
+}
+function passive(node, [event, handler]) {
+  user_pre_effect(() => {
+    return on(node, event, handler() ?? noop, {
+      passive: true
+    });
+  });
+}
+function nonpassive(node, [event, handler]) {
+  user_pre_effect(() => {
+    return on(node, event, handler() ?? noop, {
+      passive: false
+    });
+  });
+}
+
+// node_modules/svelte/src/legacy/legacy-client.js
+function createClassComponent(options) {
+  return new Svelte4Component(options);
+}
+function asClassComponent(component) {
+  return class extends Svelte4Component {
+    /** @param {any} options */
+    constructor(options) {
+      super({
+        component,
+        ...options
+      });
+    }
+  };
+}
+var _events, _instance;
+var Svelte4Component = class {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(options) {
+    /** @type {any} */
+    __privateAdd(this, _events);
+    /** @type {Record<string, any>} */
+    __privateAdd(this, _instance);
+    var _a;
+    var sources = /* @__PURE__ */ new Map();
+    var add_source = (key, value) => {
+      var s = mutable_source(value);
+      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);
+        }
+      }
+    );
+    __privateSet(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
+    }));
+    if (!((_a = options == null ? void 0 : options.props) == null ? void 0 : _a.$$host) || options.sync === false) {
+      flush_sync();
+    }
+    __privateSet(this, _events, props.$$events);
+    for (const key of Object.keys(__privateGet(this, _instance))) {
+      if (key === "$set" || key === "$destroy" || key === "$on") continue;
+      define_property(this, key, {
+        get() {
+          return __privateGet(this, _instance)[key];
+        },
+        /** @param {any} value */
+        set(value) {
+          __privateGet(this, _instance)[key] = value;
+        },
+        enumerable: true
+      });
+    }
+    __privateGet(this, _instance).$set = /** @param {Record<string, any>} next */
+    (next) => {
+      Object.assign(props, next);
+    };
+    __privateGet(this, _instance).$destroy = () => {
+      unmount(__privateGet(this, _instance));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(props) {
+    __privateGet(this, _instance).$set(props);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(event, callback) {
+    __privateGet(this, _events)[event] = __privateGet(this, _events)[event] || [];
+    const cb = (...args) => callback.call(this, ...args);
+    __privateGet(this, _events)[event].push(cb);
+    return () => {
+      __privateGet(this, _events)[event] = __privateGet(this, _events)[event].filter(
+        /** @param {any} fn */
+        (fn) => fn !== cb
+      );
+    };
+  }
+  $destroy() {
+    __privateGet(this, _instance).$destroy();
+  }
+};
+_events = new WeakMap();
+_instance = new WeakMap();
+function run(fn) {
+  user_pre_effect(() => {
+    var _a;
+    fn();
+    var effect = (
+      /** @type {import('#client').Effect} */
+      active_effect
+    );
+    if ((effect.f & DIRTY) !== 0) {
+      let filename = "a file (we can't know which one)";
+      if (true_default) {
+        filename = ((_a = dev_current_component_function) == null ? void 0 : _a[FILENAME]) ?? filename;
+      }
+      legacy_recursive_reactive_block(filename);
+      set_signal_status(effect, MAYBE_DIRTY);
+    }
+  });
+}
+function handlers(...handlers2) {
+  return function(event) {
+    const { stopImmediatePropagation: stopImmediatePropagation2 } = event;
+    let stopped = false;
+    event.stopImmediatePropagation = () => {
+      stopped = true;
+      stopImmediatePropagation2.call(event);
+    };
+    const errors = [];
+    for (const handler of handlers2) {
+      try {
+        handler == null ? void 0 : handler.call(this, event);
+      } catch (e) {
+        errors.push(e);
+      }
+      if (stopped) {
+        break;
+      }
+    }
+    for (let error of errors) {
+      queueMicrotask(() => {
+        throw error;
+      });
+    }
+  };
+}
+function createBubbler() {
+  const active_component_context = component_context;
+  if (active_component_context === null) {
+    lifecycle_outside_component("createBubbler");
+  }
+  return (type) => (event) => {
+    var _a;
+    const events = (
+      /** @type {Record<string, Function | Function[]>} */
+      (_a = active_component_context.s.$$events) == null ? void 0 : _a[
+        /** @type {any} */
+        type
+      ]
+    );
+    if (events) {
+      const callbacks = is_array(events) ? events.slice() : [events];
+      for (const fn of callbacks) {
+        fn.call(active_component_context.x, event);
+      }
+      return !event.defaultPrevented;
+    }
+    return true;
+  };
+}
+
+export {
+  hash,
+  is_void,
+  is_capture_event,
+  is_delegated,
+  normalize_attribute,
+  is_raw_text_element,
+  sanitize_location,
+  head,
+  create_fragment_from_html,
+  assign_nodes,
+  template,
+  template_with_script,
+  ns_template,
+  svg_template_with_script,
+  mathml_template,
+  text,
+  comment,
+  append,
+  should_intro,
+  set_should_intro,
+  set_text,
+  mount,
+  hydrate,
+  unmount,
+  trusted,
+  self,
+  stopPropagation,
+  once,
+  stopImmediatePropagation,
+  preventDefault,
+  passive,
+  nonpassive,
+  createClassComponent,
+  asClassComponent,
+  run,
+  handlers,
+  createBubbler
+};
+//# sourceMappingURL=chunk-YGTFLEU5.js.map

node_modules/.vite/deps/clsx.js

@@ -0,0 +1,9 @@
+import {
+  clsx,
+  clsx_default
+} from "./chunk-U7P2NEEE.js";
+import "./chunk-UGBVNEQM.js";
+export {
+  clsx,
+  clsx_default as default
+};

node_modules/.vite/deps/clsx.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/devalue.js

@@ -0,0 +1,698 @@
+import "./chunk-UGBVNEQM.js";
+
+// node_modules/devalue/src/utils.js
+var escaped = {
+  "<": "\\u003C",
+  "\\": "\\\\",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+var DevalueError = class extends Error {
+  /**
+   * @param {string} message
+   * @param {string[]} keys
+   */
+  constructor(message, keys) {
+    super(message);
+    this.name = "DevalueError";
+    this.path = keys.join("");
+  }
+};
+function is_primitive(thing) {
+  return Object(thing) !== thing;
+}
+var object_proto_names = Object.getOwnPropertyNames(
+  Object.prototype
+).sort().join("\0");
+function is_plain_object(thing) {
+  const proto = Object.getPrototypeOf(thing);
+  return proto === Object.prototype || proto === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
+}
+function get_type(thing) {
+  return Object.prototype.toString.call(thing).slice(8, -1);
+}
+function get_escaped_char(char) {
+  switch (char) {
+    case '"':
+      return '\\"';
+    case "<":
+      return "\\u003C";
+    case "\\":
+      return "\\\\";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "	":
+      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")}` : "";
+  }
+}
+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)}"`;
+}
+function enumerable_symbols(object) {
+  return Object.getOwnPropertySymbols(object).filter(
+    (symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable
+  );
+}
+var is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+function stringify_key(key) {
+  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+}
+
+// node_modules/devalue/src/uneval.js
+var chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
+var unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
+var 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)$/;
+function uneval(value, replacer) {
+  const counts = /* @__PURE__ */ new Map();
+  const keys = [];
+  const custom = /* @__PURE__ */ new Map();
+  function walk(thing) {
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys);
+    }
+    if (!is_primitive(thing)) {
+      if (counts.has(thing)) {
+        counts.set(thing, counts.get(thing) + 1);
+        return;
+      }
+      counts.set(thing, 1);
+      if (replacer) {
+        const str2 = replacer(thing);
+        if (typeof str2 === "string") {
+          custom.set(thing, str2);
+          return;
+        }
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "BigInt":
+        case "String":
+        case "Boolean":
+        case "Date":
+        case "RegExp":
+          return;
+        case "Array":
+          thing.forEach((value2, i) => {
+            keys.push(`[${i}]`);
+            walk(value2);
+            keys.pop();
+          });
+          break;
+        case "Set":
+          Array.from(thing).forEach(walk);
+          break;
+        case "Map":
+          for (const [key, value2] of thing) {
+            keys.push(
+              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
+            );
+            walk(value2);
+            keys.pop();
+          }
+          break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array":
+          return;
+        case "ArrayBuffer":
+          return;
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(
+              `Cannot stringify arbitrary non-POJOs`,
+              keys
+            );
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(
+              `Cannot stringify POJOs with symbolic keys`,
+              keys
+            );
+          }
+          for (const key in thing) {
+            keys.push(stringify_key(key));
+            walk(thing[key]);
+            keys.pop();
+          }
+      }
+    }
+  }
+  walk(value);
+  const names = /* @__PURE__ */ 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));
+  });
+  function stringify2(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":
+        return `Object(${stringify2(thing.valueOf())})`;
+      case "RegExp":
+        return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
+      case "Date":
+        return `new Date(${thing.getTime()})`;
+      case "Array":
+        const members = (
+          /** @type {any[]} */
+          thing.map(
+            (v, i) => i in thing ? stringify2(v) : ""
+          )
+        );
+        const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
+        return `[${members.join(",")}${tail}]`;
+      case "Set":
+      case "Map":
+        return `new ${type}([${Array.from(thing).map(stringify2).join(",")}])`;
+      case "Int8Array":
+      case "Uint8Array":
+      case "Uint8ClampedArray":
+      case "Int16Array":
+      case "Uint16Array":
+      case "Int32Array":
+      case "Uint32Array":
+      case "Float32Array":
+      case "Float64Array":
+      case "BigInt64Array":
+      case "BigUint64Array": {
+        const typedArray = thing;
+        return `new ${type}([${typedArray.toString()}])`;
+      }
+      case "ArrayBuffer": {
+        const ui8 = new Uint8Array(thing);
+        return `new Uint8Array([${ui8.toString()}]).buffer`;
+      }
+      default:
+        const obj = `{${Object.keys(thing).map((key) => `${safe_key(key)}:${stringify2(thing[key])}`).join(",")}}`;
+        const proto = Object.getPrototypeOf(thing);
+        if (proto === null) {
+          return Object.keys(thing).length > 0 ? `Object.assign(Object.create(null),${obj})` : `Object.create(null)`;
+        }
+        return obj;
+    }
+  }
+  const str = stringify2(value);
+  if (names.size) {
+    const params = [];
+    const statements = [];
+    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":
+          values.push(`Object(${stringify2(thing.valueOf())})`);
+          break;
+        case "RegExp":
+          values.push(thing.toString());
+          break;
+        case "Date":
+          values.push(`new Date(${thing.getTime()})`);
+          break;
+        case "Array":
+          values.push(`Array(${thing.length})`);
+          thing.forEach((v, i) => {
+            statements.push(`${name}[${i}]=${stringify2(v)}`);
+          });
+          break;
+        case "Set":
+          values.push(`new Set`);
+          statements.push(
+            `${name}.${Array.from(thing).map((v) => `add(${stringify2(v)})`).join(".")}`
+          );
+          break;
+        case "Map":
+          values.push(`new Map`);
+          statements.push(
+            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify2(k)}, ${stringify2(v)})`).join(".")}`
+          );
+          break;
+        default:
+          values.push(
+            Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}"
+          );
+          Object.keys(thing).forEach((key) => {
+            statements.push(
+              `${name}${safe_prop(key)}=${stringify2(thing[key])}`
+            );
+          });
+      }
+    });
+    statements.push(`return ${str}`);
+    return `(function(${params.join(",")}){${statements.join(
+      ";"
+    )}}(${values.join(",")}))`;
+  } else {
+    return str;
+  }
+}
+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;
+}
+function escape_unsafe_char(c) {
+  return escaped[c] || c;
+}
+function escape_unsafe_chars(str) {
+  return str.replace(unsafe_chars, escape_unsafe_char);
+}
+function safe_key(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
+}
+function safe_prop(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
+}
+function stringify_primitive(thing) {
+  if (typeof thing === "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 (typeof thing === "number") return str.replace(/^(-)?0\./, "$1.");
+  if (typeof thing === "bigint") return thing + "n";
+  return str;
+}
+
+// node_modules/devalue/src/base64.js
+function encode64(arraybuffer) {
+  const dv = new DataView(arraybuffer);
+  let binaryString = "";
+  for (let i = 0; i < arraybuffer.byteLength; i++) {
+    binaryString += String.fromCharCode(dv.getUint8(i));
+  }
+  return binaryToAscii(binaryString);
+}
+function decode64(string) {
+  const binaryString = asciiToBinary(string);
+  const arraybuffer = new ArrayBuffer(binaryString.length);
+  const dv = new DataView(arraybuffer);
+  for (let i = 0; i < arraybuffer.byteLength; i++) {
+    dv.setUint8(i, binaryString.charCodeAt(i));
+  }
+  return arraybuffer;
+}
+var KEY_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function asciiToBinary(data) {
+  if (data.length % 4 === 0) {
+    data = data.replace(/==?$/, "");
+  }
+  let output = "";
+  let buffer = 0;
+  let accumulatedBits = 0;
+  for (let i = 0; i < data.length; i++) {
+    buffer <<= 6;
+    buffer |= KEY_STRING.indexOf(data[i]);
+    accumulatedBits += 6;
+    if (accumulatedBits === 24) {
+      output += String.fromCharCode((buffer & 16711680) >> 16);
+      output += String.fromCharCode((buffer & 65280) >> 8);
+      output += String.fromCharCode(buffer & 255);
+      buffer = accumulatedBits = 0;
+    }
+  }
+  if (accumulatedBits === 12) {
+    buffer >>= 4;
+    output += String.fromCharCode(buffer);
+  } else if (accumulatedBits === 18) {
+    buffer >>= 2;
+    output += String.fromCharCode((buffer & 65280) >> 8);
+    output += String.fromCharCode(buffer & 255);
+  }
+  return output;
+}
+function binaryToAscii(str) {
+  let out = "";
+  for (let i = 0; i < str.length; i += 3) {
+    const groupsOfSix = [void 0, void 0, void 0, void 0];
+    groupsOfSix[0] = str.charCodeAt(i) >> 2;
+    groupsOfSix[1] = (str.charCodeAt(i) & 3) << 4;
+    if (str.length > i + 1) {
+      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
+      groupsOfSix[2] = (str.charCodeAt(i + 1) & 15) << 2;
+    }
+    if (str.length > i + 2) {
+      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
+      groupsOfSix[3] = str.charCodeAt(i + 2) & 63;
+    }
+    for (let j = 0; j < groupsOfSix.length; j++) {
+      if (typeof groupsOfSix[j] === "undefined") {
+        out += "=";
+      } else {
+        out += KEY_STRING[groupsOfSix[j]];
+      }
+    }
+  }
+  return out;
+}
+
+// node_modules/devalue/src/constants.js
+var UNDEFINED = -1;
+var HOLE = -2;
+var NAN = -3;
+var POSITIVE_INFINITY = -4;
+var NEGATIVE_INFINITY = -5;
+var NEGATIVE_ZERO = -6;
+
+// node_modules/devalue/src/parse.js
+function parse(serialized, revivers) {
+  return unflatten(JSON.parse(serialized), 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 = (
+    /** @type {any[]} */
+    parsed
+  );
+  const hydrated = Array(values.length);
+  function hydrate(index, standalone = false) {
+    if (index === UNDEFINED) return void 0;
+    if (index === NAN) return NaN;
+    if (index === POSITIVE_INFINITY) return Infinity;
+    if (index === NEGATIVE_INFINITY) return -Infinity;
+    if (index === NEGATIVE_ZERO) return -0;
+    if (standalone) 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 == null ? void 0 : revivers[type];
+        if (reviver) {
+          return hydrated[index] = reviver(hydrate(value[1]));
+        }
+        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":
+            hydrated[index] = Object(value[1]);
+            break;
+          case "BigInt":
+            hydrated[index] = BigInt(value[1]);
+            break;
+          case "null":
+            const obj = /* @__PURE__ */ Object.create(null);
+            hydrated[index] = obj;
+            for (let i = 1; i < value.length; i += 2) {
+              obj[value[i]] = hydrate(value[i + 1]);
+            }
+            break;
+          case "Int8Array":
+          case "Uint8Array":
+          case "Uint8ClampedArray":
+          case "Int16Array":
+          case "Uint16Array":
+          case "Int32Array":
+          case "Uint32Array":
+          case "Float32Array":
+          case "Float64Array":
+          case "BigInt64Array":
+          case "BigUint64Array": {
+            const TypedArrayConstructor = globalThis[type];
+            const base64 = value[1];
+            const arraybuffer = decode64(base64);
+            const typedArray = new TypedArrayConstructor(arraybuffer);
+            hydrated[index] = typedArray;
+            break;
+          }
+          case "ArrayBuffer": {
+            const base64 = value[1];
+            const arraybuffer = decode64(base64);
+            hydrated[index] = arraybuffer;
+            break;
+          }
+          default:
+            throw new Error(`Unknown type ${type}`);
+        }
+      } 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 === HOLE) continue;
+          array[i] = hydrate(n);
+        }
+      }
+    } else {
+      const object = {};
+      hydrated[index] = object;
+      for (const key in value) {
+        const n = value[key];
+        object[key] = hydrate(n);
+      }
+    }
+    return hydrated[index];
+  }
+  return hydrate(0);
+}
+
+// node_modules/devalue/src/stringify.js
+function stringify(value, reducers) {
+  const stringified = [];
+  const indexes = /* @__PURE__ */ new Map();
+  const custom = [];
+  if (reducers) {
+    for (const key of Object.getOwnPropertyNames(reducers)) {
+      custom.push({ key, fn: reducers[key] });
+    }
+  }
+  const keys = [];
+  let p = 0;
+  function flatten(thing) {
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys);
+    }
+    if (indexes.has(thing)) return indexes.get(thing);
+    if (thing === void 0) return UNDEFINED;
+    if (Number.isNaN(thing)) return NAN;
+    if (thing === Infinity) return POSITIVE_INFINITY;
+    if (thing === -Infinity) return NEGATIVE_INFINITY;
+    if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
+    const index2 = p++;
+    indexes.set(thing, index2);
+    for (const { key, fn } of custom) {
+      const value2 = fn(thing);
+      if (value2) {
+        stringified[index2] = `["${key}",${flatten(value2)}]`;
+        return index2;
+      }
+    }
+    let str = "";
+    if (is_primitive(thing)) {
+      str = stringify_primitive2(thing);
+    } else {
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+          str = `["Object",${stringify_primitive2(thing)}]`;
+          break;
+        case "BigInt":
+          str = `["BigInt",${thing}]`;
+          break;
+        case "Date":
+          const valid = !isNaN(thing.getDate());
+          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          break;
+        case "RegExp":
+          const { source, flags } = thing;
+          str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+          break;
+        case "Array":
+          str = "[";
+          for (let i = 0; i < thing.length; i += 1) {
+            if (i > 0) str += ",";
+            if (i in thing) {
+              keys.push(`[${i}]`);
+              str += flatten(thing[i]);
+              keys.pop();
+            } else {
+              str += HOLE;
+            }
+          }
+          str += "]";
+          break;
+        case "Set":
+          str = '["Set"';
+          for (const value2 of thing) {
+            str += `,${flatten(value2)}`;
+          }
+          str += "]";
+          break;
+        case "Map":
+          str = '["Map"';
+          for (const [key, value2] of thing) {
+            keys.push(
+              `.get(${is_primitive(key) ? stringify_primitive2(key) : "..."})`
+            );
+            str += `,${flatten(key)},${flatten(value2)}`;
+            keys.pop();
+          }
+          str += "]";
+          break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array": {
+          const typedArray = thing;
+          const base64 = encode64(typedArray.buffer);
+          str = '["' + type + '","' + base64 + '"]';
+          break;
+        }
+        case "ArrayBuffer": {
+          const arraybuffer = thing;
+          const base64 = encode64(arraybuffer);
+          str = `["ArrayBuffer","${base64}"]`;
+          break;
+        }
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(
+              `Cannot stringify arbitrary non-POJOs`,
+              keys
+            );
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(
+              `Cannot stringify POJOs with symbolic keys`,
+              keys
+            );
+          }
+          if (Object.getPrototypeOf(thing) === null) {
+            str = '["null"';
+            for (const key in thing) {
+              keys.push(stringify_key(key));
+              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              keys.pop();
+            }
+            str += "]";
+          } else {
+            str = "{";
+            let started = false;
+            for (const key in thing) {
+              if (started) str += ",";
+              started = true;
+              keys.push(stringify_key(key));
+              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              keys.pop();
+            }
+            str += "}";
+          }
+      }
+    }
+    stringified[index2] = str;
+    return index2;
+  }
+  const index = flatten(value);
+  if (index < 0) return `${index}`;
+  return `[${stringified.join(",")}]`;
+}
+function stringify_primitive2(thing) {
+  const type = typeof thing;
+  if (type === "string") return stringify_string(thing);
+  if (thing instanceof String) return stringify_string(thing.toString());
+  if (thing === void 0) return UNDEFINED.toString();
+  if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
+  if (type === "bigint") return `["BigInt","${thing}"]`;
+  return String(thing);
+}
+export {
+  parse,
+  stringify,
+  uneval,
+  unflatten
+};
+//# sourceMappingURL=devalue.js.map