@sveltejs/kit 3.0.0-next.10 → 3.0.0-next.12

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

@@ -7,7 +7,8 @@ import { compact } from '../../../utils/array.js';
 import { get_status, normalize_error } from '../../../utils/error.js';
 import { noop } from '../../../utils/functions.js';
 import { add_data_suffix } from '../../pathname.js';
-import { redirect_response, static_error_page, handle_error_and_jsonify } from '../utils.js';
+import { redirect_response } from '../utils.js';
+import { static_error_page, handle_error_and_jsonify } from '../errors.js';
 import {
 	handle_action_json_request,
 	handle_action_request,
@@ -19,7 +20,7 @@ import { load_data, load_server_data } from './load_data.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
 import { DEV } from 'esm-env';
-import { get_remote_action, handle_remote_form_post } from '../remote.js';
+import { get_remote_action, handle_remote_form_post } from '../remote-functions.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 
 /**

package/src/runtime/server/page/load_data.js

@@ -465,7 +465,7 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 					const included = resolve_opts.filterSerializedResponseHeaders(lower, value);
 					if (!included) {
 						throw new Error(
-							`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#Server-hooks-handle (at ${event.route.id})`
+							`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#handle (at ${event.route.id})`
 						);
 					}
 				}

package/src/runtime/server/page/render.js

@@ -14,14 +14,10 @@ import { create_server_routing_response, generate_route_object } from './server_
 import { add_data_suffix, add_resolution_suffix } from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
-import {
-	count_non_ssi_comments,
-	create_replacer,
-	get_global_name,
-	handle_error_and_jsonify
-} from '../utils.js';
+import { count_non_ssi_comments, create_replacer, get_global_name } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
 import * as env from '__sveltekit/env';
-import { collect_remote_data } from '../remote.js';
+import { collect_remote_data } from '../remote-functions.js';
 import Root from '../../components/root.svelte';
 import { render } from 'svelte/server';
 
@@ -308,6 +304,19 @@ export async function render_response({
 		head.add_style(style, attributes);
 	}
 
+	/**
+	 * see the `output.linkHeaderPreload` option for details on why we have multiple options here
+	 * @param {string} path
+	 * @param {string[]} attributes
+	 */
+	const add_preload = (path, attributes) => {
+		if (options.link_header_preload && !state.prerendering) {
+			link_headers.add(`<${encodeURI(path)}>; ${attributes.join('; ')}; nopush`);
+		} else {
+			head.add_link_tag(path, attributes);
+		}
+	};
+
 	for (const dep of stylesheets) {
 		const path = prefixed(dep);
 
@@ -332,18 +341,7 @@ export async function render_response({
 		if (resolve_opts.preload({ type: 'font', path })) {
 			const ext = dep.slice(dep.lastIndexOf('.') + 1);
 
-			if (options.link_header_preload && !state.prerendering) {
-				link_headers.add(
-					`<${encodeURI(path)}>; rel="preload"; as="font"; type="font/${ext}"; crossorigin; nopush`
-				);
-			} else {
-				head.add_link_tag(path, [
-					'rel="preload"',
-					'as="font"',
-					`type="font/${ext}"`,
-					'crossorigin'
-				]);
-			}
+			add_preload(path, ['rel="preload"', 'as="font"', `type="font/${ext}"`, 'crossorigin']);
 		}
 	}
 
@@ -372,23 +370,12 @@ export async function render_response({
 		}
 
 		if (!client.inline) {
-			const included_modulepreloads = Array.from(modulepreloads, (dep) => prefixed(dep)).filter(
-				(path) => resolve_opts.preload({ type: 'js', path })
-			);
-
-			/** @type {(path: string) => void} */
-			let add_preload;
+			for (const dep of modulepreloads) {
+				const path = prefixed(dep);
 
-			// see the output.preloadStrategy option for details on why we have multiple options here
-			if (options.link_header_preload && !state.prerendering) {
-				add_preload = (path) =>
-					link_headers.add(`<${encodeURI(path)}>; rel="modulepreload"; nopush`);
-			} else {
-				add_preload = (path) => head.add_link_tag(path, ['rel="modulepreload"']);
-			}
-
-			for (const path of included_modulepreloads) {
-				add_preload(path);
+				if (resolve_opts.preload({ type: 'js', path })) {
+					add_preload(path, ['rel="modulepreload"']);
+				}
 			}
 		}
 

package/src/runtime/server/page/respond_with_error.js

@@ -1,7 +1,8 @@
 import { Redirect } from '@sveltejs/kit/internal';
 import { render_response } from './render.js';
 import { load_data, load_server_data } from './load_data.js';
-import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
+import { redirect_response } from '../utils.js';
+import { handle_error_and_jsonify, static_error_page } from '../errors.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
 
@@ -33,12 +34,12 @@ export async function respond_with_error({
 }) {
 	// reroute to the fallback page to prevent an infinite chain of requests.
 	if (event.request.headers.get('x-sveltekit-error')) {
-		return static_error_page(options, status, /** @type {Error} */ (error).message);
+		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+		return static_error_page(options, status, transformed.message);
 	}
 
 	/** @type {import('./types.js').Fetched[]} */
 	const fetched = [];
-
 	try {
 		const branch = [];
 		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
@@ -46,6 +47,8 @@ export async function respond_with_error({
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
 		const data_serializer = server_data_serializer(event, event_state, options);
+		// Do this here first in case the awaits below before rendering themselves error
+		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
 
 		if (ssr) {
 			state.error = true;
@@ -89,8 +92,6 @@ export async function respond_with_error({
 			);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
-
 		return await render_response({
 			options,
 			manifest,

package/src/runtime/server/{remote.js → remote-functions.js}

@@ -7,12 +7,13 @@ import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server
 import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
 import { create_remote_key, parse_remote_arg, split_remote_key, stringify } from '../shared.js';
-import { handle_error_and_jsonify } from './utils.js';
+import { handle_error_and_jsonify } from './errors.js';
 import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';
 import { record_span } from '../telemetry/record_span.js';
 import { deserialize_binary_form } from '../form-utils.js';
+import { with_version_header } from './utils.js';
 
 /**
  * How long (in milliseconds) to wait after the last message was sent before
@@ -28,11 +29,12 @@ export async function handle_remote_call(event, state, options, manifest, id) {
 		attributes: {
 			'sveltekit.remote.call.id': id
 		},
-		fn: (current) => {
+		fn: async (current) => {
 			const traced_event = merge_tracing(event, current);
-			return with_request_store({ event: traced_event, state }, () =>
+			const response = await with_request_store({ event: traced_event, state }, () =>
 				handle_remote_call_internal(traced_event, state, options, manifest, id)
 			);
+			return with_version_header(response);
 		}
 	});
 }
@@ -240,7 +242,11 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					);
 				}
 
-				const { data: input, meta, form_data } = await deserialize_binary_form(event.request);
+				const {
+					data: input,
+					meta,
+					form_data
+				} = await deserialize_binary_form(event.request, internals.id);
 				state.remote.requested = create_requested_map(meta.remote_refreshes);
 
 				// If this is a keyed form instance (created via form.for(key)), add the key to the form data (unless already set)
@@ -368,43 +374,64 @@ export async function collect_remote_data(data, event, state, options) {
 	/** @type {Promise<any>[]} */
 	const promises = [];
 
+	// Keys the explicit pass has serialized. Invoking a query's `fn` there can, as a
+	// side effect, register the same query in `state.remote.implicit` (via
+	// `get_response`), so we skip those keys in the implicit pass below to avoid
+	// processing them twice.
+	/** @type {Set<string>} */
+	const processed = new Set();
+
 	if (state.remote.explicit) {
-		for (const [remote_key, { internals, fn }] of state.remote.explicit) {
-			// there were explicit refreshes/reconnects (via `refresh()`/`set()`/`reconnect()`),
-			// so the client should apply these single-flight updates instead of calling `invalidateAll()`
-			data.r = true;
+		const { explicit } = state.remote;
 
-			const type = /** @type {'p' | 'q' | 'l'} */ (
-				internals.type === 'query_live' ? 'l' : internals.type[0]
-			);
+		/** @type {Promise<void>[]} */
+		const inflight = [];
+
+		const drain = () => {
+			for (const [remote_key, { internals, fn }] of explicit) {
+				explicit.delete(remote_key);
+				if (processed.has(remote_key)) continue;
+				processed.add(remote_key);
+
+				// there were explicit refreshes/reconnects (via `refresh()`/`set()`/`reconnect()`),
+				// so the client should apply these single-flight updates instead of calling `invalidateAll()`
+				data.r = true;
 
-			// `fn` is deferred until now so the query runs after any state mutations
-			// in the command/form body. If the query was re-awaited in the meantime,
-			// `fn` returns the existing (fresh) cache entry rather than re-running.
-			// Kick off the query immediately and collect the promise so that multiple
-			// explicit refreshes run concurrently rather than serially.
-			const promise = fn();
-
-			promises.push(
-				promise.then(
-					(v) => {
-						((data[type] ??= {})[remote_key] ??= {}).v = v;
-					},
-					async (e) => {
-						if (e instanceof Redirect) {
-							// already handled elsewhere
-							return;
+				const type = /** @type {'p' | 'q' | 'l'} */ (
+					internals.type === 'query_live' ? 'l' : internals.type[0]
+				);
+
+				// `fn` is deferred until now so the query runs after any state mutations
+				// in the command/form body. If the query was re-awaited in the meantime,
+				// `fn` returns the existing (fresh) cache entry rather than re-running.
+				inflight.push(
+					fn().then(
+						(v) => {
+							// a fresh value replaces the node entirely, so a re-run can't leave
+							// a stale error from a previous run alongside the new value
+							(data[type] ??= {})[remote_key] = { v };
+							drain();
+						},
+						async (e) => {
+							if (!(e instanceof Redirect)) {
+								// (a Redirect is already handled elsewhere)
+								(data[type] ??= {})[remote_key] = { e: await convert_error(e) };
+							}
+							drain();
 						}
+					)
+				);
+			}
+		};
 
-						((data[type] ??= {})[remote_key] ??= {}).e = await convert_error(e);
-					}
-				)
-			);
+		drain();
+
+		// `inflight` grows as settles drain newly-refreshed queries
+		for (const promise of inflight) {
+			await promise;
 		}
 	}
 
-	await Promise.all(promises);
-
 	if (state.remote.implicit) {
 		for (const [internals, record] of state.remote.implicit) {
 			// Private (non-exported) remote functions have no `id` and must never be
@@ -416,6 +443,10 @@ export async function collect_remote_data(data, event, state, options) {
 				// form outputs are registered under the client-side action id directly
 				const remote_key = internals.type === 'form' ? key : create_remote_key(internals.id, key);
 
+				// already serialized by the explicit pass (which always awaits and wins),
+				// so don't reprocess it here with the implicit "still loading" heuristic
+				if (processed.has(remote_key)) continue;
+
 				const type = /** @type {'p' | 'q' | 'l' | 'f'} */ (
 					internals.type === 'query_live' ? 'l' : internals.type[0]
 				);
@@ -540,9 +571,9 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 	}
 
 	try {
-		const fn = /** @type {RemoteFormInternals} */ (/** @type {any} */ (form).__).fn;
+		const __ = /** @type {RemoteFormInternals} */ (/** @type {any} */ (form).__);
 
-		const { data, meta, form_data } = await deserialize_binary_form(event.request);
+		const { data, meta, form_data } = await deserialize_binary_form(event.request, __.id);
 
 		if (action_id && !('id' in data)) {
 			data.id = JSON.parse(decodeURIComponent(action_id));
@@ -550,7 +581,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 
 		await with_request_store(
 			{ event, state: { ...state, is_in_remote_form_or_command: true } },
-			() => fn(data, meta, form_data)
+			() => __.fn(data, meta, form_data)
 		);
 
 		// We don't want the data to appear on `let { form } = $props()`, which is why we're not returning it.

package/src/runtime/server/respond.js

@@ -9,13 +9,14 @@ import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
 import { get_self_origin, is_csrf_forbidden, is_remote_forbidden } from './csrf.js';
+import { has_prerendered_path, method_not_allowed, redirect_response } from './utils.js';
+import { handle_fatal_error } from './errors.js';
 import {
-	handle_fatal_error,
-	has_prerendered_path,
-	method_not_allowed,
-	redirect_response
-} from './utils.js';
-import { decode_pathname, disable_search, normalize_path } from '../../utils/url.js';
+	decode_pathname,
+	disable_search,
+	normalize_path,
+	relative_pathname
+} from '../../utils/url.js';
 import { find_route } from '../../utils/routing.js';
 import { redirect_json_response, render_data } from './data/index.js';
 import { add_cookies_to_headers, get_cookies } from './cookie.js';
@@ -36,7 +37,7 @@ import {
 	strip_resolution_suffix
 } from '../pathname.js';
 import { server_data_serializer } from './page/data_serializer.js';
-import { get_remote_id, handle_remote_call } from './remote.js';
+import { get_remote_id, handle_remote_call } from './remote-functions.js';
 import { record_span } from '../telemetry/record_span.js';
 import { otel } from '../telemetry/otel.js';
 
@@ -49,6 +50,28 @@ const default_filter = () => false;
 /** @type {import('types').RequiredResolveOptions['preload']} */
 const default_preload = ({ type }) => type === 'js' || type === 'css';
 
+// `Sec-Fetch-Dest` values for subresource requests that can never render an HTML error page
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Sec-Fetch-Dest
+const non_html_fetch_destinations = new Set([
+	'audio',
+	'audioworklet',
+	'font',
+	'image',
+	'json',
+	'manifest',
+	'paintworklet',
+	'report',
+	'script',
+	'serviceworker',
+	'sharedworker',
+	'style',
+	'track',
+	'video',
+	'webidentity',
+	'worker',
+	'xslt'
+]);
+
 const page_methods = new Set(['GET', 'HEAD', 'POST']);
 
 const allowed_page_methods = new Set(['GET', 'HEAD', 'OPTIONS']);
@@ -113,6 +136,8 @@ export async function internal_respond(request, options, manifest, state) {
 	/** @type {boolean[] | undefined} */
 	let invalidated_data_nodes;
 
+	let skip_route_resolution = false;
+
 	if (is_route_resolution_request) {
 		/**
 		 * If the request is for a route resolution, first modify the URL, then continue as normal
@@ -130,8 +155,15 @@ export async function internal_respond(request, options, manifest, state) {
 			.map((node) => node === '1');
 		url.searchParams.delete(INVALIDATED_PARAM);
 	} else if (remote_id) {
-		url.pathname = request.headers.get('x-sveltekit-pathname') ?? base;
-		url.search = request.headers.get('x-sveltekit-search') ?? '';
+		// query clients don't send these headers, leaving `event.url` as the endpoint URL
+		const pathname = request.headers.get('x-sveltekit-pathname');
+
+		if (pathname === null) {
+			skip_route_resolution = true;
+		} else {
+			url.pathname = pathname;
+			url.search = request.headers.get('x-sveltekit-search') ?? '';
+		}
 	}
 
 	/** @type {Record<string, string>} */
@@ -162,6 +194,7 @@ export async function internal_respond(request, options, manifest, state) {
 		is_in_remote_function: false,
 		is_in_remote_form_or_command: false,
 		is_in_remote_query: false,
+		is_in_remote_prerender: false,
 		is_in_render: false,
 		is_in_universal_load: false
 	};
@@ -335,7 +368,7 @@ export async function internal_respond(request, options, manifest, state) {
 		return text('Not found', { status: 404, headers });
 	}
 
-	if (!state.prerendering?.fallback) {
+	if (!state.prerendering?.fallback && !skip_route_resolution) {
 		try {
 			const matchers = await manifest._.matchers();
 			const result = find_route(resolved_path, manifest._.routes, matchers);
@@ -382,10 +415,9 @@ export async function internal_respond(request, options, manifest, state) {
 						status: 308,
 						headers: {
 							'x-sveltekit-normalize': '1',
+							// relative so (possibly invisible) path prefixes are preserved
 							location:
-								// ensure paths starting with '//' are not treated as protocol-relative
-								(normalized.startsWith('//') ? url.origin + normalized : normalized) +
-								(url.search === '?' ? '' : url.search)
+								relative_pathname(url.pathname, normalized) + (url.search === '?' ? '' : url.search)
 						}
 					});
 				}
@@ -635,13 +667,12 @@ export async function internal_respond(request, options, manifest, state) {
 					) {
 						endpoint = await route.endpoint();
 
-						// Prefer rendering the page if the endpoint can't handle this GET or HEAD request
-						if (route.page && (method === 'GET' || method === 'HEAD')) {
-							const endpoint_can_handle = !!(
-								endpoint.GET ||
-								endpoint.fallback ||
-								(method === 'HEAD' && endpoint.HEAD)
-							);
+						// Prefer rendering the page if the endpoint can't handle this GET, HEAD, or POST request
+						if (route.page && (method === 'GET' || method === 'HEAD' || method === 'POST')) {
+							const endpoint_can_handle =
+								method === 'POST'
+									? !!(endpoint.POST || endpoint.fallback)
+									: !!(endpoint.GET || endpoint.fallback || (method === 'HEAD' && endpoint.HEAD));
 							if (!endpoint_can_handle) {
 								endpoint = undefined;
 							}
@@ -737,6 +768,13 @@ export async function internal_respond(request, options, manifest, state) {
 			// if this request came direct from the user, rather than
 			// via our own `fetch`, render a 404 page
 			if (state.depth === 0) {
+				if (non_html_fetch_destinations.has(event.request.headers.get('sec-fetch-dest') ?? '')) {
+					return text('Not Found', {
+						status: 404,
+						headers: { vary: 'Sec-Fetch-Dest' }
+					});
+				}
+
 				return await respond_with_error({
 					event,
 					event_state,

package/src/runtime/server/sourcemaps.js

@@ -0,0 +1,183 @@
+/* eslint-disable n/prefer-global/process */
+
+// using `getBuiltinModule` rather than `import` makes this safe to run in non-Node-compatible environments
+const fs = globalThis.process?.getBuiltinModule?.('node:fs');
+const url = globalThis.process?.getBuiltinModule?.('node:url');
+const path = globalThis.process?.getBuiltinModule?.('node:path');
+const module = globalThis.process?.getBuiltinModule?.('node:module');
+
+const cwd = globalThis.process?.cwd?.();
+
+/** @type {(file: string) => string} */
+const relative = cwd ? (file) => path.relative(cwd, file) : (file) => file;
+
+/**
+ * Applies sourcemaps, makes paths relative to the cwd, and truncates
+ * non-user code from the bottom of the stack
+ * @param {Error} error
+ * @returns void
+ */
+export let fix_stack_trace = (error) => {
+	if (!error.stack || !fs) return;
+
+	let end = 0;
+
+	error.stack = error.stack
+		.split('\n')
+		.map((line, i) => {
+			const match = line.match(/^ {4}at.+(file:\/\/\/.*):(\d+):(\d+)(\)?)$/);
+
+			if (!match) {
+				if (!line.includes('node:internal/')) {
+					end = i + 1;
+				}
+
+				return line;
+			}
+
+			const file = url.fileURLToPath(match[1]);
+			const traced = trace(file, Number(match[2]) - 1, Number(match[3]) - 1);
+
+			// truncate non-user code from the bottom of the stack (but leave it in otherwise)
+			if (!/[\\/]node_modules[\\/]/.test(traced?.file ?? file)) {
+				end = i + 1;
+			}
+
+			if (traced?.line) {
+				const location = `${match[1]}:${match[2]}:${match[3]}`;
+				const original = `${relative(traced.file)}:${traced.line}:${traced.column}`;
+
+				return line.replace(location, original);
+			}
+
+			if (traced) {
+				return `${line.replace(match[1], relative(file))} [${traced.file}]`;
+			}
+
+			return line;
+		})
+		.slice(0, end)
+		.join('\n');
+};
+
+/**
+ * Override the implementation of fix_stack_trace (for using during dev)
+ * @param {(error: Error) => void} fn
+ */
+export function set_fix_stack_trace(fn) {
+	fix_stack_trace = fn;
+}
+
+/** @type {Map<string, { map: import('node:module').SourceMap; directory: string } | null>} */
+const source_maps = new Map();
+
+/** @type {Map<string, Array<string | undefined>>} */
+const source_regions = new Map();
+
+/** @param {string} file */
+function get_source_map(file) {
+	if (source_maps.has(file)) {
+		return source_maps.get(file);
+	}
+
+	try {
+		let source;
+		let directory = path.dirname(file);
+
+		const code = fs.readFileSync(file, 'utf8');
+		const matches = Array.from(code.matchAll(/\/\/[#@]\s*sourceMappingURL=(\S+)/g));
+		const url = matches.at(-1)?.[1];
+
+		if (url?.startsWith('data:')) {
+			const comma = url.indexOf(',');
+			const metadata = url.slice(5, comma);
+			const data = url.slice(comma + 1);
+			source = metadata.endsWith(';base64')
+				? Buffer.from(data, 'base64').toString()
+				: decodeURIComponent(data);
+		} else {
+			const map_file = url
+				? path.resolve(path.dirname(file), decodeURIComponent(url))
+				: `${file}.map`;
+			if (fs.existsSync(map_file)) {
+				directory = path.dirname(map_file);
+				source = fs.readFileSync(map_file, 'utf8');
+			}
+		}
+
+		if (source) {
+			const source_map = { map: new module.SourceMap(JSON.parse(source)), directory };
+			source_maps.set(file, source_map);
+
+			return source_map;
+		}
+	} catch {
+		// failure could be for any reason and this is best-effort, ignore
+	}
+
+	source_maps.set(file, null);
+	return null;
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {number} line
+ * @param {number} column
+ * @returns {null | { file: string, line?: number, column?: number }}
+ */
+function trace(file, line, column) {
+	const source_map = get_source_map(file);
+	if (!source_map) return null;
+
+	const entry = source_map.map.findEntry(line, column);
+
+	if (
+		entry &&
+		'originalSource' in entry &&
+		entry.originalSource &&
+		typeof entry.originalLine === 'number' &&
+		typeof entry.originalColumn === 'number'
+	) {
+		const source = entry.originalSource.startsWith('file:')
+			? url.fileURLToPath(entry.originalSource)
+			: path.resolve(source_map.directory, entry.originalSource);
+
+		const traced = {
+			file: source,
+			line: entry.originalLine + 1,
+			column: entry.originalColumn + 1
+		};
+
+		// keep going, in case we are running code that was bundled a second time by an adapter
+		return trace(traced.file, traced.line - 1, traced.column - 1) ?? traced;
+	}
+
+	let regions = source_regions.get(file);
+	if (!regions) {
+		/** @type {string | undefined} */
+		let source;
+		regions = fs
+			.readFileSync(file, 'utf8')
+			.split('\n')
+			.map((line) => {
+				// Vite will merge multiple files into one but add region markers
+				// with the original file names, which we try to extract here.
+				const start = line.match(/^\/\/#region (.+)$/);
+				if (start) source = start[1];
+				if (line === '//#endregion') source = undefined;
+				return source;
+			});
+		source_regions.set(file, regions);
+	}
+
+	const source = regions[line];
+
+	if (source) {
+		return {
+			file: source
+		};
+	}
+
+	return null;
+}