@sveltejs/kit 1.17.1 → 1.19.0

package/src/exports/vite/build/build_server.js

@@ -58,13 +58,13 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 
 		if (node.universal) {
 			imports.push(`import * as universal from '../${server_manifest[node.universal].file}';`);
-			exports.push(`export { universal };`);
+			exports.push('export { universal };');
 			exports.push(`export const universal_id = ${s(node.universal)};`);
 		}
 
 		if (node.server) {
 			imports.push(`import * as server from '../${server_manifest[node.server].file}';`);
-			exports.push(`export { server };`);
+			exports.push('export { server };');
 			exports.push(`export const server_id = ${s(node.server)};`);
 		}
 

package/src/exports/vite/build/build_service_worker.js

@@ -35,7 +35,7 @@ export async function build_service_worker(
 
 	// in a service worker, `location` is the location of the service worker itself,
 	// which is guaranteed to be `<base>/service-worker.js`
-	const base = `location.pathname.split('/').slice(0, -1).join('/')`;
+	const base = "location.pathname.split('/').slice(0, -1).join('/')";
 
 	fs.writeFileSync(
 		service_worker,

package/src/exports/vite/dev/index.js

@@ -44,7 +44,7 @@ export async function dev(vite, vite_config, svelte_config) {
 
 	/** @type {import('types').ManifestData} */
 	let manifest_data;
-	/** @type {import('types').SSRManifest} */
+	/** @type {import('@sveltejs/kit').SSRManifest} */
 	let manifest;
 
 	/** @type {Error | null} */
@@ -226,7 +226,7 @@ export async function dev(vite, vite_config, svelte_config) {
 					})
 				),
 				matchers: async () => {
-					/** @type {Record<string, import('types').ParamMatcher>} */
+					/** @type {Record<string, import('@sveltejs/kit').ParamMatcher>} */
 					const matchers = {};
 
 					for (const key in manifest_data.matchers) {
@@ -346,7 +346,7 @@ export async function dev(vite, vite_config, svelte_config) {
 		// This shameful hack allows us to load runtime server code via Vite
 		// while apps load `HttpError` and `Redirect` in Node, without
 		// causing `instanceof` checks to fail
-		const control_module_node = await import(`../../../runtime/control.js`);
+		const control_module_node = await import('../../../runtime/control.js');
 		const control_module_vite = await vite.ssrLoadModule(`${runtime_base}/control.js`);
 
 		control_module_node.replace_implementations({

package/src/exports/vite/index.js

@@ -101,7 +101,7 @@ const warning_preprocessor = {
 		if (basename.startsWith('+layout.') && !content.includes('<slot')) {
 			const message =
 				`\n${colors.bold().red(path.relative('.', filename))}\n` +
-				`\`<slot />\` missing — inner content will not be rendered`;
+				'`<slot />` missing — inner content will not be rendered';
 
 			if (!warned.has(message)) {
 				console.log(message);
@@ -111,7 +111,10 @@ const warning_preprocessor = {
 	}
 };
 
-/** @return {Promise<import('vite').Plugin[]>} */
+/**
+ * Returns the SvelteKit Vite plugins.
+ * @returns {Promise<import('vite').Plugin[]>}
+ */
 export async function sveltekit() {
 	const svelte_config = await load_config();
 
@@ -342,7 +345,7 @@ function kit({ svelte_config }) {
 
 			const global = is_build
 				? `globalThis.__sveltekit_${version_hash}`
-				: `globalThis.__sveltekit_dev`;
+				: 'globalThis.__sveltekit_dev';
 
 			if (options?.ssr === false && process.env.TEST !== 'true') {
 				const normalized_cwd = vite.normalizePath(cwd);
@@ -388,7 +391,7 @@ function kit({ svelte_config }) {
 
 				// for internal use only. it's published as $app/paths externally
 				// we use this alias so that we won't collide with user aliases
-				case '\0__sveltekit/paths':
+				case '\0__sveltekit/paths': {
 					const { assets, base } = svelte_config.kit.paths;
 
 					// use the values defined in `global`, but fall back to hard-coded values
@@ -424,8 +427,9 @@ function kit({ svelte_config }) {
 							assets = initial.assets = path;
 						}
 					`;
+				}
 
-				case '\0__sveltekit/environment':
+				case '\0__sveltekit/environment': {
 					const { version } = svelte_config.kit;
 
 					return dedent`
@@ -436,6 +440,7 @@ function kit({ svelte_config }) {
 							building = true;
 						}
 					`;
+				}
 			}
 		}
 	};
@@ -653,7 +658,7 @@ function kit({ svelte_config }) {
 					app_dir: kit.appDir,
 					app_path: `${kit.paths.base.slice(1)}${kit.paths.base ? '/' : ''}${kit.appDir}`,
 					manifest_data,
-					service_worker: !!service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
+					service_worker: service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 					client: null,
 					server_manifest
 				};

package/src/runtime/app/environment.js

@@ -1,13 +1,12 @@
 import { BROWSER, DEV } from 'esm-env';
+export { building, version } from '__sveltekit/environment';
 
 /**
- * @type {import('$app/environment').browser}
+ * `true` if the app is running in the browser.
  */
 export const browser = BROWSER;
 
 /**
- * @type {import('$app/environment').dev}
+ * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
  */
 export const dev = DEV;
-
-export { building, version } from '__sveltekit/environment';

package/src/runtime/app/forms.js

@@ -1,11 +1,46 @@
 import * as devalue from 'devalue';
-import { DEV } from 'esm-env';
-import { client_method } from '../client/singletons.js';
+import { BROWSER, DEV } from 'esm-env';
+import { client } from '../client/singletons.js';
 import { invalidateAll } from './navigation.js';
 
-export const applyAction = client_method('apply_action');
+/**
+ * This action updates the `form` property of the current page with the given data and updates `$page.status`.
+ * In case of an error, it redirects to the nearest error page.
+ * @template {Record<string, unknown> | undefined} Success
+ * @template {Record<string, unknown> | undefined} Failure
+ * @param {import('@sveltejs/kit').ActionResult<Success, Failure>} result
+ * @returns {Promise<void>}
+ */
+export function applyAction(result) {
+	if (BROWSER) {
+		return client.apply_action(result);
+	} else {
+		throw new Error('Cannot call applyAction(...) on the server');
+	}
+}
 
-/** @type {import('$app/forms').deserialize} */
+/**
+ * Use this function to deserialize the response from a form submission.
+ * Usage:
+ *
+ * ```js
+ * import { deserialize } from '$app/forms';
+ *
+ * async function handleSubmit(event) {
+ *   const response = await fetch('/form?/action', {
+ *     method: 'POST',
+ *     body: new FormData(event.target)
+ *   });
+ *
+ *   const result = deserialize(await response.text());
+ *   // ...
+ * }
+ * ```
+ * @template {Record<string, unknown> | undefined} Success
+ * @template {Record<string, unknown> | undefined} Failure
+ * @param {string} result
+ * @returns {import('@sveltejs/kit').ActionResult<Success, Failure>}
+ */
 export function deserialize(result) {
 	const parsed = JSON.parse(result);
 	if (parsed.data) {
@@ -39,7 +74,28 @@ function clone(element) {
 	return /** @type {T} */ (HTMLElement.prototype.cloneNode.call(element));
 }
 
-/** @type {import('$app/forms').enhance} */
+/**
+ * This action enhances a `<form>` element that otherwise would work without JavaScript.
+ *
+ * The `submit` function is called upon submission with the given FormData and the `action` that should be triggered.
+ * If `cancel` is called, the form will not be submitted.
+ * You can use the abort `controller` to cancel the submission in case another one starts.
+ * If a function is returned, that function is called with the response from the server.
+ * If nothing is returned, the fallback will be used.
+ *
+ * If this function or its return value isn't set, it
+ * - falls back to updating the `form` prop with the returned data if the action is one same page as the form
+ * - updates `$page.status`
+ * - resets the `<form>` element and invalidates all data in case of successful submission with no redirect response
+ * - redirects in case of a redirect response
+ * - redirects to the nearest error page in case of an unexpected error
+ *
+ * If you provide a custom function with a callback and want to use the default behavior, invoke `update` in your callback.
+ * @template {Record<string, unknown> | undefined} Success
+ * @template {Record<string, unknown> | undefined} Failure
+ * @param {HTMLFormElement} form_element The form element
+ * @param {import('@sveltejs/kit').SubmitFunction<Success, Failure>} submit Submit callback
+ */
 export function enhance(form_element, submit = () => {}) {
 	if (DEV && clone(form_element).method !== 'post') {
 		throw new Error('use:enhance can only be used on <form> fields with method="POST"');
@@ -48,7 +104,7 @@ export function enhance(form_element, submit = () => {}) {
 	/**
 	 * @param {{
 	 *   action: URL;
-	 *   result: import('types').ActionResult;
+	 *   result: import('@sveltejs/kit').ActionResult;
 	 *   reset?: boolean
 	 * }} opts
 	 */
@@ -127,7 +183,7 @@ export function enhance(form_element, submit = () => {}) {
 			})) ?? fallback_callback;
 		if (cancelled) return;
 
-		/** @type {import('types').ActionResult} */
+		/** @type {import('@sveltejs/kit').ActionResult} */
 		let result;
 
 		try {

package/src/runtime/app/navigation.js

@@ -1,17 +1,112 @@
 import { client_method } from '../client/singletons.js';
 
+/**
+ * If called when the page is being updated following a navigation (in `onMount` or `afterNavigate` or an action, for example), this disables SvelteKit's built-in scroll handling.
+ * This is generally discouraged, since it breaks user expectations.
+ * @returns {void}
+ */
 export const disableScrollHandling = /* @__PURE__ */ client_method('disable_scroll_handling');
 
+/**
+ * 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)`.
+ *
+ * @type {(url: string | URL, opts?: {
+ *   replaceState?: boolean;
+ *   noScroll?: boolean;
+ *   keepFocus?: boolean;
+ *   invalidateAll?: boolean;
+ *   state?: any
+ * }) => Promise<void>}
+ * @param {string | URL} url Where to navigate to. Note that if you've set [`config.kit.paths.base`](https://kit.svelte.dev/docs/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} [invalidateAll] If `true`, all `load` functions of the page will be rerun. See https://kit.svelte.dev/docs/load#rerunning-load-functions for more info on invalidation.
+ * @param {any} [opts.state] The state of the new/updated history entry
+ * @returns {Promise<void>}
+ */
 export const goto = /* @__PURE__ */ client_method('goto');
 
+/**
+ * Causes any `load` functions belonging to the currently active page to re-run if they depend on the `url` in question, via `fetch` or `depends`. Returns a `Promise` that resolves when the page is subsequently updated.
+ *
+ * If the argument is given as a `string` or `URL`, it must resolve to the same URL that was passed to `fetch` or `depends` (including query parameters).
+ * To create a custom identifier, use a string beginning with `[a-z]+:` (e.g. `custom:state`) — this is a valid URL.
+ *
+ * The `function` argument can be used define a custom predicate. It receives the full `URL` and causes `load` to rerun if `true` is returned.
+ * This can be useful if you want to invalidate based on a pattern instead of a exact match.
+ *
+ * ```ts
+ * // Example: Match '/path' regardless of the query parameters
+ * import { invalidate } from '$app/navigation';
+ *
+ * invalidate((url) => url.pathname === '/path');
+ * ```
+ * @type {(url: string | URL | ((url: URL) => boolean)) => Promise<void>}
+ * @param {string | URL | ((url: URL) => boolean)} url The invalidated URL
+ * @returns {Promise<void>}
+ */
 export const invalidate = /* @__PURE__ */ client_method('invalidate');
 
+/**
+ * Causes all `load` functions belonging to the currently active page to re-run. Returns a `Promise` that resolves when the page is subsequently updated.
+ * @type {() => Promise<void>}
+ * @returns {Promise<void>}
+ */
 export const invalidateAll = /* @__PURE__ */ client_method('invalidate_all');
 
+/**
+ * Programmatically preloads the given page, which means
+ *  1. ensuring that the code for the page is loaded, and
+ *  2. calling the page's load function with the appropriate options.
+ *
+ * This is the same behaviour that SvelteKit triggers when the user taps or mouses over an `<a>` element with `data-sveltekit-preload-data`.
+ * If the next navigation is to `href`, the values returned from load will be used, making navigation instantaneous.
+ * Returns a Promise that resolves when the preload is complete.
+ *
+ * @type {(href: string) => Promise<void>}
+ * @param {string} href Page to preload
+ * @returns {Promise<void>}
+ */
 export const preloadData = /* @__PURE__ */ client_method('preload_data');
 
+/**
+ * Programmatically imports the code for routes that haven't yet been fetched.
+ * Typically, you might call this to speed up subsequent navigation.
+ *
+ * You can specify routes by any matching pathname such as `/about` (to match `src/routes/about/+page.svelte`) or `/blog/*` (to match `src/routes/blog/[slug]/+page.svelte`).
+ *
+ * Unlike `preloadData`, this won't call `load` functions.
+ * Returns a Promise that resolves when the modules have been imported.
+ *
+ * @type {(...urls: string[]) => Promise<void>}
+ * @param {...string[]} urls
+ * @returns {Promise<void>}
+ */
 export const preloadCode = /* @__PURE__ */ client_method('preload_code');
 
+/**
+ * A navigation interceptor that triggers before we navigate to a new URL, whether by clicking a link, calling `goto(...)`, or using the browser back/forward controls.
+ * Calling `cancel()` will prevent the navigation from completing. If the navigation would have directly unloaded the current page, calling `cancel` will trigger the native
+ * browser unload confirmation dialog. In these cases, `navigation.willUnload` is `true`.
+ *
+ * When a navigation isn't client side, `navigation.to.route.id` will be `null`.
+ *
+ * `beforeNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
+ * @type {(callback: (navigation: import('@sveltejs/kit').BeforeNavigate) => void) => void}
+ * @param {(navigation: import('@sveltejs/kit').BeforeNavigate) => void} callback
+ * @returns {void}
+ */
 export const beforeNavigate = /* @__PURE__ */ client_method('before_navigate');
 
+/**
+ * A lifecycle function that runs the supplied `callback` when the current component mounts, and also whenever we navigate to a new URL.
+ *
+ * `afterNavigate` must be called during a component initialization. It remains active as long as the component is mounted.
+ * @type {(callback: (navigation: import('@sveltejs/kit').AfterNavigate) => void) => void}
+ * @param {(navigation: import('@sveltejs/kit').AfterNavigate) => void} callback
+ * @returns {void}
+ */
 export const afterNavigate = /* @__PURE__ */ client_method('after_navigate');

package/src/runtime/app/stores.js

@@ -3,32 +3,48 @@ import { browser } from './environment.js';
 import { stores as browser_stores } from '../client/singletons.js';
 
 /**
- * @type {import('$app/stores').getStores}
+ * A function that returns all of the contextual stores. On the server, this must be called during component initialization.
+ * Only use this if you need to defer store subscription until after the component has mounted, for some reason.
  */
 export const getStores = () => {
 	const stores = browser ? browser_stores : getContext('__svelte__');
 
 	return {
+		/** @type {typeof page} */
 		page: {
 			subscribe: stores.page.subscribe
 		},
+		/** @type {typeof navigating} */
 		navigating: {
 			subscribe: stores.navigating.subscribe
 		},
+		/** @type {typeof updated} */
 		updated: stores.updated
 	};
 };
 
-/** @type {typeof import('$app/stores').page} */
+/**
+ * A readable store whose value contains page data.
+ *
+ * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
+ *
+ * @type {import('svelte/store').Readable<import('@sveltejs/kit').Page>}
+ */
 export const page = {
-	/** @param {(value: any) => void} fn */
 	subscribe(fn) {
 		const store = __SVELTEKIT_DEV__ ? get_store('page') : getStores().page;
 		return store.subscribe(fn);
 	}
 };
 
-/** @type {typeof import('$app/stores').navigating} */
+/**
+ * A readable store.
+ * When navigating starts, its value is a `Navigation` object with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
+ * When navigating finishes, its value reverts to `null`.
+ *
+ * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
+ * @type {import('svelte/store').Readable<import('@sveltejs/kit').Navigation | null>}
+ */
 export const navigating = {
 	subscribe(fn) {
 		const store = __SVELTEKIT_DEV__ ? get_store('navigating') : getStores().navigating;
@@ -36,7 +52,12 @@ export const navigating = {
 	}
 };
 
-/** @type {typeof import('$app/stores').updated} */
+/**
+ * A readable store whose initial value is `false`. If [`version.pollInterval`](https://kit.svelte.dev/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
+ *
+ * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
+ * @type {import('svelte/store').Readable<boolean> & { check(): Promise<boolean> }}
+ */
 export const updated = {
 	subscribe(fn) {
 		const store = __SVELTEKIT_DEV__ ? get_store('updated') : getStores().updated;
@@ -50,8 +71,8 @@ export const updated = {
 	check: () => {
 		throw new Error(
 			browser
-				? `Cannot check updated store before subscribing`
-				: `Can only check updated store in browser`
+				? 'Cannot check updated store before subscribing'
+				: 'Can only check updated store in browser'
 		);
 	}
 };

package/src/runtime/client/client.js

@@ -86,10 +86,10 @@ export function create_client(app, target) {
 	let load_cache = null;
 
 	const callbacks = {
-		/** @type {Array<(navigation: import('types').BeforeNavigate) => void>} */
+		/** @type {Array<(navigation: import('@sveltejs/kit').BeforeNavigate) => void>} */
 		before_navigate: [],
 
-		/** @type {Array<(navigation: import('types').AfterNavigate) => void>} */
+		/** @type {Array<(navigation: import('@sveltejs/kit').AfterNavigate) => void>} */
 		after_navigate: []
 	};
 
@@ -138,7 +138,7 @@ export function create_client(app, target) {
 		scrollTo(scroll.x, scroll.y);
 	}
 
-	/** @type {import('types').Page} */
+	/** @type {import('@sveltejs/kit').Page} */
 	let page;
 
 	/** @type {{}} */
@@ -279,7 +279,7 @@ export function create_client(app, target) {
 		const style = document.querySelector('style[data-sveltekit]');
 		if (style) style.remove();
 
-		page = /** @type {import('types').Page} */ (result.props.page);
+		page = /** @type {import('@sveltejs/kit').Page} */ (result.props.page);
 
 		root = new app.root({
 			target,
@@ -289,7 +289,7 @@ export function create_client(app, target) {
 
 		restore_snapshot(current_history_index);
 
-		/** @type {import('types').AfterNavigate} */
+		/** @type {import('@sveltejs/kit').AfterNavigate} */
 		const navigation = {
 			from: null,
 			to: {
@@ -332,6 +332,7 @@ export function create_client(app, target) {
 			if (node?.slash !== undefined) slash = node.slash;
 		}
 		url.pathname = normalize_path(url.pathname, slash);
+		// eslint-disable-next-line
 		url.search = url.search; // turn `/?` into `/`
 
 		/** @type {import('./types').NavigationFinished} */
@@ -445,7 +446,7 @@ export function create_client(app, target) {
 				}
 			}
 
-			/** @type {import('types').LoadEvent} */
+			/** @type {import('@sveltejs/kit').LoadEvent} */
 			const load_input = {
 				route: {
 					get id() {
@@ -900,7 +901,7 @@ export function create_client(app, target) {
 	/**
 	 * @param {{
 	 *   url: URL;
-	 *   type: import('types').NavigationType;
+	 *   type: import('@sveltejs/kit').NavigationType;
 	 *   intent?: import('./types').NavigationIntent;
 	 *   delta?: number;
 	 * }} opts
@@ -908,7 +909,7 @@ export function create_client(app, target) {
 	function before_navigate({ url, type, intent, delta }) {
 		let should_block = false;
 
-		/** @type {import('types').Navigation} */
+		/** @type {import('@sveltejs/kit').Navigation} */
 		const navigation = {
 			from: {
 				params: current.params,
@@ -953,7 +954,7 @@ export function create_client(app, target) {
 	 *     replaceState: boolean;
 	 *     state: any;
 	 *   } | null;
-	 *   type: import('types').NavigationType;
+	 *   type: import('@sveltejs/kit').NavigationType;
 	 *   delta?: number;
 	 *   nav_token?: {};
 	 *   accepted: () => void;
@@ -1141,7 +1142,7 @@ export function create_client(app, target) {
 		}
 
 		callbacks.after_navigate.forEach((fn) =>
-			fn(/** @type {import('types').AfterNavigate} */ (navigation))
+			fn(/** @type {import('@sveltejs/kit').AfterNavigate} */ (navigation))
 		);
 		stores.navigating.set(null);
 
@@ -1173,7 +1174,7 @@ export function create_client(app, target) {
 				'An error occurred while loading the page. This will cause a full page reload. (This message will only appear during development.)'
 			);
 
-			debugger;
+			debugger; // eslint-disable-line
 		}
 
 		return await native_navigation(url);
@@ -1295,7 +1296,7 @@ export function create_client(app, target) {
 
 	/**
 	 * @param {unknown} error
-	 * @param {import('types').NavigationEvent} event
+	 * @param {import('@sveltejs/kit').NavigationEvent} event
 	 * @returns {import('types').MaybePromise<App.Error>}
 	 */
 	function handle_error(error, event) {
@@ -1444,7 +1445,7 @@ export function create_client(app, target) {
 				if (!navigating) {
 					// If we're navigating, beforeNavigate was already called. If we end up in here during navigation,
 					// it's due to an external or full-page-reload link, for which we don't want to call the hook again.
-					/** @type {import('types').BeforeNavigate} */
+					/** @type {import('@sveltejs/kit').BeforeNavigate} */
 					const navigation = {
 						from: {
 							params: current.params,
@@ -1538,6 +1539,15 @@ export function create_client(app, target) {
 				// Removing the hash does a full page navigation in the browser, so make sure a hash is present
 				const [nonhash, hash] = url.href.split('#');
 				if (hash !== undefined && nonhash === location.href.split('#')[0]) {
+					// If we are trying to navigate to the same hash, we should only
+					// attempt to scroll to that element and avoid any history changes.
+					// Otherwise, this can cause Firefox to incorrectly assign a null
+					// history state value without any signal that we can detect.
+					if (current.url.hash === url.hash) {
+						event.preventDefault();
+						a.ownerDocument.getElementById(hash)?.scrollIntoView();
+						return;
+					}
 					// set this flag to distinguish between navigations triggered by
 					// clicking a hash link and those triggered by popstate
 					hash_navigating = true;
@@ -1679,7 +1689,7 @@ export function create_client(app, target) {
 			// URLs after a pushState/replaceState, resulting in a 404 — see
 			// https://github.com/sveltejs/kit/issues/3748#issuecomment-1125980897
 			for (const link of document.querySelectorAll('link')) {
-				if (link.rel === 'icon') link.href = link.href;
+				if (link.rel === 'icon') link.href = link.href; // eslint-disable-line
 			}
 
 			addEventListener('pageshow', (event) => {
@@ -1806,6 +1816,8 @@ async function load_data(url, invalid) {
 		throw new HttpError(res.status, await res.json());
 	}
 
+	// TODO: fix eslint error
+	// eslint-disable-next-line
 	return new Promise(async (resolve) => {
 		/**
 		 * Map of deferred promises that will be resolved by a subsequent chunk of data

package/src/runtime/client/singletons.js

@@ -44,8 +44,10 @@ export function client_method(key) {
 }
 
 export const stores = {
-	url: notifiable_store({}),
-	page: notifiable_store({}),
-	navigating: writable(/** @type {import('types').Navigation | null} */ (null)),
-	updated: create_updated_store()
+	url: /* @__PURE__ */ notifiable_store({}),
+	page: /* @__PURE__ */ notifiable_store({}),
+	navigating: /* @__PURE__ */ writable(
+		/** @type {import('@sveltejs/kit').Navigation | null} */ (null)
+	),
+	updated: /* @__PURE__ */ create_updated_store()
 };

package/src/runtime/client/start.js

@@ -10,7 +10,7 @@ import { init } from './singletons.js';
 export async function start(app, target, hydrate) {
 	if (DEV && target === document.body) {
 		console.warn(
-			`Placing %sveltekit.body% directly inside <body> is not recommended, as your app may break for users who have certain browser extensions installed.\n\nConsider wrapping it in an element:\n\n<div style="display: contents">\n  %sveltekit.body%\n</div>`
+			'Placing %sveltekit.body% directly inside <body> is not recommended, as your app may break for users who have certain browser extensions installed.\n\nConsider wrapping it in an element:\n\n<div style="display: contents">\n  %sveltekit.body%\n</div>'
 		);
 	}
 

package/src/runtime/client/types.d.ts

@@ -1,4 +1,4 @@
-import { applyAction } from '$app/forms';
+import { applyAction } from '../app/forms';
 import {
 	afterNavigate,
 	beforeNavigate,
@@ -7,18 +7,10 @@ import {
 	invalidateAll,
 	preloadCode,
 	preloadData
-} from '$app/navigation';
+} from '../app/navigation';
 import { SvelteComponent } from 'svelte';
-import {
-	ClientHooks,
-	CSRPageNode,
-	CSRPageNodeLoader,
-	CSRRoute,
-	Page,
-	ParamMatcher,
-	TrailingSlash,
-	Uses
-} from 'types';
+import { ClientHooks, CSRPageNode, CSRPageNodeLoader, CSRRoute, TrailingSlash, Uses } from 'types';
+import { Page, ParamMatcher } from '@sveltejs/kit';
 
 export interface SvelteKitApp {
 	/**