@openpalm/ui 0.11.0-rc.2

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

@@ -0,0 +1,1544 @@
+import { H as HttpError, S as SvelteKitError, c as base64_decode } from './utils-BSRjJDrZ.js';
+import { R as is_valid_array_len, M as MAX_ARRAY_INDEX, Q as is_valid_array_index, D as DevalueError, P as is_primitive, z as get_type, O as is_plain_object, o as enumerable_symbols, a7 as stringify_key, a8 as stringify_string, aa as valid_array_indices, Y as render, _ as set, L as LEGACY_PROPS, s as get, r as flushSync, l as define_property, T as mutable_source, K as init_operations, w as get_first_child, x as get_next_sibling, H as HYDRATION_ERROR, a3 as set_hydrating, a2 as set_hydrate_node, I as hydration_failed, g as clear_text_content, i as component_root, F as hydrate_node, k as create_text, f as boundary, c as array_from, N as is_passive_event, a1 as set_active_reaction, a0 as set_active_effect, b as active_reaction, a as active_effect, $ as setContext, m as derived, G as hydrating, W as push, h as component_context, J as hydration_mismatch, V as pop } from './dev-DjANv7AF.js';
+import 'node:module';
+
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/utils/functions.js
+function noop() {}
+/**
+* @template T
+* @param {() => T} fn
+*/
+function once(fn) {
+	let done = false;
+	/** @type T */
+	let result;
+	return () => {
+		if (done) return result;
+		done = true;
+		return result = fn();
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/runtime/server/constants.js
+var NULL_BODY_STATUS = [
+	101,
+	103,
+	204,
+	205,
+	304
+];
+var IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/exports/internal/event.js
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestStore } from 'types' */
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
+/** @type {RequestStore | null} */
+var sync_store = null;
+/** @type {AsyncLocalStorage<RequestStore | null> | null} */
+var als;
+import('node:async_hooks').then((hooks) => als = new hooks.AsyncLocalStorage()).catch(() => {});
+/**
+* @template T
+* @param {RequestStore | null} store
+* @param {() => T} fn
+*/
+function with_request_store(store, fn) {
+	try {
+		sync_store = store;
+		return als ? als.run(store, fn) : fn();
+	} finally {
+		if (!IN_WEBCONTAINER) sync_store = null;
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/exports/internal/server.js
+/**
+* @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
+* @param {T} event_like
+* @param {import('@opentelemetry/api').Span} current
+* @returns {T}
+*/
+function merge_tracing(event_like, current) {
+	return {
+		...event_like,
+		tracing: {
+			...event_like.tracing,
+			current
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/devalue@5.8.1/node_modules/devalue/src/base64.js
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_native(base64) {
+	return Uint8Array.fromBase64(base64).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString("base64");
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_buffer(base64) {
+	return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = "";
+	const chunk_size = 32768;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
+	return btoa(binary);
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_legacy(base64) {
+	const binary_string = atob(base64);
+	const len = binary_string.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binary_string.charCodeAt(i);
+	return array.buffer;
+}
+var native = typeof Uint8Array.fromBase64 === "function";
+var buffer = typeof process === "object" && process.versions?.node !== void 0;
+var encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+var decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
+//#endregion
+//#region ../../node_modules/.bun/devalue@5.8.1/node_modules/devalue/src/parse.js
+/**
+* Revive a value serialized with `devalue.stringify`
+* @param {string} serialized
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function parse(serialized, revivers) {
+	return unflatten(JSON.parse(serialized), revivers);
+}
+/**
+* Revive a value flattened with `devalue.stringify`
+* @param {number | any[]} parsed
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function unflatten(parsed, revivers) {
+	if (typeof parsed === "number") return hydrate(parsed, true);
+	if (!Array.isArray(parsed) || parsed.length === 0) throw new Error("Invalid input");
+	const values = parsed;
+	const hydrated = Array(values.length);
+	/**
+	* A set of values currently being hydrated with custom revivers,
+	* used to detect invalid cyclical dependencies
+	* @type {Set<number> | null}
+	*/
+	let hydrating = null;
+	/**
+	* @param {number} index
+	* @returns {any}
+	*/
+	function hydrate(index, standalone = false) {
+		if (index === -1) return void 0;
+		if (index === -3) return NaN;
+		if (index === -4) return Infinity;
+		if (index === -5) return -Infinity;
+		if (index === -6) return -0;
+		if (standalone || typeof index !== "number") throw new Error(`Invalid input`);
+		if (index in hydrated) return hydrated[index];
+		const value = values[index];
+		if (!value || typeof value !== "object") hydrated[index] = value;
+		else if (Array.isArray(value)) if (typeof value[0] === "string") {
+			const type = value[0];
+			const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : void 0;
+			if (reviver) {
+				let i = value[1];
+				if (typeof i !== "number") i = values.push(value[1]) - 1;
+				hydrating ??= /* @__PURE__ */ new Set();
+				if (hydrating.has(i)) throw new Error("Invalid circular reference");
+				hydrating.add(i);
+				hydrated[index] = reviver(hydrate(i));
+				hydrating.delete(i);
+				return hydrated[index];
+			}
+			switch (type) {
+				case "Date":
+					hydrated[index] = new Date(value[1]);
+					break;
+				case "Set":
+					const set = /* @__PURE__ */ new Set();
+					hydrated[index] = set;
+					for (let i = 1; i < value.length; i += 1) set.add(hydrate(value[i]));
+					break;
+				case "Map":
+					const map = /* @__PURE__ */ new Map();
+					hydrated[index] = map;
+					for (let i = 1; i < value.length; i += 2) map.set(hydrate(value[i]), hydrate(value[i + 1]));
+					break;
+				case "RegExp":
+					hydrated[index] = new RegExp(value[1], value[2]);
+					break;
+				case "Object": {
+					const wrapped_index = value[1];
+					if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") throw new Error("Invalid input");
+					hydrated[index] = Object(hydrate(wrapped_index));
+					break;
+				}
+				case "BigInt":
+					hydrated[index] = BigInt(value[1]);
+					break;
+				case "null":
+					const obj = Object.create(null);
+					hydrated[index] = obj;
+					for (let i = 1; i < value.length; i += 2) {
+						if (value[i] === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+						obj[value[i]] = hydrate(value[i + 1]);
+					}
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array":
+				case "DataView": {
+					if (values[value[1]][0] !== "ArrayBuffer") throw new Error("Invalid data");
+					const TypedArrayConstructor = globalThis[type];
+					const buffer = hydrate(value[1]);
+					hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer, value[2], value[3]) : new TypedArrayConstructor(buffer);
+					break;
+				}
+				case "ArrayBuffer": {
+					const base64 = value[1];
+					if (typeof base64 !== "string") throw new Error("Invalid ArrayBuffer encoding");
+					hydrated[index] = decode64(base64);
+					break;
+				}
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime": {
+					const temporalName = type.slice(9);
+					hydrated[index] = Temporal[temporalName].from(value[1]);
+					break;
+				}
+				case "URL":
+					hydrated[index] = new URL(value[1]);
+					break;
+				case "URLSearchParams":
+					hydrated[index] = new URLSearchParams(value[1]);
+					break;
+				default: throw new Error(`Unknown type ${type}`);
+			}
+		} else if (value[0] === -7) {
+			const len = value[1];
+			if (!is_valid_array_len(len)) throw new Error("Invalid input");
+			/** @type {any[]} */
+			const array = [];
+			hydrated[index] = array;
+			array[MAX_ARRAY_INDEX] = void 0;
+			delete array[MAX_ARRAY_INDEX];
+			for (let i = 2; i < value.length; i += 2) {
+				const idx = value[i];
+				if (!is_valid_array_index(idx) || idx >= len) throw new Error("Invalid input");
+				array[idx] = hydrate(value[i + 1]);
+			}
+			array.length = len;
+		} else {
+			const array = new Array(value.length);
+			hydrated[index] = array;
+			for (let i = 0; i < value.length; i += 1) {
+				const n = value[i];
+				if (n === -2) continue;
+				array[i] = hydrate(n);
+			}
+		}
+		else {
+			/** @type {Record<string, any>} */
+			const object = {};
+			hydrated[index] = object;
+			for (const key of Object.keys(value)) {
+				if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+				const n = value[key];
+				object[key] = hydrate(n);
+			}
+		}
+		return hydrated[index];
+	}
+	return hydrate(0);
+}
+//#endregion
+//#region ../../node_modules/.bun/devalue@5.8.1/node_modules/devalue/src/stringify.js
+/**
+* Turn a value into a JSON string that can be parsed with `devalue.parse`
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function stringify$1(value, reducers) {
+	const stringified = run(false, value, reducers);
+	return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+/**
+* @param {boolean} async
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function run(async, value, reducers) {
+	/** @type {any[]} */
+	const stringified = [];
+	/** @type {Map<any, number>} */
+	const indexes = /* @__PURE__ */ new Map();
+	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
+	const custom = [];
+	if (reducers) for (const key of Object.getOwnPropertyNames(reducers)) custom.push({
+		key,
+		fn: reducers[key]
+	});
+	/** @type {string[]} */
+	const keys = [];
+	let p = 0;
+	/**
+	* @param {any} thing
+	* @param {number} [index]
+	*/
+	function flatten(thing, index) {
+		if (thing === void 0) return -1;
+		if (Number.isNaN(thing)) return -3;
+		if (thing === Infinity) return -4;
+		if (thing === -Infinity) return -5;
+		if (thing === 0 && 1 / thing < 0) return -6;
+		if (indexes.has(thing)) return indexes.get(thing);
+		index ??= p++;
+		indexes.set(thing, index);
+		for (const { key, fn } of custom) {
+			const value = fn(thing);
+			if (value) {
+				stringified[index] = `["${key}",${flatten(value)}]`;
+				return index;
+			}
+		}
+		if (typeof thing === "function") throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		else if (typeof thing === "symbol") throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+		/** @type {string | Promise<any>} */
+		let str = "";
+		if (is_primitive(thing)) str = stringify_primitive(thing);
+		else if (typeof thing.then === "function") {
+			throw new DevalueError(`Cannot stringify a Promise or thenable — use stringifyAsync instead`, keys, thing, value);
+		} else {
+			const type = get_type(thing);
+			switch (type) {
+				case "Number":
+				case "String":
+				case "Boolean":
+				case "BigInt":
+					str = `["Object",${flatten(thing.valueOf())}]`;
+					break;
+				case "Date":
+					str = `["Date","${!isNaN(thing.getDate()) ? thing.toISOString() : ""}"]`;
+					break;
+				case "URL":
+					str = `["URL",${stringify_string(thing.toString())}]`;
+					break;
+				case "URLSearchParams":
+					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					break;
+				case "RegExp":
+					const { source, flags } = thing;
+					str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+					break;
+				case "Array": {
+					let mostly_dense = false;
+					str = "[";
+					for (let i = 0; i < thing.length; i += 1) {
+						if (i > 0) str += ",";
+						if (Object.hasOwn(thing, i)) {
+							keys.push(`[${i}]`);
+							str += flatten(thing[i]);
+							keys.pop();
+						} else if (mostly_dense) str += -2;
+						else {
+							const populated_keys = valid_array_indices(thing);
+							const population = populated_keys.length;
+							const d = String(thing.length).length;
+							if ((thing.length - population) * 3 > 4 + d + population * (d + 1)) {
+								str = "[-7," + thing.length;
+								for (let j = 0; j < populated_keys.length; j++) {
+									const key = populated_keys[j];
+									keys.push(`[${key}]`);
+									str += "," + key + "," + flatten(thing[key]);
+									keys.pop();
+								}
+								break;
+							} else {
+								mostly_dense = true;
+								str += -2;
+							}
+						}
+					}
+					str += "]";
+					break;
+				}
+				case "Set":
+					str = "[\"Set\"";
+					for (const value of thing) str += `,${flatten(value)}`;
+					str += "]";
+					break;
+				case "Map":
+					str = "[\"Map\"";
+					for (const [key, value] of thing) {
+						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+						str += `,${flatten(key)},${flatten(value)}`;
+						keys.pop();
+					}
+					str += "]";
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array":
+				case "DataView": {
+					/** @type {import("./types.js").TypedArray} */
+					const typedArray = thing;
+					str = "[\"" + type + "\"," + flatten(typedArray.buffer);
+					if (typedArray.byteLength !== typedArray.buffer.byteLength) str += `,${typedArray.byteOffset},${typedArray.length}`;
+					str += "]";
+					break;
+				}
+				case "ArrayBuffer":
+					str = `["ArrayBuffer","${encode64(thing)}"]`;
+					break;
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					str = `["${type}",${stringify_string(thing.toString())}]`;
+					break;
+				default:
+					if (!is_plain_object(thing)) throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
+					if (enumerable_symbols(thing).length > 0) throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
+					if (Object.getPrototypeOf(thing) === null) {
+						str = "[\"null\"";
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							keys.push(stringify_key(key));
+							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "]";
+					} else {
+						str = "{";
+						let started = false;
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							if (started) str += ",";
+							started = true;
+							keys.push(stringify_key(key));
+							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "}";
+					}
+			}
+		}
+		stringified[index] = str;
+		return index;
+	}
+	const index = flatten(value);
+	if (index < 0) return `${index}`;
+	return stringified;
+}
+/**
+* @param {any} thing
+* @returns {string}
+*/
+function stringify_primitive(thing) {
+	const type = typeof thing;
+	if (type === "string") return stringify_string(thing);
+	if (thing === void 0) return (-1).toString();
+	if (thing === 0 && 1 / thing < 0) return (-6).toString();
+	if (type === "bigint") return `["BigInt","${thing}"]`;
+	return String(thing);
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/utils/error.js
+/**
+* @param {unknown} err
+* @return {Error}
+*/
+function coalesce_to_error(err) {
+	return err instanceof Error || err && err.name && err.message ? err : new Error(JSON.stringify(err));
+}
+/**
+* This is an identity function that exists to make TypeScript less
+* paranoid about people throwing things that aren't errors, which
+* frankly is not something we should care about
+* @param {unknown} error
+*/
+function normalize_error(error) {
+	return error;
+}
+/**
+* @param {unknown} error
+*/
+function get_status(error) {
+	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+}
+/**
+* @param {unknown} error
+*/
+function get_message(error) {
+	return error instanceof SvelteKitError ? error.text : "Internal Error";
+}
+var INVALIDATED_PARAM = "x-sveltekit-invalidated";
+var TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
+/**
+* Try to `devalue.stringify` the data object using the provided transport encoders.
+* @param {any} data
+* @param {Transport} transport
+*/
+function stringify(data, transport) {
+	return stringify$1(data, Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode])));
+}
+var remote_object = "__skrao";
+var remote_map = "__skram";
+var remote_set = "__skras";
+/** @param {Transport} transport */
+function create_remote_arg_revivers(transport) {
+	const remote_fns_revivers = {
+		/** @type {(value: unknown) => unknown} */
+		[remote_object]: (value) => value,
+		/** @type {(value: unknown) => Map<unknown, unknown>} */
+		[remote_map]: (value) => {
+			if (!Array.isArray(value)) throw new Error("Invalid data for Map reviver");
+			const map = /* @__PURE__ */ new Map();
+			for (const item of value) {
+				if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || typeof item[1] !== "string") throw new Error("Invalid data for Map reviver");
+				const [key, val] = item;
+				map.set(parse$1(key), parse$1(val));
+			}
+			return map;
+		},
+		/** @type {(value: unknown) => Set<unknown>} */
+		[remote_set]: (value) => {
+			if (!Array.isArray(value)) throw new Error("Invalid data for Set reviver");
+			const set = /* @__PURE__ */ new Set();
+			for (const item of value) {
+				if (typeof item !== "string") throw new Error("Invalid data for Set reviver");
+				set.add(parse$1(item));
+			}
+			return set;
+		}
+	};
+	const all_revivers = {
+		...Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode])),
+		...remote_fns_revivers
+	};
+	/** @type {(data: string) => unknown} */
+	const parse$1 = (data) => parse(data, all_revivers);
+	return all_revivers;
+}
+/**
+* Parses the argument (if any) for a remote function
+* @param {string} string
+* @param {Transport} transport
+*/
+function parse_remote_arg(string, transport) {
+	if (!string) return void 0;
+	return parse(new TextDecoder().decode(base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))), create_remote_arg_revivers(transport));
+}
+/**
+* @param {string} id
+* @param {string} payload
+*/
+function create_remote_key(id, payload) {
+	return id + "/" + payload;
+}
+/**
+* @param {string} key
+* @returns {{ id: string; payload: string }}
+*/
+function split_remote_key(key) {
+	const i = key.lastIndexOf("/");
+	if (i === -1) throw new Error(`Invalid remote key: ${key}`);
+	return {
+		id: key.slice(0, i),
+		payload: key.slice(i + 1)
+	};
+}
+
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/utils/array.js
+/**
+* Removes nullish values from an array.
+*
+* @template T
+* @param {Array<T>} arr
+*/
+function compact(arr) {
+	return arr.filter(
+		/** @returns {val is NonNullable<T>} */
+		(val) => val != null
+	);
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/runtime/telemetry/noop.js
+/**
+* @type {Span}
+*/
+var noop_span = {
+	spanContext() {
+		return noop_span_context;
+	},
+	setAttribute() {
+		return this;
+	},
+	setAttributes() {
+		return this;
+	},
+	addEvent() {
+		return this;
+	},
+	setStatus() {
+		return this;
+	},
+	updateName() {
+		return this;
+	},
+	end() {
+		return this;
+	},
+	isRecording() {
+		return false;
+	},
+	recordException() {
+		return this;
+	},
+	addLink() {
+		return this;
+	},
+	addLinks() {
+		return this;
+	}
+};
+/**
+* @type {SpanContext}
+*/
+var noop_span_context = {
+	traceId: "",
+	spanId: "",
+	traceFlags: 0
+};
+var internal = new URL("sveltekit-internal://");
+/**
+* @param {string} base
+* @param {string} path
+*/
+function resolve(base, path) {
+	if (path[0] === "/" && path[1] === "/") return path;
+	let url = new URL(base, internal);
+	url = new URL(path, url);
+	return url.protocol === internal.protocol ? url.pathname + url.search + url.hash : url.href;
+}
+/**
+* @param {string} path
+* @param {import('types').TrailingSlash} trailing_slash
+*/
+function normalize_path(path, trailing_slash) {
+	if (path === "/" || trailing_slash === "ignore") return path;
+	if (trailing_slash === "never") return path.endsWith("/") ? path.slice(0, -1) : path;
+	else if (trailing_slash === "always" && !path.endsWith("/")) return path + "/";
+	return path;
+}
+/**
+* Decode pathname excluding %25 to prevent further double decoding of params
+* @param {string} pathname
+*/
+function decode_pathname(pathname) {
+	return pathname.split("%25").map(decodeURI).join("%25");
+}
+/** @param {Record<string, string>} params */
+function decode_params(params) {
+	for (const key in params) params[key] = decodeURIComponent(params[key]);
+	return params;
+}
+/**
+* @param {URL} url
+* @param {() => void} callback
+* @param {(search_param: string) => void} search_params_callback
+* @param {boolean} [allow_hash]
+*/
+function make_trackable(url, callback, search_params_callback, allow_hash = false) {
+	const tracked = new URL(url);
+	Object.defineProperty(tracked, "searchParams", {
+		value: new Proxy(tracked.searchParams, { get(obj, key) {
+			if (key === "get" || key === "getAll" || key === "has") return (param, ...rest) => {
+				search_params_callback(param);
+				return obj[key](param, ...rest);
+			};
+			callback();
+			const value = Reflect.get(obj, key);
+			return typeof value === "function" ? value.bind(obj) : value;
+		} }),
+		enumerable: true,
+		configurable: true
+	});
+	/**
+	* URL properties that could change during the lifetime of the page,
+	* which excludes things like `origin`
+	*/
+	const tracked_url_properties = [
+		"href",
+		"pathname",
+		"search",
+		"toString",
+		"toJSON"
+	];
+	if (allow_hash) tracked_url_properties.push("hash");
+	for (const property of tracked_url_properties) Object.defineProperty(tracked, property, {
+		get() {
+			callback();
+			return url[property];
+		},
+		enumerable: true,
+		configurable: true
+	});
+	tracked[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(url, opts);
+	};
+	tracked.searchParams[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(url.searchParams, opts);
+	};
+	if (!allow_hash) disable_hash(tracked);
+	return tracked;
+}
+/**
+* Disallow access to `url.hash` on the server and in `load`
+* @param {URL} url
+*/
+function disable_hash(url) {
+	allow_nodejs_console_log(url);
+	Object.defineProperty(url, "hash", { get() {
+		throw new Error("Cannot access event.url.hash. Consider using `page.url.hash` inside a component instead");
+	} });
+}
+/**
+* Disallow access to `url.search` and `url.searchParams` during prerendering
+* @param {URL} url
+*/
+function disable_search(url) {
+	allow_nodejs_console_log(url);
+	for (const property of ["search", "searchParams"]) Object.defineProperty(url, property, { get() {
+		throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+	} });
+}
+/**
+* Allow URL to be console logged, bypassing disabled properties.
+* @param {URL} url
+*/
+function allow_nodejs_console_log(url) {
+	url[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(new URL(url), opts);
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/utils/hash.js
+/**
+* Hash using djb2
+* @param {import('types').StrictBody[]} values
+*/
+function hash(...values) {
+	let hash = 5381;
+	for (const value of values) if (typeof value === "string") {
+		let i = value.length;
+		while (i) hash = hash * 33 ^ value.charCodeAt(--i);
+	} else if (ArrayBuffer.isView(value)) {
+		const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+		let i = buffer.length;
+		while (i) hash = hash * 33 ^ buffer[--i];
+	} else throw new TypeError("value must be a string or TypedArray");
+	return (hash >>> 0).toString(36);
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/utils/routing.js
+/**
+* @param {RegExpMatchArray} match
+* @param {import('types').RouteParam[]} params
+* @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+*/
+function exec(match, params, matchers) {
+	/** @type {Record<string, string>} */
+	const result = {};
+	const values = match.slice(1);
+	const values_needing_match = values.filter((value) => value !== void 0);
+	let buffered = 0;
+	for (let i = 0; i < params.length; i += 1) {
+		const param = params[i];
+		let value = values[i - buffered];
+		if (param.chained && param.rest && buffered) {
+			value = values.slice(i - buffered, i + 1).filter((s) => s).join("/");
+			buffered = 0;
+		}
+		if (value === void 0) if (param.rest) value = "";
+		else continue;
+		if (!param.matcher || matchers[param.matcher](value)) {
+			result[param.name] = value;
+			const next_param = params[i + 1];
+			const next_value = values[i + 1];
+			if (next_param && !next_param.rest && next_param.optional && next_value && param.chained) buffered = 0;
+			if (!next_param && !next_value && Object.keys(result).length === values_needing_match.length) buffered = 0;
+			continue;
+		}
+		if (param.optional && param.chained) {
+			buffered++;
+			continue;
+		}
+		return;
+	}
+	if (buffered) return;
+	return result;
+}
+/**
+* Find the first route that matches the given path
+* @template {{pattern: RegExp, params: import('types').RouteParam[]}} Route
+* @param {string} path - The decoded pathname to match
+* @param {Route[]} routes
+* @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+* @returns {{ route: Route, params: Record<string, string> } | null}
+*/
+function find_route(path, routes, matchers) {
+	for (const route of routes) {
+		const match = route.pattern.exec(path);
+		if (!match) continue;
+		const matched = exec(match, route.params, matchers);
+		if (matched) return {
+			route,
+			params: decode_params(matched)
+		};
+	}
+	return null;
+}
+//#endregion
+//#region ../../node_modules/.bun/@sveltejs+kit@2.61.0+aeb06e9cf8e23ab6/node_modules/@sveltejs/kit/src/utils/exports.js
+/**
+* @param {Set<string>} expected
+*/
+function validator(expected) {
+	/**
+	* @param {any} module
+	* @param {string} [file]
+	*/
+	function validate(module, file) {
+		if (!module) return;
+		for (const key in module) {
+			if (key[0] === "_" || expected.has(key)) continue;
+			const values = [...expected.values()];
+			const hint = hint_for_supported_files(key, file?.slice(file.lastIndexOf("."))) ?? `valid exports are ${values.join(", ")}, or anything with a '_' prefix`;
+			throw new Error(`Invalid export '${key}'${file ? ` in ${file}` : ""} (${hint})`);
+		}
+	}
+	return validate;
+}
+/**
+* @param {string} key
+* @param {string} ext
+* @returns {string | void}
+*/
+function hint_for_supported_files(key, ext = ".js") {
+	const supported_files = [];
+	if (valid_layout_exports.has(key)) supported_files.push(`+layout${ext}`);
+	if (valid_page_exports.has(key)) supported_files.push(`+page${ext}`);
+	if (valid_layout_server_exports.has(key)) supported_files.push(`+layout.server${ext}`);
+	if (valid_page_server_exports.has(key)) supported_files.push(`+page.server${ext}`);
+	if (valid_server_exports.has(key)) supported_files.push(`+server${ext}`);
+	if (supported_files.length > 0) return `'${key}' is a valid export in ${supported_files.slice(0, -1).join(", ")}${supported_files.length > 1 ? " or " : ""}${supported_files.at(-1)}`;
+}
+var valid_layout_exports = new Set([
+	"load",
+	"prerender",
+	"csr",
+	"ssr",
+	"trailingSlash",
+	"config"
+]);
+var valid_page_exports = new Set([...valid_layout_exports, "entries"]);
+var valid_layout_server_exports = new Set([...valid_layout_exports]);
+var valid_page_server_exports = new Set([
+	...valid_layout_server_exports,
+	"actions",
+	"entries"
+]);
+var valid_server_exports = new Set([
+	"GET",
+	"POST",
+	"PATCH",
+	"PUT",
+	"DELETE",
+	"OPTIONS",
+	"HEAD",
+	"fallback",
+	"prerender",
+	"trailingSlash",
+	"config",
+	"entries"
+]);
+var validate_layout_exports = validator(valid_layout_exports);
+var validate_page_exports = validator(valid_page_exports);
+var validate_layout_server_exports = validator(valid_layout_server_exports);
+var validate_page_server_exports = validator(valid_page_server_exports);
+
+//#region \0virtual:__sveltekit/server
+var read_implementation = null;
+function set_read_implementation(fn) {
+	read_implementation = fn;
+}
+//#endregion
+//#region ../../node_modules/.bun/svelte@5.55.9+b050a890ad81aed8/node_modules/svelte/src/internal/client/dom/elements/events.js
+/**
+* Used on elements, as a map of event type -> event handler,
+* and on events themselves to track which element handled an event
+*/
+var event_symbol = Symbol("events");
+/** @type {Set<string>} */
+var all_registered_events = /* @__PURE__ */ new Set();
+/** @type {Set<(events: Array<string>) => void>} */
+var root_event_handles = /* @__PURE__ */ new Set();
+var last_propagated_event = null;
+/**
+* @this {EventTarget}
+* @param {Event} event
+* @returns {void}
+*/
+function handle_event_propagation(event) {
+	var handler_element = this;
+	var owner_document = handler_element.ownerDocument;
+	var event_name = event.type;
+	var path = event.composedPath?.() || [];
+	var current_target = path[0] || event.target;
+	last_propagated_event = event;
+	var path_idx = 0;
+	var handled_at = last_propagated_event === event && event[event_symbol];
+	if (handled_at) {
+		var at_idx = path.indexOf(handled_at);
+		if (at_idx !== -1 && (handler_element === document || handler_element === window)) {
+			event[event_symbol] = handler_element;
+			return;
+		}
+		var handler_idx = path.indexOf(handler_element);
+		if (handler_idx === -1) return;
+		if (at_idx <= handler_idx) path_idx = at_idx;
+	}
+	current_target = path[path_idx] || event.target;
+	if (current_target === handler_element) return;
+	define_property(event, "currentTarget", {
+		configurable: true,
+		get() {
+			return current_target || owner_document;
+		}
+	});
+	var previous_reaction = active_reaction;
+	var previous_effect = active_effect;
+	set_active_reaction(null);
+	set_active_effect(null);
+	try {
+		/**
+		* @type {unknown}
+		*/
+		var throw_error;
+		/**
+		* @type {unknown[]}
+		*/
+		var other_errors = [];
+		while (current_target !== null) {
+			/** @type {null | Element} */
+			var parent_element = current_target.assignedSlot || current_target.parentNode || current_target.host || null;
+			try {
+				var delegated = current_target[event_symbol]?.[event_name];
+				if (delegated != null && (!current_target.disabled || event.target === current_target)) delegated.call(current_target, event);
+			} catch (error) {
+				if (throw_error) other_errors.push(error);
+				else throw_error = error;
+			}
+			if (event.cancelBubble || parent_element === handler_element || parent_element === null) break;
+			current_target = parent_element;
+		}
+		if (throw_error) {
+			for (let error of other_errors) queueMicrotask(() => {
+				throw error;
+			});
+			throw throw_error;
+		}
+	} finally {
+		event[event_symbol] = handler_element;
+		delete event.currentTarget;
+		set_active_reaction(previous_reaction);
+		set_active_effect(previous_effect);
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/svelte@5.55.9+b050a890ad81aed8/node_modules/svelte/src/internal/client/dom/template.js
+/**
+* @param {TemplateNode} start
+* @param {TemplateNode | null} end
+*/
+function assign_nodes(start, end) {
+	var effect = active_effect;
+	if (effect.nodes === null) effect.nodes = {
+		start,
+		end,
+		a: null,
+		t: null
+	};
+}
+/**
+* Mounts a component to the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component.
+* Transitions will play during the initial render unless the `intro` option is set to `false`.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
+* @param {MountOptions<Props>} options
+* @returns {Exports}
+*/
+function mount(component, options) {
+	return _mount(component, options);
+}
+/**
+* Hydrates a component on the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
+* @param {{} extends Props ? {
+* 		target: Document | Element | ShadowRoot;
+* 		props?: Props;
+* 		events?: Record<string, (e: any) => any>;
+*  	context?: Map<any, any>;
+* 		intro?: boolean;
+* 		recover?: boolean;
+*		transformError?: (error: unknown) => unknown;
+* 	} : {
+* 		target: Document | Element | ShadowRoot;
+* 		props: Props;
+* 		events?: Record<string, (e: any) => any>;
+*  	context?: Map<any, any>;
+* 		intro?: boolean;
+* 		recover?: boolean;
+*		transformError?: (error: unknown) => unknown;
+* 	}} options
+* @returns {Exports}
+*/
+function hydrate(component, options) {
+	init_operations();
+	options.intro = options.intro ?? false;
+	const target = options.target;
+	const was_hydrating = hydrating;
+	const previous_hydrate_node = hydrate_node;
+	try {
+		var anchor = /* @__PURE__ */ get_first_child(target);
+		while (anchor && (anchor.nodeType !== 8 || anchor.data !== "[")) anchor = /* @__PURE__ */ get_next_sibling(anchor);
+		if (!anchor) throw HYDRATION_ERROR;
+		set_hydrating(true);
+		set_hydrate_node(anchor);
+		const instance = _mount(component, {
+			...options,
+			anchor
+		});
+		set_hydrating(false);
+		return instance;
+	} catch (error) {
+		if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) throw error;
+		if (error !== HYDRATION_ERROR) console.warn("Failed to hydrate: ", error);
+		if (options.recover === false) hydration_failed();
+		init_operations();
+		clear_text_content(target);
+		set_hydrating(false);
+		return mount(component, options);
+	} finally {
+		set_hydrating(was_hydrating);
+		set_hydrate_node(previous_hydrate_node);
+	}
+}
+/** @type {Map<EventTarget, Map<string, number>>} */
+var listeners = /* @__PURE__ */ new Map();
+/**
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<any>> | Component<any>} Component
+* @param {MountOptions} options
+* @returns {Exports}
+*/
+function _mount(Component, { target, anchor, props = {}, events, context, intro = true, transformError }) {
+	init_operations();
+	/** @type {Exports} */
+	var component = void 0;
+	var unmount = component_root(() => {
+		var anchor_node = anchor ?? target.appendChild(create_text());
+		boundary(anchor_node, { pending: () => {} }, (anchor_node) => {
+			push({});
+			var ctx = component_context;
+			if (context) ctx.c = context;
+			if (events)
+ /** @type {any} */ props.$$events = events;
+			if (hydrating) assign_nodes(anchor_node, null);
+			component = Component(anchor_node, props) || {};
+			if (hydrating) {
+				/** @type {Effect & { nodes: EffectNodes }} */ active_effect.nodes.end = hydrate_node;
+				if (hydrate_node === null || hydrate_node.nodeType !== 8 || hydrate_node.data !== "]") {
+					hydration_mismatch();
+					throw HYDRATION_ERROR;
+				}
+			}
+			pop();
+		}, transformError);
+		/** @type {Set<string>} */
+		var registered_events = /* @__PURE__ */ new Set();
+		/** @param {Array<string>} events */
+		var event_handle = (events) => {
+			for (var i = 0; i < events.length; i++) {
+				var event_name = events[i];
+				if (registered_events.has(event_name)) continue;
+				registered_events.add(event_name);
+				var passive = is_passive_event(event_name);
+				for (const node of [target, document]) {
+					var counts = listeners.get(node);
+					if (counts === void 0) {
+						counts = /* @__PURE__ */ new Map();
+						listeners.set(node, counts);
+					}
+					var count = counts.get(event_name);
+					if (count === void 0) {
+						node.addEventListener(event_name, handle_event_propagation, { passive });
+						counts.set(event_name, 1);
+					} else counts.set(event_name, count + 1);
+				}
+			}
+		};
+		event_handle(array_from(all_registered_events));
+		root_event_handles.add(event_handle);
+		return () => {
+			for (var event_name of registered_events) for (const node of [target, document]) {
+				var counts = listeners.get(node);
+				var count = counts.get(event_name);
+				if (--count == 0) {
+					node.removeEventListener(event_name, handle_event_propagation);
+					counts.delete(event_name);
+					if (counts.size === 0) listeners.delete(node);
+				} else counts.set(event_name, count);
+			}
+			root_event_handles.delete(event_handle);
+			if (anchor_node !== anchor) anchor_node.parentNode?.removeChild(anchor_node);
+		};
+	});
+	mounted_components.set(component, unmount);
+	return component;
+}
+/**
+* References of the components that were mounted or hydrated.
+* Uses a `WeakMap` to avoid memory leaks.
+*/
+var mounted_components = /* @__PURE__ */ new WeakMap();
+/**
+* Unmounts a component that was previously mounted using `mount` or `hydrate`.
+*
+* Since 5.13.0, if `options.outro` is `true`, [transitions](https://svelte.dev/docs/svelte/transition) will play before the component is removed from the DOM.
+*
+* Returns a `Promise` that resolves after transitions have completed if `options.outro` is true, or immediately otherwise (prior to 5.13.0, returns `void`).
+*
+* ```js
+* import { mount, unmount } from 'svelte';
+* import App from './App.svelte';
+*
+* const app = mount(App, { target: document.body });
+*
+* // later...
+* unmount(app, { outro: true });
+* ```
+* @param {Record<string, any>} component
+* @param {{ outro?: boolean }} [options]
+* @returns {Promise<void>}
+*/
+function unmount(component, options) {
+	const fn = mounted_components.get(component);
+	if (fn) {
+		mounted_components.delete(component);
+		return fn(options);
+	}
+	return Promise.resolve();
+}
+//#endregion
+//#region ../../node_modules/.bun/svelte@5.55.9+b050a890ad81aed8/node_modules/svelte/src/legacy/legacy-client.js
+/** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
+/**
+* Takes the component function and returns a Svelte 4 compatible component constructor.
+*
+* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @template {Record<string, any>} Events
+* @template {Record<string, any>} Slots
+*
+* @param {SvelteComponent<Props, Events, Slots> | Component<Props>} component
+* @returns {ComponentType<SvelteComponent<Props, Events, Slots> & Exports>}
+*/
+function asClassComponent$1(component) {
+	return class extends Svelte4Component {
+		/** @param {any} options */
+		constructor(options) {
+			super({
+				component,
+				...options
+			});
+		}
+	};
+}
+/**
+* Support using the component as both a class and function during the transition period
+* @typedef  {{new (o: ComponentConstructorOptions): SvelteComponent;(...args: Parameters<Component<Record<string, any>>>): ReturnType<Component<Record<string, any>, Record<string, any>>>;}} LegacyComponentType
+*/
+var Svelte4Component = class {
+	/** @type {any} */
+	#events;
+	/** @type {Record<string, any>} */
+	#instance;
+	/**
+	* @param {ComponentConstructorOptions & {
+	*  component: any;
+	* }} options
+	*/
+	constructor(options) {
+		var sources = /* @__PURE__ */ new Map();
+		/**
+		* @param {string | symbol} key
+		* @param {unknown} value
+		*/
+		var add_source = (key, value) => {
+			var s = /* @__PURE__ */ mutable_source(value, false, false);
+			sources.set(key, s);
+			return s;
+		};
+		const props = new Proxy({
+			...options.props || {},
+			$$events: {}
+		}, {
+			get(target, prop) {
+				return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+			},
+			has(target, prop) {
+				if (prop === LEGACY_PROPS) return true;
+				get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+				return Reflect.has(target, prop);
+			},
+			set(target, prop, value) {
+				set(sources.get(prop) ?? add_source(prop, value), value);
+				return Reflect.set(target, prop, value);
+			}
+		});
+		this.#instance = (options.hydrate ? hydrate : mount)(options.component, {
+			target: options.target,
+			anchor: options.anchor,
+			props,
+			context: options.context,
+			intro: options.intro ?? false,
+			recover: options.recover,
+			transformError: options.transformError
+		});
+		if ((!options?.props?.$$host || options.sync === false)) flushSync();
+		this.#events = props.$$events;
+		for (const key of Object.keys(this.#instance)) {
+			if (key === "$set" || key === "$destroy" || key === "$on") continue;
+			define_property(this, key, {
+				get() {
+					return this.#instance[key];
+				},
+				/** @param {any} value */
+				set(value) {
+					this.#instance[key] = value;
+				},
+				enumerable: true
+			});
+		}
+		this.#instance.$set = (next) => {
+			Object.assign(props, next);
+		};
+		this.#instance.$destroy = () => {
+			unmount(this.#instance);
+		};
+	}
+	/** @param {Record<string, any>} props */
+	$set(props) {
+		this.#instance.$set(props);
+	}
+	/**
+	* @param {string} event
+	* @param {(...args: any[]) => any} callback
+	* @returns {any}
+	*/
+	$on(event, callback) {
+		this.#events[event] = this.#events[event] || [];
+		/** @param {any[]} args */
+		const cb = (...args) => callback.call(this, ...args);
+		this.#events[event].push(cb);
+		return () => {
+			this.#events[event] = this.#events[event].filter(
+				/** @param {any} fn */
+				(fn) => fn !== cb
+			);
+		};
+	}
+	$destroy() {
+		this.#instance.$destroy();
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/svelte@5.55.9+b050a890ad81aed8/node_modules/svelte/src/legacy/legacy-server.js
+/** @import { SvelteComponent } from '../index.js' */
+/** @import { Csp } from '#server' */
+/** @typedef {{ head: string, html: string, css: { code: string, map: null }; hashes?: { script: `sha256-${string}`[] } }} LegacyRenderResult */
+/**
+* Takes a Svelte 5 component and returns a Svelte 4 compatible component constructor.
+*
+* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @template {Record<string, any>} Events
+* @template {Record<string, any>} Slots
+*
+* @param {SvelteComponent<Props, Events, Slots>} component
+* @returns {typeof SvelteComponent<Props, Events, Slots> & Exports}
+*/
+function asClassComponent(component) {
+	const component_constructor = asClassComponent$1(component);
+	/** @type {(props?: {}, opts?: { $$slots?: {}; context?: Map<any, any>; csp?: Csp; transformError?: (error: unknown) => unknown }) => LegacyRenderResult & PromiseLike<LegacyRenderResult> } */
+	const _render = (props, { context, csp, transformError } = {}) => {
+		const result = render(component, {
+			props,
+			context,
+			csp,
+			transformError
+		});
+		const munged = Object.defineProperties({}, {
+			css: { value: {
+				code: "",
+				map: null
+			} },
+			head: { get: () => result.head },
+			html: { get: () => result.body },
+			then: { 
+			/**
+			* this is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
+			*
+			* @template TResult1
+			* @template [TResult2=never]
+			* @param { (value: LegacyRenderResult) => TResult1 } onfulfilled
+			* @param { (reason: unknown) => TResult2 } onrejected
+			*/
+value: (onfulfilled, onrejected) => {
+				{
+					const user_result = onfulfilled({
+						css: munged.css,
+						head: munged.head,
+						html: munged.html
+					});
+					return Promise.resolve(user_result);
+				}
+			} }
+		});
+		return munged;
+	};
+	component_constructor.render = _render;
+	return component_constructor;
+}
+//#endregion
+//#region .svelte-kit/generated/root.svelte
+function Root($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { stores, page, constructors, components = [], form, data_0 = null, data_1 = null, data_2 = null } = $$props;
+		setContext("__svelte__", stores);
+		stores.page.set(page);
+		const Pyramid_2 = derived(() => constructors[2]);
+		if (constructors[1]) {
+			$$renderer.push("<!--[0-->");
+			const Pyramid_0 = constructors[0];
+			if (Pyramid_0) {
+				$$renderer.push("<!--[-->");
+				Pyramid_0($$renderer, {
+					data: data_0,
+					form,
+					params: page.params,
+					children: ($$renderer) => {
+						if (constructors[2]) {
+							$$renderer.push("<!--[0-->");
+							const Pyramid_1 = constructors[1];
+							if (Pyramid_1) {
+								$$renderer.push("<!--[-->");
+								Pyramid_1($$renderer, {
+									data: data_1,
+									form,
+									params: page.params,
+									children: ($$renderer) => {
+										if (Pyramid_2()) {
+											$$renderer.push("<!--[-->");
+											Pyramid_2()($$renderer, {
+												data: data_2,
+												form,
+												params: page.params
+											});
+											$$renderer.push("<!--]-->");
+										} else {
+											$$renderer.push("<!--[!-->");
+											$$renderer.push("<!--]-->");
+										}
+									},
+									$$slots: { default: true }
+								});
+								$$renderer.push("<!--]-->");
+							} else {
+								$$renderer.push("<!--[!-->");
+								$$renderer.push("<!--]-->");
+							}
+						} else {
+							$$renderer.push("<!--[-1-->");
+							const Pyramid_1 = constructors[1];
+							if (Pyramid_1) {
+								$$renderer.push("<!--[-->");
+								Pyramid_1($$renderer, {
+									data: data_1,
+									form,
+									params: page.params
+								});
+								$$renderer.push("<!--]-->");
+							} else {
+								$$renderer.push("<!--[!-->");
+								$$renderer.push("<!--]-->");
+							}
+						}
+						$$renderer.push(`<!--]-->`);
+					},
+					$$slots: { default: true }
+				});
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		} else {
+			$$renderer.push("<!--[-1-->");
+			const Pyramid_0 = constructors[0];
+			if (Pyramid_0) {
+				$$renderer.push("<!--[-->");
+				Pyramid_0($$renderer, {
+					data: data_0,
+					form,
+					params: page.params
+				});
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		$$renderer.push(`<!--]--> `);
+		$$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+	});
+}
+//#endregion
+//#region .svelte-kit/generated/server/internal.js
+var options = {
+	app_template_contains_nonce: false,
+	async: false,
+	csp: {
+		"mode": "hash",
+		"directives": {
+			"default-src": ["self"],
+			"frame-src": [
+				"self",
+				"http://localhost:*",
+				"http://127.0.0.1:*",
+				"https://localhost:*",
+				"https://127.0.0.1:*"
+			],
+			"connect-src": ["self"],
+			"font-src": ["self", "https://fonts.gstatic.com"],
+			"img-src": ["self", "data:"],
+			"media-src": ["self", "blob:"],
+			"object-src": ["none"],
+			"script-src": ["self"],
+			"style-src": [
+				"self",
+				"unsafe-inline",
+				"https://fonts.googleapis.com"
+			],
+			"base-uri": ["none"],
+			"frame-ancestors": ["none"],
+			"upgrade-insecure-requests": false,
+			"block-all-mixed-content": false
+		},
+		"reportOnly": {
+			"upgrade-insecure-requests": false,
+			"block-all-mixed-content": false
+		}
+	},
+	csrf_check_origin: true,
+	csrf_trusted_origins: [],
+	embedded: false,
+	env_public_prefix: "PUBLIC_",
+	env_private_prefix: "",
+	hash_routing: false,
+	hooks: null,
+	preload_strategy: "modulepreload",
+	root: asClassComponent(Root),
+	service_worker: false,
+	service_worker_options: void 0,
+	server_error_boundaries: false,
+	templates: {
+		app: ({ head, body, assets, nonce, env }) => "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <meta name=\"theme-color\" content=\"#ffffff\" />\n    <meta name=\"color-scheme\" content=\"light\" />\n    <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n    <link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin />\n    <link\n      href=\"https://fonts.googleapis.com/css2?family=Source+Sans+3:wght@400;500;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap\"\n      rel=\"stylesheet\"\n    />\n    " + head + "\n  </head>\n  <body data-sveltekit-preload-data=\"hover\">\n    <div style=\"display: contents\">" + body + "</div>\n  </body>\n</html>\n",
+		error: ({ status, message }) => "<!doctype html>\n<html lang=\"en\">\n	<head>\n		<meta charset=\"utf-8\" />\n		<title>" + message + "</title>\n\n		<style>\n			body {\n				--bg: white;\n				--fg: #222;\n				--divider: #ccc;\n				background: var(--bg);\n				color: var(--fg);\n				font-family:\n					system-ui,\n					-apple-system,\n					BlinkMacSystemFont,\n					'Segoe UI',\n					Roboto,\n					Oxygen,\n					Ubuntu,\n					Cantarell,\n					'Open Sans',\n					'Helvetica Neue',\n					sans-serif;\n				display: flex;\n				align-items: center;\n				justify-content: center;\n				height: 100vh;\n				margin: 0;\n			}\n\n			.error {\n				display: flex;\n				align-items: center;\n				max-width: 32rem;\n				margin: 0 1rem;\n			}\n\n			.status {\n				font-weight: 200;\n				font-size: 3rem;\n				line-height: 1;\n				position: relative;\n				top: -0.05rem;\n			}\n\n			.message {\n				border-left: 1px solid var(--divider);\n				padding: 0 0 0 1rem;\n				margin: 0 0 0 1rem;\n				min-height: 2.5rem;\n				display: flex;\n				align-items: center;\n			}\n\n			.message h1 {\n				font-weight: 400;\n				font-size: 1em;\n				margin: 0;\n			}\n\n			@media (prefers-color-scheme: dark) {\n				body {\n					--bg: #222;\n					--fg: #ddd;\n					--divider: #666;\n				}\n			}\n		</style>\n	</head>\n	<body>\n		<div class=\"error\">\n			<span class=\"status\">" + status + "</span>\n			<div class=\"message\">\n				<h1>" + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
+	},
+	version_hash: "7dmwv9"
+};
+async function get_hooks() {
+	let handle;
+	let handleFetch;
+	let handleError;
+	let handleValidationError;
+	let init;
+	({handle, handleFetch, handleError, handleValidationError, init} = await import('./hooks.server-Al9-eO5K.js'));
+	let reroute;
+	let transport;
+	return {
+		handle,
+		handleFetch,
+		handleError,
+		handleValidationError,
+		init,
+		reroute,
+		transport
+	};
+}
+
+export { stringify$1 as A, validate_layout_exports as B, validate_layout_server_exports as C, validate_page_exports as D, validate_page_server_exports as E, with_request_store as F, INVALIDATED_PARAM as I, NULL_BODY_STATUS as N, TRAILING_SLASH_PARAM as T, IN_WEBCONTAINER as a, compact as b, coalesce_to_error as c, create_remote_key as d, decode_pathname as e, disable_search as f, find_route as g, get_hooks as h, get_message as i, get_status as j, hash as k, merge_tracing as l, make_trackable as m, noop as n, noop_span as o, normalize_error as p, normalize_path as q, once as r, options as s, parse as t, parse_remote_arg as u, read_implementation as v, resolve as w, set_read_implementation as x, split_remote_key as y, stringify as z };
+//# sourceMappingURL=internal-CJBOAkaQ.js.map