@sveltejs/vite-plugin-svelte 1.1.1 → 1.2.0

package/dist/index.cjs

@@ -31,12 +31,13 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../node_modules/.pnpm/tsup@6.4.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");
@@ -368,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)};
 `;
@@ -377,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
@@ -602,182 +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) {
-  return !!pkg.dependencies?.svelte || !!pkg.peerDependencies?.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) {
@@ -832,7 +661,38 @@ 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 {
@@ -843,7 +703,7 @@ function esbuildSveltePlugin(options) {
       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 };
@@ -855,9 +715,13 @@ function esbuildSveltePlugin(options) {
   };
 }
 async function compileSvelte(options, { filename, code }) {
+  let css = options.compilerOptions.css;
+  if (css !== "none") {
+    css = isCssString ? "injected" : true;
+  }
   const compileOptions = {
     ...options.compilerOptions,
-    css: true,
+    css,
     filename,
     format: "esm",
     generate: "dom"
@@ -865,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;
@@ -886,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 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);
@@ -944,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() {
@@ -977,7 +841,7 @@ function createViteStylePreprocessor(config) {
     const moduleId = `${filename}.${lang}`;
     const result = await transform(content, moduleId);
     if (result.map?.sources?.[0] === moduleId) {
-      result.map.sources[0] = import_path3.default.basename(filename);
+      result.map.sources[0] = import_path2.default.basename(filename);
     }
     return {
       code: result.code,
@@ -1005,7 +869,7 @@ function getCssTransformFn(config) {
 function createVitePreprocessorGroup(config) {
   return {
     markup({ content, filename }) {
-      return (0, import_compiler3.preprocess)(
+      return (0, import_compiler4.preprocess)(
         content,
         {
           script: createViteScriptPreprocessor(),
@@ -1024,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
         })
       };
@@ -1148,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",
@@ -1265,13 +1195,14 @@ function mergeConfigs(...configs) {
   return result;
 }
 function resolveOptions(preResolveOptions2, viteConfig) {
+  const css = cssAsString ? preResolveOptions2.emitCss ? "external" : "injected" : !preResolveOptions2.emitCss;
   const defaultOptions = {
     hot: viteConfig.isProduction ? false : {
-      injectCss: !preResolveOptions2.emitCss,
+      injectCss: css === true || css === "injected",
       partialAccept: !!viteConfig.experimental?.hmrPartialAccept
     },
     compilerOptions: {
-      css: !preResolveOptions2.emitCss,
+      css,
       dev: !viteConfig.isProduction
     }
   };
@@ -1299,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) {
@@ -1316,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;
       }
     }
   }
@@ -1358,16 +1293,9 @@ function removeIgnoredOptions(options) {
   }
 }
 function addSvelteKitOptions(options) {
-  if (options?.kit != null) {
-    const kit_browser_hydrate = options.kit.browser?.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) {
@@ -1381,100 +1309,118 @@ function handleDeprecatedOptions(options) {
 function resolveViteRoot(viteConfig) {
   return (0, import_vite3.normalizePath)(viteConfig.root ? import_path4.default.resolve(viteConfig.root) : process.cwd());
 }
-function buildExtraViteConfig(options, config) {
-  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) && 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) => include.includes(dep) || optimizeDeps?.include?.includes(dep);
-  const isExcluded = (dep) => {
-    return exclude.includes(dep) || optimizeDeps?.exclude?.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) {
   const noExternal = [];
-  if (!config.ssr?.external?.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) => !config.ssr?.external?.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) => !ssr.noExternal.includes(dep) && !config.ssr?.external?.includes(dep)
-    );
-  }
-  return ssr;
+  return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 function patchResolvedViteConfig(viteConfig, options) {
   const facadeEsbuildSveltePlugin = viteConfig.optimizeDeps.esbuildOptions?.plugins?.find(
@@ -1591,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;
@@ -1603,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`
         );
@@ -1664,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) {
@@ -1691,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)) {
@@ -1709,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",
@@ -1727,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) {
@@ -1746,7 +1691,7 @@ function generateSvelteMetadata(options) {
 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/`;
@@ -1823,8 +1768,8 @@ function svelteInspector() {
         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}.`);
         }
@@ -1885,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;
       },
@@ -1924,7 +1869,7 @@ 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");
           }
         }
       },
@@ -1957,19 +1902,23 @@ 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) {