@sveltejs/vite-plugin-svelte 1.3.1 → 2.0.0-beta.0

package/dist/index.js

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import { isDepExcluded as isDepExcluded2 } from "vitefu";
 
 // src/utils/log.ts
@@ -184,7 +184,7 @@ async function handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, option
     log.debug(`handleHotUpdate called before initial transform for ${svelteRequest.id}`);
     return;
   }
-  const { read, server } = ctx;
+  const { read, server, modules } = ctx;
   const cachedJS = cache.getJS(svelteRequest);
   const cachedCss = cache.getCSS(svelteRequest);
   const content = await read();
@@ -196,34 +196,35 @@ async function handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, option
     cache.setError(svelteRequest, e);
     throw e;
   }
-  const affectedModules = /* @__PURE__ */ new Set();
-  const cssModule = server.moduleGraph.getModuleById(svelteRequest.cssId);
-  const mainModule = server.moduleGraph.getModuleById(svelteRequest.id);
-  const cssUpdated = cssModule && cssChanged(cachedCss, compileData.compiled.css);
-  if (cssUpdated) {
-    log.debug(`handleHotUpdate css changed for ${svelteRequest.cssId}`);
-    affectedModules.add(cssModule);
-  }
-  const jsUpdated = mainModule && jsChanged(cachedJS, compileData.compiled.js, svelteRequest.filename);
-  if (jsUpdated) {
-    log.debug(`handleHotUpdate js changed for ${svelteRequest.id}`);
-    affectedModules.add(mainModule);
+  const affectedModules = [...modules];
+  const cssIdx = modules.findIndex((m) => m.id === svelteRequest.cssId);
+  if (cssIdx > -1) {
+    const cssUpdated = cssChanged(cachedCss, compileData.compiled.css);
+    if (!cssUpdated) {
+      log.debug(`skipping unchanged css for ${svelteRequest.cssId}`);
+      affectedModules.splice(cssIdx, 1);
+    }
   }
-  if (!jsUpdated) {
-    logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
+  const jsIdx = modules.findIndex((m) => m.id === svelteRequest.id);
+  if (jsIdx > -1) {
+    const jsUpdated = jsChanged(cachedJS, compileData.compiled.js, svelteRequest.filename);
+    if (!jsUpdated) {
+      log.debug(`skipping unchanged js for ${svelteRequest.id}`);
+      affectedModules.splice(jsIdx, 1);
+      logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
+    }
   }
-  const result = [...affectedModules].filter(Boolean);
-  const ssrModulesToInvalidate = result.filter((m) => !!m.ssrTransformResult);
+  const ssrModulesToInvalidate = affectedModules.filter((m) => !!m.ssrTransformResult);
   if (ssrModulesToInvalidate.length > 0) {
     log.debug(`invalidating modules ${ssrModulesToInvalidate.map((m) => m.id).join(", ")}`);
     ssrModulesToInvalidate.forEach((moduleNode) => server.moduleGraph.invalidateModule(moduleNode));
   }
-  if (result.length > 0) {
+  if (affectedModules.length > 0) {
     log.debug(
-      `handleHotUpdate for ${svelteRequest.id} result: ${result.map((m) => m.id).join(", ")}`
+      `handleHotUpdate for ${svelteRequest.id} result: ${affectedModules.map((m) => m.id).join(", ")}`
     );
   }
-  return result;
+  return affectedModules;
 }
 function cssChanged(prev, next) {
   return !isCodeEqual(prev?.code, next?.code);
@@ -260,7 +261,7 @@ function normalizeJsCode(code) {
 }
 
 // src/utils/compile.ts
-import { compile, preprocess, walk } from "svelte/compiler";
+import { compile, preprocess as preprocess2, walk } from "svelte/compiler";
 import { createMakeHot } from "svelte-hmr";
 
 // src/utils/hash.ts
@@ -287,12 +288,210 @@ function toSafe(base64) {
   return base64.replace(replaceRE, (x) => replacements[x]);
 }
 
+// src/utils/preprocess.ts
+import MagicString from "magic-string";
+import { preprocess } from "svelte/compiler";
+import path2 from "path";
+
+// src/preprocess.ts
+import path from "path";
+import * as vite from "vite";
+var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss", "sss"];
+var supportedScriptLangs = ["ts"];
+function vitePreprocess(opts) {
+  const preprocessor = {};
+  if (opts?.script !== false) {
+    preprocessor.script = viteScript().script;
+  }
+  if (opts?.style !== false) {
+    const styleOpts = typeof opts?.style == "object" ? opts?.style : void 0;
+    preprocessor.style = viteStyle(styleOpts).style;
+  }
+  return preprocessor;
+}
+function viteScript() {
+  return {
+    async script({ attributes, content, filename = "" }) {
+      const lang = attributes.lang;
+      if (!supportedScriptLangs.includes(lang))
+        return;
+      const transformResult = await vite.transformWithEsbuild(content, filename, {
+        loader: lang,
+        target: "esnext",
+        tsconfigRaw: {
+          compilerOptions: {
+            importsNotUsedAsValues: "preserve",
+            preserveValueImports: true
+          }
+        }
+      });
+      return {
+        code: transformResult.code,
+        map: transformResult.map
+      };
+    }
+  };
+}
+function viteStyle(config = {}) {
+  let transform;
+  const style = async ({ attributes, content, filename = "" }) => {
+    const lang = attributes.lang;
+    if (!supportedStyleLangs.includes(lang))
+      return;
+    if (!transform) {
+      let resolvedConfig;
+      if (style.__resolvedConfig) {
+        resolvedConfig = style.__resolvedConfig;
+      } else if (isResolvedConfig(config)) {
+        resolvedConfig = config;
+      } else {
+        resolvedConfig = await vite.resolveConfig(
+          config,
+          process.env.NODE_ENV === "production" ? "build" : "serve"
+        );
+      }
+      transform = getCssTransformFn(resolvedConfig);
+    }
+    const moduleId = `${filename}.${lang}`;
+    const result = await transform(content, moduleId);
+    if (result.map?.sources?.[0] === moduleId) {
+      result.map.sources[0] = path.basename(filename);
+    }
+    return {
+      code: result.code,
+      map: result.map ?? void 0
+    };
+  };
+  style.__resolvedConfig = null;
+  return { style };
+}
+function getCssTransformFn(config) {
+  if (vite.preprocessCSS) {
+    return async (code, filename) => {
+      return vite.preprocessCSS(code, filename, config);
+    };
+  } else {
+    const pluginName = "vite:css";
+    const plugin = config.plugins.find((p) => p.name === pluginName);
+    if (!plugin) {
+      throw new Error(`failed to find plugin ${pluginName}`);
+    }
+    if (!plugin.transform) {
+      throw new Error(`plugin ${pluginName} has no transform`);
+    }
+    return plugin.transform.bind(null);
+  }
+}
+function isResolvedConfig(config) {
+  return !!config.inlineConfig;
+}
+
+// src/utils/preprocess.ts
+function createVitePreprocessorGroup(config) {
+  return {
+    markup({ content, filename }) {
+      return preprocess(content, vitePreprocess({ style: config }), { filename });
+    }
+  };
+}
+function createInjectScopeEverythingRulePreprocessorGroup() {
+  return {
+    style({ content, filename }) {
+      const s = new MagicString(content);
+      s.append(" *{}");
+      return {
+        code: s.toString(),
+        map: s.generateDecodedMap({
+          source: filename ? path2.basename(filename) : void 0,
+          hires: true
+        })
+      };
+    }
+  };
+}
+function buildExtraPreprocessors(options, config) {
+  const prependPreprocessors = [];
+  const appendPreprocessors = [];
+  if (options.experimental?.useVitePreprocess) {
+    log.warn(
+      "`experimental.useVitePreprocess` is deprecated. Use the `vitePreprocess()` preprocessor instead. See https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/preprocess.md for more information."
+    );
+    prependPreprocessors.push(createVitePreprocessorGroup(config));
+  }
+  const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p?.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.map((p) => p.name).join(", ")}`
+    );
+    pluginsWithPreprocessorsDeprecated.forEach((p) => {
+      if (!p.api) {
+        p.api = {};
+      }
+      if (p.api.sveltePreprocess === void 0) {
+        p.api.sveltePreprocess = p.sveltePreprocess;
+      } else {
+        log.error(
+          `ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`
+        );
+      }
+    });
+  }
+  const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);
+  const ignored = [], included = [];
+  for (const p of pluginsWithPreprocessors) {
+    if (options.ignorePluginPreprocessors === true || Array.isArray(options.ignorePluginPreprocessors) && options.ignorePluginPreprocessors?.includes(p.name)) {
+      ignored.push(p);
+    } else {
+      included.push(p);
+    }
+  }
+  if (ignored.length > 0) {
+    log.debug(
+      `Ignoring svelte preprocessors defined by these vite plugins: ${ignored.map((p) => p.name).join(", ")}`
+    );
+  }
+  if (included.length > 0) {
+    log.debug(
+      `Adding svelte preprocessors defined by these vite plugins: ${included.map((p) => p.name).join(", ")}`
+    );
+    appendPreprocessors.push(...pluginsWithPreprocessors.map((p) => p.api.sveltePreprocess));
+  }
+  return { prependPreprocessors, appendPreprocessors };
+}
+function addExtraPreprocessors(options, config) {
+  const { prependPreprocessors, appendPreprocessors } = buildExtraPreprocessors(options, config);
+  if (prependPreprocessors.length > 0 || appendPreprocessors.length > 0) {
+    if (!options.preprocess) {
+      options.preprocess = [...prependPreprocessors, ...appendPreprocessors];
+    } else if (Array.isArray(options.preprocess)) {
+      options.preprocess.unshift(...prependPreprocessors);
+      options.preprocess.push(...appendPreprocessors);
+    } else {
+      options.preprocess = [...prependPreprocessors, options.preprocess, ...appendPreprocessors];
+    }
+  }
+}
+
 // src/utils/compile.ts
+import path3 from "path";
 var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
+function mapSourcesToRelative(map, filename) {
+  if (map?.sources) {
+    map.sources = map.sources.map((s) => {
+      if (path3.isAbsolute(s)) {
+        const relative = path3.relative(filename, s);
+        return relative === "" ? path3.basename(filename) : relative;
+      } else {
+        return s;
+      }
+    });
+  }
+}
 var _createCompileSvelte = (makeHot) => {
   let stats;
+  const devStylePreprocessor = createInjectScopeEverythingRulePreprocessorGroup();
   return async function compileSvelte2(svelteRequest, code, options) {
-    const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
+    const { filename, normalizedFilename, cssId, ssr, raw } = svelteRequest;
     const { emitCss = true } = options;
     const dependencies = [];
     if (options.stats) {
@@ -314,7 +513,7 @@ var _createCompileSvelte = (makeHot) => {
     }
     const compileOptions = {
       ...options.compilerOptions,
-      filename,
+      filename: normalizedFilename,
       generate: ssr ? "ssr" : "dom",
       format: "esm"
     };
@@ -331,9 +530,17 @@ var _createCompileSvelte = (makeHot) => {
       }
     }
     let preprocessed;
-    if (options.preprocess) {
+    let preprocessors = options.preprocess;
+    if (!options.isBuild && options.emitCss && options.hot) {
+      if (!Array.isArray(preprocessors)) {
+        preprocessors = preprocessors ? [preprocessors, devStylePreprocessor] : [devStylePreprocessor];
+      } else {
+        preprocessors = preprocessors.concat(devStylePreprocessor);
+      }
+    }
+    if (preprocessors) {
       try {
-        preprocessed = await preprocess(code, options.preprocess, { filename });
+        preprocessed = await preprocess2(code, preprocessors, { filename });
       } catch (e) {
         e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
         throw e;
@@ -343,6 +550,12 @@ var _createCompileSvelte = (makeHot) => {
       if (preprocessed.map)
         compileOptions.sourcemap = preprocessed.map;
     }
+    if (typeof preprocessed?.map === "object") {
+      mapSourcesToRelative(preprocessed?.map, filename);
+    }
+    if (raw && svelteRequest.query.type === "preprocessed") {
+      return { preprocessed: preprocessed ?? { code } };
+    }
     const finalCode = preprocessed ? preprocessed.code : code;
     const dynamicCompileOptions = await options.experimental?.dynamicCompileOptions?.({
       filename,
@@ -363,21 +576,25 @@ var _createCompileSvelte = (makeHot) => {
     if (endStat) {
       endStat();
     }
-    const hasCss = compiled.css?.code?.trim().length > 0;
-    if (emitCss && hasCss) {
-      compiled.js.code += `
+    mapSourcesToRelative(compiled.js?.map, filename);
+    mapSourcesToRelative(compiled.css?.map, filename);
+    if (!raw) {
+      const hasCss = compiled.css?.code?.trim().length > 0;
+      if (emitCss && hasCss) {
+        compiled.js.code += `
 import ${JSON.stringify(cssId)};
 `;
-    }
-    if (!ssr && makeHot) {
-      compiled.js.code = makeHot({
-        id: filename,
-        compiledCode: compiled.js.code,
-        hotOptions: { ...options.hot, injectCss: options.hot?.injectCss === true && hasCss },
-        compiled,
-        originalCode: code,
-        compileOptions: finalCompileOptions
-      });
+      }
+      if (!ssr && makeHot) {
+        compiled.js.code = makeHot({
+          id: filename,
+          compiledCode: compiled.js.code,
+          hotOptions: { ...options.hot, injectCss: options.hot?.injectCss === true && hasCss },
+          compiled,
+          originalCode: code,
+          compileOptions: finalCompileOptions
+        });
+      }
     }
     compiled.js.dependencies = dependencies;
     return {
@@ -386,7 +603,8 @@ import ${JSON.stringify(cssId)};
       lang: code.match(scriptLangRE)?.[1] || "js",
       compiled,
       ssr,
-      dependencies
+      dependencies,
+      preprocessed: preprocessed ?? { code }
     };
   };
 };
@@ -414,6 +632,16 @@ import { normalizePath } from "vite";
 import * as fs from "fs";
 var VITE_FS_PREFIX = "/@fs/";
 var IS_WINDOWS = process.platform === "win32";
+var SUPPORTED_COMPILER_OPTIONS = [
+  "generate",
+  "dev",
+  "css",
+  "hydratable",
+  "customElement",
+  "immutable",
+  "enableSourcemap"
+];
+var TYPES_WITH_COMPILER_OPTIONS = ["style", "script", "all"];
 function splitId(id) {
   const parts = id.split(`?`, 2);
   const filename = parts[0];
@@ -422,9 +650,11 @@ function splitId(id) {
 }
 function parseToSvelteRequest(id, filename, rawQuery, root, timestamp, ssr) {
   const query = parseRequestQuery(rawQuery);
-  if (query.url || query.raw) {
+  const rawOrDirect = !!(query.raw || query.direct);
+  if (query.url || !query.svelte && rawOrDirect) {
     return;
   }
+  const raw = rawOrDirect;
   const normalizedFilename = normalize(filename, root);
   const cssId = createVirtualImportId(filename, root, "style");
   return {
@@ -434,7 +664,8 @@ function parseToSvelteRequest(id, filename, rawQuery, root, timestamp, ssr) {
     cssId,
     query,
     timestamp,
-    ssr
+    ssr,
+    raw
   };
 }
 function createVirtualImportId(filename, root, type) {
@@ -456,6 +687,33 @@ function parseRequestQuery(rawQuery) {
       query[key] = true;
     }
   }
+  const compilerOptions = query.compilerOptions;
+  if (compilerOptions) {
+    if (!((query.raw || query.direct) && TYPES_WITH_COMPILER_OPTIONS.includes(query.type))) {
+      throw new Error(
+        `Invalid compilerOptions in query ${rawQuery}. CompilerOptions are only supported for raw or direct queries with type in "${TYPES_WITH_COMPILER_OPTIONS.join(
+          ", "
+        )}" e.g. '?svelte&raw&type=script&compilerOptions={"generate":"ssr","dev":false}`
+      );
+    }
+    try {
+      const parsed = JSON.parse(compilerOptions);
+      const invalid = Object.keys(parsed).filter(
+        (key) => !SUPPORTED_COMPILER_OPTIONS.includes(key)
+      );
+      if (invalid.length) {
+        throw new Error(
+          `Invalid compilerOptions in query ${rawQuery}: ${invalid.join(
+            ", "
+          )}. Supported: ${SUPPORTED_COMPILER_OPTIONS.join(", ")}`
+        );
+      }
+      query.compilerOptions = parsed;
+    } catch (e) {
+      log.error("failed to parse request query compilerOptions", e);
+      throw e;
+    }
+  }
   return query;
 }
 function normalize(filename, normalizedRoot) {
@@ -491,7 +749,7 @@ import { normalizePath as normalizePath3 } from "vite";
 
 // src/utils/load-svelte-config.ts
 import { createRequire } from "module";
-import path from "path";
+import path4 from "path";
 import fs2 from "fs";
 import { pathToFileURL } from "url";
 var esmRequire;
@@ -557,13 +815,13 @@ async function loadSvelteConfig(viteConfig, inlineOptions) {
 function findConfigToLoad(viteConfig, inlineOptions) {
   const root = viteConfig?.root || process.cwd();
   if (inlineOptions?.configFile) {
-    const abolutePath = path.isAbsolute(inlineOptions.configFile) ? inlineOptions.configFile : path.resolve(root, inlineOptions.configFile);
+    const abolutePath = path4.isAbsolute(inlineOptions.configFile) ? inlineOptions.configFile : path4.resolve(root, inlineOptions.configFile);
     if (!fs2.existsSync(abolutePath)) {
       throw new Error(`failed to find svelte config file ${abolutePath}.`);
     }
     return abolutePath;
   } else {
-    const existingKnownConfigFiles = knownSvelteConfigNames.map((candidate) => path.resolve(root, candidate)).filter((file) => fs2.existsSync(file));
+    const existingKnownConfigFiles = knownSvelteConfigNames.map((candidate) => path4.resolve(root, candidate)).filter((file) => fs2.existsSync(file));
     if (existingKnownConfigFiles.length === 0) {
       log.debug(`no svelte config found at ${root}`);
       return;
@@ -598,11 +856,11 @@ var SVELTE_HMR_IMPORTS = [
 var SVELTE_EXPORT_CONDITIONS = ["svelte"];
 
 // src/utils/options.ts
-import path4 from "path";
+import path6 from "path";
 
 // src/utils/esbuild.ts
 import { readFileSync } from "fs";
-import { compile as compile2, preprocess as preprocess2 } from "svelte/compiler";
+import { compile as compile2, preprocess as preprocess3 } from "svelte/compiler";
 
 // src/utils/error.ts
 function toRollupError(error, options) {
@@ -734,7 +992,7 @@ async function compileSvelte(options, { filename, code }, statsCollection) {
   let preprocessed;
   if (options.preprocess) {
     try {
-      preprocessed = await preprocess2(code, options.preprocess, { filename });
+      preprocessed = await preprocess3(code, options.preprocess, { filename });
     } catch (e) {
       e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
       throw e;
@@ -763,262 +1021,6 @@ async function compileSvelte(options, { filename, code }, statsCollection) {
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
-// src/utils/preprocess.ts
-import * as vite from "vite";
-import MagicString2 from "magic-string";
-import { preprocess as preprocess3 } from "svelte/compiler";
-
-// src/utils/sourcemap.ts
-import MagicString from "magic-string";
-async function buildMagicString(from, to, options) {
-  let diff_match_patch, DIFF_DELETE, DIFF_INSERT;
-  try {
-    const dmpPkg = await import("diff-match-patch");
-    diff_match_patch = dmpPkg.diff_match_patch;
-    DIFF_INSERT = dmpPkg.DIFF_INSERT;
-    DIFF_DELETE = dmpPkg.DIFF_DELETE;
-  } catch (e) {
-    log.error.once(
-      'Failed to import optional dependency "diff-match-patch". Please install it to enable generated sourcemaps.'
-    );
-    return null;
-  }
-  const dmp = new diff_match_patch();
-  const diffs = dmp.diff_main(from, to);
-  dmp.diff_cleanupSemantic(diffs);
-  const m = new MagicString(from, options);
-  let pos = 0;
-  for (let i = 0; i < diffs.length; i++) {
-    const diff = diffs[i];
-    const nextDiff = diffs[i + 1];
-    if (diff[0] === DIFF_DELETE) {
-      if (nextDiff?.[0] === DIFF_INSERT) {
-        m.overwrite(pos, pos + diff[1].length, nextDiff[1]);
-        i++;
-      } else {
-        m.remove(pos, pos + diff[1].length);
-      }
-      pos += diff[1].length;
-    } else if (diff[0] === DIFF_INSERT) {
-      if (nextDiff) {
-        m.appendRight(pos, diff[1]);
-      } else {
-        m.append(diff[1]);
-      }
-    } else {
-      pos += diff[1].length;
-    }
-  }
-  return m;
-}
-async function buildSourceMap(from, to, filename) {
-  const m = await buildMagicString(from, to, { filename });
-  return m ? m.generateDecodedMap({ source: filename, hires: true, includeContent: false }) : null;
-}
-
-// src/utils/preprocess.ts
-import path2 from "path";
-var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
-var supportedScriptLangs = ["ts"];
-function createViteScriptPreprocessor() {
-  return async ({ attributes, content, filename = "" }) => {
-    const lang = attributes.lang;
-    if (!supportedScriptLangs.includes(lang))
-      return;
-    const transformResult = await vite.transformWithEsbuild(content, filename, {
-      loader: lang,
-      target: "esnext",
-      tsconfigRaw: {
-        compilerOptions: {
-          importsNotUsedAsValues: "preserve",
-          preserveValueImports: true
-        }
-      }
-    });
-    return {
-      code: transformResult.code,
-      map: transformResult.map
-    };
-  };
-}
-function createViteStylePreprocessor(config) {
-  const transform = getCssTransformFn(config);
-  return async ({ attributes, content, filename = "" }) => {
-    const lang = attributes.lang;
-    if (!supportedStyleLangs.includes(lang))
-      return;
-    const moduleId = `${filename}.${lang}`;
-    const result = await transform(content, moduleId);
-    if (result.map?.sources?.[0] === moduleId) {
-      result.map.sources[0] = path2.basename(filename);
-    }
-    return {
-      code: result.code,
-      map: result.map ?? void 0
-    };
-  };
-}
-function getCssTransformFn(config) {
-  if (vite.preprocessCSS) {
-    return async (code, filename) => {
-      return vite.preprocessCSS(code, filename, config);
-    };
-  } else {
-    const pluginName = "vite:css";
-    const plugin = config.plugins.find((p) => p.name === pluginName);
-    if (!plugin) {
-      throw new Error(`failed to find plugin ${pluginName}`);
-    }
-    if (!plugin.transform) {
-      throw new Error(`plugin ${pluginName} has no transform`);
-    }
-    return plugin.transform.bind(null);
-  }
-}
-function createVitePreprocessorGroup(config) {
-  return {
-    markup({ content, filename }) {
-      return preprocess3(
-        content,
-        {
-          script: createViteScriptPreprocessor(),
-          style: createViteStylePreprocessor(config)
-        },
-        { filename }
-      );
-    }
-  };
-}
-function createInjectScopeEverythingRulePreprocessorGroup() {
-  return {
-    style({ content, filename }) {
-      const s = new MagicString2(content);
-      s.append(" *{}");
-      return {
-        code: s.toString(),
-        map: s.generateDecodedMap({
-          source: filename ? path2.basename(filename) : void 0,
-          hires: true
-        })
-      };
-    }
-  };
-}
-function buildExtraPreprocessors(options, config) {
-  const prependPreprocessors = [];
-  const appendPreprocessors = [];
-  if (options.experimental?.useVitePreprocess) {
-    log.debug("adding vite preprocessor");
-    prependPreprocessors.push(createVitePreprocessorGroup(config));
-  }
-  const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p?.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.map((p) => p.name).join(", ")}`
-    );
-    pluginsWithPreprocessorsDeprecated.forEach((p) => {
-      if (!p.api) {
-        p.api = {};
-      }
-      if (p.api.sveltePreprocess === void 0) {
-        p.api.sveltePreprocess = p.sveltePreprocess;
-      } else {
-        log.error(
-          `ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`
-        );
-      }
-    });
-  }
-  const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);
-  const ignored = [], included = [];
-  for (const p of pluginsWithPreprocessors) {
-    if (options.ignorePluginPreprocessors === true || Array.isArray(options.ignorePluginPreprocessors) && options.ignorePluginPreprocessors?.includes(p.name)) {
-      ignored.push(p);
-    } else {
-      included.push(p);
-    }
-  }
-  if (ignored.length > 0) {
-    log.debug(
-      `Ignoring svelte preprocessors defined by these vite plugins: ${ignored.map((p) => p.name).join(", ")}`
-    );
-  }
-  if (included.length > 0) {
-    log.debug(
-      `Adding svelte preprocessors defined by these vite plugins: ${included.map((p) => p.name).join(", ")}`
-    );
-    appendPreprocessors.push(...pluginsWithPreprocessors.map((p) => p.api.sveltePreprocess));
-  }
-  if (options.hot && options.emitCss) {
-    appendPreprocessors.push(createInjectScopeEverythingRulePreprocessorGroup());
-  }
-  return { prependPreprocessors, appendPreprocessors };
-}
-function addExtraPreprocessors(options, config) {
-  const { prependPreprocessors, appendPreprocessors } = buildExtraPreprocessors(options, config);
-  if (prependPreprocessors.length > 0 || appendPreprocessors.length > 0) {
-    if (!options.preprocess) {
-      options.preprocess = [...prependPreprocessors, ...appendPreprocessors];
-    } else if (Array.isArray(options.preprocess)) {
-      options.preprocess.unshift(...prependPreprocessors);
-      options.preprocess.push(...appendPreprocessors);
-    } else {
-      options.preprocess = [...prependPreprocessors, options.preprocess, ...appendPreprocessors];
-    }
-  }
-  const generateMissingSourceMaps = !!options.experimental?.generateMissingPreprocessorSourcemaps;
-  if (options.preprocess && generateMissingSourceMaps) {
-    options.preprocess = Array.isArray(options.preprocess) ? options.preprocess.map((p, i) => validateSourceMapOutputWrapper(p, i)) : validateSourceMapOutputWrapper(options.preprocess, 0);
-  }
-}
-function validateSourceMapOutputWrapper(group, i) {
-  const wrapper = {};
-  for (const [processorType, processorFn] of Object.entries(group)) {
-    wrapper[processorType] = async (options) => {
-      const result = await processorFn(options);
-      if (result && result.code !== options.content) {
-        let invalidMap = false;
-        if (!result.map) {
-          invalidMap = true;
-          log.warn.enabled && log.warn.once(
-            `preprocessor at index ${i} did not return a sourcemap for ${processorType} transform`,
-            {
-              filename: options.filename,
-              type: processorType,
-              processor: processorFn.toString()
-            }
-          );
-        } else if (result.map?.mappings === "") {
-          invalidMap = true;
-          log.warn.enabled && log.warn.once(
-            `preprocessor at index ${i} returned an invalid empty sourcemap for ${processorType} transform`,
-            {
-              filename: options.filename,
-              type: processorType,
-              processor: processorFn.toString()
-            }
-          );
-        }
-        if (invalidMap) {
-          try {
-            const map = await buildSourceMap(options.content, result.code, options.filename);
-            if (map) {
-              log.debug.enabled && log.debug(
-                `adding generated sourcemap to preprocesor result for ${options.filename}`
-              );
-              result.map = map;
-            }
-          } catch (e) {
-            log.error(`failed to build sourcemap`, e);
-          }
-        }
-      }
-      return result;
-    };
-  }
-  return wrapper;
-}
-
 // src/utils/options.ts
 import deepmerge from "deepmerge";
 import {
@@ -1030,7 +1032,7 @@ import {
 } from "vitefu";
 
 // src/utils/dependencies.ts
-import path3 from "path";
+import path5 from "path";
 import fs3 from "fs/promises";
 import { findDepPkgJsonPath } from "vitefu";
 async function resolveDependencyData(dep, parent) {
@@ -1039,7 +1041,7 @@ async function resolveDependencyData(dep, parent) {
     return void 0;
   try {
     return {
-      dir: path3.dirname(depDataPath),
+      dir: path5.dirname(depDataPath),
       pkg: JSON.parse(await fs3.readFile(depDataPath, "utf-8"))
     };
   } catch {
@@ -1136,7 +1138,7 @@ function formatPackageStats(pkgStats) {
 }
 async function getClosestNamedPackage(file) {
   let name = "$unknown";
-  let path9 = await findClosestPkgJsonPath(file, (pkgPath) => {
+  let path11 = await findClosestPkgJsonPath(file, (pkgPath) => {
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     if (pkg.name != null) {
       name = pkg.name;
@@ -1144,8 +1146,8 @@ async function getClosestNamedPackage(file) {
     }
     return false;
   });
-  path9 = normalizePath2(dirname(path9 ?? file)) + "/";
-  return { name, path: path9 };
+  path11 = normalizePath2(dirname(path11 ?? file)) + "/";
+  return { name, path: path11 };
 }
 var VitePluginSvelteStats = class {
   constructor() {
@@ -1487,9 +1489,12 @@ function handleDeprecatedOptions(options) {
       "experimental.prebundleSvelteLibraries is no longer experimental and has moved to prebundleSvelteLibraries"
     );
   }
+  if (options.experimental?.generateMissingPreprocessorSourcemaps) {
+    log.warn("experimental.generateMissingPreprocessorSourcemaps has been removed.");
+  }
 }
 function resolveViteRoot(viteConfig) {
-  return normalizePath3(viteConfig.root ? path4.resolve(viteConfig.root) : process.cwd());
+  return normalizePath3(viteConfig.root ? path6.resolve(viteConfig.root) : process.cwd());
 }
 async function buildExtraViteConfig(options, config) {
   const extraViteConfig = {
@@ -1646,6 +1651,13 @@ function buildExtraConfigForSvelte(config) {
   return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 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;
+      }
+    }
+  }
   const facadeEsbuildSveltePlugin = viteConfig.optimizeDeps.esbuildOptions?.plugins?.find(
     (plugin) => plugin.name === facadeEsbuildSveltePluginName
   );
@@ -1653,10 +1665,13 @@ function patchResolvedViteConfig(viteConfig, options) {
     Object.assign(facadeEsbuildSveltePlugin, esbuildSveltePlugin(options));
   }
 }
+function arraify(value) {
+  return Array.isArray(value) ? value : [value];
+}
 
 // src/utils/watch.ts
 import fs4 from "fs";
-import path5 from "path";
+import path7 from "path";
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
   if (!server) {
@@ -1703,7 +1718,7 @@ function setupWatchers(options, cache, requestParser) {
     unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
   };
   if (svelteConfigFile !== false) {
-    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path5.join(root, cfg));
+    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path7.join(root, cfg));
     const restartOnConfigAdd = (filename) => {
       if (possibleSvelteConfigs.includes(filename)) {
         triggerViteRestart(filename);
@@ -1729,12 +1744,12 @@ function setupWatchers(options, cache, requestParser) {
 }
 function ensureWatchedFile(watcher, file, root) {
   if (file && !file.startsWith(root + "/") && !file.includes("\0") && fs4.existsSync(file)) {
-    watcher.add(path5.resolve(file));
+    watcher.add(path7.resolve(file));
   }
 }
 
 // src/utils/resolve.ts
-import path6 from "path";
+import path8 from "path";
 import { builtinModules } from "module";
 async function resolveViaPackageJsonSvelte(importee, importer, cache) {
   if (importer && isBareImport(importee) && !isNodeInternal(importee) && !isCommonDepWithoutSvelteField(importee)) {
@@ -1746,7 +1761,7 @@ async function resolveViaPackageJsonSvelte(importee, importer, cache) {
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
-        const result = path6.resolve(dir, pkg.svelte);
+        const result = path8.resolve(dir, pkg.svelte);
         cache.setResolvedSvelteField(importee, importer, result);
         return result;
       }
@@ -1757,7 +1772,7 @@ function isNodeInternal(importee) {
   return importee.startsWith("node:") || builtinModules.includes(importee);
 }
 function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || path6.isAbsolute(importee)) {
+  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || path8.isAbsolute(importee)) {
     return false;
   }
   const parts = importee.split("/");
@@ -1773,7 +1788,7 @@ function isBareImport(importee) {
 
 // src/utils/optimizer.ts
 import { promises as fs5 } from "fs";
-import path7 from "path";
+import path9 from "path";
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
   "configFile",
@@ -1784,7 +1799,7 @@ var PREBUNDLE_SENSITIVE_OPTIONS = [
 ];
 async function saveSvelteMetadata(cacheDir, options) {
   const svelteMetadata = generateSvelteMetadata(options);
-  const svelteMetadataPath = path7.resolve(cacheDir, "_svelte_metadata.json");
+  const svelteMetadataPath = path9.resolve(cacheDir, "_svelte_metadata.json");
   const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
     return typeof value === "function" ? value.toString() : value;
   });
@@ -1807,7 +1822,7 @@ function generateSvelteMetadata(options) {
 
 // src/ui/inspector/plugin.ts
 import { normalizePath as normalizePath4 } from "vite";
-import path8 from "path";
+import path10 from "path";
 import { fileURLToPath } from "url";
 import fs6 from "fs";
 
@@ -1834,7 +1849,7 @@ var defaultInspectorOptions = {
   customStyles: true
 };
 function getInspectorPath() {
-  const pluginPath = normalizePath4(path8.dirname(fileURLToPath(import.meta.url)));
+  const pluginPath = normalizePath4(path10.dirname(fileURLToPath(import.meta.url)));
   return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
 }
 function svelteInspector() {
@@ -1860,7 +1875,7 @@ function svelteInspector() {
         disabled = true;
       } else {
         if (vps.api.options.kit && !inspectorOptions.appendTo) {
-          const out_dir = path8.basename(vps.api.options.kit.outDir || ".svelte-kit");
+          const out_dir = path10.basename(vps.api.options.kit.outDir || ".svelte-kit");
           inspectorOptions.appendTo = `${out_dir}/generated/root.svelte`;
         }
         appendTo = inspectorOptions.appendTo;
@@ -2010,8 +2025,8 @@ var VitePluginSvelteCache = class {
   getError(svelteRequest) {
     return this._errors.get(svelteRequest.normalizedFilename);
   }
-  getDependants(path9) {
-    const dependants = this._dependants.get(path9);
+  getDependants(path11) {
+    const dependants = this._dependants.get(path11);
     return dependants ? [...dependants] : [];
   }
   getResolvedSvelteField(name, importer) {
@@ -2028,6 +2043,97 @@ var VitePluginSvelteCache = class {
   }
 };
 
+// src/utils/load-raw.ts
+import fs7 from "fs";
+async function loadRaw(svelteRequest, compileSvelte2, options) {
+  const { id, filename, query } = svelteRequest;
+  let compileData;
+  const source = fs7.readFileSync(filename, "utf-8");
+  try {
+    svelteRequest.ssr = query.compilerOptions?.generate === "ssr";
+    const type = query.type;
+    compileData = await compileSvelte2(svelteRequest, source, {
+      ...options,
+      compilerOptions: {
+        dev: false,
+        css: false,
+        hydratable: false,
+        enableSourcemap: query.sourcemap ? {
+          js: type === "script" || type === "all",
+          css: type === "style" || type === "all"
+        } : false,
+        ...svelteRequest.query.compilerOptions
+      },
+      hot: false,
+      emitCss: true
+    });
+  } catch (e) {
+    throw toRollupError(e, options);
+  }
+  let result;
+  if (query.type === "style") {
+    result = compileData.compiled.css;
+  } else if (query.type === "script") {
+    result = compileData.compiled.js;
+  } else if (query.type === "preprocessed") {
+    result = compileData.preprocessed;
+  } else if (query.type === "all" && query.raw) {
+    return allToRawExports(compileData, source);
+  } else {
+    throw new Error(
+      `invalid "type=${query.type}" in ${id}. supported are script, style, preprocessed, all`
+    );
+  }
+  if (query.direct) {
+    const supportedDirectTypes = ["script", "style"];
+    if (!supportedDirectTypes.includes(query.type)) {
+      throw new Error(
+        `invalid "type=${query.type}" combined with direct in ${id}. supported are: ${supportedDirectTypes.join(", ")}`
+      );
+    }
+    log.debug(`load returns direct result for ${id}`);
+    let directOutput = result.code;
+    if (query.sourcemap && result.map?.toUrl) {
+      const map = `sourceMappingURL=${result.map.toUrl()}`;
+      if (query.type === "style") {
+        directOutput += `
+
+/*# ${map} */
+`;
+      } else if (query.type === "script") {
+        directOutput += `
+
+//# ${map}
+`;
+      }
+    }
+    return directOutput;
+  } else if (query.raw) {
+    log.debug(`load returns raw result for ${id}`);
+    return toRawExports(result);
+  } else {
+    throw new Error(`invalid raw mode in ${id}, supported are raw, direct`);
+  }
+}
+function allToRawExports(compileData, source) {
+  const exports = {
+    ...compileData,
+    ...compileData.compiled,
+    source
+  };
+  delete exports.compiled;
+  delete exports.filename;
+  return toRawExports(exports);
+}
+function toRawExports(object) {
+  let exports = Object.entries(object).filter(([key, value]) => typeof value !== "function").sort(([a], [b]) => a < b ? -1 : a === b ? 0 : 1).map(([key, value]) => `export const ${key}=${JSON.stringify(value)}`).join("\n") + "\n";
+  if (Object.prototype.hasOwnProperty.call(object, "code")) {
+    exports += `export default code
+`;
+  }
+  return exports;
+}
+
 // src/index.ts
 function svelte(inlineOptions) {
   if (process.env.DEBUG != null) {
@@ -2078,21 +2184,25 @@ function svelte(inlineOptions) {
         options.server = server;
         setupWatchers(options, cache, requestParser);
       },
-      load(id, opts) {
+      async load(id, opts) {
         const ssr = !!opts?.ssr;
         const svelteRequest = requestParser(id, !!ssr);
         if (svelteRequest) {
-          const { filename, query } = svelteRequest;
-          if (query.svelte && query.type === "style") {
-            const css = cache.getCSS(svelteRequest);
-            if (css) {
-              log.debug(`load returns css for ${filename}`);
-              return css;
+          const { filename, query, raw } = svelteRequest;
+          if (raw) {
+            return loadRaw(svelteRequest, compileSvelte2, options);
+          } else {
+            if (query.svelte && query.type === "style") {
+              const css = cache.getCSS(svelteRequest);
+              if (css) {
+                log.debug(`load returns css for ${filename}`);
+                return css;
+              }
+            }
+            if (viteConfig.assetsInclude(filename)) {
+              log.debug(`load returns raw content for ${filename}`);
+              return fs8.readFileSync(filename, "utf-8");
             }
-          }
-          if (viteConfig.assetsInclude(filename)) {
-            log.debug(`load returns raw content for ${filename}`);
-            return fs7.readFileSync(filename, "utf-8");
           }
         }
       },
@@ -2100,12 +2210,10 @@ function svelte(inlineOptions) {
         const ssr = !!opts?.ssr;
         const svelteRequest = requestParser(importee, ssr);
         if (svelteRequest?.query.svelte) {
-          if (svelteRequest.query.type === "style") {
+          if (svelteRequest.query.type === "style" && !svelteRequest.raw) {
             log.debug(`resolveId resolved virtual css module ${svelteRequest.cssId}`);
             return svelteRequest.cssId;
           }
-          log.debug(`resolveId resolved ${importee}`);
-          return importee;
         }
         if (ssr && importee === "svelte") {
           if (!resolvedSvelteSSR) {
@@ -2147,7 +2255,7 @@ function svelte(inlineOptions) {
       async transform(code, id, opts) {
         const ssr = !!opts?.ssr;
         const svelteRequest = requestParser(id, ssr);
-        if (!svelteRequest || svelteRequest.query.svelte) {
+        if (!svelteRequest || svelteRequest.query.type === "style" || svelteRequest.raw) {
           return;
         }
         let compileData;
@@ -2197,6 +2305,7 @@ function svelte(inlineOptions) {
 }
 export {
   loadSvelteConfig,
-  svelte
+  svelte,
+  vitePreprocess
 };
 //# sourceMappingURL=index.js.map