ambient-display 1.1.11 → 1.1.13

package/build/server/index.js

@@ -1,8 +1,9 @@
-import { r as render, g as get, L as LEGACY_PROPS, f as flush_sync, d as define_property, a as active_reaction, i as is_runes, D as DERIVED, B as BLOCK_EFFECT, b as derived_sources, s as state_unsafe_mutation, c as increment_version, e as DIRTY, h as set_signal_status, C as CLEAN, U as UNOWNED, j as schedule_effect, k as init_operations, l as get_first_child, H as HYDRATION_START, m as get_next_sibling, n as HYDRATION_ERROR, o as HYDRATION_END, p as hydration_failed, q as clear_text_content, t as array_from, u as component_root, v as push, w as setContext, x as pop, y as active_effect, z as BRANCH_EFFECT, A as new_deps, E as untracked_writes, F as set_untracked_writes, M as MAYBE_DIRTY, G as safe_equals, I as set_active_reaction, J as set_active_effect, K as is_array, N as is_passive_event, O as create_text, P as branch, Q as push$1, R as pop$1, S as equals, T as component_context, V as BROWSER, W as readable, X as writable } from './chunks/index2-BA59f76P.js';
-import { d as decode_pathname, h as has_data_suffix, s as strip_data_suffix, a as decode_params, n as normalize_path, b as disable_search, c as add_data_suffix, m as make_trackable, r as resolve } from './chunks/exports-DAjI6ZSp.js';
+import { r as render, L as LEGACY_PROPS, g as get, f as flushSync, d as define_property, i as init_operations, a as get_first_child, H as HYDRATION_START, b as get_next_sibling, c as HYDRATION_ERROR, e as HYDRATION_END, h as hydration_failed, j as clear_text_content, s as safe_equals, k as increment_write_version, l as array_from, m as component_root, n as equals, D as DIRTY, o as set_signal_status, C as CLEAN, U as UNOWNED, p as DERIVED, q as schedule_effect, t as is_passive_event, u as set_active_reaction, v as set_active_effect, w as is_array, x as active_effect, y as active_reaction, z as untracking, A as is_runes, B as BLOCK_EFFECT, E as derived_sources, F as state_unsafe_mutation, G as BRANCH_EFFECT, R as ROOT_EFFECT, I as untracked_writes, J as set_untracked_writes, M as MAYBE_DIRTY, K as create_text, N as branch, O as push, P as setContext, Q as pop, S as push$1, T as component_context, V as pop$1, W as BROWSER, X as readable, Y as writable } from './chunks/index2-DObisaVF.js';
+import { d as decode_pathname, a as decode_params, n as normalize_path, b as disable_search, r as resolve, m as make_trackable } from './chunks/exports-D0QHgeSL.js';
 
 let base = "";
 let assets = base;
+const app_dir = "_app";
 const initial = { base, assets };
 function override(paths) {
   base = paths.base;
@@ -20,6 +21,11 @@ function set_public_env(environment) {
 function set_safe_public_env(environment) {
   safe_public_env = environment;
 }
+function hydration_mismatch(location) {
+  {
+    console.warn(`https://svelte.dev/e/hydration_mismatch`);
+  }
+}
 function source(v, stack) {
   var signal = {
     f: 0,
@@ -27,7 +33,8 @@ function source(v, stack) {
     v,
     reactions: null,
     equals,
-    version: 0
+    rv: 0,
+    wv: 0
   };
   return signal;
 }
@@ -40,7 +47,7 @@ function mutable_source(initial_value, immutable = false) {
   return s;
 }
 function set(source2, value) {
-  if (active_reaction !== null && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT)) !== 0 && // If the source was created locally within the current derived, then
+  if (active_reaction !== null && !untracking && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT)) !== 0 && // If the source was created locally within the current derived, then
   // we allow the mutation.
   (derived_sources === null || !derived_sources.includes(source2))) {
     state_unsafe_mutation();
@@ -49,19 +56,15 @@ function set(source2, value) {
 }
 function internal_set(source2, value) {
   if (!source2.equals(value)) {
+    source2.v;
     source2.v = value;
-    source2.version = increment_version();
+    source2.wv = increment_write_version();
     mark_reactions(source2, DIRTY);
-    if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & BRANCH_EFFECT) === 0) {
-      if (new_deps !== null && new_deps.includes(source2)) {
-        set_signal_status(active_effect, DIRTY);
-        schedule_effect(active_effect);
+    if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
+      if (untracked_writes === null) {
+        set_untracked_writes([source2]);
       } else {
-        if (untracked_writes === null) {
-          set_untracked_writes([source2]);
-        } else {
-          untracked_writes.push(source2);
-        }
+        untracked_writes.push(source2);
       }
     }
   }
@@ -92,11 +95,6 @@ function mark_reactions(signal, status) {
     }
   }
 }
-function hydration_mismatch(location) {
-  {
-    console.warn(`https://svelte.dev/e/hydration_mismatch`);
-  }
-}
 let hydrating = false;
 function set_hydrating(value) {
   hydrating = value;
@@ -167,8 +165,10 @@ function handle_event_propagation(event) {
       current_target.host || null;
       try {
         var delegated = current_target["__" + event_name];
-        if (delegated !== void 0 && !/** @type {any} */
-        current_target.disabled) {
+        if (delegated !== void 0 && (!/** @type {any} */
+        current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+        // -> the target could not have been disabled because it emits the event in the first place
+        event.target === current_target)) {
           if (is_array(delegated)) {
             var [fn, ...data] = delegated;
             fn.apply(current_target, [event, ...data]);
@@ -406,7 +406,7 @@ class Svelte4Component {
       recover: options2.recover
     });
     if (!options2?.props?.$$host || options2.sync === false) {
-      flush_sync();
+      flushSync();
     }
     this.#events = props.$$events;
     for (const key of Object.keys(this.#instance)) {
@@ -520,7 +520,6 @@ function Root($$payload, $$props) {
 }
 const root = asClassComponent(Root);
 const options = {
-  app_dir: "_app",
   app_template_contains_nonce: false,
   csp: { "mode": "auto", "directives": { "upgrade-insecure-requests": false, "block-all-mixed-content": false }, "reportOnly": { "upgrade-insecure-requests": false, "block-all-mixed-content": false } },
   csrf_check_origin: true,
@@ -606,7 +605,7 @@ const options = {
 		<div class="error">
 			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
   },
-  version_hash: "5ekiqj"
+  version_hash: "h937le"
 };
 async function get_hooks() {
   let handle;
@@ -1386,14 +1385,66 @@ function requireCookie () {
 	var __toString = Object.prototype.toString;
 
 	/**
-	 * RegExp to match field-content in RFC 7230 sec 3.2
+	 * RegExp to match cookie-name in RFC 6265 sec 4.1.1
+	 * This refers out to the obsoleted definition of token in RFC 2616 sec 2.2
+	 * which has been replaced by the token definition in RFC 7230 appendix B.
+	 *
+	 * cookie-name       = token
+	 * token             = 1*tchar
+	 * tchar             = "!" / "#" / "$" / "%" / "&" / "'" /
+	 *                     "*" / "+" / "-" / "." / "^" / "_" /
+	 *                     "`" / "|" / "~" / DIGIT / ALPHA
+	 */
+
+	var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+
+	/**
+	 * RegExp to match cookie-value in RFC 6265 sec 4.1.1
+	 *
+	 * cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+	 * cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+	 *                     ; US-ASCII characters excluding CTLs,
+	 *                     ; whitespace DQUOTE, comma, semicolon,
+	 *                     ; and backslash
+	 */
+
+	var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
+
+	/**
+	 * RegExp to match domain-value in RFC 6265 sec 4.1.1
 	 *
-	 * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
-	 * field-vchar   = VCHAR / obs-text
-	 * obs-text      = %x80-FF
+	 * domain-value      = <subdomain>
+	 *                     ; defined in [RFC1034], Section 3.5, as
+	 *                     ; enhanced by [RFC1123], Section 2.1
+	 * <subdomain>       = <label> | <subdomain> "." <label>
+	 * <label>           = <let-dig> [ [ <ldh-str> ] <let-dig> ]
+	 *                     Labels must be 63 characters or less.
+	 *                     'let-dig' not 'letter' in the first char, per RFC1123
+	 * <ldh-str>         = <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+	 * <let-dig-hyp>     = <let-dig> | "-"
+	 * <let-dig>         = <letter> | <digit>
+	 * <letter>          = any one of the 52 alphabetic characters A through Z in
+	 *                     upper case and a through z in lower case
+	 * <digit>           = any one of the ten digits 0 through 9
+	 *
+	 * Keep support for leading dot: https://github.com/jshttp/cookie/issues/173
+	 *
+	 * > (Note that a leading %x2E ("."), if present, is ignored even though that
+	 * character is not permitted, but a trailing %x2E ("."), if present, will
+	 * cause the user agent to ignore the attribute.)
 	 */
 
-	var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+	var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+
+	/**
+	 * RegExp to match path-value in RFC 6265 sec 4.1.1
+	 *
+	 * path-value        = <any CHAR except CTLs or ";">
+	 * CHAR              = %x01-7F
+	 *                     ; defined in RFC 5234 appendix B.1
+	 */
+
+	var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
 
 	/**
 	 * Parse a cookie header.
@@ -1402,107 +1453,128 @@ function requireCookie () {
 	 * The object has the various cookies as keys(names) => values
 	 *
 	 * @param {string} str
-	 * @param {object} [options]
+	 * @param {object} [opt]
 	 * @return {object}
 	 * @public
 	 */
 
-	function parse(str, options) {
+	function parse(str, opt) {
 	  if (typeof str !== 'string') {
 	    throw new TypeError('argument str must be a string');
 	  }
 
 	  var obj = {};
-	  var opt = options || {};
-	  var dec = opt.decode || decode;
+	  var len = str.length;
+	  // RFC 6265 sec 4.1.1, RFC 2616 2.2 defines a cookie name consists of one char minimum, plus '='.
+	  if (len < 2) return obj;
 
+	  var dec = (opt && opt.decode) || decode;
 	  var index = 0;
-	  while (index < str.length) {
-	    var eqIdx = str.indexOf('=', index);
+	  var eqIdx = 0;
+	  var endIdx = 0;
 
-	    // no more cookie pairs
-	    if (eqIdx === -1) {
-	      break
-	    }
+	  do {
+	    eqIdx = str.indexOf('=', index);
+	    if (eqIdx === -1) break; // No more cookie pairs.
 
-	    var endIdx = str.indexOf(';', index);
+	    endIdx = str.indexOf(';', index);
 
 	    if (endIdx === -1) {
-	      endIdx = str.length;
-	    } else if (endIdx < eqIdx) {
+	      endIdx = len;
+	    } else if (eqIdx > endIdx) {
 	      // backtrack on prior semicolon
 	      index = str.lastIndexOf(';', eqIdx - 1) + 1;
-	      continue
+	      continue;
 	    }
 
-	    var key = str.slice(index, eqIdx).trim();
+	    var keyStartIdx = startIndex(str, index, eqIdx);
+	    var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
+	    var key = str.slice(keyStartIdx, keyEndIdx);
 
 	    // only assign once
-	    if (undefined === obj[key]) {
-	      var val = str.slice(eqIdx + 1, endIdx).trim();
+	    if (!obj.hasOwnProperty(key)) {
+	      var valStartIdx = startIndex(str, eqIdx + 1, endIdx);
+	      var valEndIdx = endIndex(str, endIdx, valStartIdx);
 
-	      // quoted values
-	      if (val.charCodeAt(0) === 0x22) {
-	        val = val.slice(1, -1);
+	      if (str.charCodeAt(valStartIdx) === 0x22 /* " */ && str.charCodeAt(valEndIdx - 1) === 0x22 /* " */) {
+	        valStartIdx++;
+	        valEndIdx--;
 	      }
 
+	      var val = str.slice(valStartIdx, valEndIdx);
 	      obj[key] = tryDecode(val, dec);
 	    }
 
 	    index = endIdx + 1;
-	  }
+	  } while (index < len);
 
 	  return obj;
 	}
 
+	function startIndex(str, index, max) {
+	  do {
+	    var code = str.charCodeAt(index);
+	    if (code !== 0x20 /*   */ && code !== 0x09 /* \t */) return index;
+	  } while (++index < max);
+	  return max;
+	}
+
+	function endIndex(str, index, min) {
+	  while (index > min) {
+	    var code = str.charCodeAt(--index);
+	    if (code !== 0x20 /*   */ && code !== 0x09 /* \t */) return index + 1;
+	  }
+	  return min;
+	}
+
 	/**
 	 * Serialize data into a cookie header.
 	 *
-	 * Serialize the a name value pair into a cookie string suitable for
-	 * http headers. An optional options object specified cookie parameters.
+	 * Serialize a name value pair into a cookie string suitable for
+	 * http headers. An optional options object specifies cookie parameters.
 	 *
 	 * serialize('foo', 'bar', { httpOnly: true })
 	 *   => "foo=bar; httpOnly"
 	 *
 	 * @param {string} name
 	 * @param {string} val
-	 * @param {object} [options]
+	 * @param {object} [opt]
 	 * @return {string}
 	 * @public
 	 */
 
-	function serialize(name, val, options) {
-	  var opt = options || {};
-	  var enc = opt.encode || encode;
+	function serialize(name, val, opt) {
+	  var enc = (opt && opt.encode) || encodeURIComponent;
 
 	  if (typeof enc !== 'function') {
 	    throw new TypeError('option encode is invalid');
 	  }
 
-	  if (!fieldContentRegExp.test(name)) {
+	  if (!cookieNameRegExp.test(name)) {
 	    throw new TypeError('argument name is invalid');
 	  }
 
 	  var value = enc(val);
 
-	  if (value && !fieldContentRegExp.test(value)) {
+	  if (!cookieValueRegExp.test(value)) {
 	    throw new TypeError('argument val is invalid');
 	  }
 
 	  var str = name + '=' + value;
+	  if (!opt) return str;
 
 	  if (null != opt.maxAge) {
-	    var maxAge = opt.maxAge - 0;
+	    var maxAge = Math.floor(opt.maxAge);
 
-	    if (isNaN(maxAge) || !isFinite(maxAge)) {
+	    if (!isFinite(maxAge)) {
 	      throw new TypeError('option maxAge is invalid')
 	    }
 
-	    str += '; Max-Age=' + Math.floor(maxAge);
+	    str += '; Max-Age=' + maxAge;
 	  }
 
 	  if (opt.domain) {
-	    if (!fieldContentRegExp.test(opt.domain)) {
+	    if (!domainValueRegExp.test(opt.domain)) {
 	      throw new TypeError('option domain is invalid');
 	    }
 
@@ -1510,7 +1582,7 @@ function requireCookie () {
 	  }
 
 	  if (opt.path) {
-	    if (!fieldContentRegExp.test(opt.path)) {
+	    if (!pathValueRegExp.test(opt.path)) {
 	      throw new TypeError('option path is invalid');
 	    }
 
@@ -1541,8 +1613,7 @@ function requireCookie () {
 
 	  if (opt.priority) {
 	    var priority = typeof opt.priority === 'string'
-	      ? opt.priority.toLowerCase()
-	      : opt.priority;
+	      ? opt.priority.toLowerCase() : opt.priority;
 
 	    switch (priority) {
 	      case 'low':
@@ -1597,17 +1668,6 @@ function requireCookie () {
 	    : str
 	}
 
-	/**
-	 * URL-encode value.
-	 *
-	 * @param {string} val
-	 * @returns {string}
-	 */
-
-	function encode (val) {
-	  return encodeURIComponent(val)
-	}
-
 	/**
 	 * Determine if value is a Date.
 	 *
@@ -1616,8 +1676,7 @@ function requireCookie () {
 	 */
 
 	function isDate (val) {
-	  return __toString.call(val) === '[object Date]' ||
-	    val instanceof Date
+	  return __toString.call(val) === '[object Date]';
 	}
 
 	/**
@@ -1976,6 +2035,31 @@ class ActionFailure {
     this.data = data;
   }
 }
+const DATA_SUFFIX = "/__data.json";
+const HTML_DATA_SUFFIX = ".html__data.json";
+function has_data_suffix(pathname) {
+  return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
+}
+function add_data_suffix(pathname) {
+  if (pathname.endsWith(".html")) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
+  return pathname.replace(/\/$/, "") + DATA_SUFFIX;
+}
+function strip_data_suffix(pathname) {
+  if (pathname.endsWith(HTML_DATA_SUFFIX)) {
+    return pathname.slice(0, -HTML_DATA_SUFFIX.length) + ".html";
+  }
+  return pathname.slice(0, -DATA_SUFFIX.length);
+}
+const ROUTE_SUFFIX = "/__route.js";
+function has_resolution_suffix(pathname) {
+  return pathname.endsWith(ROUTE_SUFFIX);
+}
+function add_resolution_suffix(pathname) {
+  return pathname.replace(/\/$/, "") + ROUTE_SUFFIX;
+}
+function strip_resolution_suffix(pathname) {
+  return pathname.slice(0, -ROUTE_SUFFIX.length);
+}
 function json(data, init2) {
   const body2 = JSON.stringify(data);
   const headers2 = new Headers(init2?.headers);
@@ -2431,6 +2515,18 @@ function b64_encode(buffer) {
     )
   );
 }
+function get_relative_path(from, to) {
+  const from_parts = from.split(/[/\\]/);
+  const to_parts = to.split(/[/\\]/);
+  from_parts.pop();
+  while (from_parts[0] === to_parts[0]) {
+    from_parts.shift();
+    to_parts.shift();
+  }
+  let i = from_parts.length;
+  while (i--) from_parts[i] = "..";
+  return from_parts.concat(to_parts).join("/");
+}
 async function load_server_data({ event, state, node, parent }) {
   if (!node?.server) return null;
   let is_tracking = true;
@@ -2557,7 +2653,7 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
         dependency = { response, body: null };
         state.prerendering.dependencies.set(url.pathname, dependency);
       }
-    } else {
+    } else if (url.protocol === "https:" || url.protocol === "http:") {
       const mode = input instanceof Request ? input.mode : init2?.mode ?? "cors";
       if (mode === "no-cors") {
         response = new Response("", {
@@ -2956,9 +3052,6 @@ class BaseProvider {
     if (this.#style_src_needs_csp) {
       this.#style_src.push(source);
     }
-    if (this.#style_src_needs_csp) {
-      this.#style_src.push(source);
-    }
     if (this.#style_src_attr_needs_csp) {
       this.#style_src_attr.push(source);
     }
@@ -3129,6 +3222,119 @@ function create_async_iterator() {
     }
   };
 }
+function exec(match, params, matchers) {
+  const result = {};
+  const values = match.slice(1);
+  const values_needing_match = values.filter((value) => value !== void 0);
+  let buffered = 0;
+  for (let i = 0; i < params.length; i += 1) {
+    const param = params[i];
+    let value = values[i - buffered];
+    if (param.chained && param.rest && buffered) {
+      value = values.slice(i - buffered, i + 1).filter((s2) => s2).join("/");
+      buffered = 0;
+    }
+    if (value === void 0) {
+      if (param.rest) result[param.name] = "";
+      continue;
+    }
+    if (!param.matcher || matchers[param.matcher](value)) {
+      result[param.name] = value;
+      const next_param = params[i + 1];
+      const next_value = values[i + 1];
+      if (next_param && !next_param.rest && next_param.optional && next_value && param.chained) {
+        buffered = 0;
+      }
+      if (!next_param && !next_value && Object.keys(result).length === values_needing_match.length) {
+        buffered = 0;
+      }
+      continue;
+    }
+    if (param.optional && param.chained) {
+      buffered++;
+      continue;
+    }
+    return;
+  }
+  if (buffered) return;
+  return result;
+}
+function generate_route_object(route, url, manifest) {
+  const { errors, layouts, leaf } = route;
+  const nodes = [...errors, ...layouts.map((l) => l?.[1]), leaf[1]].filter((n) => typeof n === "number").map((n) => `'${n}': () => ${create_client_import(manifest._.client.nodes?.[n], url)}`).join(",\n		");
+  return [
+    `{
+	id: ${s(route.id)}`,
+    `errors: ${s(route.errors)}`,
+    `layouts: ${s(route.layouts)}`,
+    `leaf: ${s(route.leaf)}`,
+    `nodes: {
+		${nodes}
+	}
+}`
+  ].join(",\n	");
+}
+function create_client_import(import_path, url) {
+  if (!import_path) return "Promise.resolve({})";
+  if (import_path[0] === "/") {
+    return `import('${import_path}')`;
+  }
+  if (assets !== "") {
+    return `import('${assets}/${import_path}')`;
+  }
+  let path = get_relative_path(url.pathname, `${base}/${import_path}`);
+  if (path[0] !== ".") path = `./${path}`;
+  return `import('${path}')`;
+}
+async function resolve_route(resolved_path, url, manifest) {
+  if (!manifest._.client.routes) {
+    return text("Server-side route resolution disabled", { status: 400 });
+  }
+  let route = null;
+  let params = {};
+  const matchers = await manifest._.matchers();
+  for (const candidate of manifest._.client.routes) {
+    const match = candidate.pattern.exec(resolved_path);
+    if (!match) continue;
+    const matched = exec(match, candidate.params, matchers);
+    if (matched) {
+      route = candidate;
+      params = decode_params(matched);
+      break;
+    }
+  }
+  return create_server_routing_response(route, params, url, manifest).response;
+}
+function create_server_routing_response(route, params, url, manifest) {
+  const headers2 = new Headers({
+    "content-type": "application/javascript; charset=utf-8"
+  });
+  if (route) {
+    const csr_route = generate_route_object(route, url, manifest);
+    const body2 = `${create_css_import(route, url, manifest)}
+export const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
+    return { response: text(body2, { headers: headers2 }), body: body2 };
+  } else {
+    return { response: text("", { headers: headers2 }), body: "" };
+  }
+}
+function create_css_import(route, url, manifest) {
+  const { errors, layouts, leaf } = route;
+  let css = "";
+  for (const node of [...errors, ...layouts.map((l) => l?.[1]), leaf[1]]) {
+    if (typeof node !== "number") continue;
+    const node_css = manifest._.client.css?.[node];
+    for (const css_path of node_css ?? []) {
+      css += `'${assets || base}/${css_path}',`;
+    }
+  }
+  if (!css) return "";
+  return `${create_client_import(
+    /** @type {string} */
+    manifest._.client.start,
+    url
+  )}.then(x => x.load_css([${css}]));`;
+}
 const updated = {
   ...readable(false),
   check: () => false
@@ -3246,17 +3452,13 @@ async function render_response({
     }
     return `${assets$1}/${path}`;
   };
-  if (client.inline?.style) {
-    head += `
-	<style>${client.inline.style}</style>`;
-  }
-  if (inline_styles.size > 0) {
-    const content = Array.from(inline_styles.values()).join("\n");
+  const style = client.inline ? client.inline?.style : Array.from(inline_styles.values()).join("\n");
+  if (style) {
     const attributes = [];
     if (csp.style_needs_nonce) attributes.push(` nonce="${csp.nonce}"`);
-    csp.add_style(content);
+    csp.add_style(style);
     head += `
-	<style${attributes.join("")}>${content}</style>`;
+	<style${attributes.join("")}>${style}</style>`;
   }
   for (const dep of stylesheets) {
     const path = prefixed(dep);
@@ -3302,8 +3504,9 @@ async function render_response({
     ).join("\n			")}`;
   }
   if (page_config.csr) {
+    const route = manifest._.client.routes?.find((r) => r.id === event.route.id) ?? null;
     if (client.uses_env_dynamic_public && state.prerendering) {
-      modulepreloads.add(`${options2.app_dir}/env.js`);
+      modulepreloads.add(`${app_dir}/env.js`);
     }
     if (!client.inline) {
       const included_modulepreloads = Array.from(modulepreloads, (dep) => prefixed(dep)).filter(
@@ -3320,6 +3523,13 @@ async function render_response({
         }
       }
     }
+    if (manifest._.client.routes && state.prerendering && !state.prerendering.fallback) {
+      const pathname = add_resolution_suffix(event.url.pathname);
+      state.prerendering.dependencies.set(
+        pathname,
+        create_server_routing_response(route, event.params, new URL(pathname, event.url), manifest)
+      );
+    }
     const blocks = [];
     const load_env_eagerly = client.uses_env_dynamic_public && state.prerendering;
     const properties = [`base: ${base_expression}`];
@@ -3375,7 +3585,15 @@ async function render_response({
       if (status !== 200) {
         hydrate.push(`status: ${status}`);
       }
-      if (options2.embedded) {
+      if (manifest._.client.routes) {
+        if (route) {
+          const stringified = generate_route_object(route, event.url, manifest).replaceAll(
+            "\n",
+            "\n							"
+          );
+          hydrate.push(`params: ${uneval(event.params)}`, `server_route: ${stringified}`);
+        }
+      } else if (options2.embedded) {
         hydrate.push(`params: ${uneval(event.params)}`, `route: ${s(event.route)}`);
       }
       const indent = "	".repeat(load_env_eagerly ? 7 : 6);
@@ -3395,7 +3613,7 @@ ${indent}}`);
 						app.start(${args.join(", ")})
 					});`;
     if (load_env_eagerly) {
-      blocks.push(`import(${s(`${base$1}/${options2.app_dir}/env.js`)}).then(({ env }) => {
+      blocks.push(`import(${s(`${base$1}/${app_dir}/env.js`)}).then(({ env }) => {
 						${global}.env = env;
 
 						${boot.replace(/\n/g, "\n	")}
@@ -3899,7 +4117,10 @@ async function render_page(event, page, options2, manifest, state, resolve_opts)
         status = action_result.status;
       }
     }
-    const should_prerender_data = nodes.some((node) => node?.server?.load);
+    const should_prerender_data = nodes.some(
+      // prerender in case of trailingSlash because the client retrieves that value from the server
+      (node) => node?.server?.load || node?.server?.trailingSlash !== void 0
+    );
     const data_pathname = add_data_suffix(event.url.pathname);
     const should_prerender = get_option(nodes, "prerender") ?? false;
     if (should_prerender) {
@@ -4097,43 +4318,6 @@ async function render_page(event, page, options2, manifest, state, resolve_opts)
     });
   }
 }
-function exec(match, params, matchers) {
-  const result = {};
-  const values = match.slice(1);
-  const values_needing_match = values.filter((value) => value !== void 0);
-  let buffered = 0;
-  for (let i = 0; i < params.length; i += 1) {
-    const param = params[i];
-    let value = values[i - buffered];
-    if (param.chained && param.rest && buffered) {
-      value = values.slice(i - buffered, i + 1).filter((s2) => s2).join("/");
-      buffered = 0;
-    }
-    if (value === void 0) {
-      if (param.rest) result[param.name] = "";
-      continue;
-    }
-    if (!param.matcher || matchers[param.matcher](value)) {
-      result[param.name] = value;
-      const next_param = params[i + 1];
-      const next_value = values[i + 1];
-      if (next_param && !next_param.rest && next_param.optional && next_value && param.chained) {
-        buffered = 0;
-      }
-      if (!next_param && !next_value && Object.keys(result).length === values_needing_match.length) {
-        buffered = 0;
-      }
-      continue;
-    }
-    if (param.optional && param.chained) {
-      buffered++;
-      continue;
-    }
-    return;
-  }
-  if (buffered) return;
-  return result;
-}
 const INVALID_COOKIE_CHARACTER_REGEX = /[\x00-\x1F\x7F()<>@,;:"/[\]?={} \t]/;
 function validate_options(options2) {
   if (options2?.path === void 0) {
@@ -4157,7 +4341,7 @@ function get_cookies(request, url, trailing_slash) {
     // sufficient to do so.
     /**
      * @param {string} name
-     * @param {import('cookie').CookieParseOptions} opts
+     * @param {import('cookie').CookieParseOptions} [opts]
      */
     get(name, opts) {
       const c = new_cookies[name];
@@ -4169,7 +4353,7 @@ function get_cookies(request, url, trailing_slash) {
       return cookie;
     },
     /**
-     * @param {import('cookie').CookieParseOptions} opts
+     * @param {import('cookie').CookieParseOptions} [opts]
      */
     getAll(opts) {
       const cookies2 = cookieExports.parse(header, { decode: opts?.decode });
@@ -4323,6 +4507,9 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
           }
           return await fetch(request);
         }
+        if (manifest._.prerendered_routes.has(decoded) || decoded.at(-1) === "/" && manifest._.prerendered_routes.has(decoded.slice(0, -1))) {
+          return await fetch(request);
+        }
         if (credentials !== "omit") {
           const cookie = get_cookie_header(url, request.headers.get("cookie"));
           if (cookie) {
@@ -4429,49 +4616,53 @@ async function respond(request, options2, manifest, state) {
   if (options2.hash_routing && url.pathname !== base + "/" && url.pathname !== "/[fallback]") {
     return text("Not found", { status: 404 });
   }
-  let rerouted_path;
+  let invalidated_data_nodes;
+  const is_route_resolution_request = has_resolution_suffix(url.pathname);
+  const is_data_request = has_data_suffix(url.pathname);
+  if (is_route_resolution_request) {
+    url.pathname = strip_resolution_suffix(url.pathname);
+  } else if (is_data_request) {
+    url.pathname = strip_data_suffix(url.pathname) + (url.searchParams.get(TRAILING_SLASH_PARAM) === "1" ? "/" : "") || "/";
+    url.searchParams.delete(TRAILING_SLASH_PARAM);
+    invalidated_data_nodes = url.searchParams.get(INVALIDATED_PARAM)?.split("").map((node) => node === "1");
+    url.searchParams.delete(INVALIDATED_PARAM);
+  }
+  let resolved_path;
   try {
-    rerouted_path = options2.hooks.reroute({ url: new URL(url) }) ?? url.pathname;
+    resolved_path = await options2.hooks.reroute({ url: new URL(url) }) ?? url.pathname;
   } catch {
     return text("Internal Server Error", {
       status: 500
     });
   }
-  let decoded;
   try {
-    decoded = decode_pathname(rerouted_path);
+    resolved_path = decode_pathname(resolved_path);
   } catch {
     return text("Malformed URI", { status: 400 });
   }
   let route = null;
   let params = {};
   if (base && !state.prerendering?.fallback) {
-    if (!decoded.startsWith(base)) {
+    if (!resolved_path.startsWith(base)) {
       return text("Not found", { status: 404 });
     }
-    decoded = decoded.slice(base.length) || "/";
+    resolved_path = resolved_path.slice(base.length) || "/";
+  }
+  if (is_route_resolution_request) {
+    return resolve_route(resolved_path, new URL(request.url), manifest);
   }
-  if (decoded === `/${options2.app_dir}/env.js`) {
+  if (resolved_path === `/${app_dir}/env.js`) {
     return get_public_env(request);
   }
-  if (decoded.startsWith(`/${options2.app_dir}`)) {
+  if (resolved_path.startsWith(`/${app_dir}`)) {
     const headers22 = new Headers();
     headers22.set("cache-control", "public, max-age=0, must-revalidate");
     return text("Not found", { status: 404, headers: headers22 });
   }
-  const is_data_request = has_data_suffix(decoded);
-  let invalidated_data_nodes;
-  if (is_data_request) {
-    decoded = strip_data_suffix(decoded) || "/";
-    url.pathname = strip_data_suffix(url.pathname) + (url.searchParams.get(TRAILING_SLASH_PARAM) === "1" ? "/" : "") || "/";
-    url.searchParams.delete(TRAILING_SLASH_PARAM);
-    invalidated_data_nodes = url.searchParams.get(INVALIDATED_PARAM)?.split("").map((node) => node === "1");
-    url.searchParams.delete(INVALIDATED_PARAM);
-  }
   if (!state.prerendering?.fallback) {
     const matchers = await manifest._.matchers();
     for (const candidate of manifest._.routes) {
-      const match = candidate.pattern.exec(decoded);
+      const match = candidate.pattern.exec(resolved_path);
       if (!match) continue;
       const matched = exec(match, candidate.params, matchers);
       if (matched) {
@@ -4747,11 +4938,9 @@ async function respond(request, options2, manifest, state) {
         return response;
       }
       if (state.error && event2.isSubRequest) {
-        return await fetch(request, {
-          headers: {
-            "x-sveltekit-error": "true"
-          }
-        });
+        const headers22 = new Headers(request.headers);
+        headers22.set("x-sveltekit-error", "true");
+        return await fetch(request, { headers: headers22 });
       }
       if (state.error) {
         return text("Internal Server Error", {