@sveltejs/kit 2.62.0 → 3.0.0-next.0

package/src/runtime/client/utils.js

@@ -1,7 +1,7 @@
 import { BROWSER, DEV } from 'esm-env';
 import { writable } from 'svelte/store';
 import { assets } from '$app/paths';
-import { version } from '__sveltekit/environment';
+import { version } from '$app/env';
 import { noop } from '../../utils/functions.js';
 import { PRELOAD_PRIORITIES } from './constants.js';
 
@@ -35,12 +35,12 @@ const warned = new WeakSet();
 /** @typedef {keyof typeof valid_link_options} LinkOptionName */
 
 const valid_link_options = /** @type {const} */ ({
-	'preload-code': ['', 'off', 'false', 'tap', 'hover', 'viewport', 'eager'],
-	'preload-data': ['', 'off', 'false', 'tap', 'hover'],
-	keepfocus: ['', 'true', 'off', 'false'],
-	noscroll: ['', 'true', 'off', 'false'],
-	reload: ['', 'true', 'off', 'false'],
-	replacestate: ['', 'true', 'off', 'false']
+	'preload-code': ['', 'false', 'tap', 'hover', 'viewport', 'eager'],
+	'preload-data': ['', 'false', 'tap', 'hover'],
+	keepfocus: ['', 'true', 'false'],
+	noscroll: ['', 'true', 'false'],
+	reload: ['', 'true', 'false'],
+	replacestate: ['', 'true', 'false']
 });
 
 /**
@@ -194,7 +194,6 @@ export function get_router_options(element) {
 			case '':
 			case 'true':
 				return true;
-			case 'off':
 			case 'false':
 				return false;
 			default:
@@ -203,8 +202,8 @@ export function get_router_options(element) {
 	}
 
 	return {
-		preload_code: levels[preload_code ?? 'off'],
-		preload_data: levels[preload_data ?? 'off'],
+		preload_code: levels[preload_code ?? 'false'],
+		preload_data: levels[preload_data ?? 'false'],
 		keepfocus: get_option_state(keepfocus),
 		noscroll: get_option_state(noscroll),
 		reload: get_option_state(reload),
@@ -271,7 +270,6 @@ export function create_updated_store() {
 		try {
 			const res = await fetch(`${assets}/${__SVELTEKIT_APP_VERSION_FILE__}`, {
 				headers: {
-					pragma: 'no-cache',
 					'cache-control': 'no-cache'
 				}
 			});

package/src/runtime/components/{svelte-5/layout.svelte → layout.svelte}

@@ -1,5 +1,5 @@
 <script>
-  let { children } = $props();
+	const { children } = $props();
 </script>
 
 {@render children()}

package/src/runtime/form-utils.js

@@ -1,4 +1,3 @@
-/** @import { RemoteForm } from '@sveltejs/kit' */
 /** @import { BinaryFormMeta, InternalRemoteFormIssue } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 
@@ -146,7 +145,10 @@ export async function deserialize_binary_form(request) {
 		throw deserialize_error('no body');
 	}
 
-	const reader = request.body.getReader();
+	// TODO: remove this workaround once we upgrade to TS 6.0
+	const reader = /** @type {ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>} */ (
+		request.body.getReader()
+	);
 
 	/** @type {Array<Promise<Uint8Array<ArrayBuffer> | undefined>>} */
 	const chunks = [];
@@ -858,42 +860,3 @@ export function build_path_string(path) {
 
 	return result;
 }
-
-/**
- * @param {RemoteForm<any, any>} instance
- * @deprecated remove in 3.0
- */
-export function throw_on_old_property_access(instance) {
-	Object.defineProperty(instance, 'field', {
-		value: (/** @type {string} */ name) => {
-			const new_name = name.endsWith('[]') ? name.slice(0, -2) : name;
-			throw new Error(
-				`\`form.field\` has been removed: Instead of \`<input name={form.field('${name}')} />\` do \`<input {...form.fields.${new_name}.as(type)} />\``
-			);
-		}
-	});
-
-	for (const property of ['input', 'issues']) {
-		Object.defineProperty(instance, property, {
-			get() {
-				const new_name = property === 'issues' ? 'issues' : 'value';
-				return new Proxy(
-					{},
-					{
-						get(_, prop) {
-							const prop_string = typeof prop === 'string' ? prop : String(prop);
-							const old =
-								prop_string.includes('[') || prop_string.includes('.')
-									? `['${prop_string}']`
-									: `.${prop_string}`;
-							const replacement = `.${prop_string}.${new_name}()`;
-							throw new Error(
-								`\`form.${property}\` has been removed: Instead of \`form.${property}${old}\` write \`form.fields${replacement}\``
-							);
-						}
-					}
-				);
-			}
-		});
-	}
-}

package/src/runtime/server/cookie.js

@@ -4,9 +4,6 @@ import { normalize_path, resolve } from '../../utils/url.js';
 import { add_data_suffix } from '../pathname.js';
 import { text_encoder } from '../utils.js';
 
-// eslint-disable-next-line no-control-regex -- control characters are invalid in cookie names
-const INVALID_COOKIE_CHARACTER_REGEX = /[\x00-\x1F\x7F()<>@,;:"/[\]?={} \t]/;
-
 /**
  * Tracks all cookies set during dev mode so we can emit warnings
  * when we detect that there's likely cookie misusage due to wrong paths
@@ -20,14 +17,6 @@ const cookie_paths = {};
  */
 const MAX_COOKIE_SIZE = 4129;
 
-// TODO 3.0 remove this check
-/** @param {import('./page/types.js').Cookie['options']} options */
-function validate_options(options) {
-	if (options?.path === undefined) {
-		throw new Error('You must specify a `path` when setting, deleting or serializing cookies');
-	}
-}
-
 /**
  * Generates a unique key for a cookie based on its domain, path, and name in
  * the format: `<domain>/<path>?<name>`.
@@ -49,7 +38,9 @@ function generate_cookie_key(domain, path, name) {
  */
 export function get_cookies(request, url) {
 	const header = request.headers.get('cookie') ?? '';
-	const initial_cookies = parse(header, { decode: (value) => value });
+	const initial_cookies = /** @type {Record<string, string>} */ (
+		parse(header, { decode: (value) => value })
+	);
 
 	/** @type {string | undefined} */
 	let normalized_url;
@@ -57,9 +48,10 @@ export function get_cookies(request, url) {
 	/** @type {Map<string, import('./page/types.js').Cookie>} */
 	const new_cookies = new Map();
 
-	/** @type {import('cookie').CookieSerializeOptions} */
+	/** @type {import('cookie').SerializeOptions} */
 	const defaults = {
 		httpOnly: true,
+		path: '/',
 		sameSite: 'lax',
 		secure: url.hostname === 'localhost' && url.protocol === 'http:' ? false : true
 	};
@@ -73,7 +65,7 @@ export function get_cookies(request, url) {
 
 		/**
 		 * @param {string} name
-		 * @param {import('cookie').CookieParseOptions} [opts]
+		 * @param {import('cookie').ParseOptions} [opts]
 		 */
 		get(name, opts) {
 			// Look for the most specific matching cookie from new_cookies
@@ -115,7 +107,7 @@ export function get_cookies(request, url) {
 		},
 
 		/**
-		 * @param {import('cookie').CookieParseOptions} [opts]
+		 * @param {import('cookie').ParseOptions} [opts]
 		 */
 		getAll(opts) {
 			const cookies = parse(header, { decode: opts?.decode });
@@ -142,47 +134,37 @@ export function get_cookies(request, url) {
 				cookies[c.name] = c.value;
 			}
 
-			return Object.entries(cookies).map(([name, value]) => ({ name, value }));
+			return /** @type {Array<{ name: string; value: string }>} */ (
+				Object.entries(cookies)
+					.filter(([, value]) => value != null)
+					.map(([name, value]) => ({ name, value }))
+			);
 		},
 
 		/**
 		 * @param {string} name
 		 * @param {string} value
-		 * @param {import('./page/types.js').Cookie['options']} options
+		 * @param {import('cookie').SerializeOptions} options
 		 */
 		set(name, value, options) {
-			// TODO: remove this check in 3.0
-			const illegal_characters = name.match(INVALID_COOKIE_CHARACTER_REGEX);
-			if (illegal_characters) {
-				console.warn(
-					`The cookie name "${name}" will be invalid in SvelteKit 3.0 as it contains ${illegal_characters.join(
-						' and '
-					)}. See RFC 2616 for more details https://datatracker.ietf.org/doc/html/rfc2616#section-2.2`
-				);
-			}
-
-			validate_options(options);
 			set_internal(name, value, { ...defaults, ...options });
 		},
 
 		/**
 		 * @param {string} name
-		 *  @param {import('./page/types.js').Cookie['options']} options
+		 * @param {import('cookie').SerializeOptions} options
 		 */
 		delete(name, options) {
-			validate_options(options);
 			cookies.set(name, '', { ...options, maxAge: 0 });
 		},
 
 		/**
 		 * @param {string} name
 		 * @param {string} value
-		 *  @param {import('./page/types.js').Cookie['options']} options
+		 * @param {import('cookie').SerializeOptions} options
 		 */
 		serialize(name, value, options) {
-			validate_options(options);
-
-			let path = options.path;
+			let path = options.path ?? '/';
 
 			if (!options.domain || options.domain === url.hostname) {
 				if (!normalized_url) {
@@ -217,7 +199,9 @@ export function get_cookies(request, url) {
 
 		// explicit header has highest precedence
 		if (header) {
-			const parsed = parse(header, { decode: (value) => value });
+			const parsed = /** @type {Record<string, string>} */ (
+				parse(header, { decode: (value) => value })
+			);
 			for (const name in parsed) {
 				combined_cookies[name] = parsed[name];
 			}
@@ -234,7 +218,7 @@ export function get_cookies(request, url) {
 	/**
 	 * @param {string} name
 	 * @param {string} value
-	 * @param {import('./page/types.js').Cookie['options']} options
+	 * @param {import('cookie').SerializeOptions} options
 	 */
 	function set_internal(name, value, options) {
 		if (!normalized_url) {
@@ -242,7 +226,7 @@ export function get_cookies(request, url) {
 			return;
 		}
 
-		let path = options.path;
+		let path = options.path ?? '/';
 
 		if (!options.domain || options.domain === url.hostname) {
 			path = resolve(normalized_url, path);

package/src/runtime/server/env_module.js

@@ -1,7 +1,8 @@
-import { public_env } from '../shared-server.js';
+import * as devalue from 'devalue';
+import { rendered_env } from '__sveltekit/env';
 
 /** @type {string} */
-let body;
+let payload;
 
 /** @type {string} */
 let etag;
@@ -14,7 +15,10 @@ let headers;
  * @returns {Response}
  */
 export function get_public_env(request) {
-	body ??= `export const env=${JSON.stringify(public_env)}`;
+	const env = rendered_env;
+	const script = request.url.endsWith('.script.js');
+
+	payload ??= devalue.uneval(env);
 	etag ??= `W/${Date.now()}`;
 	headers ??= new Headers({
 		'content-type': 'application/javascript; charset=utf-8',
@@ -25,5 +29,9 @@ export function get_public_env(request) {
 		return new Response(undefined, { status: 304, headers });
 	}
 
-	return new Response(body, { headers });
+	if (script) {
+		return new Response(`globalThis.__sveltekit_sw={env:${payload}}`, { headers });
+	}
+
+	return new Response(`export const env=${payload}`, { headers });
 }

package/src/runtime/server/fetch.js

@@ -1,6 +1,5 @@
-import * as set_cookie_parser from 'set-cookie-parser';
+import { parseSetCookie } from 'cookie';
 import { noop } from '../../utils/functions.js';
-import { get_set_cookies } from '../../utils/http.js';
 import { respond } from './respond.js';
 import * as paths from '$app/paths/internal/server';
 import { read_implementation } from '__sveltekit/server';
@@ -83,9 +82,8 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 
 				// handle fetch requests for static assets. e.g. prebaked data, etc.
 				// we need to support everything the browser's fetch supports
-				const prefix = paths.assets || paths.base;
 				const filename = (
-					decoded.startsWith(prefix) ? decoded.slice(prefix.length) : decoded
+					decoded.startsWith(paths.assets) ? decoded.slice(paths.assets.length) : decoded
 				).slice(1);
 				const filename_html = `${filename}/index.html`; // path may also match path/index.html
 
@@ -153,18 +151,16 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 
 				const response = await internal_fetch(request, options, manifest, state);
 
-				for (const str of get_set_cookies(response.headers)) {
-					const { name, value, ...options } = set_cookie_parser.parseString(str, {
-						decodeValues: false
-					});
+				for (const str of response.headers.getSetCookie()) {
+					const { name, value, ...options } = parseSetCookie(str, { decode: (v) => v });
 
 					const path = options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
 
 					// options.sameSite is string, something more specific is required - type cast is safe
-					set_internal(name, value, {
+					set_internal(name, /** @type {string} */ (value), {
 						path,
 						encode: (value) => value,
-						.../** @type {import('cookie').CookieSerializeOptions} */ (options)
+						.../** @type {import('cookie').SerializeOptions} */ (options)
 					});
 				}
 

package/src/runtime/server/index.js

@@ -1,13 +1,10 @@
-/** @import { PromiseWithResolvers } from '../../utils/promise.js' */
 import { noop } from '../../utils/functions.js';
-import { with_resolvers } from '../../utils/promise.js';
 import { IN_WEBCONTAINER } from './constants.js';
 import { respond } from './respond.js';
-import { set_private_env, set_public_env } from '../shared-server.js';
 import { options, get_hooks } from '__SERVER__/internal.js';
-import { filter_env } from '../../utils/env.js';
 import { format_server_error } from './utils.js';
 import { set_read_implementation, set_manifest } from '__sveltekit/server';
+import { set_env } from '__sveltekit/env';
 import { set_app } from './app.js';
 
 /** @type {Promise<any>} */
@@ -36,7 +33,9 @@ export class Server {
 
 			/** @type {typeof respond} */
 			this.respond = async (...args) => {
-				const { promise, resolve } = /** @type {PromiseWithResolvers<void>} */ (with_resolvers());
+				const { promise, resolve } = /** @type {PromiseWithResolvers<void>} */ (
+					Promise.withResolvers()
+				);
 
 				const previous = current;
 				current = promise;
@@ -58,10 +57,7 @@ export class Server {
 		// been done already.
 
 		// set env, in case it's used in initialisation
-		const { env_public_prefix, env_private_prefix } = this.#options;
-
-		set_private_env(filter_env(env, env_private_prefix, env_public_prefix));
-		set_public_env(filter_env(env, env_public_prefix, env_private_prefix));
+		set_env(env);
 
 		if (read) {
 			// Wrap the read function to handle MaybePromise<ReadableStream>

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

@@ -8,7 +8,6 @@ import { serialize_data } from './serialize_data.js';
 import { s } from '../../../utils/misc.js';
 import { Csp } from './csp.js';
 import { uneval_action_response } from './actions.js';
-import { public_env } from '../../shared-server.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { SCHEME } from '../../../utils/url.js';
 import { create_server_routing_response, generate_route_object } from './server_routing.js';
@@ -23,6 +22,7 @@ import {
 } from '../utils.js';
 import { create_remote_key } from '../../shared.js';
 import { get_status } from '../../../utils/error.js';
+import * as env from '__sveltekit/env';
 
 // TODO rename this function/module
 
@@ -293,7 +293,7 @@ export async function render_response({
 		}
 	}
 
-	const head = new Head(rendered.head, !!state.prerendering);
+	const head = new Head(rendered.head);
 	let body = rendered.html;
 
 	/** @param {string} path */
@@ -331,7 +331,7 @@ export async function render_response({
 			// include them in disabled state so that Vite can detect them and doesn't try to add them
 			attributes.push('disabled', 'media="(max-width: 0)"');
 		} else {
-			if (resolve_opts.preload({ type: 'css', path })) {
+			if (options.link_header_preload && resolve_opts.preload({ type: 'css', path })) {
 				link_headers.add(`<${encodeURI(path)}>; rel="preload"; as="style"; nopush`);
 			}
 		}
@@ -345,11 +345,18 @@ export async function render_response({
 		if (resolve_opts.preload({ type: 'font', path })) {
 			const ext = dep.slice(dep.lastIndexOf('.') + 1);
 
-			head.add_link_tag(path, ['rel="preload"', 'as="font"', `type="font/${ext}"`, 'crossorigin']);
-
-			link_headers.add(
-				`<${encodeURI(path)}>; rel="preload"; as="font"; type="font/${ext}"; crossorigin; nopush`
-			);
+			if (options.link_header_preload && !state.prerendering) {
+				link_headers.add(
+					`<${encodeURI(path)}>; rel="preload"; as="font"; type="font/${ext}"; crossorigin; nopush`
+				);
+			} else {
+				head.add_link_tag(path, [
+					'rel="preload"',
+					'as="font"',
+					`type="font/${ext}"`,
+					'crossorigin'
+				]);
+			}
 		}
 	}
 
@@ -376,15 +383,19 @@ export async function render_response({
 				(path) => resolve_opts.preload({ type: 'js', path })
 			);
 
-			for (const path of included_modulepreloads) {
-				// see the kit.output.preloadStrategy option for details on why we have multiple options here
-				link_headers.add(`<${encodeURI(path)}>; rel="modulepreload"; nopush`);
+			/** @type {(path: string) => void} */
+			let add_preload;
 
-				if (options.preload_strategy !== 'modulepreload') {
-					head.add_script_preload(path);
-				} else {
-					head.add_link_tag(path, ['rel="modulepreload"']);
-				}
+			// see the kit.output.preloadStrategy option for details on why we have multiple options here
+			if (options.link_header_preload && !state.prerendering) {
+				add_preload = (path) =>
+					link_headers.add(`<${encodeURI(path)}>; rel="modulepreload"; nopush`);
+			} else {
+				add_preload = (path) => head.add_link_tag(path, ['rel="modulepreload"']);
+			}
+
+			for (const path of included_modulepreloads) {
+				add_preload(path);
 			}
 		}
 
@@ -400,11 +411,11 @@ export async function render_response({
 
 		const blocks = [];
 
-		// when serving a prerendered page in an app that uses $env/dynamic/public, we must
+		// when serving a prerendered page in an app that uses $app/env/public, we must
 		// import the env.js module so that it evaluates before any user code can evaluate.
 		// TODO revert to using top-level await once https://bugs.webkit.org/show_bug.cgi?id=242740 is fixed
 		// https://github.com/sveltejs/kit/pull/11601
-		const load_env_eagerly = client.uses_env_dynamic_public && state.prerendering;
+		const load_env_eagerly = client.uses_env_dynamic_public && state.prerendering; // TODO implement uses_env_dynamic_public
 
 		const properties = [`base: ${base_expression}`];
 
@@ -413,7 +424,7 @@ export async function render_response({
 		}
 
 		if (client.uses_env_dynamic_public) {
-			properties.push(`env: ${load_env_eagerly ? 'null' : s(public_env)}`);
+			properties.push(`env: ${load_env_eagerly ? 'null' : devalue.uneval(env.rendered_env)}`);
 		}
 
 		if (chunks) {
@@ -667,7 +678,7 @@ export async function render_response({
 			headers.set('content-security-policy-report-only', report_only_header);
 		}
 
-		if (link_headers.size) {
+		if (options.link_header_preload && link_headers.size) {
 			headers.set('link', Array.from(link_headers).join(', '));
 		}
 	}
@@ -677,7 +688,7 @@ export async function render_response({
 		body,
 		assets,
 		nonce: /** @type {string} */ (csp.nonce),
-		env: public_env
+		env: env.explicit_public_env
 	});
 
 	// TODO flush chunks as early as we can
@@ -734,32 +745,26 @@ export async function render_response({
 
 class Head {
 	#rendered;
-	#prerendering;
 	/** @type {string[]} */
 	#http_equiv = [];
 	/** @type {string[]} */
 	#link_tags = [];
 	/** @type {string[]} */
-	#script_preloads = [];
-	/** @type {string[]} */
 	#style_tags = [];
 	/** @type {string[]} */
 	#stylesheet_links = [];
 
 	/**
 	 * @param {string} rendered
-	 * @param {boolean} prerendering
 	 */
-	constructor(rendered, prerendering) {
+	constructor(rendered) {
 		this.#rendered = rendered;
-		this.#prerendering = prerendering;
 	}
 
 	build() {
 		return [
 			...this.#http_equiv,
 			...this.#link_tags,
-			...this.#script_preloads,
 			this.#rendered,
 			...this.#style_tags,
 			...this.#stylesheet_links
@@ -784,25 +789,16 @@ class Head {
 		this.#stylesheet_links.push(`<link href="${href}" ${attributes.join(' ')}>`);
 	}
 
-	/** @param {string} href */
-	add_script_preload(href) {
-		this.#script_preloads.push(
-			`<link rel="preload" as="script" crossorigin="anonymous" href="${href}">`
-		);
-	}
-
 	/**
 	 * @param {string} href
 	 * @param {string[]} attributes
 	 */
 	add_link_tag(href, attributes) {
-		if (!this.#prerendering) return;
 		this.#link_tags.push(`<link href="${href}" ${attributes.join(' ')}>`);
 	}
 
 	/** @param {string} tag */
 	add_http_equiv(tag) {
-		if (!this.#prerendering) return;
 		this.#http_equiv.push(tag);
 	}
 }

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

@@ -1,4 +1,4 @@
-import { CookieSerializeOptions } from 'cookie';
+import { SerializeOptions } from 'cookie';
 import {
 	CspDirectives,
 	ServerDataNode,
@@ -39,7 +39,9 @@ export interface CspOpts {
 export interface Cookie {
 	name: string;
 	value: string;
-	options: CookieSerializeOptions & { path: string };
+	options: SerializeOptions & {
+		path: string;
+	};
 }
 
 export type ServerDataSerializer = {

package/src/runtime/server/respond.js

@@ -8,7 +8,7 @@ import { is_endpoint_request, render_endpoint } from './endpoint.js';
 import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
-import { get_set_cookies, is_form_content_type } from '../../utils/http.js';
+import { is_form_content_type } from '../../utils/http.js';
 import {
 	handle_fatal_error,
 	has_prerendered_path,
@@ -317,7 +317,7 @@ export async function internal_respond(request, options, manifest, state) {
 		return resolve_route(resolved_path, new URL(request.url), manifest);
 	}
 
-	if (resolved_path === `/${app_dir}/env.js`) {
+	if (resolved_path === `/${app_dir}/env.js` || resolved_path === `/${app_dir}/env.script.js`) {
 		return get_public_env(request);
 	}
 
@@ -517,7 +517,7 @@ export async function internal_respond(request, options, manifest, state) {
 					if (value) headers.set(key, value);
 				}
 
-				for (const cookie of get_set_cookies(response.headers)) {
+				for (const cookie of response.headers.getSetCookie()) {
 					headers.append('set-cookie', cookie);
 				}
 

package/src/runtime/server/utils.js

@@ -9,6 +9,7 @@ import { negotiate } from '../../utils/http.js';
 import { fix_stack_trace } from '../shared-server.js';
 import { ENDPOINT_METHODS } from '../../constants.js';
 import { escape_html } from '../../utils/escape.js';
+import * as path from '../../utils/path.js';
 
 /**
  * @param {Partial<Record<import('types').HttpMethod, any>>} mod
@@ -212,10 +213,7 @@ let relative = (file) => file;
 
 if (DEV) {
 	try {
-		const path = await import('node:path');
-		const process = await import('node:process');
-
-		relative = (file) => path.relative(process.cwd(), file);
+		relative = (file) => path.relative(__SVELTEKIT_ROOT__, file);
 	} catch {
 		// do nothing
 	}

package/src/runtime/shared-server.js

@@ -1,28 +1,6 @@
-/**
- * `$env/dynamic/private`
- * @type {Record<string, string>}
- */
-export let private_env = {};
-
-/**
- * `$env/dynamic/public`
- * @type {Record<string, string>}
- */
-export let public_env = {};
-
 /** @param {any} error */
 export let fix_stack_trace = (error) => error?.stack;
 
-/** @type {(environment: Record<string, string>) => void} */
-export function set_private_env(environment) {
-	private_env = environment;
-}
-
-/** @type {(environment: Record<string, string>) => void} */
-export function set_public_env(environment) {
-	public_env = environment;
-}
-
 /** @param {(error: Error) => string} value */
 export function set_fix_stack_trace(value) {
 	fix_stack_trace = value;