Spaces:

pngwn
/

static-test

Running

App Files Files Community

pngwn commited on Jan 10, 2022

Commit

5fd8183

1 Parent(s): e61a59a

tweak

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

.DS_Store +0 -0
.gitignore +1 -0
.pnpm-debug.log +22 -0
.svelte-kit/build/app.js +77 -0
.svelte-kit/build/components/error.svelte +29 -0
.svelte-kit/build/components/layout.svelte +1 -0
.svelte-kit/build/generated/manifest.js +28 -0
.svelte-kit/build/generated/root.svelte +70 -0
.svelte-kit/build/kit.js +1921 -0
.svelte-kit/build/runtime/app/env.js +20 -0
.svelte-kit/build/runtime/app/navigation.js +65 -0
.svelte-kit/build/runtime/app/paths.js +1 -0
.svelte-kit/build/runtime/app/stores.js +84 -0
.svelte-kit/build/runtime/chunks/utils.js +13 -0
.svelte-kit/build/runtime/env.js +8 -0
.svelte-kit/build/runtime/internal/singletons.js +18 -0
.svelte-kit/build/runtime/internal/start.js +1219 -0
.svelte-kit/build/runtime/paths.js +13 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-all-400-normal-0d19eb5d.woff +0 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-cyrillic-400-normal-046b609f.woff2 +0 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-cyrillic-ext-400-normal-b3140dd3.woff2 +0 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-greek-400-normal-1f8b3a07.woff2 +0 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-greek-ext-400-normal-8659ae46.woff2 +0 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-latin-400-normal-a2f9dbe8.woff2 +0 -0
{_app → .svelte-kit/output/client/_app}/assets/fira-mono-latin-ext-400-normal-b6331a25.woff2 +0 -0
.svelte-kit/output/client/_app/assets/pages/__layout.svelte-343606d7.css +1 -0
{_app → .svelte-kit/output/client/_app}/assets/pages/about.svelte-bf4528fa.css +0 -0
{_app → .svelte-kit/output/client/_app}/assets/pages/index.svelte-c63fe1c6.css +0 -0
{_app → .svelte-kit/output/client/_app}/assets/pages/todos/index.svelte-784042c1.css +0 -0
{_app → .svelte-kit/output/client/_app}/assets/start-61d1577b.css +0 -0
{_app → .svelte-kit/output/client/_app}/assets/svelte-logo-87df40b8.svg +0 -0
{_app → .svelte-kit/output/client/_app}/chunks/vendor-d68c61c2.js +0 -0
{_app → .svelte-kit/output/client/_app}/error.svelte-97b7e85d.js +0 -0
{_app → .svelte-kit/output/client/_app}/manifest.json +2 -2
.svelte-kit/output/client/_app/pages/__layout.svelte-2dd96704.js +1 -0
{_app → .svelte-kit/output/client/_app}/pages/about.svelte-a7982a52.js +0 -0
{_app → .svelte-kit/output/client/_app}/pages/index.svelte-934bb81d.js +0 -0
{_app → .svelte-kit/output/client/_app}/pages/todos/index.svelte-82693d56.js +0 -0
.svelte-kit/output/client/_app/start-2ccc875c.js +1 -0
.svelte-kit/output/server/app.js +1473 -0
.svelte-kit/output/server/chunks/_api-cf43c630.js +26 -0
.svelte-kit/output/server/chunks/index-c7a03ab5.js +159 -0
.svelte-kit/output/server/entries/endpoints/todos/_uid_.json.js +11 -0
.svelte-kit/output/server/entries/endpoints/todos/index.json.js +15 -0
.svelte-kit/output/server/entries/pages/__layout.svelte.js +63 -0
.svelte-kit/output/server/entries/pages/about.svelte.js +35 -0
.svelte-kit/output/server/entries/pages/error.svelte.js +21 -0
.svelte-kit/output/server/entries/pages/index.svelte.js +190 -0
.svelte-kit/output/server/entries/pages/todos/index.svelte.js +37 -0
.svelte-kit/output/server/manifest.js +53 -0

.DS_Store ADDED Viewed

Binary file (6.15 kB). View file

.gitignore ADDED Viewed

	@@ -0,0 +1 @@


1	+ node_modules

.pnpm-debug.log ADDED Viewed

	@@ -0,0 +1,22 @@

+{
+  "0 debug pnpm:scope": {
+    "selected": 1
+  },
+  "1 error pnpm": {
+    "code": "ELIFECYCLE",
+    "errno": "ENOENT",
+    "syscall": "spawn",
+    "file": "sh",
+    "pkgid": "[email protected]",
+    "stage": "build",
+    "script": "svelte-kit build",
+    "pkgname": "my-app",
+    "err": {
+      "name": "pnpm",
+      "message": "[email protected] build: `svelte-kit build`\nspawn ENOENT",
+      "code": "ELIFECYCLE",
+      "stack": "pnpm: [email protected] build: `svelte-kit build`\nspawn ENOENT\n    at ChildProcess.<anonymous> (/Users/peterallen/.volta/tools/image/packages/pnpm/lib/node_modules/pnpm/dist/pnpm.cjs:91465:22)\n    at ChildProcess.emit (node:events:390:28)\n    at maybeClose (node:internal/child_process:1064:16)\n    at Process.ChildProcess._handle.onexit (node:internal/child_process:301:5)"
+    }
+  },
+  "2 warn pnpm:global": " Local package.json exists, but node_modules missing, did you mean to install?"
+}

.svelte-kit/build/app.js ADDED Viewed

	@@ -0,0 +1,77 @@

+import { respond } from './kit.js';
+import root from './generated/root.svelte';
+import { set_paths, assets, base } from './runtime/paths.js';
+import { set_prerendering } from './runtime/env.js';
+import * as user_hooks from "../../src/hooks.js";
+const template = ({ head, body, assets }) => "<!DOCTYPE html>\n<html lang=\"en\">\n\t<head>\n\t\t<meta charset=\"utf-8\" />\n\t\t<meta name=\"description\" content=\"Svelte demo app\" />\n\t\t<link rel=\"icon\" href=\"" + assets + "/favicon.png\" />\n\t\t<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n\t\t" + head + "\n\t</head>\n\t<body>\n\t\t<div id=\"svelte\">" + body + "</div>\n\t</body>\n</html>\n";
+let read = null;
+set_paths({"base":"/staticspaceiframe/spaces/pngwn/static-test","assets":""});
+// this looks redundant, but the indirection allows us to access
+// named imports without triggering Rollup's missing import detection
+const get_hooks = hooks => ({
+	getSession: hooks.getSession || (() => ({})),
+	handle: hooks.handle || (({ request, resolve }) => resolve(request)),
+	handleError: hooks.handleError || (({ error }) => console.error(error.stack)),
+	externalFetch: hooks.externalFetch || fetch
+});
+let default_protocol = 'https';
+// allow paths to be globally overridden
+// in svelte-kit preview and in prerendering
+export function override(settings) {
+	default_protocol = settings.protocol || default_protocol;
+	set_paths(settings.paths);
+	set_prerendering(settings.prerendering);
+	read = settings.read;
+}
+export class App {
+	constructor(manifest) {
+		const hooks = get_hooks(user_hooks);
+		this.options = {
+			amp: false,
+			dev: false,
+			floc: false,
+			get_stack: error => String(error), // for security
+			handle_error: (error, request) => {
+				hooks.handleError({ error, request });
+				error.stack = this.options.get_stack(error);
+			},
+			hooks,
+			hydrate: true,
+			manifest,
+			paths: { base, assets },
+			prefix: assets + '/_app/',
+			prerender: true,
+			read,
+			root,
+			service_worker: null,
+			router: true,
+			ssr: true,
+			target: "#svelte",
+			template,
+			trailing_slash: "never"
+		};
+	}
+	render(request, {
+		prerender
+	} = {}) {
+		// TODO remove this for 1.0
+		if (Object.keys(request).sort().join() !== 'headers,method,rawBody,url') {
+			throw new Error('Adapters should call app.render({ url, method, headers, rawBody })');
+		}
+		const host = request.headers["host"];
+		const protocol = default_protocol;
+		return respond({ ...request, url: new URL(request.url, protocol + '://' + host) }, this.options, { prerender });
+	}
+}

.svelte-kit/build/components/error.svelte ADDED Viewed

	@@ -0,0 +1,29 @@

+<script context="module">
+	/** @type {import('@sveltejs/kit').ErrorLoad} */
+	export function load({ error, status }) {
+		return {
+			props: { error, status }
+		};
+	}
+</script>
+<script>
+	/** @type {number} */
+	export let status;
+	/** @type {Error & {frame?: string} & {loc?: object}} */
+	export let error;
+</script>
+<h1>{status}</h1>
+<pre>{error.message}</pre>
+<!-- TODO figure out what to do with frames/stacktraces in prod -->
+<!-- frame is populated by Svelte in its CompileError and is a Rollup/Vite convention -->
+{#if error.frame}
+	<pre>{error.frame}</pre>
+{/if}
+{#if error.stack}
+	<pre>{error.stack}</pre>
+{/if}

.svelte-kit/build/components/layout.svelte ADDED Viewed

	@@ -0,0 +1 @@


1	+ <slot></slot>

.svelte-kit/build/generated/manifest.js ADDED Viewed

	@@ -0,0 +1,28 @@

+const c = [
+	() => import("../../../src/routes/__layout.svelte"),
+	() => import("../components/error.svelte"),
+	() => import("../../../src/routes/index.svelte"),
+	() => import("../../../src/routes/about.svelte"),
+	() => import("../../../src/routes/todos/index.svelte")
+];
+const d = decodeURIComponent;
+export const routes = [
+	// src/routes/index.svelte
+	[/^\/$/, [c[0], c[2]], [c[1]]],
+	// src/routes/about.svelte
+	[/^\/about\/?$/, [c[0], c[3]], [c[1]]],
+	,
+	// src/routes/todos/index.svelte
+	[/^\/todos\/?$/, [c[0], c[4]], [c[1]]],
+];
+// we import the root layout/error components eagerly, so that
+// connectivity errors after initialisation don't nuke the app
+export const fallback = [c[0](), c[1]()];

.svelte-kit/build/generated/root.svelte ADDED Viewed

	@@ -0,0 +1,70 @@

+<!-- This file is generated by @sveltejs/kit — do not edit it! -->
+<script>
+	import { setContext, afterUpdate, onMount } from 'svelte';
+	// stores
+	export let stores;
+	export let page;
+	export let components;
+	export let props_0 = null;
+	export let props_1 = null;
+	export let props_2 = null;
+	setContext('__svelte__', stores);
+	$: stores.page.set(page);
+	afterUpdate(stores.page.notify);
+	let mounted = false;
+	let navigated = false;
+	let title = null;
+	onMount(() => {
+		const unsubscribe = stores.page.subscribe(() => {
+			if (mounted) {
+				navigated = true;
+				title = document.title || 'untitled page';
+			}
+		});
+		mounted = true;
+		return unsubscribe;
+	});
+</script>
+{#if components[1]}
+	<svelte:component this={components[0]} {...(props_0 || {})}>
+		{#if components[2]}
+			<svelte:component this={components[1]} {...(props_1 || {})}>
+				<svelte:component this={components[2]} {...(props_2 || {})}/>
+			</svelte:component>
+		{:else}
+			<svelte:component this={components[1]} {...(props_1 || {})} />
+		{/if}
+	</svelte:component>
+{:else}
+	<svelte:component this={components[0]} {...(props_0 || {})} />
+{/if}
+{#if mounted}
+	<div id="svelte-announcer" aria-live="assertive" aria-atomic="true">
+		{#if navigated}
+			{title}
+		{/if}
+	</div>
+{/if}
+<style>
+	#svelte-announcer {
+		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;
+	}
+</style>

.svelte-kit/build/kit.js ADDED Viewed

	@@ -0,0 +1,1921 @@

+/**
+ * @param {Record<string, string | string[] | undefined>} headers
+ * @param {string} key
+ * @returns {string | undefined}
+ * @throws {Error}
+ */
+function get_single_valued_header(headers, key) {
+	const value = headers[key];
+	if (Array.isArray(value)) {
+		if (value.length === 0) {
+			return undefined;
+		}
+		if (value.length > 1) {
+			throw new Error(
+				`Multiple headers provided for ${key}. Multiple may be provided only for set-cookie`
+			);
+		}
+		return value[0];
+	}
+	return value;
+}
+/** @param {Record<string, any>} obj */
+function lowercase_keys(obj) {
+	/** @type {Record<string, any>} */
+	const clone = {};
+	for (const key in obj) {
+		clone[key.toLowerCase()] = obj[key];
+	}
+	return clone;
+}
+/** @param {Record<string, string>} params */
+function decode_params(params) {
+	for (const key in params) {
+		// input has already been decoded by decodeURI
+		// now handle the rest that decodeURIComponent would do
+		params[key] = params[key]
+			.replace(/%23/g, '#')
+			.replace(/%3[Bb]/g, ';')
+			.replace(/%2[Cc]/g, ',')
+			.replace(/%2[Ff]/g, '/')
+			.replace(/%3[Ff]/g, '?')
+			.replace(/%3[Aa]/g, ':')
+			.replace(/%40/g, '@')
+			.replace(/%26/g, '&')
+			.replace(/%3[Dd]/g, '=')
+			.replace(/%2[Bb]/g, '+')
+			.replace(/%24/g, '$');
+	}
+	return params;
+}
+/** @param {string} body */
+function error(body) {
+	return {
+		status: 500,
+		body,
+		headers: {}
+	};
+}
+/** @param {unknown} s */
+function is_string(s) {
+	return typeof s === 'string' || s instanceof String;
+}
+const text_types = new Set([
+	'application/xml',
+	'application/json',
+	'application/x-www-form-urlencoded',
+	'multipart/form-data'
+]);
+/**
+ * Decides how the body should be parsed based on its mime type. Should match what's in parse_body
+ *
+ * @param {string | undefined | null} content_type The `content-type` header of a request/response.
+ * @returns {boolean}
+ */
+function is_text(content_type) {
+	if (!content_type) return true; // defaults to json
+	const type = content_type.split(';')[0].toLowerCase(); // get the mime type
+	return type.startsWith('text/') || type.endsWith('+xml') || text_types.has(type);
+}
+/**
+ * @param {import('types/hooks').ServerRequest} request
+ * @param {import('types/internal').SSREndpoint} route
+ * @param {RegExpExecArray} match
+ * @returns {Promise<import('types/hooks').ServerResponse | undefined>}
+ */
+async function render_endpoint(request, route, match) {
+	const mod = await route.load();
+	/** @type {import('types/endpoint').RequestHandler} */
+	const handler = mod[request.method.toLowerCase().replace('delete', 'del')]; // 'delete' is a reserved word
+	if (!handler) {
+		return;
+	}
+	// we're mutating `request` so that we don't have to do { ...request, params }
+	// on the next line, since that breaks the getters that replace path, query and
+	// origin. We could revert that once we remove the getters
+	request.params = route.params ? decode_params(route.params(match)) : {};
+	const response = await handler(request);
+	const preface = `Invalid response from route ${request.url.pathname}`;
+	if (!response) {
+		return;
+	}
+	if (typeof response !== 'object') {
+		return error(`${preface}: expected an object, got ${typeof response}`);
+	}
+	let { status = 200, body, headers = {} } = response;
+	headers = lowercase_keys(headers);
+	const type = get_single_valued_header(headers, 'content-type');
+	if (!is_text(type) && !(body instanceof Uint8Array || is_string(body))) {
+		return error(
+			`${preface}: body must be an instance of string or Uint8Array if content-type is not a supported textual content-type`
+		);
+	}
+	/** @type {import('types/hooks').StrictBody} */
+	let normalized_body;
+	// ensure the body is an object
+	if (
+		(typeof body === 'object' || typeof body === 'undefined') &&
+		!(body instanceof Uint8Array) &&
+		(!type || type.startsWith('application/json'))
+	) {
+		headers = { ...headers, 'content-type': 'application/json; charset=utf-8' };
+		normalized_body = JSON.stringify(typeof body === 'undefined' ? {} : body);
+	} else {
+		normalized_body = /** @type {import('types/hooks').StrictBody} */ (body);
+	}
+	return { status, body: normalized_body, headers };
+}
+var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+var unsafeChars = /[<>\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)$/;
+var escaped = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '/': '\\u002F',
+    '\\': '\\\\',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    '\0': '\\0',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029'
+};
+var objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join('\0');
+function devalue(value) {
+    var counts = new Map();
+    function walk(thing) {
+        if (typeof thing === 'function') {
+            throw new Error("Cannot stringify a function");
+        }
+        if (counts.has(thing)) {
+            counts.set(thing, counts.get(thing) + 1);
+            return;
+        }
+        counts.set(thing, 1);
+        if (!isPrimitive(thing)) {
+            var type = getType(thing);
+            switch (type) {
+                case 'Number':
+                case 'String':
+                case 'Boolean':
+                case 'Date':
+                case 'RegExp':
+                    return;
+                case 'Array':
+                    thing.forEach(walk);
+                    break;
+                case 'Set':
+                case 'Map':
+                    Array.from(thing).forEach(walk);
+                    break;
+                default:
+                    var proto = Object.getPrototypeOf(thing);
+                    if (proto !== Object.prototype &&
+                        proto !== null &&
+                        Object.getOwnPropertyNames(proto).sort().join('\0') !== objectProtoOwnPropertyNames) {
+                        throw new Error("Cannot stringify arbitrary non-POJOs");
+                    }
+                    if (Object.getOwnPropertySymbols(thing).length > 0) {
+                        throw new Error("Cannot stringify POJOs with symbolic keys");
+                    }
+                    Object.keys(thing).forEach(function (key) { return walk(thing[key]); });
+            }
+        }
+    }
+    walk(value);
+    var names = new Map();
+    Array.from(counts)
+        .filter(function (entry) { return entry[1] > 1; })
+        .sort(function (a, b) { return b[1] - a[1]; })
+        .forEach(function (entry, i) {
+        names.set(entry[0], getName(i));
+    });
+    function stringify(thing) {
+        if (names.has(thing)) {
+            return names.get(thing);
+        }
+        if (isPrimitive(thing)) {
+            return stringifyPrimitive(thing);
+        }
+        var type = getType(thing);
+        switch (type) {
+            case 'Number':
+            case 'String':
+            case 'Boolean':
+                return "Object(" + stringify(thing.valueOf()) + ")";
+            case 'RegExp':
+                return "new RegExp(" + stringifyString(thing.source) + ", \"" + thing.flags + "\")";
+            case 'Date':
+                return "new Date(" + thing.getTime() + ")";
+            case 'Array':
+                var members = thing.map(function (v, i) { return i in thing ? stringify(v) : ''; });
+                var tail = thing.length === 0 || (thing.length - 1 in thing) ? '' : ',';
+                return "[" + members.join(',') + tail + "]";
+            case 'Set':
+            case 'Map':
+                return "new " + type + "([" + Array.from(thing).map(stringify).join(',') + "])";
+            default:
+                var obj = "{" + Object.keys(thing).map(function (key) { return safeKey(key) + ":" + stringify(thing[key]); }).join(',') + "}";
+                var proto = Object.getPrototypeOf(thing);
+                if (proto === null) {
+                    return Object.keys(thing).length > 0
+                        ? "Object.assign(Object.create(null)," + obj + ")"
+                        : "Object.create(null)";
+                }
+                return obj;
+        }
+    }
+    var str = stringify(value);
+    if (names.size) {
+        var params_1 = [];
+        var statements_1 = [];
+        var values_1 = [];
+        names.forEach(function (name, thing) {
+            params_1.push(name);
+            if (isPrimitive(thing)) {
+                values_1.push(stringifyPrimitive(thing));
+                return;
+            }
+            var type = getType(thing);
+            switch (type) {
+                case 'Number':
+                case 'String':
+                case 'Boolean':
+                    values_1.push("Object(" + stringify(thing.valueOf()) + ")");
+                    break;
+                case 'RegExp':
+                    values_1.push(thing.toString());
+                    break;
+                case 'Date':
+                    values_1.push("new Date(" + thing.getTime() + ")");
+                    break;
+                case 'Array':
+                    values_1.push("Array(" + thing.length + ")");
+                    thing.forEach(function (v, i) {
+                        statements_1.push(name + "[" + i + "]=" + stringify(v));
+                    });
+                    break;
+                case 'Set':
+                    values_1.push("new Set");
+                    statements_1.push(name + "." + Array.from(thing).map(function (v) { return "add(" + stringify(v) + ")"; }).join('.'));
+                    break;
+                case 'Map':
+                    values_1.push("new Map");
+                    statements_1.push(name + "." + Array.from(thing).map(function (_a) {
+                        var k = _a[0], v = _a[1];
+                        return "set(" + stringify(k) + ", " + stringify(v) + ")";
+                    }).join('.'));
+                    break;
+                default:
+                    values_1.push(Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}');
+                    Object.keys(thing).forEach(function (key) {
+                        statements_1.push("" + name + safeProp(key) + "=" + stringify(thing[key]));
+                    });
+            }
+        });
+        statements_1.push("return " + str);
+        return "(function(" + params_1.join(',') + "){" + statements_1.join(';') + "}(" + values_1.join(',') + "))";
+    }
+    else {
+        return str;
+    }
+}
+function getName(num) {
+    var name = '';
+    do {
+        name = chars[num % chars.length] + name;
+        num = ~~(num / chars.length) - 1;
+    } while (num >= 0);
+    return reserved.test(name) ? name + "_" : name;
+}
+function isPrimitive(thing) {
+    return Object(thing) !== thing;
+}
+function stringifyPrimitive(thing) {
+    if (typeof thing === 'string')
+        return stringifyString(thing);
+    if (thing === void 0)
+        return 'void 0';
+    if (thing === 0 && 1 / thing < 0)
+        return '-0';
+    var str = String(thing);
+    if (typeof thing === 'number')
+        return str.replace(/^(-)?0\./, '$1.');
+    return str;
+}
+function getType(thing) {
+    return Object.prototype.toString.call(thing).slice(8, -1);
+}
+function escapeUnsafeChar(c) {
+    return escaped[c] || c;
+}
+function escapeUnsafeChars(str) {
+    return str.replace(unsafeChars, escapeUnsafeChar);
+}
+function safeKey(key) {
+    return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
+}
+function safeProp(key) {
+    return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? "." + key : "[" + escapeUnsafeChars(JSON.stringify(key)) + "]";
+}
+function stringifyString(str) {
+    var result = '"';
+    for (var i = 0; i < str.length; i += 1) {
+        var char = str.charAt(i);
+        var code = char.charCodeAt(0);
+        if (char === '"') {
+            result += '\\"';
+        }
+        else if (char in escaped) {
+            result += escaped[char];
+        }
+        else if (code >= 0xd800 && code <= 0xdfff) {
+            var next = str.charCodeAt(i + 1);
+            // If this is the beginning of a [high, low] surrogate pair,
+            // add the next two characters, otherwise escape
+            if (code <= 0xdbff && (next >= 0xdc00 && next <= 0xdfff)) {
+                result += char + str[++i];
+            }
+            else {
+                result += "\\u" + code.toString(16).toUpperCase();
+            }
+        }
+        else {
+            result += char;
+        }
+    }
+    result += '"';
+    return result;
+}
+function noop() { }
+function safe_not_equal(a, b) {
+    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+}
+Promise.resolve();
+const subscriber_queue = [];
+/**
+ * Create a `Writable` store that allows both updating and reading by subscription.
+ * @param {*=}value initial value
+ * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+ */
+function writable(value, start = noop) {
+    let stop;
+    const subscribers = new Set();
+    function set(new_value) {
+        if (safe_not_equal(value, new_value)) {
+            value = new_value;
+            if (stop) { // store is ready
+                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(value));
+    }
+    function subscribe(run, invalidate = noop) {
+        const subscriber = [run, invalidate];
+        subscribers.add(subscriber);
+        if (subscribers.size === 1) {
+            stop = start(set) || noop;
+        }
+        run(value);
+        return () => {
+            subscribers.delete(subscriber);
+            if (subscribers.size === 0) {
+                stop();
+                stop = null;
+            }
+        };
+    }
+    return { set, update, subscribe };
+}
+/**
+ * @param {unknown} err
+ * @return {Error}
+ */
+function coalesce_to_error(err) {
+	return err instanceof Error ||
+		(err && /** @type {any} */ (err).name && /** @type {any} */ (err).message)
+		? /** @type {Error} */ (err)
+		: new Error(JSON.stringify(err));
+}
+/**
+ * Hash using djb2
+ * @param {import('types/hooks').StrictBody} value
+ */
+function hash(value) {
+	let hash = 5381;
+	let i = value.length;
+	if (typeof value === 'string') {
+		while (i) hash = (hash * 33) ^ value.charCodeAt(--i);
+	} else {
+		while (i) hash = (hash * 33) ^ value[--i];
+	}
+	return (hash >>> 0).toString(36);
+}
+/** @type {Record<string, string>} */
+const escape_json_string_in_html_dict = {
+	'"': '\\"',
+	'<': '\\u003C',
+	'>': '\\u003E',
+	'/': '\\u002F',
+	'\\': '\\\\',
+	'\b': '\\b',
+	'\f': '\\f',
+	'\n': '\\n',
+	'\r': '\\r',
+	'\t': '\\t',
+	'\0': '\\0',
+	'\u2028': '\\u2028',
+	'\u2029': '\\u2029'
+};
+/** @param {string} str */
+function escape_json_string_in_html(str) {
+	return escape(
+		str,
+		escape_json_string_in_html_dict,
+		(code) => `\\u${code.toString(16).toUpperCase()}`
+	);
+}
+/** @type {Record<string, string>} */
+const escape_html_attr_dict = {
+	'<': '&lt;',
+	'>': '&gt;',
+	'"': '&quot;'
+};
+/**
+ * use for escaping string values to be used html attributes on the page
+ * e.g.
+ * <script data-url="here">
+ *
+ * @param {string} str
+ * @returns string escaped string
+ */
+function escape_html_attr(str) {
+	return '"' + escape(str, escape_html_attr_dict, (code) => `&#${code};`) + '"';
+}
+/**
+ *
+ * @param str {string} string to escape
+ * @param dict {Record<string, string>} dictionary of character replacements
+ * @param unicode_encoder {function(number): string} encoder to use for high unicode characters
+ * @returns {string}
+ */
+function escape(str, dict, unicode_encoder) {
+	let result = '';
+	for (let i = 0; i < str.length; i += 1) {
+		const char = str.charAt(i);
+		const code = char.charCodeAt(0);
+		if (char in dict) {
+			result += dict[char];
+		} else if (code >= 0xd800 && code <= 0xdfff) {
+			const next = str.charCodeAt(i + 1);
+			// If this is the beginning of a [high, low] surrogate pair,
+			// add the next two characters, otherwise escape
+			if (code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
+				result += char + str[++i];
+			} else {
+				result += unicode_encoder(code);
+			}
+		} else {
+			result += char;
+		}
+	}
+	return result;
+}
+const s = JSON.stringify;
+// TODO rename this function/module
+/**
+ * @param {{
+ *   branch: Array<import('./types').Loaded>;
+ *   options: import('types/internal').SSRRenderOptions;
+ *   $session: any;
+ *   page_config: { hydrate: boolean, router: boolean, ssr: boolean };
+ *   status: number;
+ *   error?: Error,
+ *   url: URL;
+ *   params: Record<string, string>
+ * }} opts
+ */
+async function render_response({
+	branch,
+	options,
+	$session,
+	page_config,
+	status,
+	error,
+	url,
+	params
+}) {
+	const css = new Set(options.manifest._.entry.css);
+	const js = new Set(options.manifest._.entry.js);
+	const styles = new Set();
+	/** @type {Array<{ url: string, body: string, json: string }>} */
+	const serialized_data = [];
+	let rendered;
+	let is_private = false;
+	let maxage;
+	if (error) {
+		error.stack = options.get_stack(error);
+	}
+	if (page_config.ssr) {
+		branch.forEach(({ node, loaded, fetched, uses_credentials }) => {
+			if (node.css) node.css.forEach((url) => css.add(url));
+			if (node.js) node.js.forEach((url) => js.add(url));
+			if (node.styles) node.styles.forEach((content) => styles.add(content));
+			// TODO probably better if `fetched` wasn't populated unless `hydrate`
+			if (fetched && page_config.hydrate) serialized_data.push(...fetched);
+			if (uses_credentials) is_private = true;
+			maxage = loaded.maxage;
+		});
+		const session = writable($session);
+		/** @type {Record<string, any>} */
+		const props = {
+			stores: {
+				page: writable(null),
+				navigating: writable(null),
+				session
+			},
+			page: { url, params, status, error },
+			components: branch.map(({ node }) => node.module.default)
+		};
+		// TODO remove this for 1.0
+		/**
+		 * @param {string} property
+		 * @param {string} replacement
+		 */
+		const print_error = (property, replacement) => {
+			Object.defineProperty(props.page, property, {
+				get: () => {
+					throw new Error(`$page.${property} has been replaced by $page.url.${replacement}`);
+				}
+			});
+		};
+		print_error('origin', 'origin');
+		print_error('path', 'pathname');
+		print_error('query', 'searchParams');
+		// props_n (instead of props[n]) makes it easy to avoid
+		// unnecessary updates for layout components
+		for (let i = 0; i < branch.length; i += 1) {
+			props[`props_${i}`] = await branch[i].loaded.props;
+		}
+		let session_tracking_active = false;
+		const unsubscribe = session.subscribe(() => {
+			if (session_tracking_active) is_private = true;
+		});
+		session_tracking_active = true;
+		try {
+			rendered = options.root.render(props);
+		} finally {
+			unsubscribe();
+		}
+	} else {
+		rendered = { head: '', html: '', css: { code: '', map: null } };
+	}
+	const include_js = page_config.router || page_config.hydrate;
+	if (!include_js) js.clear();
+	// TODO strip the AMP stuff out of the build if not relevant
+	const links = options.amp
+		? styles.size > 0 || rendered.css.code.length > 0
+			? `<style amp-custom>${Array.from(styles).concat(rendered.css.code).join('\n')}</style>`
+			: ''
+		: [
+				// From https://web.dev/priority-hints/:
+				// Generally, preloads will load in the order the parser gets to them for anything above "Medium" priority
+				// Thus, we should list CSS first
+				...Array.from(css).map((dep) => `<link rel="stylesheet" href="${options.prefix}${dep}">`),
+				...Array.from(js).map((dep) => `<link rel="modulepreload" href="${options.prefix}${dep}">`)
+		  ].join('\n\t\t');
+	/** @type {string} */
+	let init = '';
+	if (options.amp) {
+		init = `
+		<style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style>
+		<noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>
+		<script async src="https://cdn.ampproject.org/v0.js"></script>`;
+		init += options.service_worker
+			? '<script async custom-element="amp-install-serviceworker" src="https://cdn.ampproject.org/v0/amp-install-serviceworker-0.1.js"></script>'
+			: '';
+	} else if (include_js) {
+		// prettier-ignore
+		init = `<script type="module">
+			import { start } from ${s(options.prefix + options.manifest._.entry.file)};
+			start({
+				target: ${options.target ? `document.querySelector(${s(options.target)})` : 'document.body'},
+				paths: ${s(options.paths)},
+				session: ${try_serialize($session, (error) => {
+					throw new Error(`Failed to serialize session data: ${error.message}`);
+				})},
+				route: ${!!page_config.router},
+				spa: ${!page_config.ssr},
+				trailing_slash: ${s(options.trailing_slash)},
+				hydrate: ${page_config.ssr && page_config.hydrate ? `{
+					status: ${status},
+					error: ${serialize_error(error)},
+					nodes: [
+						${(branch || [])
+						.map(({ node }) => `import(${s(options.prefix + node.entry)})`)
+						.join(',\n\t\t\t\t\t\t')}
+					],
+					url: new URL(${s(url.href)}),
+					params: ${devalue(params)}
+				}` : 'null'}
+			});
+		</script>`;
+	}
+	if (options.service_worker && !options.amp) {
+		init += `<script>
+			if ('serviceWorker' in navigator) {
+				navigator.serviceWorker.register('${options.service_worker}');
+			}
+		</script>`;
+	}
+	const head = [
+		rendered.head,
+		styles.size && !options.amp
+			? `<style data-svelte>${Array.from(styles).join('\n')}</style>`
+			: '',
+		links,
+		init
+	].join('\n\n\t\t');
+	let body = rendered.html;
+	if (options.amp) {
+		if (options.service_worker) {
+			body += `<amp-install-serviceworker src="${options.service_worker}" layout="nodisplay"></amp-install-serviceworker>`;
+		}
+	} else {
+		body += serialized_data
+			.map(({ url, body, json }) => {
+				let attributes = `type="application/json" data-type="svelte-data" data-url=${escape_html_attr(
+					url
+				)}`;
+				if (body) attributes += ` data-body="${hash(body)}"`;
+				return `<script ${attributes}>${json}</script>`;
+			})
+			.join('\n\n\t');
+	}
+	/** @type {import('types/helper').ResponseHeaders} */
+	const headers = {
+		'content-type': 'text/html'
+	};
+	if (maxage) {
+		headers['cache-control'] = `${is_private ? 'private' : 'public'}, max-age=${maxage}`;
+	}
+	if (!options.floc) {
+		headers['permissions-policy'] = 'interest-cohort=()';
+	}
+	const segments = url.pathname.slice(options.paths.base.length).split('/').slice(2);
+	const assets =
+		options.paths.assets || (segments.length > 0 ? segments.map(() => '..').join('/') : '.');
+	return {
+		status,
+		headers,
+		body: options.template({
+			head,
+			body,
+			assets
+		})
+	};
+}
+/**
+ * @param {any} data
+ * @param {(error: Error) => void} [fail]
+ */
+function try_serialize(data, fail) {
+	try {
+		return devalue(data);
+	} catch (err) {
+		if (fail) fail(coalesce_to_error(err));
+		return null;
+	}
+}
+// Ensure we return something truthy so the client will not re-render the page over the error
+/** @param {(Error & {frame?: string} & {loc?: object}) | undefined | null} error */
+function serialize_error(error) {
+	if (!error) return null;
+	let serialized = try_serialize(error);
+	if (!serialized) {
+		const { name, message, stack } = error;
+		serialized = try_serialize({ ...error, name, message, stack });
+	}
+	if (!serialized) {
+		serialized = '{}';
+	}
+	return serialized;
+}
+/**
+ * @param {import('types/page').LoadOutput} loaded
+ * @returns {import('types/internal').NormalizedLoadOutput}
+ */
+function normalize(loaded) {
+	const has_error_status =
+		loaded.status && loaded.status >= 400 && loaded.status <= 599 && !loaded.redirect;
+	if (loaded.error || has_error_status) {
+		const status = loaded.status;
+		if (!loaded.error && has_error_status) {
+			return {
+				status: status || 500,
+				error: new Error()
+			};
+		}
+		const error = typeof loaded.error === 'string' ? new Error(loaded.error) : loaded.error;
+		if (!(error instanceof Error)) {
+			return {
+				status: 500,
+				error: new Error(
+					`"error" property returned from load() must be a string or instance of Error, received type "${typeof error}"`
+				)
+			};
+		}
+		if (!status || status < 400 || status > 599) {
+			console.warn('"error" returned from load() without a valid status code — defaulting to 500');
+			return { status: 500, error };
+		}
+		return { status, error };
+	}
+	if (loaded.redirect) {
+		if (!loaded.status || Math.floor(loaded.status / 100) !== 3) {
+			return {
+				status: 500,
+				error: new Error(
+					'"redirect" property returned from load() must be accompanied by a 3xx status code'
+				)
+			};
+		}
+		if (typeof loaded.redirect !== 'string') {
+			return {
+				status: 500,
+				error: new Error('"redirect" property returned from load() must be a string')
+			};
+		}
+	}
+	// TODO remove before 1.0
+	if (/** @type {any} */ (loaded).context) {
+		throw new Error(
+			'You are returning "context" from a load function. ' +
+				'"context" was renamed to "stuff", please adjust your code accordingly.'
+		);
+	}
+	return /** @type {import('types/internal').NormalizedLoadOutput} */ (loaded);
+}
+const absolute = /^([a-z]+:)?\/?\//;
+const scheme = /^[a-z]+:/;
+/**
+ * @param {string} base
+ * @param {string} path
+ */
+function resolve(base, path) {
+	if (scheme.test(path)) return path;
+	const base_match = absolute.exec(base);
+	const path_match = absolute.exec(path);
+	if (!base_match) {
+		throw new Error(`bad base path: "${base}"`);
+	}
+	const baseparts = path_match ? [] : base.slice(base_match[0].length).split('/');
+	const pathparts = path_match ? path.slice(path_match[0].length).split('/') : path.split('/');
+	baseparts.pop();
+	for (let i = 0; i < pathparts.length; i += 1) {
+		const part = pathparts[i];
+		if (part === '.') continue;
+		else if (part === '..') baseparts.pop();
+		else baseparts.push(part);
+	}
+	const prefix = (path_match && path_match[0]) || (base_match && base_match[0]) || '';
+	return `${prefix}${baseparts.join('/')}`;
+}
+/** @param {string} path */
+function is_root_relative(path) {
+	return path[0] === '/' && path[1] !== '/';
+}
+/**
+ * @param {{
+ *   request: import('types/hooks').ServerRequest;
+ *   options: import('types/internal').SSRRenderOptions;
+ *   state: import('types/internal').SSRRenderState;
+ *   route: import('types/internal').SSRPage | null;
+ *   url: URL;
+ *   params: Record<string, string>;
+ *   node: import('types/internal').SSRNode;
+ *   $session: any;
+ *   stuff: Record<string, any>;
+ *   prerender_enabled: boolean;
+ *   is_leaf: boolean;
+ *   is_error: boolean;
+ *   status?: number;
+ *   error?: Error;
+ * }} opts
+ * @returns {Promise<import('./types').Loaded | undefined>} undefined for fallthrough
+ */
+async function load_node({
+	request,
+	options,
+	state,
+	route,
+	url,
+	params,
+	node,
+	$session,
+	stuff,
+	prerender_enabled,
+	is_leaf,
+	is_error,
+	status,
+	error
+}) {
+	const { module } = node;
+	let uses_credentials = false;
+	/**
+	 * @type {Array<{
+	 *   url: string;
+	 *   body: string;
+	 *   json: string;
+	 * }>}
+	 */
+	const fetched = [];
+	/**
+	 * @type {string[]}
+	 */
+	let set_cookie_headers = [];
+	let loaded;
+	const url_proxy = new Proxy(url, {
+		get: (target, prop, receiver) => {
+			if (prerender_enabled && (prop === 'search' || prop === 'searchParams')) {
+				throw new Error('Cannot access query on a page with prerendering enabled');
+			}
+			return Reflect.get(target, prop, receiver);
+		}
+	});
+	if (module.load) {
+		/** @type {import('types/page').LoadInput | import('types/page').ErrorLoadInput} */
+		const load_input = {
+			url: url_proxy,
+			params,
+			get session() {
+				uses_credentials = true;
+				return $session;
+			},
+			/**
+			 * @param {RequestInfo} resource
+			 * @param {RequestInit} opts
+			 */
+			fetch: async (resource, opts = {}) => {
+				/** @type {string} */
+				let requested;
+				if (typeof resource === 'string') {
+					requested = resource;
+				} else {
+					requested = resource.url;
+					opts = {
+						method: resource.method,
+						headers: resource.headers,
+						body: resource.body,
+						mode: resource.mode,
+						credentials: resource.credentials,
+						cache: resource.cache,
+						redirect: resource.redirect,
+						referrer: resource.referrer,
+						integrity: resource.integrity,
+						...opts
+					};
+				}
+				opts.headers = new Headers(opts.headers);
+				const resolved = resolve(request.url.pathname, requested.split('?')[0]);
+				let response;
+				// handle fetch requests for static assets. e.g. prebaked data, etc.
+				// we need to support everything the browser's fetch supports
+				const prefix = options.paths.assets || options.paths.base;
+				const filename = (
+					resolved.startsWith(prefix) ? resolved.slice(prefix.length) : resolved
+				).slice(1);
+				const filename_html = `${filename}/index.html`; // path may also match path/index.html
+				const is_asset = options.manifest.assets.has(filename);
+				const is_asset_html = options.manifest.assets.has(filename_html);
+				if (is_asset || is_asset_html) {
+					const file = is_asset ? filename : filename_html;
+					if (options.read) {
+						const type = is_asset
+							? options.manifest._.mime[filename.slice(filename.lastIndexOf('.'))]
+							: 'text/html';
+						response = new Response(options.read(file), {
+							headers: type ? { 'content-type': type } : {}
+						});
+					} else {
+						response = await fetch(`${url.origin}/${file}`, /** @type {RequestInit} */ (opts));
+					}
+				} else if (is_root_relative(resolved)) {
+					const relative = resolved;
+					// TODO: fix type https://github.com/node-fetch/node-fetch/issues/1113
+					if (opts.credentials !== 'omit') {
+						uses_credentials = true;
+						if (request.headers.cookie) {
+							opts.headers.set('cookie', request.headers.cookie);
+						}
+						if (request.headers.authorization && !opts.headers.has('authorization')) {
+							opts.headers.set('authorization', request.headers.authorization);
+						}
+					}
+					if (opts.body && typeof opts.body !== 'string') {
+						// per https://developer.mozilla.org/en-US/docs/Web/API/Request/Request, this can be a
+						// Blob, BufferSource, FormData, URLSearchParams, USVString, or ReadableStream object.
+						// non-string bodies are irksome to deal with, but luckily aren't particularly useful
+						// in this context anyway, so we take the easy route and ban them
+						throw new Error('Request body must be a string');
+					}
+					const rendered = await respond(
+						{
+							url: new URL(requested, request.url),
+							method: opts.method || 'GET',
+							headers: Object.fromEntries(opts.headers),
+							rawBody: opts.body == null ? null : new TextEncoder().encode(opts.body)
+						},
+						options,
+						{
+							fetched: requested,
+							initiator: route
+						}
+					);
+					if (rendered) {
+						if (state.prerender) {
+							state.prerender.dependencies.set(relative, rendered);
+						}
+						// Set-Cookie must be filtered out (done below) and that's the only header value that
+						// can be an array so we know we have only simple values
+						// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+						response = new Response(rendered.body, {
+							status: rendered.status,
+							headers: /** @type {Record<string, string>} */ (rendered.headers)
+						});
+					} else {
+						// we can't load the endpoint from our own manifest,
+						// so we need to make an actual HTTP request
+						return fetch(new URL(requested, request.url).href, {
+							method: opts.method || 'GET',
+							headers: opts.headers
+						});
+					}
+				} else {
+					// external
+					if (resolved.startsWith('//')) {
+						throw new Error(
+							`Cannot request protocol-relative URL (${requested}) in server-side fetch`
+						);
+					}
+					// external fetch
+					// allow cookie passthrough for "same-origin"
+					// if SvelteKit is serving my.domain.com:
+					// -        domain.com WILL NOT receive cookies
+					// -     my.domain.com WILL receive cookies
+					// -    api.domain.dom WILL NOT receive cookies
+					// - sub.my.domain.com WILL receive cookies
+					// ports do not affect the resolution
+					// leading dot prevents mydomain.com matching domain.com
+					if (
+						`.${new URL(requested).hostname}`.endsWith(`.${request.url.hostname}`) &&
+						opts.credentials !== 'omit'
+					) {
+						uses_credentials = true;
+						opts.headers.set('cookie', request.headers.cookie);
+					}
+					const external_request = new Request(requested, /** @type {RequestInit} */ (opts));
+					response = await options.hooks.externalFetch.call(null, external_request);
+				}
+				if (response) {
+					const proxy = new Proxy(response, {
+						get(response, key, _receiver) {
+							async function text() {
+								const body = await response.text();
+								/** @type {import('types/helper').ResponseHeaders} */
+								const headers = {};
+								for (const [key, value] of response.headers) {
+									if (key === 'set-cookie') {
+										set_cookie_headers = set_cookie_headers.concat(value);
+									} else if (key !== 'etag') {
+										headers[key] = value;
+									}
+								}
+								if (!opts.body || typeof opts.body === 'string') {
+									// prettier-ignore
+									fetched.push({
+										url: requested,
+										body: /** @type {string} */ (opts.body),
+										json: `{"status":${response.status},"statusText":${s(response.statusText)},"headers":${s(headers)},"body":"${escape_json_string_in_html(body)}"}`
+									});
+								}
+								return body;
+							}
+							if (key === 'text') {
+								return text;
+							}
+							if (key === 'json') {
+								return async () => {
+									return JSON.parse(await text());
+								};
+							}
+							// TODO arrayBuffer?
+							return Reflect.get(response, key, response);
+						}
+					});
+					return proxy;
+				}
+				return (
+					response ||
+					new Response('Not found', {
+						status: 404
+					})
+				);
+			},
+			stuff: { ...stuff }
+		};
+		if (options.dev) {
+			// TODO remove this for 1.0
+			Object.defineProperty(load_input, 'page', {
+				get: () => {
+					throw new Error('`page` in `load` functions has been replaced by `url` and `params`');
+				}
+			});
+		}
+		if (is_error) {
+			/** @type {import('types/page').ErrorLoadInput} */ (load_input).status = status;
+			/** @type {import('types/page').ErrorLoadInput} */ (load_input).error = error;
+		}
+		loaded = await module.load.call(null, load_input);
+	} else {
+		loaded = {};
+	}
+	// if leaf node (i.e. page component) has a load function
+	// that returns nothing, we fall through to the next one
+	if (!loaded && is_leaf && !is_error) return;
+	if (!loaded) {
+		throw new Error(`${node.entry} - load must return a value except for page fall through`);
+	}
+	return {
+		node,
+		loaded: normalize(loaded),
+		stuff: loaded.stuff || stuff,
+		fetched,
+		set_cookie_headers,
+		uses_credentials
+	};
+}
+/**
+ * @typedef {import('./types.js').Loaded} Loaded
+ * @typedef {import('types/internal').SSRNode} SSRNode
+ * @typedef {import('types/internal').SSRRenderOptions} SSRRenderOptions
+ * @typedef {import('types/internal').SSRRenderState} SSRRenderState
+ */
+/**
+ * @param {{
+ *   request: import('types/hooks').ServerRequest;
+ *   options: SSRRenderOptions;
+ *   state: SSRRenderState;
+ *   $session: any;
+ *   status: number;
+ *   error: Error;
+ * }} opts
+ */
+async function respond_with_error({ request, options, state, $session, status, error }) {
+	const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
+	const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
+	/** @type {Record<string, string>} */
+	const params = {}; // error page has no params
+	// error pages don't fall through, so we know it's not undefined
+	const loaded = /** @type {Loaded} */ (
+		await load_node({
+			request,
+			options,
+			state,
+			route: null,
+			url: request.url, // TODO this is redundant, no?
+			params,
+			node: default_layout,
+			$session,
+			stuff: {},
+			prerender_enabled: is_prerender_enabled(options, default_error, state),
+			is_leaf: false,
+			is_error: false
+		})
+	);
+	const branch = [
+		loaded,
+		/** @type {Loaded} */ (
+			await load_node({
+				request,
+				options,
+				state,
+				route: null,
+				url: request.url,
+				params,
+				node: default_error,
+				$session,
+				stuff: loaded ? loaded.stuff : {},
+				prerender_enabled: is_prerender_enabled(options, default_error, state),
+				is_leaf: false,
+				is_error: true,
+				status,
+				error
+			})
+		)
+	];
+	try {
+		return await render_response({
+			options,
+			$session,
+			page_config: {
+				hydrate: options.hydrate,
+				router: options.router,
+				ssr: options.ssr
+			},
+			status,
+			error,
+			branch,
+			url: request.url,
+			params
+		});
+	} catch (err) {
+		const error = coalesce_to_error(err);
+		options.handle_error(error, request);
+		return {
+			status: 500,
+			headers: {},
+			body: error.stack
+		};
+	}
+}
+/**
+ * @param {SSRRenderOptions} options
+ * @param {SSRNode} node
+ * @param {SSRRenderState} state
+ */
+function is_prerender_enabled(options, node, state) {
+	return (
+		options.prerender && (!!node.module.prerender || (!!state.prerender && state.prerender.all))
+	);
+}
+/**
+ * @typedef {import('./types.js').Loaded} Loaded
+ * @typedef {import('types/hooks').ServerResponse} ServerResponse
+ * @typedef {import('types/internal').SSRNode} SSRNode
+ * @typedef {import('types/internal').SSRRenderOptions} SSRRenderOptions
+ * @typedef {import('types/internal').SSRRenderState} SSRRenderState
+ */
+/**
+ * @param {{
+ *   request: import('types/hooks').ServerRequest;
+ *   options: SSRRenderOptions;
+ *   state: SSRRenderState;
+ *   $session: any;
+ *   route: import('types/internal').SSRPage;
+ *   params: Record<string, string>;
+ * }} opts
+ * @returns {Promise<ServerResponse | undefined>}
+ */
+async function respond$1(opts) {
+	const { request, options, state, $session, route } = opts;
+	/** @type {Array<SSRNode | undefined>} */
+	let nodes;
+	try {
+		nodes = await Promise.all(
+			route.a.map((n) => options.manifest._.nodes[n] && options.manifest._.nodes[n]())
+		);
+	} catch (err) {
+		const error = coalesce_to_error(err);
+		options.handle_error(error, request);
+		return await respond_with_error({
+			request,
+			options,
+			state,
+			$session,
+			status: 500,
+			error
+		});
+	}
+	// the leaf node will be present. only layouts may be undefined
+	const leaf = /** @type {SSRNode} */ (nodes[nodes.length - 1]).module;
+	let page_config = get_page_config(leaf, options);
+	if (!leaf.prerender && state.prerender && !state.prerender.all) {
+		// if the page has `export const prerender = true`, continue,
+		// otherwise bail out at this point
+		return {
+			status: 204,
+			headers: {}
+		};
+	}
+	/** @type {Array<Loaded>} */
+	let branch = [];
+	/** @type {number} */
+	let status = 200;
+	/** @type {Error|undefined} */
+	let error;
+	/** @type {string[]} */
+	let set_cookie_headers = [];
+	ssr: if (page_config.ssr) {
+		let stuff = {};
+		for (let i = 0; i < nodes.length; i += 1) {
+			const node = nodes[i];
+			/** @type {Loaded | undefined} */
+			let loaded;
+			if (node) {
+				try {
+					loaded = await load_node({
+						...opts,
+						url: request.url,
+						node,
+						stuff,
+						prerender_enabled: is_prerender_enabled(options, node, state),
+						is_leaf: i === nodes.length - 1,
+						is_error: false
+					});
+					if (!loaded) return;
+					set_cookie_headers = set_cookie_headers.concat(loaded.set_cookie_headers);
+					if (loaded.loaded.redirect) {
+						return with_cookies(
+							{
+								status: loaded.loaded.status,
+								headers: {
+									location: encodeURI(loaded.loaded.redirect)
+								}
+							},
+							set_cookie_headers
+						);
+					}
+					if (loaded.loaded.error) {
+						({ status, error } = loaded.loaded);
+					}
+				} catch (err) {
+					const e = coalesce_to_error(err);
+					options.handle_error(e, request);
+					status = 500;
+					error = e;
+				}
+				if (loaded && !error) {
+					branch.push(loaded);
+				}
+				if (error) {
+					while (i--) {
+						if (route.b[i]) {
+							const error_node = await options.manifest._.nodes[route.b[i]]();
+							/** @type {Loaded} */
+							let node_loaded;
+							let j = i;
+							while (!(node_loaded = branch[j])) {
+								j -= 1;
+							}
+							try {
+								// there's no fallthough on an error page, so we know it's not undefined
+								const error_loaded = /** @type {import('./types').Loaded} */ (
+									await load_node({
+										...opts,
+										url: request.url,
+										node: error_node,
+										stuff: node_loaded.stuff,
+										prerender_enabled: is_prerender_enabled(options, error_node, state),
+										is_leaf: false,
+										is_error: true,
+										status,
+										error
+									})
+								);
+								if (error_loaded.loaded.error) {
+									continue;
+								}
+								page_config = get_page_config(error_node.module, options);
+								branch = branch.slice(0, j + 1).concat(error_loaded);
+								break ssr;
+							} catch (err) {
+								const e = coalesce_to_error(err);
+								options.handle_error(e, request);
+								continue;
+							}
+						}
+					}
+					// TODO backtrack until we find an __error.svelte component
+					// that we can use as the leaf node
+					// for now just return regular error page
+					return with_cookies(
+						await respond_with_error({
+							request,
+							options,
+							state,
+							$session,
+							status,
+							error
+						}),
+						set_cookie_headers
+					);
+				}
+			}
+			if (loaded && loaded.loaded.stuff) {
+				stuff = {
+					...stuff,
+					...loaded.loaded.stuff
+				};
+			}
+		}
+	}
+	try {
+		return with_cookies(
+			await render_response({
+				...opts,
+				url: request.url,
+				page_config,
+				status,
+				error,
+				branch: branch.filter(Boolean)
+			}),
+			set_cookie_headers
+		);
+	} catch (err) {
+		const error = coalesce_to_error(err);
+		options.handle_error(error, request);
+		return with_cookies(
+			await respond_with_error({
+				...opts,
+				status: 500,
+				error
+			}),
+			set_cookie_headers
+		);
+	}
+}
+/**
+ * @param {import('types/internal').SSRComponent} leaf
+ * @param {SSRRenderOptions} options
+ */
+function get_page_config(leaf, options) {
+	return {
+		ssr: 'ssr' in leaf ? !!leaf.ssr : options.ssr,
+		router: 'router' in leaf ? !!leaf.router : options.router,
+		hydrate: 'hydrate' in leaf ? !!leaf.hydrate : options.hydrate
+	};
+}
+/**
+ * @param {ServerResponse} response
+ * @param {string[]} set_cookie_headers
+ */
+function with_cookies(response, set_cookie_headers) {
+	if (set_cookie_headers.length) {
+		response.headers['set-cookie'] = set_cookie_headers;
+	}
+	return response;
+}
+/**
+ * @param {import('types/hooks').ServerRequest} request
+ * @param {import('types/internal').SSRPage} route
+ * @param {RegExpExecArray} match
+ * @param {import('types/internal').SSRRenderOptions} options
+ * @param {import('types/internal').SSRRenderState} state
+ * @returns {Promise<import('types/hooks').ServerResponse | undefined>}
+ */
+async function render_page(request, route, match, options, state) {
+	if (state.initiator === route) {
+		// infinite request cycle detected
+		return {
+			status: 404,
+			headers: {},
+			body: `Not found: ${request.url.pathname}`
+		};
+	}
+	const params = route.params ? decode_params(route.params(match)) : {};
+	const $session = await options.hooks.getSession(request);
+	const response = await respond$1({
+		request,
+		options,
+		state,
+		$session,
+		route,
+		params
+	});
+	if (response) {
+		return response;
+	}
+	if (state.fetched) {
+		// we came here because of a bad request in a `load` function.
+		// rather than render the error page — which could lead to an
+		// infinite loop, if the `load` belonged to the root layout,
+		// we respond with a bare-bones 500
+		return {
+			status: 500,
+			headers: {},
+			body: `Bad request in load function: failed to fetch ${state.fetched}`
+		};
+	}
+}
+function read_only_form_data() {
+	/** @type {Map<string, string[]>} */
+	const map = new Map();
+	return {
+		/**
+		 * @param {string} key
+		 * @param {string} value
+		 */
+		append(key, value) {
+			if (map.has(key)) {
+				(map.get(key) || []).push(value);
+			} else {
+				map.set(key, [value]);
+			}
+		},
+		data: new ReadOnlyFormData(map)
+	};
+}
+class ReadOnlyFormData {
+	/** @type {Map<string, string[]>} */
+	#map;
+	/** @param {Map<string, string[]>} map */
+	constructor(map) {
+		this.#map = map;
+	}
+	/** @param {string} key */
+	get(key) {
+		const value = this.#map.get(key);
+		return value && value[0];
+	}
+	/** @param {string} key */
+	getAll(key) {
+		return this.#map.get(key);
+	}
+	/** @param {string} key */
+	has(key) {
+		return this.#map.has(key);
+	}
+	*[Symbol.iterator]() {
+		for (const [key, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield [key, value[i]];
+			}
+		}
+	}
+	*entries() {
+		for (const [key, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield [key, value[i]];
+			}
+		}
+	}
+	*keys() {
+		for (const [key] of this.#map) yield key;
+	}
+	*values() {
+		for (const [, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield value[i];
+			}
+		}
+	}
+}
+/**
+ * @param {import('types/app').RawBody} raw
+ * @param {import('types/helper').RequestHeaders} headers
+ */
+function parse_body(raw, headers) {
+	if (!raw) return raw;
+	const content_type = headers['content-type'];
+	const [type, ...directives] = content_type ? content_type.split(/;\s*/) : [];
+	const text = () => new TextDecoder(headers['content-encoding'] || 'utf-8').decode(raw);
+	switch (type) {
+		case 'text/plain':
+			return text();
+		case 'application/json':
+			return JSON.parse(text());
+		case 'application/x-www-form-urlencoded':
+			return get_urlencoded(text());
+		case 'multipart/form-data': {
+			const boundary = directives.find((directive) => directive.startsWith('boundary='));
+			if (!boundary) throw new Error('Missing boundary');
+			return get_multipart(text(), boundary.slice('boundary='.length));
+		}
+		default:
+			return raw;
+	}
+}
+/** @param {string} text */
+function get_urlencoded(text) {
+	const { data, append } = read_only_form_data();
+	text
+		.replace(/\+/g, ' ')
+		.split('&')
+		.forEach((str) => {
+			const [key, value] = str.split('=');
+			append(decodeURIComponent(key), decodeURIComponent(value));
+		});
+	return data;
+}
+/**
+ * @param {string} text
+ * @param {string} boundary
+ */
+function get_multipart(text, boundary) {
+	const parts = text.split(`--${boundary}`);
+	if (parts[0] !== '' || parts[parts.length - 1].trim() !== '--') {
+		throw new Error('Malformed form data');
+	}
+	const { data, append } = read_only_form_data();
+	parts.slice(1, -1).forEach((part) => {
+		const match = /\s*([\s\S]+?)\r\n\r\n([\s\S]*)\s*/.exec(part);
+		if (!match) {
+			throw new Error('Malformed form data');
+		}
+		const raw_headers = match[1];
+		const body = match[2].trim();
+		let key;
+		/** @type {Record<string, string>} */
+		const headers = {};
+		raw_headers.split('\r\n').forEach((str) => {
+			const [raw_header, ...raw_directives] = str.split('; ');
+			let [name, value] = raw_header.split(': ');
+			name = name.toLowerCase();
+			headers[name] = value;
+			/** @type {Record<string, string>} */
+			const directives = {};
+			raw_directives.forEach((raw_directive) => {
+				const [name, value] = raw_directive.split('=');
+				directives[name] = JSON.parse(value); // TODO is this right?
+			});
+			if (name === 'content-disposition') {
+				if (value !== 'form-data') throw new Error('Malformed form data');
+				if (directives.filename) {
+					// TODO we probably don't want to do this automatically
+					throw new Error('File upload is not yet implemented');
+				}
+				if (directives.name) {
+					key = directives.name;
+				}
+			}
+		});
+		if (!key) throw new Error('Malformed form data');
+		append(key, body);
+	});
+	return data;
+}
+/** @type {import('@sveltejs/kit/ssr').Respond} */
+async function respond(incoming, options, state = {}) {
+	if (incoming.url.pathname !== '/' && options.trailing_slash !== 'ignore') {
+		const has_trailing_slash = incoming.url.pathname.endsWith('/');
+		if (
+			(has_trailing_slash && options.trailing_slash === 'never') ||
+			(!has_trailing_slash &&
+				options.trailing_slash === 'always' &&
+				!(incoming.url.pathname.split('/').pop() || '').includes('.'))
+		) {
+			incoming.url.pathname = has_trailing_slash
+				? incoming.url.pathname.slice(0, -1)
+				: incoming.url.pathname + '/';
+			if (incoming.url.search === '?') incoming.url.search = '';
+			return {
+				status: 301,
+				headers: {
+					location: incoming.url.pathname + incoming.url.search
+				}
+			};
+		}
+	}
+	const headers = lowercase_keys(incoming.headers);
+	const request = {
+		...incoming,
+		headers,
+		body: parse_body(incoming.rawBody, headers),
+		params: {},
+		locals: {}
+	};
+	// TODO remove this for 1.0
+	/**
+	 * @param {string} property
+	 * @param {string} replacement
+	 */
+	const print_error = (property, replacement) => {
+		Object.defineProperty(request, property, {
+			get: () => {
+				throw new Error(`request.${property} has been replaced by request.url.${replacement}`);
+			}
+		});
+	};
+	print_error('origin', 'origin');
+	print_error('path', 'pathname');
+	print_error('query', 'searchParams');
+	try {
+		return await options.hooks.handle({
+			request,
+			resolve: async (request) => {
+				if (state.prerender && state.prerender.fallback) {
+					return await render_response({
+						url: request.url,
+						params: request.params,
+						options,
+						$session: await options.hooks.getSession(request),
+						page_config: { ssr: false, router: true, hydrate: true },
+						status: 200,
+						branch: []
+					});
+				}
+				const decoded = decodeURI(request.url.pathname).replace(options.paths.base, '');
+				for (const route of options.manifest._.routes) {
+					const match = route.pattern.exec(decoded);
+					if (!match) continue;
+					const response =
+						route.type === 'endpoint'
+							? await render_endpoint(request, route, match)
+							: await render_page(request, route, match, options, state);
+					if (response) {
+						// inject ETags for 200 responses
+						if (response.status === 200) {
+							const cache_control = get_single_valued_header(response.headers, 'cache-control');
+							if (!cache_control || !/(no-store|immutable)/.test(cache_control)) {
+								let if_none_match_value = request.headers['if-none-match'];
+								// ignore W/ prefix https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match#directives
+								if (if_none_match_value?.startsWith('W/"')) {
+									if_none_match_value = if_none_match_value.substring(2);
+								}
+								const etag = `"${hash(response.body || '')}"`;
+								if (if_none_match_value === etag) {
+									return {
+										status: 304,
+										headers: {}
+									};
+								}
+								response.headers['etag'] = etag;
+							}
+						}
+						return response;
+					}
+				}
+				// if this request came direct from the user, rather than
+				// via a `fetch` in a `load`, render a 404 page
+				if (!state.initiator) {
+					const $session = await options.hooks.getSession(request);
+					return await respond_with_error({
+						request,
+						options,
+						state,
+						$session,
+						status: 404,
+						error: new Error(`Not found: ${request.url.pathname}`)
+					});
+				}
+			}
+		});
+	} catch (/** @type {unknown} */ err) {
+		const e = coalesce_to_error(err);
+		options.handle_error(e, request);
+		return {
+			status: 500,
+			headers: {},
+			body: options.dev ? e.stack : e.message
+		};
+	}
+}
+export { respond };

.svelte-kit/build/runtime/app/env.js ADDED Viewed

	@@ -0,0 +1,20 @@

+export { prerendering } from '../env.js';
+/**
+ * @type {import('$app/env').browser}
+ */
+const browser = !import.meta.env.SSR;
+/**
+ * @type {import('$app/env').dev}
+ */
+const dev = !!import.meta.env.DEV;
+/**
+ * @type {import('$app/env').mode}
+ */
+const mode = import.meta.env.MODE;
+/**
+ * @type {import('$app/env').amp}
+ */
+const amp = !!import.meta.env.VITE_SVELTEKIT_AMP;
+export { amp, browser, dev, mode };

.svelte-kit/build/runtime/app/navigation.js ADDED Viewed

	@@ -0,0 +1,65 @@

+import { renderer, router as router$1 } from '../internal/singletons.js';
+import { g as get_base_uri } from '../chunks/utils.js';
+const router = /** @type {import('../client/router').Router} */ (router$1);
+/**
+ * @param {string} name
+ */
+function guard(name) {
+	return () => {
+		throw new Error(`Cannot call ${name}(...) on the server`);
+	};
+}
+const disableScrollHandling = import.meta.env.SSR
+	? guard('disableScrollHandling')
+	: disableScrollHandling_;
+const goto = import.meta.env.SSR ? guard('goto') : goto_;
+const invalidate = import.meta.env.SSR ? guard('invalidate') : invalidate_;
+const prefetch = import.meta.env.SSR ? guard('prefetch') : prefetch_;
+const prefetchRoutes = import.meta.env.SSR ? guard('prefetchRoutes') : prefetchRoutes_;
+/**
+ * @type {import('$app/navigation').goto}
+ */
+async function disableScrollHandling_() {
+	renderer.disable_scroll_handling();
+}
+/**
+ * @type {import('$app/navigation').goto}
+ */
+async function goto_(href, opts) {
+	return router.goto(href, opts, []);
+}
+/**
+ * @type {import('$app/navigation').invalidate}
+ */
+async function invalidate_(resource) {
+	const { href } = new URL(resource, location.href);
+	return router.renderer.invalidate(href);
+}
+/**
+ * @type {import('$app/navigation').prefetch}
+ */
+function prefetch_(href) {
+	return router.prefetch(new URL(href, get_base_uri(document)));
+}
+/**
+ * @type {import('$app/navigation').prefetchRoutes}
+ */
+async function prefetchRoutes_(pathnames) {
+	const matching = pathnames
+		? router.routes.filter((route) => pathnames.some((pathname) => route[0].test(pathname)))
+		: router.routes;
+	const promises = matching.map((r) => Promise.all(r[1].map((load) => load())));
+	await Promise.all(promises);
+}
+export { disableScrollHandling, goto, invalidate, prefetch, prefetchRoutes };

.svelte-kit/build/runtime/app/paths.js ADDED Viewed

	@@ -0,0 +1 @@


1	+ export { assets, base } from '../paths.js';

.svelte-kit/build/runtime/app/stores.js ADDED Viewed

	@@ -0,0 +1,84 @@

+import { getContext } from 'svelte';
+import { browser } from './env.js';
+import '../env.js';
+const ssr = !browser;
+// TODO remove this (for 1.0? after 1.0?)
+let warned = false;
+function stores() {
+	if (!warned) {
+		console.error('stores() is deprecated; use getStores() instead');
+		warned = true;
+	}
+	return getStores();
+}
+/**
+ * @type {import('$app/stores').getStores}
+ */
+const getStores = () => {
+	const stores = getContext('__svelte__');
+	return {
+		page: {
+			subscribe: stores.page.subscribe
+		},
+		navigating: {
+			subscribe: stores.navigating.subscribe
+		},
+		// TODO remove this (for 1.0? after 1.0?)
+		// @ts-expect-error - deprecated, not part of type definitions, but still callable
+		get preloading() {
+			console.error('stores.preloading is deprecated; use stores.navigating instead');
+			return {
+				subscribe: stores.navigating.subscribe
+			};
+		},
+		session: stores.session
+	};
+};
+/** @type {typeof import('$app/stores').page} */
+const page = {
+	/** @param {(value: any) => void} fn */
+	subscribe(fn) {
+		const store = getStores().page;
+		return store.subscribe(fn);
+	}
+};
+/** @type {typeof import('$app/stores').navigating} */
+const navigating = {
+	subscribe(fn) {
+		const store = getStores().navigating;
+		return store.subscribe(fn);
+	}
+};
+/** @param {string} verb */
+const throw_error = (verb) => {
+	throw new Error(
+		ssr
+			? `Can only ${verb} session store in browser`
+			: `Cannot ${verb} session store before subscribing`
+	);
+};
+/** @type {typeof import('$app/stores').session} */
+const session = {
+	subscribe(fn) {
+		const store = getStores().session;
+		if (!ssr) {
+			session.set = store.set;
+			session.update = store.update;
+		}
+		return store.subscribe(fn);
+	},
+	set: () => throw_error('set'),
+	update: () => throw_error('update')
+};
+export { getStores, navigating, page, session, stores };

.svelte-kit/build/runtime/chunks/utils.js ADDED Viewed

	@@ -0,0 +1,13 @@

+/** @param {HTMLDocument} doc */
+function get_base_uri(doc) {
+	let baseURI = doc.baseURI;
+	if (!baseURI) {
+		const baseTags = doc.getElementsByTagName('base');
+		baseURI = baseTags.length ? baseTags[0].href : doc.URL;
+	}
+	return baseURI;
+}
+export { get_base_uri as g };

.svelte-kit/build/runtime/env.js ADDED Viewed

	@@ -0,0 +1,8 @@

+let prerendering = false;
+/** @param {boolean} value */
+function set_prerendering(value) {
+	prerendering = value;
+}
+export { prerendering, set_prerendering };

.svelte-kit/build/runtime/internal/singletons.js ADDED Viewed

	@@ -0,0 +1,18 @@

+/** @type {import('./router').Router?} */
+let router;
+/** @type {import('./renderer').Renderer} */
+let renderer;
+/**
+ * @param {{
+ *   router: import('./router').Router?;
+ *   renderer: import('./renderer').Renderer;
+ * }} opts
+ */
+function init(opts) {
+	router = opts.router;
+	renderer = opts.renderer;
+}
+export { init, renderer, router };

.svelte-kit/build/runtime/internal/start.js ADDED Viewed

	@@ -0,0 +1,1219 @@

+import Root from '../../generated/root.svelte';
+import { fallback, routes } from '../../generated/manifest.js';
+import { g as get_base_uri } from '../chunks/utils.js';
+import { tick } from 'svelte';
+import { writable } from 'svelte/store';
+import { init } from './singletons.js';
+import { set_paths } from '../paths.js';
+function scroll_state() {
+	return {
+		x: pageXOffset,
+		y: pageYOffset
+	};
+}
+/**
+ * @param {Event} event
+ * @returns {HTMLAnchorElement | SVGAElement | undefined}
+ */
+function find_anchor(event) {
+	const node = event
+		.composedPath()
+		.find((e) => e instanceof Node && e.nodeName.toUpperCase() === 'A'); // SVG <a> elements have a lowercase name
+	return /** @type {HTMLAnchorElement | SVGAElement | undefined} */ (node);
+}
+/**
+ * @param {HTMLAnchorElement | SVGAElement} node
+ * @returns {URL}
+ */
+function get_href(node) {
+	return node instanceof SVGAElement
+		? new URL(node.href.baseVal, document.baseURI)
+		: new URL(node.href);
+}
+class Router {
+	/**
+	 * @param {{
+	 *    base: string;
+	 *    routes: import('types/internal').CSRRoute[];
+	 *    trailing_slash: import('types/internal').TrailingSlash;
+	 *    renderer: import('./renderer').Renderer
+	 * }} opts
+	 */
+	constructor({ base, routes, trailing_slash, renderer }) {
+		this.base = base;
+		this.routes = routes;
+		this.trailing_slash = trailing_slash;
+		/** Keeps tracks of multiple navigations caused by redirects during rendering */
+		this.navigating = 0;
+		/** @type {import('./renderer').Renderer} */
+		this.renderer = renderer;
+		renderer.router = this;
+		this.enabled = true;
+		// make it possible to reset focus
+		document.body.setAttribute('tabindex', '-1');
+		// create initial history entry, so we can return here
+		history.replaceState(history.state || {}, '', location.href);
+	}
+	init_listeners() {
+		if ('scrollRestoration' in history) {
+			history.scrollRestoration = 'manual';
+		}
+		// Adopted from Nuxt.js
+		// Reset scrollRestoration to auto when leaving page, allowing page reload
+		// and back-navigation from other pages to use the browser to restore the
+		// scrolling position.
+		addEventListener('beforeunload', () => {
+			history.scrollRestoration = 'auto';
+		});
+		// Setting scrollRestoration to manual again when returning to this page.
+		addEventListener('load', () => {
+			history.scrollRestoration = 'manual';
+		});
+		// There's no API to capture the scroll location right before the user
+		// hits the back/forward button, so we listen for scroll events
+		/** @type {NodeJS.Timeout} */
+		let scroll_timer;
+		addEventListener('scroll', () => {
+			clearTimeout(scroll_timer);
+			scroll_timer = setTimeout(() => {
+				// Store the scroll location in the history
+				// This will persist even if we navigate away from the site and come back
+				const new_state = {
+					...(history.state || {}),
+					'sveltekit:scroll': scroll_state()
+				};
+				history.replaceState(new_state, document.title, window.location.href);
+				// iOS scroll event intervals happen between 30-150ms, sometimes around 200ms
+			}, 200);
+		});
+		/** @param {Event} event */
+		const trigger_prefetch = (event) => {
+			const a = find_anchor(event);
+			if (a && a.href && a.hasAttribute('sveltekit:prefetch')) {
+				this.prefetch(get_href(a));
+			}
+		};
+		/** @type {NodeJS.Timeout} */
+		let mousemove_timeout;
+		/** @param {MouseEvent|TouchEvent} event */
+		const handle_mousemove = (event) => {
+			clearTimeout(mousemove_timeout);
+			mousemove_timeout = setTimeout(() => {
+				// event.composedPath(), which is used in find_anchor, will be empty if the event is read in a timeout
+				// add a layer of indirection to address that
+				event.target?.dispatchEvent(
+					new CustomEvent('sveltekit:trigger_prefetch', { bubbles: true })
+				);
+			}, 20);
+		};
+		addEventListener('touchstart', trigger_prefetch);
+		addEventListener('mousemove', handle_mousemove);
+		addEventListener('sveltekit:trigger_prefetch', trigger_prefetch);
+		/** @param {MouseEvent} event */
+		addEventListener('click', (event) => {
+			if (!this.enabled) return;
+			// Adapted from https://github.com/visionmedia/page.js
+			// MIT license https://github.com/visionmedia/page.js#license
+			if (event.button || event.which !== 1) return;
+			if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+			if (event.defaultPrevented) return;
+			const a = find_anchor(event);
+			if (!a) return;
+			if (!a.href) return;
+			const url = get_href(a);
+			const url_string = url.toString();
+			if (url_string === location.href) {
+				if (!location.hash) event.preventDefault();
+				return;
+			}
+			// Ignore if tag has
+			// 1. 'download' attribute
+			// 2. 'rel' attribute includes external
+			const rel = (a.getAttribute('rel') || '').split(/\s+/);
+			if (a.hasAttribute('download') || (rel && rel.includes('external'))) {
+				return;
+			}
+			// Ignore if <a> has a target
+			if (a instanceof SVGAElement ? a.target.baseVal : a.target) return;
+			if (!this.owns(url)) return;
+			// Check if new url only differs by hash
+			if (url.href.split('#')[0] === location.href.split('#')[0]) {
+				// Call `pushState` to add url to history so going back works.
+				// Also make a delay, otherwise the browser default behaviour would not kick in
+				setTimeout(() => history.pushState({}, '', url.href));
+				return;
+			}
+			history.pushState({}, '', url.href);
+			const noscroll = a.hasAttribute('sveltekit:noscroll');
+			this._navigate(url, noscroll ? scroll_state() : null, false, [], url.hash);
+			event.preventDefault();
+		});
+		addEventListener('popstate', (event) => {
+			if (event.state && this.enabled) {
+				const url = new URL(location.href);
+				this._navigate(url, event.state['sveltekit:scroll'], false, []);
+			}
+		});
+	}
+	/** @param {URL} url */
+	owns(url) {
+		return url.origin === location.origin && url.pathname.startsWith(this.base);
+	}
+	/**
+	 * @param {URL} url
+	 * @returns {import('./types').NavigationInfo | undefined}
+	 */
+	parse(url) {
+		if (this.owns(url)) {
+			const path = decodeURI(url.pathname.slice(this.base.length) || '/');
+			return {
+				id: url.pathname + url.search,
+				routes: this.routes.filter(([pattern]) => pattern.test(path)),
+				url,
+				path
+			};
+		}
+	}
+	/**
+	 * @typedef {Parameters<typeof import('$app/navigation').goto>} GotoParams
+	 *
+	 * @param {GotoParams[0]} href
+	 * @param {GotoParams[1]} opts
+	 * @param {string[]} chain
+	 */
+	async goto(
+		href,
+		{ noscroll = false, replaceState = false, keepfocus = false, state = {} } = {},
+		chain
+	) {
+		const url = new URL(href, get_base_uri(document));
+		if (this.enabled && this.owns(url)) {
+			history[replaceState ? 'replaceState' : 'pushState'](state, '', href);
+			return this._navigate(url, noscroll ? scroll_state() : null, keepfocus, chain, url.hash);
+		}
+		location.href = url.href;
+		return new Promise(() => {
+			/* never resolves */
+		});
+	}
+	enable() {
+		this.enabled = true;
+	}
+	disable() {
+		this.enabled = false;
+	}
+	/**
+	 * @param {URL} url
+	 * @returns {Promise<import('./types').NavigationResult>}
+	 */
+	async prefetch(url) {
+		const info = this.parse(url);
+		if (!info) {
+			throw new Error('Attempted to prefetch a URL that does not belong to this app');
+		}
+		return this.renderer.load(info);
+	}
+	/**
+	 * @param {URL} url
+	 * @param {{ x: number, y: number }?} scroll
+	 * @param {boolean} keepfocus
+	 * @param {string[]} chain
+	 * @param {string} [hash]
+	 */
+	async _navigate(url, scroll, keepfocus, chain, hash) {
+		const info = this.parse(url);
+		if (!info) {
+			throw new Error('Attempted to navigate to a URL that does not belong to this app');
+		}
+		if (!this.navigating) {
+			dispatchEvent(new CustomEvent('sveltekit:navigation-start'));
+		}
+		this.navigating++;
+		let { pathname } = url;
+		if (this.trailing_slash === 'never') {
+			if (pathname !== '/' && pathname.endsWith('/')) pathname = pathname.slice(0, -1);
+		} else if (this.trailing_slash === 'always') {
+			const is_file = /** @type {string} */ (url.pathname.split('/').pop()).includes('.');
+			if (!is_file && !pathname.endsWith('/')) pathname += '/';
+		}
+		info.url = new URL(url.origin + pathname + url.search + url.hash);
+		history.replaceState({}, '', info.url);
+		await this.renderer.handle_navigation(info, chain, false, { hash, scroll, keepfocus });
+		this.navigating--;
+		if (!this.navigating) {
+			dispatchEvent(new CustomEvent('sveltekit:navigation-end'));
+		}
+	}
+}
+/**
+ * @param {unknown} err
+ * @return {Error}
+ */
+function coalesce_to_error(err) {
+	return err instanceof Error ||
+		(err && /** @type {any} */ (err).name && /** @type {any} */ (err).message)
+		? /** @type {Error} */ (err)
+		: new Error(JSON.stringify(err));
+}
+/**
+ * Hash using djb2
+ * @param {import('types/hooks').StrictBody} value
+ */
+function hash(value) {
+	let hash = 5381;
+	let i = value.length;
+	if (typeof value === 'string') {
+		while (i) hash = (hash * 33) ^ value.charCodeAt(--i);
+	} else {
+		while (i) hash = (hash * 33) ^ value[--i];
+	}
+	return (hash >>> 0).toString(36);
+}
+/**
+ * @param {import('types/page').LoadOutput} loaded
+ * @returns {import('types/internal').NormalizedLoadOutput}
+ */
+function normalize(loaded) {
+	const has_error_status =
+		loaded.status && loaded.status >= 400 && loaded.status <= 599 && !loaded.redirect;
+	if (loaded.error || has_error_status) {
+		const status = loaded.status;
+		if (!loaded.error && has_error_status) {
+			return {
+				status: status || 500,
+				error: new Error()
+			};
+		}
+		const error = typeof loaded.error === 'string' ? new Error(loaded.error) : loaded.error;
+		if (!(error instanceof Error)) {
+			return {
+				status: 500,
+				error: new Error(
+					`"error" property returned from load() must be a string or instance of Error, received type "${typeof error}"`
+				)
+			};
+		}
+		if (!status || status < 400 || status > 599) {
+			console.warn('"error" returned from load() without a valid status code — defaulting to 500');
+			return { status: 500, error };
+		}
+		return { status, error };
+	}
+	if (loaded.redirect) {
+		if (!loaded.status || Math.floor(loaded.status / 100) !== 3) {
+			return {
+				status: 500,
+				error: new Error(
+					'"redirect" property returned from load() must be accompanied by a 3xx status code'
+				)
+			};
+		}
+		if (typeof loaded.redirect !== 'string') {
+			return {
+				status: 500,
+				error: new Error('"redirect" property returned from load() must be a string')
+			};
+		}
+	}
+	// TODO remove before 1.0
+	if (/** @type {any} */ (loaded).context) {
+		throw new Error(
+			'You are returning "context" from a load function. ' +
+				'"context" was renamed to "stuff", please adjust your code accordingly.'
+		);
+	}
+	return /** @type {import('types/internal').NormalizedLoadOutput} */ (loaded);
+}
+/**
+ * @typedef {import('types/internal').CSRComponent} CSRComponent
+ * @typedef {{ from: URL; to: URL }} Navigating
+ */
+/** @param {any} value */
+function notifiable_store(value) {
+	const store = writable(value);
+	let ready = true;
+	function notify() {
+		ready = true;
+		store.update((val) => val);
+	}
+	/** @param {any} new_value */
+	function set(new_value) {
+		ready = false;
+		store.set(new_value);
+	}
+	/** @param {(value: any) => void} run */
+	function subscribe(run) {
+		/** @type {any} */
+		let old_value;
+		return store.subscribe((new_value) => {
+			if (old_value === undefined || (ready && new_value !== old_value)) {
+				run((old_value = new_value));
+			}
+		});
+	}
+	return { notify, set, subscribe };
+}
+/**
+ * @param {RequestInfo} resource
+ * @param {RequestInit} [opts]
+ */
+function initial_fetch(resource, opts) {
+	const url = typeof resource === 'string' ? resource : resource.url;
+	let selector = `script[data-type="svelte-data"][data-url=${JSON.stringify(url)}]`;
+	if (opts && typeof opts.body === 'string') {
+		selector += `[data-body="${hash(opts.body)}"]`;
+	}
+	const script = document.querySelector(selector);
+	if (script && script.textContent) {
+		const { body, ...init } = JSON.parse(script.textContent);
+		return Promise.resolve(new Response(body, init));
+	}
+	return fetch(resource, opts);
+}
+class Renderer {
+	/**
+	 * @param {{
+	 *   Root: CSRComponent;
+	 *   fallback: [CSRComponent, CSRComponent];
+	 *   target: Node;
+	 *   session: any;
+	 * }} opts
+	 */
+	constructor({ Root, fallback, target, session }) {
+		this.Root = Root;
+		this.fallback = fallback;
+		/** @type {import('./router').Router | undefined} */
+		this.router;
+		this.target = target;
+		this.started = false;
+		this.session_id = 1;
+		this.invalid = new Set();
+		this.invalidating = null;
+		this.autoscroll = true;
+		this.updating = false;
+		/** @type {import('./types').NavigationState} */
+		this.current = {
+			// @ts-ignore - we need the initial value to be null
+			url: null,
+			session_id: 0,
+			branch: []
+		};
+		/** @type {Map<string, import('./types').NavigationResult>} */
+		this.cache = new Map();
+		/** @type {{id: string | null, promise: Promise<import('./types').NavigationResult> | null}} */
+		this.loading = {
+			id: null,
+			promise: null
+		};
+		this.stores = {
+			url: notifiable_store({}),
+			page: notifiable_store({}),
+			navigating: writable(/** @type {Navigating | null} */ (null)),
+			session: writable(session)
+		};
+		this.$session = null;
+		this.root = null;
+		let ready = false;
+		this.stores.session.subscribe(async (value) => {
+			this.$session = value;
+			if (!ready || !this.router) return;
+			this.session_id += 1;
+			const info = this.router.parse(new URL(location.href));
+			if (info) this.update(info, [], true);
+		});
+		ready = true;
+	}
+	disable_scroll_handling() {
+		if (import.meta.env.DEV && this.started && !this.updating) {
+			throw new Error('Can only disable scroll handling during navigation');
+		}
+		if (this.updating || !this.started) {
+			this.autoscroll = false;
+		}
+	}
+	/**
+	 * @param {{
+	 *   status: number;
+	 *   error: Error;
+	 *   nodes: Array<Promise<CSRComponent>>;
+	 *   url: URL;
+	 *   params: Record<string, string>;
+	 * }} selected
+	 */
+	async start({ status, error, nodes, url, params }) {
+		/** @type {Array<import('./types').BranchNode | undefined>} */
+		const branch = [];
+		/** @type {Record<string, any>} */
+		let stuff = {};
+		/** @type {import('./types').NavigationResult | undefined} */
+		let result;
+		let error_args;
+		try {
+			for (let i = 0; i < nodes.length; i += 1) {
+				const is_leaf = i === nodes.length - 1;
+				const node = await this._load_node({
+					module: await nodes[i],
+					url,
+					params,
+					stuff,
+					status: is_leaf ? status : undefined,
+					error: is_leaf ? error : undefined
+				});
+				branch.push(node);
+				if (node && node.loaded) {
+					if (node.loaded.error) {
+						if (error) throw node.loaded.error;
+						error_args = {
+							status: node.loaded.status,
+							error: node.loaded.error,
+							url
+						};
+					} else if (node.loaded.stuff) {
+						stuff = {
+							...stuff,
+							...node.loaded.stuff
+						};
+					}
+				}
+			}
+			result = error_args
+				? await this._load_error(error_args)
+				: await this._get_navigation_result_from_branch({ url, params, branch, status, error });
+		} catch (e) {
+			if (error) throw e;
+			result = await this._load_error({
+				status: 500,
+				error: coalesce_to_error(e),
+				url
+			});
+		}
+		if (result.redirect) {
+			// this is a real edge case — `load` would need to return
+			// a redirect but only in the browser
+			location.href = new URL(result.redirect, location.href).href;
+			return;
+		}
+		this._init(result);
+	}
+	/**
+	 * @param {import('./types').NavigationInfo} info
+	 * @param {string[]} chain
+	 * @param {boolean} no_cache
+	 * @param {{hash?: string, scroll: { x: number, y: number } | null, keepfocus: boolean}} [opts]
+	 */
+	async handle_navigation(info, chain, no_cache, opts) {
+		if (this.started) {
+			this.stores.navigating.set({
+				from: this.current.url,
+				to: info.url
+			});
+		}
+		await this.update(info, chain, no_cache, opts);
+	}
+	/**
+	 * @param {import('./types').NavigationInfo} info
+	 * @param {string[]} chain
+	 * @param {boolean} no_cache
+	 * @param {{hash?: string, scroll: { x: number, y: number } | null, keepfocus: boolean}} [opts]
+	 */
+	async update(info, chain, no_cache, opts) {
+		const token = (this.token = {});
+		let navigation_result = await this._get_navigation_result(info, no_cache);
+		// abort if user navigated during update
+		if (token !== this.token) return;
+		this.invalid.clear();
+		if (navigation_result.redirect) {
+			if (chain.length > 10 || chain.includes(info.url.pathname)) {
+				navigation_result = await this._load_error({
+					status: 500,
+					error: new Error('Redirect loop'),
+					url: info.url
+				});
+			} else {
+				if (this.router) {
+					this.router.goto(navigation_result.redirect, { replaceState: true }, [
+						...chain,
+						info.url.pathname
+					]);
+				} else {
+					location.href = new URL(navigation_result.redirect, location.href).href;
+				}
+				return;
+			}
+		}
+		this.updating = true;
+		if (this.started) {
+			this.current = navigation_result.state;
+			this.root.$set(navigation_result.props);
+			this.stores.navigating.set(null);
+		} else {
+			this._init(navigation_result);
+		}
+		// opts must be passed if we're navigating
+		if (opts) {
+			const { hash, scroll, keepfocus } = opts;
+			if (!keepfocus) {
+				getSelection()?.removeAllRanges();
+				document.body.focus();
+			}
+			// need to render the DOM before we can scroll to the rendered elements
+			await tick();
+			if (this.autoscroll) {
+				const deep_linked = hash && document.getElementById(hash.slice(1));
+				if (scroll) {
+					scrollTo(scroll.x, scroll.y);
+				} else if (deep_linked) {
+					// Here we use `scrollIntoView` on the element instead of `scrollTo`
+					// because it natively supports the `scroll-margin` and `scroll-behavior`
+					// CSS properties.
+					deep_linked.scrollIntoView();
+				} else {
+					scrollTo(0, 0);
+				}
+			}
+		} else {
+			// in this case we're simply invalidating
+			await tick();
+		}
+		this.loading.promise = null;
+		this.loading.id = null;
+		this.autoscroll = true;
+		this.updating = false;
+		if (!this.router) return;
+		const leaf_node = navigation_result.state.branch[navigation_result.state.branch.length - 1];
+		if (leaf_node && leaf_node.module.router === false) {
+			this.router.disable();
+		} else {
+			this.router.enable();
+		}
+	}
+	/**
+	 * @param {import('./types').NavigationInfo} info
+	 * @returns {Promise<import('./types').NavigationResult>}
+	 */
+	load(info) {
+		this.loading.promise = this._get_navigation_result(info, false);
+		this.loading.id = info.id;
+		return this.loading.promise;
+	}
+	/** @param {string} href */
+	invalidate(href) {
+		this.invalid.add(href);
+		if (!this.invalidating) {
+			this.invalidating = Promise.resolve().then(async () => {
+				const info = this.router && this.router.parse(new URL(location.href));
+				if (info) await this.update(info, [], true);
+				this.invalidating = null;
+			});
+		}
+		return this.invalidating;
+	}
+	/** @param {import('./types').NavigationResult} result */
+	_init(result) {
+		this.current = result.state;
+		const style = document.querySelector('style[data-svelte]');
+		if (style) style.remove();
+		this.root = new this.Root({
+			target: this.target,
+			props: {
+				stores: this.stores,
+				...result.props
+			},
+			hydrate: true
+		});
+		this.started = true;
+	}
+	/**
+	 * @param {import('./types').NavigationInfo} info
+	 * @param {boolean} no_cache
+	 * @returns {Promise<import('./types').NavigationResult>}
+	 */
+	async _get_navigation_result(info, no_cache) {
+		if (this.loading.id === info.id && this.loading.promise) {
+			return this.loading.promise;
+		}
+		for (let i = 0; i < info.routes.length; i += 1) {
+			const route = info.routes[i];
+			// load code for subsequent routes immediately, if they are as
+			// likely to match the current path/query as the current one
+			let j = i + 1;
+			while (j < info.routes.length) {
+				const next = info.routes[j];
+				if (next[0].toString() === route[0].toString()) {
+					next[1].forEach((loader) => loader());
+					j += 1;
+				} else {
+					break;
+				}
+			}
+			const result = await this._load(
+				{
+					route,
+					info
+				},
+				no_cache
+			);
+			if (result) return result;
+		}
+		return await this._load_error({
+			status: 404,
+			error: new Error(`Not found: ${info.url.pathname}`),
+			url: info.url
+		});
+	}
+	/**
+	 *
+	 * @param {{
+	 *   url: URL;
+	 *   params: Record<string, string>;
+	 *   branch: Array<import('./types').BranchNode | undefined>;
+	 *   status: number;
+	 *   error?: Error;
+	 * }} opts
+	 */
+	async _get_navigation_result_from_branch({ url, params, branch, status, error }) {
+		const filtered = /** @type {import('./types').BranchNode[] } */ (branch.filter(Boolean));
+		const redirect = filtered.find((f) => f.loaded && f.loaded.redirect);
+		/** @type {import('./types').NavigationResult} */
+		const result = {
+			redirect: redirect && redirect.loaded ? redirect.loaded.redirect : undefined,
+			state: {
+				url,
+				params,
+				branch,
+				session_id: this.session_id
+			},
+			props: {
+				components: filtered.map((node) => node.module.default)
+			}
+		};
+		for (let i = 0; i < filtered.length; i += 1) {
+			const loaded = filtered[i].loaded;
+			result.props[`props_${i}`] = loaded ? await loaded.props : null;
+		}
+		if (!this.current.url || url.href !== this.current.url.href) {
+			result.props.page = { url, params, status, error };
+			// TODO remove this for 1.0
+			/**
+			 * @param {string} property
+			 * @param {string} replacement
+			 */
+			const print_error = (property, replacement) => {
+				Object.defineProperty(result.props.page, property, {
+					get: () => {
+						throw new Error(`$page.${property} has been replaced by $page.url.${replacement}`);
+					}
+				});
+			};
+			print_error('origin', 'origin');
+			print_error('path', 'pathname');
+			print_error('query', 'searchParams');
+		}
+		const leaf = filtered[filtered.length - 1];
+		const maxage = leaf.loaded && leaf.loaded.maxage;
+		if (maxage) {
+			const key = url.pathname + url.search; // omit hash
+			let ready = false;
+			const clear = () => {
+				if (this.cache.get(key) === result) {
+					this.cache.delete(key);
+				}
+				unsubscribe();
+				clearTimeout(timeout);
+			};
+			const timeout = setTimeout(clear, maxage * 1000);
+			const unsubscribe = this.stores.session.subscribe(() => {
+				if (ready) clear();
+			});
+			ready = true;
+			this.cache.set(key, result);
+		}
+		return result;
+	}
+	/**
+	 * @param {{
+	 *   status?: number;
+	 *   error?: Error;
+	 *   module: CSRComponent;
+	 *   url: URL;
+	 *   params: Record<string, string>;
+	 *   stuff: Record<string, any>;
+	 * }} options
+	 * @returns
+	 */
+	async _load_node({ status, error, module, url, params, stuff }) {
+		/** @type {import('./types').BranchNode} */
+		const node = {
+			module,
+			uses: {
+				params: new Set(),
+				url: false,
+				session: false,
+				stuff: false,
+				dependencies: []
+			},
+			loaded: null,
+			stuff
+		};
+		/** @type {Record<string, string>} */
+		const uses_params = {};
+		for (const key in params) {
+			Object.defineProperty(uses_params, key, {
+				get() {
+					node.uses.params.add(key);
+					return params[key];
+				},
+				enumerable: true
+			});
+		}
+		const session = this.$session;
+		if (module.load) {
+			const { started } = this;
+			/** @type {import('types/page').LoadInput | import('types/page').ErrorLoadInput} */
+			const load_input = {
+				params: uses_params,
+				get url() {
+					node.uses.url = true;
+					return url;
+				},
+				get session() {
+					node.uses.session = true;
+					return session;
+				},
+				get stuff() {
+					node.uses.stuff = true;
+					return { ...stuff };
+				},
+				fetch(resource, info) {
+					const requested = typeof resource === 'string' ? resource : resource.url;
+					const { href } = new URL(requested, url);
+					node.uses.dependencies.push(href);
+					return started ? fetch(resource, info) : initial_fetch(resource, info);
+				}
+			};
+			if (import.meta.env.DEV) {
+				// TODO remove this for 1.0
+				Object.defineProperty(load_input, 'page', {
+					get: () => {
+						throw new Error('`page` in `load` functions has been replaced by `url` and `params`');
+					}
+				});
+			}
+			if (error) {
+				/** @type {import('types/page').ErrorLoadInput} */ (load_input).status = status;
+				/** @type {import('types/page').ErrorLoadInput} */ (load_input).error = error;
+			}
+			const loaded = await module.load.call(null, load_input);
+			// if the page component returns nothing from load, fall through
+			if (!loaded) return;
+			node.loaded = normalize(loaded);
+			if (node.loaded.stuff) node.stuff = node.loaded.stuff;
+		}
+		return node;
+	}
+	/**
+	 * @param {import('./types').NavigationCandidate} selected
+	 * @param {boolean} no_cache
+	 * @returns {Promise<import('./types').NavigationResult | undefined>} undefined if fallthrough
+	 */
+	async _load({ route, info: { url, path } }, no_cache) {
+		const key = url.pathname + url.search;
+		if (!no_cache) {
+			const cached = this.cache.get(key);
+			if (cached) return cached;
+		}
+		const [pattern, a, b, get_params] = route;
+		const params = get_params
+			? // the pattern is for the route which we've already matched to this path
+			  get_params(/** @type {RegExpExecArray}  */ (pattern.exec(path)))
+			: {};
+		const changed = this.current.url && {
+			url: key !== this.current.url.pathname + this.current.url.search,
+			params: Object.keys(params).filter((key) => this.current.params[key] !== params[key]),
+			session: this.session_id !== this.current.session_id
+		};
+		/** @type {Array<import('./types').BranchNode | undefined>} */
+		let branch = [];
+		/** @type {Record<string, any>} */
+		let stuff = {};
+		let stuff_changed = false;
+		/** @type {number | undefined} */
+		let status = 200;
+		/** @type {Error | undefined} */
+		let error;
+		// preload modules
+		a.forEach((loader) => loader());
+		load: for (let i = 0; i < a.length; i += 1) {
+			/** @type {import('./types').BranchNode | undefined} */
+			let node;
+			try {
+				if (!a[i]) continue;
+				const module = await a[i]();
+				const previous = this.current.branch[i];
+				const changed_since_last_render =
+					!previous ||
+					module !== previous.module ||
+					(changed.url && previous.uses.url) ||
+					changed.params.some((param) => previous.uses.params.has(param)) ||
+					(changed.session && previous.uses.session) ||
+					previous.uses.dependencies.some((dep) => this.invalid.has(dep)) ||
+					(stuff_changed && previous.uses.stuff);
+				if (changed_since_last_render) {
+					node = await this._load_node({
+						module,
+						url,
+						params,
+						stuff
+					});
+					const is_leaf = i === a.length - 1;
+					if (node && node.loaded) {
+						if (node.loaded.error) {
+							status = node.loaded.status;
+							error = node.loaded.error;
+						}
+						if (node.loaded.redirect) {
+							return {
+								redirect: node.loaded.redirect,
+								props: {},
+								state: this.current
+							};
+						}
+						if (node.loaded.stuff) {
+							stuff_changed = true;
+						}
+					} else if (is_leaf && module.load) {
+						// if the leaf node has a `load` function
+						// that returns nothing, fall through
+						return;
+					}
+				} else {
+					node = previous;
+				}
+			} catch (e) {
+				status = 500;
+				error = coalesce_to_error(e);
+			}
+			if (error) {
+				while (i--) {
+					if (b[i]) {
+						let error_loaded;
+						/** @type {import('./types').BranchNode | undefined} */
+						let node_loaded;
+						let j = i;
+						while (!(node_loaded = branch[j])) {
+							j -= 1;
+						}
+						try {
+							error_loaded = await this._load_node({
+								status,
+								error,
+								module: await b[i](),
+								url,
+								params,
+								stuff: node_loaded.stuff
+							});
+							if (error_loaded && error_loaded.loaded && error_loaded.loaded.error) {
+								continue;
+							}
+							branch = branch.slice(0, j + 1).concat(error_loaded);
+							break load;
+						} catch (e) {
+							continue;
+						}
+					}
+				}
+				return await this._load_error({
+					status,
+					error,
+					url
+				});
+			} else {
+				if (node && node.loaded && node.loaded.stuff) {
+					stuff = {
+						...stuff,
+						...node.loaded.stuff
+					};
+				}
+				branch.push(node);
+			}
+		}
+		return await this._get_navigation_result_from_branch({ url, params, branch, status, error });
+	}
+	/**
+	 * @param {{
+	 *   status: number;
+	 *   error: Error;
+	 *   url: URL;
+	 * }} opts
+	 */
+	async _load_error({ status, error, url }) {
+		/** @type {Record<string, string>} */
+		const params = {}; // error page does not have params
+		const node = await this._load_node({
+			module: await this.fallback[0],
+			url,
+			params,
+			stuff: {}
+		});
+		const branch = [
+			node,
+			await this._load_node({
+				status,
+				error,
+				module: await this.fallback[1],
+				url,
+				params,
+				stuff: (node && node.loaded && node.loaded.stuff) || {}
+			})
+		];
+		return await this._get_navigation_result_from_branch({ url, params, branch, status, error });
+	}
+}
+// @ts-expect-error - doesn't exist yet. generated by Rollup
+/**
+ * @param {{
+ *   paths: {
+ *     assets: string;
+ *     base: string;
+ *   },
+ *   target: Node;
+ *   session: any;
+ *   route: boolean;
+ *   spa: boolean;
+ *   trailing_slash: import('types/internal').TrailingSlash;
+ *   hydrate: {
+ *     status: number;
+ *     error: Error;
+ *     nodes: Array<Promise<import('types/internal').CSRComponent>>;
+ *     url: URL;
+ *     params: Record<string, string>;
+ *   };
+ * }} opts
+ */
+async function start({ paths, target, session, route, spa, trailing_slash, hydrate }) {
+	if (import.meta.env.DEV && !target) {
+		throw new Error('Missing target element. See https://kit.svelte.dev/docs#configuration-target');
+	}
+	const renderer = new Renderer({
+		Root,
+		fallback,
+		target,
+		session
+	});
+	const router = route
+		? new Router({
+				base: paths.base,
+				routes,
+				trailing_slash,
+				renderer
+		  })
+		: null;
+	init({ router, renderer });
+	set_paths(paths);
+	if (hydrate) await renderer.start(hydrate);
+	if (router) {
+		if (spa) router.goto(location.href, { replaceState: true }, []);
+		router.init_listeners();
+	}
+	dispatchEvent(new CustomEvent('sveltekit:start'));
+}
+export { start };

.svelte-kit/build/runtime/paths.js ADDED Viewed

	@@ -0,0 +1,13 @@

+/** @type {string} */
+let base = '';
+/** @type {string} */
+let assets = '';
+/** @param {{ base: string, assets: string }} paths */
+function set_paths(paths) {
+	base = paths.base;
+	assets = paths.assets || base;
+}
+export { assets, base, set_paths };

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-all-400-normal-0d19eb5d.woff RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-cyrillic-400-normal-046b609f.woff2 RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-cyrillic-ext-400-normal-b3140dd3.woff2 RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-greek-400-normal-1f8b3a07.woff2 RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-greek-ext-400-normal-8659ae46.woff2 RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-latin-400-normal-a2f9dbe8.woff2 RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/fira-mono-latin-ext-400-normal-b6331a25.woff2 RENAMED Viewed

File without changes

.svelte-kit/output/client/_app/assets/pages/__layout.svelte-343606d7.css ADDED Viewed

	@@ -0,0 +1 @@

+ header.svelte-t2wq17.svelte-t2wq17{display:flex;justify-content:space-between}.corner.svelte-t2wq17.svelte-t2wq17{width:3em;height:3em}.corner.svelte-t2wq17 a.svelte-t2wq17{display:flex;align-items:center;justify-content:center;width:100%;height:100%}.corner.svelte-t2wq17 img.svelte-t2wq17{width:2em;height:2em;object-fit:contain}nav.svelte-t2wq17.svelte-t2wq17{display:flex;justify-content:center;--background:rgba(255, 255, 255, .7)}svg.svelte-t2wq17.svelte-t2wq17{width:2em;height:3em;display:block}path.svelte-t2wq17.svelte-t2wq17{fill:var(--background)}ul.svelte-t2wq17.svelte-t2wq17{position:relative;padding:0;margin:0;height:3em;display:flex;justify-content:center;align-items:center;list-style:none;background:var(--background);background-size:contain}li.svelte-t2wq17.svelte-t2wq17{position:relative;height:100%}li.active.svelte-t2wq17.svelte-t2wq17:before{--size:6px;content:"";width:0;height:0;position:absolute;top:0;left:calc(50% - var(--size));border:var(--size) solid transparent;border-top:var(--size) solid var(--accent-color)}nav.svelte-t2wq17 a.svelte-t2wq17{display:flex;height:100%;align-items:center;padding:0 1em;color:var(--heading-color);font-weight:700;font-size:.8rem;text-transform:uppercase;letter-spacing:.1em;text-decoration:none;transition:color .2s linear}a.svelte-t2wq17.svelte-t2wq17:hover{color:var(--accent-color)}@font-face{font-family:Fira Mono;font-style:normal;font-display:swap;font-weight:400;src:url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-cyrillic-ext-400-normal-b3140dd3.woff2) format("woff2"),url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-all-400-normal-0d19eb5d.woff) format("woff");unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:Fira Mono;font-style:normal;font-display:swap;font-weight:400;src:url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-cyrillic-400-normal-046b609f.woff2) format("woff2"),url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-all-400-normal-0d19eb5d.woff) format("woff");unicode-range:U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116}@font-face{font-family:Fira Mono;font-style:normal;font-display:swap;font-weight:400;src:url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-greek-ext-400-normal-8659ae46.woff2) format("woff2"),url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-all-400-normal-0d19eb5d.woff) format("woff");unicode-range:U+1F00-1FFF}@font-face{font-family:Fira Mono;font-style:normal;font-display:swap;font-weight:400;src:url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-greek-400-normal-1f8b3a07.woff2) format("woff2"),url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-all-400-normal-0d19eb5d.woff) format("woff");unicode-range:U+0370-03FF}@font-face{font-family:Fira Mono;font-style:normal;font-display:swap;font-weight:400;src:url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-latin-ext-400-normal-b6331a25.woff2) format("woff2"),url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-all-400-normal-0d19eb5d.woff) format("woff");unicode-range:U+0100-024F,U+0259,U+1E00-1EFF,U+2020,U+20A0-20AB,U+20AD-20CF,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:Fira Mono;font-style:normal;font-display:swap;font-weight:400;src:url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-latin-400-normal-a2f9dbe8.woff2) format("woff2"),url(/staticspaceiframe/spaces/pngwn/static-test/_app/assets/fira-mono-all-400-normal-0d19eb5d.woff) format("woff");unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}:root{font-family:Arial,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Open Sans,Helvetica Neue,sans-serif;--font-mono: "Fira Mono", monospace;--pure-white: #ffffff;--primary-color: #b9c6d2;--secondary-color: #d0dde9;--tertiary-color: #edf0f8;--accent-color: #ff3e00;--heading-color: rgba(0, 0, 0, .7);--text-color: #444444;--background-without-opacity: rgba(255, 255, 255, .7);--column-width: 42rem;--column-margin-top: 4rem}body{min-height:100vh;margin:0;background-color:var(--primary-color);background:linear-gradient(180deg,var(--primary-color) 0%,var(--secondary-color) 10.45%,var(--tertiary-color) 41.35%)}body:before{content:"";width:80vw;height:100vh;position:absolute;top:0;left:10vw;z-index:-1;background:radial-gradient(50% 50% at 50% 50%,var(--pure-white) 0%,rgba(255,255,255,0) 100%);opacity:.05}#svelte{min-height:100vh;display:flex;flex-direction:column}h1,h2,p{font-weight:400;color:var(--heading-color)}p{line-height:1.5}a{color:var(--accent-color);text-decoration:none}a:hover{text-decoration:underline}h1{font-size:2rem;text-align:center}h2{font-size:1rem}pre{font-size:16px;font-family:var(--font-mono);background-color:#ffffff73;border-radius:3px;box-shadow:2px 2px 6px #ffffff40;padding:.5em;overflow-x:auto;color:var(--text-color)}input,button{font-size:inherit;font-family:inherit}button:focus:not(:focus-visible){outline:none}@media (min-width: 720px){h1{font-size:2.4rem}}main.svelte-1izrdc8.svelte-1izrdc8{flex:1;display:flex;flex-direction:column;padding:1rem;width:100%;max-width:1024px;margin:0 auto;box-sizing:border-box}footer.svelte-1izrdc8.svelte-1izrdc8{display:flex;flex-direction:column;justify-content:center;align-items:center;padding:40px}footer.svelte-1izrdc8 a.svelte-1izrdc8{font-weight:700}@media (min-width: 480px){footer.svelte-1izrdc8.svelte-1izrdc8{padding:40px 0}}

{_app → .svelte-kit/output/client/_app}/assets/pages/about.svelte-bf4528fa.css RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/pages/index.svelte-c63fe1c6.css RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/pages/todos/index.svelte-784042c1.css RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/start-61d1577b.css RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/assets/svelte-logo-87df40b8.svg RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/chunks/vendor-d68c61c2.js RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/error.svelte-97b7e85d.js RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/manifest.json RENAMED Viewed

@@ -1,6 +1,6 @@
 {
   ".svelte-kit/build/runtime/internal/start.js": {
-    "file": "start-d56ab1d8.js",
     "src": ".svelte-kit/build/runtime/internal/start.js",
     "isEntry": true,
     "imports": [
@@ -26,7 +26,7 @@
       "_vendor-d68c61c2.js"
     ],
     "css": [
-      "assets/pages/__layout.svelte-b65cc429.css"
     ],
     "assets": [
       "assets/svelte-logo-87df40b8.svg",

 {
   ".svelte-kit/build/runtime/internal/start.js": {
+    "file": "start-2ccc875c.js",
     "src": ".svelte-kit/build/runtime/internal/start.js",
     "isEntry": true,
     "imports": [
       "_vendor-d68c61c2.js"
     ],
     "css": [
+      "assets/pages/__layout.svelte-343606d7.css"
     ],
     "assets": [
       "assets/svelte-logo-87df40b8.svg",

.svelte-kit/output/client/_app/pages/__layout.svelte-2dd96704.js ADDED Viewed

	@@ -0,0 +1 @@

+ import{E as ne,S as se,i as ae,s as le,e as u,j as y,F as V,t as z,c as f,a as c,d as l,l as H,G as j,g as D,H as ve,b as e,I as N,f as T,J as s,K as re,L as ue,M as fe,v as _e,w as de,x as he,N as pe,O as me,P as ge,p as oe,n as ie,A as be}from"../chunks/vendor-d68c61c2.js";const we=()=>{const o=ne("__svelte__");return{page:{subscribe:o.page.subscribe},navigating:{subscribe:o.navigating.subscribe},get preloading(){return console.error("stores.preloading is deprecated; use stores.navigating instead"),{subscribe:o.navigating.subscribe}},session:o.session}},Ee={subscribe(o){return we().page.subscribe(o)}};var $e="/staticspaceiframe/spaces/pngwn/static-test/_app/assets/svelte-logo-87df40b8.svg";function qe(o){let a,d,i,n,m,E,p,_,q,S,v,b,r,t,h,$,g,M,x,A,L,F,G,I,B,P,O;return{c(){a=u("header"),d=u("div"),i=u("a"),n=u("img"),E=y(),p=u("nav"),_=V("svg"),q=V("path"),S=y(),v=u("ul"),b=u("li"),r=u("a"),t=z("Home"),h=y(),$=u("li"),g=u("a"),M=z("About"),x=y(),A=u("li"),L=u("a"),F=z("Todos"),G=y(),I=V("svg"),B=V("path"),P=y(),O=u("div"),this.h()},l(k){a=f(k,"HEADER",{class:!0});var w=c(a);d=f(w,"DIV",{class:!0});var R=c(d);i=f(R,"A",{href:!0,class:!0});var Z=c(i);n=f(Z,"IMG",{src:!0,alt:!0,class:!0}),Z.forEach(l),R.forEach(l),E=H(w),p=f(w,"NAV",{class:!0});var C=c(p);_=j(C,"svg",{viewBox:!0,"aria-hidden":!0,class:!0});var J=c(_);q=j(J,"path",{d:!0,class:!0}),c(q).forEach(l),J.forEach(l),S=H(C),v=f(C,"UL",{class:!0});var K=c(v);b=f(K,"LI",{class:!0});var U=c(b);r=f(U,"A",{"sveltekit:prefetch":!0,href:!0,class:!0});var Q=c(r);t=D(Q,"Home"),Q.forEach(l),U.forEach(l),h=H(K),$=f(K,"LI",{class:!0});var W=c($);g=f(W,"A",{"sveltekit:prefetch":!0,href:!0,class:!0});var X=c(g);M=D(X,"About"),X.forEach(l),W.forEach(l),x=H(K),A=f(K,"LI",{class:!0});var Y=c(A);L=f(Y,"A",{"sveltekit:prefetch":!0,href:!0,class:!0});var ee=c(L);F=D(ee,"Todos"),ee.forEach(l),Y.forEach(l),K.forEach(l),G=H(C),I=j(C,"svg",{viewBox:!0,"aria-hidden":!0,class:!0});var te=c(I);B=j(te,"path",{d:!0,class:!0}),c(B).forEach(l),te.forEach(l),C.forEach(l),P=H(w),O=f(w,"DIV",{class:!0});var ce=c(O);ce.forEach(l),w.forEach(l),this.h()},h(){ve(n.src,m=$e)||e(n,"src",m),e(n,"alt","SvelteKit"),e(n,"class","svelte-t2wq17"),e(i,"href","https://kit.svelte.dev"),e(i,"class","svelte-t2wq17"),e(d,"class","corner svelte-t2wq17"),e(q,"d","M0,0 L1,2 C1.5,3 1.5,3 2,3 L2,0 Z"),e(q,"class","svelte-t2wq17"),e(_,"viewBox","0 0 2 3"),e(_,"aria-hidden","true"),e(_,"class","svelte-t2wq17"),e(r,"sveltekit:prefetch",""),e(r,"href","/"),e(r,"class","svelte-t2wq17"),e(b,"class","svelte-t2wq17"),N(b,"active",o[0].url.pathname==="/"),e(g,"sveltekit:prefetch",""),e(g,"href","/about"),e(g,"class","svelte-t2wq17"),e($,"class","svelte-t2wq17"),N($,"active",o[0].url.pathname==="/about"),e(L,"sveltekit:prefetch",""),e(L,"href","/todos"),e(L,"class","svelte-t2wq17"),e(A,"class","svelte-t2wq17"),N(A,"active",o[0].url.pathname==="/todos"),e(v,"class","svelte-t2wq17"),e(B,"d","M0,0 L0,3 C0.5,3 0.5,3 1,2 L2,0 Z"),e(B,"class","svelte-t2wq17"),e(I,"viewBox","0 0 2 3"),e(I,"aria-hidden","true"),e(I,"class","svelte-t2wq17"),e(p,"class","svelte-t2wq17"),e(O,"class","corner svelte-t2wq17"),e(a,"class","svelte-t2wq17")},m(k,w){T(k,a,w),s(a,d),s(d,i),s(i,n),s(a,E),s(a,p),s(p,_),s(_,q),s(p,S),s(p,v),s(v,b),s(b,r),s(r,t),s(v,h),s(v,$),s($,g),s(g,M),s(v,x),s(v,A),s(A,L),s(L,F),s(p,G),s(p,I),s(I,B),s(a,P),s(a,O)},p(k,[w]){w&1&&N(b,"active",k[0].url.pathname==="/"),w&1&&N($,"active",k[0].url.pathname==="/about"),w&1&&N(A,"active",k[0].url.pathname==="/todos")},i:re,o:re,d(k){k&&l(a)}}}function ke(o,a,d){let i;return ue(o,Ee,n=>d(0,i=n)),[i]}class Ae extends se{constructor(a){super();ae(this,a,ke,qe,le,{})}}function Le(o){let a,d,i,n,m,E,p,_,q,S,v;a=new Ae({});const b=o[1].default,r=fe(b,o,o[0],null);return{c(){_e(a.$$.fragment),d=y(),i=u("main"),r&&r.c(),n=y(),m=u("footer"),E=u("p"),p=z("visit "),_=u("a"),q=z("kit.svelte.dev"),S=z(" to learn SvelteKit"),this.h()},l(t){de(a.$$.fragment,t),d=H(t),i=f(t,"MAIN",{class:!0});var h=c(i);r&&r.l(h),h.forEach(l),n=H(t),m=f(t,"FOOTER",{class:!0});var $=c(m);E=f($,"P",{});var g=c(E);p=D(g,"visit "),_=f(g,"A",{href:!0,class:!0});var M=c(_);q=D(M,"kit.svelte.dev"),M.forEach(l),S=D(g," to learn SvelteKit"),g.forEach(l),$.forEach(l),this.h()},h(){e(i,"class","svelte-1izrdc8"),e(_,"href","https://kit.svelte.dev"),e(_,"class","svelte-1izrdc8"),e(m,"class","svelte-1izrdc8")},m(t,h){he(a,t,h),T(t,d,h),T(t,i,h),r&&r.m(i,null),T(t,n,h),T(t,m,h),s(m,E),s(E,p),s(E,_),s(_,q),s(E,S),v=!0},p(t,[h]){r&&r.p&&(!v||h&1)&&pe(r,b,t,t[0],v?ge(b,t[0],h,null):me(t[0]),null)},i(t){v||(oe(a.$$.fragment,t),oe(r,t),v=!0)},o(t){ie(a.$$.fragment,t),ie(r,t),v=!1},d(t){be(a,t),t&&l(d),t&&l(i),r&&r.d(t),t&&l(n),t&&l(m)}}}function Ie(o,a,d){let{$$slots:i={},$$scope:n}=a;return o.$$set=m=>{"$$scope"in m&&d(0,n=m.$$scope)},[n,i]}class He extends se{constructor(a){super();ae(this,a,Ie,Le,le,{})}}export{He as default};

{_app → .svelte-kit/output/client/_app}/pages/about.svelte-a7982a52.js RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/pages/index.svelte-934bb81d.js RENAMED Viewed

File without changes

{_app → .svelte-kit/output/client/_app}/pages/todos/index.svelte-82693d56.js RENAMED Viewed

File without changes

.svelte-kit/output/client/_app/start-2ccc875c.js ADDED Viewed

	@@ -0,0 +1 @@

+ var ne=Object.defineProperty,ie=Object.defineProperties;var ae=Object.getOwnPropertyDescriptors;var B=Object.getOwnPropertySymbols;var J=Object.prototype.hasOwnProperty,G=Object.prototype.propertyIsEnumerable;var M=(n,e,t)=>e in n?ne(n,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):n[e]=t,A=(n,e)=>{for(var t in e||(e={}))J.call(e,t)&&M(n,t,e[t]);if(B)for(var t of B(e))G.call(e,t)&&M(n,t,e[t]);return n},Y=(n,e)=>ie(n,ae(e));var X=(n,e)=>{var t={};for(var r in n)J.call(n,r)&&e.indexOf(r)<0&&(t[r]=n[r]);if(n!=null&&B)for(var r of B(n))e.indexOf(r)<0&&G.call(n,r)&&(t[r]=n[r]);return t};import{S as oe,i as le,s as ce,e as fe,c as ue,a as he,d as y,b as K,f as k,t as de,g as _e,h as pe,j as me,k as m,l as ge,m as T,n as g,o as j,p as w,q as we,r as be,u as ve,v as E,w as O,x as R,y as C,z as I,A as L,B as V,C as W,D as F}from"./chunks/vendor-d68c61c2.js";function ye(n){let e,t,r;const l=[n[1]||{}];var i=n[0][0];function a(s){let o={};for(let c=0;c<l.length;c+=1)o=V(o,l[c]);return{props:o}}return i&&(e=new i(a())),{c(){e&&E(e.$$.fragment),t=m()},l(s){e&&O(e.$$.fragment,s),t=m()},m(s,o){e&&R(e,s,o),k(s,t,o),r=!0},p(s,o){const c=o&2?C(l,[I(s[1]||{})]):{};if(i!==(i=s[0][0])){if(e){T();const f=e;g(f.$$.fragment,1,0,()=>{L(f,1)}),j()}i?(e=new i(a()),E(e.$$.fragment),w(e.$$.fragment,1),R(e,t.parentNode,t)):e=null}else i&&e.$set(c)},i(s){r||(e&&w(e.$$.fragment,s),r=!0)},o(s){e&&g(e.$$.fragment,s),r=!1},d(s){s&&y(t),e&&L(e,s)}}}function $e(n){let e,t,r;const l=[n[1]||{}];var i=n[0][0];function a(s){let o={$$slots:{default:[Le]},$$scope:{ctx:s}};for(let c=0;c<l.length;c+=1)o=V(o,l[c]);return{props:o}}return i&&(e=new i(a(n))),{c(){e&&E(e.$$.fragment),t=m()},l(s){e&&O(e.$$.fragment,s),t=m()},m(s,o){e&&R(e,s,o),k(s,t,o),r=!0},p(s,o){const c=o&2?C(l,[I(s[1]||{})]):{};if(o&525&&(c.$$scope={dirty:o,ctx:s}),i!==(i=s[0][0])){if(e){T();const f=e;g(f.$$.fragment,1,0,()=>{L(f,1)}),j()}i?(e=new i(a(s)),E(e.$$.fragment),w(e.$$.fragment,1),R(e,t.parentNode,t)):e=null}else i&&e.$set(c)},i(s){r||(e&&w(e.$$.fragment,s),r=!0)},o(s){e&&g(e.$$.fragment,s),r=!1},d(s){s&&y(t),e&&L(e,s)}}}function ke(n){let e,t,r;const l=[n[2]||{}];var i=n[0][1];function a(s){let o={};for(let c=0;c<l.length;c+=1)o=V(o,l[c]);return{props:o}}return i&&(e=new i(a())),{c(){e&&E(e.$$.fragment),t=m()},l(s){e&&O(e.$$.fragment,s),t=m()},m(s,o){e&&R(e,s,o),k(s,t,o),r=!0},p(s,o){const c=o&4?C(l,[I(s[2]||{})]):{};if(i!==(i=s[0][1])){if(e){T();const f=e;g(f.$$.fragment,1,0,()=>{L(f,1)}),j()}i?(e=new i(a()),E(e.$$.fragment),w(e.$$.fragment,1),R(e,t.parentNode,t)):e=null}else i&&e.$set(c)},i(s){r||(e&&w(e.$$.fragment,s),r=!0)},o(s){e&&g(e.$$.fragment,s),r=!1},d(s){s&&y(t),e&&L(e,s)}}}function Ee(n){let e,t,r;const l=[n[2]||{}];var i=n[0][1];function a(s){let o={$$slots:{default:[Re]},$$scope:{ctx:s}};for(let c=0;c<l.length;c+=1)o=V(o,l[c]);return{props:o}}return i&&(e=new i(a(n))),{c(){e&&E(e.$$.fragment),t=m()},l(s){e&&O(e.$$.fragment,s),t=m()},m(s,o){e&&R(e,s,o),k(s,t,o),r=!0},p(s,o){const c=o&4?C(l,[I(s[2]||{})]):{};if(o&521&&(c.$$scope={dirty:o,ctx:s}),i!==(i=s[0][1])){if(e){T();const f=e;g(f.$$.fragment,1,0,()=>{L(f,1)}),j()}i?(e=new i(a(s)),E(e.$$.fragment),w(e.$$.fragment,1),R(e,t.parentNode,t)):e=null}else i&&e.$set(c)},i(s){r||(e&&w(e.$$.fragment,s),r=!0)},o(s){e&&g(e.$$.fragment,s),r=!1},d(s){s&&y(t),e&&L(e,s)}}}function Re(n){let e,t,r;const l=[n[3]||{}];var i=n[0][2];function a(s){let o={};for(let c=0;c<l.length;c+=1)o=V(o,l[c]);return{props:o}}return i&&(e=new i(a())),{c(){e&&E(e.$$.fragment),t=m()},l(s){e&&O(e.$$.fragment,s),t=m()},m(s,o){e&&R(e,s,o),k(s,t,o),r=!0},p(s,o){const c=o&8?C(l,[I(s[3]||{})]):{};if(i!==(i=s[0][2])){if(e){T();const f=e;g(f.$$.fragment,1,0,()=>{L(f,1)}),j()}i?(e=new i(a()),E(e.$$.fragment),w(e.$$.fragment,1),R(e,t.parentNode,t)):e=null}else i&&e.$set(c)},i(s){r||(e&&w(e.$$.fragment,s),r=!0)},o(s){e&&g(e.$$.fragment,s),r=!1},d(s){s&&y(t),e&&L(e,s)}}}function Le(n){let e,t,r,l;const i=[Ee,ke],a=[];function s(o,c){return o[0][2]?0:1}return e=s(n),t=a[e]=i[e](n),{c(){t.c(),r=m()},l(o){t.l(o),r=m()},m(o,c){a[e].m(o,c),k(o,r,c),l=!0},p(o,c){let f=e;e=s(o),e===f?a[e].p(o,c):(T(),g(a[f],1,1,()=>{a[f]=null}),j(),t=a[e],t?t.p(o,c):(t=a[e]=i[e](o),t.c()),w(t,1),t.m(r.parentNode,r))},i(o){l||(w(t),l=!0)},o(o){g(t),l=!1},d(o){a[e].d(o),o&&y(r)}}}function H(n){let e,t=n[5]&&Q(n);return{c(){e=fe("div"),t&&t.c(),this.h()},l(r){e=ue(r,"DIV",{id:!0,"aria-live":!0,"aria-atomic":!0,class:!0});var l=he(e);t&&t.l(l),l.forEach(y),this.h()},h(){K(e,"id","svelte-announcer"),K(e,"aria-live","assertive"),K(e,"aria-atomic","true"),K(e,"class","svelte-1j55zn5")},m(r,l){k(r,e,l),t&&t.m(e,null)},p(r,l){r[5]?t?t.p(r,l):(t=Q(r),t.c(),t.m(e,null)):t&&(t.d(1),t=null)},d(r){r&&y(e),t&&t.d()}}}function Q(n){let e;return{c(){e=de(n[6])},l(t){e=_e(t,n[6])},m(t,r){k(t,e,r)},p(t,r){r&64&&pe(e,t[6])},d(t){t&&y(e)}}}function Se(n){let e,t,r,l,i;const a=[$e,ye],s=[];function o(f,h){return f[0][1]?0:1}e=o(n),t=s[e]=a[e](n);let c=n[4]&&H(n);return{c(){t.c(),r=me(),c&&c.c(),l=m()},l(f){t.l(f),r=ge(f),c&&c.l(f),l=m()},m(f,h){s[e].m(f,h),k(f,r,h),c&&c.m(f,h),k(f,l,h),i=!0},p(f,[h]){let u=e;e=o(f),e===u?s[e].p(f,h):(T(),g(s[u],1,1,()=>{s[u]=null}),j(),t=s[e],t?t.p(f,h):(t=s[e]=a[e](f),t.c()),w(t,1),t.m(r.parentNode,r)),f[4]?c?c.p(f,h):(c=H(f),c.c(),c.m(l.parentNode,l)):c&&(c.d(1),c=null)},i(f){i||(w(t),i=!0)},o(f){g(t),i=!1},d(f){s[e].d(f),f&&y(r),c&&c.d(f),f&&y(l)}}}function Ue(n,e,t){let{stores:r}=e,{page:l}=e,{components:i}=e,{props_0:a=null}=e,{props_1:s=null}=e,{props_2:o=null}=e;we("__svelte__",r),be(r.page.notify);let c=!1,f=!1,h=null;return ve(()=>{const u=r.page.subscribe(()=>{c&&(t(5,f=!0),t(6,h=document.title||"untitled page"))});return t(4,c=!0),u}),n.$$set=u=>{"stores"in u&&t(7,r=u.stores),"page"in u&&t(8,l=u.page),"components"in u&&t(0,i=u.components),"props_0"in u&&t(1,a=u.props_0),"props_1"in u&&t(2,s=u.props_1),"props_2"in u&&t(3,o=u.props_2)},n.$$.update=()=>{n.$$.dirty&384&&r.page.set(l)},[i,a,s,o,c,f,h,r,l]}class Ae extends oe{constructor(e){super();le(this,e,Ue,Se,ce,{stores:7,page:8,components:0,props_0:1,props_1:2,props_2:3})}}const Pe="modulepreload",Z={},Te="/staticspaceiframe/spaces/pngwn/static-test/_app/",D=function(e,t){return!t||t.length===0?e():Promise.all(t.map(r=>{if(r=`${Te}${r}`,r in Z)return;Z[r]=!0;const l=r.endsWith(".css"),i=l?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${r}"]${i}`))return;const a=document.createElement("link");if(a.rel=l?"stylesheet":Pe,l||(a.as="script",a.crossOrigin=""),a.href=r,document.head.appendChild(a),l)return new Promise((s,o)=>{a.addEventListener("load",s),a.addEventListener("error",o)})})).then(()=>e())},$=[()=>D(()=>import("./pages/__layout.svelte-2dd96704.js"),["pages/__layout.svelte-2dd96704.js","assets/pages/__layout.svelte-343606d7.css","chunks/vendor-d68c61c2.js"]),()=>D(()=>import("./error.svelte-97b7e85d.js"),["error.svelte-97b7e85d.js","chunks/vendor-d68c61c2.js"]),()=>D(()=>import("./pages/index.svelte-934bb81d.js"),["pages/index.svelte-934bb81d.js","assets/pages/index.svelte-c63fe1c6.css","chunks/vendor-d68c61c2.js"]),()=>D(()=>import("./pages/about.svelte-a7982a52.js"),["pages/about.svelte-a7982a52.js","assets/pages/about.svelte-bf4528fa.css","chunks/vendor-d68c61c2.js"]),()=>D(()=>import("./pages/todos/index.svelte-82693d56.js"),["pages/todos/index.svelte-82693d56.js","assets/pages/todos/index.svelte-784042c1.css","chunks/vendor-d68c61c2.js"])],je=[[/^\/$/,[$[0],$[2]],[$[1]]],[/^\/about\/?$/,[$[0],$[3]],[$[1]]],,[/^\/todos\/?$/,[$[0],$[4]],[$[1]]]],Ne=[$[0](),$[1]()];function Oe(n){let e=n.baseURI;if(!e){const t=n.getElementsByTagName("base");e=t.length?t[0].href:n.URL}return e}let x="";function Ce(n){x=n.base,n.assets}function z(){return{x:pageXOffset,y:pageYOffset}}function ee(n){return n.composedPath().find(t=>t instanceof Node&&t.nodeName.toUpperCase()==="A")}function te(n){return n instanceof SVGAElement?new URL(n.href.baseVal,document.baseURI):new URL(n.href)}class Ie{constructor({base:e,routes:t,trailing_slash:r,renderer:l}){this.base=e,this.routes=t,this.trailing_slash=r,this.navigating=0,this.renderer=l,l.router=this,this.enabled=!0,document.body.setAttribute("tabindex","-1"),history.replaceState(history.state||{},"",location.href)}init_listeners(){"scrollRestoration"in history&&(history.scrollRestoration="manual"),addEventListener("beforeunload",()=>{history.scrollRestoration="auto"}),addEventListener("load",()=>{history.scrollRestoration="manual"});let e;addEventListener("scroll",()=>{clearTimeout(e),e=setTimeout(()=>{const i=Y(A({},history.state||{}),{"sveltekit:scroll":z()});history.replaceState(i,document.title,window.location.href)},200)});const t=i=>{const a=ee(i);a&&a.href&&a.hasAttribute("sveltekit:prefetch")&&this.prefetch(te(a))};let r;const l=i=>{clearTimeout(r),r=setTimeout(()=>{var a;(a=i.target)==null||a.dispatchEvent(new CustomEvent("sveltekit:trigger_prefetch",{bubbles:!0}))},20)};addEventListener("touchstart",t),addEventListener("mousemove",l),addEventListener("sveltekit:trigger_prefetch",t),addEventListener("click",i=>{if(!this.enabled||i.button||i.which!==1||i.metaKey||i.ctrlKey||i.shiftKey||i.altKey||i.defaultPrevented)return;const a=ee(i);if(!a||!a.href)return;const s=te(a);if(s.toString()===location.href){location.hash||i.preventDefault();return}const c=(a.getAttribute("rel")||"").split(/\s+/);if(a.hasAttribute("download")||c&&c.includes("external")||(a instanceof SVGAElement?a.target.baseVal:a.target)||!this.owns(s))return;if(s.href.split("#")[0]===location.href.split("#")[0]){setTimeout(()=>history.pushState({},"",s.href));return}history.pushState({},"",s.href);const f=a.hasAttribute("sveltekit:noscroll");this._navigate(s,f?z():null,!1,[],s.hash),i.preventDefault()}),addEventListener("popstate",i=>{if(i.state&&this.enabled){const a=new URL(location.href);this._navigate(a,i.state["sveltekit:scroll"],!1,[])}})}owns(e){return e.origin===location.origin&&e.pathname.startsWith(this.base)}parse(e){if(this.owns(e)){const t=decodeURI(e.pathname.slice(this.base.length)||"/");return{id:e.pathname+e.search,routes:this.routes.filter(([r])=>r.test(t)),url:e,path:t}}}async goto(e,{noscroll:t=!1,replaceState:r=!1,keepfocus:l=!1,state:i={}}={},a){const s=new URL(e,Oe(document));return this.enabled&&this.owns(s)?(history[r?"replaceState":"pushState"](i,"",e),this._navigate(s,t?z():null,l,a,s.hash)):(location.href=s.href,new Promise(()=>{}))}enable(){this.enabled=!0}disable(){this.enabled=!1}async prefetch(e){const t=this.parse(e);if(!t)throw new Error("Attempted to prefetch a URL that does not belong to this app");return this.renderer.load(t)}async _navigate(e,t,r,l,i){const a=this.parse(e);if(!a)throw new Error("Attempted to navigate to a URL that does not belong to this app");this.navigating||dispatchEvent(new CustomEvent("sveltekit:navigation-start")),this.navigating++;let{pathname:s}=e;this.trailing_slash==="never"?s!=="/"&&s.endsWith("/")&&(s=s.slice(0,-1)):this.trailing_slash==="always"&&!e.pathname.split("/").pop().includes(".")&&!s.endsWith("/")&&(s+="/"),a.url=new URL(e.origin+s+e.search+e.hash),history.replaceState({},"",a.url),await this.renderer.handle_navigation(a,l,!1,{hash:i,scroll:t,keepfocus:r}),this.navigating--,this.navigating||dispatchEvent(new CustomEvent("sveltekit:navigation-end"))}}function se(n){return n instanceof Error||n&&n.name&&n.message?n:new Error(JSON.stringify(n))}function Ve(n){let e=5381,t=n.length;if(typeof n=="string")for(;t;)e=e*33^n.charCodeAt(--t);else for(;t;)e=e*33^n[--t];return(e>>>0).toString(36)}function De(n){const e=n.status&&n.status>=400&&n.status<=599&&!n.redirect;if(n.error||e){const t=n.status;if(!n.error&&e)return{status:t||500,error:new Error};const r=typeof n.error=="string"?new Error(n.error):n.error;return r instanceof Error?!t||t<400||t>599?(console.warn('"error" returned from load() without a valid status code \u2014 defaulting to 500'),{status:500,error:r}):{status:t,error:r}:{status:500,error:new Error(`"error" property returned from load() must be a string or instance of Error, received type "${typeof r}"`)}}if(n.redirect){if(!n.status||Math.floor(n.status/100)!==3)return{status:500,error:new Error('"redirect" property returned from load() must be accompanied by a 3xx status code')};if(typeof n.redirect!="string")return{status:500,error:new Error('"redirect" property returned from load() must be a string')}}if(n.context)throw new Error('You are returning "context" from a load function. "context" was renamed to "stuff", please adjust your code accordingly.');return n}function re(n){const e=W(n);let t=!0;function r(){t=!0,e.update(a=>a)}function l(a){t=!1,e.set(a)}function i(a){let s;return e.subscribe(o=>{(s===void 0||t&&o!==s)&&a(s=o)})}return{notify:r,set:l,subscribe:i}}function qe(n,e){const t=typeof n=="string"?n:n.url;let r=`script[data-type="svelte-data"][data-url=${JSON.stringify(t)}]`;e&&typeof e.body=="string"&&(r+=`[data-body="${Ve(e.body)}"]`);const l=document.querySelector(r);if(l&&l.textContent){const i=JSON.parse(l.textContent),{body:a}=i,s=X(i,["body"]);return Promise.resolve(new Response(a,s))}return fetch(n,e)}class Be{constructor({Root:e,fallback:t,target:r,session:l}){this.Root=e,this.fallback=t,this.router,this.target=r,this.started=!1,this.session_id=1,this.invalid=new Set,this.invalidating=null,this.autoscroll=!0,this.updating=!1,this.current={url:null,session_id:0,branch:[]},this.cache=new Map,this.loading={id:null,promise:null},this.stores={url:re({}),page:re({}),navigating:W(null),session:W(l)},this.$session=null,this.root=null;let i=!1;this.stores.session.subscribe(async a=>{if(this.$session=a,!i||!this.router)return;this.session_id+=1;const s=this.router.parse(new URL(location.href));s&&this.update(s,[],!0)}),i=!0}disable_scroll_handling(){(this.updating||!this.started)&&(this.autoscroll=!1)}async start({status:e,error:t,nodes:r,url:l,params:i}){const a=[];let s={},o,c;try{for(let f=0;f<r.length;f+=1){const h=f===r.length-1,u=await this._load_node({module:await r[f],url:l,params:i,stuff:s,status:h?e:void 0,error:h?t:void 0});if(a.push(u),u&&u.loaded)if(u.loaded.error){if(t)throw u.loaded.error;c={status:u.loaded.status,error:u.loaded.error,url:l}}else u.loaded.stuff&&(s=A(A({},s),u.loaded.stuff))}o=c?await this._load_error(c):await this._get_navigation_result_from_branch({url:l,params:i,branch:a,status:e,error:t})}catch(f){if(t)throw f;o=await this._load_error({status:500,error:se(f),url:l})}if(o.redirect){location.href=new URL(o.redirect,location.href).href;return}this._init(o)}async handle_navigation(e,t,r,l){this.started&&this.stores.navigating.set({from:this.current.url,to:e.url}),await this.update(e,t,r,l)}async update(e,t,r,l){var o;const i=this.token={};let a=await this._get_navigation_result(e,r);if(i!==this.token)return;if(this.invalid.clear(),a.redirect)if(t.length>10||t.includes(e.url.pathname))a=await this._load_error({status:500,error:new Error("Redirect loop"),url:e.url});else{this.router?this.router.goto(a.redirect,{replaceState:!0},[...t,e.url.pathname]):location.href=new URL(a.redirect,location.href).href;return}if(this.updating=!0,this.started?(this.current=a.state,this.root.$set(a.props),this.stores.navigating.set(null)):this._init(a),l){const{hash:c,scroll:f,keepfocus:h}=l;if(h||((o=getSelection())==null||o.removeAllRanges(),document.body.focus()),await F(),this.autoscroll){const u=c&&document.getElementById(c.slice(1));f?scrollTo(f.x,f.y):u?u.scrollIntoView():scrollTo(0,0)}}else await F();if(this.loading.promise=null,this.loading.id=null,this.autoscroll=!0,this.updating=!1,!this.router)return;const s=a.state.branch[a.state.branch.length-1];s&&s.module.router===!1?this.router.disable():this.router.enable()}load(e){return this.loading.promise=this._get_navigation_result(e,!1),this.loading.id=e.id,this.loading.promise}invalidate(e){return this.invalid.add(e),this.invalidating||(this.invalidating=Promise.resolve().then(async()=>{const t=this.router&&this.router.parse(new URL(location.href));t&&await this.update(t,[],!0),this.invalidating=null})),this.invalidating}_init(e){this.current=e.state;const t=document.querySelector("style[data-svelte]");t&&t.remove(),this.root=new this.Root({target:this.target,props:A({stores:this.stores},e.props),hydrate:!0}),this.started=!0}async _get_navigation_result(e,t){if(this.loading.id===e.id&&this.loading.promise)return this.loading.promise;for(let r=0;r<e.routes.length;r+=1){const l=e.routes[r];let i=r+1;for(;i<e.routes.length;){const s=e.routes[i];if(s[0].toString()===l[0].toString())s[1].forEach(o=>o()),i+=1;else break}const a=await this._load({route:l,info:e},t);if(a)return a}return await this._load_error({status:404,error:new Error(`Not found: ${e.url.pathname}`),url:e.url})}async _get_navigation_result_from_branch({url:e,params:t,branch:r,status:l,error:i}){const a=r.filter(Boolean),s=a.find(h=>h.loaded&&h.loaded.redirect),o={redirect:s&&s.loaded?s.loaded.redirect:void 0,state:{url:e,params:t,branch:r,session_id:this.session_id},props:{components:a.map(h=>h.module.default)}};for(let h=0;h<a.length;h+=1){const u=a[h].loaded;o.props[`props_${h}`]=u?await u.props:null}if(!this.current.url||e.href!==this.current.url.href){o.props.page={url:e,params:t,status:l,error:i};const h=(u,p)=>{Object.defineProperty(o.props.page,u,{get:()=>{throw new Error(`$page.${u} has been replaced by $page.url.${p}`)}})};h("origin","origin"),h("path","pathname"),h("query","searchParams")}const c=a[a.length-1],f=c.loaded&&c.loaded.maxage;if(f){const h=e.pathname+e.search;let u=!1;const p=()=>{this.cache.get(h)===o&&this.cache.delete(h),S(),clearTimeout(P)},P=setTimeout(p,f*1e3),S=this.stores.session.subscribe(()=>{u&&p()});u=!0,this.cache.set(h,o)}return o}async _load_node({status:e,error:t,module:r,url:l,params:i,stuff:a}){const s={module:r,uses:{params:new Set,url:!1,session:!1,stuff:!1,dependencies:[]},loaded:null,stuff:a},o={};for(const f in i)Object.defineProperty(o,f,{get(){return s.uses.params.add(f),i[f]},enumerable:!0});const c=this.$session;if(r.load){const{started:f}=this,h={params:o,get url(){return s.uses.url=!0,l},get session(){return s.uses.session=!0,c},get stuff(){return s.uses.stuff=!0,A({},a)},fetch(p,P){const S=typeof p=="string"?p:p.url,{href:U}=new URL(S,l);return s.uses.dependencies.push(U),f?fetch(p,P):qe(p,P)}};t&&(h.status=e,h.error=t);const u=await r.load.call(null,h);if(!u)return;s.loaded=De(u),s.loaded.stuff&&(s.stuff=s.loaded.stuff)}return s}async _load({route:e,info:{url:t,path:r}},l){const i=t.pathname+t.search;if(!l){const d=this.cache.get(i);if(d)return d}const[a,s,o,c]=e,f=c?c(a.exec(r)):{},h=this.current.url&&{url:i!==this.current.url.pathname+this.current.url.search,params:Object.keys(f).filter(d=>this.current.params[d]!==f[d]),session:this.session_id!==this.current.session_id};let u=[],p={},P=!1,S=200,U;s.forEach(d=>d());e:for(let d=0;d<s.length;d+=1){let _;try{if(!s[d])continue;const b=await s[d](),v=this.current.branch[d];if(!v||b!==v.module||h.url&&v.uses.url||h.params.some(N=>v.uses.params.has(N))||h.session&&v.uses.session||v.uses.dependencies.some(N=>this.invalid.has(N))||P&&v.uses.stuff){_=await this._load_node({module:b,url:t,params:f,stuff:p});const N=d===s.length-1;if(_&&_.loaded){if(_.loaded.error&&(S=_.loaded.status,U=_.loaded.error),_.loaded.redirect)return{redirect:_.loaded.redirect,props:{},state:this.current};_.loaded.stuff&&(P=!0)}else if(N&&b.load)return}else _=v}catch(b){S=500,U=se(b)}if(U){for(;d--;)if(o[d]){let b,v,q=d;for(;!(v=u[q]);)q-=1;try{if(b=await this._load_node({status:S,error:U,module:await o[d](),url:t,params:f,stuff:v.stuff}),b&&b.loaded&&b.loaded.error)continue;u=u.slice(0,q+1).concat(b);break e}catch{continue}}return await this._load_error({status:S,error:U,url:t})}else _&&_.loaded&&_.loaded.stuff&&(p=A(A({},p),_.loaded.stuff)),u.push(_)}return await this._get_navigation_result_from_branch({url:t,params:f,branch:u,status:S,error:U})}async _load_error({status:e,error:t,url:r}){const l={},i=await this._load_node({module:await this.fallback[0],url:r,params:l,stuff:{}}),a=[i,await this._load_node({status:e,error:t,module:await this.fallback[1],url:r,params:l,stuff:i&&i.loaded&&i.loaded.stuff||{}})];return await this._get_navigation_result_from_branch({url:r,params:l,branch:a,status:e,error:t})}}async function ze({paths:n,target:e,session:t,route:r,spa:l,trailing_slash:i,hydrate:a}){const s=new Be({Root:Ae,fallback:Ne,target:e,session:t}),o=r?new Ie({base:n.base,routes:je,trailing_slash:i,renderer:s}):null;Ce(n),a&&await s.start(a),o&&(l&&o.goto(location.href,{replaceState:!0},[]),o.init_listeners()),dispatchEvent(new CustomEvent("sveltekit:start"))}export{ze as start};

.svelte-kit/output/server/app.js ADDED Viewed

	@@ -0,0 +1,1473 @@

+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw 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);
+  return value;
+};
+var _map;
+import { c as create_ssr_component, s as setContext, v as validate_component, m as missing_component } from "./chunks/index-c7a03ab5.js";
+import cookie from "cookie";
+import { v4 } from "@lukeed/uuid";
+function get_single_valued_header(headers, key) {
+  const value = headers[key];
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return void 0;
+    }
+    if (value.length > 1) {
+      throw new Error(`Multiple headers provided for ${key}. Multiple may be provided only for set-cookie`);
+    }
+    return value[0];
+  }
+  return value;
+}
+function lowercase_keys(obj) {
+  const clone = {};
+  for (const key in obj) {
+    clone[key.toLowerCase()] = obj[key];
+  }
+  return clone;
+}
+function decode_params(params) {
+  for (const key in params) {
+    params[key] = params[key].replace(/%23/g, "#").replace(/%3[Bb]/g, ";").replace(/%2[Cc]/g, ",").replace(/%2[Ff]/g, "/").replace(/%3[Ff]/g, "?").replace(/%3[Aa]/g, ":").replace(/%40/g, "@").replace(/%26/g, "&").replace(/%3[Dd]/g, "=").replace(/%2[Bb]/g, "+").replace(/%24/g, "$");
+  }
+  return params;
+}
+function error(body) {
+  return {
+    status: 500,
+    body,
+    headers: {}
+  };
+}
+function is_string(s2) {
+  return typeof s2 === "string" || s2 instanceof String;
+}
+const text_types = new Set([
+  "application/xml",
+  "application/json",
+  "application/x-www-form-urlencoded",
+  "multipart/form-data"
+]);
+function is_text(content_type) {
+  if (!content_type)
+    return true;
+  const type = content_type.split(";")[0].toLowerCase();
+  return type.startsWith("text/") || type.endsWith("+xml") || text_types.has(type);
+}
+async function render_endpoint(request, route, match) {
+  const mod = await route.load();
+  const handler = mod[request.method.toLowerCase().replace("delete", "del")];
+  if (!handler) {
+    return;
+  }
+  request.params = route.params ? decode_params(route.params(match)) : {};
+  const response = await handler(request);
+  const preface = `Invalid response from route ${request.url.pathname}`;
+  if (!response) {
+    return;
+  }
+  if (typeof response !== "object") {
+    return error(`${preface}: expected an object, got ${typeof response}`);
+  }
+  let { status = 200, body, headers = {} } = response;
+  headers = lowercase_keys(headers);
+  const type = get_single_valued_header(headers, "content-type");
+  if (!is_text(type) && !(body instanceof Uint8Array || is_string(body))) {
+    return error(`${preface}: body must be an instance of string or Uint8Array if content-type is not a supported textual content-type`);
+  }
+  let normalized_body;
+  if ((typeof body === "object" || typeof body === "undefined") && !(body instanceof Uint8Array) && (!type || type.startsWith("application/json"))) {
+    headers = { ...headers, "content-type": "application/json; charset=utf-8" };
+    normalized_body = JSON.stringify(typeof body === "undefined" ? {} : body);
+  } else {
+    normalized_body = body;
+  }
+  return { status, body: normalized_body, headers };
+}
+var chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
+var unsafeChars = /[<>\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)$/;
+var escaped = {
+  "<": "\\u003C",
+  ">": "\\u003E",
+  "/": "\\u002F",
+  "\\": "\\\\",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t",
+  "\0": "\\0",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+var objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+function devalue(value) {
+  var counts = new Map();
+  function walk(thing) {
+    if (typeof thing === "function") {
+      throw new Error("Cannot stringify a function");
+    }
+    if (counts.has(thing)) {
+      counts.set(thing, counts.get(thing) + 1);
+      return;
+    }
+    counts.set(thing, 1);
+    if (!isPrimitive(thing)) {
+      var type = getType(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+        case "Date":
+        case "RegExp":
+          return;
+        case "Array":
+          thing.forEach(walk);
+          break;
+        case "Set":
+        case "Map":
+          Array.from(thing).forEach(walk);
+          break;
+        default:
+          var proto = Object.getPrototypeOf(thing);
+          if (proto !== Object.prototype && proto !== null && Object.getOwnPropertyNames(proto).sort().join("\0") !== objectProtoOwnPropertyNames) {
+            throw new Error("Cannot stringify arbitrary non-POJOs");
+          }
+          if (Object.getOwnPropertySymbols(thing).length > 0) {
+            throw new Error("Cannot stringify POJOs with symbolic keys");
+          }
+          Object.keys(thing).forEach(function(key) {
+            return walk(thing[key]);
+          });
+      }
+    }
+  }
+  walk(value);
+  var names = new Map();
+  Array.from(counts).filter(function(entry) {
+    return entry[1] > 1;
+  }).sort(function(a, b) {
+    return b[1] - a[1];
+  }).forEach(function(entry, i) {
+    names.set(entry[0], getName(i));
+  });
+  function stringify(thing) {
+    if (names.has(thing)) {
+      return names.get(thing);
+    }
+    if (isPrimitive(thing)) {
+      return stringifyPrimitive(thing);
+    }
+    var type = getType(thing);
+    switch (type) {
+      case "Number":
+      case "String":
+      case "Boolean":
+        return "Object(" + stringify(thing.valueOf()) + ")";
+      case "RegExp":
+        return "new RegExp(" + stringifyString(thing.source) + ', "' + thing.flags + '")';
+      case "Date":
+        return "new Date(" + thing.getTime() + ")";
+      case "Array":
+        var members = thing.map(function(v, i) {
+          return i in thing ? stringify(v) : "";
+        });
+        var tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
+        return "[" + members.join(",") + tail + "]";
+      case "Set":
+      case "Map":
+        return "new " + type + "([" + Array.from(thing).map(stringify).join(",") + "])";
+      default:
+        var obj = "{" + Object.keys(thing).map(function(key) {
+          return safeKey(key) + ":" + stringify(thing[key]);
+        }).join(",") + "}";
+        var proto = Object.getPrototypeOf(thing);
+        if (proto === null) {
+          return Object.keys(thing).length > 0 ? "Object.assign(Object.create(null)," + obj + ")" : "Object.create(null)";
+        }
+        return obj;
+    }
+  }
+  var str = stringify(value);
+  if (names.size) {
+    var params_1 = [];
+    var statements_1 = [];
+    var values_1 = [];
+    names.forEach(function(name, thing) {
+      params_1.push(name);
+      if (isPrimitive(thing)) {
+        values_1.push(stringifyPrimitive(thing));
+        return;
+      }
+      var type = getType(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+          values_1.push("Object(" + stringify(thing.valueOf()) + ")");
+          break;
+        case "RegExp":
+          values_1.push(thing.toString());
+          break;
+        case "Date":
+          values_1.push("new Date(" + thing.getTime() + ")");
+          break;
+        case "Array":
+          values_1.push("Array(" + thing.length + ")");
+          thing.forEach(function(v, i) {
+            statements_1.push(name + "[" + i + "]=" + stringify(v));
+          });
+          break;
+        case "Set":
+          values_1.push("new Set");
+          statements_1.push(name + "." + Array.from(thing).map(function(v) {
+            return "add(" + stringify(v) + ")";
+          }).join("."));
+          break;
+        case "Map":
+          values_1.push("new Map");
+          statements_1.push(name + "." + Array.from(thing).map(function(_a) {
+            var k = _a[0], v = _a[1];
+            return "set(" + stringify(k) + ", " + stringify(v) + ")";
+          }).join("."));
+          break;
+        default:
+          values_1.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
+          Object.keys(thing).forEach(function(key) {
+            statements_1.push("" + name + safeProp(key) + "=" + stringify(thing[key]));
+          });
+      }
+    });
+    statements_1.push("return " + str);
+    return "(function(" + params_1.join(",") + "){" + statements_1.join(";") + "}(" + values_1.join(",") + "))";
+  } else {
+    return str;
+  }
+}
+function getName(num) {
+  var name = "";
+  do {
+    name = chars[num % chars.length] + name;
+    num = ~~(num / chars.length) - 1;
+  } while (num >= 0);
+  return reserved.test(name) ? name + "_" : name;
+}
+function isPrimitive(thing) {
+  return Object(thing) !== thing;
+}
+function stringifyPrimitive(thing) {
+  if (typeof thing === "string")
+    return stringifyString(thing);
+  if (thing === void 0)
+    return "void 0";
+  if (thing === 0 && 1 / thing < 0)
+    return "-0";
+  var str = String(thing);
+  if (typeof thing === "number")
+    return str.replace(/^(-)?0\./, "$1.");
+  return str;
+}
+function getType(thing) {
+  return Object.prototype.toString.call(thing).slice(8, -1);
+}
+function escapeUnsafeChar(c) {
+  return escaped[c] || c;
+}
+function escapeUnsafeChars(str) {
+  return str.replace(unsafeChars, escapeUnsafeChar);
+}
+function safeKey(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
+}
+function safeProp(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? "." + key : "[" + escapeUnsafeChars(JSON.stringify(key)) + "]";
+}
+function stringifyString(str) {
+  var result = '"';
+  for (var i = 0; i < str.length; i += 1) {
+    var char = str.charAt(i);
+    var code = char.charCodeAt(0);
+    if (char === '"') {
+      result += '\\"';
+    } else if (char in escaped) {
+      result += escaped[char];
+    } else if (code >= 55296 && code <= 57343) {
+      var next = str.charCodeAt(i + 1);
+      if (code <= 56319 && (next >= 56320 && next <= 57343)) {
+        result += char + str[++i];
+      } else {
+        result += "\\u" + code.toString(16).toUpperCase();
+      }
+    } else {
+      result += char;
+    }
+  }
+  result += '"';
+  return result;
+}
+function noop() {
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
+}
+Promise.resolve();
+const subscriber_queue = [];
+function writable(value, start = noop) {
+  let stop;
+  const subscribers = 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(value));
+  }
+  function subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) {
+      stop = start(set) || noop;
+    }
+    run(value);
+    return () => {
+      subscribers.delete(subscriber);
+      if (subscribers.size === 0) {
+        stop();
+        stop = null;
+      }
+    };
+  }
+  return { set, update, subscribe };
+}
+function coalesce_to_error(err) {
+  return err instanceof Error || err && err.name && err.message ? err : new Error(JSON.stringify(err));
+}
+function hash(value) {
+  let hash2 = 5381;
+  let i = value.length;
+  if (typeof value === "string") {
+    while (i)
+      hash2 = hash2 * 33 ^ value.charCodeAt(--i);
+  } else {
+    while (i)
+      hash2 = hash2 * 33 ^ value[--i];
+  }
+  return (hash2 >>> 0).toString(36);
+}
+const escape_json_string_in_html_dict = {
+  '"': '\\"',
+  "<": "\\u003C",
+  ">": "\\u003E",
+  "/": "\\u002F",
+  "\\": "\\\\",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t",
+  "\0": "\\0",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+function escape_json_string_in_html(str) {
+  return escape(str, escape_json_string_in_html_dict, (code) => `\\u${code.toString(16).toUpperCase()}`);
+}
+const escape_html_attr_dict = {
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;"
+};
+function escape_html_attr(str) {
+  return '"' + escape(str, escape_html_attr_dict, (code) => `&#${code};`) + '"';
+}
+function escape(str, dict, unicode_encoder) {
+  let result = "";
+  for (let i = 0; i < str.length; i += 1) {
+    const char = str.charAt(i);
+    const code = char.charCodeAt(0);
+    if (char in dict) {
+      result += dict[char];
+    } else if (code >= 55296 && code <= 57343) {
+      const next = str.charCodeAt(i + 1);
+      if (code <= 56319 && next >= 56320 && next <= 57343) {
+        result += char + str[++i];
+      } else {
+        result += unicode_encoder(code);
+      }
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+const s = JSON.stringify;
+async function render_response({
+  branch,
+  options,
+  $session,
+  page_config,
+  status,
+  error: error2,
+  url,
+  params
+}) {
+  const css2 = new Set(options.manifest._.entry.css);
+  const js = new Set(options.manifest._.entry.js);
+  const styles = new Set();
+  const serialized_data = [];
+  let rendered;
+  let is_private = false;
+  let maxage;
+  if (error2) {
+    error2.stack = options.get_stack(error2);
+  }
+  if (page_config.ssr) {
+    branch.forEach(({ node, loaded, fetched, uses_credentials }) => {
+      if (node.css)
+        node.css.forEach((url2) => css2.add(url2));
+      if (node.js)
+        node.js.forEach((url2) => js.add(url2));
+      if (node.styles)
+        node.styles.forEach((content) => styles.add(content));
+      if (fetched && page_config.hydrate)
+        serialized_data.push(...fetched);
+      if (uses_credentials)
+        is_private = true;
+      maxage = loaded.maxage;
+    });
+    const session = writable($session);
+    const props = {
+      stores: {
+        page: writable(null),
+        navigating: writable(null),
+        session
+      },
+      page: { url, params, status, error: error2 },
+      components: branch.map(({ node }) => node.module.default)
+    };
+    const print_error = (property, replacement) => {
+      Object.defineProperty(props.page, property, {
+        get: () => {
+          throw new Error(`$page.${property} has been replaced by $page.url.${replacement}`);
+        }
+      });
+    };
+    print_error("origin", "origin");
+    print_error("path", "pathname");
+    print_error("query", "searchParams");
+    for (let i = 0; i < branch.length; i += 1) {
+      props[`props_${i}`] = await branch[i].loaded.props;
+    }
+    let session_tracking_active = false;
+    const unsubscribe = session.subscribe(() => {
+      if (session_tracking_active)
+        is_private = true;
+    });
+    session_tracking_active = true;
+    try {
+      rendered = options.root.render(props);
+    } finally {
+      unsubscribe();
+    }
+  } else {
+    rendered = { head: "", html: "", css: { code: "", map: null } };
+  }
+  const include_js = page_config.router || page_config.hydrate;
+  if (!include_js)
+    js.clear();
+  const links = options.amp ? styles.size > 0 || rendered.css.code.length > 0 ? `<style amp-custom>${Array.from(styles).concat(rendered.css.code).join("\n")}</style>` : "" : [
+    ...Array.from(css2).map((dep) => `<link rel="stylesheet" href="${options.prefix}${dep}">`),
+    ...Array.from(js).map((dep) => `<link rel="modulepreload" href="${options.prefix}${dep}">`)
+  ].join("\n		");
+  let init = "";
+  if (options.amp) {
+    init = `
+		<style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style>
+		<noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>
+		<script async src="https://cdn.ampproject.org/v0.js"><\/script>`;
+    init += options.service_worker ? '<script async custom-element="amp-install-serviceworker" src="https://cdn.ampproject.org/v0/amp-install-serviceworker-0.1.js"><\/script>' : "";
+  } else if (include_js) {
+    init = `<script type="module">
+			import { start } from ${s(options.prefix + options.manifest._.entry.file)};
+			start({
+				target: ${options.target ? `document.querySelector(${s(options.target)})` : "document.body"},
+				paths: ${s(options.paths)},
+				session: ${try_serialize($session, (error3) => {
+      throw new Error(`Failed to serialize session data: ${error3.message}`);
+    })},
+				route: ${!!page_config.router},
+				spa: ${!page_config.ssr},
+				trailing_slash: ${s(options.trailing_slash)},
+				hydrate: ${page_config.ssr && page_config.hydrate ? `{
+					status: ${status},
+					error: ${serialize_error(error2)},
+					nodes: [
+						${(branch || []).map(({ node }) => `import(${s(options.prefix + node.entry)})`).join(",\n						")}
+					],
+					url: new URL(${s(url.href)}),
+					params: ${devalue(params)}
+				}` : "null"}
+			});
+		<\/script>`;
+  }
+  if (options.service_worker && !options.amp) {
+    init += `<script>
+			if ('serviceWorker' in navigator) {
+				navigator.serviceWorker.register('${options.service_worker}');
+			}
+		<\/script>`;
+  }
+  const head = [
+    rendered.head,
+    styles.size && !options.amp ? `<style data-svelte>${Array.from(styles).join("\n")}</style>` : "",
+    links,
+    init
+  ].join("\n\n		");
+  let body = rendered.html;
+  if (options.amp) {
+    if (options.service_worker) {
+      body += `<amp-install-serviceworker src="${options.service_worker}" layout="nodisplay"></amp-install-serviceworker>`;
+    }
+  } else {
+    body += serialized_data.map(({ url: url2, body: body2, json }) => {
+      let attributes = `type="application/json" data-type="svelte-data" data-url=${escape_html_attr(url2)}`;
+      if (body2)
+        attributes += ` data-body="${hash(body2)}"`;
+      return `<script ${attributes}>${json}<\/script>`;
+    }).join("\n\n	");
+  }
+  const headers = {
+    "content-type": "text/html"
+  };
+  if (maxage) {
+    headers["cache-control"] = `${is_private ? "private" : "public"}, max-age=${maxage}`;
+  }
+  if (!options.floc) {
+    headers["permissions-policy"] = "interest-cohort=()";
+  }
+  const segments = url.pathname.slice(options.paths.base.length).split("/").slice(2);
+  const assets2 = options.paths.assets || (segments.length > 0 ? segments.map(() => "..").join("/") : ".");
+  return {
+    status,
+    headers,
+    body: options.template({
+      head,
+      body,
+      assets: assets2
+    })
+  };
+}
+function try_serialize(data, fail) {
+  try {
+    return devalue(data);
+  } catch (err) {
+    if (fail)
+      fail(coalesce_to_error(err));
+    return null;
+  }
+}
+function serialize_error(error2) {
+  if (!error2)
+    return null;
+  let serialized = try_serialize(error2);
+  if (!serialized) {
+    const { name, message, stack } = error2;
+    serialized = try_serialize({ ...error2, name, message, stack });
+  }
+  if (!serialized) {
+    serialized = "{}";
+  }
+  return serialized;
+}
+function normalize(loaded) {
+  const has_error_status = loaded.status && loaded.status >= 400 && loaded.status <= 599 && !loaded.redirect;
+  if (loaded.error || has_error_status) {
+    const status = loaded.status;
+    if (!loaded.error && has_error_status) {
+      return {
+        status: status || 500,
+        error: new Error()
+      };
+    }
+    const error2 = typeof loaded.error === "string" ? new Error(loaded.error) : loaded.error;
+    if (!(error2 instanceof Error)) {
+      return {
+        status: 500,
+        error: new Error(`"error" property returned from load() must be a string or instance of Error, received type "${typeof error2}"`)
+      };
+    }
+    if (!status || status < 400 || status > 599) {
+      console.warn('"error" returned from load() without a valid status code \u2014 defaulting to 500');
+      return { status: 500, error: error2 };
+    }
+    return { status, error: error2 };
+  }
+  if (loaded.redirect) {
+    if (!loaded.status || Math.floor(loaded.status / 100) !== 3) {
+      return {
+        status: 500,
+        error: new Error('"redirect" property returned from load() must be accompanied by a 3xx status code')
+      };
+    }
+    if (typeof loaded.redirect !== "string") {
+      return {
+        status: 500,
+        error: new Error('"redirect" property returned from load() must be a string')
+      };
+    }
+  }
+  if (loaded.context) {
+    throw new Error('You are returning "context" from a load function. "context" was renamed to "stuff", please adjust your code accordingly.');
+  }
+  return loaded;
+}
+const absolute = /^([a-z]+:)?\/?\//;
+const scheme = /^[a-z]+:/;
+function resolve(base2, path) {
+  if (scheme.test(path))
+    return path;
+  const base_match = absolute.exec(base2);
+  const path_match = absolute.exec(path);
+  if (!base_match) {
+    throw new Error(`bad base path: "${base2}"`);
+  }
+  const baseparts = path_match ? [] : base2.slice(base_match[0].length).split("/");
+  const pathparts = path_match ? path.slice(path_match[0].length).split("/") : path.split("/");
+  baseparts.pop();
+  for (let i = 0; i < pathparts.length; i += 1) {
+    const part = pathparts[i];
+    if (part === ".")
+      continue;
+    else if (part === "..")
+      baseparts.pop();
+    else
+      baseparts.push(part);
+  }
+  const prefix = path_match && path_match[0] || base_match && base_match[0] || "";
+  return `${prefix}${baseparts.join("/")}`;
+}
+function is_root_relative(path) {
+  return path[0] === "/" && path[1] !== "/";
+}
+async function load_node({
+  request,
+  options,
+  state,
+  route,
+  url,
+  params,
+  node,
+  $session,
+  stuff,
+  prerender_enabled,
+  is_leaf,
+  is_error,
+  status,
+  error: error2
+}) {
+  const { module } = node;
+  let uses_credentials = false;
+  const fetched = [];
+  let set_cookie_headers = [];
+  let loaded;
+  const url_proxy = new Proxy(url, {
+    get: (target, prop, receiver) => {
+      if (prerender_enabled && (prop === "search" || prop === "searchParams")) {
+        throw new Error("Cannot access query on a page with prerendering enabled");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  if (module.load) {
+    const load_input = {
+      url: url_proxy,
+      params,
+      get session() {
+        uses_credentials = true;
+        return $session;
+      },
+      fetch: async (resource, opts = {}) => {
+        let requested;
+        if (typeof resource === "string") {
+          requested = resource;
+        } else {
+          requested = resource.url;
+          opts = {
+            method: resource.method,
+            headers: resource.headers,
+            body: resource.body,
+            mode: resource.mode,
+            credentials: resource.credentials,
+            cache: resource.cache,
+            redirect: resource.redirect,
+            referrer: resource.referrer,
+            integrity: resource.integrity,
+            ...opts
+          };
+        }
+        opts.headers = new Headers(opts.headers);
+        const resolved = resolve(request.url.pathname, requested.split("?")[0]);
+        let response;
+        const prefix = options.paths.assets || options.paths.base;
+        const filename = (resolved.startsWith(prefix) ? resolved.slice(prefix.length) : resolved).slice(1);
+        const filename_html = `${filename}/index.html`;
+        const is_asset = options.manifest.assets.has(filename);
+        const is_asset_html = options.manifest.assets.has(filename_html);
+        if (is_asset || is_asset_html) {
+          const file = is_asset ? filename : filename_html;
+          if (options.read) {
+            const type = is_asset ? options.manifest._.mime[filename.slice(filename.lastIndexOf("."))] : "text/html";
+            response = new Response(options.read(file), {
+              headers: type ? { "content-type": type } : {}
+            });
+          } else {
+            response = await fetch(`${url.origin}/${file}`, opts);
+          }
+        } else if (is_root_relative(resolved)) {
+          const relative = resolved;
+          if (opts.credentials !== "omit") {
+            uses_credentials = true;
+            if (request.headers.cookie) {
+              opts.headers.set("cookie", request.headers.cookie);
+            }
+            if (request.headers.authorization && !opts.headers.has("authorization")) {
+              opts.headers.set("authorization", request.headers.authorization);
+            }
+          }
+          if (opts.body && typeof opts.body !== "string") {
+            throw new Error("Request body must be a string");
+          }
+          const rendered = await respond({
+            url: new URL(requested, request.url),
+            method: opts.method || "GET",
+            headers: Object.fromEntries(opts.headers),
+            rawBody: opts.body == null ? null : new TextEncoder().encode(opts.body)
+          }, options, {
+            fetched: requested,
+            initiator: route
+          });
+          if (rendered) {
+            if (state.prerender) {
+              state.prerender.dependencies.set(relative, rendered);
+            }
+            response = new Response(rendered.body, {
+              status: rendered.status,
+              headers: rendered.headers
+            });
+          } else {
+            return fetch(new URL(requested, request.url).href, {
+              method: opts.method || "GET",
+              headers: opts.headers
+            });
+          }
+        } else {
+          if (resolved.startsWith("//")) {
+            throw new Error(`Cannot request protocol-relative URL (${requested}) in server-side fetch`);
+          }
+          if (`.${new URL(requested).hostname}`.endsWith(`.${request.url.hostname}`) && opts.credentials !== "omit") {
+            uses_credentials = true;
+            opts.headers.set("cookie", request.headers.cookie);
+          }
+          const external_request = new Request(requested, opts);
+          response = await options.hooks.externalFetch.call(null, external_request);
+        }
+        if (response) {
+          const proxy = new Proxy(response, {
+            get(response2, key, _receiver) {
+              async function text() {
+                const body = await response2.text();
+                const headers = {};
+                for (const [key2, value] of response2.headers) {
+                  if (key2 === "set-cookie") {
+                    set_cookie_headers = set_cookie_headers.concat(value);
+                  } else if (key2 !== "etag") {
+                    headers[key2] = value;
+                  }
+                }
+                if (!opts.body || typeof opts.body === "string") {
+                  fetched.push({
+                    url: requested,
+                    body: opts.body,
+                    json: `{"status":${response2.status},"statusText":${s(response2.statusText)},"headers":${s(headers)},"body":"${escape_json_string_in_html(body)}"}`
+                  });
+                }
+                return body;
+              }
+              if (key === "text") {
+                return text;
+              }
+              if (key === "json") {
+                return async () => {
+                  return JSON.parse(await text());
+                };
+              }
+              return Reflect.get(response2, key, response2);
+            }
+          });
+          return proxy;
+        }
+        return response || new Response("Not found", {
+          status: 404
+        });
+      },
+      stuff: { ...stuff }
+    };
+    if (options.dev) {
+      Object.defineProperty(load_input, "page", {
+        get: () => {
+          throw new Error("`page` in `load` functions has been replaced by `url` and `params`");
+        }
+      });
+    }
+    if (is_error) {
+      load_input.status = status;
+      load_input.error = error2;
+    }
+    loaded = await module.load.call(null, load_input);
+  } else {
+    loaded = {};
+  }
+  if (!loaded && is_leaf && !is_error)
+    return;
+  if (!loaded) {
+    throw new Error(`${node.entry} - load must return a value except for page fall through`);
+  }
+  return {
+    node,
+    loaded: normalize(loaded),
+    stuff: loaded.stuff || stuff,
+    fetched,
+    set_cookie_headers,
+    uses_credentials
+  };
+}
+async function respond_with_error({ request, options, state, $session, status, error: error2 }) {
+  const default_layout = await options.manifest._.nodes[0]();
+  const default_error = await options.manifest._.nodes[1]();
+  const params = {};
+  const loaded = await load_node({
+    request,
+    options,
+    state,
+    route: null,
+    url: request.url,
+    params,
+    node: default_layout,
+    $session,
+    stuff: {},
+    prerender_enabled: is_prerender_enabled(options, default_error, state),
+    is_leaf: false,
+    is_error: false
+  });
+  const branch = [
+    loaded,
+    await load_node({
+      request,
+      options,
+      state,
+      route: null,
+      url: request.url,
+      params,
+      node: default_error,
+      $session,
+      stuff: loaded ? loaded.stuff : {},
+      prerender_enabled: is_prerender_enabled(options, default_error, state),
+      is_leaf: false,
+      is_error: true,
+      status,
+      error: error2
+    })
+  ];
+  try {
+    return await render_response({
+      options,
+      $session,
+      page_config: {
+        hydrate: options.hydrate,
+        router: options.router,
+        ssr: options.ssr
+      },
+      status,
+      error: error2,
+      branch,
+      url: request.url,
+      params
+    });
+  } catch (err) {
+    const error3 = coalesce_to_error(err);
+    options.handle_error(error3, request);
+    return {
+      status: 500,
+      headers: {},
+      body: error3.stack
+    };
+  }
+}
+function is_prerender_enabled(options, node, state) {
+  return options.prerender && (!!node.module.prerender || !!state.prerender && state.prerender.all);
+}
+async function respond$1(opts) {
+  const { request, options, state, $session, route } = opts;
+  let nodes;
+  try {
+    nodes = await Promise.all(route.a.map((n) => options.manifest._.nodes[n] && options.manifest._.nodes[n]()));
+  } catch (err) {
+    const error3 = coalesce_to_error(err);
+    options.handle_error(error3, request);
+    return await respond_with_error({
+      request,
+      options,
+      state,
+      $session,
+      status: 500,
+      error: error3
+    });
+  }
+  const leaf = nodes[nodes.length - 1].module;
+  let page_config = get_page_config(leaf, options);
+  if (!leaf.prerender && state.prerender && !state.prerender.all) {
+    return {
+      status: 204,
+      headers: {}
+    };
+  }
+  let branch = [];
+  let status = 200;
+  let error2;
+  let set_cookie_headers = [];
+  ssr:
+    if (page_config.ssr) {
+      let stuff = {};
+      for (let i = 0; i < nodes.length; i += 1) {
+        const node = nodes[i];
+        let loaded;
+        if (node) {
+          try {
+            loaded = await load_node({
+              ...opts,
+              url: request.url,
+              node,
+              stuff,
+              prerender_enabled: is_prerender_enabled(options, node, state),
+              is_leaf: i === nodes.length - 1,
+              is_error: false
+            });
+            if (!loaded)
+              return;
+            set_cookie_headers = set_cookie_headers.concat(loaded.set_cookie_headers);
+            if (loaded.loaded.redirect) {
+              return with_cookies({
+                status: loaded.loaded.status,
+                headers: {
+                  location: encodeURI(loaded.loaded.redirect)
+                }
+              }, set_cookie_headers);
+            }
+            if (loaded.loaded.error) {
+              ({ status, error: error2 } = loaded.loaded);
+            }
+          } catch (err) {
+            const e = coalesce_to_error(err);
+            options.handle_error(e, request);
+            status = 500;
+            error2 = e;
+          }
+          if (loaded && !error2) {
+            branch.push(loaded);
+          }
+          if (error2) {
+            while (i--) {
+              if (route.b[i]) {
+                const error_node = await options.manifest._.nodes[route.b[i]]();
+                let node_loaded;
+                let j = i;
+                while (!(node_loaded = branch[j])) {
+                  j -= 1;
+                }
+                try {
+                  const error_loaded = await load_node({
+                    ...opts,
+                    url: request.url,
+                    node: error_node,
+                    stuff: node_loaded.stuff,
+                    prerender_enabled: is_prerender_enabled(options, error_node, state),
+                    is_leaf: false,
+                    is_error: true,
+                    status,
+                    error: error2
+                  });
+                  if (error_loaded.loaded.error) {
+                    continue;
+                  }
+                  page_config = get_page_config(error_node.module, options);
+                  branch = branch.slice(0, j + 1).concat(error_loaded);
+                  break ssr;
+                } catch (err) {
+                  const e = coalesce_to_error(err);
+                  options.handle_error(e, request);
+                  continue;
+                }
+              }
+            }
+            return with_cookies(await respond_with_error({
+              request,
+              options,
+              state,
+              $session,
+              status,
+              error: error2
+            }), set_cookie_headers);
+          }
+        }
+        if (loaded && loaded.loaded.stuff) {
+          stuff = {
+            ...stuff,
+            ...loaded.loaded.stuff
+          };
+        }
+      }
+    }
+  try {
+    return with_cookies(await render_response({
+      ...opts,
+      url: request.url,
+      page_config,
+      status,
+      error: error2,
+      branch: branch.filter(Boolean)
+    }), set_cookie_headers);
+  } catch (err) {
+    const error3 = coalesce_to_error(err);
+    options.handle_error(error3, request);
+    return with_cookies(await respond_with_error({
+      ...opts,
+      status: 500,
+      error: error3
+    }), set_cookie_headers);
+  }
+}
+function get_page_config(leaf, options) {
+  return {
+    ssr: "ssr" in leaf ? !!leaf.ssr : options.ssr,
+    router: "router" in leaf ? !!leaf.router : options.router,
+    hydrate: "hydrate" in leaf ? !!leaf.hydrate : options.hydrate
+  };
+}
+function with_cookies(response, set_cookie_headers) {
+  if (set_cookie_headers.length) {
+    response.headers["set-cookie"] = set_cookie_headers;
+  }
+  return response;
+}
+async function render_page(request, route, match, options, state) {
+  if (state.initiator === route) {
+    return {
+      status: 404,
+      headers: {},
+      body: `Not found: ${request.url.pathname}`
+    };
+  }
+  const params = route.params ? decode_params(route.params(match)) : {};
+  const $session = await options.hooks.getSession(request);
+  const response = await respond$1({
+    request,
+    options,
+    state,
+    $session,
+    route,
+    params
+  });
+  if (response) {
+    return response;
+  }
+  if (state.fetched) {
+    return {
+      status: 500,
+      headers: {},
+      body: `Bad request in load function: failed to fetch ${state.fetched}`
+    };
+  }
+}
+function read_only_form_data() {
+  const map = new Map();
+  return {
+    append(key, value) {
+      if (map.has(key)) {
+        (map.get(key) || []).push(value);
+      } else {
+        map.set(key, [value]);
+      }
+    },
+    data: new ReadOnlyFormData(map)
+  };
+}
+class ReadOnlyFormData {
+  constructor(map) {
+    __privateAdd(this, _map, void 0);
+    __privateSet(this, _map, map);
+  }
+  get(key) {
+    const value = __privateGet(this, _map).get(key);
+    return value && value[0];
+  }
+  getAll(key) {
+    return __privateGet(this, _map).get(key);
+  }
+  has(key) {
+    return __privateGet(this, _map).has(key);
+  }
+  *[Symbol.iterator]() {
+    for (const [key, value] of __privateGet(this, _map)) {
+      for (let i = 0; i < value.length; i += 1) {
+        yield [key, value[i]];
+      }
+    }
+  }
+  *entries() {
+    for (const [key, value] of __privateGet(this, _map)) {
+      for (let i = 0; i < value.length; i += 1) {
+        yield [key, value[i]];
+      }
+    }
+  }
+  *keys() {
+    for (const [key] of __privateGet(this, _map))
+      yield key;
+  }
+  *values() {
+    for (const [, value] of __privateGet(this, _map)) {
+      for (let i = 0; i < value.length; i += 1) {
+        yield value[i];
+      }
+    }
+  }
+}
+_map = new WeakMap();
+function parse_body(raw, headers) {
+  if (!raw)
+    return raw;
+  const content_type = headers["content-type"];
+  const [type, ...directives] = content_type ? content_type.split(/;\s*/) : [];
+  const text = () => new TextDecoder(headers["content-encoding"] || "utf-8").decode(raw);
+  switch (type) {
+    case "text/plain":
+      return text();
+    case "application/json":
+      return JSON.parse(text());
+    case "application/x-www-form-urlencoded":
+      return get_urlencoded(text());
+    case "multipart/form-data": {
+      const boundary = directives.find((directive) => directive.startsWith("boundary="));
+      if (!boundary)
+        throw new Error("Missing boundary");
+      return get_multipart(text(), boundary.slice("boundary=".length));
+    }
+    default:
+      return raw;
+  }
+}
+function get_urlencoded(text) {
+  const { data, append } = read_only_form_data();
+  text.replace(/\+/g, " ").split("&").forEach((str) => {
+    const [key, value] = str.split("=");
+    append(decodeURIComponent(key), decodeURIComponent(value));
+  });
+  return data;
+}
+function get_multipart(text, boundary) {
+  const parts = text.split(`--${boundary}`);
+  if (parts[0] !== "" || parts[parts.length - 1].trim() !== "--") {
+    throw new Error("Malformed form data");
+  }
+  const { data, append } = read_only_form_data();
+  parts.slice(1, -1).forEach((part) => {
+    const match = /\s*([\s\S]+?)\r\n\r\n([\s\S]*)\s*/.exec(part);
+    if (!match) {
+      throw new Error("Malformed form data");
+    }
+    const raw_headers = match[1];
+    const body = match[2].trim();
+    let key;
+    const headers = {};
+    raw_headers.split("\r\n").forEach((str) => {
+      const [raw_header, ...raw_directives] = str.split("; ");
+      let [name, value] = raw_header.split(": ");
+      name = name.toLowerCase();
+      headers[name] = value;
+      const directives = {};
+      raw_directives.forEach((raw_directive) => {
+        const [name2, value2] = raw_directive.split("=");
+        directives[name2] = JSON.parse(value2);
+      });
+      if (name === "content-disposition") {
+        if (value !== "form-data")
+          throw new Error("Malformed form data");
+        if (directives.filename) {
+          throw new Error("File upload is not yet implemented");
+        }
+        if (directives.name) {
+          key = directives.name;
+        }
+      }
+    });
+    if (!key)
+      throw new Error("Malformed form data");
+    append(key, body);
+  });
+  return data;
+}
+async function respond(incoming, options, state = {}) {
+  if (incoming.url.pathname !== "/" && options.trailing_slash !== "ignore") {
+    const has_trailing_slash = incoming.url.pathname.endsWith("/");
+    if (has_trailing_slash && options.trailing_slash === "never" || !has_trailing_slash && options.trailing_slash === "always" && !(incoming.url.pathname.split("/").pop() || "").includes(".")) {
+      incoming.url.pathname = has_trailing_slash ? incoming.url.pathname.slice(0, -1) : incoming.url.pathname + "/";
+      if (incoming.url.search === "?")
+        incoming.url.search = "";
+      return {
+        status: 301,
+        headers: {
+          location: incoming.url.pathname + incoming.url.search
+        }
+      };
+    }
+  }
+  const headers = lowercase_keys(incoming.headers);
+  const request = {
+    ...incoming,
+    headers,
+    body: parse_body(incoming.rawBody, headers),
+    params: {},
+    locals: {}
+  };
+  const print_error = (property, replacement) => {
+    Object.defineProperty(request, property, {
+      get: () => {
+        throw new Error(`request.${property} has been replaced by request.url.${replacement}`);
+      }
+    });
+  };
+  print_error("origin", "origin");
+  print_error("path", "pathname");
+  print_error("query", "searchParams");
+  try {
+    return await options.hooks.handle({
+      request,
+      resolve: async (request2) => {
+        if (state.prerender && state.prerender.fallback) {
+          return await render_response({
+            url: request2.url,
+            params: request2.params,
+            options,
+            $session: await options.hooks.getSession(request2),
+            page_config: { ssr: false, router: true, hydrate: true },
+            status: 200,
+            branch: []
+          });
+        }
+        const decoded = decodeURI(request2.url.pathname).replace(options.paths.base, "");
+        for (const route of options.manifest._.routes) {
+          const match = route.pattern.exec(decoded);
+          if (!match)
+            continue;
+          const response = route.type === "endpoint" ? await render_endpoint(request2, route, match) : await render_page(request2, route, match, options, state);
+          if (response) {
+            if (response.status === 200) {
+              const cache_control = get_single_valued_header(response.headers, "cache-control");
+              if (!cache_control || !/(no-store|immutable)/.test(cache_control)) {
+                let if_none_match_value = request2.headers["if-none-match"];
+                if (if_none_match_value?.startsWith('W/"')) {
+                  if_none_match_value = if_none_match_value.substring(2);
+                }
+                const etag = `"${hash(response.body || "")}"`;
+                if (if_none_match_value === etag) {
+                  return {
+                    status: 304,
+                    headers: {}
+                  };
+                }
+                response.headers["etag"] = etag;
+              }
+            }
+            return response;
+          }
+        }
+        if (!state.initiator) {
+          const $session = await options.hooks.getSession(request2);
+          return await respond_with_error({
+            request: request2,
+            options,
+            state,
+            $session,
+            status: 404,
+            error: new Error(`Not found: ${request2.url.pathname}`)
+          });
+        }
+      }
+    });
+  } catch (err) {
+    const e = coalesce_to_error(err);
+    options.handle_error(e, request);
+    return {
+      status: 500,
+      headers: {},
+      body: options.dev ? e.stack : e.message
+    };
+  }
+}
+function afterUpdate() {
+}
+var root_svelte_svelte_type_style_lang = "";
+const css = {
+  code: "#svelte-announcer.svelte-1j55zn5{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}",
+  map: null
+};
+const Root = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  let { stores } = $$props;
+  let { page } = $$props;
+  let { components } = $$props;
+  let { props_0 = null } = $$props;
+  let { props_1 = null } = $$props;
+  let { props_2 = null } = $$props;
+  setContext("__svelte__", stores);
+  afterUpdate(stores.page.notify);
+  if ($$props.stores === void 0 && $$bindings.stores && stores !== void 0)
+    $$bindings.stores(stores);
+  if ($$props.page === void 0 && $$bindings.page && page !== void 0)
+    $$bindings.page(page);
+  if ($$props.components === void 0 && $$bindings.components && components !== void 0)
+    $$bindings.components(components);
+  if ($$props.props_0 === void 0 && $$bindings.props_0 && props_0 !== void 0)
+    $$bindings.props_0(props_0);
+  if ($$props.props_1 === void 0 && $$bindings.props_1 && props_1 !== void 0)
+    $$bindings.props_1(props_1);
+  if ($$props.props_2 === void 0 && $$bindings.props_2 && props_2 !== void 0)
+    $$bindings.props_2(props_2);
+  $$result.css.add(css);
+  {
+    stores.page.set(page);
+  }
+  return `
+${components[1] ? `${validate_component(components[0] || missing_component, "svelte:component").$$render($$result, Object.assign(props_0 || {}), {}, {
+    default: () => `${components[2] ? `${validate_component(components[1] || missing_component, "svelte:component").$$render($$result, Object.assign(props_1 || {}), {}, {
+      default: () => `${validate_component(components[2] || missing_component, "svelte:component").$$render($$result, Object.assign(props_2 || {}), {}, {})}`
+    })}` : `${validate_component(components[1] || missing_component, "svelte:component").$$render($$result, Object.assign(props_1 || {}), {}, {})}`}`
+  })}` : `${validate_component(components[0] || missing_component, "svelte:component").$$render($$result, Object.assign(props_0 || {}), {}, {})}`}
+${``}`;
+});
+let base = "";
+let assets = "";
+function set_paths(paths) {
+  base = paths.base;
+  assets = paths.assets || base;
+}
+function set_prerendering(value) {
+}
+const handle = async ({ request, resolve: resolve2 }) => {
+  const cookies = cookie.parse(request.headers.cookie || "");
+  request.locals.userid = cookies.userid || v4();
+  const method = request.url.searchParams.get("_method");
+  if (method) {
+    request.method = method.toUpperCase();
+  }
+  const response = await resolve2(request);
+  if (!cookies.userid) {
+    response.headers["set-cookie"] = cookie.serialize("userid", request.locals.userid, {
+      path: "/",
+      httpOnly: true
+    });
+  }
+  return response;
+};
+var user_hooks = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  [Symbol.toStringTag]: "Module",
+  handle
+});
+const template = ({ head, body, assets: assets2 }) => '<!DOCTYPE html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="description" content="Svelte demo app" />\n		<link rel="icon" href="' + assets2 + '/favicon.png" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		' + head + '\n	</head>\n	<body>\n		<div id="svelte">' + body + "</div>\n	</body>\n</html>\n";
+let read = null;
+set_paths({ "base": "/staticspaceiframe/spaces/pngwn/static-test", "assets": "" });
+const get_hooks = (hooks) => ({
+  getSession: hooks.getSession || (() => ({})),
+  handle: hooks.handle || (({ request, resolve: resolve2 }) => resolve2(request)),
+  handleError: hooks.handleError || (({ error: error2 }) => console.error(error2.stack)),
+  externalFetch: hooks.externalFetch || fetch
+});
+let default_protocol = "https";
+function override(settings) {
+  default_protocol = settings.protocol || default_protocol;
+  set_paths(settings.paths);
+  set_prerendering(settings.prerendering);
+  read = settings.read;
+}
+class App {
+  constructor(manifest) {
+    const hooks = get_hooks(user_hooks);
+    this.options = {
+      amp: false,
+      dev: false,
+      floc: false,
+      get_stack: (error2) => String(error2),
+      handle_error: (error2, request) => {
+        hooks.handleError({ error: error2, request });
+        error2.stack = this.options.get_stack(error2);
+      },
+      hooks,
+      hydrate: true,
+      manifest,
+      paths: { base, assets },
+      prefix: assets + "/_app/",
+      prerender: true,
+      read,
+      root: Root,
+      service_worker: null,
+      router: true,
+      ssr: true,
+      target: "#svelte",
+      template,
+      trailing_slash: "never"
+    };
+  }
+  render(request, {
+    prerender
+  } = {}) {
+    if (Object.keys(request).sort().join() !== "headers,method,rawBody,url") {
+      throw new Error("Adapters should call app.render({ url, method, headers, rawBody })");
+    }
+    const host = request.headers["host"];
+    const protocol = default_protocol;
+    return respond({ ...request, url: new URL(request.url, protocol + "://" + host) }, this.options, { prerender });
+  }
+}
+export { App, override };

.svelte-kit/output/server/chunks/_api-cf43c630.js ADDED Viewed

	@@ -0,0 +1,26 @@

+const base = "https://api.svelte.dev";
+async function api(request, resource, data) {
+  if (!request.locals.userid) {
+    return { status: 401 };
+  }
+  const res = await fetch(`${base}/${resource}`, {
+    method: request.method,
+    headers: {
+      "content-type": "application/json"
+    },
+    body: data && JSON.stringify(data)
+  });
+  if (res.ok && request.method !== "GET" && request.headers.accept !== "application/json") {
+    return {
+      status: 303,
+      headers: {
+        location: "/todos"
+      }
+    };
+  }
+  return {
+    status: res.status,
+    body: await res.json()
+  };
+}
+export { api as a };

.svelte-kit/output/server/chunks/index-c7a03ab5.js ADDED Viewed

	@@ -0,0 +1,159 @@

+function noop() {
+}
+function run(fn) {
+  return fn();
+}
+function blank_object() {
+  return Object.create(null);
+}
+function run_all(fns) {
+  fns.forEach(run);
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
+}
+function subscribe(store, ...callbacks) {
+  if (store == null) {
+    return noop;
+  }
+  const unsub = store.subscribe(...callbacks);
+  return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
+}
+const is_client = typeof window !== "undefined";
+let now = is_client ? () => window.performance.now() : () => Date.now();
+let raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
+const tasks = new Set();
+function run_tasks(now2) {
+  tasks.forEach((task) => {
+    if (!task.c(now2)) {
+      tasks.delete(task);
+      task.f();
+    }
+  });
+  if (tasks.size !== 0)
+    raf(run_tasks);
+}
+function loop(callback) {
+  let task;
+  if (tasks.size === 0)
+    raf(run_tasks);
+  return {
+    promise: new Promise((fulfill) => {
+      tasks.add(task = { c: callback, f: fulfill });
+    }),
+    abort() {
+      tasks.delete(task);
+    }
+  };
+}
+let current_component;
+function set_current_component(component) {
+  current_component = component;
+}
+function get_current_component() {
+  if (!current_component)
+    throw new Error("Function called outside component initialization");
+  return current_component;
+}
+function setContext(key, context) {
+  get_current_component().$$.context.set(key, context);
+}
+function getContext(key) {
+  return get_current_component().$$.context.get(key);
+}
+Promise.resolve();
+const boolean_attributes = new Set([
+  "allowfullscreen",
+  "allowpaymentrequest",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "ismap",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+]);
+const escaped = {
+  '"': "&quot;",
+  "'": "&#39;",
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;"
+};
+function escape(html) {
+  return String(html).replace(/["'&<>]/g, (match) => escaped[match]);
+}
+function each(items, fn) {
+  let str = "";
+  for (let i = 0; i < items.length; i += 1) {
+    str += fn(items[i], i);
+  }
+  return str;
+}
+const missing_component = {
+  $$render: () => ""
+};
+function validate_component(component, name) {
+  if (!component || !component.$$render) {
+    if (name === "svelte:component")
+      name += " this={...}";
+    throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules`);
+  }
+  return component;
+}
+let on_destroy;
+function create_ssr_component(fn) {
+  function $$render(result, props, bindings, slots, context) {
+    const parent_component = current_component;
+    const $$ = {
+      on_destroy,
+      context: new Map(context || (parent_component ? parent_component.$$.context : [])),
+      on_mount: [],
+      before_update: [],
+      after_update: [],
+      callbacks: blank_object()
+    };
+    set_current_component({ $$ });
+    const html = fn(result, props, bindings, slots);
+    set_current_component(parent_component);
+    return html;
+  }
+  return {
+    render: (props = {}, { $$slots = {}, context = new Map() } = {}) => {
+      on_destroy = [];
+      const result = { title: "", head: "", css: new Set() };
+      const html = $$render(result, props, {}, $$slots, context);
+      run_all(on_destroy);
+      return {
+        html,
+        css: {
+          code: Array.from(result.css).map((css) => css.code).join("\n"),
+          map: null
+        },
+        head: result.title + result.head
+      };
+    },
+    $$render
+  };
+}
+function add_attribute(name, value, boolean) {
+  if (value == null || boolean && !value)
+    return "";
+  return ` ${name}${value === true && boolean_attributes.has(name) ? "" : `=${typeof value === "string" ? JSON.stringify(escape(value)) : `"${value}"`}`}`;
+}
+export { subscribe as a, add_attribute as b, create_ssr_component as c, safe_not_equal as d, escape as e, now as f, getContext as g, each as h, loop as l, missing_component as m, noop as n, setContext as s, validate_component as v };

.svelte-kit/output/server/entries/endpoints/todos/_uid_.json.js ADDED Viewed

	@@ -0,0 +1,11 @@

+import { a as api } from "../../../chunks/_api-cf43c630.js";
+const patch = async (request) => {
+  return api(request, `todos/${request.locals.userid}/${request.params.uid}`, {
+    text: request.body.get("text"),
+    done: request.body.has("done") ? !!request.body.get("done") : void 0
+  });
+};
+const del = async (request) => {
+  return api(request, `todos/${request.locals.userid}/${request.params.uid}`);
+};
+export { del, patch };

.svelte-kit/output/server/entries/endpoints/todos/index.json.js ADDED Viewed

	@@ -0,0 +1,15 @@

+import { a as api } from "../../../chunks/_api-cf43c630.js";
+const get = async (request) => {
+  const response = await api(request, `todos/${request.locals.userid}`);
+  if (response.status === 404) {
+    return { body: [] };
+  }
+  return response;
+};
+const post = async (request) => {
+  const response = await api(request, `todos/${request.locals.userid}`, {
+    text: request.body.get("text")
+  });
+  return response;
+};
+export { get, post };

.svelte-kit/output/server/entries/pages/__layout.svelte.js ADDED Viewed

	@@ -0,0 +1,63 @@

+import { g as getContext, c as create_ssr_component, a as subscribe, b as add_attribute, v as validate_component } from "../../chunks/index-c7a03ab5.js";
+const getStores = () => {
+  const stores = getContext("__svelte__");
+  return {
+    page: {
+      subscribe: stores.page.subscribe
+    },
+    navigating: {
+      subscribe: stores.navigating.subscribe
+    },
+    get preloading() {
+      console.error("stores.preloading is deprecated; use stores.navigating instead");
+      return {
+        subscribe: stores.navigating.subscribe
+      };
+    },
+    session: stores.session
+  };
+};
+const page = {
+  subscribe(fn) {
+    const store = getStores().page;
+    return store.subscribe(fn);
+  }
+};
+var logo = "/staticspaceiframe/spaces/pngwn/static-test/_app/assets/svelte-logo-87df40b8.svg";
+var Header_svelte_svelte_type_style_lang = "";
+const css$1 = {
+  code: "header.svelte-t2wq17.svelte-t2wq17{display:flex;justify-content:space-between}.corner.svelte-t2wq17.svelte-t2wq17{width:3em;height:3em}.corner.svelte-t2wq17 a.svelte-t2wq17{display:flex;align-items:center;justify-content:center;width:100%;height:100%}.corner.svelte-t2wq17 img.svelte-t2wq17{width:2em;height:2em;object-fit:contain}nav.svelte-t2wq17.svelte-t2wq17{display:flex;justify-content:center;--background:rgba(255, 255, 255, 0.7)}svg.svelte-t2wq17.svelte-t2wq17{width:2em;height:3em;display:block}path.svelte-t2wq17.svelte-t2wq17{fill:var(--background)}ul.svelte-t2wq17.svelte-t2wq17{position:relative;padding:0;margin:0;height:3em;display:flex;justify-content:center;align-items:center;list-style:none;background:var(--background);background-size:contain}li.svelte-t2wq17.svelte-t2wq17{position:relative;height:100%}li.active.svelte-t2wq17.svelte-t2wq17::before{--size:6px;content:'';width:0;height:0;position:absolute;top:0;left:calc(50% - var(--size));border:var(--size) solid transparent;border-top:var(--size) solid var(--accent-color)}nav.svelte-t2wq17 a.svelte-t2wq17{display:flex;height:100%;align-items:center;padding:0 1em;color:var(--heading-color);font-weight:700;font-size:0.8rem;text-transform:uppercase;letter-spacing:0.1em;text-decoration:none;transition:color 0.2s linear}a.svelte-t2wq17.svelte-t2wq17:hover{color:var(--accent-color)}",
+  map: null
+};
+const Header = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  let $page, $$unsubscribe_page;
+  $$unsubscribe_page = subscribe(page, (value) => $page = value);
+  $$result.css.add(css$1);
+  $$unsubscribe_page();
+  return `<header class="${"svelte-t2wq17"}"><div class="${"corner svelte-t2wq17"}"><a href="${"https://kit.svelte.dev"}" class="${"svelte-t2wq17"}"><img${add_attribute("src", logo, 0)} alt="${"SvelteKit"}" class="${"svelte-t2wq17"}"></a></div>
+	<nav class="${"svelte-t2wq17"}"><svg viewBox="${"0 0 2 3"}" aria-hidden="${"true"}" class="${"svelte-t2wq17"}"><path d="${"M0,0 L1,2 C1.5,3 1.5,3 2,3 L2,0 Z"}" class="${"svelte-t2wq17"}"></path></svg>
+		<ul class="${"svelte-t2wq17"}"><li class="${["svelte-t2wq17", $page.url.pathname === "/" ? "active" : ""].join(" ").trim()}"><a sveltekit:prefetch href="${"/"}" class="${"svelte-t2wq17"}">Home</a></li>
+			<li class="${["svelte-t2wq17", $page.url.pathname === "/about" ? "active" : ""].join(" ").trim()}"><a sveltekit:prefetch href="${"/about"}" class="${"svelte-t2wq17"}">About</a></li>
+			<li class="${["svelte-t2wq17", $page.url.pathname === "/todos" ? "active" : ""].join(" ").trim()}"><a sveltekit:prefetch href="${"/todos"}" class="${"svelte-t2wq17"}">Todos</a></li></ul>
+		<svg viewBox="${"0 0 2 3"}" aria-hidden="${"true"}" class="${"svelte-t2wq17"}"><path d="${"M0,0 L0,3 C0.5,3 0.5,3 1,2 L2,0 Z"}" class="${"svelte-t2wq17"}"></path></svg></nav>
+	<div class="${"corner svelte-t2wq17"}"></div>
+</header>`;
+});
+var app = "";
+var __layout_svelte_svelte_type_style_lang = "";
+const css = {
+  code: "main.svelte-1izrdc8.svelte-1izrdc8{flex:1;display:flex;flex-direction:column;padding:1rem;width:100%;max-width:1024px;margin:0 auto;box-sizing:border-box}footer.svelte-1izrdc8.svelte-1izrdc8{display:flex;flex-direction:column;justify-content:center;align-items:center;padding:40px}footer.svelte-1izrdc8 a.svelte-1izrdc8{font-weight:bold}@media(min-width: 480px){footer.svelte-1izrdc8.svelte-1izrdc8{padding:40px 0}}",
+  map: null
+};
+const _layout = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  $$result.css.add(css);
+  return `${validate_component(Header, "Header").$$render($$result, {}, {}, {})}
+<main class="${"svelte-1izrdc8"}">${slots.default ? slots.default({}) : ``}</main>
+<footer class="${"svelte-1izrdc8"}"><p>visit <a href="${"https://kit.svelte.dev"}" class="${"svelte-1izrdc8"}">kit.svelte.dev</a> to learn SvelteKit</p>
+</footer>`;
+});
+export { _layout as default };

.svelte-kit/output/server/entries/pages/about.svelte.js ADDED Viewed

	@@ -0,0 +1,35 @@

+import { c as create_ssr_component } from "../../chunks/index-c7a03ab5.js";
+const browser = false;
+const dev = false;
+var about_svelte_svelte_type_style_lang = "";
+const css = {
+  code: ".content.svelte-cf77e8{width:100%;max-width:var(--column-width);margin:var(--column-margin-top) auto 0 auto}",
+  map: null
+};
+const hydrate = dev;
+const router = browser;
+const prerender = true;
+const About = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  $$result.css.add(css);
+  return `${$$result.head += `${$$result.title = `<title>About</title>`, ""}`, ""}
+<div class="${"content svelte-cf77e8"}"><h1>About this app</h1>
+	<p>This is a <a href="${"https://kit.svelte.dev"}">SvelteKit</a> app. You can make your own by typing the
+		following into your command line and following the prompts:
+	</p>
+	<pre>npm init svelte@next</pre>
+	<p>The page you&#39;re looking at is purely static HTML, with no client-side interactivity needed.
+		Because of that, we don&#39;t need to load any JavaScript. Try viewing the page&#39;s source, or opening
+		the devtools network panel and reloading.
+	</p>
+	<p>The <a href="${"/todos"}">TODOs</a> page illustrates SvelteKit&#39;s data loading and form handling. Try using
+		it with JavaScript disabled!
+	</p>
+</div>`;
+});
+export { About as default, hydrate, prerender, router };

.svelte-kit/output/server/entries/pages/error.svelte.js ADDED Viewed

	@@ -0,0 +1,21 @@

+import { c as create_ssr_component, e as escape } from "../../chunks/index-c7a03ab5.js";
+function load({ error, status }) {
+  return { props: { error, status } };
+}
+const Error = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  let { status } = $$props;
+  let { error } = $$props;
+  if ($$props.status === void 0 && $$bindings.status && status !== void 0)
+    $$bindings.status(status);
+  if ($$props.error === void 0 && $$bindings.error && error !== void 0)
+    $$bindings.error(error);
+  return `<h1>${escape(status)}</h1>
+<pre>${escape(error.message)}</pre>
+${error.frame ? `<pre>${escape(error.frame)}</pre>` : ``}
+${error.stack ? `<pre>${escape(error.stack)}</pre>` : ``}`;
+});
+export { Error as default, load };

.svelte-kit/output/server/entries/pages/index.svelte.js ADDED Viewed

	@@ -0,0 +1,190 @@

+import { n as noop, d as safe_not_equal, f as now, l as loop, c as create_ssr_component, a as subscribe, e as escape, v as validate_component } from "../../chunks/index-c7a03ab5.js";
+const subscriber_queue = [];
+function writable(value, start = noop) {
+  let stop;
+  const subscribers = 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(value));
+  }
+  function subscribe2(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) {
+      stop = start(set) || noop;
+    }
+    run(value);
+    return () => {
+      subscribers.delete(subscriber);
+      if (subscribers.size === 0) {
+        stop();
+        stop = null;
+      }
+    };
+  }
+  return { set, update, subscribe: subscribe2 };
+}
+function is_date(obj) {
+  return Object.prototype.toString.call(obj) === "[object Date]";
+}
+function tick_spring(ctx, last_value, current_value, target_value) {
+  if (typeof current_value === "number" || is_date(current_value)) {
+    const delta = target_value - current_value;
+    const velocity = (current_value - last_value) / (ctx.dt || 1 / 60);
+    const spring2 = ctx.opts.stiffness * delta;
+    const damper = ctx.opts.damping * velocity;
+    const acceleration = (spring2 - damper) * ctx.inv_mass;
+    const d = (velocity + acceleration) * ctx.dt;
+    if (Math.abs(d) < ctx.opts.precision && Math.abs(delta) < ctx.opts.precision) {
+      return target_value;
+    } else {
+      ctx.settled = false;
+      return is_date(current_value) ? new Date(current_value.getTime() + d) : current_value + d;
+    }
+  } else if (Array.isArray(current_value)) {
+    return current_value.map((_, i) => tick_spring(ctx, last_value[i], current_value[i], target_value[i]));
+  } else if (typeof current_value === "object") {
+    const next_value = {};
+    for (const k in current_value) {
+      next_value[k] = tick_spring(ctx, last_value[k], current_value[k], target_value[k]);
+    }
+    return next_value;
+  } else {
+    throw new Error(`Cannot spring ${typeof current_value} values`);
+  }
+}
+function spring(value, opts = {}) {
+  const store = writable(value);
+  const { stiffness = 0.15, damping = 0.8, precision = 0.01 } = opts;
+  let last_time;
+  let task;
+  let current_token;
+  let last_value = value;
+  let target_value = value;
+  let inv_mass = 1;
+  let inv_mass_recovery_rate = 0;
+  let cancel_task = false;
+  function set(new_value, opts2 = {}) {
+    target_value = new_value;
+    const token = current_token = {};
+    if (value == null || opts2.hard || spring2.stiffness >= 1 && spring2.damping >= 1) {
+      cancel_task = true;
+      last_time = now();
+      last_value = new_value;
+      store.set(value = target_value);
+      return Promise.resolve();
+    } else if (opts2.soft) {
+      const rate = opts2.soft === true ? 0.5 : +opts2.soft;
+      inv_mass_recovery_rate = 1 / (rate * 60);
+      inv_mass = 0;
+    }
+    if (!task) {
+      last_time = now();
+      cancel_task = false;
+      task = loop((now2) => {
+        if (cancel_task) {
+          cancel_task = false;
+          task = null;
+          return false;
+        }
+        inv_mass = Math.min(inv_mass + inv_mass_recovery_rate, 1);
+        const ctx = {
+          inv_mass,
+          opts: spring2,
+          settled: true,
+          dt: (now2 - last_time) * 60 / 1e3
+        };
+        const next_value = tick_spring(ctx, last_value, value, target_value);
+        last_time = now2;
+        last_value = value;
+        store.set(value = next_value);
+        if (ctx.settled) {
+          task = null;
+        }
+        return !ctx.settled;
+      });
+    }
+    return new Promise((fulfil) => {
+      task.promise.then(() => {
+        if (token === current_token)
+          fulfil();
+      });
+    });
+  }
+  const spring2 = {
+    set,
+    update: (fn, opts2) => set(fn(target_value, value), opts2),
+    subscribe: store.subscribe,
+    stiffness,
+    damping,
+    precision
+  };
+  return spring2;
+}
+var Counter_svelte_svelte_type_style_lang = "";
+const css$1 = {
+  code: ".counter.svelte-139m1ow.svelte-139m1ow{display:flex;border-top:1px solid rgba(0, 0, 0, 0.1);border-bottom:1px solid rgba(0, 0, 0, 0.1);margin:1rem 0}.counter.svelte-139m1ow button.svelte-139m1ow{width:2em;padding:0;display:flex;align-items:center;justify-content:center;border:0;background-color:transparent;color:var(--text-color);font-size:2rem}.counter.svelte-139m1ow button.svelte-139m1ow:hover{background-color:var(--secondary-color)}svg.svelte-139m1ow.svelte-139m1ow{width:25%;height:25%}path.svelte-139m1ow.svelte-139m1ow{vector-effect:non-scaling-stroke;stroke-width:2px;stroke:var(--text-color)}.counter-viewport.svelte-139m1ow.svelte-139m1ow{width:8em;height:4em;overflow:hidden;text-align:center;position:relative}.counter-viewport.svelte-139m1ow strong.svelte-139m1ow{position:absolute;display:flex;width:100%;height:100%;font-weight:400;color:var(--accent-color);font-size:4rem;align-items:center;justify-content:center}.counter-digits.svelte-139m1ow.svelte-139m1ow{position:absolute;width:100%;height:100%}",
+  map: null
+};
+function modulo(n, m) {
+  return (n % m + m) % m;
+}
+const Counter = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  let offset;
+  let $displayed_count, $$unsubscribe_displayed_count;
+  let count = 0;
+  const displayed_count = spring();
+  $$unsubscribe_displayed_count = subscribe(displayed_count, (value) => $displayed_count = value);
+  $$result.css.add(css$1);
+  {
+    displayed_count.set(count);
+  }
+  offset = modulo($displayed_count, 1);
+  $$unsubscribe_displayed_count();
+  return `<div class="${"counter svelte-139m1ow"}"><button aria-label="${"Decrease the counter by one"}" class="${"svelte-139m1ow"}"><svg aria-hidden="${"true"}" viewBox="${"0 0 1 1"}" class="${"svelte-139m1ow"}"><path d="${"M0,0.5 L1,0.5"}" class="${"svelte-139m1ow"}"></path></svg></button>
+	<div class="${"counter-viewport svelte-139m1ow"}"><div class="${"counter-digits svelte-139m1ow"}" style="${"transform: translate(0, " + escape(100 * offset) + "%)"}"><strong style="${"top: -100%"}" aria-hidden="${"true"}" class="${"svelte-139m1ow"}">${escape(Math.floor($displayed_count + 1))}</strong>
+			<strong class="${"svelte-139m1ow"}">${escape(Math.floor($displayed_count))}</strong></div></div>
+	<button aria-label="${"Increase the counter by one"}" class="${"svelte-139m1ow"}"><svg aria-hidden="${"true"}" viewBox="${"0 0 1 1"}" class="${"svelte-139m1ow"}"><path d="${"M0,0.5 L1,0.5 M0.5,0 L0.5,1"}" class="${"svelte-139m1ow"}"></path></svg></button>
+</div>`;
+});
+var index_svelte_svelte_type_style_lang = "";
+const css = {
+  code: "section.svelte-mjk9ig.svelte-mjk9ig{display:flex;flex-direction:column;justify-content:center;align-items:center;flex:1}h1.svelte-mjk9ig.svelte-mjk9ig{width:100%}.welcome.svelte-mjk9ig.svelte-mjk9ig{position:relative;width:100%;height:0;padding:0 0 calc(100% * 495 / 2048) 0}.welcome.svelte-mjk9ig img.svelte-mjk9ig{position:absolute;width:100%;height:100%;top:0;display:block}",
+  map: null
+};
+const prerender = true;
+const Routes = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  $$result.css.add(css);
+  return `${$$result.head += `${$$result.title = `<title>Home</title>`, ""}`, ""}
+<section class="${"svelte-mjk9ig"}"><h1 class="${"svelte-mjk9ig"}"><div class="${"welcome svelte-mjk9ig"}"><picture><source srcset="${"svelte-welcome.webp"}" type="${"image/webp"}">
+				<img src="${"svelte-welcome.png"}" alt="${"Welcome"}" class="${"svelte-mjk9ig"}"></picture></div>
+		to your new<br>SvelteKit app
+	</h1>
+	<h2>try editing <strong>src/routes/index.svelte</strong></h2>
+	${validate_component(Counter, "Counter").$$render($$result, {}, {}, {})}
+</section>`;
+});
+export { Routes as default, prerender };

.svelte-kit/output/server/entries/pages/todos/index.svelte.js ADDED Viewed

	@@ -0,0 +1,37 @@

+import { c as create_ssr_component, h as each, e as escape, b as add_attribute } from "../../../chunks/index-c7a03ab5.js";
+var index_svelte_svelte_type_style_lang = "";
+const css = {
+  code: `.todos.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{width:100%;max-width:var(--column-width);margin:var(--column-margin-top) auto 0 auto;line-height:1}.new.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{margin:0 0 0.5rem 0}input.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{border:1px solid transparent}input.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd:focus-visible{box-shadow:inset 1px 1px 6px rgba(0, 0, 0, 0.1);border:1px solid #ff3e00 !important;outline:none}.new.svelte-dmxqmd input.svelte-dmxqmd.svelte-dmxqmd{font-size:28px;width:100%;padding:0.5em 1em 0.3em 1em;box-sizing:border-box;background:rgba(255, 255, 255, 0.05);border-radius:8px;text-align:center}.todo.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{display:grid;grid-template-columns:2rem 1fr 2rem;grid-gap:0.5rem;align-items:center;margin:0 0 0.5rem 0;padding:0.5rem;background-color:white;border-radius:8px;filter:drop-shadow(2px 4px 6px rgba(0, 0, 0, 0.1));transform:translate(-1px, -1px);transition:filter 0.2s, transform 0.2s}.done.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{transform:none;opacity:0.4;filter:drop-shadow(0px 0px 1px rgba(0, 0, 0, 0.1))}form.text.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{position:relative;display:flex;align-items:center;flex:1}.todo.svelte-dmxqmd input.svelte-dmxqmd.svelte-dmxqmd{flex:1;padding:0.5em 2em 0.5em 0.8em;border-radius:3px}.todo.svelte-dmxqmd button.svelte-dmxqmd.svelte-dmxqmd{width:2em;height:2em;border:none;background-color:transparent;background-position:50% 50%;background-repeat:no-repeat}button.toggle.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{border:1px solid rgba(0, 0, 0, 0.2);border-radius:50%;box-sizing:border-box;background-size:1em auto}.done.svelte-dmxqmd .toggle.svelte-dmxqmd.svelte-dmxqmd{background-image:url("data:image/svg+xml,%3Csvg width='22' height='16' viewBox='0 0 22 16' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M20.5 1.5L7.4375 14.5L1.5 8.5909' stroke='%23676778' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E")}.delete.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{background-image:url("data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M4.5 5V22H19.5V5H4.5Z' fill='%23676778' stroke='%23676778' stroke-width='1.5' stroke-linejoin='round'/%3E%3Cpath d='M10 10V16.5' stroke='white' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3Cpath d='M14 10V16.5' stroke='white' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3Cpath d='M2 5H22' stroke='%23676778' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3Cpath d='M8 5L9.6445 2H14.3885L16 5H8Z' fill='%23676778' stroke='%23676778' stroke-width='1.5' stroke-linejoin='round'/%3E%3C/svg%3E%0A");opacity:0.2}.delete.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd:hover,.delete.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd:focus{transition:opacity 0.2s;opacity:1}.save.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd{position:absolute;right:0;opacity:0;background-image:url("data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M20.5 2H3.5C2.67158 2 2 2.67157 2 3.5V20.5C2 21.3284 2.67158 22 3.5 22H20.5C21.3284 22 22 21.3284 22 20.5V3.5C22 2.67157 21.3284 2 20.5 2Z' fill='%23676778' stroke='%23676778' stroke-width='1.5' stroke-linejoin='round'/%3E%3Cpath d='M17 2V11H7.5V2H17Z' fill='white' stroke='white' stroke-width='1.5' stroke-linejoin='round'/%3E%3Cpath d='M13.5 5.5V7.5' stroke='%23676778' stroke-width='1.5' stroke-linecap='round'/%3E%3Cpath d='M5.99844 2H18.4992' stroke='%23676778' stroke-width='1.5' stroke-linecap='round'/%3E%3C/svg%3E%0A")}.todo.svelte-dmxqmd input.svelte-dmxqmd:focus+.save.svelte-dmxqmd,.save.svelte-dmxqmd.svelte-dmxqmd.svelte-dmxqmd:focus{transition:opacity 0.2s;opacity:1}`,
+  map: null
+};
+const load = async ({ fetch }) => {
+  const res = await fetch("/todos.json");
+  if (res.ok) {
+    const todos = await res.json();
+    return { props: { todos } };
+  }
+  const { message } = await res.json();
+  return { error: new Error(message) };
+};
+const Todos = create_ssr_component(($$result, $$props, $$bindings, slots) => {
+  let { todos } = $$props;
+  if ($$props.todos === void 0 && $$bindings.todos && todos !== void 0)
+    $$bindings.todos(todos);
+  $$result.css.add(css);
+  return `${$$result.head += `${$$result.title = `<title>Todos</title>`, ""}`, ""}
+<div class="${"todos svelte-dmxqmd"}"><h1>Todos</h1>
+	<form class="${"new svelte-dmxqmd"}" action="${"/todos.json"}" method="${"post"}"><input name="${"text"}" aria-label="${"Add todo"}" placeholder="${"+ tap to add a todo"}" class="${"svelte-dmxqmd"}"></form>
+	${each(todos, (todo) => `<div class="${["todo svelte-dmxqmd", todo.done ? "done" : ""].join(" ").trim()}"><form action="${"/todos/" + escape(todo.uid) + ".json?_method=patch"}" method="${"post"}"><input type="${"hidden"}" name="${"done"}"${add_attribute("value", todo.done ? "" : "true", 0)} class="${"svelte-dmxqmd"}">
+				<button class="${"toggle svelte-dmxqmd"}" aria-label="${"Mark todo as " + escape(todo.done ? "not done" : "done")}"></button></form>
+			<form class="${"text svelte-dmxqmd"}" action="${"/todos/" + escape(todo.uid) + ".json?_method=patch"}" method="${"post"}"><input aria-label="${"Edit todo"}" type="${"text"}" name="${"text"}"${add_attribute("value", todo.text, 0)} class="${"svelte-dmxqmd"}">
+				<button class="${"save svelte-dmxqmd"}" aria-label="${"Save todo"}"></button></form>
+			<form action="${"/todos/" + escape(todo.uid) + ".json?_method=delete"}" method="${"post"}"><button class="${"delete svelte-dmxqmd"}" aria-label="${"Delete todo"}" ${todo.pending_delete ? "disabled" : ""}></button></form>
+		</div>`)}
+</div>`;
+});
+export { Todos as default, load };

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

	@@ -0,0 +1,53 @@

+export const manifest = {
+	appDir: "_app",
+	assets: new Set(["favicon.png","robots.txt","svelte-welcome.png","svelte-welcome.webp"]),
+	_: {
+		mime: {".png":"image/png",".txt":"text/plain",".webp":"image/webp"},
+		entry: {"file":"start-2ccc875c.js","js":["start-2ccc875c.js","chunks/vendor-d68c61c2.js"],"css":["assets/start-61d1577b.css"]},
+		nodes: [
+			() => import('./nodes/0.js'),
+			() => import('./nodes/1.js'),
+			() => import('./nodes/2.js'),
+			() => import('./nodes/3.js'),
+			() => import('./nodes/4.js')
+		],
+		routes: [
+			{
+				type: 'page',
+				pattern: /^\/$/,
+				params: null,
+				path: "/",
+				a: [0,2],
+				b: [1]
+			},
+			{
+				type: 'page',
+				pattern: /^\/about\/?$/,
+				params: null,
+				path: "/about",
+				a: [0,3],
+				b: [1]
+			},
+			{
+				type: 'endpoint',
+				pattern: /^\/todos\.json$/,
+				params: null,
+				load: () => import('./entries/endpoints/todos/index.json.js')
+			},
+			{
+				type: 'page',
+				pattern: /^\/todos\/?$/,
+				params: null,
+				path: "/todos",
+				a: [0,4],
+				b: [1]
+			},
+			{
+				type: 'endpoint',
+				pattern: /^\/todos\/([^/]+?)\.json$/,
+				params: (m) => ({ uid: m[1]}),
+				load: () => import('./entries/endpoints/todos/_uid_.json.js')
+			}
+		]
+	}
+};