@sveltejs/vite-plugin-svelte 6.0.0-next.1 → 6.0.0-next.2

package/src/utils/compile.js

@@ -2,10 +2,7 @@ import * as svelte from 'svelte/compiler';
 import { safeBase64Hash } from './hash.js';
 import { log } from './log.js';
 
-import {
-	checkPreprocessDependencies,
-	createInjectScopeEverythingRulePreprocessorGroup
-} from './preprocess.js';
+import { checkPreprocessDependencies } from './preprocess.js';
 import { mapToRelative } from './sourcemaps.js';
 import { enhanceCompileError } from './error.js';
 
@@ -21,9 +18,8 @@ const scriptLangRE =
 export function createCompileSvelte() {
 	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
 	let stats;
-	const devStylePreprocessor = createInjectScopeEverythingRulePreprocessorGroup();
 	/** @type {import('../types/compile.d.ts').CompileSvelte} */
-	return async function compileSvelte(svelteRequest, code, options) {
+	return async function compileSvelte(svelteRequest, code, options, preprocessed) {
 		const { filename, normalizedFilename, cssId, ssr, raw } = svelteRequest;
 		const { emitCss = true } = options;
 		/** @type {string[]} */
@@ -55,6 +51,7 @@ export function createCompileSvelte() {
 				// also they for hmr updates too
 			}
 		}
+
 		/** @type {import('svelte/compiler').CompileOptions} */
 		const compileOptions = {
 			...options.compilerOptions,
@@ -62,31 +59,7 @@ export function createCompileSvelte() {
 			generate: ssr ? 'server' : 'client'
 		};
 
-		if (compileOptions.hmr && options.emitCss) {
-			const hash = `s-${safeBase64Hash(normalizedFilename)}`;
-			compileOptions.cssHash = () => hash;
-		}
-
-		let preprocessed;
-		let preprocessors = options.preprocess;
-		if (!options.isBuild && options.emitCss && compileOptions.hmr) {
-			// inject preprocessor that ensures css hmr works better
-			if (!Array.isArray(preprocessors)) {
-				preprocessors = preprocessors
-					? [preprocessors, devStylePreprocessor]
-					: [devStylePreprocessor];
-			} else {
-				preprocessors = preprocessors.concat(devStylePreprocessor);
-			}
-		}
-		if (preprocessors) {
-			try {
-				preprocessed = await svelte.preprocess(code, preprocessors, { filename }); // full filename here so postcss works
-			} catch (e) {
-				e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ''}`;
-				throw e;
-			}
-
+		if (preprocessed) {
 			if (preprocessed.dependencies?.length) {
 				const checked = checkPreprocessDependencies(filename, preprocessed.dependencies);
 				if (checked.warnings.length) {
@@ -99,16 +72,19 @@ export function createCompileSvelte() {
 
 			if (preprocessed.map) compileOptions.sourcemap = preprocessed.map;
 		}
-		if (typeof preprocessed?.map === 'object') {
-			mapToRelative(preprocessed?.map, filename);
-		}
-		if (raw && svelteRequest.query.type === 'preprocessed') {
-			// @ts-expect-error shortcut
-			return /** @type {import('../types/compile.d.ts').CompileData} */ {
-				preprocessed: preprocessed ?? { code }
-			};
+
+		let finalCode = code;
+		if (compileOptions.hmr && options.emitCss) {
+			const hash = `s-${safeBase64Hash(normalizedFilename)}`;
+			compileOptions.cssHash = () => hash;
+			const closeStylePos = code.lastIndexOf('</style>');
+			if (closeStylePos > -1) {
+				// inject rule that forces compile to attach scope class to every node in the template
+				// this reduces the amount of js hot updates when editing css in .svelte files
+				finalCode = finalCode.slice(0, closeStylePos) + ' *{}' + finalCode.slice(closeStylePos);
+			}
 		}
-		const finalCode = preprocessed ? preprocessed.code : code;
+
 		const dynamicCompileOptions = await options?.dynamicCompileOptions?.({
 			filename,
 			code: finalCode,
@@ -145,7 +121,7 @@ export function createCompileSvelte() {
 				);
 			}
 		} catch (e) {
-			enhanceCompileError(e, code, preprocessors);
+			enhanceCompileError(e, code, options.preprocess);
 			throw e;
 		}
 
@@ -181,6 +157,7 @@ export function createCompileSvelte() {
 		return {
 			filename,
 			normalizedFilename,
+			cssId,
 			lang,
 			compiled,
 			ssr,

package/src/utils/constants.js

@@ -30,7 +30,4 @@ export const DEFAULT_SVELTE_EXT = ['.svelte'];
 export const DEFAULT_SVELTE_MODULE_INFIX = ['.svelte.'];
 export const DEFAULT_SVELTE_MODULE_EXT = ['.js', '.ts'];
 
-export const SVELTE_VIRTUAL_STYLE_SUFFIX = '?svelte&type=style&lang.css';
-export const SVELTE_VIRTUAL_STYLE_ID_REGEX = new RegExp(
-	`${SVELTE_VIRTUAL_STYLE_SUFFIX.replace(/[?.]/g, '\\$&')}$`
-);
+export const SVELTE_VIRTUAL_STYLE_ID_REGEX = /[?&]svelte&type=style&lang.css$/;

package/src/utils/dependencies.js

@@ -1,32 +1,3 @@
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { findDepPkgJsonPath } from 'vitefu';
-
-/**
- * @typedef {{
- *  dir: string;
- *	pkg: Record<string, any>;
- * }} DependencyData
- */
-
-/**
- * @param {string} dep
- * @param {string} parent
- * @returns {Promise<DependencyData | undefined>}
- */
-export async function resolveDependencyData(dep, parent) {
-	const depDataPath = await findDepPkgJsonPath(dep, parent);
-	if (!depDataPath) return undefined;
-	try {
-		return {
-			dir: path.dirname(depDataPath),
-			pkg: JSON.parse(await fs.readFile(depDataPath, 'utf-8'))
-		};
-	} catch {
-		return undefined;
-	}
-}
-
 const COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD = [
 	'@lukeed/uuid',
 	'@playwright/test',

package/src/utils/id.js

@@ -5,7 +5,8 @@ import { log } from './log.js';
 import {
 	DEFAULT_SVELTE_EXT,
 	DEFAULT_SVELTE_MODULE_EXT,
-	DEFAULT_SVELTE_MODULE_INFIX
+	DEFAULT_SVELTE_MODULE_INFIX,
+	SVELTE_VIRTUAL_STYLE_ID_REGEX
 } from './constants.js';
 import { arraify } from './options.js';
 
@@ -179,13 +180,15 @@ export function buildIdFilter(options) {
 			.map(escapeRE)
 			.join('|')})(?:[?#]|$)`
 	);
-	const filter = {
+	return {
 		id: {
 			include: [extensionsRE, .../**@type {Array<string|RegExp>}*/ arraify(include)],
-			exclude: /**@type {Array<string|RegExp>}*/ arraify(exclude)
+			exclude: /**@type {Array<string|RegExp>}*/ [
+				SVELTE_VIRTUAL_STYLE_ID_REGEX, // exclude from regular pipeline, we load it in a separate plugin
+				...arraify(exclude)
+			]
 		}
 	};
-	return filter;
 }
 
 /**

package/src/utils/options.js

@@ -5,11 +5,9 @@ const {
 	defaultServerMainFields,
 	defaultClientConditions,
 	defaultServerConditions,
-	normalizePath,
-	//@ts-expect-error rolldownVersion not in type
-	rolldownVersion
+	normalizePath
 } = vite;
-import { isDebugNamespaceEnabled, log } from './log.js';
+import { log } from './log.js';
 import { loadSvelteConfig } from './load-svelte-config.js';
 import {
 	DEFAULT_SVELTE_EXT,
@@ -20,12 +18,6 @@ import {
 } from './constants.js';
 
 import path from 'node:path';
-import {
-	optimizeSvelteModulePluginName,
-	optimizeSveltePluginName,
-	patchESBuildOptimizerPlugin,
-	patchRolldownOptimizerPlugin
-} from './optimizer-plugins.js';
 import { addExtraPreprocessors } from './preprocess.js';
 import deepmerge from 'deepmerge';
 import {
@@ -37,7 +29,6 @@ import {
 } from 'vitefu';
 
 import { isCommonDepWithoutSvelteField } from './dependencies.js';
-import { VitePluginSvelteStats } from './vite-plugin-svelte-stats.js';
 
 const allowedPluginOptions = new Set([
 	'include',
@@ -198,10 +189,9 @@ function mergeConfigs(...configs) {
  *
  * @param {import('../types/options.d.ts').PreResolvedOptions} preResolveOptions
  * @param {import('vite').ResolvedConfig} viteConfig
- * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
  * @returns {import('../types/options.d.ts').ResolvedOptions}
  */
-export function resolveOptions(preResolveOptions, viteConfig, cache) {
+export function resolveOptions(preResolveOptions, viteConfig) {
 	const css = preResolveOptions.emitCss ? 'external' : 'injected';
 	/** @type {Partial<import('../public.d.ts').Options>} */
 	const defaultOptions = {
@@ -230,10 +220,7 @@ export function resolveOptions(preResolveOptions, viteConfig, cache) {
 	addExtraPreprocessors(merged, viteConfig);
 	enforceOptionsForHmr(merged, viteConfig);
 	enforceOptionsForProduction(merged);
-	// mergeConfigs would mangle functions on the stats class, so do this afterwards
-	if (log.debug.enabled && isDebugNamespaceEnabled('stats')) {
-		merged.stats = new VitePluginSvelteStats(cache);
-	}
+
 	return merged;
 }
 
@@ -384,46 +371,6 @@ export async function buildExtraViteConfig(options, config) {
 		]
 	};
 
-	// handle prebundling for svelte files
-	if (options.prebundleSvelteLibraries) {
-		extraViteConfig.optimizeDeps = {
-			...extraViteConfig.optimizeDeps,
-			// Experimental Vite API to allow these extensions to be scanned and prebundled
-			extensions: options.extensions ?? ['.svelte']
-		};
-		// Add optimizer plugins to prebundle Svelte files.
-		// Currently a placeholder as more information is needed after Vite config is resolved,
-		// the added plugins are patched in `patchResolvedViteConfig()`
-		if (rolldownVersion) {
-			/**
-			 *
-			 * @param {string} name
-			 * @returns {import('vite').Rollup.Plugin}
-			 */
-			const placeholderRolldownOptimizerPlugin = (name) => ({
-				name,
-				options() {},
-				buildStart() {},
-				buildEnd() {},
-				transform: { filter: { id: /^$/ }, handler() {} }
-			});
-			//@ts-expect-error rolldown types not finished
-			extraViteConfig.optimizeDeps.rollupOptions = {
-				plugins: [
-					placeholderRolldownOptimizerPlugin(optimizeSveltePluginName),
-					placeholderRolldownOptimizerPlugin(optimizeSvelteModulePluginName)
-				]
-			};
-		} else {
-			extraViteConfig.optimizeDeps.esbuildOptions = {
-				plugins: [
-					{ name: optimizeSveltePluginName, setup: () => {} },
-					{ name: optimizeSvelteModulePluginName, setup: () => {} }
-				]
-			};
-		}
-	}
-
 	// enable hmrPartialAccept if not explicitly disabled
 	if (config.experimental?.hmrPartialAccept !== false) {
 		log.debug('enabling "experimental.hmrPartialAccept" in vite config', undefined, 'config');
@@ -607,38 +554,6 @@ function buildExtraConfigForSvelte(config) {
 	return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 
-/**
- * @param {import('vite').ResolvedConfig} viteConfig
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- */
-export function patchResolvedViteConfig(viteConfig, options) {
-	if (options.preprocess) {
-		for (const preprocessor of arraify(options.preprocess)) {
-			if (preprocessor.style && '__resolvedConfig' in preprocessor.style) {
-				preprocessor.style.__resolvedConfig = viteConfig;
-			}
-		}
-	}
-	if (rolldownVersion) {
-		const plugins =
-			// @ts-expect-error not typed
-			viteConfig.optimizeDeps.rollupOptions?.plugins?.filter((p) =>
-				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-			) ?? [];
-		for (const plugin of plugins) {
-			patchRolldownOptimizerPlugin(plugin, options);
-		}
-	} else {
-		const plugins =
-			viteConfig.optimizeDeps.esbuildOptions?.plugins?.filter((p) =>
-				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-			) ?? [];
-		for (const plugin of plugins) {
-			patchESBuildOptimizerPlugin(plugin, options);
-		}
-	}
-}
-
 /**
  * Mutates `config` to ensure `resolve.mainFields` is set. If unset, it emulates Vite's default fallback.
  * @param {string} name

package/src/utils/preprocess.js

@@ -1,33 +1,6 @@
-import MagicString from 'magic-string';
 import { log } from './log.js';
-import path from 'node:path';
 import { normalizePath } from 'vite';
 
-/**
- * this appends a *{} rule to component styles to force the svelte compiler to add style classes to all nodes
- * That means adding/removing class rules from <style> node won't trigger js updates as the scope classes are not changed
- *
- * only used during dev with enabled css hmr
- *
- * @returns {import('svelte/compiler').PreprocessorGroup}
- */
-export function createInjectScopeEverythingRulePreprocessorGroup() {
-	return {
-		name: 'inject-scope-everything-rule',
-		style({ content, filename }) {
-			const s = new MagicString(content);
-			s.append(' *{}');
-			return {
-				code: s.toString(),
-				map: s.generateDecodedMap({
-					source: filename ? path.basename(filename) : undefined,
-					hires: true
-				})
-			};
-		}
-	};
-}
-
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  * @param {import('vite').ResolvedConfig} config
@@ -42,28 +15,13 @@ function buildExtraPreprocessors(options, config) {
 	/** @type {import('svelte/compiler').PreprocessorGroup[]} */
 	const appendPreprocessors = [];
 
-	// @ts-expect-error not typed
-	const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p?.sveltePreprocess);
+	const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p.api?.sveltePreprocess);
 	if (pluginsWithPreprocessorsDeprecated.length > 0) {
 		log.warn(
-			`The following plugins use the deprecated 'plugin.sveltePreprocess' field. Please contact their maintainers and ask them to move it to 'plugin.api.sveltePreprocess': ${pluginsWithPreprocessorsDeprecated
+			`The following plugins use the deprecated 'plugin.api.sveltePreprocess' field. Please contact their maintainers and ask them to use a vite plugin transform instead: ${pluginsWithPreprocessorsDeprecated
 				.map((p) => p.name)
 				.join(', ')}`
 		);
-		// patch plugin to avoid breaking
-		pluginsWithPreprocessorsDeprecated.forEach((p) => {
-			if (!p.api) {
-				p.api = {};
-			}
-			if (p.api.sveltePreprocess === undefined) {
-				// @ts-expect-error not typed
-				p.api.sveltePreprocess = p.sveltePreprocess;
-			} else {
-				log.error(
-					`ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`
-				);
-			}
-		});
 	}
 	/** @type {import('vite').Plugin[]} */
 	const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);

package/src/utils/vite-plugin-svelte-cache.js

@@ -1,17 +1,3 @@
-import { readFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { findClosestPkgJsonPath } from 'vitefu';
-import { normalizePath } from 'vite';
-
-/**
- * @typedef {{
- * 	name: string;
- * 	version: string;
- * 	svelte?: string;
- * 	path: string;
- * }} PackageInfo
- */
-
 /**
  * @class
  */
@@ -26,8 +12,6 @@ export class VitePluginSvelteCache {
 	#dependants = new Map();
 	/** @type {Map<string, any>} */
 	#errors = new Map();
-	/** @type {PackageInfo[]} */
-	#packageInfos = [];
 
 	/**
 	 * @param {import('../types/compile.d.ts').CompileData} compileData
@@ -149,6 +133,7 @@ export class VitePluginSvelteCache {
 			return this.#js.get(svelteRequest.normalizedFilename);
 		}
 	}
+
 	/**
 	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
 	 * @returns {any}
@@ -165,48 +150,4 @@ export class VitePluginSvelteCache {
 		const dependants = this.#dependants.get(path);
 		return dependants ? [...dependants] : [];
 	}
-
-	/**
-	 * @param {string} file
-	 * @returns {Promise<PackageInfo>}
-	 */
-	async getPackageInfo(file) {
-		let info = this.#packageInfos.find((pi) => file.startsWith(pi.path));
-		if (!info) {
-			info = await findPackageInfo(file);
-			this.#packageInfos.push(info);
-		}
-		return info;
-	}
-}
-
-/**
- * utility to get some info from the closest package.json with a "name" set
- *
- * @param {string} file to find info for
- * @returns {Promise<PackageInfo>}
- */
-async function findPackageInfo(file) {
-	/** @type {PackageInfo} */
-	const info = {
-		name: '$unknown',
-		version: '0.0.0-unknown',
-		path: '$unknown'
-	};
-	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
-		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-		if (pkg.name != null) {
-			info.name = pkg.name;
-			if (pkg.version != null) {
-				info.version = pkg.version;
-			}
-			info.svelte = pkg.svelte;
-			return true;
-		}
-		return false;
-	});
-	// return normalized path with appended '/' so .startsWith works for future file checks
-	path = normalizePath(dirname(path ?? file)) + '/';
-	info.path = path;
-	return info;
 }

package/src/utils/vite-plugin-svelte-stats.js

@@ -1,6 +1,9 @@
 import { log } from './log.js';
 import { performance } from 'node:perf_hooks';
 import { normalizePath } from 'vite';
+import { findClosestPkgJsonPath } from 'vitefu';
+import { readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 /** @type {import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions} */
 const defaultCollectionOptions = {
@@ -63,19 +66,12 @@ function formatPackageStats(pkgStats) {
  * @class
  */
 export class VitePluginSvelteStats {
-	// package directory -> package name
-	/** @type {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} */
-	#cache;
+	/** @type {PackageInfo[]} */
+	#packageInfos = [];
+
 	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection[]} */
 	#collections = [];
 
-	/**
-	 * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
-	 */
-	constructor(cache) {
-		this.#cache = cache;
-	}
-
 	/**
 	 * @param {string} name
 	 * @param {Partial<import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions>} [opts]
@@ -173,7 +169,7 @@ export class VitePluginSvelteStats {
 	async #aggregateStatsResult(collection) {
 		const stats = collection.stats;
 		for (const stat of stats) {
-			stat.pkg = (await this.#cache.getPackageInfo(stat.file)).name;
+			stat.pkg = (await this.#getPackageInfo(stat.file)).name;
 		}
 
 		// group stats
@@ -197,4 +193,56 @@ export class VitePluginSvelteStats {
 		groups.sort((a, b) => b.duration - a.duration);
 		collection.packageStats = groups;
 	}
+	/**
+	 * @param {string} file
+	 * @returns {Promise<PackageInfo>}
+	 */
+	async #getPackageInfo(file) {
+		let info = this.#packageInfos.find((pi) => file.startsWith(pi.path));
+		if (!info) {
+			info = await findPackageInfo(file);
+			this.#packageInfos.push(info);
+		}
+		return info;
+	}
+}
+
+/**
+ * @typedef {{
+ * 	name: string;
+ * 	version: string;
+ * 	svelte?: string;
+ * 	path: string;
+ * }} PackageInfo
+ */
+
+/**
+ * utility to get some info from the closest package.json with a "name" set
+ *
+ * @param {string} file to find info for
+ * @returns {Promise<PackageInfo>}
+ */
+async function findPackageInfo(file) {
+	/** @type {PackageInfo} */
+	const info = {
+		name: '$unknown',
+		version: '0.0.0-unknown',
+		path: '$unknown'
+	};
+	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
+		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+		if (pkg.name != null) {
+			info.name = pkg.name;
+			if (pkg.version != null) {
+				info.version = pkg.version;
+			}
+			info.svelte = pkg.svelte;
+			return true;
+		}
+		return false;
+	});
+	// return normalized path with appended '/' so .startsWith works for future file checks
+	path = normalizePath(dirname(path ?? file)) + '/';
+	info.path = path;
+	return info;
 }

package/src/utils/watch.js

@@ -6,10 +6,9 @@ import path from 'node:path';
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
- * @param {import('../types/id.d.ts').IdParser} requestParser
  * @returns {void}
  */
-export function setupWatchers(options, cache, requestParser) {
+export function setupWatchers(options, cache) {
 	const { server, configFile: svelteConfigFile } = options;
 	if (!server) {
 		return;
@@ -30,16 +29,7 @@ export function setupWatchers(options, cache, requestParser) {
 			}
 		});
 	};
-	/** @type {(filename: string) => void} */
-	const removeUnlinkedFromCache = (filename) => {
-		const svelteRequest = requestParser(filename, false);
-		if (svelteRequest) {
-			const removedFromCache = cache.remove(svelteRequest);
-			if (removedFromCache) {
-				log.debug(`cleared VitePluginSvelteCache for deleted file ${filename}`, undefined, 'hmr');
-			}
-		}
-	};
+
 	/** @type {(filename: string) => void} */
 	const triggerViteRestart = (filename) => {
 		if (serverConfig.middlewareMode) {
@@ -63,7 +53,7 @@ export function setupWatchers(options, cache, requestParser) {
 	const listenerCollection = {
 		add: [],
 		change: [emitChangeEventOnDependants],
-		unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
+		unlink: [emitChangeEventOnDependants]
 	};
 
 	if (svelteConfigFile !== false) {

package/types/index.d.ts

@@ -206,6 +206,11 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 */
 		style?: boolean | InlineConfig | ResolvedConfig;
 	}
+	/**
+	 * returns a list of plugins to handle svelte files
+	 * plugins are named `vite-plugin-svelte:<task>`
+	 *
+	 * */
 	export function svelte(inlineOptions?: Partial<Options>): import("vite").Plugin[];
 	export function vitePreprocess(opts?: VitePreprocessOptions): import("svelte/compiler").PreprocessorGroup;
 	export function loadSvelteConfig(viteConfig?: import("vite").UserConfig, inlineOptions?: Partial<Options>): Promise<Partial<SvelteConfig> | undefined>;

package/types/index.d.ts.map

@@ -26,6 +26,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;iBC/JtBC,MAAMA;iBCXNC,cAAcA;iBCFRC,gBAAgBA",
+	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;;;;;;iBChLtBC,MAAMA;iBCMNC,cAAcA;iBCFRC,gBAAgBA",
 	"ignoreList": []
 }