@sveltejs/kit 1.3.5 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.3.5",
+  "version": "1.3.6",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/runtime/client/fetcher.js

@@ -127,8 +127,19 @@ function build_selector(resource, opts) {
 
 	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)}"]`;
+	if (opts?.headers || opts?.body) {
+		/** @type {import('types').StrictBody[]} */
+		const values = [];
+
+		if (opts.headers) {
+			values.push([...new Headers(opts.headers)].join(','));
+		}
+
+		if (opts.body && (typeof opts.body === 'string' || ArrayBuffer.isView(opts.body))) {
+			values.push(opts.body);
+		}
+
+		selector += `[data-hash="${hash(...values)}"]`;
 	}
 
 	return selector;

package/src/runtime/hash.js

@@ -1,19 +1,21 @@
 /**
  * Hash using djb2
- * @param {import('types').StrictBody} value
+ * @param {import('types').StrictBody[]} values
  */
-export function hash(value) {
+export function hash(...values) {
 	let hash = 5381;
 
-	if (typeof value === 'string') {
-		let i = value.length;
-		while (i) hash = (hash * 33) ^ value.charCodeAt(--i);
-	} else if (ArrayBuffer.isView(value)) {
-		const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-		let i = buffer.length;
-		while (i) hash = (hash * 33) ^ buffer[--i];
-	} else {
-		throw new TypeError('value must be a string or TypedArray');
+	for (const value of values) {
+		if (typeof value === 'string') {
+			let i = value.length;
+			while (i) hash = (hash * 33) ^ value.charCodeAt(--i);
+		} else if (ArrayBuffer.isView(value)) {
+			const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+			let i = buffer.length;
+			while (i) hash = (hash * 33) ^ buffer[--i];
+		} else {
+			throw new TypeError('value must be a string or TypedArray');
+		}
 	}
 
 	return (hash >>> 0).toString(36);

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

@@ -194,6 +194,7 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 									? await stream_to_string(cloned_body)
 									: init?.body
 							),
+							request_headers: init?.headers,
 							response_body: body,
 							response: response
 						});

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

@@ -73,8 +73,19 @@ export function serialize_data(fetched, filter, prerendering = false) {
 		`data-url=${escape_html_attr(fetched.url)}`
 	];
 
-	if (fetched.request_body) {
-		attrs.push(`data-hash=${escape_html_attr(hash(fetched.request_body))}`);
+	if (fetched.request_headers || fetched.request_body) {
+		/** @type {import('types').StrictBody[]} */
+		const values = [];
+
+		if (fetched.request_headers) {
+			values.push([...new Headers(fetched.request_headers)].join(','));
+		}
+
+		if (fetched.request_body) {
+			values.push(fetched.request_body);
+		}
+
+		attrs.push(`data-hash="${hash(...values)}"`);
 	}
 
 	// Compute the time the response should be cached, taking into account max-age and age.

package/src/runtime/server/page/types.d.ts

@@ -5,6 +5,7 @@ export interface Fetched {
 	url: string;
 	method: string;
 	request_body?: string | ArrayBufferView | null;
+	request_headers?: HeadersInit | undefined;
 	response_body: string;
 	response: Response;
 }

package/src/utils/routing.js

@@ -126,57 +126,44 @@ export function exec(match, params, matchers) {
 
 	const values = match.slice(1);
 
-	let buffered = '';
+	let buffered = 0;
 
 	for (let i = 0; i < params.length; i += 1) {
 		const param = params[i];
-		let value = values[i];
+		const value = values[i - buffered];
 
+		// in the `[[a=b]]/.../[...rest]` case, if one or more optional parameters
+		// weren't matched, roll the skipped values into the rest
 		if (param.chained && param.rest && buffered) {
-			// in the `[[lang=lang]]/[...rest]` case, if `lang` didn't
-			// match, we roll it over into the rest value
-			value = value ? buffered + '/' + value : buffered;
-		}
+			result[param.name] = values
+				.slice(i - buffered, i + 1)
+				.filter((s) => s)
+				.join('/');
 
-		buffered = '';
+			buffered = 0;
+			continue;
+		}
 
+		// if `value` is undefined, it means this is an optional or rest parameter
 		if (value === undefined) {
-			// if `value` is undefined, it means this is
-			// an optional or rest parameter
 			if (param.rest) result[param.name] = '';
-		} else {
-			if (param.matcher && !matchers[param.matcher](value)) {
-				// in the `/[[a=b]]/[[c=d]]` case, if the value didn't satisfy the `b` matcher,
-				// try again with the next segment by shifting values rightwards
-				if (param.optional && param.chained) {
-					// @ts-expect-error TypeScript is... wrong
-					let j = values.indexOf(undefined, i);
-
-					if (j === -1) {
-						// we can't shift values any further, so hang on to this value
-						// so it can be rolled into a subsequent `[...rest]` param
-						const next = params[i + 1];
-						if (next?.rest && next.chained) {
-							buffered = value;
-						} else {
-							return;
-						}
-					}
-
-					while (j >= i) {
-						values[j] = values[j - 1];
-						j -= 1;
-					}
-
-					continue;
-				}
-
-				// otherwise, if the matcher returns `false`, the route did not match
-				return;
-			}
+			continue;
+		}
 
+		if (!param.matcher || matchers[param.matcher](value)) {
 			result[param.name] = value;
+			continue;
 		}
+
+		// in the `/[[a=b]]/...` case, if the value didn't satisfy the matcher,
+		// keep track of the number of skipped optional parameters and continue
+		if (param.optional && param.chained) {
+			buffered++;
+			continue;
+		}
+
+		// otherwise, if the matcher returns `false`, the route did not match
+		return;
 	}
 
 	if (buffered) return;