@sveltejs/vite-plugin-svelte 1.3.1 → 1.4.0

package/dist/index.cjs

@@ -27,7 +27,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   loadSvelteConfig: () => loadSvelteConfig,
-  svelte: () => svelte
+  svelte: () => svelte,
+  vitePreprocess: () => vitePreprocess
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -36,7 +37,7 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL("file:" +
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/index.ts
-var import_fs7 = __toESM(require("fs"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
 var import_vitefu4 = require("vitefu");
 
 // src/utils/log.ts
@@ -213,7 +214,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();
@@ -225,34 +226,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);
@@ -289,7 +291,7 @@ function normalizeJsCode(code) {
 }
 
 // src/utils/compile.ts
-var import_compiler = require("svelte/compiler");
+var import_compiler2 = require("svelte/compiler");
 var import_svelte_hmr = require("svelte-hmr");
 
 // src/utils/hash.ts
@@ -316,12 +318,210 @@ function toSafe(base64) {
   return base64.replace(replaceRE, (x) => replacements[x]);
 }
 
+// src/utils/preprocess.ts
+var import_magic_string = __toESM(require("magic-string"), 1);
+var import_compiler = require("svelte/compiler");
+var import_path2 = __toESM(require("path"), 1);
+
+// src/preprocess.ts
+var import_path = __toESM(require("path"), 1);
+var vite = __toESM(require("vite"), 1);
+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] = import_path.default.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 (0, import_compiler.preprocess)(content, vitePreprocess({ style: config }), { filename });
+    }
+  };
+}
+function createInjectScopeEverythingRulePreprocessorGroup() {
+  return {
+    style({ content, filename }) {
+      const s = new import_magic_string.default(content);
+      s.append(" *{}");
+      return {
+        code: s.toString(),
+        map: s.generateDecodedMap({
+          source: filename ? import_path2.default.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
+var import_path3 = __toESM(require("path"), 1);
 var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
+function mapSourcesToRelative(map, filename) {
+  if (map?.sources) {
+    map.sources = map.sources.map((s) => {
+      if (import_path3.default.isAbsolute(s)) {
+        const relative = import_path3.default.relative(filename, s);
+        return relative === "" ? import_path3.default.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) {
@@ -343,7 +543,7 @@ var _createCompileSvelte = (makeHot) => {
     }
     const compileOptions = {
       ...options.compilerOptions,
-      filename,
+      filename: normalizedFilename,
       generate: ssr ? "ssr" : "dom",
       format: "esm"
     };
@@ -360,9 +560,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 (0, import_compiler.preprocess)(code, options.preprocess, { filename });
+        preprocessed = await (0, import_compiler2.preprocess)(code, preprocessors, { filename });
       } catch (e) {
         e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
         throw e;
@@ -372,6 +580,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,
@@ -388,25 +602,29 @@ var _createCompileSvelte = (makeHot) => {
       ...dynamicCompileOptions
     } : compileOptions;
     const endStat = stats?.start(filename);
-    const compiled = (0, import_compiler.compile)(finalCode, finalCompileOptions);
+    const compiled = (0, import_compiler2.compile)(finalCode, finalCompileOptions);
     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 {
@@ -415,7 +633,8 @@ import ${JSON.stringify(cssId)};
       lang: code.match(scriptLangRE)?.[1] || "js",
       compiled,
       ssr,
-      dependencies
+      dependencies,
+      preprocessed: preprocessed ?? { code }
     };
   };
 };
@@ -425,7 +644,7 @@ function buildMakeHot(options) {
     const hotApi = options?.hot?.hotApi;
     const adapter = options?.hot?.adapter;
     return (0, import_svelte_hmr.createMakeHot)({
-      walk: import_compiler.walk,
+      walk: import_compiler2.walk,
       hotApi,
       adapter,
       hotOptions: { noOverlay: true, ...options.hot }
@@ -443,6 +662,16 @@ var import_vite2 = require("vite");
 var fs = __toESM(require("fs"), 1);
 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];
@@ -451,9 +680,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 {
@@ -463,7 +694,8 @@ function parseToSvelteRequest(id, filename, rawQuery, root, timestamp, ssr) {
     cssId,
     query,
     timestamp,
-    ssr
+    ssr,
+    raw
   };
 }
 function createVirtualImportId(filename, root, type) {
@@ -485,6 +717,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) {
@@ -520,7 +779,7 @@ var import_vite4 = require("vite");
 
 // src/utils/load-svelte-config.ts
 var import_module = require("module");
-var import_path = __toESM(require("path"), 1);
+var import_path4 = __toESM(require("path"), 1);
 var import_fs = __toESM(require("fs"), 1);
 var import_url = require("url");
 var esmRequire;
@@ -586,13 +845,13 @@ async function loadSvelteConfig(viteConfig, inlineOptions) {
 function findConfigToLoad(viteConfig, inlineOptions) {
   const root = viteConfig?.root || process.cwd();
   if (inlineOptions?.configFile) {
-    const abolutePath = import_path.default.isAbsolute(inlineOptions.configFile) ? inlineOptions.configFile : import_path.default.resolve(root, inlineOptions.configFile);
+    const abolutePath = import_path4.default.isAbsolute(inlineOptions.configFile) ? inlineOptions.configFile : import_path4.default.resolve(root, inlineOptions.configFile);
     if (!import_fs.default.existsSync(abolutePath)) {
       throw new Error(`failed to find svelte config file ${abolutePath}.`);
     }
     return abolutePath;
   } else {
-    const existingKnownConfigFiles = knownSvelteConfigNames.map((candidate) => import_path.default.resolve(root, candidate)).filter((file) => import_fs.default.existsSync(file));
+    const existingKnownConfigFiles = knownSvelteConfigNames.map((candidate) => import_path4.default.resolve(root, candidate)).filter((file) => import_fs.default.existsSync(file));
     if (existingKnownConfigFiles.length === 0) {
       log.debug(`no svelte config found at ${root}`);
       return;
@@ -627,11 +886,11 @@ var SVELTE_HMR_IMPORTS = [
 var SVELTE_EXPORT_CONDITIONS = ["svelte"];
 
 // src/utils/options.ts
-var import_path5 = __toESM(require("path"), 1);
+var import_path7 = __toESM(require("path"), 1);
 
 // src/utils/esbuild.ts
 var import_fs2 = require("fs");
-var import_compiler3 = require("svelte/compiler");
+var import_compiler4 = require("svelte/compiler");
 
 // src/utils/error.ts
 function toRollupError(error, options) {
@@ -687,8 +946,8 @@ function formatFrameForVite(frame) {
 }
 
 // src/utils/svelte-version.ts
-var import_compiler2 = require("svelte/compiler");
-var svelteVersion = parseVersion(import_compiler2.VERSION);
+var import_compiler3 = require("svelte/compiler");
+var svelteVersion = parseVersion(import_compiler3.VERSION);
 function parseVersion(version) {
   const segments = version.split(".", 3).map((s) => parseInt(s, 10));
   while (segments.length < 3) {
@@ -763,7 +1022,7 @@ async function compileSvelte(options, { filename, code }, statsCollection) {
   let preprocessed;
   if (options.preprocess) {
     try {
-      preprocessed = await (0, import_compiler3.preprocess)(code, options.preprocess, { filename });
+      preprocessed = await (0, import_compiler4.preprocess)(code, options.preprocess, { filename });
     } catch (e) {
       e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
       throw e;
@@ -785,275 +1044,19 @@ async function compileSvelte(options, { filename, code }, statsCollection) {
     ...dynamicCompileOptions
   } : compileOptions;
   const endStat = statsCollection?.start(filename);
-  const compiled = (0, import_compiler3.compile)(finalCode, finalCompileOptions);
+  const compiled = (0, import_compiler4.compile)(finalCode, finalCompileOptions);
   if (endStat) {
     endStat();
   }
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
-// src/utils/preprocess.ts
-var vite = __toESM(require("vite"), 1);
-var import_magic_string2 = __toESM(require("magic-string"), 1);
-var import_compiler4 = require("svelte/compiler");
-
-// src/utils/sourcemap.ts
-var import_magic_string = __toESM(require("magic-string"), 1);
-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 import_magic_string.default(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
-var import_path2 = __toESM(require("path"), 1);
-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] = import_path2.default.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 (0, import_compiler4.preprocess)(
-        content,
-        {
-          script: createViteScriptPreprocessor(),
-          style: createViteStylePreprocessor(config)
-        },
-        { filename }
-      );
-    }
-  };
-}
-function createInjectScopeEverythingRulePreprocessorGroup() {
-  return {
-    style({ content, filename }) {
-      const s = new import_magic_string2.default(content);
-      s.append(" *{}");
-      return {
-        code: s.toString(),
-        map: s.generateDecodedMap({
-          source: filename ? import_path2.default.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
 var import_deepmerge = __toESM(require("deepmerge"), 1);
 var import_vitefu3 = require("vitefu");
 
 // src/utils/dependencies.ts
-var import_path3 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_vitefu = require("vitefu");
 async function resolveDependencyData(dep, parent) {
@@ -1062,7 +1065,7 @@ async function resolveDependencyData(dep, parent) {
     return void 0;
   try {
     return {
-      dir: import_path3.default.dirname(depDataPath),
+      dir: import_path5.default.dirname(depDataPath),
       pkg: JSON.parse(await import_promises.default.readFile(depDataPath, "utf-8"))
     };
   } catch {
@@ -1117,7 +1120,7 @@ function isCommonDepWithoutSvelteField(dependency) {
 // src/utils/vite-plugin-svelte-stats.ts
 var import_vitefu2 = require("vitefu");
 var import_fs3 = require("fs");
-var import_path4 = require("path");
+var import_path6 = require("path");
 var import_perf_hooks = require("perf_hooks");
 var import_vite3 = require("vite");
 var defaultCollectionOptions = {
@@ -1159,7 +1162,7 @@ function formatPackageStats(pkgStats) {
 }
 async function getClosestNamedPackage(file) {
   let name = "$unknown";
-  let path9 = await (0, import_vitefu2.findClosestPkgJsonPath)(file, (pkgPath) => {
+  let path11 = await (0, import_vitefu2.findClosestPkgJsonPath)(file, (pkgPath) => {
     const pkg = JSON.parse((0, import_fs3.readFileSync)(pkgPath, "utf-8"));
     if (pkg.name != null) {
       name = pkg.name;
@@ -1167,8 +1170,8 @@ async function getClosestNamedPackage(file) {
     }
     return false;
   });
-  path9 = (0, import_vite3.normalizePath)((0, import_path4.dirname)(path9 ?? file)) + "/";
-  return { name, path: path9 };
+  path11 = (0, import_vite3.normalizePath)((0, import_path6.dirname)(path11 ?? file)) + "/";
+  return { name, path: path11 };
 }
 var VitePluginSvelteStats = class {
   constructor() {
@@ -1510,9 +1513,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 (0, import_vite4.normalizePath)(viteConfig.root ? import_path5.default.resolve(viteConfig.root) : process.cwd());
+  return (0, import_vite4.normalizePath)(viteConfig.root ? import_path7.default.resolve(viteConfig.root) : process.cwd());
 }
 async function buildExtraViteConfig(options, config) {
   const extraViteConfig = {
@@ -1669,6 +1675,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
   );
@@ -1676,10 +1689,13 @@ function patchResolvedViteConfig(viteConfig, options) {
     Object.assign(facadeEsbuildSveltePlugin, esbuildSveltePlugin(options));
   }
 }
+function arraify(value) {
+  return Array.isArray(value) ? value : [value];
+}
 
 // src/utils/watch.ts
 var import_fs4 = __toESM(require("fs"), 1);
-var import_path6 = __toESM(require("path"), 1);
+var import_path8 = __toESM(require("path"), 1);
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
   if (!server) {
@@ -1726,7 +1742,7 @@ function setupWatchers(options, cache, requestParser) {
     unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
   };
   if (svelteConfigFile !== false) {
-    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path6.default.join(root, cfg));
+    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path8.default.join(root, cfg));
     const restartOnConfigAdd = (filename) => {
       if (possibleSvelteConfigs.includes(filename)) {
         triggerViteRestart(filename);
@@ -1752,12 +1768,12 @@ function setupWatchers(options, cache, requestParser) {
 }
 function ensureWatchedFile(watcher, file, root) {
   if (file && !file.startsWith(root + "/") && !file.includes("\0") && import_fs4.default.existsSync(file)) {
-    watcher.add(import_path6.default.resolve(file));
+    watcher.add(import_path8.default.resolve(file));
   }
 }
 
 // src/utils/resolve.ts
-var import_path7 = __toESM(require("path"), 1);
+var import_path9 = __toESM(require("path"), 1);
 var import_module2 = require("module");
 async function resolveViaPackageJsonSvelte(importee, importer, cache) {
   if (importer && isBareImport(importee) && !isNodeInternal(importee) && !isCommonDepWithoutSvelteField(importee)) {
@@ -1769,7 +1785,7 @@ async function resolveViaPackageJsonSvelte(importee, importer, cache) {
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
-        const result = import_path7.default.resolve(dir, pkg.svelte);
+        const result = import_path9.default.resolve(dir, pkg.svelte);
         cache.setResolvedSvelteField(importee, importer, result);
         return result;
       }
@@ -1780,7 +1796,7 @@ function isNodeInternal(importee) {
   return importee.startsWith("node:") || import_module2.builtinModules.includes(importee);
 }
 function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path7.default.isAbsolute(importee)) {
+  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path9.default.isAbsolute(importee)) {
     return false;
   }
   const parts = importee.split("/");
@@ -1796,7 +1812,7 @@ function isBareImport(importee) {
 
 // src/utils/optimizer.ts
 var import_fs5 = require("fs");
-var import_path8 = __toESM(require("path"), 1);
+var import_path10 = __toESM(require("path"), 1);
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
   "configFile",
@@ -1807,7 +1823,7 @@ var PREBUNDLE_SENSITIVE_OPTIONS = [
 ];
 async function saveSvelteMetadata(cacheDir, options) {
   const svelteMetadata = generateSvelteMetadata(options);
-  const svelteMetadataPath = import_path8.default.resolve(cacheDir, "_svelte_metadata.json");
+  const svelteMetadataPath = import_path10.default.resolve(cacheDir, "_svelte_metadata.json");
   const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
     return typeof value === "function" ? value.toString() : value;
   });
@@ -1830,7 +1846,7 @@ function generateSvelteMetadata(options) {
 
 // src/ui/inspector/plugin.ts
 var import_vite5 = require("vite");
-var import_path9 = __toESM(require("path"), 1);
+var import_path11 = __toESM(require("path"), 1);
 var import_url2 = require("url");
 var import_fs6 = __toESM(require("fs"), 1);
 
@@ -1857,7 +1873,7 @@ var defaultInspectorOptions = {
   customStyles: true
 };
 function getInspectorPath() {
-  const pluginPath = (0, import_vite5.normalizePath)(import_path9.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl)));
+  const pluginPath = (0, import_vite5.normalizePath)(import_path11.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl)));
   return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
 }
 function svelteInspector() {
@@ -1883,7 +1899,7 @@ function svelteInspector() {
         disabled = true;
       } else {
         if (vps.api.options.kit && !inspectorOptions.appendTo) {
-          const out_dir = import_path9.default.basename(vps.api.options.kit.outDir || ".svelte-kit");
+          const out_dir = import_path11.default.basename(vps.api.options.kit.outDir || ".svelte-kit");
           inspectorOptions.appendTo = `${out_dir}/generated/root.svelte`;
         }
         appendTo = inspectorOptions.appendTo;
@@ -2033,8 +2049,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) {
@@ -2051,6 +2067,97 @@ var VitePluginSvelteCache = class {
   }
 };
 
+// src/utils/load-raw.ts
+var import_fs7 = __toESM(require("fs"), 1);
+async function loadRaw(svelteRequest, compileSvelte2, options) {
+  const { id, filename, query } = svelteRequest;
+  let compileData;
+  const source = import_fs7.default.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) {
@@ -2101,21 +2208,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 import_fs8.default.readFileSync(filename, "utf-8");
             }
-          }
-          if (viteConfig.assetsInclude(filename)) {
-            log.debug(`load returns raw content for ${filename}`);
-            return import_fs7.default.readFileSync(filename, "utf-8");
           }
         }
       },
@@ -2123,12 +2234,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) {
@@ -2170,7 +2279,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;
@@ -2221,6 +2330,7 @@ function svelte(inlineOptions) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   loadSvelteConfig,
-  svelte
+  svelte,
+  vitePreprocess
 });
 //# sourceMappingURL=index.cjs.map