@sveltejs/kit 3.0.0-next.18 → 3.0.0-next.19

package/src/pathname.js

@@ -0,0 +1,55 @@
+const DATA_SUFFIX = '/__data.json';
+const HTML_DATA_SUFFIX = '.html__data.json';
+
+/** @param {string} pathname */
+export function has_data_suffix(pathname) {
+	return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
+}
+
+/** @param {string} pathname */
+export function add_data_suffix(pathname) {
+	if (pathname.endsWith('.html')) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
+	return pathname.replace(/\/$/, '') + DATA_SUFFIX;
+}
+
+/** @param {string} pathname */
+export function strip_data_suffix(pathname) {
+	if (pathname.endsWith(HTML_DATA_SUFFIX)) {
+		return pathname.slice(0, -HTML_DATA_SUFFIX.length) + '.html';
+	}
+
+	return pathname.slice(0, -DATA_SUFFIX.length);
+}
+
+const ROUTE_SUFFIX = '/__route.js';
+const HTML_ROUTE_SUFFIX = '.html__route.js';
+
+/**
+ * @param {string} pathname
+ * @returns {boolean}
+ */
+export function has_resolution_suffix(pathname) {
+	return pathname.endsWith(ROUTE_SUFFIX) || pathname.endsWith(HTML_ROUTE_SUFFIX);
+}
+
+/**
+ * Convert a regular URL to a route to send to SvelteKit's server-side route resolution endpoint
+ * @param {string} pathname
+ * @returns {string}
+ */
+export function add_resolution_suffix(pathname) {
+	if (pathname.endsWith('.html')) return pathname.replace(/\.html$/, HTML_ROUTE_SUFFIX);
+	return pathname.replace(/\/$/, '') + ROUTE_SUFFIX;
+}
+
+/**
+ * @param {string} pathname
+ * @returns {string}
+ */
+export function strip_resolution_suffix(pathname) {
+	if (pathname.endsWith(HTML_ROUTE_SUFFIX)) {
+		return pathname.slice(0, -HTML_ROUTE_SUFFIX.length) + '.html';
+	}
+
+	return pathname.slice(0, -ROUTE_SUFFIX.length);
+}

package/src/runtime/app/{forms.js → forms/index.js}

@@ -1,13 +1,14 @@
+/** @import { ActionResult, SubmitFunction } from './types.js' */
 import { DEV } from 'esm-env';
-import { noop } from '../../utils/functions.js';
-import { refreshAll } from './navigation.js';
+import { noop } from '../../../utils/functions.js';
+import { refreshAll } from '../navigation/index.js';
 import {
 	applyAction,
 	apply_action_navigation,
 	handle_error,
 	is_current_location
-} from '../client/client.js';
-import { notify_version } from '../client/state.svelte.js';
+} from '../../client/client.js';
+import { notify_version } from '../../client/state.svelte.js';
 import { parse } from '#app/internal/transport';
 
 export { applyAction };
@@ -32,7 +33,7 @@ export { applyAction };
  * @template {Record<string, unknown> | undefined} Success
  * @template {Record<string, unknown> | undefined} Failure
  * @param {string} result
- * @returns {import('@sveltejs/kit').ActionResult<Success, Failure>}
+ * @returns {ActionResult<Success, Failure>}
  */
 export function deserialize(result) {
 	const parsed = JSON.parse(result);
@@ -79,7 +80,7 @@ function clone(element) {
  * @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
+ * @param {SubmitFunction<Success, Failure>} submit Submit callback
  */
 export function enhance(form_element, submit = noop) {
 	if (DEV && clone(form_element).method !== 'post') {
@@ -88,7 +89,7 @@ export function enhance(form_element, submit = noop) {
 
 	/**
 	 * @param {{
-	 *   result: import('@sveltejs/kit').ActionResult;
+	 *   result: ActionResult;
 	 *   reset?: boolean;
 	 *   refreshAll?: boolean;
 	 *   invalidateAll?: boolean;
@@ -182,7 +183,7 @@ export function enhance(form_element, submit = noop) {
 			})) ?? fallback_callback;
 		if (cancelled) return;
 
-		/** @type {import('@sveltejs/kit').ActionResult} */
+		/** @type {ActionResult} */
 		let result;
 
 		try {

package/src/runtime/app/forms/public.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export type { ActionResult, SubmitFunction } from './types.js';

package/src/runtime/app/forms/types.d.ts

@@ -0,0 +1,56 @@
+// kept separate from public.d.ts so generated $types can resolve these without pulling in the runtime graph
+import type { MaybePromise } from '../../../types/private.js';
+/**
+ * When calling a form action via fetch, the response will be one of these shapes.
+ * ```svelte
+ * <form method="post" use:enhance={() => {
+ *   return ({ result }) => {
+ * 		// result is of type ActionResult
+ *   };
+ * }}
+ * ```
+ *
+ * Success and failure results carry the root-relative `pathname + search` of the action URL, with
+ * the `?/actionName` parameter removed. Redirect results carry the redirect target. Server-generated
+ * error results also carry the action location, while client-generated errors such as network
+ * failures do not. `update` uses this location to emulate native form navigation.
+ */
+export type ActionResult<
+	Success extends Record<string, unknown> | undefined = Record<string, any>,
+	Failure extends Record<string, unknown> | undefined = Record<string, any>
+> =
+	| { type: 'success'; status: number; data?: Success; location: string }
+	| { type: 'failure'; status: number; data?: Failure; location: string }
+	| { type: 'redirect'; status: number; location: string }
+	| { type: 'error'; status?: number; error: App.Error; location?: string };
+
+export type SubmitFunction<
+	Success extends Record<string, unknown> | undefined = Record<string, any>,
+	Failure extends Record<string, unknown> | undefined = Record<string, any>
+> = (input: {
+	action: URL;
+	formData: FormData;
+	formElement: HTMLFormElement;
+	controller: AbortController;
+	submitter: HTMLElement | null;
+	cancel: () => void;
+}) => MaybePromise<
+	| void
+	| ((opts: {
+			formData: FormData;
+			formElement: HTMLFormElement;
+			action: URL;
+			result: ActionResult<Success, Failure>;
+			/**
+			 * Call this to get the default behavior of a form submission response.
+			 * @param options Set `reset: false` if you don't want the `<form>` values to be reset after a successful submission. `refreshAll` defaults to `true` for successful results and `false` for failures. When the submission navigates, setting it to `false` still runs the destination's `load` functions but may reuse shared layout data. Set `navigate: false` to apply non-redirect results to the current page instead of navigating to `result.location`. Redirects are always followed.
+			 */
+			update: (options?: {
+				reset?: boolean;
+				refreshAll?: boolean;
+				navigate?: boolean;
+				/** @deprecated Use `refreshAll` instead. */
+				invalidateAll?: boolean;
+			}) => Promise<void>;
+	  }) => MaybePromise<void>)
+>;

package/src/runtime/app/{navigation.js → navigation/index.js}

@@ -11,5 +11,5 @@ export {
 	preloadData,
 	pushState,
 	replaceState
-} from '../client/client.js';
-export { snapshot } from '../client/snapshots.js';
+} from '../../client/client.js';
+export { snapshot } from '../../client/snapshots.js';

package/src/runtime/app/navigation/public.d.ts

@@ -0,0 +1,237 @@
+import type { LayoutParams as AppLayoutParams, RouteId as AppRouteId } from '$app/types';
+
+export * from './index.js';
+
+/**
+ * Information about the target of a specific navigation.
+ */
+export interface NavigationTarget<
+	Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+	RouteId extends AppRouteId | null = AppRouteId | null
+> {
+	/**
+	 * Parameters of the target page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+	 * Is `null` if the target is not part of the SvelteKit app (could not be resolved to a route).
+	 */
+	params: Params | null;
+	/**
+	 * Info about the target route
+	 */
+	route: {
+		/**
+		 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+		 */
+		id: RouteId | null;
+	};
+	/**
+	 * The URL that is navigated to
+	 */
+	url: URL;
+	/**
+	 * The scroll position associated with this navigation.
+	 *
+	 * For the `from` target, this is the scroll position at the moment of navigation.
+	 *
+	 * For the `to` target, this represents the scroll position that will be or was restored:
+	 * - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button)
+	 *   and will be `null` for other navigation types, since the final scroll position isn't known
+	 *   ahead of time.
+	 * - In `afterNavigate`, this is always the scroll position that was applied after the navigation
+	 *   completed.
+	 */
+	scroll: { x: number; y: number } | null;
+}
+
+export interface GotoOptions {
+	/**
+	 * If `true`, replaces the current history entry rather than creating a new one.
+	 * @default false
+	 */
+	replace?: boolean;
+	/** @deprecated Use `replace` instead. */
+	replaceState?: boolean;
+	/**
+	 * If `true`, updates the URL and `page.state` without navigating.
+	 * @default false
+	 */
+	shallow?: boolean;
+	/**
+	 * If `true`, resets the scroll position (to the top of the page, or to the element
+	 * matching the URL's `#hash` if there is one) and resets focus (to the `<body>`, or the
+	 * `autofocus` element if there is one) once the navigation completes.
+	 *
+	 * If `false`, the current scroll position and focused element are left alone.
+	 * @default true, or false when `shallow` is true
+	 */
+	reset?: boolean;
+	/**
+	 * If `true`, reruns all `load` functions and queries of the page.
+	 * @default false
+	 */
+	refreshAll?: boolean;
+	/** Causes any `load` functions to rerun if they depend on one of the URLs. */
+	invalidate?: Array<string | URL | ((url: URL) => boolean)>;
+	/** @deprecated Use `refreshAll` instead. */
+	invalidateAll?: boolean;
+	/** An optional object that will be available as `page.state`. */
+	state?: App.PageState;
+	/**
+	 * If `true`, `page.state` will be restored after a full page reload.
+	 * @default false
+	 */
+	persistState?: boolean;
+}
+
+/**
+ * - `enter`: The app has hydrated/started
+ * - `form`: The user submitted a `<form method="GET">`
+ * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
+ * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
+ * - `link`: Navigation was triggered by a link click
+ * - `popstate`: Navigation was triggered by back/forward navigation
+ */
+export type NavigationType = 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate';
+
+export interface NavigationBase {
+	/**
+	 * The type of navigation:
+	 * - `enter`: The app has hydrated/started
+	 * - `form`: The user submitted a `<form method="GET">`
+	 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
+	 * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
+	 * - `link`: Navigation was triggered by a link click
+	 * - `popstate`: Navigation was triggered by back/forward navigation
+	 */
+	type: NavigationType;
+	/** Whether this is a shallow navigation. */
+	shallow: boolean;
+	/**
+	 * Where navigation was triggered from
+	 */
+	from: NavigationTarget | null;
+	/**
+	 * Where navigation is going to/has gone to
+	 */
+	to: NavigationTarget | null;
+	/**
+	 * Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation).
+	 */
+	willUnload: boolean;
+	/**
+	 * A promise that resolves once the navigation is complete, and rejects if the navigation
+	 * fails or is aborted. In the case of a `willUnload` navigation, the promise will never resolve
+	 */
+	complete: Promise<void>;
+}
+
+/**
+ * The navigation that occurs when the app starts/hydrates
+ */
+export interface NavigationEnter extends NavigationBase {
+	type: 'enter';
+
+	/**
+	 * In case of a history back/forward navigation, the number of steps to go back/forward
+	 */
+	delta?: undefined;
+
+	/**
+	 * Dispatched `Event` object when navigation occurred by `popstate` or `link`.
+	 */
+	event?: undefined;
+}
+
+export type NavigationExternal = NavigationGoto | NavigationLeave;
+
+/**
+ * A navigation triggered by a `goto(...)` call or a redirect
+ */
+export interface NavigationGoto extends NavigationBase {
+	type: 'goto';
+}
+
+/**
+ * A navigation triggered by the tab being closed, or the user navigating to a different document
+ */
+export interface NavigationLeave extends NavigationBase {
+	type: 'leave';
+}
+
+/**
+ * A navigation triggered by a `<form method="GET">`
+ */
+export interface NavigationFormSubmit extends NavigationBase {
+	type: 'form';
+
+	/**
+	 * The `SubmitEvent` that caused the navigation
+	 */
+	event: SubmitEvent;
+}
+
+/**
+ * A navigation triggered by back/forward navigation
+ */
+export interface NavigationPopState extends NavigationBase {
+	type: 'popstate';
+
+	/**
+	 * In case of a history back/forward navigation, the number of steps to go back/forward
+	 */
+	delta: number;
+
+	/**
+	 * The `PopStateEvent` that caused the navigation
+	 */
+	event: PopStateEvent;
+}
+
+/**
+ * A navigation triggered by a link click
+ */
+export interface NavigationLink extends NavigationBase {
+	type: 'link';
+
+	/**
+	 * The `PointerEvent` that caused the navigation
+	 */
+	event: PointerEvent;
+}
+
+export type Navigation =
+	| NavigationExternal
+	| NavigationFormSubmit
+	| NavigationPopState
+	| NavigationLink;
+
+/**
+ * The argument passed to [`beforeNavigate`](https://svelte.dev/docs/kit/$app-navigation#beforeNavigate) callbacks.
+ */
+export type BeforeNavigate = Navigation & {
+	/**
+	 * Call this to prevent the navigation from starting.
+	 */
+	cancel: () => void;
+};
+
+/**
+ * The argument passed to [`onNavigate`](https://svelte.dev/docs/kit/$app-navigation#onNavigate) callbacks.
+ */
+export type OnNavigate = Navigation & {
+	type: Exclude<NavigationType, 'enter' | 'leave'>;
+	/**
+	 * Since `onNavigate` callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page.
+	 */
+	willUnload: false;
+};
+
+/**
+ * The argument passed to [`afterNavigate`](https://svelte.dev/docs/kit/$app-navigation#afterNavigate) callbacks.
+ */
+export type AfterNavigate = (Navigation | NavigationEnter) & {
+	type: Exclude<NavigationType, 'leave'>;
+	/**
+	 * Since `afterNavigate` callbacks are called after a navigation completes, they will never be called with a navigation that unloads the page.
+	 */
+	willUnload: false;
+};

package/src/runtime/app/paths/client.js

@@ -4,6 +4,8 @@ import { base, assets, hash_routing, match_implementation } from './internal/cli
 import { resolve_route } from '../../../utils/routing.js';
 import { DEV } from 'esm-env';
 
+export { base, assets, app_dir } from './internal/client.js';
+
 /**
  * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
  *
@@ -23,16 +25,18 @@ import { DEV } from 'esm-env';
  * @returns {string}
  */
 export function asset(file) {
+	let path = /** @type {string} */ (file);
+
 	// TODO 4.0 remove this
-	if (file[0] === '/') {
+	if (path[0] === '/') {
 		if (DEV) {
-			console.warn(`\`asset('${file}')\` should now be \`asset('${file.slice(1)}')\``);
+			console.warn(`\`asset('${path}')\` should now be \`asset('${path.slice(1)}')\``);
 		}
 
-		file = file.slice(1);
+		path = path.slice(1);
 	}
 
-	return (assets || base) + '/' + file;
+	return (assets || base) + '/' + path;
 }
 
 const pathname_prefix = hash_routing ? '#' : '';
@@ -61,18 +65,20 @@ const pathname_prefix = hash_routing ? '#' : '';
  * @returns {ResolvedPathname}
  */
 export function resolve(...args) {
-	if (args[0][0] === '/') {
-		const [id, params] = args;
+	const [id, params] = /** @type {[string, Record<string, string>?]} */ (args);
 
+	if (id[0] === '/') {
 		// route ID
 		if (id.includes('[') && !params) {
 			throw new Error(`Missing params for dynamic route ID ${id}`);
 		}
 
-		return base + pathname_prefix + resolve_route(args[0], args[1] ?? {});
+		return (
+			/** @type {ResolvedPathname} */ (base + pathname_prefix + resolve_route(id, params ?? {}))
+		);
 	}
 
-	return base + pathname_prefix + '/' + args[0];
+	return /** @type {ResolvedPathname} */ (base + pathname_prefix + '/' + id);
 }
 
 /**

package/src/runtime/app/paths/index.js

@@ -1 +1 @@
-export * from '#app/paths';
+export { asset, resolve, match } from '#app/paths';

package/src/runtime/app/paths/internal/client.js

@@ -1,3 +1,7 @@
+// TODO get rid of this module — merge the contents into `../client.js`, and expose it to the
+// rest of the codebase as `#app/paths/client`, with an export condition that errors if
+// it is imported on the server
+
 /** @import { RouteId } from '$app/types' */
 import { payload } from '../../../client/payload.js';
 

package/src/runtime/app/paths/internal/server.js

@@ -1,3 +1,7 @@
+// TODO get rid of this module — merge the contents into `../server.js`, and expose it to the
+// rest of the codebase as `#app/paths/server`, with an export condition that errors if
+// it is imported on the client
+
 export const base = __SVELTEKIT_PATHS_BASE__;
 export let assets = __SVELTEKIT_PATHS_ASSETS__ || base;
 export const app_dir = __SVELTEKIT_APP_DIR__;

package/src/runtime/app/paths/internal.d.ts

@@ -0,0 +1,3 @@
+import '../../../types/global-private.js';
+
+export * from './client.js';

package/src/runtime/app/paths/public.d.ts

@@ -1 +1 @@
-export { resolve, asset, match } from './client.js';
+export { asset, resolve, match } from './client.js';

package/src/runtime/app/paths/server.js

@@ -1,13 +1,15 @@
 import { base, assets, relative } from './internal/server.js';
 import { resolve_route, find_route } from '../../../utils/routing.js';
 import { decode_pathname } from '../../../utils/url.js';
-import { add_data_suffix } from '../../pathname.js';
+import { add_data_suffix } from '../../../pathname.js';
 import { try_get_request_store } from '@sveltejs/kit/internal/server';
 import { manifest } from '../../server/internal.js';
 import { get_hooks } from '__SERVER__/internal.js';
 import { DEV } from 'esm-env';
 
-/** @type {import('./client.js').asset} */
+export { base, assets, app_dir } from './internal/server.js';
+
+/** @type {typeof import('./client.js').asset} */
 export function asset(file) {
 	// TODO 4.0 remove this
 	if (file[0] === '/') {
@@ -21,7 +23,7 @@ export function asset(file) {
 	return assets !== base ? `${assets}/${file}` : resolve(file);
 }
 
-/** @type {import('./client.js').resolve} */
+/** @type {typeof import('./client.js').resolve} */
 export function resolve(id, params) {
 	let resolved;
 
@@ -56,7 +58,7 @@ export function resolve(id, params) {
 	return base + resolved;
 }
 
-/** @type {import('./client.js').match} */
+/** @type {typeof import('./client.js').match} */
 export async function match(url) {
 	const store = try_get_request_store();
 

package/src/runtime/app/server/index.js

@@ -1,5 +1,5 @@
 import { read_implementation, manifest } from '../../server/internal.js';
-import { assets } from '$app/paths/internal/server';
+import { assets } from '#app/paths';
 import { base64_decode } from '../../utils.js';
 
 /**

package/src/runtime/app/server/remote/form.js

@@ -72,8 +72,7 @@ export function form(validate_or_fn, maybe_fn) {
 	 * @param {string | number | boolean} [key]
 	 */
 	function create_instance(key) {
-		/** @type {RemoteForm<Input, Output>} */
-		const instance = {};
+		const instance = /** @type {RemoteForm<Input, Output>} */ ({});
 
 		instance.method = 'POST';
 
@@ -89,8 +88,8 @@ export function form(validate_or_fn, maybe_fn) {
 			name: '',
 			id: '',
 			fn: async (data, meta, form_data) => {
-				/** @type {{ submission: true, input?: Record<string, any>, issues?: InternalRemoteFormIssue[], result: Output }} */
-				const output = {};
+				const output =
+					/** @type {{ submission: true, input?: Record<string, any>, issues?: InternalRemoteFormIssue[], result: Output }} */ ({});
 
 				// make it possible to differentiate between user submission and programmatic `field.set(...)` updates
 				output.submission = true;

package/src/runtime/app/server/remote/prerender.js

@@ -2,12 +2,12 @@
 /** @import { RemoteFunctionResponse, RemotePrerenderInputsGenerator, RemotePrerenderInternals, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { json } from '@sveltejs/kit';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HandledHttpError } from '@sveltejs/kit/internal';
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { stringify_remote_arg } from '../../../shared.js';
 import { parse, stringify } from '#app/internal/transport';
 import { noop } from '../../../../utils/functions.js';
-import { app_dir, base } from '$app/paths/internal/server';
+import { app_dir, base } from '#app/paths';
 import { create_validator, get_response, run_remote_function } from './shared.js';
 
 /**
@@ -114,7 +114,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 
 				if (prerendered) {
 					if (prerendered.type === 'error') {
-						throw new HttpError(prerendered.error);
+						throw new HandledHttpError(prerendered.error);
 					}
 
 					return parse(prerendered.data)._;

package/src/runtime/app/server/remote/shared.js

@@ -1,7 +1,8 @@
 /** @import { RequestEvent } from '@sveltejs/kit' */
 /** @import { MaybePromise, RequestState, RemoteInternals, RequestStore, RemoteLiveQueryUserFunctionReturnType } from 'types' */
 import { error } from '@sveltejs/kit';
-import { with_request_store, get_request_store } from '@sveltejs/kit/internal/server';
+import { ValidationError } from '@sveltejs/kit/internal';
+import { with_request_store } from '@sveltejs/kit/internal/server';
 
 /**
  * @param {any} validate_or_fn
@@ -26,19 +27,12 @@ export function create_validator(validate_or_fn, maybe_fn) {
 	// use https://standardschema.dev validator if provided
 	if ('~standard' in validate_or_fn) {
 		return async (arg) => {
-			// Get event before async validation to ensure it's available in server environments without AsyncLocalStorage, too
-			const { event, state } = get_request_store();
-
 			// access property and call method in one go to preserve potential this context
 			const result = await validate_or_fn['~standard'].validate(arg);
 
 			// if the `issues` field exists, the validation failed
 			if (result.issues) {
-				const body = await state.handleValidationError({
-					issues: result.issues,
-					event: state.original_event ?? event
-				});
-				error(body.status ?? 400, body);
+				throw new ValidationError(result.issues);
 			}
 
 			return result.value;
@@ -137,7 +131,6 @@ function derive_remote_function_event(event, state, allow_cookies) {
 		event: derived,
 		state: {
 			...state,
-			original_event: state.original_event ?? event,
 			is_in_remote_function: true
 		}
 	};

package/src/runtime/app/state/index.js

@@ -1,3 +1,5 @@
+/** @import { Navigation } from '$app/navigation' */
+/** @import { Page } from '$app/state' */
 import {
 	page as client_page,
 	navigating as client_navigating,
@@ -45,14 +47,14 @@ import { BROWSER } from 'esm-env';
  *
  * On the server, values can only be read during rendering (in other words _not_ in e.g. `load` functions). In the browser, the values can be read at any time.
  *
- * @type {import('@sveltejs/kit').Page}
+ * @type {Page}
  */
 export const page = BROWSER ? client_page : server_page;
 
 /**
  * A read-only object representing an in-progress navigation, with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
  * Values are `null` when no navigation is occurring, or during server rendering.
- * @type {import('@sveltejs/kit').Navigation | { from: null, to: null, type: null, willUnload: null, delta: null, complete: null }}
+ * @type {Navigation | { from: null, to: null, type: null, willUnload: null, delta: null, complete: null }}
  */
 // @ts-expect-error
 export const navigating = BROWSER ? client_navigating : server_navigating;