Configuration

import const adapter: () => import("@sveltejs/kit").Adapteradapter from '@sveltejs/adapter-auto';

/** @type {import('@sveltejs/kit').Config} */
const const config: Config
@type{import('@sveltejs/kit').Config}config = {
	Config.kit?: KitConfig | undefined
SvelteKit options
kit: {
		KitConfig.adapter?: Adapter | undefined
Your adapter is run when executing vite build. It determines how the output is converted for different platforms.
@defaultundefinedadapter: function adapter(): import("@sveltejs/kit").Adapteradapter()
	}
};

export default const config: Config
@type{import('@sveltejs/kit').Config}config;

interface Config extends SvelteConfig {…}

kit?: KitConfig;

/** @type {import('@sveltejs/kit').Config} */
const 
const config: {
    kit: {
        alias: {
 'my-file': string;
 'my-directory': string;
            'my-directory/*': string;
        };
    };
}
@type{import('@sveltejs/kit').Config}config = {
	
kit: {
    alias: {
        'my-file': string;
        'my-directory': string;
        'my-directory/*': string;
    };
}kit: {
		
alias: {
    'my-file': string;
    'my-directory': string;
    'my-directory/*': string;
}alias: {
			// this will match a file
			'my-file': 'path/to/my-file.js',

			// this will match a directory and its contents
			// (`my-directory/x` resolves to `path/to/my-directory/x`)
			'my-directory': 'path/to/my-directory',

			// an alias ending /* will only match
			// the contents of a directory, not the directory itself
			'my-directory/*': 'path/to/my-directory/*'
		}
	}
};

/** @type {import('@sveltejs/kit').Config} */
const 
const config: {
    kit: {
        csp: {
 directives: {
   'script-src': string[];
 };
 reportOnly: {
   'script-src': string[];
   'report-uri': string[];
 };
        };
    };
}
@type{import('@sveltejs/kit').Config}config = {
	
kit: {
    csp: {
        directives: {
 'script-src': string[];
        };
        reportOnly: {
 'script-src': string[];
 'report-uri': string[];
        };
    };
}kit: {
		
csp: {
    directives: {
        'script-src': string[];
    };
    reportOnly: {
        'script-src': string[];
        'report-uri': string[];
    };
}csp: {
			
directives: {
    'script-src': string[];
}directives: {
				'script-src': ['self']
			},
			// must be specified with either the `report-uri` or `report-to` directives, or both
			
reportOnly: {
    'script-src': string[];
    'report-uri': string[];
}reportOnly: {
				'script-src': ['self'],
				'report-uri': ['/']
			}
		}
	}
};

export default 
const config: {
    kit: {
        csp: {
 directives: {
   'script-src': string[];
 };
 reportOnly: {
   'script-src': string[];
   'report-uri': string[];
            };
        };
    };
}
@type{import('@sveltejs/kit').Config}config;

mode?: 'hash' | 'nonce' | 'auto';

directives?: CspDirectives;

reportOnly?: CspDirectives;

checkOrigin?: boolean;

publicPrefix?: string;

privatePrefix?: string;

assets?: string;

client?: string;

server?: string;

universal?: string;

params?: string;

routes?: string;

serviceWorker?: string;

appTemplate?: string;

errorTemplate?: string;

preloadStrategy?: 'modulepreload' | 'preload-js' | 'preload-mjs';

bundleStrategy?: 'split' | 'single' | 'inline';

import { function sveltekit(): Promise<Plugin$1<any>[]>
Returns the SvelteKit Vite plugins.
sveltekit } from '@sveltejs/kit/vite';
import { function defineConfig(config: UserConfig): UserConfig (+5 overloads)
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
defineConfig } from 'vite';

export default function defineConfig(config: UserConfig): UserConfig (+5 overloads)
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
defineConfig({
	UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
plugins: [function sveltekit(): Promise<Plugin$1<any>[]>
Returns the SvelteKit Vite plugins.
sveltekit()],
	build?: BuildEnvironmentOptions | undefined
Build specific options
build: {
		// inline all imported assets
		BuildEnvironmentOptions.assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined) | undefined
Static asset files smaller than this number (in bytes) will be inlined as
base64 strings. If a callback is passed, a boolean can be returned to opt-in
or opt-out of inlining. If nothing is returned the default logic applies.
Default limit is 4096 (4 KiB). Set to 0 to disable.
@default4096assetsInlineLimit: var Infinity: numberInfinity
	}
});

<script>
	// import the asset through Vite
	import favicon from './favicon.png';
</script>

<svelte:head>
	<!-- this asset will be inlined as a base64 URL -->
	<link rel="icon" href={favicon} />
</svelte:head>

<script lang="ts">
	// import the asset through Vite
	import favicon from './favicon.png';
</script>

<svelte:head>
	<!-- this asset will be inlined as a base64 URL -->
	<link rel="icon" href={favicon} />
</svelte:head>

assets?: '' | `http://${string}` | `https://${string}`;

base?: '' | `/${string}`;

relative?: boolean;

concurrency?: number;

crawl?: boolean;

entries?: var Array: ArrayConstructorArray<'*' | `/${string}`>;

handleHttpError?: PrerenderHttpErrorHandlerValue;

/** @type {import('@sveltejs/kit').Config} */
const 
const config: {
    kit: {
        prerender: {
 handleHttpError: ({ path, referrer, message }: {
   path: any;
   referrer: any;
     message: any;
 }) => void;
        };
    };
}
@type{import('@sveltejs/kit').Config}config = {
	
kit: {
    prerender: {
        handleHttpError: ({ path, referrer, message }: {
 path: any;
 referrer: any;
 message: any;
        }) => void;
    };
}kit: {
		
prerender: {
    handleHttpError: ({ path, referrer, message }: {
        path: any;
        referrer: any;
        message: any;
    }) => void;
}prerender: {
			
handleHttpError: ({ path, referrer, message }: {
    path: any;
    referrer: any;
    message: any;
}) => voidhandleHttpError: ({ path: anypath, referrer: anyreferrer, message: anymessage }) => {
				// ignore deliberate link to shiny 404 page
				if (path: anypath === '/not-found' && referrer: anyreferrer === '/blog/how-we-built-our-404-page') {
					return;
				}

				// otherwise fail the build
				throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error(message: anymessage);
			}
		}
	}
};

handleMissingId?: PrerenderMissingIdHandlerValue;

handleEntryGeneratorMismatch?: PrerenderEntryGeneratorMismatchHandlerValue;

var origin: string
MDN Reference
origin?: string;

type?: 'pathname' | 'hash';

resolution?: 'client' | 'server';

register?: boolean;

files?(filepath: stringfilepath: string): boolean;

config?: (config: Record<string, any>config: type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
Record<string, any>) => Record<string, any> | void;

<script>
	import { beforeNavigate } from '$app/navigation';
	import { updated } from '$app/state';

	beforeNavigate(({ willUnload, to }) => {
		if (updated.current && !willUnload && to?.url) {
			location.href = to.url.href;
		}
	});
</script>

import * as module "node:child_process"child_process from 'node:child_process';

export default {
	
kit: {
    version: {
        name: string;
    };
}kit: {
		
version: {
    name: string;
}version: {
			name: stringname: module "node:child_process"child_process.function execSync(command: string): Buffer (+3 overloads)
The child_process.execSync() method is generally identical to 
{@link 
exec
}
 with the exception that the method will not return
until the child process has fully closed. When a timeout has been encountered
and killSignal is sent, the method won’t return until the process has
completely exited. If the child process intercepts and handles the SIGTERM signal and doesn’t exit, the parent process will wait until the child process
has exited.
If the process times out or has a non-zero exit code, this method will throw.
The Error object will contain the entire result from 
{@link 
spawnSync
}
.
Never pass unsanitized user input to this function. Any input containing shell
metacharacters may be used to trigger arbitrary command execution.
@sincev0.11.12
@paramcommand The command to run.
@returnThe stdout from the command.execSync('git rev-parse HEAD').Buffer<ArrayBufferLike>.toString(encoding?: BufferEncoding, start?: number, end?: number): string
Decodes buf to a string according to the specified character encoding inencoding. start and end may be passed to decode only a subset of buf.
If encoding is 'utf8' and a byte sequence in the input is not valid UTF-8,
then each invalid byte is replaced with the replacement character U+FFFD.
The maximum length of a string instance (in UTF-16 code units) is available
as 
{@link 
constants.MAX_STRING_LENGTH
}
.
import { Buffer } from 'node:buffer';

const buf1 = Buffer.allocUnsafe(26);

for (let i = 0; i &#x3C; 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

console.log(buf1.toString('utf8'));
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5));
// Prints: abcde

const buf2 = Buffer.from('tést');

console.log(buf2.toString('hex'));
// Prints: 74c3a97374
console.log(buf2.toString('utf8', 0, 3));
// Prints: té
console.log(buf2.toString(undefined, 0, 3));
// Prints: té
@sincev0.1.90
@paramencoding The character encoding to use.
@paramstart The byte offset to start decoding at.
@paramend The byte offset to stop decoding at (not inclusive).toString().String.trim(): string
Removes the leading and trailing white space and line terminator characters from a string.
trim()
		}
	}
};

pollInterval?: number;