@sveltejs/kit 2.41.0 → 2.42.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.41.0",
+  "version": "2.42.1",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",

package/src/exports/public.d.ts

@@ -1810,28 +1810,105 @@ export interface Snapshot<T = any> {
 	restore: (snapshot: T) => void;
 }
 
+// If T is unknown or RemoteFormInput, the types below will recurse indefinitely and create giant unions that TS can't handle
+type WillRecurseIndefinitely<T> = unknown extends T
+	? true
+	: RemoteFormInput extends T
+		? true
+		: false;
+
+// Helper type to convert union to intersection
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+	? I
+	: never;
+
+type FlattenInput<T, Prefix extends string> =
+	WillRecurseIndefinitely<T> extends true
+		? { [key: string]: string }
+		: T extends Array<infer U>
+			? U extends string | File
+				? { [P in Prefix]: string[] }
+				: FlattenInput<U, `${Prefix}[${number}]`>
+			: T extends File
+				? { [P in Prefix]: string }
+				: T extends object
+					? {
+							[K in keyof T]: FlattenInput<
+								T[K],
+								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+							>;
+						}[keyof T]
+					: { [P in Prefix]: string };
+
+type FlattenIssues<T, Prefix extends string> =
+	WillRecurseIndefinitely<T> extends true
+		? { [key: string]: RemoteFormIssue[] }
+		: T extends Array<infer U>
+			? { [P in Prefix | `${Prefix}[${number}]`]: RemoteFormIssue[] } & FlattenIssues<
+					U,
+					`${Prefix}[${number}]`
+				>
+			: T extends File
+				? { [P in Prefix]: RemoteFormIssue[] }
+				: T extends object
+					? {
+							[K in keyof T]: FlattenIssues<
+								T[K],
+								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+							>;
+						}[keyof T]
+					: { [P in Prefix]: RemoteFormIssue[] };
+
+type FlattenKeys<T, Prefix extends string> =
+	WillRecurseIndefinitely<T> extends true
+		? { [key: string]: string }
+		: T extends Array<infer U>
+			? U extends string | File
+				? { [P in `${Prefix}[]`]: string[] }
+				: FlattenKeys<U, `${Prefix}[${number}]`>
+			: T extends File
+				? { [P in Prefix]: string }
+				: T extends object
+					? {
+							[K in keyof T]: FlattenKeys<
+								T[K],
+								Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+							>;
+						}[keyof T]
+					: { [P in Prefix]: string };
+
+export interface RemoteFormInput {
+	[key: string]: FormDataEntryValue | FormDataEntryValue[] | RemoteFormInput | RemoteFormInput[];
+}
+
+export interface RemoteFormIssue {
+	name: string;
+	path: Array<string | number>;
+	message: string;
+}
+
 /**
  * The return value of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  */
-export type RemoteForm<Result> = {
+export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
+	/** Attachment that sets up an event handler that intercepts the form submission on the client to prevent a full page reload */
+	[attachment: symbol]: (node: HTMLFormElement) => void;
 	method: 'POST';
 	/** The URL to send the form to. */
 	action: string;
-	/** Event handler that intercepts the form submission on the client to prevent a full page reload */
-	onsubmit: (event: SubmitEvent) => void;
 	/** Use the `enhance` method to influence what happens when the form is submitted. */
 	enhance(
 		callback: (opts: {
 			form: HTMLFormElement;
-			data: FormData;
+			data: Input;
 			submit: () => Promise<void> & {
 				updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 			};
-		}) => void
+		}) => void | Promise<void>
 	): {
 		method: 'POST';
 		action: string;
-		onsubmit: (event: SubmitEvent) => void;
+		[attachment: symbol]: (node: HTMLFormElement) => void;
 	};
 	/**
 	 * Create an instance of the form for the given key.
@@ -1847,11 +1924,27 @@ export type RemoteForm<Result> = {
 	 *	{/each}
 	 * ```
 	 */
-	for(key: string | number | boolean): Omit<RemoteForm<Result>, 'for'>;
+	for(key: string | number | boolean): Omit<RemoteForm<Input, Output>, 'for'>;
+	/**
+	 * This method exists to allow you to typecheck `name` attributes. It returns its argument
+	 * @example
+	 * ```svelte
+	 * <input name={login.field('username')} />
+	 * ```
+	 **/
+	field<Name extends keyof UnionToIntersection<FlattenKeys<Input, ''>>>(string: Name): Name;
+	/** Preflight checks */
+	preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
+	/** Validate the form contents programmatically */
+	validate(options?: { includeUntouched?: boolean }): Promise<void>;
 	/** The result of the form submission */
-	get result(): Result | undefined;
+	get result(): Output | undefined;
 	/** The number of pending submissions */
 	get pending(): number;
+	/** The submitted values */
+	input: null | UnionToIntersection<FlattenInput<Input, ''>>;
+	/** Validation issues */
+	issues: null | UnionToIntersection<FlattenIssues<Input, ''>>;
 	/** Spread this onto a `<button>` or `<input type="submit">` */
 	buttonProps: {
 		type: 'submit';
@@ -1862,11 +1955,11 @@ export type RemoteForm<Result> = {
 		enhance(
 			callback: (opts: {
 				form: HTMLFormElement;
-				data: FormData;
+				data: Input;
 				submit: () => Promise<void> & {
 					updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 				};
-			}) => void
+			}) => void | Promise<void>
 		): {
 			type: 'submit';
 			formmethod: 'POST';

package/src/exports/vite/index.js

@@ -682,9 +682,13 @@ async function kit({ svelte_config }) {
 			config.build.rollupOptions.output = {
 				...config.build.rollupOptions.output,
 				manualChunks(id, meta) {
+					// Prevent core runtime and env from ending up in a remote chunk, which could break because of initialization order
 					if (id === `${runtime_directory}/app/server/index.js`) {
 						return 'app-server';
 					}
+					if (id === `${runtime_directory}/shared-server.js`) {
+						return 'app-shared-server';
+					}
 
 					// Check if this is a *.remote.ts file
 					if (svelte_config.kit.moduleExtensions.some((ext) => id.endsWith(`.remote${ext}`))) {

package/src/runtime/app/server/remote/form.js

@@ -1,34 +1,77 @@
-/** @import { RemoteForm } from '@sveltejs/kit' */
-/** @import { RemoteInfo, MaybePromise } from 'types' */
+/** @import { RemoteFormInput, RemoteForm } from '@sveltejs/kit' */
+/** @import { MaybePromise, RemoteInfo } from 'types' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
+import { DEV } from 'esm-env';
 import { run_remote_function } from './shared.js';
+import { convert_formdata, flatten_issues } from '../../../utils.js';
 
 /**
  * Creates a form object that can be spread onto a `<form>` element.
  *
  * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
  *
- * @template T
- * @param {(data: FormData) => MaybePromise<T>} fn
- * @returns {RemoteForm<T>}
+ * @template Output
+ * @overload
+ * @param {() => Output} fn
+ * @returns {RemoteForm<void, Output>}
+ * @since 2.27
+ */
+/**
+ * Creates a form object that can be spread onto a `<form>` element.
+ *
+ * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+ *
+ * @template {RemoteFormInput} Input
+ * @template Output
+ * @overload
+ * @param {'unchecked'} validate
+ * @param {(data: Input) => MaybePromise<Output>} fn
+ * @returns {RemoteForm<Input, Output>}
+ * @since 2.27
+ */
+/**
+ * Creates a form object that can be spread onto a `<form>` element.
+ *
+ * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+ *
+ * @template {StandardSchemaV1<RemoteFormInput, Record<string, any>>} Schema
+ * @template Output
+ * @overload
+ * @param {Schema} validate
+ * @param {(data: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>} fn
+ * @returns {RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>}
+ * @since 2.27
+ */
+/**
+ * @template {RemoteFormInput} Input
+ * @template Output
+ * @param {any} validate_or_fn
+ * @param {(data?: Input) => MaybePromise<Output>} [maybe_fn]
+ * @returns {RemoteForm<Input, Output>}
  * @since 2.27
  */
 /*@__NO_SIDE_EFFECTS__*/
 // @ts-ignore we don't want to prefix `fn` with an underscore, as that will be user-visible
-export function form(fn) {
+export function form(validate_or_fn, maybe_fn) {
+	/** @type {(data?: Input) => Output} */
+	const fn = maybe_fn ?? validate_or_fn;
+
+	/** @type {StandardSchemaV1 | null} */
+	const schema = !maybe_fn || validate_or_fn === 'unchecked' ? null : validate_or_fn;
+
 	/**
 	 * @param {string | number | boolean} [key]
 	 */
 	function create_instance(key) {
-		/** @type {RemoteForm<T>} */
+		/** @type {RemoteForm<Input, Output>} */
 		const instance = {};
 
 		instance.method = 'POST';
-		instance.onsubmit = () => {};
 
 		Object.defineProperty(instance, 'enhance', {
 			value: () => {
-				return { action: instance.action, method: instance.method, onsubmit: instance.onsubmit };
+				return { action: instance.action, method: instance.method };
 			}
 		});
 
@@ -54,19 +97,79 @@ export function form(fn) {
 			id: '',
 			/** @param {FormData} form_data */
 			fn: async (form_data) => {
+				const validate_only = form_data.get('sveltekit:validate_only') === 'true';
+				form_data.delete('sveltekit:validate_only');
+
+				let data = maybe_fn ? convert_formdata(form_data) : undefined;
+
+				// TODO 3.0 remove this warning
+				if (DEV && !data) {
+					const error = () => {
+						throw new Error(
+							'Remote form functions no longer get passed a FormData object. ' +
+								"`form` now has the same signature as `query` or `command`, i.e. it expects to be invoked like `form(schema, callback)` or `form('unchecked', callback)`. " +
+								'The payload of the callback function is now a POJO instead of a FormData object. See https://kit.svelte.dev/docs/remote-functions#form for details.'
+						);
+					};
+					data = {};
+					for (const key of [
+						'append',
+						'delete',
+						'entries',
+						'forEach',
+						'get',
+						'getAll',
+						'has',
+						'keys',
+						'set',
+						'values'
+					]) {
+						Object.defineProperty(data, key, { get: error });
+					}
+				}
+
+				/** @type {{ input?: Record<string, string | string[]>, issues?: Record<string, StandardSchemaV1.Issue[]>, result: Output }} */
+				const output = {};
+
 				const { event, state } = get_request_store();
+				const validated = await schema?.['~standard'].validate(data);
+
+				if (validate_only) {
+					return validated?.issues ?? [];
+				}
+
+				if (validated?.issues !== undefined) {
+					output.issues = flatten_issues(validated.issues);
+					output.input = {};
+
+					for (let key of form_data.keys()) {
+						// redact sensitive fields
+						if (/^[.\]]?_/.test(key)) continue;
+
+						const is_array = key.endsWith('[]');
+						const values = form_data.getAll(key).filter((value) => typeof value === 'string');
 
-				state.refreshes ??= {};
+						if (is_array) key = key.slice(0, -2);
 
-				const result = await run_remote_function(event, state, true, form_data, (d) => d, fn);
+						output.input[key] = is_array ? values : values[0];
+					}
+				} else {
+					if (validated !== undefined) {
+						data = validated.value;
+					}
+
+					state.refreshes ??= {};
+
+					output.result = await run_remote_function(event, state, true, data, (d) => d, fn);
+				}
 
 				// We don't need to care about args or deduplicating calls, because uneval results are only relevant in full page reloads
 				// where only one form submission is active at the same time
 				if (!event.isRemoteRequest) {
-					(state.remote_data ??= {})[__.id] = result;
+					(state.remote_data ??= {})[__.id] = output;
 				}
 
-				return result;
+				return output;
 			}
 		};
 
@@ -82,11 +185,24 @@ export function form(fn) {
 			enumerable: true
 		});
 
+		for (const property of ['input', 'issues']) {
+			Object.defineProperty(instance, property, {
+				get() {
+					try {
+						const { remote_data } = get_request_store().state;
+						return remote_data?.[__.id]?.[property] ?? {};
+					} catch {
+						return undefined;
+					}
+				}
+			});
+		}
+
 		Object.defineProperty(instance, 'result', {
 			get() {
 				try {
 					const { remote_data } = get_request_store().state;
-					return remote_data?.[__.id];
+					return remote_data?.[__.id]?.result;
 				} catch {
 					return undefined;
 				}
@@ -103,9 +219,24 @@ export function form(fn) {
 			get: () => 0
 		});
 
+		Object.defineProperty(instance, 'field', {
+			value: (/** @type {string} */ name) => name
+		});
+
+		Object.defineProperty(instance, 'preflight', {
+			// preflight is a noop on the server
+			value: () => instance
+		});
+
+		Object.defineProperty(instance, 'validate', {
+			value: () => {
+				throw new Error('Cannot call validate() on the server');
+			}
+		});
+
 		if (key == undefined) {
 			Object.defineProperty(instance, 'for', {
-				/** @type {RemoteForm<any>['for']} */
+				/** @type {RemoteForm<any, any>['for']} */
 				value: (key) => {
 					const { state } = get_request_store();
 					const cache_key = __.id + '|' + JSON.stringify(key);

package/src/runtime/client/remote-functions/form.svelte.js

@@ -1,4 +1,5 @@
-/** @import { RemoteForm, RemoteQueryOverride } from '@sveltejs/kit' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { RemoteFormInput, RemoteForm, RemoteQueryOverride } from '@sveltejs/kit' */
 /** @import { RemoteFunctionResponse } from 'types' */
 /** @import { Query } from './query.svelte.js' */
 import { app_dir, base } from '__sveltekit/paths';
@@ -15,15 +16,18 @@ import {
 } from '../client.js';
 import { tick } from 'svelte';
 import { refresh_queries, release_overrides } from './shared.svelte.js';
+import { createAttachmentKey } from 'svelte/attachments';
+import { convert_formdata, file_transport, flatten_issues } from '../../utils.js';
 
 /**
  * Client-version of the `form` function from `$app/server`.
- * @template T
+ * @template {RemoteFormInput} T
+ * @template U
  * @param {string} id
- * @returns {RemoteForm<T>}
+ * @returns {RemoteForm<T, U>}
  */
 export function form(id) {
-	/** @type {Map<any, { count: number, instance: RemoteForm<T> }>} */
+	/** @type {Map<any, { count: number, instance: RemoteForm<T, U> }>} */
 	const instances = new Map();
 
 	/** @param {string | number | boolean} [key] */
@@ -31,12 +35,80 @@ export function form(id) {
 		const action_id = id + (key != undefined ? `/${JSON.stringify(key)}` : '');
 		const action = '?/remote=' + encodeURIComponent(action_id);
 
+		/** @type {Record<string, string | string[] | File | File[]>} */
+		let input = $state({});
+
+		/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+		let issues = $state.raw({});
+
 		/** @type {any} */
 		let result = $state.raw(started ? undefined : remote_responses[action_id]);
 
 		/** @type {number} */
 		let pending_count = $state(0);
 
+		/** @type {StandardSchemaV1 | undefined} */
+		let preflight_schema = undefined;
+
+		/** @type {HTMLFormElement | null} */
+		let element = null;
+
+		/** @type {Record<string, boolean>} */
+		let touched = {};
+
+		/**
+		 * @param {HTMLFormElement} form
+		 * @param {FormData} form_data
+		 * @param {Parameters<RemoteForm<any, any>['enhance']>[0]} callback
+		 */
+		async function handle_submit(form, form_data, callback) {
+			const data = convert_formdata(form_data);
+
+			const validated = await preflight_schema?.['~standard'].validate(data);
+
+			if (validated?.issues) {
+				issues = flatten_issues(validated.issues);
+				return;
+			}
+
+			// TODO 3.0 remove this warning
+			if (DEV) {
+				const error = () => {
+					throw new Error(
+						'Remote form functions no longer get passed a FormData object. The payload is now a POJO. See https://kit.svelte.dev/docs/remote-functions#form for details.'
+					);
+				};
+				for (const key of [
+					'append',
+					'delete',
+					'entries',
+					'forEach',
+					'get',
+					'getAll',
+					'has',
+					'keys',
+					'set',
+					'values'
+				]) {
+					if (!(key in data)) {
+						Object.defineProperty(data, key, { get: error });
+					}
+				}
+			}
+
+			try {
+				await callback({
+					form,
+					data,
+					submit: () => submit(form_data)
+				});
+			} catch (e) {
+				const error = e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
+				const status = e instanceof HttpError ? e.status : 500;
+				void set_nearest_error_page(error, status);
+			}
+		}
+
 		/**
 		 * @param {FormData} data
 		 * @returns {Promise<any> & { updates: (...args: any[]) => any }}
@@ -64,13 +136,6 @@ export function form(id) {
 					await Promise.resolve();
 
 					if (updates.length > 0) {
-						if (DEV) {
-							if (data.get('sveltekit:remote_refreshes')) {
-								throw new Error(
-									'The FormData key `sveltekit:remote_refreshes` is reserved for internal use and should not be set manually'
-								);
-							}
-						}
 						data.set('sveltekit:remote_refreshes', JSON.stringify(updates.map((u) => u._key)));
 					}
 
@@ -88,9 +153,18 @@ export function form(id) {
 					const form_result = /** @type { RemoteFunctionResponse} */ (await response.json());
 
 					if (form_result.type === 'result') {
-						result = devalue.parse(form_result.result, app.decoders);
-
-						if (form_result.refreshes) {
+						({
+							input = {},
+							issues = {},
+							result
+						} = devalue.parse(form_result.result, {
+							...app.decoders,
+							File: file_transport.decode
+						}));
+
+						if (issues.$) {
+							release_overrides(updates);
+						} else if (form_result.refreshes) {
 							refresh_queries(form_result.refreshes, updates);
 						} else {
 							void invalidateAll();
@@ -104,7 +178,6 @@ export function form(id) {
 						// Use internal version to allow redirects to external URLs
 						void _goto(form_result.location, { invalidateAll }, 0);
 					} else {
-						result = undefined;
 						throw new HttpError(form_result.status ?? 500, form_result.error);
 					}
 				} catch (e) {
@@ -134,43 +207,13 @@ export function form(id) {
 			return promise;
 		}
 
-		/** @type {RemoteForm<T>} */
+		/** @type {RemoteForm<T, U>} */
 		const instance = {};
 
 		instance.method = 'POST';
 		instance.action = action;
 
-		/**
-		 * @param {HTMLFormElement} form_element
-		 * @param {HTMLElement | null} submitter
-		 */
-		function create_form_data(form_element, submitter) {
-			const form_data = new FormData(form_element);
-
-			if (DEV) {
-				const enctype = submitter?.hasAttribute('formenctype')
-					? /** @type {HTMLButtonElement | HTMLInputElement} */ (submitter).formEnctype
-					: clone(form_element).enctype;
-				if (enctype !== 'multipart/form-data') {
-					for (const value of form_data.values()) {
-						if (value instanceof File) {
-							throw new Error(
-								'Your form contains <input type="file"> fields, but is missing the necessary `enctype="multipart/form-data"` attribute. This will lead to inconsistent behavior between enhanced and native forms. For more details, see https://github.com/sveltejs/kit/issues/9819.'
-							);
-						}
-					}
-				}
-			}
-
-			const submitter_name = submitter?.getAttribute('name');
-			if (submitter_name) {
-				form_data.append(submitter_name, submitter?.getAttribute('value') ?? '');
-			}
-
-			return form_data;
-		}
-
-		/** @param {Parameters<RemoteForm<any>['enhance']>[0]} callback */
+		/** @param {Parameters<RemoteForm<any, any>['enhance']>[0]} callback */
 		const form_onsubmit = (callback) => {
 			/** @param {SubmitEvent} event */
 			return async (event) => {
@@ -194,26 +237,105 @@ export function form(id) {
 
 				event.preventDefault();
 
-				const data = create_form_data(form, event.submitter);
+				const form_data = new FormData(form);
 
-				try {
-					await callback({
-						form,
-						data,
-						submit: () => submit(data)
-					});
-				} catch (e) {
-					const error =
-						e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
-					const status = e instanceof HttpError ? e.status : 500;
-					void set_nearest_error_page(error, status);
+				if (DEV) {
+					validate_form_data(form_data, clone(form).enctype);
 				}
+
+				await handle_submit(form, form_data, callback);
 			};
 		};
 
-		instance.onsubmit = form_onsubmit(({ submit, form }) => submit().then(() => form.reset()));
+		/** @param {(event: SubmitEvent) => void} onsubmit */
+		function create_attachment(onsubmit) {
+			return (/** @type {HTMLFormElement} */ form) => {
+				if (element) {
+					let message = `A form object can only be attached to a single \`<form>\` element`;
+					if (DEV && !key) {
+						const name = id.split('/').pop();
+						message += `. To create multiple instances, use \`${name}.for(key)\``;
+					}
+
+					throw new Error(message);
+				}
+
+				element = form;
+
+				touched = {};
+
+				form.addEventListener('submit', onsubmit);
+
+				form.addEventListener('input', (e) => {
+					// strictly speaking it can be an HTMLTextAreaElement or HTMLSelectElement
+					// but that makes the types unnecessarily awkward
+					const element = /** @type {HTMLInputElement} */ (e.target);
+
+					let name = element.name;
+					if (!name) return;
+
+					const is_array = name.endsWith('[]');
+					if (is_array) name = name.slice(0, -2);
+
+					const is_file = element.type === 'file';
+
+					touched[name] = true;
+
+					if (is_array) {
+						const elements = /** @type {HTMLInputElement[]} */ (
+							Array.from(form.querySelectorAll(`[name="${name}[]"]`))
+						);
+
+						if (DEV) {
+							for (const e of elements) {
+								if ((e.type === 'file') !== is_file) {
+									throw new Error(
+										`Cannot mix and match file and non-file inputs under the same name ("${element.name}")`
+									);
+								}
+							}
+						}
+
+						input[name] = is_file
+							? elements.map((input) => Array.from(input.files ?? [])).flat()
+							: elements.map((element) => element.value);
+					} else if (is_file) {
+						if (DEV && element.multiple) {
+							throw new Error(
+								`Can only use the \`multiple\` attribute when \`name\` includes a \`[]\` suffix — consider changing "${name}" to "${name}[]"`
+							);
+						}
+
+						const file = /** @type {HTMLInputElement & { files: FileList }} */ (element).files[0];
 
-		/** @param {Parameters<RemoteForm<any>['buttonProps']['enhance']>[0]} callback */
+						if (file) {
+							input[name] = file;
+						} else {
+							delete input[name];
+						}
+					} else {
+						input[name] = element.value;
+					}
+				});
+
+				return () => {
+					element = null;
+					preflight_schema = undefined;
+				};
+			};
+		}
+
+		instance[createAttachmentKey()] = create_attachment(
+			form_onsubmit(({ submit, form }) =>
+				submit().then(() => {
+					if (!issues.$) {
+						form.reset();
+					}
+				})
+			)
+		);
+
+		/** @param {Parameters<RemoteForm<any, any>['buttonProps']['enhance']>[0]} callback */
 		const form_action_onclick = (callback) => {
 			/** @param {Event} event */
 			return async (event) => {
@@ -225,34 +347,41 @@ export function form(id) {
 				event.stopPropagation();
 				event.preventDefault();
 
-				const data = create_form_data(form, target);
+				const form_data = new FormData(form);
 
-				try {
-					await callback({
-						form,
-						data,
-						submit: () => submit(data)
-					});
-				} catch (e) {
-					const error =
-						e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
-					const status = e instanceof HttpError ? e.status : 500;
-					void set_nearest_error_page(error, status);
+				if (DEV) {
+					const enctype = target.hasAttribute('formenctype')
+						? target.formEnctype
+						: clone(form).enctype;
+
+					validate_form_data(form_data, enctype);
 				}
+
+				if (target.name) {
+					form_data.append(target.name, target?.getAttribute('value') ?? '');
+				}
+
+				await handle_submit(form, form_data, callback);
 			};
 		};
 
-		/** @type {RemoteForm<any>['buttonProps']} */
+		/** @type {RemoteForm<any, any>['buttonProps']} */
 		// @ts-expect-error we gotta set enhance as a non-enumerable property
 		const button_props = {
 			type: 'submit',
 			formmethod: 'POST',
 			formaction: action,
-			onclick: form_action_onclick(({ submit, form }) => submit().then(() => form.reset()))
+			onclick: form_action_onclick(({ submit, form }) =>
+				submit().then(() => {
+					if (!issues.$) {
+						form.reset();
+					}
+				})
+			)
 		};
 
 		Object.defineProperty(button_props, 'enhance', {
-			/** @type {RemoteForm<any>['buttonProps']['enhance']} */
+			/** @type {RemoteForm<any, any>['buttonProps']['enhance']} */
 			value: (callback) => {
 				return {
 					type: 'submit',
@@ -267,23 +396,106 @@ export function form(id) {
 			get: () => pending_count
 		});
 
+		let validate_id = 0;
+
 		Object.defineProperties(instance, {
 			buttonProps: {
 				value: button_props
 			},
+			input: {
+				get: () => input,
+				set: (v) => {
+					input = v;
+				}
+			},
+			issues: {
+				get: () => issues
+			},
 			result: {
 				get: () => result
 			},
 			pending: {
 				get: () => pending_count
 			},
+			field: {
+				value: (/** @type {string} */ name) => name
+			},
+			preflight: {
+				/** @type {RemoteForm<any, any>['preflight']} */
+				value: (schema) => {
+					preflight_schema = schema;
+					return instance;
+				}
+			},
+			validate: {
+				/** @type {RemoteForm<any, any>['validate']} */
+				value: async ({ includeUntouched = false } = {}) => {
+					if (!element) return;
+
+					const id = ++validate_id;
+
+					const form_data = new FormData(element);
+
+					/** @type {readonly StandardSchemaV1.Issue[]} */
+					let array = [];
+
+					const validated = await preflight_schema?.['~standard'].validate(
+						convert_formdata(form_data)
+					);
+
+					if (validated?.issues) {
+						array = validated.issues;
+					} else {
+						form_data.set('sveltekit:validate_only', 'true');
+
+						const response = await fetch(`${base}/${app_dir}/remote/${action_id}`, {
+							method: 'POST',
+							body: form_data
+						});
+
+						const result = await response.json();
+
+						if (validate_id !== id) {
+							return;
+						}
+
+						if (result.type === 'result') {
+							array = /** @type {StandardSchemaV1.Issue[]} */ (
+								devalue.parse(result.result, app.decoders)
+							);
+						}
+					}
+
+					if (!includeUntouched) {
+						array = array.filter((issue) => {
+							if (issue.path !== undefined) {
+								let path = '';
+
+								for (const segment of issue.path) {
+									const key = typeof segment === 'object' ? segment.key : segment;
+
+									if (typeof key === 'number') {
+										path += `[${key}]`;
+									} else if (typeof key === 'string') {
+										path += path === '' ? key : '.' + key;
+									}
+								}
+
+								return touched[path];
+							}
+						});
+					}
+
+					issues = flatten_issues(array);
+				}
+			},
 			enhance: {
-				/** @type {RemoteForm<any>['enhance']} */
+				/** @type {RemoteForm<any, any>['enhance']} */
 				value: (callback) => {
 					return {
 						method: 'POST',
 						action,
-						onsubmit: form_onsubmit(callback)
+						[createAttachmentKey()]: create_attachment(form_onsubmit(callback))
 					};
 				}
 			}
@@ -295,7 +507,7 @@ export function form(id) {
 	const instance = create_instance();
 
 	Object.defineProperty(instance, 'for', {
-		/** @type {RemoteForm<any>['for']} */
+		/** @type {RemoteForm<T, U>['for']} */
 		value: (key) => {
 			const entry = instances.get(key) ?? { count: 0, instance: create_instance(key) };
 
@@ -335,3 +547,33 @@ export function form(id) {
 function clone(element) {
 	return /** @type {T} */ (HTMLElement.prototype.cloneNode.call(element));
 }
+
+/**
+ * @param {FormData} form_data
+ * @param {string} enctype
+ */
+function validate_form_data(form_data, enctype) {
+	for (const key of form_data.keys()) {
+		if (key.startsWith('sveltekit:')) {
+			throw new Error(
+				'FormData keys starting with `sveltekit:` are reserved for internal use and should not be set manually'
+			);
+		}
+
+		if (/^\$[.[]?/.test(key)) {
+			throw new Error(
+				'`$` is used to collect all FormData validation issues and cannot be used as the `name` of a form control'
+			);
+		}
+	}
+
+	if (enctype !== 'multipart/form-data') {
+		for (const value of form_data.values()) {
+			if (value instanceof File) {
+				throw new Error(
+					'Your form contains <input type="file"> fields, but is missing the necessary `enctype="multipart/form-data"` attribute. This will lead to inconsistent behavior between enhanced and native forms. For more details, see https://github.com/sveltejs/kit/issues/9819.'
+				);
+			}
+		}
+	}
+}

package/src/runtime/server/remote.js

@@ -12,6 +12,7 @@ import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';
 import { record_span } from '../telemetry/record_span.js';
+import { file_transport } from '../utils.js';
 
 /** @type {typeof handle_remote_call_internal} */
 export async function handle_remote_call(event, state, options, manifest, id) {
@@ -128,8 +129,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
-					result: stringify(data, transport),
-					refreshes: await serialize_refreshes(form_client_refreshes)
+					result: stringify(data, { ...transport, File: file_transport }),
+					refreshes: data.issues ? {} : await serialize_refreshes(form_client_refreshes)
 				})
 			);
 		}
@@ -262,7 +263,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 	const remotes = manifest._.remotes;
 	const module = await remotes[hash]?.();
 
-	let form = /** @type {RemoteForm<any>} */ (module?.default[name]);
+	let form = /** @type {RemoteForm<any, any>} */ (module?.default[name]);
 
 	if (!form) {
 		event.setHeaders({

package/src/runtime/utils.js

@@ -1,3 +1,5 @@
+/** @import { RemoteFormIssue } from '@sveltejs/kit' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
@@ -63,3 +65,123 @@ export function base64_decode(encoded) {
 
 	return bytes;
 }
+
+/**
+ * Convert `FormData` into a POJO
+ * @param {FormData} data
+ */
+export function convert_formdata(data) {
+	/** @type {Record<string, any>} */
+	const result = Object.create(null); // guard against prototype pollution
+
+	for (let key of data.keys()) {
+		const is_array = key.endsWith('[]');
+		let values = data.getAll(key);
+
+		if (is_array) key = key.slice(0, -2);
+
+		if (values.length > 1 && !is_array) {
+			throw new Error(`Form cannot contain duplicated keys — "${key}" has ${values.length} values`);
+		}
+
+		// an empty `<input type="file">` will submit a non-existent file, bizarrely
+		values = values.filter(
+			(entry) => typeof entry === 'string' || entry.name !== '' || entry.size > 0
+		);
+
+		deep_set(result, split_path(key), is_array ? values : values[0]);
+	}
+
+	return result;
+}
+
+const path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
+
+/**
+ * @param {string} path
+ */
+export function split_path(path) {
+	if (!path_regex.test(path)) {
+		throw new Error(`Invalid path ${path}`);
+	}
+
+	return path.split(/\.|\[|\]/).filter(Boolean);
+}
+
+/**
+ * @param {Record<string, any>} object
+ * @param {string[]} keys
+ * @param {any} value
+ */
+export function deep_set(object, keys, value) {
+	for (let i = 0; i < keys.length - 1; i += 1) {
+		const key = keys[i];
+		const is_array = /^\d+$/.test(keys[i + 1]);
+
+		if (object[key]) {
+			if (is_array !== Array.isArray(object[key])) {
+				throw new Error(`Invalid array key ${keys[i + 1]}`);
+			}
+		} else {
+			object = object[key] ??= is_array ? [] : Object.create(null); // guard against prototype pollution
+		}
+	}
+
+	object[keys[keys.length - 1]] = value;
+}
+
+/**
+ * @param {readonly StandardSchemaV1.Issue[]} issues
+ */
+export function flatten_issues(issues) {
+	/** @type {Record<string, RemoteFormIssue[]>} */
+	const result = {};
+
+	for (const issue of issues) {
+		/** @type {RemoteFormIssue} */
+		const normalized = { name: '', path: [], message: issue.message };
+
+		(result.$ ??= []).push(normalized);
+
+		let name = '';
+
+		if (issue.path !== undefined) {
+			for (const segment of issue.path) {
+				const key = /** @type {string | number} */ (
+					typeof segment === 'object' ? segment.key : segment
+				);
+
+				normalized.path.push(key);
+
+				if (typeof key === 'number') {
+					name += `[${key}]`;
+				} else if (typeof key === 'string') {
+					name += name === '' ? key : '.' + key;
+				}
+
+				(result[name] ??= []).push(normalized);
+			}
+
+			normalized.name = name;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * We need to encode `File` objects when returning `issues` from a `form` submission,
+ * because some validators include the original value in the issue. It doesn't
+ * need to deserialize to a `File` object
+ * @type {import('@sveltejs/kit').Transporter}
+ */
+export const file_transport = {
+	encode: (file) =>
+		file instanceof File && {
+			size: file.size,
+			type: file.type,
+			name: file.name,
+			lastModified: file.lastModified
+		},
+	decode: (data) => data
+};

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.41.0';
+export const VERSION = '2.42.1';

package/types/index.d.ts

@@ -1786,28 +1786,105 @@ declare module '@sveltejs/kit' {
 		restore: (snapshot: T) => void;
 	}
 
+	// If T is unknown or RemoteFormInput, the types below will recurse indefinitely and create giant unions that TS can't handle
+	type WillRecurseIndefinitely<T> = unknown extends T
+		? true
+		: RemoteFormInput extends T
+			? true
+			: false;
+
+	// Helper type to convert union to intersection
+	type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+		? I
+		: never;
+
+	type FlattenInput<T, Prefix extends string> =
+		WillRecurseIndefinitely<T> extends true
+			? { [key: string]: string }
+			: T extends Array<infer U>
+				? U extends string | File
+					? { [P in Prefix]: string[] }
+					: FlattenInput<U, `${Prefix}[${number}]`>
+				: T extends File
+					? { [P in Prefix]: string }
+					: T extends object
+						? {
+								[K in keyof T]: FlattenInput<
+									T[K],
+									Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+								>;
+							}[keyof T]
+						: { [P in Prefix]: string };
+
+	type FlattenIssues<T, Prefix extends string> =
+		WillRecurseIndefinitely<T> extends true
+			? { [key: string]: RemoteFormIssue[] }
+			: T extends Array<infer U>
+				? { [P in Prefix | `${Prefix}[${number}]`]: RemoteFormIssue[] } & FlattenIssues<
+						U,
+						`${Prefix}[${number}]`
+					>
+				: T extends File
+					? { [P in Prefix]: RemoteFormIssue[] }
+					: T extends object
+						? {
+								[K in keyof T]: FlattenIssues<
+									T[K],
+									Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+								>;
+							}[keyof T]
+						: { [P in Prefix]: RemoteFormIssue[] };
+
+	type FlattenKeys<T, Prefix extends string> =
+		WillRecurseIndefinitely<T> extends true
+			? { [key: string]: string }
+			: T extends Array<infer U>
+				? U extends string | File
+					? { [P in `${Prefix}[]`]: string[] }
+					: FlattenKeys<U, `${Prefix}[${number}]`>
+				: T extends File
+					? { [P in Prefix]: string }
+					: T extends object
+						? {
+								[K in keyof T]: FlattenKeys<
+									T[K],
+									Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+								>;
+							}[keyof T]
+						: { [P in Prefix]: string };
+
+	export interface RemoteFormInput {
+		[key: string]: FormDataEntryValue | FormDataEntryValue[] | RemoteFormInput | RemoteFormInput[];
+	}
+
+	export interface RemoteFormIssue {
+		name: string;
+		path: Array<string | number>;
+		message: string;
+	}
+
 	/**
 	 * The return value of a remote `form` function. See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
 	 */
-	export type RemoteForm<Result> = {
+	export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
+		/** Attachment that sets up an event handler that intercepts the form submission on the client to prevent a full page reload */
+		[attachment: symbol]: (node: HTMLFormElement) => void;
 		method: 'POST';
 		/** The URL to send the form to. */
 		action: string;
-		/** Event handler that intercepts the form submission on the client to prevent a full page reload */
-		onsubmit: (event: SubmitEvent) => void;
 		/** Use the `enhance` method to influence what happens when the form is submitted. */
 		enhance(
 			callback: (opts: {
 				form: HTMLFormElement;
-				data: FormData;
+				data: Input;
 				submit: () => Promise<void> & {
 					updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 				};
-			}) => void
+			}) => void | Promise<void>
 		): {
 			method: 'POST';
 			action: string;
-			onsubmit: (event: SubmitEvent) => void;
+			[attachment: symbol]: (node: HTMLFormElement) => void;
 		};
 		/**
 		 * Create an instance of the form for the given key.
@@ -1823,11 +1900,27 @@ declare module '@sveltejs/kit' {
 		 *	{/each}
 		 * ```
 		 */
-		for(key: string | number | boolean): Omit<RemoteForm<Result>, 'for'>;
+		for(key: string | number | boolean): Omit<RemoteForm<Input, Output>, 'for'>;
+		/**
+		 * This method exists to allow you to typecheck `name` attributes. It returns its argument
+		 * @example
+		 * ```svelte
+		 * <input name={login.field('username')} />
+		 * ```
+		 **/
+		field<Name extends keyof UnionToIntersection<FlattenKeys<Input, ''>>>(string: Name): Name;
+		/** Preflight checks */
+		preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
+		/** Validate the form contents programmatically */
+		validate(options?: { includeUntouched?: boolean }): Promise<void>;
 		/** The result of the form submission */
-		get result(): Result | undefined;
+		get result(): Output | undefined;
 		/** The number of pending submissions */
 		get pending(): number;
+		/** The submitted values */
+		input: null | UnionToIntersection<FlattenInput<Input, ''>>;
+		/** Validation issues */
+		issues: null | UnionToIntersection<FlattenIssues<Input, ''>>;
 		/** Spread this onto a `<button>` or `<input type="submit">` */
 		buttonProps: {
 			type: 'submit';
@@ -1838,11 +1931,11 @@ declare module '@sveltejs/kit' {
 			enhance(
 				callback: (opts: {
 					form: HTMLFormElement;
-					data: FormData;
+					data: Input;
 					submit: () => Promise<void> & {
 						updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => Promise<void>;
 					};
-				}) => void
+				}) => void | Promise<void>
 			): {
 				type: 'submit';
 				formmethod: 'POST';
@@ -2910,7 +3003,7 @@ declare module '$app/paths' {
 }
 
 declare module '$app/server' {
-	import type { RequestEvent, RemoteCommand, RemoteForm, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
+	import type { RequestEvent, RemoteCommand, RemoteForm, RemoteFormInput, RemotePrerenderFunction, RemoteQueryFunction } from '@sveltejs/kit';
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	/**
 	 * Read the contents of an imported asset from the filesystem
@@ -2964,7 +3057,23 @@ declare module '$app/server' {
 	 *
 	 * @since 2.27
 	 */
-	export function form<T>(fn: (data: FormData) => MaybePromise<T>): RemoteForm<T>;
+	export function form<Output>(fn: () => Output): RemoteForm<void, Output>;
+	/**
+	 * Creates a form object that can be spread onto a `<form>` element.
+	 *
+	 * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+	 *
+	 * @since 2.27
+	 */
+	export function form<Input extends RemoteFormInput, Output>(validate: "unchecked", fn: (data: Input) => MaybePromise<Output>): RemoteForm<Input, Output>;
+	/**
+	 * Creates a form object that can be spread onto a `<form>` element.
+	 *
+	 * See [Remote functions](https://svelte.dev/docs/kit/remote-functions#form) for full documentation.
+	 *
+	 * @since 2.27
+	 */
+	export function form<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(validate: Schema, fn: (data: StandardSchemaV1.InferOutput<Schema>) => MaybePromise<Output>): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;
 	/**
 	 * Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a `fetch` call.
 	 *

package/types/index.d.ts.map

@@ -57,6 +57,13 @@
 		"Redirect",
 		"SubmitFunction",
 		"Snapshot",
+		"WillRecurseIndefinitely",
+		"UnionToIntersection",
+		"FlattenInput",
+		"FlattenIssues",
+		"FlattenKeys",
+		"RemoteFormInput",
+		"RemoteFormIssue",
 		"RemoteForm",
 		"RemoteCommand",
 		"RemoteResource",
@@ -144,7 +151,6 @@
 		"resolveRoute",
 		"read",
 		"getRequestEvent",
-		"form",
 		"RemotePrerenderInputsGenerator",
 		"page",
 		"navigating",
@@ -168,7 +174,6 @@
 		"../src/runtime/app/paths/types.d.ts",
 		"../src/runtime/app/server/index.js",
 		"../src/exports/internal/event.js",
-		"../src/runtime/app/server/remote/form.js",
 		"../src/runtime/app/state/index.js",
 		"../src/runtime/app/stores.js"
 	],
@@ -190,9 +195,8 @@
 		null,
 		null,
 		null,
-		null,
 		null
 	],
-	"mappings": ";;;;;;;;;;;kBAkCiBA,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiCZC,cAAcA;;;;;;aAMdC,cAAcA;;;;;;;;MAQrBC,aAAaA;;;;;OAKJC,YAAYA;;kBAETC,aAAaA;;;;;;MAMzBC,qBAAqBA;;;;;;;;;;;kBAWTC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8IPC,MAAMA;;;;;;;;;;;kBAWNC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4DPC,QAAQA;;;;;;;;kBAQRC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqkBdC,MAAMA;;;;;;;;;;;aAWNC,iBAAiBA;;;;;;;;;;;;aAYjBC,qBAAqBA;;;;;;;;;aASrBC,iBAAiBA;;;;;;;;;;aAUjBC,WAAWA;;;;;;;;;;aAUXC,UAAUA;;;;;;aAMVC,UAAUA;;;;;;aAMVC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;aA0BPC,SAASA;;;;;kBAKJC,WAAWA;;;;;;;;;;;;aAYhBC,IAAIA;;;;;;;;;;;;kBAYCC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyHTC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BfC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgCrBC,cAAcA;;kBAETC,cAAcA;;;;;;;;;;;;;;;;;;;;kBAoBdC,eAAeA;;;;;;;;;;;;;;;;;;;;;;kBAsBfC,kBAAkBA;;;;;;;;;;;;;;;;;;;kBAmBlBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;kBAwBpBC,kBAAkBA;;;;;;;;;;;;;;;;;;;;;;kBAsBlBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;aAwBnBC,UAAUA;;;;;;;;;aASVC,cAAcA;;;;;;;;;;aAUdC,UAAUA;;;;;;;;;;;;;;;;;;aAkBVC,aAAaA;;;;;;;;;;;;;;;;;;;kBAmBRC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CTC,YAAYA;;kBAEPC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+GjBC,cAAcA;;;;;kBAKTC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;kBAuBdC,eAAeA;;;;;;;;;;;;;;;cAenBC,MAAMA;;;;;;kBAMFC,iBAAiBA;;;;;;;kBAOjBC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;aAyBhBC,UAAUA;;;;;;;kBAOLC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkFpBC,MAAMA;;;;;;;;;;aAUNC,OAAOA;;;;;;;;;;;;;;;;aAgBPC,YAAYA;;;;;;;;;;;;kBCrtDXC,SAASA;;;;;;;;;;kBAqBTC,QAAQA;;;;;;;aD6tDTC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6BTC,QAAQA;;;;;;;;aAQbC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoEVC,aAAaA;;;;;;;;aAQbC,cAAcA;;;;;;;;;;;;;;;;;;aAkBdC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqCNC,mBAAmBA;;;;;;;;aAQxBC,uBAAuBA;;;;;aAKvBC,mBAAmBA;WEj6DdC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAkDZC,GAAGA;;;;;;;;;;;;;;;;;;;;;WAqBHC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmElBC,UAAUA;;WAELC,MAAMA;;;;;;;;;MASXC,YAAYA;;WAEPC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmCXC,yBAAyBA;;;;;;;;;;WAUzBC,yBAAyBA;;;;WAIzBC,sCAAsCA;;;;WAItCC,4BAA4BA;;;;MAIjCC,8BAA8BA;MAC9BC,8BAA8BA;MAC9BC,iCAAiCA;;;;;MAKjCC,2CAA2CA;;;;;;aAM3CC,eAAeA;;WAIVC,cAAcA;;;;;WAKdC,YAAYA;;;;;;MAMjBC,aAAaA;WC/LRC,KAAKA;;;;;;WAeLC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuHTC,YAAYA;;;;;;;;;;;;;WAkBZC,QAAQA;;;;;;;;;;;;;;MAgCbC,iBAAiBA;;;;;;;;;WAWZC,UAAUA;;;;;;;;;;;;;WAaVC,SAASA;;;;;;;;;;;;;;;;;;;;;;;WAsHTC,YAAYA;;;;;;;;;;;;;;;;MAgBjBC,kBAAkBA;;WAEbC,aAAaA;;;;;;;;;;WAUbC,UAAUA;;;;;;;;;;;WAWVC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;MAuBZC,aAAaA;;WA6BRC,eAAeA;;;;;;MAMpBC,uBAAuBA;;MAGvBC,WAAWA;;;;;;;;WAQNC,QAAQA;;;;;;;;;WASRC,cAAcA;;;;;;;;;MA+CnBC,eAAeA;;;;;MAKfC,kBAAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC3cdC,WAAWA;;;;;;;;;;;;;;;;;;;iBAsBXC,QAAQA;;;;;iBAiBRC,UAAUA;;;;;;iBASVC,IAAIA;;;;;;iBA4BJC,IAAIA;;;;;;;;;;;;;;;;iBAkDJC,eAAeA;;;;;;;;;;;;;;iBAmBfC,YAAYA;;;;;;;cCrOfC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC4EJC,QAAQA;;;;;;iBC4BFC,UAAUA;;;;;;iBAkCVC,WAAWA;;;;;iBAgFjBC,oBAAoBA;;;;;;;;;;;iBC3MpBC,gBAAgBA;;;;;;;;;iBCsHVC,SAASA;;;;;;;;;cCrIlBC,OAAOA;;;;;cAKPC,GAAGA;;;;;cAKHC,QAAQA;;;;;cAKRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;iBCYJC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;iBAgDXC,OAAOA;;;;;;;iBCupEDC,WAAWA;;;;;;;;;;;iBA9UjBC,aAAaA;;;;;;;;;;;;iBAiBbC,cAAcA;;;;;;;;;;iBAedC,UAAUA;;;;;iBASVC,qBAAqBA;;;;;;;;;;iBA8BrBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCJC,UAAUA;;;;iBA0BVC,aAAaA;;;;;iBAebC,UAAUA;;;;;;;;;;;;;;iBAqBJC,WAAWA;;;;;;;;;;;;;;;;;;iBAoCXC,WAAWA;;;;;iBAsCjBC,SAASA;;;;;iBA+CTC,YAAYA;MVhiEhBlE,YAAYA;;;;;;;;;;;;;;YWlJbmE,IAAIA;;;;;;;;;YASJC,MAAMA;;MAEZC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBAC,OAAOA;;;;;;;;;;;;;;;;;iBAiBPC,KAAKA;;;;;iBAKLC,YAAYA;;;;;;;;;;;;;;;;;;;;;;iBChDZC,IAAIA;;;;;;;;iBCOJC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCTfC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Mb0cRC,8BAA8BA;MDhU9B5E,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ce1GX6E,IAAIA;;;;;cAQJC,UAAUA;;;;;;;;;;;cAMVC,OAAOA;;;;;;;;;iBCrDPC,SAASA;;;;;;;;;;;;;;;cAyBTH,IAAIA;;;;;;;;;;cAiBJC,UAAUA;;;;;;;;cAeVC,OAAOA",
+	"mappings": ";;;;;;;;;;;kBAkCiBA,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiCZC,cAAcA;;;;;;aAMdC,cAAcA;;;;;;;;MAQrBC,aAAaA;;;;;OAKJC,YAAYA;;kBAETC,aAAaA;;;;;;MAMzBC,qBAAqBA;;;;;;;;;;;kBAWTC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8IPC,MAAMA;;;;;;;;;;;kBAWNC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4DPC,QAAQA;;;;;;;;kBAQRC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqkBdC,MAAMA;;;;;;;;;;;aAWNC,iBAAiBA;;;;;;;;;;;;aAYjBC,qBAAqBA;;;;;;;;;aASrBC,iBAAiBA;;;;;;;;;;aAUjBC,WAAWA;;;;;;;;;;aAUXC,UAAUA;;;;;;aAMVC,UAAUA;;;;;;aAMVC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;aA0BPC,SAASA;;;;;kBAKJC,WAAWA;;;;;;;;;;;;aAYhBC,IAAIA;;;;;;;;;;;;kBAYCC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyHTC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BfC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgCrBC,cAAcA;;kBAETC,cAAcA;;;;;;;;;;;;;;;;;;;;kBAoBdC,eAAeA;;;;;;;;;;;;;;;;;;;;;;kBAsBfC,kBAAkBA;;;;;;;;;;;;;;;;;;;kBAmBlBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;kBAwBpBC,kBAAkBA;;;;;;;;;;;;;;;;;;;;;;kBAsBlBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;aAwBnBC,UAAUA;;;;;;;;;aASVC,cAAcA;;;;;;;;;;aAUdC,UAAUA;;;;;;;;;;;;;;;;;;aAkBVC,aAAaA;;;;;;;;;;;;;;;;;;;kBAmBRC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CTC,YAAYA;;kBAEPC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+GjBC,cAAcA;;;;;kBAKTC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;kBAuBdC,eAAeA;;;;;;;;;;;;;;;cAenBC,MAAMA;;;;;;kBAMFC,iBAAiBA;;;;;;;kBAOjBC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;aAyBhBC,UAAUA;;;;;;;kBAOLC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkFpBC,MAAMA;;;;;;;;;;aAUNC,OAAOA;;;;;;;;;;;;;;;;aAgBPC,YAAYA;;;;;;;;;;;;kBCrtDXC,SAASA;;;;;;;;;;kBAqBTC,QAAQA;;;;;;;aD6tDTC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6BTC,QAAQA;;;;;;MAMpBC,uBAAuBA;;;;;;;MAOvBC,mBAAmBA;;;;MAInBC,YAAYA;;;;;;;;;;;;;;;;;;MAkBZC,aAAaA;;;;;;;;;;;;;;;;;;;MAmBbC,WAAWA;;;;;;;;;;;;;;;;;;kBAkBCC,eAAeA;;;;kBAIfC,eAAeA;;;;;;;;;aASpBC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoFVC,aAAaA;;;;;;;;aAQbC,cAAcA;;;;;;;;;;;;;;;;;;aAkBdC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqCNC,mBAAmBA;;;;;;;;aAQxBC,uBAAuBA;;;;;aAKvBC,mBAAmBA;WE9/DdC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAkDZC,GAAGA;;;;;;;;;;;;;;;;;;;;;WAqBHC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmElBC,UAAUA;;WAELC,MAAMA;;;;;;;;;MASXC,YAAYA;;WAEPC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmCXC,yBAAyBA;;;;;;;;;;WAUzBC,yBAAyBA;;;;WAIzBC,sCAAsCA;;;;WAItCC,4BAA4BA;;;;MAIjCC,8BAA8BA;MAC9BC,8BAA8BA;MAC9BC,iCAAiCA;;;;;MAKjCC,2CAA2CA;;;;;;aAM3CC,eAAeA;;WAIVC,cAAcA;;;;;WAKdC,YAAYA;;;;;;MAMjBC,aAAaA;WC/LRC,KAAKA;;;;;;WAeLC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuHTC,YAAYA;;;;;;;;;;;;;WAkBZC,QAAQA;;;;;;;;;;;;;;MAgCbC,iBAAiBA;;;;;;;;;WAWZC,UAAUA;;;;;;;;;;;;;WAaVC,SAASA;;;;;;;;;;;;;;;;;;;;;;;WAsHTC,YAAYA;;;;;;;;;;;;;;;;MAgBjBC,kBAAkBA;;WAEbC,aAAaA;;;;;;;;;;WAUbC,UAAUA;;;;;;;;;;;WAWVC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;MAuBZC,aAAaA;;WA6BRC,eAAeA;;;;;;MAMpBC,uBAAuBA;;MAGvBC,WAAWA;;;;;;;;WAQNC,QAAQA;;;;;;;;;WASRC,cAAcA;;;;;;;;;MA+CnBC,eAAeA;;;;;MAKfC,kBAAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC3cdC,WAAWA;;;;;;;;;;;;;;;;;;;iBAsBXC,QAAQA;;;;;iBAiBRC,UAAUA;;;;;;iBASVC,IAAIA;;;;;;iBA4BJC,IAAIA;;;;;;;;;;;;;;;;iBAkDJC,eAAeA;;;;;;;;;;;;;;iBAmBfC,YAAYA;;;;;;;cCrOfC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC4EJC,QAAQA;;;;;;iBC4BFC,UAAUA;;;;;;iBAkCVC,WAAWA;;;;;iBAgFjBC,oBAAoBA;;;;;;;;;;;iBC3MpBC,gBAAgBA;;;;;;;;;iBCsHVC,SAASA;;;;;;;;;cCrIlBC,OAAOA;;;;;cAKPC,GAAGA;;;;;cAKHC,QAAQA;;;;;cAKRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;iBCYJC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;iBAgDXC,OAAOA;;;;;;;iBCupEDC,WAAWA;;;;;;;;;;;iBA9UjBC,aAAaA;;;;;;;;;;;;iBAiBbC,cAAcA;;;;;;;;;;iBAedC,UAAUA;;;;;iBASVC,qBAAqBA;;;;;;;;;;iBA8BrBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCJC,UAAUA;;;;iBA0BVC,aAAaA;;;;;iBAebC,UAAUA;;;;;;;;;;;;;;iBAqBJC,WAAWA;;;;;;;;;;;;;;;;;;iBAoCXC,WAAWA;;;;;iBAsCjBC,SAASA;;;;;iBA+CTC,YAAYA;MVhiEhBlE,YAAYA;;;;;;;;;;;;;;YWlJbmE,IAAIA;;;;;;;;;YASJC,MAAMA;;MAEZC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBAC,OAAOA;;;;;;;;;;;;;;;;;iBAiBPC,KAAKA;;;;;iBAKLC,YAAYA;;;;;;;;;;;;;;;;;;;;;;iBChDZC,IAAIA;;;;;;;;iBCOJC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MZicnBC,8BAA8BA;MDhU9B3E,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cc1GX4E,IAAIA;;;;;cAQJC,UAAUA;;;;;;;;;;;cAMVC,OAAOA;;;;;;;;;iBCrDPC,SAASA;;;;;;;;;;;;;;;cAyBTH,IAAIA;;;;;;;;;;cAiBJC,UAAUA;;;;;;;;cAeVC,OAAOA",
 	"ignoreList": []
 }