sveltekit-ui 1.1.71 → 1.1.73

package/.vercel/output/functions/![-]/catchall.func/.svelte-kit/output/server/chunks/client.js

@@ -0,0 +1,1609 @@
+import { a as settled, o as tick$1, r as index_server_exports } from "./internal.js";
+import { d as get_message, f as get_status, m as base64_decode, n as TRAILING_SLASH_PARAM, r as create_remote_key, t as INVALIDATED_PARAM, v as noop } from "./shared.js";
+import { s as base } from "./internal2.js";
+import { S as compact, f as make_trackable, g as add_data_suffix, h as noop_span, l as decode_params, p as normalize_path, s as hash, u as decode_pathname } from "./exports.js";
+import { E as writable, ht as noop$1 } from "./server.js";
+import { HttpError, Redirect, SvelteKitError } from "@sveltejs/kit/internal";
+import "@sveltejs/kit/internal/server";
+import * as devalue from "devalue";
+var cache = /* @__PURE__ */ new Map();
+/**
+* Should be called on the initial run of load functions that hydrate the page.
+* Saves any requests with cache-control max-age to the cache.
+* @param {URL | string} resource
+* @param {RequestInit} [opts]
+*/
+function initial_fetch(resource, opts) {
+	const selector = build_selector(resource, opts);
+	const script = document.querySelector(selector);
+	if (script?.textContent) {
+		script.remove();
+		let { body, ...init } = JSON.parse(script.textContent);
+		if (script.getAttribute("data-b64") !== null) body = base64_decode(body);
+		const ttl = script.getAttribute("data-ttl");
+		if (ttl) cache.set(selector, {
+			body,
+			init,
+			ttl: 1e3 * Number(ttl)
+		});
+		return Promise.resolve(new Response(body, init));
+	}
+	return window.fetch(resource, opts);
+}
+/**
+* Tries to get the response from the cache, if max-age allows it, else does a fetch.
+* @param {URL | string} resource
+* @param {string} resolved
+* @param {RequestInit} [opts]
+*/
+function subsequent_fetch(resource, resolved, opts) {
+	if (cache.size > 0) {
+		const selector = build_selector(resource, opts);
+		const cached = cache.get(selector);
+		if (cached) {
+			if (performance.now() < cached.ttl && [
+				"default",
+				"force-cache",
+				"only-if-cached",
+				void 0
+			].includes(opts?.cache)) return new Response(cached.body, cached.init);
+			cache.delete(selector);
+		}
+	}
+	return window.fetch(resolved, opts);
+}
+/**
+* Build the cache key for a given request
+* @param {URL | RequestInfo} resource
+* @param {RequestInit} [opts]
+*/
+function build_selector(resource, opts) {
+	let selector = `script[data-sveltekit-fetched][data-url=${JSON.stringify(resource instanceof Request ? resource.url : resource)}]`;
+	if (opts?.headers || opts?.body) {
+		/** @type {import('types').StrictBody[]} */
+		const values = [];
+		if (opts.headers) values.push([...new Headers(opts.headers)].join(","));
+		if (opts.body && (typeof opts.body === "string" || ArrayBuffer.isView(opts.body))) values.push(opts.body);
+		selector += `[data-hash="${hash(...values)}"]`;
+	}
+	return selector;
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/client/session-storage.js
+/**
+* Read a value from `sessionStorage`
+* @param {string} key
+* @param {(value: string) => any} parse
+*/
+/*@__NO_SIDE_EFFECTS__*/
+function get(key, parse = JSON.parse) {
+	try {
+		return parse(sessionStorage[key]);
+	} catch {}
+}
+var STATES_KEY = "sveltekit:states";
+var HISTORY_INDEX = "sveltekit:history";
+var NAVIGATION_INDEX = "sveltekit:navigation";
+var PRELOAD_PRIORITIES = {
+	tap: 1,
+	hover: 2,
+	viewport: 3,
+	eager: 4,
+	off: -1,
+	false: -1
+};
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/client/utils.js
+var origin = "";
+/** @param {string | URL} url */
+function resolve_url(url) {
+	if (url instanceof URL) return url;
+	let baseURI = document.baseURI;
+	if (!baseURI) {
+		const baseTags = document.getElementsByTagName("base");
+		baseURI = baseTags.length ? baseTags[0].href : document.URL;
+	}
+	return new URL(url, baseURI);
+}
+function scroll_state() {
+	return {
+		x: pageXOffset,
+		y: pageYOffset
+	};
+}
+({ ...PRELOAD_PRIORITIES }), PRELOAD_PRIORITIES.hover;
+/** @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 === void 0 || ready && new_value !== old_value) run(old_value = new_value);
+		});
+	}
+	return {
+		notify,
+		set,
+		subscribe
+	};
+}
+var updated_listener = { v: noop };
+function create_updated_store() {
+	const { set, subscribe } = writable(false);
+	return {
+		subscribe,
+		check: async () => false
+	};
+}
+/**
+* Is external if
+* - origin different
+* - path doesn't start with base
+* - uses hash router and pathname is more than base
+* @param {URL} url
+* @param {string} base
+* @param {boolean} hash_routing
+*/
+function is_external_url(url, base, hash_routing) {
+	if (url.origin !== origin || !url.pathname.startsWith(base)) return true;
+	if (hash_routing) return url.pathname !== location.pathname;
+	return false;
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/client/state.svelte.js
+var page;
+var navigating;
+var updated;
+var is_legacy = noop$1.toString().includes("$$") || /function \w+\(\) \{\}/.test(noop$1.toString());
+var placeholder_url = "a:";
+if (is_legacy) {
+	page = {
+		data: {},
+		form: null,
+		error: null,
+		params: {},
+		route: { id: null },
+		state: {},
+		status: -1,
+		url: new URL(placeholder_url)
+	};
+	navigating = { current: null };
+	updated = { current: false };
+} else {
+	page = new class Page {
+		data = {};
+		form = null;
+		error = null;
+		params = {};
+		route = { id: null };
+		state = {};
+		status = -1;
+		url = new URL(placeholder_url);
+	}();
+	navigating = new class Navigating {
+		current = null;
+	}();
+	updated = new class Updated {
+		current = false;
+	}();
+	updated_listener.v = () => updated.current = true;
+}
+/**
+* @param {import('@sveltejs/kit').Page} new_page
+*/
+function update(new_page) {
+	Object.assign(page, new_page);
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/client/stream.js
+/**
+* Reads from a stream, decoding it as text and yielding each block of content
+* separated by `delimiter`. The trailing block (if any) is yielded once the
+* stream closes.
+* @param {ReadableStreamDefaultReader<Uint8Array>} reader
+* @param {string} delimiter
+*/
+async function* read_stream(reader, delimiter) {
+	let done = false;
+	let buffer = "";
+	const decoder = new TextDecoder();
+	while (true) {
+		let split = buffer.indexOf(delimiter);
+		while (split !== -1) {
+			yield buffer.slice(0, split);
+			buffer = buffer.slice(split + delimiter.length);
+			split = buffer.indexOf(delimiter);
+		}
+		if (done) {
+			if (buffer) yield buffer;
+			return;
+		}
+		const chunk = await reader.read();
+		done = chunk.done;
+		if (chunk.value) buffer += decoder.decode(chunk.value, { stream: true });
+		if (done) buffer += decoder.decode();
+	}
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/client/ndjson.js
+/**
+* Yields parsed JSON objects from a ReadableStream of newline-delimited JSON.
+* Each yielded value is the raw `JSON.parse`'d object — callers handle deserialization.
+* @param {ReadableStreamDefaultReader<Uint8Array>} reader
+*/
+async function* read_ndjson(reader) {
+	for await (const block of read_stream(reader, "\n")) {
+		const line = block.trim();
+		if (line) yield JSON.parse(line);
+	}
+}
+//#endregion
+//#region node_modules/@sveltejs/kit/src/runtime/client/client.js
+/** @import { RemoteFunctionDataNode, ServerNodesResponse, ServerRedirectNode } from 'types' */
+/** @import { CacheEntry } from './remote-functions/cache.svelte.js' */
+/** @import { Query } from './remote-functions/query/instance.svelte.js' */
+/** @import { LiveQuery } from './remote-functions/query-live/instance.svelte.js' */
+var { onMount, tick } = index_server_exports;
+/**
+* Set via transformError, reset and read at the end of navigate.
+* Necessary because a navigation might succeed loading but during rendering
+* an error occurs, at which point the navigation result needs to be overridden with the error result.
+* TODO this is all very hacky, rethink for SvelteKit 3 where we can assume Svelte 5 and do an overhaul of client.js
+* @type {{ error: App.Error, status: number } | null}
+*/
+var rendering_error = null;
+/**
+* history index -> { x, y }
+* @type {Record<number, { x: number; y: number }>}
+*/
+var scroll_positions = /* @__PURE__ */ get("sveltekit:scroll") ?? {};
+/**
+* navigation index -> any
+* @type {Record<string, any[]>}
+*/
+var snapshots = /* @__PURE__ */ get("sveltekit:snapshot") ?? {};
+var stores = {
+	url: /* @__PURE__ */ notifiable_store({}),
+	page: /* @__PURE__ */ notifiable_store({}),
+	navigating: /* @__PURE__ */ writable(null),
+	updated: /* @__PURE__ */ create_updated_store()
+};
+/** @param {number} index */
+function update_scroll_positions(index) {
+	scroll_positions[index] = scroll_state();
+}
+/**
+* @param {number} current_history_index
+* @param {number} current_navigation_index
+*/
+function clear_onward_history(current_history_index, current_navigation_index) {
+	let i = current_history_index + 1;
+	while (scroll_positions[i]) {
+		delete scroll_positions[i];
+		i += 1;
+	}
+	i = current_navigation_index + 1;
+	while (snapshots[i]) {
+		delete snapshots[i];
+		i += 1;
+	}
+}
+/**
+* Loads `href` the old-fashioned way, with a full page reload.
+* Returns a `Promise` that never resolves (to prevent any
+* subsequent work, e.g. history manipulation, from happening)
+* @param {URL} url
+* @param {boolean} [replace] if `true`, will replace the current `history` entry rather than creating a new one with `pushState`
+* @returns {Promise<any>} a promise that never resolves
+*/
+function native_navigation(url, replace = false) {
+	if (replace) location.replace(url.href);
+	else location.href = url.href;
+	return new Promise(noop);
+}
+/**
+* Checks whether a service worker is registered, and if it is,
+* tries to update it.
+*/
+async function update_service_worker() {
+	if ("serviceWorker" in navigator) {
+		const registration = await navigator.serviceWorker.getRegistration(base || "/");
+		if (registration) await registration.update();
+	}
+}
+/** @type {import('types').CSRRoute[]} All routes of the app. Only available when kit.router.resolution=client */
+var routes;
+/** @type {import('types').CSRPageNodeLoader} */
+var default_layout_loader;
+/** @type {import('types').CSRPageNodeLoader} */
+var default_error_loader;
+/** @type {HTMLElement} */
+var target;
+/** @type {import('./types.js').SvelteKitApp} */
+var app;
+/** @type {Array<((url: URL) => boolean)>} */
+var invalidated = [];
+/**
+* An array of the `+layout.svelte` and `+page.svelte` component instances
+* that currently live on the page — used for capturing and restoring snapshots.
+* It's updated/manipulated through `bind:this` in `Root.svelte`.
+* @type {import('svelte').SvelteComponent[]}
+*/
+var components = [];
+/** @type {{id: string, token: {}, promise: Promise<import('./types.js').NavigationResult>, fork: Promise<import('svelte').Fork | null> | null} | null} */
+var load_cache = null;
+function discard_load_cache() {
+	load_cache?.fork?.then((f) => f?.discard());
+	load_cache = null;
+	current_a = {
+		element: void 0,
+		href: void 0
+	};
+}
+/**
+* @type {Map<string, Promise<URL>>}
+* Cache for client-side rerouting, since it could contain async calls which we want to
+* avoid running multiple times which would slow down navigations (e.g. else preloading
+* wouldn't help because on navigation it would be called again). Since `reroute` should be
+* a pure function (i.e. always return the same) value it's safe to cache across navigations.
+* The server reroute calls don't need to be cached because they are called using `import(...)`
+* which is cached per the JS spec.
+*/
+var reroute_cache = /* @__PURE__ */ new Map();
+/**
+* Note on before_navigate_callbacks, on_navigate_callbacks and after_navigate_callbacks:
+* do not re-assign as some closures keep references to these Sets
+*/
+/** @type {Set<(navigation: import('@sveltejs/kit').BeforeNavigate) => void>} */
+var before_navigate_callbacks = /* @__PURE__ */ new Set();
+/** @type {Set<(navigation: import('@sveltejs/kit').OnNavigate) => import('types').MaybePromise<(() => void) | void>>} */
+var on_navigate_callbacks = /* @__PURE__ */ new Set();
+/** @type {Set<(navigation: import('@sveltejs/kit').AfterNavigate) => void>} */
+var after_navigate_callbacks = /* @__PURE__ */ new Set();
+/** @type {import('./types.js').NavigationState & { nav: import('@sveltejs/kit').NavigationEvent }} */
+var current = {
+	branch: [],
+	error: null,
+	url: null,
+	nav: null
+};
+/** this being true means we SSR'd */
+var hydrated = false;
+var started = false;
+var autoscroll = true;
+var is_navigating = false;
+var force_invalidation = false;
+/** @type {import('svelte').SvelteComponent} */
+var root;
+/** @type {number} keeping track of the history index in order to prevent popstate navigation events if needed */
+var current_history_index;
+/** @type {number} */
+var current_navigation_index;
+/** @type {{}} */
+var token;
+/**
+* A set of tokens which are associated to current preloads.
+* If a preload becomes a real navigation, it's removed from the set.
+* If a preload token is in the set and the preload errors, the error
+* handling logic (for example reloading) is skipped.
+*/
+/** @type {Set<{}>} */
+var preload_tokens = /* @__PURE__ */ new Set();
+/**
+* @type {Map<string, Map<string, CacheEntry<Query<any>>>>}
+* A map of query id -> payload -> query internals for all active queries.
+*/
+var query_map = /* @__PURE__ */ new Map();
+/**
+* @type {Map<string, Map<string, CacheEntry<LiveQuery<any>>>>}
+* A map of id -> payload -> live query internals for all active queries.
+*/
+var live_query_map = /* @__PURE__ */ new Map();
+function reset_invalidation() {
+	invalidated.length = 0;
+	force_invalidation = false;
+}
+/** @param {number} index */
+function capture_snapshot(index) {
+	if (components.some((c) => c?.snapshot)) snapshots[index] = components.map((c) => c?.snapshot?.capture());
+}
+/** @param {number} index */
+function restore_snapshot(index) {
+	snapshots[index]?.forEach((value, i) => {
+		components[i]?.snapshot?.restore(value);
+	});
+}
+/**
+* @param {string | URL} url
+* @param {{ replaceState?: boolean; noScroll?: boolean; keepFocus?: boolean; invalidateAll?: boolean; invalidate?: Array<string | URL | ((url: URL) => boolean)>; state?: Record<string, any> }} options
+* @param {number} redirect_count
+* @param {{}} [nav_token]
+* @returns {Promise<void>}
+*/
+async function _goto(url, options, redirect_count, nav_token) {
+	/** @type {Set<string>} */
+	let query_keys;
+	/** @type {Set<string>} */
+	let live_query_keys;
+	if (options.invalidateAll) discard_load_cache();
+	await navigate({
+		type: "goto",
+		url: resolve_url(url),
+		keepfocus: options.keepFocus,
+		noscroll: options.noScroll,
+		replace_state: options.replaceState,
+		state: options.state,
+		redirect_count,
+		nav_token,
+		accept: () => {
+			if (options.invalidateAll) {
+				force_invalidation = true;
+				query_keys = /* @__PURE__ */ new Set();
+				for (const [id, entries] of query_map) for (const [payload, entry] of entries) {
+					entry.resource?.reset();
+					query_keys.add(create_remote_key(id, payload));
+				}
+				live_query_keys = /* @__PURE__ */ new Set();
+				for (const [id, entries] of live_query_map) for (const payload of entries.keys()) live_query_keys.add(create_remote_key(id, payload));
+			}
+			if (options.invalidate) options.invalidate.forEach(push_invalidated);
+		}
+	});
+	if (options.invalidateAll) tick$1().then(tick$1).then(() => {
+		for (const [id, entries] of query_map) for (const [payload, { resource }] of entries) if (query_keys?.has(create_remote_key(id, payload))) resource.start();
+		for (const [id, entries] of live_query_map) for (const [payload, { resource }] of entries) if (live_query_keys?.has(create_remote_key(id, payload))) resource.reconnect();
+	});
+}
+/**
+* @param {import('./types.js').NavigationFinished} result
+* @param {HTMLElement} target
+* @param {boolean} hydrate
+*/
+async function initialize(result, target, hydrate) {
+	/** @type {import('@sveltejs/kit').NavigationEvent} */
+	const nav = {
+		params: current.params,
+		route: { id: current.route?.id ?? null },
+		url: new URL(location.href)
+	};
+	current = {
+		...result.state,
+		nav
+	};
+	update(result.props.page);
+	root = new app.root({
+		target,
+		props: {
+			...result.props,
+			stores,
+			components
+		},
+		hydrate,
+		sync: false,
+		transformError: void 0
+	});
+	await Promise.resolve();
+	if (hydrate) {
+		/** @type {import('@sveltejs/kit').AfterNavigate} */
+		const navigation = {
+			from: null,
+			to: {
+				...nav,
+				scroll: scroll_positions[current_history_index] ?? scroll_state()
+			},
+			willUnload: false,
+			type: "enter",
+			complete: Promise.resolve()
+		};
+		after_navigate_callbacks.forEach((fn) => fn(navigation));
+	}
+	restore_snapshot(current_navigation_index);
+	started = true;
+}
+/**
+*
+* @param {{
+*   url: URL;
+*   params: Record<string, string>;
+*   branch: Array<import('./types.js').BranchNode | undefined>;
+*   errors?: Array<import('types').CSRPageNodeLoader | undefined>;
+*   status: number;
+*   error: App.Error | null;
+*   route: import('types').CSRRoute | null;
+*   form?: Record<string, any> | null;
+* }} opts
+*/
+async function get_navigation_result_from_branch({ url, params, branch, errors, status, error, route, form }) {
+	/** @type {import('types').TrailingSlash} */
+	let slash = "never";
+	if (base && (url.pathname === base || url.pathname === base + "/")) slash = "always";
+	else for (const node of branch) if (node?.slash !== void 0) slash = node.slash;
+	url.pathname = normalize_path(url.pathname, slash);
+	url.search = url.search;
+	/** @type {import('./types.js').NavigationFinished} */
+	const result = {
+		type: "loaded",
+		state: {
+			url,
+			params,
+			branch,
+			error,
+			route
+		},
+		props: {
+			constructors: compact(branch).map((branch_node) => branch_node.node.component),
+			page: clone_page(page)
+		}
+	};
+	if (form !== void 0) result.props.form = form;
+	let data = {};
+	let data_changed = !page;
+	let p = 0;
+	for (let i = 0; i < Math.max(branch.length, current.branch.length); i += 1) {
+		const node = branch[i];
+		const prev = current.branch[i];
+		if (node?.data !== prev?.data) data_changed = true;
+		if (!node) continue;
+		data = {
+			...data,
+			...node.data
+		};
+		if (data_changed) result.props[`data_${p}`] = data;
+		p += 1;
+	}
+	if (!current.url || url.href !== current.url.href || current.error !== error || form !== void 0 && form !== page.form || data_changed) result.props.page = {
+		error,
+		params,
+		route: { id: route?.id ?? null },
+		state: {},
+		status,
+		url: new URL(url),
+		form: form ?? null,
+		data: data_changed ? data : page.data
+	};
+	return result;
+}
+/**
+* Call the universal load function of the given node, if it exists.
+*
+* @param {{
+*   loader: import('types').CSRPageNodeLoader;
+* 	 parent: () => Promise<Record<string, any>>;
+*   url: URL;
+*   params: Record<string, string>;
+*   route: { id: string | null };
+* 	 server_data_node: import('./types.js').DataNode | null;
+* }} options
+* @returns {Promise<import('./types.js').BranchNode>}
+*/
+async function load_node({ loader, parent, url, params, route, server_data_node }) {
+	/** @type {Record<string, any> | null} */
+	let data = null;
+	let is_tracking = true;
+	/** @type {import('types').Uses} */
+	const uses = {
+		dependencies: /* @__PURE__ */ new Set(),
+		params: /* @__PURE__ */ new Set(),
+		parent: false,
+		route: false,
+		url: false,
+		search_params: /* @__PURE__ */ new Set()
+	};
+	const node = await loader();
+	if (node.universal?.load) {
+		/** @param {string[]} deps */
+		function depends(...deps) {
+			for (const dep of deps) {
+				const { href } = new URL(dep, url);
+				uses.dependencies.add(href);
+			}
+		}
+		/** @type {import('@sveltejs/kit').LoadEvent} */
+		const load_input = {
+			tracing: {
+				enabled: false,
+				root: noop_span,
+				current: noop_span
+			},
+			route: new Proxy(route, { get: (target, key) => {
+				if (is_tracking) uses.route = true;
+				return target[key];
+			} }),
+			params: new Proxy(params, { get: (target, key) => {
+				if (is_tracking) uses.params.add(key);
+				return target[key];
+			} }),
+			data: server_data_node?.data ?? null,
+			url: make_trackable(url, () => {
+				if (is_tracking) uses.url = true;
+			}, (param) => {
+				if (is_tracking) uses.search_params.add(param);
+			}, app.hash),
+			async fetch(resource, init) {
+				if (resource instanceof Request) init = {
+					body: resource.method === "GET" || resource.method === "HEAD" ? void 0 : await resource.blob(),
+					cache: resource.cache,
+					credentials: resource.credentials,
+					headers: [...resource.headers].length > 0 ? resource?.headers : void 0,
+					integrity: resource.integrity,
+					keepalive: resource.keepalive,
+					method: resource.method,
+					mode: resource.mode,
+					redirect: resource.redirect,
+					referrer: resource.referrer,
+					referrerPolicy: resource.referrerPolicy,
+					signal: resource.signal,
+					...init
+				};
+				const { resolved, promise } = resolve_fetch_url(resource, init, url);
+				if (is_tracking) depends(resolved.href);
+				return promise;
+			},
+			setHeaders: noop,
+			depends,
+			parent() {
+				if (is_tracking) uses.parent = true;
+				return parent();
+			},
+			untrack(fn) {
+				is_tracking = false;
+				try {
+					return fn();
+				} finally {
+					is_tracking = true;
+				}
+			}
+		};
+		data = await node.universal.load.call(null, load_input) ?? null;
+	}
+	return {
+		node,
+		loader,
+		server: server_data_node,
+		universal: node.universal?.load ? {
+			type: "data",
+			data,
+			uses
+		} : null,
+		data: data ?? server_data_node?.data ?? null,
+		slash: node.universal?.trailingSlash ?? server_data_node?.slash
+	};
+}
+/**
+* @param {Request | string | URL} input
+* @param {RequestInit | undefined} init
+* @param {URL} url
+*/
+function resolve_fetch_url(input, init, url) {
+	let requested = input instanceof Request ? input.url : input;
+	const resolved = new URL(requested, url);
+	if (resolved.origin === url.origin) requested = resolved.href.slice(url.origin.length);
+	return {
+		resolved,
+		promise: started ? subsequent_fetch(requested, resolved.href, init) : initial_fetch(requested, init)
+	};
+}
+/**
+* @param {boolean} parent_changed
+* @param {boolean} route_changed
+* @param {boolean} url_changed
+* @param {Set<string>} search_params_changed
+* @param {import('types').Uses | undefined} uses
+* @param {Record<string, string>} params
+*/
+function has_changed(parent_changed, route_changed, url_changed, search_params_changed, uses, params) {
+	if (force_invalidation) return true;
+	if (!uses) return false;
+	if (uses.parent && parent_changed) return true;
+	if (uses.route && route_changed) return true;
+	if (uses.url && url_changed) return true;
+	for (const tracked_params of uses.search_params) if (search_params_changed.has(tracked_params)) return true;
+	for (const param of uses.params) if (params[param] !== current.params[param]) return true;
+	for (const href of uses.dependencies) if (invalidated.some((fn) => fn(new URL(href)))) return true;
+	return false;
+}
+/**
+* @param {import('types').ServerDataNode | import('types').ServerDataSkippedNode | null} node
+* @param {import('./types.js').DataNode | null} [previous]
+* @returns {import('./types.js').DataNode | null}
+*/
+function create_data_node(node, previous) {
+	if (node?.type === "data") return node;
+	if (node?.type === "skip") return previous ?? null;
+	return null;
+}
+/**
+* @param {URL | null} old_url
+* @param {URL} new_url
+*/
+function diff_search_params(old_url, new_url) {
+	if (!old_url) return new Set(new_url.searchParams.keys());
+	const changed = /* @__PURE__ */ new Set([...old_url.searchParams.keys(), ...new_url.searchParams.keys()]);
+	for (const key of changed) {
+		const old_values = old_url.searchParams.getAll(key);
+		const new_values = new_url.searchParams.getAll(key);
+		if (old_values.every((value) => new_values.includes(value)) && new_values.every((value) => old_values.includes(value))) changed.delete(key);
+	}
+	return changed;
+}
+/**
+* @param {Omit<import('./types.js').NavigationFinished['state'], 'branch'> & { error: App.Error }} opts
+* @returns {import('./types.js').NavigationFinished}
+*/
+function preload_error({ error, url, route, params }) {
+	return {
+		type: "loaded",
+		state: {
+			error,
+			url,
+			route,
+			params,
+			branch: []
+		},
+		props: {
+			page: clone_page(page),
+			constructors: []
+		}
+	};
+}
+/**
+* @overload
+* @param {import('./types.js').NavigationIntent} intent
+* @returns {Promise<import('./types.js').NavigationResult | undefined>}
+*/
+/**
+* @overload
+* @param {import('./types.js').NavigationIntent & { preload: {} }} intent
+* @returns {Promise<import('./types.js').NavigationResult>}
+*/
+/**
+* @param {import('./types.js').NavigationIntent & { preload?: {} }} intent
+* @returns {Promise<import('./types.js').NavigationResult | undefined>}
+*/
+async function load_route({ id, invalidating, url, params, route, preload }) {
+	if (load_cache?.id === id) {
+		preload_tokens.delete(load_cache.token);
+		return load_cache.promise;
+	}
+	const { errors, layouts, leaf } = route;
+	const loaders = [...layouts, leaf];
+	errors.forEach((loader) => loader?.().catch(noop));
+	loaders.forEach((loader) => loader?.[1]().catch(noop));
+	/** @type {import('types').ServerNodesResponse | import('types').ServerRedirectNode | null} */
+	let server_data = null;
+	const url_changed = current.url ? id !== get_page_key(current.url) : false;
+	const route_changed = current.route ? route.id !== current.route.id : false;
+	const search_params_changed = diff_search_params(current.url, url);
+	let parent_invalid = false;
+	{
+		const invalid_server_nodes = loaders.map((loader, i) => {
+			const previous = current.branch[i];
+			const invalid = !!loader?.[0] && (previous?.loader !== loader[1] || has_changed(parent_invalid, route_changed, url_changed, search_params_changed, previous.server?.uses, params));
+			if (invalid) parent_invalid = true;
+			return invalid;
+		});
+		if (invalid_server_nodes.some(Boolean)) {
+			try {
+				server_data = await load_data(url, invalid_server_nodes);
+			} catch (error) {
+				const handled_error = await handle_error(error, {
+					url,
+					params,
+					route: { id }
+				});
+				if (preload && preload_tokens.has(preload)) return preload_error({
+					error: handled_error,
+					url,
+					params,
+					route
+				});
+				return load_root_error_page({
+					status: get_status(error),
+					error: handled_error,
+					url,
+					route
+				});
+			}
+			if (server_data.type === "redirect") return server_data;
+		}
+	}
+	const server_data_nodes = server_data?.nodes;
+	let parent_changed = false;
+	const branch_promises = loaders.map(async (loader, i) => {
+		if (!loader) return;
+		/** @type {import('./types.js').BranchNode | undefined} */
+		const previous = current.branch[i];
+		const server_data_node = server_data_nodes?.[i];
+		if ((!server_data_node || server_data_node.type === "skip") && loader[1] === previous?.loader && !has_changed(parent_changed, route_changed, url_changed, search_params_changed, previous.universal?.uses, params)) return previous;
+		parent_changed = true;
+		if (server_data_node?.type === "error") throw server_data_node;
+		return load_node({
+			loader: loader[1],
+			url,
+			params,
+			route,
+			parent: async () => {
+				const data = {};
+				for (let j = 0; j < i; j += 1) Object.assign(data, (await branch_promises[j])?.data);
+				return data;
+			},
+			server_data_node: create_data_node(server_data_node === void 0 && loader[0] ? { type: "skip" } : server_data_node ?? null, loader[0] ? previous?.server : void 0)
+		});
+	});
+	for (const p of branch_promises) p.catch(noop);
+	/** @type {Array<import('./types.js').BranchNode | undefined>} */
+	const branch = [];
+	for (let i = 0; i < loaders.length; i += 1) if (loaders[i]) try {
+		branch.push(await branch_promises[i]);
+	} catch (err) {
+		if (err instanceof Redirect) return {
+			type: "redirect",
+			location: err.location
+		};
+		if (preload && preload_tokens.has(preload)) return preload_error({
+			error: await handle_error(err, {
+				params,
+				url,
+				route: { id: route.id }
+			}),
+			url,
+			params,
+			route
+		});
+		let status = get_status(err);
+		/** @type {App.Error} */
+		let error;
+		if (server_data_nodes?.includes(err)) {
+			status = err.status ?? status;
+			error = err.error;
+		} else if (err instanceof HttpError) error = err.body;
+		else {
+			if (await stores.updated.check()) {
+				await update_service_worker();
+				return await native_navigation(url);
+			}
+			error = await handle_error(err, {
+				params,
+				url,
+				route: { id: route.id }
+			});
+		}
+		const error_load = await load_nearest_error_page(i, branch, errors);
+		if (error_load) return get_navigation_result_from_branch({
+			url,
+			params,
+			branch: branch.slice(0, error_load.idx).concat(error_load.node),
+			errors,
+			status,
+			error,
+			route
+		});
+		else return await server_fallback(url, { id: route.id }, error, status);
+	}
+	else branch.push(void 0);
+	return get_navigation_result_from_branch({
+		url,
+		params,
+		branch,
+		errors,
+		status: 200,
+		error: null,
+		route,
+		form: invalidating ? void 0 : null
+	});
+}
+/**
+* @param {number} i Start index to backtrack from
+* @param {Array<import('./types.js').BranchNode | undefined>} branch Branch to backtrack
+* @param {Array<import('types').CSRPageNodeLoader | undefined>} errors All error pages for this branch
+* @returns {Promise<{idx: number; node: import('./types.js').BranchNode} | undefined>}
+*/
+async function load_nearest_error_page(i, branch, errors) {
+	while (i--) if (errors[i]) {
+		let j = i;
+		while (!branch[j]) j -= 1;
+		try {
+			return {
+				idx: j + 1,
+				node: {
+					node: await errors[i](),
+					loader: errors[i],
+					data: {},
+					server: null,
+					universal: null
+				}
+			};
+		} catch {
+			continue;
+		}
+	}
+}
+/**
+* @param {{
+*   status: number;
+*   error: App.Error;
+*   url: URL;
+*   route: { id: string | null }
+* }} opts
+* @returns {Promise<import('./types.js').NavigationFinished | undefined>} returns `undefined` in case of a redirect
+*/
+async function load_root_error_page({ status, error, url, route }) {
+	/** @type {Record<string, string>} */
+	const params = {};
+	/** @type {import('types').ServerDataNode | null} */
+	let server_data_node = null;
+	if (app.server_loads[0] === 0) try {
+		const server_data = await load_data(url, [true]);
+		if (server_data.type !== "data" || server_data.nodes[0] && server_data.nodes[0].type !== "data") throw 0;
+		server_data_node = server_data.nodes[0] ?? null;
+	} catch (e) {
+		if (!(e instanceof HttpError && e.status === 404) && (url.origin !== origin || url.pathname !== location.pathname || hydrated)) return await native_navigation(url);
+	}
+	try {
+		return get_navigation_result_from_branch({
+			url,
+			params,
+			branch: [await load_node({
+				loader: default_layout_loader,
+				url,
+				params,
+				route,
+				parent: () => Promise.resolve({}),
+				server_data_node: create_data_node(server_data_node)
+			}), {
+				node: await default_error_loader(),
+				loader: default_error_loader,
+				universal: null,
+				server: null,
+				data: null
+			}],
+			status,
+			error,
+			errors: [],
+			route: null
+		});
+	} catch (error) {
+		if (error instanceof Redirect) {
+			await _goto(new URL(error.location, location.href), {}, 0);
+			return;
+		}
+		const error_template = await app.get_error_template();
+		const handled = await handle_error(error, {
+			url,
+			params,
+			route
+		});
+		const html = error_template({
+			status,
+			message: String(handled?.message ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+		});
+		const parsed = new DOMParser().parseFromString(html, "text/html");
+		document.documentElement.replaceChild(document.adoptNode(parsed.head), document.head);
+		document.documentElement.replaceChild(document.adoptNode(parsed.body), document.body);
+		throw error;
+	}
+}
+/**
+* Resolve the relative rerouted URL for a client-side navigation
+* @param {URL} url
+* @returns {Promise<URL | undefined>}
+*/
+async function get_rerouted_url(url) {
+	const href = url.href;
+	if (reroute_cache.has(href)) return reroute_cache.get(href);
+	let rerouted;
+	try {
+		const promise = (async () => {
+			let rerouted = await app.hooks.reroute({
+				url: new URL(url),
+				fetch: async (input, init) => {
+					return resolve_fetch_url(input, init, url).promise;
+				}
+			}) ?? url;
+			if (typeof rerouted === "string") {
+				const tmp = new URL(url);
+				if (app.hash) tmp.hash = rerouted;
+				else tmp.pathname = rerouted;
+				rerouted = tmp;
+			}
+			return rerouted;
+		})();
+		reroute_cache.set(href, promise);
+		rerouted = await promise;
+	} catch (e) {
+		reroute_cache.delete(href);
+		return;
+	}
+	return rerouted;
+}
+/**
+* Resolve the full info (which route, params, etc.) for a client-side navigation from the URL,
+* taking the reroute hook into account. If this isn't a client-side-navigation (or the URL is undefined),
+* returns undefined.
+* @param {URL | undefined} url
+* @param {boolean} invalidating
+* @returns {Promise<import('./types.js').NavigationIntent | undefined>}
+*/
+async function get_navigation_intent(url, invalidating) {
+	if (!url) return;
+	if (is_external_url(url, base, app.hash)) return;
+	{
+		const rerouted = await get_rerouted_url(url);
+		if (!rerouted) return;
+		const path = get_url_path(rerouted);
+		for (const route of routes) {
+			const params = route.exec(path);
+			if (params) return {
+				id: get_page_key(url),
+				invalidating,
+				route,
+				params: decode_params(params),
+				url
+			};
+		}
+	}
+}
+/** @param {URL} url */
+function get_url_path(url) {
+	return decode_pathname(app.hash ? url.hash.replace(/^#/, "").replace(/[?#].+/, "") : url.pathname.slice(base.length)) || "/";
+}
+/** @param {URL} url */
+function get_page_key(url) {
+	return (app.hash ? url.hash.replace(/^#/, "") : url.pathname) + url.search;
+}
+/**
+* @param {{
+*   url: URL;
+*   type: import('@sveltejs/kit').Navigation["type"];
+*   intent?: import('./types.js').NavigationIntent;
+*   delta?: number;
+*   event?: PopStateEvent | MouseEvent;
+*   scroll?: { x: number, y: number };
+* }} opts
+*/
+function _before_navigate({ url, type, intent, delta, event, scroll }) {
+	let should_block = false;
+	const nav = create_navigation(current, intent, url, type, scroll ?? null);
+	if (delta !== void 0) nav.navigation.delta = delta;
+	if (event !== void 0) nav.navigation.event = event;
+	const cancellable = {
+		...nav.navigation,
+		cancel: () => {
+			should_block = true;
+			nav.reject(/* @__PURE__ */ new Error("navigation cancelled"));
+		}
+	};
+	if (!is_navigating) before_navigate_callbacks.forEach((fn) => fn(cancellable));
+	return should_block ? null : nav;
+}
+/**
+* @param {{
+*   type: import('@sveltejs/kit').NavigationType;
+*   url: URL;
+*   popped?: {
+*     state: Record<string, any>;
+*     scroll: { x: number, y: number };
+*     delta: number;
+*   };
+*   keepfocus?: boolean;
+*   noscroll?: boolean;
+*   replace_state?: boolean;
+*   state?: Record<string, any>;
+*   redirect_count?: number;
+*   nav_token?: {};
+*   accept?: () => void;
+*   block?: () => void;
+*   event?: Event
+* }} opts
+* @returns {Promise<void>}
+*/
+async function navigate({ type, url, popped, keepfocus, noscroll, replace_state, state = {}, redirect_count = 0, nav_token = {}, accept = noop, block = noop, event }) {
+	const prev_token = token;
+	token = nav_token;
+	const intent = await get_navigation_intent(url, false);
+	const nav = type === "enter" ? create_navigation(current, intent, url, type) : _before_navigate({
+		url,
+		type,
+		delta: popped?.delta,
+		intent,
+		scroll: popped?.scroll,
+		event
+	});
+	if (!nav) {
+		block();
+		if (token === nav_token) token = prev_token;
+		return;
+	}
+	const previous_history_index = current_history_index;
+	const previous_navigation_index = current_navigation_index;
+	accept();
+	is_navigating = true;
+	if (started && nav.navigation.type !== "enter") stores.navigating.set(navigating.current = nav.navigation);
+	let navigation_result = intent && await load_route(intent);
+	if (!navigation_result) if (is_external_url(url, base, app.hash)) return await native_navigation(url, replace_state);
+	else navigation_result = await server_fallback(url, { id: null }, await handle_error(new SvelteKitError(404, "Not Found", `Not found: ${url.pathname}`), {
+		url,
+		params: {},
+		route: { id: null }
+	}), 404, replace_state);
+	url = intent?.url || url;
+	if (token !== nav_token) {
+		nav.reject(/* @__PURE__ */ new Error("navigation aborted"));
+		return;
+	}
+	if (!navigation_result) return;
+	if (navigation_result.type === "redirect") {
+		if (redirect_count < 20) {
+			await navigate({
+				type,
+				url: new URL(navigation_result.location, url),
+				popped,
+				keepfocus,
+				noscroll,
+				replace_state,
+				state,
+				redirect_count: redirect_count + 1,
+				nav_token
+			});
+			nav.fulfil(void 0);
+			return;
+		}
+		navigation_result = await load_root_error_page({
+			status: 500,
+			error: await handle_error(/* @__PURE__ */ new Error("Redirect loop"), {
+				url,
+				params: {},
+				route: { id: null }
+			}),
+			url,
+			route: { id: null }
+		});
+		if (!navigation_result) return;
+	} else if (navigation_result.props.page.status >= 400) {
+		if (await stores.updated.check()) {
+			await update_service_worker();
+			return await native_navigation(url, replace_state);
+		}
+	}
+	reset_invalidation();
+	update_scroll_positions(previous_history_index);
+	capture_snapshot(previous_navigation_index);
+	if (navigation_result.props.page.url.pathname !== url.pathname) url.pathname = navigation_result.props.page.url.pathname;
+	state = popped ? popped.state : state;
+	if (!popped) {
+		const change = replace_state ? 0 : 1;
+		const entry = {
+			[HISTORY_INDEX]: current_history_index += change,
+			[NAVIGATION_INDEX]: current_navigation_index += change,
+			[STATES_KEY]: state
+		};
+		(replace_state ? history.replaceState : history.pushState).call(history, entry, "", url);
+		if (!replace_state) clear_onward_history(current_history_index, current_navigation_index);
+	}
+	const load_cache_fork = intent && load_cache?.id === intent.id ? load_cache.fork : null;
+	if (load_cache?.fork && !load_cache_fork) discard_load_cache();
+	else {
+		load_cache = null;
+		current_a = {
+			element: void 0,
+			href: void 0
+		};
+	}
+	navigation_result.props.page.state = state;
+	/**
+	* @type {Promise<void> | undefined}
+	*/
+	let commit_promise;
+	if (started) {
+		const after_navigate = (await Promise.all(Array.from(on_navigate_callbacks, (fn) => fn(nav.navigation)))).filter(
+			/** @returns {value is () => void} */
+			(value) => typeof value === "function"
+		);
+		if (after_navigate.length > 0) {
+			function cleanup() {
+				after_navigate.forEach((fn) => {
+					after_navigate_callbacks.delete(fn);
+				});
+			}
+			after_navigate.push(cleanup);
+			after_navigate.forEach((fn) => {
+				after_navigate_callbacks.add(fn);
+			});
+		}
+		const target = nav.navigation.to;
+		current = {
+			...navigation_result.state,
+			nav: {
+				params: target.params,
+				route: target.route,
+				url: target.url
+			}
+		};
+		if (navigation_result.props.page) navigation_result.props.page.url = url;
+		if (!keepfocus && document.activeElement instanceof HTMLElement && document.activeElement !== document.body) document.activeElement.blur();
+		const fork = load_cache_fork && await load_cache_fork;
+		if (fork) commit_promise = fork.commit();
+		else {
+			rendering_error = null;
+			root.$set(navigation_result.props);
+			if (rendering_error) Object.assign(navigation_result.props.page, rendering_error);
+			update(navigation_result.props.page);
+			commit_promise = settled?.();
+		}
+	} else await initialize(navigation_result, target, false);
+	const { activeElement } = document;
+	await commit_promise;
+	await tick$1();
+	await tick$1();
+	if (token !== nav_token) {
+		nav.reject(/* @__PURE__ */ new Error("navigation aborted"));
+		return;
+	}
+	if (navigation_result.props.page && rendering_error) Object.assign(navigation_result.props.page, rendering_error);
+	/** @type {Element | null | ''} */
+	let deep_linked = null;
+	if (autoscroll) {
+		const scroll = popped ? popped.scroll : noscroll ? scroll_state() : null;
+		if (scroll) scrollTo(scroll.x, scroll.y);
+		else if (deep_linked = url.hash && document.getElementById(get_id(url))) deep_linked.scrollIntoView();
+		else scrollTo(0, 0);
+	}
+	const changed_focus = document.activeElement !== activeElement && document.activeElement !== document.body;
+	if (!keepfocus && !changed_focus) reset_focus(url, !deep_linked);
+	autoscroll = true;
+	is_navigating = false;
+	nav.fulfil(void 0);
+	if (nav.navigation.to) nav.navigation.to.scroll = scroll_state();
+	after_navigate_callbacks.forEach((fn) => fn(nav.navigation));
+	if (type === "popstate") restore_snapshot(current_navigation_index);
+	stores.navigating.set(navigating.current = null);
+}
+/**
+* Does a full page reload if it wouldn't result in an endless loop in the SPA case
+* @param {URL} url
+* @param {{ id: string | null }} route
+* @param {App.Error} error
+* @param {number} status
+* @param {boolean} [replace_state]
+* @returns {Promise<import('./types.js').NavigationFinished | undefined>}
+*/
+async function server_fallback(url, route, error, status, replace_state) {
+	if (url.origin === origin && url.pathname === location.pathname && !hydrated) return await load_root_error_page({
+		status,
+		error,
+		url,
+		route
+	});
+	return await native_navigation(url, replace_state);
+}
+/** @typedef {(typeof PRELOAD_PRIORITIES)['hover'] | (typeof PRELOAD_PRIORITIES)['tap']} PreloadDataPriority */
+/**
+* The anchor element whose href is being preloaded. It is reset after navigation
+* or changes when a different anchor element is being preloaded.
+* @type {{ element: Element | SVGAElement | undefined; href: string | SVGAnimatedString | undefined }}
+*/
+var current_a = {
+	element: void 0,
+	href: void 0
+};
+/**
+* @param {unknown} error
+* @param {import('@sveltejs/kit').NavigationEvent} event
+* @returns {import('types').MaybePromise<App.Error>}
+*/
+function handle_error(error, event) {
+	if (error instanceof HttpError) return error.body;
+	const status = get_status(error);
+	const message = get_message(error);
+	return app.hooks.handleError({
+		error,
+		event,
+		status,
+		message
+	}) ?? { message };
+}
+/**
+* @template {Function} T
+* @param {Set<T>} callbacks
+* @param {T} callback
+*/
+function add_navigation_callback(callbacks, callback) {
+	onMount(() => {
+		callbacks.add(callback);
+		return () => {
+			callbacks.delete(callback);
+		};
+	});
+}
+/**
+* A lifecycle function that runs the supplied `callback` when the current component mounts, and also whenever we navigate to a URL.
+*
+* `afterNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
+* @param {(navigation: import('@sveltejs/kit').AfterNavigate) => void} callback
+* @returns {void}
+*/
+function afterNavigate(callback) {
+	add_navigation_callback(after_navigate_callbacks, callback);
+}
+/**
+* A navigation interceptor that triggers before we navigate to a URL, whether by clicking a link, calling `goto(...)`, or using the browser back/forward controls.
+*
+* Calling `cancel()` will prevent the navigation from completing. If `navigation.type === 'leave'` — meaning the user is navigating away from the app (or closing the tab) — calling `cancel` will trigger the native browser unload confirmation dialog. In this case, the navigation may or may not be cancelled depending on the user's response.
+*
+* When a navigation isn't to a SvelteKit-owned route (and therefore controlled by SvelteKit's client-side router), `navigation.to.route.id` will be `null`.
+*
+* If the navigation will (if not cancelled) cause the document to unload — in other words `'leave'` navigations and `'link'` navigations where `navigation.to.route === null` — `navigation.willUnload` is `true`.
+*
+* `beforeNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
+* @param {(navigation: import('@sveltejs/kit').BeforeNavigate) => void} callback
+* @returns {void}
+*/
+function beforeNavigate(callback) {
+	add_navigation_callback(before_navigate_callbacks, callback);
+}
+/**
+* A lifecycle function that runs the supplied `callback` immediately before we navigate to a new URL except during full-page navigations.
+*
+* If you return a `Promise`, SvelteKit will wait for it to resolve before completing the navigation. This allows you to — for example — use `document.startViewTransition`. Avoid promises that are slow to resolve, since navigation will appear stalled to the user.
+*
+* If a function (or a `Promise` that resolves to a function) is returned from the callback, it will be called once the DOM has updated.
+*
+* `onNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
+* @param {(navigation: import('@sveltejs/kit').OnNavigate) => import('types').MaybePromise<(() => void) | void>} callback
+* @returns {void}
+*/
+function onNavigate(callback) {
+	add_navigation_callback(on_navigate_callbacks, callback);
+}
+/**
+* Allows you to navigate programmatically to a given route, with options such as keeping the current element focused.
+* Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified `url`.
+*
+* For external URLs, use `window.location = url` instead of calling `goto(url)`.
+*
+* @param {string | URL} url Where to navigate to. Note that if you've set [`config.kit.paths.base`](https://svelte.dev/docs/kit/configuration#paths) and the URL is root-relative, you need to prepend the base path if you want to navigate within the app.
+* @param {Object} [opts] Options related to the navigation
+* @param {boolean} [opts.replaceState] If `true`, will replace the current `history` entry rather than creating a new one with `pushState`
+* @param {boolean} [opts.noScroll] If `true`, the browser will maintain its scroll position rather than scrolling to the top of the page after navigation
+* @param {boolean} [opts.keepFocus] If `true`, the currently focused element will retain focus after navigation. Otherwise, focus will be reset to the body
+* @param {boolean} [opts.invalidateAll] If `true`, all `load` functions of the page will be rerun. See https://svelte.dev/docs/kit/load#rerunning-load-functions for more info on invalidation.
+* @param {Array<string | URL | ((url: URL) => boolean)>} [opts.invalidate] Causes any load functions to re-run if they depend on one of the urls
+* @param {App.PageState} [opts.state] An optional object that will be available as `page.state`
+* @returns {Promise<void>}
+*/
+function goto(url, opts = {}) {
+	throw new Error("Cannot call goto(...) on the server");
+}
+/**
+* @param {string | URL | ((url: URL) => boolean)} resource The invalidated URL
+*/
+function push_invalidated(resource) {
+	if (typeof resource === "function") invalidated.push(resource);
+	else {
+		const { href } = new URL(resource, location.href);
+		invalidated.push((url) => url.href === href);
+	}
+}
+/**
+* Causes all `load` and `query` functions belonging to the currently active page to re-run. Returns a `Promise` that resolves when the page is subsequently updated.
+* @returns {Promise<void>}
+*/
+function invalidateAll() {
+	throw new Error("Cannot call invalidateAll() on the server");
+}
+/**
+* @param {URL} url
+* @param {boolean[]} invalid
+* @returns {Promise<import('types').ServerNodesResponse | import('types').ServerRedirectNode>}
+*/
+async function load_data(url, invalid) {
+	const data_url = new URL(url);
+	data_url.pathname = add_data_suffix(url.pathname);
+	if (url.pathname.endsWith("/")) data_url.searchParams.append(TRAILING_SLASH_PARAM, "1");
+	data_url.searchParams.append(INVALIDATED_PARAM, invalid.map((i) => i ? "1" : "0").join(""));
+	const res = await (0, window.fetch)(data_url.href, {});
+	if (!res.ok) {
+		/** @type {string | undefined} */
+		let message;
+		if (res.headers.get("content-type")?.includes("application/json")) message = await res.json();
+		else if (res.status === 404) message = "Not Found";
+		else if (res.status === 500) message = "Internal Error";
+		throw new HttpError(res.status, message);
+	}
+	return new Promise((resolve, reject) => {
+		process_stream(resolve, res).catch(reject);
+	});
+}
+/**
+* @param {(value: ServerNodesResponse | ServerRedirectNode) => void} resolve
+* @param {Response} res
+* @returns {Promise<void>}
+*/
+async function process_stream(resolve, res) {
+	const reader = res.body.getReader();
+	/**
+	* Map of deferred promises that will be resolved by a subsequent chunk of data
+	* @type {Map<string, import('types').Deferred>}
+	*/
+	const deferreds = /* @__PURE__ */ new Map();
+	/**
+	* @param {any} data
+	*/
+	function deserialize(data) {
+		return devalue.unflatten(data, {
+			...app.decoders,
+			Promise: (id) => {
+				return new Promise((fulfil, reject) => {
+					deferreds.set(id, {
+						fulfil,
+						reject
+					});
+				});
+			}
+		});
+	}
+	for await (const node of read_ndjson(reader)) {
+		if (node.type === "redirect") return resolve(node);
+		if (node.type === "data") {
+			node.nodes?.forEach((node) => {
+				if (node?.type === "data") {
+					node.uses = deserialize_uses(node.uses);
+					node.data = deserialize(node.data);
+				}
+			});
+			resolve(node);
+		} else if (node.type === "chunk") {
+			const { id, data, error } = node;
+			const deferred = deferreds.get(id);
+			deferreds.delete(id);
+			if (error) deferred.reject(deserialize(error));
+			else deferred.fulfil(deserialize(data));
+		}
+	}
+}
+/**
+* @param {any} uses
+* @return {import('types').Uses}
+*/
+function deserialize_uses(uses) {
+	return {
+		dependencies: new Set(uses?.dependencies ?? []),
+		params: new Set(uses?.params ?? []),
+		parent: !!uses?.parent,
+		route: !!uses?.route,
+		url: !!uses?.url,
+		search_params: new Set(uses?.search_params ?? [])
+	};
+}
+/**
+* @param {URL} url
+* @param {boolean} [scroll]
+*/
+function reset_focus(url, scroll = true) {
+	const autofocus = document.querySelector("[autofocus]");
+	if (autofocus) autofocus.focus();
+	else {
+		const id = get_id(url);
+		if (id && document.getElementById(id)) {
+			const { x, y } = scroll_state();
+			setTimeout(() => {
+				const history_state = history.state;
+				location.replace(new URL(`#${id}`, location.href));
+				history.replaceState(history_state, "", url);
+				if (scroll) scrollTo(x, y);
+			});
+		} else {
+			const root = document.body;
+			const tabindex = root.getAttribute("tabindex");
+			root.tabIndex = -1;
+			root.focus({
+				preventScroll: true,
+				focusVisible: false
+			});
+			if (tabindex !== null) root.setAttribute("tabindex", tabindex);
+			else root.removeAttribute("tabindex");
+		}
+		const selection = getSelection();
+		if (selection && selection.type !== "None") {
+			/** @type {Range[]} */
+			const ranges = [];
+			for (let i = 0; i < selection.rangeCount; i += 1) ranges.push(selection.getRangeAt(i));
+			setTimeout(() => {
+				if (selection.rangeCount !== ranges.length) return;
+				for (let i = 0; i < selection.rangeCount; i += 1) {
+					const a = ranges[i];
+					const b = selection.getRangeAt(i);
+					if (a.commonAncestorContainer !== b.commonAncestorContainer || a.startContainer !== b.startContainer || a.endContainer !== b.endContainer || a.startOffset !== b.startOffset || a.endOffset !== b.endOffset) return;
+				}
+				selection.removeAllRanges();
+			});
+		}
+	}
+}
+/**
+* @template {import('@sveltejs/kit').NavigationType} T
+* @param {import('./types.js').NavigationState} current
+* @param {import('./types.js').NavigationIntent | undefined} intent
+* @param {URL | null} url
+* @param {T} type
+* @param {{ x: number, y: number } | null} [target_scroll] The scroll position for the target (for popstate navigations)
+*/
+function create_navigation(current, intent, url, type, target_scroll = null) {
+	/** @type {(value: any) => void} */
+	let fulfil;
+	/** @type {(error: any) => void} */
+	let reject;
+	const complete = new Promise((f, r) => {
+		fulfil = f;
+		reject = r;
+	});
+	complete.catch(noop);
+	return {
+		navigation: {
+			from: {
+				params: current.params,
+				route: { id: current.route?.id ?? null },
+				url: current.url,
+				scroll: scroll_state()
+			},
+			to: url && {
+				params: intent?.params ?? null,
+				route: { id: intent?.route?.id ?? null },
+				url,
+				scroll: target_scroll
+			},
+			willUnload: !intent,
+			type,
+			complete
+		},
+		fulfil,
+		reject
+	};
+}
+/**
+* TODO: remove this in 3.0 when the page store is also removed
+*
+* We need to assign a new page object so that subscribers are correctly notified.
+* However, spreading `{ ...page }` returns an empty object so we manually
+* assign to each property instead.
+*
+* @param {import('@sveltejs/kit').Page} page
+*/
+function clone_page(page) {
+	return {
+		data: page.data,
+		error: page.error,
+		form: page.form,
+		params: page.params,
+		route: page.route,
+		state: page.state,
+		status: page.status,
+		url: page.url
+	};
+}
+/**
+* @param {URL} url
+* @returns {string}
+*/
+function get_id(url) {
+	let id;
+	if (app.hash) {
+		const [, , second] = url.hash.split("#", 3);
+		id = second ?? "";
+	} else id = url.hash.slice(1);
+	return decodeURIComponent(id);
+}
+//#endregion
+export { onNavigate as a, page as c, invalidateAll as i, updated as l, beforeNavigate as n, stores as o, goto as r, navigating as s, afterNavigate as t };