@sveltejs/kit 1.0.0-next.300 → 1.0.0-next.303

package/assets/client/start.js

@@ -250,39 +250,75 @@ function initial_fetch(resource, opts) {
 	return fetch(resource, opts);
 }
 
-/** @param {string} key */
-function parse_route_id(key) {
+const param_pattern = /^(\.\.\.)?(\w+)(?:=(\w+))?$/;
+
+/** @param {string} id */
+function parse_route_id(id) {
 	/** @type {string[]} */
 	const names = [];
 
 	/** @type {string[]} */
 	const types = [];
 
+	// `/foo` should get an optional trailing slash, `/foo.json` should not
+	// const add_trailing_slash = !/\.[a-z]+$/.test(key);
+	let add_trailing_slash = true;
+
 	const pattern =
-		key === ''
+		id === ''
 			? /^\/$/
 			: new RegExp(
-					`^${decodeURIComponent(key)
+					`^${decodeURIComponent(id)
 						.split('/')
-						.map((segment) => {
+						.map((segment, i, segments) => {
 							// special case — /[...rest]/ could contain zero segments
-							const match = /^\[\.\.\.(\w+)(?:=\w+)?\]$/.exec(segment);
+							const match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
 							if (match) {
 								names.push(match[1]);
 								types.push(match[2]);
 								return '(?:/(.*))?';
 							}
 
+							const is_last = i === segments.length - 1;
+
 							return (
 								'/' +
-								segment.replace(/\[(\.\.\.)?(\w+)(?:=(\w+))?\]/g, (m, rest, name, type) => {
-									names.push(name);
-									types.push(type);
-									return rest ? '(.*?)' : '([^/]+?)';
-								})
+								segment
+									.split(/\[(.+?)\]/)
+									.map((content, i) => {
+										if (i % 2) {
+											const [, rest, name, type] = /** @type {RegExpMatchArray} */ (
+												param_pattern.exec(content)
+											);
+											names.push(name);
+											types.push(type);
+											return rest ? '(.*?)' : '([^/]+?)';
+										}
+
+										if (is_last && content.includes('.')) add_trailing_slash = false;
+
+										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.
+												// We skip '/' since you can't create a file with it on any OS
+												.replace(/#/g, '%23')
+												.replace(/\?/g, '%3F')
+												// escape characters that have special meaning in regex
+												.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+										); // TODO handle encoding
+									})
+									.join('')
 							);
 						})
-						.join('')}/?$`
+						.join('')}${add_trailing_slash ? '/?' : ''}$`
 			  );
 
 	return { pattern, names, types };
@@ -527,7 +563,11 @@ function create_client({ target, session, base, trailing_slash }) {
 		const current_token = (token = {});
 		let navigation_result = intent && (await load_route(intent, no_cache));
 
-		if (!navigation_result && url.pathname === location.pathname) {
+		if (
+			!navigation_result &&
+			url.origin === location.origin &&
+			url.pathname === location.pathname
+		) {
 			// this could happen in SPA fallback mode if the user navigated to
 			// `/non-existent-page`. if we fall back to reloading the page, it
 			// will create an infinite loop. so whereas we normally handle
@@ -985,7 +1025,7 @@ function create_client({ target, session, base, trailing_slash }) {
 							// @ts-expect-error
 							if (node.loaded.fallthrough) {
 								throw new Error(
-									'fallthrough is no longer supported. Use matchers instead: https://kit.svelte.dev/docs/routing#advanced-routing-validation'
+									'fallthrough is no longer supported. Use matchers instead: https://kit.svelte.dev/docs/routing#advanced-routing-matching'
 								);
 							}
 

package/assets/server/index.js

@@ -2498,8 +2498,6 @@ function negotiate(accept, types) {
 	return accepted;
 }
 
-/** @param {string} key */
-
 /**
  * @param {RegExpMatchArray} match
  * @param {string[]} names
@@ -2543,7 +2541,10 @@ async function respond(request, options, state) {
 		return new Response(undefined, {
 			status: 301,
 			headers: {
-				location: normalized + (url.search === '?' ? '' : url.search)
+				location:
+					// ensure paths starting with '//' are not treated as protocol-relative
+					(normalized.startsWith('//') ? url.origin + normalized : normalized) +
+					(url.search === '?' ? '' : url.search)
 			}
 		});
 	}

package/dist/chunks/index.js

@@ -11,7 +11,7 @@ import { update, init } from './sync.js';
 import { getRequest, setResponse } from '../node.js';
 import { sequence } from '../hooks.js';
 import { p as posixify } from './filesystem.js';
-import { p as parse_route_id } from './routing.js';
+import { p as parse_route_id } from './misc.js';
 import 'sade';
 import 'child_process';
 import 'net';
@@ -23,7 +23,6 @@ import 'node:zlib';
 import 'node:stream';
 import 'node:util';
 import 'node:url';
-import './misc.js';
 import 'stream';
 
 /**

package/dist/chunks/index2.js

@@ -15,7 +15,6 @@ import 'sade';
 import 'child_process';
 import 'net';
 import 'os';
-import './routing.js';
 import 'node:http';
 import 'node:https';
 import 'node:zlib';

package/dist/chunks/index3.js

@@ -1,5 +1,4 @@
-import { s } from './misc.js';
-import { p as parse_route_id } from './routing.js';
+import { s, p as parse_route_id } from './misc.js';
 import { a as get_mime_lookup } from '../cli.js';
 
 /**

package/dist/chunks/index4.js

@@ -2,14 +2,13 @@ import { $ } from '../cli.js';
 import { r as rimraf, m as mkdirp, c as copy } from './filesystem.js';
 import { g as generate_manifest } from './index3.js';
 import 'sade';
+import 'fs';
 import 'path';
 import 'child_process';
 import 'net';
-import 'fs';
 import 'url';
 import 'os';
 import './misc.js';
-import './routing.js';
 
 /**
  * @param {{
@@ -49,7 +48,11 @@ function create_builder({ config, build_data, prerendered, log }) {
 			/** @type {import('types').RouteDefinition[]} */
 			const facades = routes.map((route) => ({
 				type: route.type,
-				segments: route.segments,
+				segments: route.id.split('/').map((segment) => ({
+					dynamic: segment.includes('['),
+					rest: segment.includes('[...'),
+					content: segment
+				})),
 				pattern: route.pattern,
 				methods: route.type === 'page' ? ['get'] : build_data.server.methods[route.file]
 			}));
@@ -78,22 +81,7 @@ function create_builder({ config, build_data, prerendered, log }) {
 				// also be included, since the page likely needs the endpoint
 				filtered.forEach((route) => {
 					if (route.type === 'page') {
-						const length = route.segments.length;
-
-						const endpoint = routes.find((candidate) => {
-							if (candidate.segments.length !== length) return false;
-
-							for (let i = 0; i < length; i += 1) {
-								const a = route.segments[i];
-								const b = candidate.segments[i];
-
-								if (i === length - 1) {
-									return b.content === `${a.content}.json`;
-								}
-
-								if (a.content !== b.content) return false;
-							}
-						});
+						const endpoint = routes.find((candidate) => candidate.id === route.id + '.json');
 
 						if (endpoint) {
 							filtered.add(endpoint);

package/dist/chunks/misc.js

@@ -1,3 +1,77 @@
+const param_pattern = /^(\.\.\.)?(\w+)(?:=(\w+))?$/;
+
+/** @param {string} id */
+function parse_route_id(id) {
+	/** @type {string[]} */
+	const names = [];
+
+	/** @type {string[]} */
+	const types = [];
+
+	// `/foo` should get an optional trailing slash, `/foo.json` should not
+	// const add_trailing_slash = !/\.[a-z]+$/.test(key);
+	let add_trailing_slash = true;
+
+	const pattern =
+		id === ''
+			? /^\/$/
+			: new RegExp(
+					`^${decodeURIComponent(id)
+						.split('/')
+						.map((segment, i, segments) => {
+							// special case — /[...rest]/ could contain zero segments
+							const match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+							if (match) {
+								names.push(match[1]);
+								types.push(match[2]);
+								return '(?:/(.*))?';
+							}
+
+							const is_last = i === segments.length - 1;
+
+							return (
+								'/' +
+								segment
+									.split(/\[(.+?)\]/)
+									.map((content, i) => {
+										if (i % 2) {
+											const [, rest, name, type] = /** @type {RegExpMatchArray} */ (
+												param_pattern.exec(content)
+											);
+											names.push(name);
+											types.push(type);
+											return rest ? '(.*?)' : '([^/]+?)';
+										}
+
+										if (is_last && content.includes('.')) add_trailing_slash = false;
+
+										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.
+												// We skip '/' since you can't create a file with it on any OS
+												.replace(/#/g, '%23')
+												.replace(/\?/g, '%3F')
+												// escape characters that have special meaning in regex
+												.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+										); // TODO handle encoding
+									})
+									.join('')
+							);
+						})
+						.join('')}${add_trailing_slash ? '/?' : ''}$`
+			  );
+
+	return { pattern, names, types };
+}
+
 const s = JSON.stringify;
 
-export { s };
+export { parse_route_id as p, s };

package/dist/chunks/sync.js

@@ -2,8 +2,8 @@ import path__default from 'path';
 import fs__default from 'fs';
 import { g as get_runtime_path, $ } from '../cli.js';
 import { p as posixify, c as copy, m as mkdirp } from './filesystem.js';
+import { p as parse_route_id, s } from './misc.js';
 import { fileURLToPath } from 'url';
-import { s } from './misc.js';
 import 'sade';
 import 'child_process';
 import 'net';
@@ -122,9 +122,7 @@ var mime = new Mime(standard, other);
  *   type: string | null;
  * }} Part
  * @typedef {{
- *   basename: string;
  *   name: string;
- *   ext: string;
  *   parts: Part[],
  *   file: string;
  *   is_dir: boolean;
@@ -170,14 +168,13 @@ function create_manifest_data({
 	/**
 	 * @param {string} dir
 	 * @param {string[]} parent_id
-	 * @param {Part[][]} parent_segments
-	 * @param {string[]} parent_params
 	 * @param {Array<string|undefined>} layout_stack // accumulated __layout.svelte components
 	 * @param {Array<string|undefined>} error_stack // accumulated __error.svelte components
 	 */
-	function walk(dir, parent_id, parent_segments, parent_params, layout_stack, error_stack) {
+	function walk(dir, parent_id, layout_stack, error_stack) {
 		/** @type {Item[]} */
-		let items = [];
+		const items = [];
+
 		fs__default.readdirSync(dir).forEach((basename) => {
 			const resolved = path__default.join(dir, basename);
 			const file = posixify(path__default.relative(cwd, resolved));
@@ -190,110 +187,38 @@ function create_manifest_data({
 
 			if (ext === undefined) return;
 
-			const name = ext ? basename.slice(0, -ext.length) : basename;
-
-			// TODO remove this after a while
-			['layout', 'layout.reset', 'error'].forEach((reserved) => {
-				if (name === `$${reserved}`) {
-					const prefix = posixify(path__default.relative(cwd, dir));
-					const bad = `${prefix}/$${reserved}${ext}`;
-					const good = `${prefix}/__${reserved}${ext}`;
-
-					throw new Error(`${bad} should be renamed ${good}`);
-				}
-			});
+			const name = basename.slice(0, basename.length - ext.length);
 
-			if (basename.startsWith('__') && !specials.has(name)) {
+			if (name.startsWith('__') && !specials.has(name)) {
 				throw new Error(`Files and directories prefixed with __ are reserved (saw ${file})`);
 			}
 
-			if (!is_dir && !/^(\.[a-z0-9]+)+$/i.test(ext)) return null; // filter out tmp files etc
-
-			if (!config.kit.routes(file)) {
-				return;
-			}
-
-			const segment = is_dir ? basename : name;
-
-			if (/\]\[/.test(segment)) {
-				throw new Error(`Invalid route ${file} — parameters must be separated`);
-			}
-
-			if (count_occurrences('[', segment) !== count_occurrences(']', segment)) {
-				throw new Error(`Invalid route ${file} — brackets are unbalanced`);
-			}
-
-			const parts = get_parts(segment, file);
-			const is_index = is_dir ? false : basename.startsWith('index.');
-			const is_page = config.extensions.indexOf(ext) !== -1;
-			const route_suffix = basename.slice(basename.indexOf('.'), -ext.length);
+			if (!config.kit.routes(file)) return;
 
 			items.push({
-				basename,
-				name,
-				ext,
-				parts,
 				file,
+				name,
+				parts: get_parts(name, file),
+				route_suffix: basename.slice(basename.indexOf('.'), -ext.length),
 				is_dir,
-				is_index,
-				is_page,
-				route_suffix
+				is_index: !is_dir && basename.startsWith('index.'),
+				is_page: config.extensions.includes(ext)
 			});
 		});
-		items = items.sort(comparator);
+
+		items.sort(comparator);
 
 		items.forEach((item) => {
-			const id = parent_id.slice();
-			const segments = parent_segments.slice();
+			const id_parts = parent_id.slice();
 
 			if (item.is_index) {
-				if (item.route_suffix) {
-					if (segments.length > 0) {
-						const last_segment = segments[segments.length - 1].slice();
-						const last_part = last_segment[last_segment.length - 1];
-
-						if (last_part.dynamic) {
-							last_segment.push({
-								dynamic: false,
-								rest: false,
-								content: item.route_suffix,
-								type: null
-							});
-						} else {
-							last_segment[last_segment.length - 1] = {
-								dynamic: false,
-								rest: false,
-								content: `${last_part.content}${item.route_suffix}`,
-								type: null
-							};
-						}
-
-						segments[segments.length - 1] = last_segment;
-						id[id.length - 1] += item.route_suffix;
-					} else {
-						segments.push(item.parts);
-					}
+				if (item.route_suffix && id_parts.length > 0) {
+					id_parts[id_parts.length - 1] += item.route_suffix;
 				}
 			} else {
-				id.push(item.name);
-				segments.push(item.parts);
+				id_parts.push(item.name);
 			}
 
-			const params = parent_params.slice();
-			params.push(...item.parts.filter((p) => p.dynamic).map((p) => p.content));
-
-			// TODO seems slightly backwards to derive the simple segment representation
-			// from the more complex form, rather than vice versa — maybe swap it round
-			const simple_segments = segments.map((segment) => {
-				return {
-					dynamic: segment.some((part) => part.dynamic),
-					rest: segment.some((part) => part.rest),
-					content: segment
-						.map((part) => (part.dynamic ? `[${part.content}]` : part.content))
-						.join('')
-				};
-			});
-
 			if (item.is_dir) {
 				const layout_reset = find_layout('__layout.reset', item.file);
 				const layout = find_layout('__layout', item.file);
@@ -308,62 +233,55 @@ function create_manifest_data({
 				if (error) components.push(error);
 
 				walk(
-					path__default.join(dir, item.basename),
-					id,
-					segments,
-					params,
+					path__default.join(dir, item.name),
+					id_parts,
 					layout_reset ? [layout_reset] : layout_stack.concat(layout),
 					layout_reset ? [error] : error_stack.concat(error)
 				);
-			} else if (item.is_page) {
-				components.push(item.file);
+			} else {
+				const id = id_parts.join('/');
+				const { pattern } = parse_route_id(id);
 
-				const concatenated = layout_stack.concat(item.file);
-				const errors = error_stack.slice();
+				if (item.is_page) {
+					components.push(item.file);
 
-				const pattern = get_pattern(segments, true);
+					const concatenated = layout_stack.concat(item.file);
+					const errors = error_stack.slice();
 
-				let i = concatenated.length;
-				while (i--) {
-					if (!errors[i] && !concatenated[i]) {
-						errors.splice(i, 1);
-						concatenated.splice(i, 1);
+					let i = concatenated.length;
+					while (i--) {
+						if (!errors[i] && !concatenated[i]) {
+							errors.splice(i, 1);
+							concatenated.splice(i, 1);
+						}
 					}
-				}
 
-				i = errors.length;
-				while (i--) {
-					if (errors[i]) break;
-				}
+					i = errors.length;
+					while (i--) {
+						if (errors[i]) break;
+					}
 
-				errors.splice(i + 1);
-
-				const path = segments.every((segment) => segment.length === 1 && !segment[0].dynamic)
-					? `/${segments.map((segment) => segment[0].content).join('/')}`
-					: '';
-
-				routes.push({
-					type: 'page',
-					id: id.join('/'),
-					segments: simple_segments,
-					pattern,
-					params,
-					path,
-					shadow: null,
-					a: /** @type {string[]} */ (concatenated),
-					b: /** @type {string[]} */ (errors)
-				});
-			} else {
-				const pattern = get_pattern(segments, !item.route_suffix);
-
-				routes.push({
-					type: 'endpoint',
-					id: id.join('/'),
-					segments: simple_segments,
-					pattern,
-					file: item.file,
-					params
-				});
+					errors.splice(i + 1);
+
+					const path = id.includes('[') ? '' : `/${id}`;
+
+					routes.push({
+						type: 'page',
+						id,
+						pattern,
+						path,
+						shadow: null,
+						a: /** @type {string[]} */ (concatenated),
+						b: /** @type {string[]} */ (errors)
+					});
+				} else {
+					routes.push({
+						type: 'endpoint',
+						id,
+						pattern,
+						file: item.file
+					});
+				}
 			}
 		});
 	}
@@ -375,7 +293,7 @@ function create_manifest_data({
 
 	components.push(layout, error);
 
-	walk(config.kit.files.routes, [], [], [], [layout], [error]);
+	walk(config.kit.files.routes, [], [layout], [error]);
 
 	const lookup = new Map();
 	for (const route of routes) {
@@ -410,7 +328,7 @@ function create_manifest_data({
 				matchers[type] = path__default.join(params_base, file);
 			} else {
 				throw new Error(
-					`Validator names must match /^[a-zA-Z_][a-zA-Z0-9_]*$/ — "${file}" is invalid`
+					`Matcher names must match /^[a-zA-Z_][a-zA-Z0-9_]*$/ — "${file}" is invalid`
 				);
 			}
 		}
@@ -438,11 +356,7 @@ function count_occurrences(needle, haystack) {
 	return count;
 }
 
-/** @param {string} path */
-function is_spread(path) {
-	const spread_pattern = /\[\.{3}/g;
-	return spread_pattern.test(path);
-}
+const spread_pattern = /\[\.{3}/;
 
 /**
  * @param {Item} a
@@ -450,9 +364,8 @@ function is_spread(path) {
  */
 function comparator(a, b) {
 	if (a.is_index !== b.is_index) {
-		if (a.is_index) return is_spread(a.file) ? 1 : -1;
-
-		return is_spread(b.file) ? -1 : 1;
+		if (a.is_index) return spread_pattern.test(a.file) ? 1 : -1;
+		return spread_pattern.test(b.file) ? -1 : 1;
 	}
 
 	const max = Math.max(a.parts.length, b.parts.length);
@@ -504,6 +417,14 @@ function comparator(a, b) {
  * @param {string} file
  */
 function get_parts(part, file) {
+	if (/\]\[/.test(part)) {
+		throw new Error(`Invalid route ${file} — parameters must be separated`);
+	}
+
+	if (count_occurrences('[', part) !== count_occurrences(']', part)) {
+		throw new Error(`Invalid route ${file} — brackets are unbalanced`);
+	}
+
 	/** @type {Part[]} */
 	const result = [];
 	part.split(/\[(.+?\(.+?\)|.+?)\]/).map((str, i) => {
@@ -535,52 +456,6 @@ function get_parts(part, file) {
 	return result;
 }
 
-/**
- * @param {Part[][]} segments
- * @param {boolean} add_trailing_slash
- */
-function get_pattern(segments, add_trailing_slash) {
-	const path = segments
-		.map((segment) => {
-			if (segment.length === 1 && segment[0].rest) {
-				// special case — `src/routes/foo/[...bar]/baz` matches `/foo/baz`
-				// so we need to make the leading slash optional
-				return '(?:\\/(.*))?';
-			}
-
-			const parts = segment.map((part) => {
-				if (part.rest) return '(.*?)';
-				if (part.dynamic) return '([^/]+?)';
-
-				return (
-					part.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.
-						// We skip '/' since you can't create a file with it on any OS
-						.replace(/#/g, '%23')
-						.replace(/\?/g, '%3F')
-						// escape characters that have special meaning in regex
-						.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-				);
-			});
-
-			return '\\/' + parts.join('');
-		})
-		.join('');
-
-	const trailing = add_trailing_slash && segments.length ? '\\/?$' : '$';
-
-	return new RegExp(`^${path || '\\/'}${trailing}`);
-}
-
 /**
  * @param {{
  *  config: import('types').ValidatedConfig;
@@ -704,6 +579,28 @@ function write_manifest(manifest_data, base, output) {
 	);
 }
 
+/**
+ * @param {import('types').ManifestData} manifest_data
+ * @param {string} output
+ */
+function write_matchers(manifest_data, output) {
+	const imports = [];
+	const matchers = [];
+
+	for (const key in manifest_data.matchers) {
+		const src = manifest_data.matchers[key];
+
+		imports.push(`import { match as ${key} } from ${s(path__default.relative(output, src))};`);
+		matchers.push(key);
+	}
+
+	const module = imports.length
+		? `${imports.join('\n')}\n\nexport const matchers = { ${matchers.join(', ')} };`
+		: 'export const matchers = {};';
+
+	write_if_changed(`${output}/client-matchers.js`, module);
+}
+
 /**
  * @param {import('types').ManifestData} manifest_data
  * @param {string} output
@@ -1003,28 +900,6 @@ function write_types(config, manifest_data) {
 	});
 }
 
-/**
- * @param {import('types').ManifestData} manifest_data
- * @param {string} output
- */
-function write_validators(manifest_data, output) {
-	const imports = [];
-	const matchers = [];
-
-	for (const key in manifest_data.matchers) {
-		const src = manifest_data.matchers[key];
-
-		imports.push(`import { match as ${key} } from ${s(path__default.relative(output, src))};`);
-		matchers.push(key);
-	}
-
-	const module = imports.length
-		? `${imports.join('\n')}\n\nexport const matchers = { ${matchers.join(', ')} };`
-		: 'export const matchers = {};';
-
-	write_if_changed(`${output}/client-matchers.js`, module);
-}
-
 /** @param {import('types').ValidatedConfig} config */
 function init(config) {
 	copy_assets(path__default.join(config.kit.outDir, 'runtime'));
@@ -1040,7 +915,7 @@ function update(config) {
 
 	write_manifest(manifest_data, base, output);
 	write_root(manifest_data, output);
-	write_validators(manifest_data, output);
+	write_matchers(manifest_data, output);
 	write_types(config, manifest_data);
 
 	return { manifest_data };

package/dist/cli.js

@@ -1,8 +1,8 @@
 import sade from 'sade';
+import fs__default from 'fs';
 import path__default, { join, relative } from 'path';
 import { exec as exec$1 } from 'child_process';
 import { createConnection, createServer } from 'net';
-import fs__default from 'fs';
 import * as url from 'url';
 import { networkInterfaces, release } from 'os';
 
@@ -869,7 +869,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.300');
+const prog = sade('svelte-kit').version('1.0.0-next.303');
 
 prog
 	.command('dev')
@@ -996,6 +996,11 @@ prog
 	.command('sync')
 	.describe('Synchronise generated files')
 	.action(async () => {
+		if (!fs__default.existsSync('svelte.config.js')) {
+			console.warn('Missing svelte.config.js — skipping');
+			return;
+		}
+
 		try {
 			const config = await load_config();
 			const sync = await import('./chunks/sync.js');
@@ -1042,7 +1047,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.300'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.303'}\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.300",
+  "version": "1.0.0-next.303",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/types/internal.d.ts

@@ -78,9 +78,7 @@ export type CSRRoute = {
 export interface EndpointData {
 	type: 'endpoint';
 	id: string;
-	segments: RouteSegment[];
 	pattern: RegExp;
-	params: string[];
 	file: string;
 }
 
@@ -129,9 +127,7 @@ export interface PageData {
 	type: 'page';
 	id: string;
 	shadow: string | null;
-	segments: RouteSegment[];
 	pattern: RegExp;
-	params: string[];
 	path: string;
 	a: string[];
 	b: string[];

package/dist/chunks/routing.js

@@ -1,39 +0,0 @@
-/** @param {string} key */
-function parse_route_id(key) {
-	/** @type {string[]} */
-	const names = [];
-
-	/** @type {string[]} */
-	const types = [];
-
-	const pattern =
-		key === ''
-			? /^\/$/
-			: new RegExp(
-					`^${decodeURIComponent(key)
-						.split('/')
-						.map((segment) => {
-							// special case — /[...rest]/ could contain zero segments
-							const match = /^\[\.\.\.(\w+)(?:=\w+)?\]$/.exec(segment);
-							if (match) {
-								names.push(match[1]);
-								types.push(match[2]);
-								return '(?:/(.*))?';
-							}
-
-							return (
-								'/' +
-								segment.replace(/\[(\.\.\.)?(\w+)(?:=(\w+))?\]/g, (m, rest, name, type) => {
-									names.push(name);
-									types.push(type);
-									return rest ? '(.*?)' : '([^/]+?)';
-								})
-							);
-						})
-						.join('')}/?$`
-			  );
-
-	return { pattern, names, types };
-}
-
-export { parse_route_id as p };