@sveltejs/kit 1.0.0-next.265 → 1.0.0-next.269

package/assets/client/start.js

@@ -6,6 +6,22 @@ import { writable } from 'svelte/store';
 import { base, set_paths } from '../paths.js';
 import { init } from './singletons.js';
 
+/**
+ * @param {string} path
+ * @param {'always' | 'never' | 'ignore'} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && /\/[^./]+$/.test(path)) {
+		return path + '/';
+	}
+
+	return path;
+}
+
 function scroll_state() {
 	return {
 		x: pageXOffset,
@@ -396,14 +412,7 @@ class Router {
 		}
 		this.navigating++;
 
-		let { pathname } = url;
-
-		if (this.trailing_slash === 'never') {
-			if (pathname !== '/' && pathname.endsWith('/')) pathname = pathname.slice(0, -1);
-		} else if (this.trailing_slash === 'always') {
-			const is_file = /** @type {string} */ (url.pathname.split('/').pop()).includes('.');
-			if (!is_file && !pathname.endsWith('/')) pathname += '/';
-		}
+		const pathname = normalize_path(url.pathname, this.trailing_slash);
 
 		info.url = new URL(url.origin + pathname + url.search + url.hash);
 

package/assets/server/index.js

@@ -147,7 +147,9 @@ async function render_endpoint(event, mod) {
 
 	const { status = 200, body = {} } = response;
 	const headers =
-		response.headers instanceof Headers ? response.headers : to_headers(response.headers);
+		response.headers instanceof Headers
+			? new Headers(response.headers)
+			: to_headers(response.headers);
 
 	const type = headers.get('content-type');
 
@@ -483,52 +485,29 @@ function coalesce_to_error(err) {
 		: new Error(JSON.stringify(err));
 }
 
+// dict from https://github.com/yahoo/serialize-javascript/blob/183c18a776e4635a379fdc620f81771f219832bb/index.js#L25
 /** @type {Record<string, string>} */
 const escape_json_in_html_dict = {
-	'&': '\\u0026',
-	'>': '\\u003e',
-	'<': '\\u003c',
-	'\u2028': '\\u2028',
-	'\u2029': '\\u2029'
-};
-
-/** @type {Record<string, string>} */
-const escape_json_value_in_html_dict = {
-	'"': '\\"',
 	'<': '\\u003C',
 	'>': '\\u003E',
 	'/': '\\u002F',
-	'\\': '\\\\',
-	'\b': '\\b',
-	'\f': '\\f',
-	'\n': '\\n',
-	'\r': '\\r',
-	'\t': '\\t',
-	'\0': '\\0',
 	'\u2028': '\\u2028',
 	'\u2029': '\\u2029'
 };
 
-/**
- * Escape a stringified JSON object that's going to be embedded in a `<script>` tag
- * @param {string} str
- */
-function escape_json_in_html(str) {
-	// adapted from https://github.com/vercel/next.js/blob/694407450638b037673c6d714bfe4126aeded740/packages/next/server/htmlescape.ts
-	// based on https://github.com/zertosh/htmlescape
-	// License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
-	return str.replace(/[&><\u2028\u2029]/g, (match) => escape_json_in_html_dict[match]);
-}
+const escape_json_in_html_regex = new RegExp(
+	`[${Object.keys(escape_json_in_html_dict).join('')}]`,
+	'g'
+);
 
 /**
- * Escape a string JSON value to be embedded into a `<script>` tag
- * @param {string} str
+ * Escape a JSONValue that's going to be embedded in a `<script>` tag
+ * @param {import("@sveltejs/kit/types/helper").JSONValue} val
  */
-function escape_json_value_in_html(str) {
-	return escape(
-		str,
-		escape_json_value_in_html_dict,
-		(code) => `\\u${code.toString(16).toUpperCase()}`
+function escape_json_in_html(val) {
+	return JSON.stringify(val).replace(
+		escape_json_in_html_regex,
+		(match) => escape_json_in_html_dict[match]
 	);
 }
 
@@ -1301,7 +1280,7 @@ async function render_response({
 
 			if (shadow_props) {
 				// prettier-ignore
-				body += `<script type="application/json" data-type="svelte-props">${escape_json_in_html(s(shadow_props))}</script>`;
+				body += `<script type="application/json" data-type="svelte-props">${escape_json_in_html(shadow_props)}</script>`;
 			}
 		}
 
@@ -1496,6 +1475,22 @@ function is_root_relative(path) {
 	return path[0] === '/' && path[1] !== '/';
 }
 
+/**
+ * @param {string} path
+ * @param {'always' | 'never' | 'ignore'} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && /\/[^./]+$/.test(path)) {
+		return path + '/';
+	}
+
+	return path;
+}
+
 /**
  * @param {{
  *   event: import('types/hooks').RequestEvent;
@@ -1555,6 +1550,7 @@ async function load_node({
 		? await load_shadow_data(
 				/** @type {import('types/internal').SSRPage} */ (route),
 				event,
+				options,
 				!!state.prerender
 		  )
 		: {};
@@ -1698,9 +1694,7 @@ async function load_node({
 				} else {
 					// external
 					if (resolved.startsWith('//')) {
-						throw new Error(
-							`Cannot request protocol-relative URL (${requested}) in server-side fetch`
-						);
+						requested = event.url.protocol + requested;
 					}
 
 					// external fetch
@@ -1742,11 +1736,21 @@ async function load_node({
 							}
 
 							if (!opts.body || typeof opts.body === 'string') {
+								// the json constructed below is later added to the dom in a script tag
+								// make sure the used values are safe
+								const status_number = Number(response.status);
+								if (isNaN(status_number)) {
+									throw new Error(
+										`response.status is not a number. value: "${
+											response.status
+										}" type: ${typeof response.status}`
+									);
+								}
 								// prettier-ignore
 								fetched.push({
 									url: requested,
 									body: /** @type {string} */ (opts.body),
-									json: `{"status":${response.status},"statusText":${s(response.statusText)},"headers":${s(headers)},"body":"${escape_json_value_in_html(body)}"}`
+									json: `{"status":${status_number},"statusText":${s(response.statusText)},"headers":${s(headers)},"body":${escape_json_in_html(body)}}`
 								});
 							}
 
@@ -1851,10 +1855,11 @@ async function load_node({
  *
  * @param {import('types/internal').SSRPage} route
  * @param {import('types/hooks').RequestEvent} event
+ * @param {import('types/internal').SSROptions} options
  * @param {boolean} prerender
  * @returns {Promise<import('types/endpoint').ShadowData>}
  */
-async function load_shadow_data(route, event, prerender) {
+async function load_shadow_data(route, event, options, prerender) {
 	if (!route.shadow) return {};
 
 	try {
@@ -1887,22 +1892,21 @@ async function load_shadow_data(route, event, prerender) {
 			if (result.fallthrough) return result;
 
 			const { status, headers, body } = validate_shadow_output(result);
+			data.status = status;
+
 			add_cookies(/** @type {string[]} */ (data.cookies), headers);
 
 			// Redirects are respected...
 			if (status >= 300 && status < 400) {
-				return {
-					status,
-					redirect: /** @type {string} */ (
-						headers instanceof Headers ? headers.get('location') : headers.location
-					)
-				};
+				data.redirect = /** @type {string} */ (
+					headers instanceof Headers ? headers.get('location') : headers.location
+				);
+				return data;
 			}
 
 			// ...but 4xx and 5xx status codes _don't_ result in the error page
 			// rendering for non-GET requests — instead, we allow the page
 			// to render with any validation errors etc that were returned
-			data.status = status;
 			data.body = body;
 		}
 
@@ -1913,21 +1917,18 @@ async function load_shadow_data(route, event, prerender) {
 
 			const { status, headers, body } = validate_shadow_output(result);
 			add_cookies(/** @type {string[]} */ (data.cookies), headers);
+			data.status = status;
 
 			if (status >= 400) {
-				return {
-					status,
-					error: new Error('Failed to load data')
-				};
+				data.error = new Error('Failed to load data');
+				return data;
 			}
 
 			if (status >= 300) {
-				return {
-					status,
-					redirect: /** @type {string} */ (
-						headers instanceof Headers ? headers.get('location') : headers.location
-					)
-				};
+				data.redirect = /** @type {string} */ (
+					headers instanceof Headers ? headers.get('location') : headers.location
+				);
+				return data;
 			}
 
 			data.body = { ...body, ...data.body };
@@ -1935,9 +1936,12 @@ async function load_shadow_data(route, event, prerender) {
 
 		return data;
 	} catch (e) {
+		const error = coalesce_to_error(e);
+		options.handle_error(error, event);
+
 		return {
 			status: 500,
-			error: coalesce_to_error(e)
+			error
 		};
 	}
 }
@@ -2446,26 +2450,15 @@ const DATA_SUFFIX = '/__data.json';
 async function respond(request, options, state = {}) {
 	const url = new URL(request.url);
 
-	if (url.pathname !== '/' && options.trailing_slash !== 'ignore') {
-		const has_trailing_slash = url.pathname.endsWith('/');
-
-		if (
-			(has_trailing_slash && options.trailing_slash === 'never') ||
-			(!has_trailing_slash &&
-				options.trailing_slash === 'always' &&
-				!(url.pathname.split('/').pop() || '').includes('.'))
-		) {
-			url.pathname = has_trailing_slash ? url.pathname.slice(0, -1) : url.pathname + '/';
-
-			if (url.search === '?') url.search = '';
+	const normalized = normalize_path(url.pathname, options.trailing_slash);
 
-			return new Response(undefined, {
-				status: 301,
-				headers: {
-					location: url.pathname + url.search
-				}
-			});
-		}
+	if (normalized !== url.pathname) {
+		return new Response(undefined, {
+			status: 301,
+			headers: {
+				location: normalized + (url.search === '?' ? '' : url.search)
+			}
+		});
 	}
 
 	const { parameter, allowed } = options.method_override;
@@ -2594,11 +2587,11 @@ async function respond(request, options, state = {}) {
 							const location = response.headers.get('location');
 
 							if (location) {
+								const headers = new Headers(response.headers);
+								headers.set('x-sveltekit-location', location);
 								response = new Response(undefined, {
 									status: 204,
-									headers: {
-										'x-sveltekit-location': location
-									}
+									headers
 								});
 							}
 						}

package/dist/chunks/index5.js

@@ -1,4 +1,4 @@
-import { m as mkdirp, b as SVELTE_KIT, h as rimraf, i as copy, $, j as logger } from '../cli.js';
+import { b as SVELTE_KIT, m as mkdirp, h as rimraf, i as copy, $, j as logger } from '../cli.js';
 import { readFileSync, writeFileSync } from 'fs';
 import { resolve as resolve$1, join, dirname } from 'path';
 import { pathToFileURL, URL } from 'url';
@@ -55,6 +55,22 @@ function is_root_relative(path) {
 	return path[0] === '/' && path[1] !== '/';
 }
 
+/**
+ * @param {string} path
+ * @param {'always' | 'never' | 'ignore'} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && /\/[^./]+$/.test(path)) {
+		return path + '/';
+	}
+
+	return path;
+}
+
 /** @typedef {{
  *   fn: () => Promise<any>,
  *   fulfil: (value: any) => void,
@@ -331,7 +347,20 @@ function crawl(html) {
 	return hrefs;
 }
 
+// dict from https://github.com/yahoo/serialize-javascript/blob/183c18a776e4635a379fdc620f81771f219832bb/index.js#L25
 /** @type {Record<string, string>} */
+const escape_json_in_html_dict = {
+	'<': '\\u003C',
+	'>': '\\u003E',
+	'/': '\\u002F',
+	'\u2028': '\\u2028',
+	'\u2029': '\\u2029'
+};
+
+new RegExp(
+	`[${Object.keys(escape_json_in_html_dict).join('')}]`,
+	'g'
+);
 
 /**
  * @param str {string} string to escape
@@ -425,25 +454,27 @@ const REDIRECT = 3;
  *   fallback?: string;
  *   all: boolean; // disregard `export const prerender = true`
  * }} opts
- * @returns {Promise<{ paths: string[] }>} returns a promise that resolves to an array of paths corresponding to the files that have been prerendered.
  */
 async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
+	/** @type {import('types/config').Prerendered} */
+	const prerendered = {
+		pages: new Map(),
+		assets: new Map(),
+		redirects: new Map(),
+		paths: []
+	};
+
 	if (!config.kit.prerender.enabled && !fallback) {
-		return { paths: [] };
+		return prerendered;
 	}
 
 	__fetch_polyfill();
 
-	mkdirp(out);
-
-	const dir = resolve$1(cwd, `${SVELTE_KIT}/output`);
-
-	const seen = new Set();
-
-	const server_root = resolve$1(dir);
+	const server_root = resolve$1(cwd, `${SVELTE_KIT}/output`);
 
 	/** @type {import('types/internal').AppModule} */
 	const { App, override } = await import(pathToFileURL(`${server_root}/server/app.js`).href);
+	const { manifest } = await import(pathToFileURL(`${server_root}/server/manifest.js`).href);
 
 	override({
 		paths: config.kit.paths,
@@ -451,8 +482,6 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		read: (file) => readFileSync(join(config.kit.files.assets, file))
 	});
 
-	const { manifest } = await import(pathToFileURL(`${server_root}/server/manifest.js`).href);
-
 	const app = new App(manifest);
 
 	const error = normalise_error_handler(log, config.kit.prerender.onError);
@@ -463,28 +492,12 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		...build_data.client.assets.map((chunk) => `${config.kit.appDir}/${chunk.fileName}`)
 	]);
 
-	/** @type {string[]} */
-	const paths = [];
-
 	build_data.static.forEach((file) => {
 		if (file.endsWith('/index.html')) {
 			files.add(file.slice(0, -11));
 		}
 	});
 
-	/**
-	 * @param {string} path
-	 */
-	function normalize(path) {
-		if (config.kit.trailingSlash === 'always') {
-			return path.endsWith('/') ? path : `${path}/`;
-		} else if (config.kit.trailingSlash === 'never') {
-			return !path.endsWith('/') || path === '/' ? path : path.slice(0, -1);
-		}
-
-		return path;
-	}
-
 	const q = queue(config.kit.prerender.concurrency);
 
 	/**
@@ -492,150 +505,168 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 	 * @param {boolean} is_html
 	 */
 	function output_filename(path, is_html) {
-		path = path.slice(config.kit.paths.base.length) || '/';
+		const file = path.slice(config.kit.paths.base.length + 1);
 
-		if (path === '/') {
-			return '/index.html';
+		if (file === '') {
+			return 'index.html';
 		}
 
-		const parts = path.split('/');
-		if (is_html && parts[parts.length - 1] !== 'index.html') {
-			if (config.kit.trailingSlash === 'always') {
-				parts.push('index.html');
-			} else {
-				parts[parts.length - 1] += '.html';
-			}
+		if (is_html && !file.endsWith('.html')) {
+			return file + (config.kit.trailingSlash === 'always' ? 'index.html' : '.html');
 		}
-		return parts.join('/');
+
+		return file;
 	}
 
+	const seen = new Set();
+	const written = new Set();
+
 	/**
-	 * @param {string} decoded_path
-	 * @param {string?} referrer
+	 * @param {string | null} referrer
+	 * @param {string} decoded
+	 * @param {string} [encoded]
 	 */
-	function enqueue(decoded_path, referrer) {
-		const path = encodeURI(normalize(decoded_path));
+	function enqueue(referrer, decoded, encoded) {
+		if (seen.has(decoded)) return;
+		seen.add(decoded);
 
-		if (seen.has(path)) return;
-		seen.add(path);
+		const file = decoded.slice(config.kit.paths.base.length + 1);
+		if (files.has(file)) return;
 
-		return q.add(() => visit(path, decoded_path, referrer));
+		return q.add(() => visit(decoded, encoded || encodeURI(decoded), referrer));
 	}
 
 	/**
-	 * @param {string} path
-	 * @param {string} decoded_path
+	 * @param {string} decoded
+	 * @param {string} encoded
 	 * @param {string?} referrer
 	 */
-	async function visit(path, decoded_path, referrer) {
-		if (!path.startsWith(config.kit.paths.base)) {
-			error({ status: 404, path, referrer, referenceType: 'linked' });
+	async function visit(decoded, encoded, referrer) {
+		if (!decoded.startsWith(config.kit.paths.base)) {
+			error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
 			return;
 		}
 
 		/** @type {Map<string, import('types/internal').PrerenderDependency>} */
 		const dependencies = new Map();
 
-		const rendered = await app.render(new Request(`http://sveltekit-prerender${path}`), {
+		const response = await app.render(new Request(`http://sveltekit-prerender${encoded}`), {
 			prerender: {
 				all,
 				dependencies
 			}
 		});
 
-		const response_type = Math.floor(rendered.status / 100);
-		const type = rendered.headers.get('content-type');
+		const text = await response.text();
+
+		save(response, text, decoded, encoded, referrer, 'linked');
+
+		for (const [dependency_path, result] of dependencies) {
+			// this seems circuitous, but using new URL allows us to not care
+			// whether dependency_path is encoded or not
+			const encoded_dependency_path = new URL(dependency_path, 'http://localhost').pathname;
+			const decoded_dependency_path = decodeURI(encoded_dependency_path);
+
+			const body = result.body ?? new Uint8Array(await result.response.arrayBuffer());
+			save(
+				result.response,
+				body,
+				decoded_dependency_path,
+				encoded_dependency_path,
+				decoded,
+				'fetched'
+			);
+		}
+
+		if (config.kit.prerender.crawl && response.headers.get('content-type') === 'text/html') {
+			for (const href of crawl(text)) {
+				if (href.startsWith('data:') || href.startsWith('#')) continue;
+
+				const resolved = resolve(encoded, href);
+				if (!is_root_relative(resolved)) continue;
+
+				const parsed = new URL(resolved, 'http://localhost');
+
+				if (parsed.search) ;
+
+				const pathname = normalize_path(parsed.pathname, config.kit.trailingSlash);
+				enqueue(decoded, decodeURI(pathname), pathname);
+			}
+		}
+	}
+
+	/**
+	 * @param {Response} response
+	 * @param {string | Uint8Array} body
+	 * @param {string} decoded
+	 * @param {string} encoded
+	 * @param {string | null} referrer
+	 * @param {'linked' | 'fetched'} referenceType
+	 */
+	function save(response, body, decoded, encoded, referrer, referenceType) {
+		const response_type = Math.floor(response.status / 100);
+		const type = /** @type {string} */ (response.headers.get('content-type'));
 		const is_html = response_type === REDIRECT || type === 'text/html';
 
-		const file = `${out}${output_filename(decoded_path, is_html)}`;
+		const file = output_filename(decoded, is_html);
+		const dest = `${out}/${file}`;
+
+		if (written.has(file)) return;
+		written.add(file);
 
 		if (response_type === REDIRECT) {
-			const location = rendered.headers.get('location');
+			const location = response.headers.get('location');
 
 			if (location) {
-				mkdirp(dirname(file));
+				mkdirp(dirname(dest));
 
-				log.warn(`${rendered.status} ${decoded_path} -> ${location}`);
+				log.warn(`${response.status} ${decoded} -> ${location}`);
 
 				writeFileSync(
-					file,
+					dest,
 					`<meta http-equiv="refresh" content=${escape_html_attr(`0;url=${location}`)}>`
 				);
 
-				const resolved = resolve(path, location);
+				let resolved = resolve(encoded, location);
 				if (is_root_relative(resolved)) {
-					enqueue(resolved, path);
+					resolved = normalize_path(resolved, config.kit.trailingSlash);
+					enqueue(decoded, decodeURI(resolved), resolved);
+				}
+
+				if (!prerendered.redirects.has(decoded)) {
+					prerendered.redirects.set(decoded, {
+						status: response.status,
+						location: resolved
+					});
+
+					prerendered.paths.push(normalize_path(decoded, 'never'));
 				}
 			} else {
-				log.warn(`location header missing on redirect received from ${decoded_path}`);
+				log.warn(`location header missing on redirect received from ${decoded}`);
 			}
 
 			return;
 		}
 
-		const text = await rendered.text();
-
-		if (rendered.status === 200) {
-			mkdirp(dirname(file));
-
-			log.info(`${rendered.status} ${decoded_path}`);
-			writeFileSync(file, text);
-			paths.push(normalize(decoded_path));
-		} else if (response_type !== OK) {
-			error({ status: rendered.status, path, referrer, referenceType: 'linked' });
-		}
-
-		for (const [dependency_path, result] of dependencies) {
-			const { status, headers } = result.response;
-
-			const response_type = Math.floor(status / 100);
-
-			const is_html = headers.get('content-type') === 'text/html';
-
-			const file = `${out}${output_filename(dependency_path, is_html)}`;
-			mkdirp(dirname(file));
+		if (response.status === 200) {
+			mkdirp(dirname(dest));
 
-			writeFileSync(
-				file,
-				result.body === null ? new Uint8Array(await result.response.arrayBuffer()) : result.body
-			);
-			paths.push(dependency_path);
+			log.info(`${response.status} ${decoded}`);
+			writeFileSync(dest, body);
 
-			if (response_type === OK) {
-				log.info(`${status} ${dependency_path}`);
+			if (is_html) {
+				prerendered.pages.set(decoded, {
+					file
+				});
 			} else {
-				error({
-					status,
-					path: dependency_path,
-					referrer: path,
-					referenceType: 'fetched'
+				prerendered.assets.set(decoded, {
+					type
 				});
 			}
-		}
-
-		if (is_html && config.kit.prerender.crawl) {
-			for (const href of crawl(text)) {
-				if (href.startsWith('data:') || href.startsWith('#')) continue;
 
-				const resolved = resolve(path, href);
-				if (!is_root_relative(resolved)) continue;
-
-				const parsed = new URL(resolved, 'http://localhost');
-
-				let pathname = decodeURI(parsed.pathname);
-
-				if (config.kit.paths.base) {
-					if (!pathname.startsWith(config.kit.paths.base)) continue;
-					pathname = pathname.slice(config.kit.paths.base.length) || '/';
-				}
-
-				const file = pathname.slice(1);
-				if (files.has(file)) continue;
-
-				if (parsed.search) ;
-
-				enqueue(pathname, path);
-			}
+			prerendered.paths.push(normalize_path(decoded, 'never'));
+		} else if (response_type !== OK) {
+			error({ status: response.status, path: decoded, referrer, referenceType });
 		}
 	}
 
@@ -643,10 +674,10 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		for (const entry of config.kit.prerender.entries) {
 			if (entry === '*') {
 				for (const entry of build_data.entries) {
-					enqueue(config.kit.paths.base + entry, null);
+					enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash)); // TODO can we pre-normalize these?
 				}
 			} else {
-				enqueue(config.kit.paths.base + entry, null);
+				enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash));
 			}
 		}
 
@@ -667,9 +698,7 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		writeFileSync(file, await rendered.text());
 	}
 
-	return {
-		paths
-	};
+	return prerendered;
 }
 
 /**
@@ -683,11 +712,14 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
  */
 function create_builder({ cwd, config, build_data, log }) {
 	/** @type {Set<string>} */
-	const prerendered_paths = new Set();
+	let prerendered_paths;
+
 	let generated_manifest = false;
 
 	/** @param {import('types/internal').RouteData} route */
 	function not_prerendered(route) {
+		if (!prerendered_paths) return true;
+
 		if (route.type === 'page' && route.path) {
 			return !prerendered_paths.has(route.path);
 		}
@@ -832,10 +864,7 @@ function create_builder({ cwd, config, build_data, log }) {
 				log
 			});
 
-			prerendered.paths.forEach((path) => {
-				prerendered_paths.add(path);
-				prerendered_paths.add(path + '/');
-			});
+			prerendered_paths = new Set(prerendered.paths);
 
 			return prerendered;
 		}

package/dist/cli.js

@@ -620,7 +620,8 @@ const options = object(
 				concurrency: number(1),
 				crawl: boolean(true),
 				createIndexFiles: error(
-					(keypath) => `${keypath} has been removed — it is now controlled by the trailingSlash option. See https://kit.svelte.dev/docs/configuration#trailingslash`
+					(keypath) =>
+						`${keypath} has been removed — it is now controlled by the trailingSlash option. See https://kit.svelte.dev/docs/configuration#trailingslash`
 				),
 				enabled: boolean(true),
 				entries: validate(['*'], (input, keypath) => {
@@ -677,7 +678,7 @@ const options = object(
 
 			serviceWorker: object({
 				register: boolean(true),
-				files: fun((filename) => !/\.DS_STORE/.test(filename))
+				files: fun((filename) => !/\.DS_Store/.test(filename))
 			}),
 
 			// TODO remove this for 1.0
@@ -997,7 +998,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.265');
+const prog = sade('svelte-kit').version('1.0.0-next.269');
 
 prog
 	.command('dev')
@@ -1155,7 +1156,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.265'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.269'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/package.json

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

package/types/config.d.ts

@@ -35,6 +35,32 @@ export interface AdapterEntry {
 	}) => void;
 }
 
+export interface Prerendered {
+	pages: Map<
+		string,
+		{
+			/** The location of the .html file relative to the output directory */
+			file: string;
+		}
+	>;
+	assets: Map<
+		string,
+		{
+			/** The MIME type of the asset */
+			type: string;
+		}
+	>;
+	redirects: Map<
+		string,
+		{
+			status: number;
+			location: string;
+		}
+	>;
+	/** An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config) */
+	paths: string[];
+}
+
 export interface Builder {
 	log: Logger;
 	rimraf(dir: string): void;
@@ -87,9 +113,7 @@ export interface Builder {
 		}
 	): string[];
 
-	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<{
-		paths: string[];
-	}>;
+	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<Prerendered>;
 }
 
 export interface Adapter {

package/types/index.d.ts

@@ -4,7 +4,14 @@
 import './ambient-modules';
 
 export { App, SSRManifest } from './app';
-export { Adapter, Builder, Config, PrerenderErrorHandler, ValidatedConfig } from './config';
+export {
+	Adapter,
+	Builder,
+	Config,
+	Prerendered,
+	PrerenderErrorHandler,
+	ValidatedConfig
+} from './config';
 export { EndpointOutput, RequestHandler } from './endpoint';
 export { ErrorLoad, ErrorLoadInput, Load, LoadInput, LoadOutput } from './page';
 export { ExternalFetch, GetSession, Handle, HandleError, RequestEvent, ResolveOpts } from './hooks';