@sveltejs/vite-plugin-svelte 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -31,12 +31,13 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../node_modules/.pnpm/tsup@6.3.0/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@6.5.0/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = () => typeof document === "undefined" ? new URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/index.ts
-var import_fs7 = __toESM(require("fs"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
+var import_vitefu3 = require("vitefu");
 
 // src/utils/log.ts
 var import_colors = require("kleur/colors");
@@ -127,12 +128,11 @@ var log = {
   setLevel
 };
 function logCompilerWarnings(svelteRequest, warnings, options) {
-  var _a, _b, _c;
   const { emitCss, onwarn, isBuild } = options;
-  const sendViaWS = !isBuild && ((_a = options.experimental) == null ? void 0 : _a.sendWarningsToBrowser);
+  const sendViaWS = !isBuild && options.experimental?.sendWarningsToBrowser;
   let warn = isBuild ? warnBuild : warnDev;
   const handledByDefaultWarn = [];
-  const notIgnored = warnings == null ? void 0 : warnings.filter((w) => !ignoreCompilerWarning(w, isBuild, emitCss));
+  const notIgnored = warnings?.filter((w) => !ignoreCompilerWarning(w, isBuild, emitCss));
   const extra = buildExtraWarnings(warnings, isBuild);
   const allWarnings = [...notIgnored, ...extra];
   if (sendViaWS) {
@@ -160,7 +160,7 @@ function logCompilerWarnings(svelteRequest, warnings, options) {
       rawWarnings: warnings
     };
     log.debug(`sending svelte:warnings message for ${svelteRequest.normalizedFilename}`);
-    (_c = (_b = options.server) == null ? void 0 : _b.ws) == null ? void 0 : _c.send("svelte:warnings", message);
+    options.server?.ws?.send("svelte:warnings", message);
   }
 }
 function ignoreCompilerWarning(warning, isBuild, emitCss) {
@@ -255,11 +255,11 @@ async function handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, option
   return result;
 }
 function cssChanged(prev, next) {
-  return !isCodeEqual(prev == null ? void 0 : prev.code, next == null ? void 0 : next.code);
+  return !isCodeEqual(prev?.code, next?.code);
 }
 function jsChanged(prev, next, filename) {
-  const prevJs = prev == null ? void 0 : prev.code;
-  const nextJs = next == null ? void 0 : next.code;
+  const prevJs = prev?.code;
+  const nextJs = next?.code;
   const isStrictEqual = isCodeEqual(prevJs, nextJs);
   if (isStrictEqual) {
     return false;
@@ -319,7 +319,6 @@ function toSafe(base64) {
 // src/utils/compile.ts
 var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
 var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequest, code, options) {
-  var _a, _b, _c;
   const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
   const { emitCss = true } = options;
   const dependencies = [];
@@ -355,11 +354,11 @@ var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequ
       compileOptions.sourcemap = preprocessed.map;
   }
   const finalCode = preprocessed ? preprocessed.code : code;
-  const dynamicCompileOptions = await ((_b = (_a = options.experimental) == null ? void 0 : _a.dynamicCompileOptions) == null ? void 0 : _b.call(_a, {
+  const dynamicCompileOptions = await options.experimental?.dynamicCompileOptions?.({
     filename,
     code: finalCode,
     compileOptions
-  }));
+  });
   if (dynamicCompileOptions && log.debug.enabled) {
     log.debug(
       `dynamic compile options for  ${filename}: ${JSON.stringify(dynamicCompileOptions)}`
@@ -370,7 +369,8 @@ var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequ
     ...dynamicCompileOptions
   } : compileOptions;
   const compiled = (0, import_compiler.compile)(finalCode, finalCompileOptions);
-  if (emitCss && compiled.css.code) {
+  const hasCss = compiled.css?.code?.trim().length > 0;
+  if (emitCss && hasCss) {
     compiled.js.code += `
 import ${JSON.stringify(cssId)};
 `;
@@ -379,7 +379,7 @@ import ${JSON.stringify(cssId)};
     compiled.js.code = makeHot({
       id: filename,
       compiledCode: compiled.js.code,
-      hotOptions: options.hot,
+      hotOptions: { ...options.hot, injectCss: options.hot?.injectCss === true && hasCss },
       compiled,
       originalCode: code,
       compileOptions: finalCompileOptions
@@ -389,18 +389,17 @@ import ${JSON.stringify(cssId)};
   return {
     filename,
     normalizedFilename,
-    lang: ((_c = code.match(scriptLangRE)) == null ? void 0 : _c[1]) || "js",
+    lang: code.match(scriptLangRE)?.[1] || "js",
     compiled,
     ssr,
     dependencies
   };
 };
 function buildMakeHot(options) {
-  var _a, _b;
   const needsMakeHot = options.hot !== false && options.isServe && !options.isProduction;
   if (needsMakeHot) {
-    const hotApi = (_a = options == null ? void 0 : options.hot) == null ? void 0 : _a.hotApi;
-    const adapter = (_b = options == null ? void 0 : options.hot) == null ? void 0 : _b.adapter;
+    const hotApi = options?.hot?.hotApi;
+    const adapter = options?.hot?.adapter;
     return (0, import_svelte_hmr.createMakeHot)({
       walk: import_compiler.walk,
       hotApi,
@@ -493,7 +492,7 @@ function buildIdParser(options) {
 }
 
 // src/utils/options.ts
-var import_vite4 = require("vite");
+var import_vite3 = require("vite");
 
 // src/utils/load-svelte-config.ts
 var import_module = require("module");
@@ -512,7 +511,7 @@ var dynamicImportDefault = new Function(
   'return import(path + "?t=" + timestamp).then(m => m.default)'
 );
 async function loadSvelteConfig(viteConfig, inlineOptions) {
-  if ((inlineOptions == null ? void 0 : inlineOptions.configFile) === false) {
+  if (inlineOptions?.configFile === false) {
     return;
   }
   const configFile = findConfigToLoad(viteConfig, inlineOptions);
@@ -561,8 +560,8 @@ async function loadSvelteConfig(viteConfig, inlineOptions) {
   }
 }
 function findConfigToLoad(viteConfig, inlineOptions) {
-  const root = (viteConfig == null ? void 0 : viteConfig.root) || process.cwd();
-  if (inlineOptions == null ? void 0 : inlineOptions.configFile) {
+  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);
     if (!import_fs.default.existsSync(abolutePath)) {
       throw new Error(`failed to find svelte config file ${abolutePath}.`);
@@ -605,183 +604,9 @@ var SVELTE_HMR_IMPORTS = [
 // src/utils/options.ts
 var import_path4 = __toESM(require("path"), 1);
 
-// src/utils/dependencies.ts
-var import_path2 = __toESM(require("path"), 1);
-var import_fs2 = __toESM(require("fs"), 1);
-var import_module2 = require("module");
-function findRootSvelteDependencies(root, cwdFallback = true) {
-  log.debug(`findSvelteDependencies: searching svelte dependencies in ${root}`);
-  const pkgFile = import_path2.default.join(root, "package.json");
-  if (!import_fs2.default.existsSync(pkgFile)) {
-    if (cwdFallback) {
-      const cwd = process.cwd();
-      if (root !== cwd) {
-        log.debug(`no package.json found in vite root ${root}`);
-        return findRootSvelteDependencies(cwd, false);
-      }
-    }
-    log.warn(`no package.json found, findRootSvelteDependencies failed`);
-    return [];
-  }
-  const pkg = parsePkg(root);
-  if (!pkg) {
-    return [];
-  }
-  const deps = [
-    ...Object.keys(pkg.dependencies || {}),
-    ...Object.keys(pkg.devDependencies || {})
-  ].filter((dep) => !is_common_without_svelte_field(dep));
-  return getSvelteDependencies(deps, root);
-}
-function getSvelteDependencies(deps, pkgDir, path9 = []) {
-  const result = [];
-  const localRequire = (0, import_module2.createRequire)(`${pkgDir}/package.json`);
-  const resolvedDeps = deps.map((dep) => resolveDependencyData(dep, localRequire)).filter(Boolean);
-  for (const { pkg, dir } of resolvedDeps) {
-    const type = getSvelteDependencyType(pkg);
-    if (!type)
-      continue;
-    result.push({ name: pkg.name, type, pkg, dir, path: path9 });
-    if (type === "component-library" && pkg.dependencies) {
-      let dependencyNames = Object.keys(pkg.dependencies);
-      const circular = dependencyNames.filter((name) => path9.includes(name));
-      if (circular.length > 0) {
-        log.warn.enabled && log.warn(
-          `skipping circular svelte dependencies in automated vite optimizeDeps handling`,
-          circular.map((x) => path9.concat(x).join(">"))
-        );
-        dependencyNames = dependencyNames.filter((name) => !path9.includes(name));
-      }
-      if (path9.length === 3) {
-        log.debug.once(`encountered deep svelte dependency tree: ${path9.join(">")}`);
-      }
-      result.push(...getSvelteDependencies(dependencyNames, dir, path9.concat(pkg.name)));
-    }
-  }
-  return result;
-}
-function resolveDependencyData(dep, localRequire) {
-  try {
-    const pkgJson = `${dep}/package.json`;
-    const pkg = localRequire(pkgJson);
-    const dir = import_path2.default.dirname(localRequire.resolve(pkgJson));
-    return { dir, pkg };
-  } catch (e) {
-    log.debug.once(`dependency ${dep} does not export package.json`, e);
-    try {
-      let dir = import_path2.default.dirname(localRequire.resolve(dep));
-      while (dir) {
-        const pkg = parsePkg(dir, true);
-        if (pkg && pkg.name === dep) {
-          return { dir, pkg };
-        }
-        const parent = import_path2.default.dirname(dir);
-        if (parent === dir) {
-          break;
-        }
-        dir = parent;
-      }
-    } catch (e2) {
-      log.debug.once(`error while trying to find package.json of ${dep}`, e2);
-    }
-  }
-  log.debug.once(`failed to resolve ${dep}`);
-}
-function parsePkg(dir, silent = false) {
-  const pkgFile = import_path2.default.join(dir, "package.json");
-  try {
-    return JSON.parse(import_fs2.default.readFileSync(pkgFile, "utf-8"));
-  } catch (e) {
-    !silent && log.warn.enabled && log.warn(`failed to parse ${pkgFile}`, e);
-  }
-}
-function getSvelteDependencyType(pkg) {
-  if (isSvelteComponentLib(pkg)) {
-    return "component-library";
-  } else if (isSvelteLib(pkg)) {
-    return "js-library";
-  } else {
-    return void 0;
-  }
-}
-function isSvelteComponentLib(pkg) {
-  return !!pkg.svelte;
-}
-function isSvelteLib(pkg) {
-  var _a, _b;
-  return !!((_a = pkg.dependencies) == null ? void 0 : _a.svelte) || !!((_b = pkg.peerDependencies) == null ? void 0 : _b.svelte);
-}
-var COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD = [
-  "@lukeed/uuid",
-  "@playwright/test",
-  "@sveltejs/vite-plugin-svelte",
-  "@sveltejs/kit",
-  "autoprefixer",
-  "cookie",
-  "dotenv",
-  "esbuild",
-  "eslint",
-  "jest",
-  "mdsvex",
-  "playwright",
-  "postcss",
-  "prettier",
-  "svelte",
-  "svelte-check",
-  "svelte-hmr",
-  "svelte-preprocess",
-  "tslib",
-  "typescript",
-  "vite",
-  "vitest",
-  "__vite-browser-external"
-];
-var COMMON_PREFIXES_WITHOUT_SVELTE_FIELD = [
-  "@fontsource/",
-  "@postcss-plugins/",
-  "@rollup/",
-  "@sveltejs/adapter-",
-  "@types/",
-  "@typescript-eslint/",
-  "eslint-",
-  "jest-",
-  "postcss-plugin-",
-  "prettier-plugin-",
-  "rollup-plugin-",
-  "vite-plugin-"
-];
-function is_common_without_svelte_field(dependency) {
-  return COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD.includes(dependency) || COMMON_PREFIXES_WITHOUT_SVELTE_FIELD.some(
-    (prefix2) => prefix2.startsWith("@") ? dependency.startsWith(prefix2) : dependency.substring(dependency.lastIndexOf("/") + 1).startsWith(prefix2)
-  );
-}
-function needsOptimization(dep, localRequire) {
-  const depData = resolveDependencyData(dep, localRequire);
-  if (!depData)
-    return false;
-  const pkg = depData.pkg;
-  const hasEsmFields = pkg.module || pkg.exports;
-  if (hasEsmFields)
-    return false;
-  if (pkg.main) {
-    const entryExt = import_path2.default.extname(pkg.main);
-    return !entryExt || entryExt === ".js" || entryExt === ".cjs";
-  } else {
-    try {
-      localRequire.resolve(`${dep}/index.js`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// src/utils/options.ts
-var import_module3 = require("module");
-
 // src/utils/esbuild.ts
-var import_fs3 = require("fs");
-var import_compiler2 = require("svelte/compiler");
+var import_fs2 = require("fs");
+var import_compiler3 = require("svelte/compiler");
 
 // src/utils/error.ts
 function toRollupError(error, options) {
@@ -836,19 +661,49 @@ function formatFrameForVite(frame) {
   return frame.split("\n").map((line) => line.match(/^\s+\^/) ? "   " + line : " " + line.replace(":", " | ")).join("\n");
 }
 
+// src/utils/svelte-version.ts
+var import_compiler2 = require("svelte/compiler");
+var svelteVersion = parseVersion(import_compiler2.VERSION);
+function parseVersion(version) {
+  const segments = version.split(".", 3).map((s) => parseInt(s, 10));
+  while (segments.length < 3) {
+    segments.push(0);
+  }
+  return segments;
+}
+function compareToSvelte(version) {
+  const parsedVersion = parseVersion(version);
+  for (let i = 0; i < svelteVersion.length; i++) {
+    const a = parsedVersion[i];
+    const b = svelteVersion[i];
+    if (a === b) {
+      continue;
+    } else if (a > b) {
+      return 1;
+    } else {
+      return -1;
+    }
+  }
+  return 0;
+}
+function atLeastSvelte(version) {
+  const result = compareToSvelte(version) <= 0;
+  return result;
+}
+
 // src/utils/esbuild.ts
+var isCssString = atLeastSvelte("3.53.0");
 var facadeEsbuildSveltePluginName = "vite-plugin-svelte:facade";
 function esbuildSveltePlugin(options) {
   return {
     name: "vite-plugin-svelte:optimize-svelte",
     setup(build) {
-      var _a;
-      if ((_a = build.initialOptions.plugins) == null ? void 0 : _a.some((v) => v.name === "vite:dep-scan"))
+      if (build.initialOptions.plugins?.some((v) => v.name === "vite:dep-scan"))
         return;
       const svelteExtensions = (options.extensions ?? [".svelte"]).map((ext) => ext.slice(1));
       const svelteFilter = new RegExp(`\\.(` + svelteExtensions.join("|") + `)(\\?.*)?$`);
       build.onLoad({ filter: svelteFilter }, async ({ path: filename }) => {
-        const code = await import_fs3.promises.readFile(filename, "utf8");
+        const code = await import_fs2.promises.readFile(filename, "utf8");
         try {
           const contents = await compileSvelte(options, { filename, code });
           return { contents };
@@ -860,10 +715,13 @@ function esbuildSveltePlugin(options) {
   };
 }
 async function compileSvelte(options, { filename, code }) {
-  var _a, _b;
+  let css = options.compilerOptions.css;
+  if (css !== "none") {
+    css = isCssString ? "injected" : true;
+  }
   const compileOptions = {
     ...options.compilerOptions,
-    css: true,
+    css,
     filename,
     format: "esm",
     generate: "dom"
@@ -871,7 +729,7 @@ async function compileSvelte(options, { filename, code }) {
   let preprocessed;
   if (options.preprocess) {
     try {
-      preprocessed = await (0, import_compiler2.preprocess)(code, options.preprocess, { filename });
+      preprocessed = await (0, import_compiler3.preprocess)(code, options.preprocess, { filename });
     } catch (e) {
       e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
       throw e;
@@ -880,11 +738,11 @@ async function compileSvelte(options, { filename, code }) {
       compileOptions.sourcemap = preprocessed.map;
   }
   const finalCode = preprocessed ? preprocessed.code : code;
-  const dynamicCompileOptions = await ((_b = (_a = options.experimental) == null ? void 0 : _a.dynamicCompileOptions) == null ? void 0 : _b.call(_a, {
+  const dynamicCompileOptions = await options.experimental?.dynamicCompileOptions?.({
     filename,
     code: finalCode,
     compileOptions
-  }));
+  });
   if (dynamicCompileOptions && log.debug.enabled) {
     log.debug(`dynamic compile options for  ${filename}: ${JSON.stringify(dynamicCompileOptions)}`);
   }
@@ -892,14 +750,14 @@ async function compileSvelte(options, { filename, code }) {
     ...compileOptions,
     ...dynamicCompileOptions
   } : compileOptions;
-  const compiled = (0, import_compiler2.compile)(finalCode, finalCompileOptions);
+  const compiled = (0, import_compiler3.compile)(finalCode, finalCompileOptions);
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
 // src/utils/preprocess.ts
-var import_vite3 = require("vite");
+var vite = __toESM(require("vite"), 1);
 var import_magic_string2 = __toESM(require("magic-string"), 1);
-var import_compiler3 = require("svelte/compiler");
+var import_compiler4 = require("svelte/compiler");
 
 // src/utils/sourcemap.ts
 var import_magic_string = __toESM(require("magic-string"), 1);
@@ -925,7 +783,7 @@ async function buildMagicString(from, to, options) {
     const diff = diffs[i];
     const nextDiff = diffs[i + 1];
     if (diff[0] === DIFF_DELETE) {
-      if ((nextDiff == null ? void 0 : nextDiff[0]) === DIFF_INSERT) {
+      if (nextDiff?.[0] === DIFF_INSERT) {
         m.overwrite(pos, pos + diff[1].length, nextDiff[1]);
         i++;
       } else {
@@ -950,7 +808,7 @@ async function buildSourceMap(from, to, filename) {
 }
 
 // src/utils/preprocess.ts
-var import_path3 = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
 var supportedScriptLangs = ["ts"];
 function createViteScriptPreprocessor() {
@@ -958,7 +816,7 @@ function createViteScriptPreprocessor() {
     const lang = attributes.lang;
     if (!supportedScriptLangs.includes(lang))
       return;
-    const transformResult = await (0, import_vite3.transformWithEsbuild)(content, filename, {
+    const transformResult = await vite.transformWithEsbuild(content, filename, {
       loader: lang,
       target: "esnext",
       tsconfigRaw: {
@@ -975,38 +833,43 @@ function createViteScriptPreprocessor() {
   };
 }
 function createViteStylePreprocessor(config) {
-  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`);
-  }
-  const pluginTransform = plugin.transform.bind(null);
+  const transform = getCssTransformFn(config);
   return async ({ attributes, content, filename = "" }) => {
-    var _a, _b;
     const lang = attributes.lang;
     if (!supportedStyleLangs.includes(lang))
       return;
     const moduleId = `${filename}.${lang}`;
-    const transformResult = await pluginTransform(
-      content,
-      moduleId
-    );
-    if (((_b = (_a = transformResult.map) == null ? void 0 : _a.sources) == null ? void 0 : _b[0]) === moduleId) {
-      transformResult.map.sources[0] = import_path3.default.basename(filename);
+    const result = await transform(content, moduleId);
+    if (result.map?.sources?.[0] === moduleId) {
+      result.map.sources[0] = import_path2.default.basename(filename);
     }
     return {
-      code: transformResult.code,
-      map: transformResult.map ?? void 0
+      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_compiler3.preprocess)(
+      return (0, import_compiler4.preprocess)(
         content,
         {
           script: createViteScriptPreprocessor(),
@@ -1025,7 +888,7 @@ function createInjectScopeEverythingRulePreprocessorGroup() {
       return {
         code: s.toString(),
         map: s.generateDecodedMap({
-          source: filename ? import_path3.default.basename(filename) : void 0,
+          source: filename ? import_path2.default.basename(filename) : void 0,
           hires: true
         })
       };
@@ -1033,14 +896,13 @@ function createInjectScopeEverythingRulePreprocessorGroup() {
   };
 }
 function buildExtraPreprocessors(options, config) {
-  var _a, _b;
   const prependPreprocessors = [];
   const appendPreprocessors = [];
-  if ((_a = options.experimental) == null ? void 0 : _a.useVitePreprocess) {
+  if (options.experimental?.useVitePreprocess) {
     log.debug("adding vite preprocessor");
     prependPreprocessors.push(createVitePreprocessorGroup(config));
   }
-  const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p == null ? void 0 : p.sveltePreprocess);
+  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(", ")}`
@@ -1058,13 +920,10 @@ function buildExtraPreprocessors(options, config) {
       }
     });
   }
-  const pluginsWithPreprocessors = config.plugins.filter((p) => {
-    var _a2;
-    return (_a2 = p == null ? void 0 : p.api) == null ? void 0 : _a2.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) && ((_b = options.ignorePluginPreprocessors) == null ? void 0 : _b.includes(p.name))) {
+    if (options.ignorePluginPreprocessors === true || Array.isArray(options.ignorePluginPreprocessors) && options.ignorePluginPreprocessors?.includes(p.name)) {
       ignored.push(p);
     } else {
       included.push(p);
@@ -1087,7 +946,6 @@ function buildExtraPreprocessors(options, config) {
   return { prependPreprocessors, appendPreprocessors };
 }
 function addExtraPreprocessors(options, config) {
-  var _a;
   const { prependPreprocessors, appendPreprocessors } = buildExtraPreprocessors(options, config);
   if (prependPreprocessors.length > 0 || appendPreprocessors.length > 0) {
     if (!options.preprocess) {
@@ -1099,7 +957,7 @@ function addExtraPreprocessors(options, config) {
       options.preprocess = [...prependPreprocessors, options.preprocess, ...appendPreprocessors];
     }
   }
-  const generateMissingSourceMaps = !!((_a = options.experimental) == null ? void 0 : _a.generateMissingPreprocessorSourcemaps);
+  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);
   }
@@ -1108,7 +966,6 @@ function validateSourceMapOutputWrapper(group, i) {
   const wrapper = {};
   for (const [processorType, processorFn] of Object.entries(group)) {
     wrapper[processorType] = async (options) => {
-      var _a;
       const result = await processorFn(options);
       if (result && result.code !== options.content) {
         let invalidMap = false;
@@ -1122,7 +979,7 @@ function validateSourceMapOutputWrapper(group, i) {
               processor: processorFn.toString()
             }
           );
-        } else if (((_a = result.map) == null ? void 0 : _a.mappings) === "") {
+        } 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`,
@@ -1155,6 +1012,72 @@ function validateSourceMapOutputWrapper(group, i) {
 
 // src/utils/options.ts
 var import_deepmerge = __toESM(require("deepmerge"), 1);
+var import_vitefu2 = require("vitefu");
+
+// src/utils/dependencies.ts
+var import_path3 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_vitefu = require("vitefu");
+async function resolveDependencyData(dep, parent) {
+  const depDataPath = await (0, import_vitefu.findDepPkgJsonPath)(dep, parent);
+  if (!depDataPath)
+    return void 0;
+  try {
+    return {
+      dir: import_path3.default.dirname(depDataPath),
+      pkg: JSON.parse(await import_promises.default.readFile(depDataPath, "utf-8"))
+    };
+  } catch {
+    return void 0;
+  }
+}
+var COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD = [
+  "@lukeed/uuid",
+  "@playwright/test",
+  "@sveltejs/vite-plugin-svelte",
+  "@sveltejs/kit",
+  "autoprefixer",
+  "cookie",
+  "dotenv",
+  "esbuild",
+  "eslint",
+  "jest",
+  "mdsvex",
+  "playwright",
+  "postcss",
+  "prettier",
+  "svelte",
+  "svelte-check",
+  "svelte-hmr",
+  "svelte-preprocess",
+  "tslib",
+  "typescript",
+  "vite",
+  "vitest",
+  "__vite-browser-external"
+];
+var COMMON_PREFIXES_WITHOUT_SVELTE_FIELD = [
+  "@fontsource/",
+  "@postcss-plugins/",
+  "@rollup/",
+  "@sveltejs/adapter-",
+  "@types/",
+  "@typescript-eslint/",
+  "eslint-",
+  "jest-",
+  "postcss-plugin-",
+  "prettier-plugin-",
+  "rollup-plugin-",
+  "vite-plugin-"
+];
+function isCommonDepWithoutSvelteField(dependency) {
+  return COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD.includes(dependency) || COMMON_PREFIXES_WITHOUT_SVELTE_FIELD.some(
+    (prefix2) => prefix2.startsWith("@") ? dependency.startsWith(prefix2) : dependency.substring(dependency.lastIndexOf("/") + 1).startsWith(prefix2)
+  );
+}
+
+// src/utils/options.ts
+var cssAsString = atLeastSvelte("3.53.0");
 var allowedPluginOptions = /* @__PURE__ */ new Set([
   "include",
   "exclude",
@@ -1257,7 +1180,7 @@ async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
     inlineOptions,
     extraOptions
   );
-  if (svelteConfig == null ? void 0 : svelteConfig.configFile) {
+  if (svelteConfig?.configFile) {
     merged.configFile = svelteConfig.configFile;
   }
   return merged;
@@ -1272,14 +1195,14 @@ function mergeConfigs(...configs) {
   return result;
 }
 function resolveOptions(preResolveOptions2, viteConfig) {
-  var _a;
+  const css = cssAsString ? preResolveOptions2.emitCss ? "external" : "injected" : !preResolveOptions2.emitCss;
   const defaultOptions = {
     hot: viteConfig.isProduction ? false : {
-      injectCss: !preResolveOptions2.emitCss,
-      partialAccept: !!((_a = viteConfig.experimental) == null ? void 0 : _a.hmrPartialAccept)
+      injectCss: css === true || css === "injected",
+      partialAccept: !!viteConfig.experimental?.hmrPartialAccept
     },
     compilerOptions: {
-      css: !preResolveOptions2.emitCss,
+      css,
       dev: !viteConfig.isProduction
     }
   };
@@ -1307,11 +1230,13 @@ function enforceOptionsForHmr(options) {
         log.warn("hmr and emitCss are enabled but hot.injectCss is true, forcing it to false");
         options.hot.injectCss = false;
       }
-      if (options.compilerOptions.css) {
+      const css = options.compilerOptions.css;
+      if (css === true || css === "injected") {
+        const forcedCss = cssAsString ? "external" : false;
         log.warn(
-          "hmr and emitCss are enabled but compilerOptions.css is true, forcing it to false"
+          `hmr and emitCss are enabled but compilerOptions.css is ${css}, forcing it to ${forcedCss}`
         );
-        options.compilerOptions.css = false;
+        options.compilerOptions.css = forcedCss;
       }
     } else {
       if (options.hot === true || !options.hot.injectCss) {
@@ -1324,11 +1249,13 @@ function enforceOptionsForHmr(options) {
           options.hot.injectCss = true;
         }
       }
-      if (!options.compilerOptions.css) {
+      const css = options.compilerOptions.css;
+      if (!(css === true || css === "injected")) {
+        const forcedCss = cssAsString ? "injected" : true;
         log.warn(
-          "hmr with emitCss disabled requires compilerOptions.css to be enabled, forcing it to true"
+          `hmr with emitCss disabled requires compilerOptions.css to be enabled, forcing it to ${forcedCss}`
         );
-        options.compilerOptions.css = true;
+        options.compilerOptions.css = forcedCss;
       }
     }
   }
@@ -1366,141 +1293,137 @@ function removeIgnoredOptions(options) {
   }
 }
 function addSvelteKitOptions(options) {
-  var _a;
-  if ((options == null ? void 0 : options.kit) != null) {
-    const kit_browser_hydrate = (_a = options.kit.browser) == null ? void 0 : _a.hydrate;
-    const hydratable = kit_browser_hydrate !== false;
-    if (options.compilerOptions.hydratable != null && options.compilerOptions.hydratable !== hydratable) {
-      log.warn(
-        `Conflicting values "compilerOptions.hydratable: ${options.compilerOptions.hydratable}" and "kit.browser.hydrate: ${kit_browser_hydrate}" in your svelte config. You should remove "compilerOptions.hydratable".`
-      );
-    }
-    log.debug(`Setting compilerOptions.hydratable: ${hydratable} for SvelteKit`);
-    options.compilerOptions.hydratable = hydratable;
+  if (options?.kit != null && options.compilerOptions.hydratable == null) {
+    log.debug(`Setting compilerOptions.hydratable = true for SvelteKit`);
+    options.compilerOptions.hydratable = true;
   }
 }
 function handleDeprecatedOptions(options) {
-  var _a, _b;
-  if ((_a = options.experimental) == null ? void 0 : _a.prebundleSvelteLibraries) {
-    options.prebundleSvelteLibraries = (_b = options.experimental) == null ? void 0 : _b.prebundleSvelteLibraries;
+  if (options.experimental?.prebundleSvelteLibraries) {
+    options.prebundleSvelteLibraries = options.experimental?.prebundleSvelteLibraries;
     log.warn(
       "experimental.prebundleSvelteLibraries is no longer experimental and has moved to prebundleSvelteLibraries"
     );
   }
 }
 function resolveViteRoot(viteConfig) {
-  return (0, import_vite4.normalizePath)(viteConfig.root ? import_path4.default.resolve(viteConfig.root) : process.cwd());
+  return (0, import_vite3.normalizePath)(viteConfig.root ? import_path4.default.resolve(viteConfig.root) : process.cwd());
 }
-function buildExtraViteConfig(options, config) {
-  var _a;
-  const svelteDeps = findRootSvelteDependencies(options.root);
+async function buildExtraViteConfig(options, config) {
   const extraViteConfig = {
     resolve: {
       mainFields: [...SVELTE_RESOLVE_MAIN_FIELDS],
       dedupe: [...SVELTE_IMPORTS, ...SVELTE_HMR_IMPORTS]
     }
   };
-  extraViteConfig.optimizeDeps = buildOptimizeDepsForSvelte(
-    svelteDeps,
-    options,
-    config.optimizeDeps
-  );
+  const extraSvelteConfig = buildExtraConfigForSvelte(config);
+  const extraDepsConfig = await buildExtraConfigForDependencies(options, config);
+  extraViteConfig.optimizeDeps = {
+    include: [
+      ...extraSvelteConfig.optimizeDeps.include,
+      ...extraDepsConfig.optimizeDeps.include.filter(
+        (dep) => !(0, import_vitefu2.isDepExcluded)(dep, extraSvelteConfig.optimizeDeps.exclude)
+      )
+    ],
+    exclude: [
+      ...extraSvelteConfig.optimizeDeps.exclude,
+      ...extraDepsConfig.optimizeDeps.exclude.filter(
+        (dep) => !(0, import_vitefu2.isDepIncluded)(dep, extraSvelteConfig.optimizeDeps.include)
+      )
+    ]
+  };
+  extraViteConfig.ssr = {
+    external: [
+      ...extraSvelteConfig.ssr.external,
+      ...extraDepsConfig.ssr.external.filter(
+        (dep) => !(0, import_vitefu2.isDepNoExternaled)(dep, extraSvelteConfig.ssr.noExternal)
+      )
+    ],
+    noExternal: [
+      ...extraSvelteConfig.ssr.noExternal,
+      ...extraDepsConfig.ssr.noExternal.filter(
+        (dep) => !(0, import_vitefu2.isDepExternaled)(dep, extraSvelteConfig.ssr.external)
+      )
+    ]
+  };
   if (options.prebundleSvelteLibraries) {
-    extraViteConfig.optimizeDeps = {
-      ...extraViteConfig.optimizeDeps,
-      extensions: options.extensions ?? [".svelte"],
-      esbuildOptions: {
-        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
-        } }]
-      }
+    extraViteConfig.optimizeDeps.extensions = options.extensions ?? [".svelte"];
+    extraViteConfig.optimizeDeps.esbuildOptions = {
+      plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
+      } }]
     };
   }
-  extraViteConfig.ssr = buildSSROptionsForSvelte(svelteDeps, options, config, extraViteConfig);
-  if ((options.hot == null || options.hot === true || options.hot && options.hot.partialAccept !== false) && ((_a = config.experimental) == null ? void 0 : _a.hmrPartialAccept) !== false) {
+  if ((options.hot == null || options.hot === true || options.hot && options.hot.partialAccept !== false) && config.experimental?.hmrPartialAccept !== false) {
     log.debug('enabling "experimental.hmrPartialAccept" in vite config');
     extraViteConfig.experimental = { hmrPartialAccept: true };
   }
   return extraViteConfig;
 }
-function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
+async function buildExtraConfigForDependencies(options, config) {
+  const depsConfig = await (0, import_vitefu2.crawlFrameworkPkgs)({
+    root: options.root,
+    isBuild: options.isBuild,
+    viteUserConfig: config,
+    isFrameworkPkgByJson(pkgJson) {
+      return !!pkgJson.svelte;
+    },
+    isSemiFrameworkPkgByJson(pkgJson) {
+      return !!pkgJson.dependencies?.svelte || !!pkgJson.peerDependencies?.svelte;
+    },
+    isFrameworkPkgByName(pkgName) {
+      const isNotSveltePackage = isCommonDepWithoutSvelteField(pkgName);
+      if (isNotSveltePackage) {
+        return false;
+      } else {
+        return void 0;
+      }
+    }
+  });
+  log.debug("extra config for dependencies generated by vitefu", depsConfig);
+  if (options.prebundleSvelteLibraries) {
+    depsConfig.optimizeDeps.exclude = [];
+    const userExclude = config.optimizeDeps?.exclude;
+    depsConfig.optimizeDeps.include = !userExclude ? [] : depsConfig.optimizeDeps.include.filter((dep) => {
+      return dep.includes(">") && dep.split(">").slice(0, -1).some((d) => (0, import_vitefu2.isDepExcluded)(d.trim(), userExclude));
+    });
+  }
+  if (options.disableDependencyReinclusion === true) {
+    depsConfig.optimizeDeps.include = depsConfig.optimizeDeps.include.filter(
+      (dep) => !dep.includes(">")
+    );
+  } else if (Array.isArray(options.disableDependencyReinclusion)) {
+    const disabledDeps = options.disableDependencyReinclusion;
+    depsConfig.optimizeDeps.include = depsConfig.optimizeDeps.include.filter((dep) => {
+      if (!dep.includes(">"))
+        return true;
+      const trimDep = dep.replace(/\s+/g, "");
+      return disabledDeps.some((disabled) => trimDep.includes(`${disabled}>`));
+    });
+  }
+  log.debug("post-processed extra config for dependencies", depsConfig);
+  return depsConfig;
+}
+function buildExtraConfigForSvelte(config) {
   const include = [];
   const exclude = ["svelte-hmr"];
-  const isIncluded = (dep) => {
-    var _a;
-    return include.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.include) == null ? void 0 : _a.includes(dep));
-  };
-  const isExcluded = (dep) => {
-    var _a;
-    return exclude.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
-  };
-  if (!isExcluded("svelte")) {
+  if (!(0, import_vitefu2.isDepExcluded)("svelte", config.optimizeDeps?.exclude ?? [])) {
     const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== "svelte/ssr");
     log.debug(
       `adding bare svelte packages to optimizeDeps.include: ${svelteImportsToInclude.join(", ")} `
     );
-    include.push(...svelteImportsToInclude.filter((x) => !isIncluded(x)));
+    include.push(...svelteImportsToInclude);
   } else {
     log.debug('"svelte" is excluded in optimizeDeps.exclude, skipped adding it to include.');
   }
-  if (options.prebundleSvelteLibraries) {
-    return { include, exclude };
-  }
-  svelteDeps = svelteDeps.filter((dep) => dep.type === "component-library");
-  const svelteDepsToExclude = Array.from(new Set(svelteDeps.map((dep) => dep.name))).filter(
-    (dep) => !isIncluded(dep)
-  );
-  log.debug(`automatically excluding found svelte dependencies: ${svelteDepsToExclude.join(", ")}`);
-  exclude.push(...svelteDepsToExclude.filter((x) => !isExcluded(x)));
-  if (options.disableDependencyReinclusion !== true) {
-    const disabledReinclusions = options.disableDependencyReinclusion || [];
-    if (disabledReinclusions.length > 0) {
-      log.debug(`not reincluding transitive dependencies of`, disabledReinclusions);
-    }
-    const transitiveDepsToInclude = svelteDeps.filter((dep) => !disabledReinclusions.includes(dep.name) && isExcluded(dep.name)).flatMap((dep) => {
-      const localRequire = (0, import_module3.createRequire)(`${dep.dir}/package.json`);
-      return Object.keys(dep.pkg.dependencies || {}).filter((depOfDep) => !isExcluded(depOfDep) && needsOptimization(depOfDep, localRequire)).map((depOfDep) => dep.path.concat(dep.name, depOfDep).join(" > "));
-    });
-    log.debug(
-      `reincluding transitive dependencies of excluded svelte dependencies`,
-      transitiveDepsToInclude
-    );
-    include.push(...transitiveDepsToInclude);
-  }
-  return { include, exclude };
-}
-function buildSSROptionsForSvelte(svelteDeps, options, config) {
-  var _a, _b;
   const noExternal = [];
-  if (!((_b = (_a = config.ssr) == null ? void 0 : _a.external) == null ? void 0 : _b.includes("svelte"))) {
+  const external = [];
+  if (!(0, import_vitefu2.isDepExternaled)("svelte", config.ssr?.external ?? [])) {
     noExternal.push("svelte", /^svelte\//);
   }
-  noExternal.push(
-    ...Array.from(new Set(svelteDeps.map((s) => s.name))).filter(
-      (x) => {
-        var _a2, _b2;
-        return !((_b2 = (_a2 = config.ssr) == null ? void 0 : _a2.external) == null ? void 0 : _b2.includes(x));
-      }
-    )
-  );
-  const ssr = {
-    noExternal,
-    external: []
-  };
-  if (options.isServe) {
-    ssr.external = Array.from(
-      new Set(svelteDeps.flatMap((dep) => Object.keys(dep.pkg.dependencies || {})))
-    ).filter(
-      (dep) => {
-        var _a2, _b2;
-        return !ssr.noExternal.includes(dep) && !((_b2 = (_a2 = config.ssr) == null ? void 0 : _a2.external) == null ? void 0 : _b2.includes(dep));
-      }
-    );
-  }
-  return ssr;
+  return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 function patchResolvedViteConfig(viteConfig, options) {
-  var _a, _b;
-  const facadeEsbuildSveltePlugin = (_b = (_a = viteConfig.optimizeDeps.esbuildOptions) == null ? void 0 : _a.plugins) == null ? void 0 : _b.find(
+  const facadeEsbuildSveltePlugin = viteConfig.optimizeDeps.esbuildOptions?.plugins?.find(
     (plugin) => plugin.name === facadeEsbuildSveltePluginName
   );
   if (facadeEsbuildSveltePlugin) {
@@ -1614,7 +1537,7 @@ var VitePluginSvelteCache = class {
 };
 
 // src/utils/watch.ts
-var import_fs4 = __toESM(require("fs"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 var import_path5 = __toESM(require("path"), 1);
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
@@ -1626,7 +1549,7 @@ function setupWatchers(options, cache, requestParser) {
   const emitChangeEventOnDependants = (filename) => {
     const dependants = cache.getDependants(filename);
     dependants.forEach((dependant) => {
-      if (import_fs4.default.existsSync(dependant)) {
+      if (import_fs3.default.existsSync(dependant)) {
         log.debug(
           `emitting virtual change event for "${dependant}" because depdendency "${filename}" changed`
         );
@@ -1687,22 +1610,21 @@ function setupWatchers(options, cache, requestParser) {
   });
 }
 function ensureWatchedFile(watcher, file, root) {
-  if (file && !file.startsWith(root + "/") && !file.includes("\0") && import_fs4.default.existsSync(file)) {
+  if (file && !file.startsWith(root + "/") && !file.includes("\0") && import_fs3.default.existsSync(file)) {
     watcher.add(import_path5.default.resolve(file));
   }
 }
 
 // src/utils/resolve.ts
 var import_path6 = __toESM(require("path"), 1);
-var import_module4 = require("module");
-function resolveViaPackageJsonSvelte(importee, importer, cache) {
-  if (importer && isBareImport(importee) && !isNodeInternal(importee) && !is_common_without_svelte_field(importee)) {
+var import_module2 = require("module");
+async function resolveViaPackageJsonSvelte(importee, importer, cache) {
+  if (importer && isBareImport(importee) && !isNodeInternal(importee) && !isCommonDepWithoutSvelteField(importee)) {
     const cached = cache.getResolvedSvelteField(importee, importer);
     if (cached) {
       return cached;
     }
-    const localRequire = (0, import_module4.createRequire)(importer);
-    const pkgData = resolveDependencyData(importee, localRequire);
+    const pkgData = await resolveDependencyData(importee, importer);
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
@@ -1714,7 +1636,7 @@ function resolveViaPackageJsonSvelte(importee, importer, cache) {
   }
 }
 function isNodeInternal(importee) {
-  return importee.startsWith("node:") || import_module4.builtinModules.includes(importee);
+  return importee.startsWith("node:") || import_module2.builtinModules.includes(importee);
 }
 function isBareImport(importee) {
   if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path6.default.isAbsolute(importee)) {
@@ -1732,7 +1654,7 @@ function isBareImport(importee) {
 }
 
 // src/utils/optimizer.ts
-var import_fs5 = require("fs");
+var import_fs4 = require("fs");
 var import_path7 = __toESM(require("path"), 1);
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
@@ -1750,11 +1672,11 @@ async function saveSvelteMetadata(cacheDir, options) {
   });
   let existingSvelteMetadata;
   try {
-    existingSvelteMetadata = await import_fs5.promises.readFile(svelteMetadataPath, "utf8");
+    existingSvelteMetadata = await import_fs4.promises.readFile(svelteMetadataPath, "utf8");
   } catch {
   }
-  await import_fs5.promises.mkdir(cacheDir, { recursive: true });
-  await import_fs5.promises.writeFile(svelteMetadataPath, currentSvelteMetadata);
+  await import_fs4.promises.mkdir(cacheDir, { recursive: true });
+  await import_fs4.promises.writeFile(svelteMetadataPath, currentSvelteMetadata);
   return currentSvelteMetadata !== existingSvelteMetadata;
 }
 function generateSvelteMetadata(options) {
@@ -1766,10 +1688,10 @@ function generateSvelteMetadata(options) {
 }
 
 // src/ui/inspector/plugin.ts
-var import_vite5 = require("vite");
+var import_vite4 = require("vite");
 var import_path8 = __toESM(require("path"), 1);
 var import_url2 = require("url");
-var import_fs6 = __toESM(require("fs"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
 
 // src/ui/inspector/utils.ts
 var FS_PREFIX = `/@fs/`;
@@ -1794,7 +1716,7 @@ var defaultInspectorOptions = {
   customStyles: true
 };
 function getInspectorPath() {
-  const pluginPath = (0, import_vite5.normalizePath)(import_path8.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl)));
+  const pluginPath = (0, import_vite4.normalizePath)(import_path8.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl)));
   return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
 }
 function svelteInspector() {
@@ -1808,9 +1730,8 @@ function svelteInspector() {
     apply: "serve",
     enforce: "pre",
     configResolved(config) {
-      var _a, _b, _c;
       const vps = config.plugins.find((p) => p.name === "vite-plugin-svelte");
-      if ((_c = (_b = (_a = vps == null ? void 0 : vps.api) == null ? void 0 : _a.options) == null ? void 0 : _b.experimental) == null ? void 0 : _c.inspector) {
+      if (vps?.api?.options?.experimental?.inspector) {
         inspectorOptions = {
           ...defaultInspectorOptions,
           ...vps.api.options.experimental.inspector
@@ -1828,7 +1749,7 @@ function svelteInspector() {
       }
     },
     async resolveId(importee, importer, options) {
-      if ((options == null ? void 0 : options.ssr) || disabled) {
+      if (options?.ssr || disabled) {
         return;
       }
       if (importee.startsWith("virtual:svelte-inspector-options")) {
@@ -1840,22 +1761,22 @@ function svelteInspector() {
       }
     },
     async load(id, options) {
-      if ((options == null ? void 0 : options.ssr) || disabled) {
+      if (options?.ssr || disabled) {
         return;
       }
       if (id === "virtual:svelte-inspector-options") {
         return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
       } else if (id.startsWith(inspectorPath)) {
         const file = idToFile(id);
-        if (import_fs6.default.existsSync(file)) {
-          return await import_fs6.default.promises.readFile(file, "utf-8");
+        if (import_fs5.default.existsSync(file)) {
+          return await import_fs5.default.promises.readFile(file, "utf-8");
         } else {
           log.error(`failed to find file for svelte-inspector: ${file}, referenced by id ${id}.`);
         }
       }
     },
     transform(code, id, options) {
-      if ((options == null ? void 0 : options.ssr) || disabled || !appendTo) {
+      if (options?.ssr || disabled || !appendTo) {
         return;
       }
       if (id.endsWith(appendTo)) {
@@ -1909,7 +1830,7 @@ function svelte(inlineOptions) {
           log.setLevel(config.logLevel);
         }
         options = await preResolveOptions(inlineOptions, config, configEnv);
-        const extraViteConfig = buildExtraViteConfig(options, config);
+        const extraViteConfig = await buildExtraViteConfig(options, config);
         log.debug("additional vite config", extraViteConfig);
         return extraViteConfig;
       },
@@ -1935,7 +1856,7 @@ function svelte(inlineOptions) {
         setupWatchers(options, cache, requestParser);
       },
       load(id, opts) {
-        const ssr = !!(opts == null ? void 0 : opts.ssr);
+        const ssr = !!opts?.ssr;
         const svelteRequest = requestParser(id, !!ssr);
         if (svelteRequest) {
           const { filename, query } = svelteRequest;
@@ -1948,14 +1869,14 @@ function svelte(inlineOptions) {
           }
           if (viteConfig.assetsInclude(filename)) {
             log.debug(`load returns raw content for ${filename}`);
-            return import_fs7.default.readFileSync(filename, "utf-8");
+            return import_fs6.default.readFileSync(filename, "utf-8");
           }
         }
       },
       async resolveId(importee, importer, opts) {
-        const ssr = !!(opts == null ? void 0 : opts.ssr);
+        const ssr = !!opts?.ssr;
         const svelteRequest = requestParser(importee, ssr);
-        if (svelteRequest == null ? void 0 : svelteRequest.query.svelte) {
+        if (svelteRequest?.query.svelte) {
           if (svelteRequest.query.type === "style") {
             log.debug(`resolveId resolved virtual css module ${svelteRequest.cssId}`);
             return svelteRequest.cssId;
@@ -1981,24 +1902,27 @@ function svelte(inlineOptions) {
           }
           return resolvedSvelteSSR;
         }
-        try {
-          const resolved = resolveViaPackageJsonSvelte(importee, importer, cache);
-          if (resolved) {
-            log.debug(
-              `resolveId resolved ${resolved} via package.json svelte field of ${importee}`
+        const scan = !!opts?.scan;
+        const isPrebundled = options.prebundleSvelteLibraries && viteConfig.optimizeDeps?.disabled !== true && viteConfig.optimizeDeps?.disabled !== (options.isBuild ? "build" : "dev") && !(0, import_vitefu3.isDepExcluded)(importee, viteConfig.optimizeDeps?.exclude ?? []);
+        if (ssr || scan || !isPrebundled) {
+          try {
+            const resolved = await resolveViaPackageJsonSvelte(importee, importer, cache);
+            if (resolved) {
+              log.debug(
+                `resolveId resolved ${resolved} via package.json svelte field of ${importee}`
+              );
+              return resolved;
+            }
+          } catch (e) {
+            log.debug.once(
+              `error trying to resolve ${importee} from ${importer} via package.json svelte field `,
+              e
             );
-            return resolved;
           }
-        } catch (e) {
-          log.debug.once(
-            `error trying to resolve ${importee} from ${importer} via package.json svelte field `,
-            e
-          );
         }
       },
       async transform(code, id, opts) {
-        var _a;
-        const ssr = !!(opts == null ? void 0 : opts.ssr);
+        const ssr = !!opts?.ssr;
         const svelteRequest = requestParser(id, ssr);
         if (!svelteRequest || svelteRequest.query.svelte) {
           return;
@@ -2012,7 +1936,7 @@ function svelte(inlineOptions) {
         }
         logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
         cache.update(compileData);
-        if (((_a = compileData.dependencies) == null ? void 0 : _a.length) && options.server) {
+        if (compileData.dependencies?.length && options.server) {
           compileData.dependencies.forEach((d) => {
             ensureWatchedFile(options.server.watcher, d, options.root);
           });