@sveltejs/kit 1.0.0-next.539 → 1.0.0-next.540

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.539",
+  "version": "1.0.0-next.540",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/scripts/special-types/$env+dynamic+private.md

@@ -1,6 +1,6 @@
 This module provides access to runtime environment variables, as defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/master/packages/adapter-node) (or running [`vite preview`](https://kit.svelte.dev/docs/cli)), this is equivalent to `process.env`. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env).
 
-This module cannot be imported into public-facing code.
+This module cannot be imported into client-side code.
 
 ```ts
 import { env } from '$env/dynamic/private';

package/scripts/special-types/$env+static+private.md

@@ -1,4 +1,4 @@
-Environment variables [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env`. Like [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), this module cannot be imported into public-facing code. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env).
+Environment variables [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env`. Like [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), this module cannot be imported into client-side code. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env).
 
 _Unlike_ [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), the values exported from this module are statically injected into your bundle at build time, enabling optimisations like dead code elimination.
 

package/scripts/special-types/$lib.md

@@ -2,4 +2,4 @@ This is a simple alias to `src/lib`, or whatever directory is specified as [`con
 
 #### `$lib/server`
 
-A subdirectory of `$lib`. SvelteKit will prevent you from importing any modules in `$lib/server` into public-facing code. See [server-only modules](/docs/server-only-modules).
+A subdirectory of `$lib`. SvelteKit will prevent you from importing any modules in `$lib/server` into client-side code. See [server-only modules](/docs/server-only-modules).

package/src/exports/node/index.js

@@ -122,6 +122,15 @@ export async function setResponse(res, response) {
 		return;
 	}
 
+	if (response.body.locked) {
+		res.write(
+			'Fatal error: Response body is locked. ' +
+				`This can happen when the response was already read (for example through 'response.json()' or 'response.text()').`
+		);
+		res.end();
+		return;
+	}
+
 	const reader = response.body.getReader();
 
 	if (res.destroyed) {

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

@@ -11,9 +11,7 @@ import { load_error_page, load_template } from '../../../core/config/index.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import * as sync from '../../../core/sync/sync.js';
 import { get_mime_lookup, runtime_base, runtime_prefix } from '../../../core/utils.js';
-import { prevent_illegal_vite_imports } from '../graph_analysis/index.js';
 import { compact } from '../../../utils/array.js';
-import { normalizePath } from 'vite';
 
 // Vite doesn't expose this so we just copy the list for now
 // https://github.com/vitejs/vite/blob/3edd1af56e980aef56641a5a51cf2932bb580d41/packages/vite/src/node/plugins/css.ts#L96
@@ -43,8 +41,6 @@ export async function dev(vite, vite_config, svelte_config) {
 	/** @type {import('types').SSRManifest} */
 	let manifest;
 
-	const extensions = [...svelte_config.extensions, ...svelte_config.kit.moduleExtensions];
-
 	/** @param {string} id */
 	async function resolve(id) {
 		const url = id.startsWith('..') ? `/@fs${path.posix.resolve(id)}` : `/${id}`;
@@ -94,12 +90,6 @@ export async function dev(vite, vite_config, svelte_config) {
 								module_nodes.push(module_node);
 								result.file = url.endsWith('.svelte') ? url : url + '?import'; // TODO what is this for?
 
-								prevent_illegal_vite_imports(
-									module_node,
-									normalizePath(svelte_config.kit.files.lib),
-									extensions
-								);
-
 								return module.default;
 							};
 						}
@@ -110,12 +100,6 @@ export async function dev(vite, vite_config, svelte_config) {
 							module_nodes.push(module_node);
 
 							result.shared = module;
-
-							prevent_illegal_vite_imports(
-								module_node,
-								normalizePath(svelte_config.kit.files.lib),
-								extensions
-							);
 						}
 
 						if (node.server) {

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

@@ -1,277 +1,107 @@
 import path from 'path';
-import { normalizePath } from 'vite';
-import { remove_query_from_id, get_module_types } from './utils.js';
+import { posixify } from '../../../utils/filesystem.js';
 
-/** @typedef {import('./types').ImportGraph} ImportGraph */
-
-const CWD_ID = normalizePath(process.cwd());
-const NODE_MODULES_ID = normalizePath(path.resolve(process.cwd(), 'node_modules'));
-const ILLEGAL_IMPORTS = new Set([
-	'/@id/__x00__$env/dynamic/private', //dev
-	'\0$env/dynamic/private', // prod
-	'/@id/__x00__$env/static/private', // dev
-	'\0$env/static/private' // prod
-]);
+const ILLEGAL_IMPORTS = new Set(['\0$env/dynamic/private', '\0$env/static/private']);
 const ILLEGAL_MODULE_NAME_PATTERN = /.*\.server\..+/;
 
-export class IllegalModuleGuard {
-	/** @type {string} */
-	#lib_dir;
-
-	/** @type {string} */
-	#server_dir;
-
-	/** @type {Array<ImportGraph>} */
-	#chain = [];
-
-	/**
-	 * @param {string} lib_dir
-	 */
-	constructor(lib_dir) {
-		this.#lib_dir = normalizePath(lib_dir);
-		this.#server_dir = normalizePath(path.resolve(lib_dir, 'server'));
-	}
+/**
+ * Checks if given id imports a module that is not allowed to be imported into client-side code.
+ * @param {string} id
+ * @param {{
+ *   cwd: string;
+ *   node_modules: string;
+ *   server: string;
+ * }} dirs
+ */
+export function is_illegal(id, dirs) {
+	if (ILLEGAL_IMPORTS.has(id)) return true;
+	if (!id.startsWith(dirs.cwd) || id.startsWith(dirs.node_modules)) return false;
+	return ILLEGAL_MODULE_NAME_PATTERN.test(path.basename(id)) || id.startsWith(dirs.server);
+}
 
-	/**
-	 * Assert that a node imports no illegal modules.
-	 * @param {ImportGraph} node
-	 * @returns {void}
-	 */
-	assert_legal(node) {
-		this.#chain.push(node);
-		for (const child of node.children) {
-			if (this.#is_illegal(child.id)) {
-				this.#chain.push(child);
-				const error = this.#format_illegal_import_chain(this.#chain);
-				this.#chain = []; // Reset the chain in case we want to reuse this guard
-				throw new Error(error);
-			}
-			this.assert_legal(child);
-		}
-		this.#chain.pop();
-	}
+/**
+ * Creates a guard that checks that no id imports a module that is not allowed to be imported into client-side code.
+ * @param {import('rollup').PluginContext} context
+ * @param {{ cwd: string, lib: string }} paths
+ */
+export function module_guard(context, { cwd, lib }) {
+	/** @type {Set<string>} */
+	const seen = new Set();
 
-	/**
-	 * `true` if the provided ID represents a server-only module, else `false`.
-	 * @param {string} module_id
-	 * @returns {boolean}
-	 */
-	#is_illegal(module_id) {
-		if (this.#is_kit_illegal(module_id) || this.#is_user_illegal(module_id)) return true;
-		return false;
-	}
+	const dirs = {
+		// ids will be posixified, so we need to posixify these, too
+		cwd: posixify(cwd),
+		node_modules: posixify(path.join(cwd, 'node_modules')),
+		server: posixify(path.join(lib, 'server'))
+	};
 
 	/**
-	 * `true` if the provided ID represents a Kit-defined server-only module, else `false`.
-	 * @param {string} module_id
-	 * @returns {boolean}
+	 * @param {string} id
+	 * @param {Array<{ id: string, dynamic: boolean }>} chain
 	 */
-	#is_kit_illegal(module_id) {
-		return ILLEGAL_IMPORTS.has(module_id);
-	}
+	function follow(id, chain) {
+		if (seen.has(id)) return;
+		seen.add(id);
 
-	/**
-	 * `true` if the provided ID represents a user-defined server-only module, else `false`.
-	 * @param {string} module_id
-	 * @returns {boolean}
-	 */
-	#is_user_illegal(module_id) {
-		if (module_id.startsWith(this.#server_dir)) return true;
+		if (is_illegal(id, dirs)) {
+			chain.shift(); // discard the entry point
+			id = normalize_id(id, lib, cwd);
 
-		// files outside the project root are ignored
-		if (!module_id.startsWith(CWD_ID)) return false;
+			const pyramid =
+				chain.map(({ id, dynamic }, i) => {
+					id = normalize_id(id, lib, cwd);
 
-		// so are files inside node_modules
-		if (module_id.startsWith(NODE_MODULES_ID)) return false;
+					return `${repeat(' ', i * 2)}- ${id} ${dynamic ? 'dynamically imports' : 'imports'}\n`;
+				}) + `${repeat(' ', chain.length)}- ${id}`;
 
-		return ILLEGAL_MODULE_NAME_PATTERN.test(path.basename(module_id));
-	}
+			const message = `Cannot import ${id} into client-side code:\n${pyramid}`;
 
-	/**
-	 * @param {string} str
-	 * @param {number} times
-	 */
-	#repeat(str, times) {
-		return new Array(times + 1).join(str);
-	}
+			throw new Error(message);
+		}
 
-	/**
-	 * Create a formatted error for an illegal import.
-	 * @param {Array<ImportGraph>} stack
-	 */
-	#format_illegal_import_chain(stack) {
-		const dev_virtual_prefix = '/@id/__x00__';
-		const prod_virtual_prefix = '\0';
+		const module = context.getModuleInfo(id);
 
-		stack = stack.map((graph) => {
-			if (graph.id.startsWith(dev_virtual_prefix)) {
-				return { ...graph, id: graph.id.replace(dev_virtual_prefix, '') };
-			}
-			if (graph.id.startsWith(prod_virtual_prefix)) {
-				return { ...graph, id: graph.id.replace(prod_virtual_prefix, '') };
-			}
-			if (graph.id.startsWith(this.#lib_dir)) {
-				return { ...graph, id: graph.id.replace(this.#lib_dir, '$lib') };
+		if (module) {
+			for (const child of module.importedIds) {
+				follow(child, [...chain, { id, dynamic: false }]);
 			}
 
-			return { ...graph, id: path.relative(process.cwd(), graph.id) };
-		});
-
-		const pyramid = stack
-			.map(
-				(file, i) =>
-					`${this.#repeat(' ', i * 2)}- ${file.id} ${
-						file.dynamic ? '(imported by parent dynamically)' : ''
-					}`
-			)
-			.join('\n');
-
-		return `Cannot import ${stack.at(-1)?.id} into public-facing code:\n${pyramid}`;
-	}
-}
-
-/** @implements {ImportGraph} */
-export class RollupImportGraph {
-	/** @type {(id: string) => import('rollup').ModuleInfo | null} */
-	#node_getter;
-
-	/** @type {import('rollup').ModuleInfo} */
-	#module_info;
-
-	/** @type {string} */
-	id;
-
-	/** @type {boolean} */
-	dynamic;
-
-	/** @type {Set<string>} */
-	#seen;
-
-	/**
-	 * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
-	 * @param {import('rollup').ModuleInfo} node
-	 */
-	constructor(node_getter, node) {
-		this.#node_getter = node_getter;
-		this.#module_info = node;
-		this.id = remove_query_from_id(normalizePath(node.id));
-		this.dynamic = false;
-		this.#seen = new Set();
-	}
-
-	/**
-	 * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
-	 * @param {import('rollup').ModuleInfo} node
-	 * @param {boolean} dynamic
-	 * @param {Set<string>} seen;
-	 * @returns {RollupImportGraph}
-	 */
-	static #new_internal(node_getter, node, dynamic, seen) {
-		const instance = new RollupImportGraph(node_getter, node);
-		instance.dynamic = dynamic;
-		instance.#seen = seen;
-		return instance;
-	}
-
-	get children() {
-		return this.#children();
+			for (const child of module.dynamicallyImportedIds) {
+				follow(child, [...chain, { id, dynamic: true }]);
+			}
+		}
 	}
 
-	*#children() {
-		if (this.#seen.has(this.id)) return;
-		this.#seen.add(this.id);
-		for (const id of this.#module_info.importedIds) {
-			const child = this.#node_getter(id);
-			if (child === null) return;
-			yield RollupImportGraph.#new_internal(this.#node_getter, child, false, this.#seen);
-		}
-		for (const id of this.#module_info.dynamicallyImportedIds) {
-			const child = this.#node_getter(id);
-			if (child === null) return;
-			yield RollupImportGraph.#new_internal(this.#node_getter, child, true, this.#seen);
+	return {
+		/** @param {string} id should be posixified */
+		check: (id) => {
+			follow(id, []);
 		}
-	}
+	};
 }
 
-/** @implements {ImportGraph} */
-export class ViteImportGraph {
-	/** @type {Set<string>} */
-	#module_types;
-
-	/** @type {import('vite').ModuleNode} */
-	#module_info;
-
-	/** @type {string} */
-	id;
-
-	/** @type {Set<string>} */
-	#seen;
-
-	/**
-	 * @param {Set<string>} module_types Module types to analyze, eg '.js', '.ts', etc.
-	 * @param {import('vite').ModuleNode} node
-	 */
-	constructor(module_types, node) {
-		this.#module_types = module_types;
-		this.#module_info = node;
-		this.id = remove_query_from_id(normalizePath(node.id ?? ''));
-		this.#seen = new Set();
-	}
-
-	/**
-	 * @param {Set<string>} module_types Module types to analyze, eg '.js', '.ts', etc.
-	 * @param {import('vite').ModuleNode} node
-	 * @param {Set<string>} seen
-	 * @returns {ViteImportGraph}
-	 */
-	static #new_internal(module_types, node, seen) {
-		const instance = new ViteImportGraph(module_types, node);
-		instance.#seen = seen;
-		return instance;
-	}
-
-	get dynamic() {
-		return false;
+/**
+ * Removes cwd/lib path from the start of the id
+ * @param {string} id
+ * @param {string} lib
+ * @param {string} cwd
+ */
+export function normalize_id(id, lib, cwd) {
+	if (id.startsWith(lib)) {
+		id = id.replace(lib, '$lib');
 	}
 
-	get children() {
-		return this.#children();
+	if (id.startsWith(cwd)) {
+		id = path.relative(cwd, id);
 	}
 
-	*#children() {
-		if (this.#seen.has(this.id)) return;
-		this.#seen.add(this.id);
-		for (const child of this.#module_info.importedModules) {
-			if (!this.#module_types.has(path.extname(this.id))) {
-				continue;
-			}
-			yield ViteImportGraph.#new_internal(this.#module_types, child, this.#seen);
-		}
-	}
-}
-
-/**
- * Throw an error if a private module is imported from a client-side node.
- * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
- * @param {import('rollup').ModuleInfo} node
- * @param {string} lib_dir
- * @returns {void}
- */
-export function prevent_illegal_rollup_imports(node_getter, node, lib_dir) {
-	const graph = new RollupImportGraph(node_getter, node);
-	const guard = new IllegalModuleGuard(lib_dir);
-	guard.assert_legal(graph);
+	return posixify(id);
 }
 
 /**
- * Throw an error if a private module is imported from a client-side node.
- * @param {import('vite').ModuleNode} node
- * @param {string} lib_dir
- * @param {Iterable<string>} module_types File extensions to analyze in addition to the defaults: `.ts`, `.js`, etc.
- * @returns {void}
+ * @param {string} str
+ * @param {number} times
  */
-export function prevent_illegal_vite_imports(node, lib_dir, module_types) {
-	const graph = new ViteImportGraph(get_module_types(module_types), node);
-	const guard = new IllegalModuleGuard(lib_dir);
-	guard.assert_legal(graph);
+function repeat(str, times) {
+	return new Array(times + 1).join(str);
 }

package/src/exports/vite/graph_analysis/utils.js

@@ -4,27 +4,3 @@ const query_pattern = /\?.*$/s;
 export function remove_query_from_id(path) {
 	return path.replace(query_pattern, '');
 }
-
-/**
- * Vite does some weird things with import trees in dev
- * for example, a Tailwind app.css will appear to import
- * every file in the project. This isn't a problem for
- * Rollup during build.
- * @param {Iterable<string>} config_module_types
- */
-export const get_module_types = (config_module_types) => {
-	return new Set([
-		'',
-		'.ts',
-		'.js',
-		'.svelte',
-		'.mts',
-		'.mjs',
-		'.cts',
-		'.cjs',
-		'.svelte.md',
-		'.svx',
-		'.md',
-		...config_module_types
-	]);
-};

package/src/exports/vite/index.js

@@ -15,9 +15,9 @@ import { runtime_directory, logger } from '../../core/utils.js';
 import { find_deps, get_default_build_config } from './build/utils.js';
 import { preview } from './preview/index.js';
 import { get_config_aliases, get_app_aliases, get_env } from './utils.js';
-import { prevent_illegal_rollup_imports } from './graph_analysis/index.js';
 import { fileURLToPath } from 'node:url';
 import { create_static_module, create_dynamic_module } from '../../core/env.js';
+import { is_illegal, module_guard, normalize_id } from './graph_analysis/index.js';
 
 const cwd = process.cwd();
 
@@ -292,7 +292,22 @@ function kit() {
 			if (id.startsWith('$env/')) return `\0${id}`;
 		},
 
-		async load(id) {
+		async load(id, options) {
+			if (options?.ssr === false) {
+				const normalized_cwd = vite.normalizePath(cwd);
+				const normalized_lib = vite.normalizePath(svelte_config.kit.files.lib);
+				if (
+					is_illegal(id, {
+						cwd: normalized_cwd,
+						node_modules: vite.normalizePath(path.join(cwd, 'node_modules')),
+						server: vite.normalizePath(path.join(normalized_lib, 'server'))
+					})
+				) {
+					const relative = normalize_id(id, normalized_lib, normalized_cwd);
+					throw new Error(`Cannot import ${relative} into client-side code`);
+				}
+			}
+
 			switch (id) {
 				case '\0$env/static/private':
 					return create_static_module('$env/static/private', env.private);
@@ -350,20 +365,17 @@ function kit() {
 					return;
 				}
 
+				const guard = module_guard(this, {
+					cwd: vite.normalizePath(process.cwd()),
+					lib: vite.normalizePath(svelte_config.kit.files.lib)
+				});
+
 				manifest_data.nodes.forEach((_node, i) => {
 					const id = vite.normalizePath(
 						path.resolve(svelte_config.kit.outDir, `generated/nodes/${i}.js`)
 					);
 
-					const module_node = this.getModuleInfo(id);
-
-					if (module_node) {
-						prevent_illegal_rollup_imports(
-							this.getModuleInfo.bind(this),
-							module_node,
-							vite.normalizePath(svelte_config.kit.files.lib)
-						);
-					}
+					guard.check(id);
 				});
 
 				const verbose = vite_config.logLevel === 'info';

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

@@ -100,27 +100,24 @@ export async function preview(vite, vite_config, svelte_config) {
 
 				const { pathname } = new URL(/** @type {string} */ (req.url), 'http://dummy');
 
-				// only treat this as a page if it doesn't include an extension
-				if (pathname === '/' || /\/[^./]+\/?$/.test(pathname)) {
-					const file = join(
-						svelte_config.kit.outDir,
-						'output/prerendered/pages' +
-							pathname +
-							(pathname.endsWith('/') ? 'index.html' : '.html')
-					);
-
-					if (fs.existsSync(file)) {
-						res.writeHead(200, {
-							'content-type': 'text/html',
-							etag
-						});
-
-						fs.createReadStream(file).pipe(res);
-						return;
-					}
+				let filename = join(svelte_config.kit.outDir, 'output/prerendered/pages' + pathname);
+				let prerendered = is_file(filename);
+
+				if (!prerendered) {
+					filename += filename.endsWith('/') ? 'index.html' : '.html';
+					prerendered = is_file(filename);
 				}
 
-				next();
+				if (prerendered) {
+					res.writeHead(200, {
+						'content-type': 'text/html',
+						etag
+					});
+
+					fs.createReadStream(filename).pipe(res);
+				} else {
+					next();
+				}
 			})
 		);
 
@@ -187,3 +184,8 @@ function scoped(scope, handler) {
 		}
 	};
 }
+
+/** @param {string} path */
+function is_file(path) {
+	return fs.existsSync(path) && !fs.statSync(path).isDirectory();
+}

package/src/runtime/client/client.js

@@ -373,6 +373,8 @@ export function create_client({ target, base, trailing_slash }) {
 
 	/** @param {import('./types').NavigationFinished} result */
 	function initialize(result) {
+		if (__SVELTEKIT_DEV__ && document.querySelector('vite-error-overlay')) return;
+
 		current = result.state;
 
 		const style = document.querySelector('style[data-sveltekit]');
@@ -485,6 +487,12 @@ export function create_client({ target, base, trailing_slash }) {
 			};
 
 			// TODO remove this for 1.0
+			Object.defineProperty(result.props.page, 'routeId', {
+				get() {
+					throw new Error('$page.routeId has been replaced by $page.route.id');
+				},
+				enumerable: false
+			});
 			/**
 			 * @param {string} property
 			 * @param {string} replacement
@@ -599,8 +607,8 @@ export function create_client({ target, base, trailing_slash }) {
 
 					// prerendered pages may be served from any origin, so `initial_fetch` urls shouldn't be resolved
 					return started
-						? subsequent_fetch(resolved, init)
-						: initial_fetch(requested, resolved, init);
+						? subsequent_fetch(requested, resolved, init)
+						: initial_fetch(requested, init);
 				},
 				setHeaders: () => {}, // noop
 				depends,
@@ -1353,9 +1361,9 @@ export function create_client({ target, base, trailing_slash }) {
 
 			/** @param {Event} event */
 			const trigger_prefetch = (event) => {
-				const { url, options } = find_anchor(event);
-				if (url && options.prefetch) {
-					if (is_external_url(url)) return;
+				const { url, options, has } = find_anchor(event);
+				if (url && options.prefetch && !is_external_url(url)) {
+					if (options.reload || has.rel_external || has.target || has.download) return;
 					prefetch(url);
 				}
 			};
@@ -1387,7 +1395,7 @@ export function create_client({ target, base, trailing_slash }) {
 				if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
 				if (event.defaultPrevented) return;
 
-				const { a, url, options } = find_anchor(event);
+				const { a, url, options, has } = find_anchor(event);
 				if (!a || !url) return;
 
 				const is_svg_a_element = a instanceof SVGAElement;
@@ -1407,15 +1415,10 @@ export function create_client({ target, base, trailing_slash }) {
 				)
 					return;
 
-				if (a.hasAttribute('download')) return;
+				if (has.download) return;
 
 				// Ignore the following but fire beforeNavigate
-				const rel = (a.getAttribute('rel') || '').split(/\s+/);
-				if (
-					rel.includes('external') ||
-					options.reload ||
-					(is_svg_a_element ? a.target.baseVal : a.target)
-				) {
+				if (options.reload || has.rel_external || has.target) {
 					const navigation = before_navigate({ url, type: 'link' });
 					if (!navigation) {
 						event.preventDefault();

package/src/runtime/client/fetcher.js

@@ -63,24 +63,17 @@ const cache = 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 {RequestInfo | URL} resource
- * @param {string} resolved
  * @param {RequestInit} [opts]
  */
-export function initial_fetch(resource, resolved, opts) {
-	const url = JSON.stringify(resource instanceof Request ? resource.url : resource);
-
-	let selector = `script[data-sveltekit-fetched][data-url=${url}]`;
-
-	if (opts?.body && (typeof opts.body === 'string' || ArrayBuffer.isView(opts.body))) {
-		selector += `[data-hash="${hash(opts.body)}"]`;
-	}
+export function initial_fetch(resource, opts) {
+	const selector = build_selector(resource, opts);
 
 	const script = document.querySelector(selector);
 	if (script?.textContent) {
 		const { body, ...init } = JSON.parse(script.textContent);
 
 		const ttl = script.getAttribute('data-ttl');
-		if (ttl) cache.set(resolved, { body, init, ttl: 1000 * Number(ttl) });
+		if (ttl) cache.set(selector, { body, init, ttl: 1000 * Number(ttl) });
 
 		return Promise.resolve(new Response(body, init));
 	}
@@ -90,18 +83,39 @@ export function initial_fetch(resource, resolved, opts) {
 
 /**
  * Tries to get the response from the cache, if max-age allows it, else does a fetch.
+ * @param {RequestInfo | URL} resource
  * @param {string} resolved
  * @param {RequestInit} [opts]
  */
-export function subsequent_fetch(resolved, opts) {
-	const cached = cache.get(resolved);
-	if (cached) {
-		if (performance.now() < cached.ttl) {
-			return new Response(cached.body, cached.init);
+export 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) {
+				return new Response(cached.body, cached.init);
+			}
+
+			cache.delete(selector);
 		}
-
-		cache.delete(resolved);
 	}
 
 	return native_fetch(resolved, opts);
 }
+
+/**
+ * Build the cache key for a given request
+ * @param {RequestInfo | URL} resource
+ * @param {RequestInit} [opts]
+ */
+function build_selector(resource, opts) {
+	const url = JSON.stringify(resource instanceof Request ? resource.url : resource);
+
+	let selector = `script[data-sveltekit-fetched][data-url=${url}]`;
+
+	if (opts?.body && (typeof opts.body === 'string' || ArrayBuffer.isView(opts.body))) {
+		selector += `[data-hash="${hash(opts.body)}"]`;
+	}
+
+	return selector;
+}

package/src/runtime/client/utils.js

@@ -58,7 +58,14 @@ export function find_anchor(event) {
 			noscroll,
 			prefetch,
 			reload
-		}
+		},
+		has: a
+			? {
+					rel_external: (a.getAttribute('rel') || '').split(/\s+/).includes('external'),
+					download: a.hasAttribute('download'),
+					target: !!(a instanceof SVGAElement ? a.target.baseVal : a.target)
+			  }
+			: {}
 	};
 }
 

package/src/utils/routing.js

@@ -72,11 +72,6 @@ export function parse_route_id(id) {
 									return (
 										content // allow users to specify characters on the file system in an encoded manner
 											.normalize()
-											// We use [ and ] to denote parameters, so users must encode these on the file
-											// system to match against them. We don't decode all characters since others
-											// can already be epressed and so that '%' can be easily used directly in filenames
-											.replace(/%5[Bb]/g, '[')
-											.replace(/%5[Dd]/g, ']')
 											// '#', '/', and '?' can only appear in URL path segments in an encoded manner.
 											// They will not be touched by decodeURI so need to be encoded here, so
 											// that we can match against them.