@sveltejs/vite-plugin-svelte 1.1.1 → 1.2.0

package/dist/index.js

@@ -8,6 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/index.ts
 import fs8 from "fs";
+import { isDepExcluded as isDepExcluded2 } from "vitefu";
 
 // src/utils/log.ts
 import { cyan, yellow, red } from "kleur/colors";
@@ -339,7 +340,8 @@ var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequ
     ...dynamicCompileOptions
   } : compileOptions;
   const compiled = 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)};
 `;
@@ -348,7 +350,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
@@ -461,9 +463,7 @@ function buildIdParser(options) {
 }
 
 // src/utils/options.ts
-import {
-  normalizePath as normalizePath2
-} from "vite";
+import { normalizePath as normalizePath2 } from "vite";
 
 // src/utils/load-svelte-config.ts
 import { createRequire } from "module";
@@ -575,181 +575,8 @@ var SVELTE_HMR_IMPORTS = [
 // src/utils/options.ts
 import path4 from "path";
 
-// src/utils/dependencies.ts
-import path2 from "path";
-import fs3 from "fs";
-import { createRequire as createRequire2 } from "module";
-function findRootSvelteDependencies(root, cwdFallback = true) {
-  log.debug(`findSvelteDependencies: searching svelte dependencies in ${root}`);
-  const pkgFile = path2.join(root, "package.json");
-  if (!fs3.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 = createRequire2(`${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 = path2.dirname(localRequire.resolve(pkgJson));
-    return { dir, pkg };
-  } catch (e) {
-    log.debug.once(`dependency ${dep} does not export package.json`, e);
-    try {
-      let dir = path2.dirname(localRequire.resolve(dep));
-      while (dir) {
-        const pkg = parsePkg(dir, true);
-        if (pkg && pkg.name === dep) {
-          return { dir, pkg };
-        }
-        const parent = path2.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 = path2.join(dir, "package.json");
-  try {
-    return JSON.parse(fs3.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 = path2.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
-import { createRequire as createRequire3 } from "module";
-
 // src/utils/esbuild.ts
-import { promises as fs4 } from "fs";
+import { promises as fs3 } from "fs";
 import { compile as compile2, preprocess as preprocess2 } from "svelte/compiler";
 
 // src/utils/error.ts
@@ -805,7 +632,38 @@ function formatFrameForVite(frame) {
   return frame.split("\n").map((line) => line.match(/^\s+\^/) ? "   " + line : " " + line.replace(":", " | ")).join("\n");
 }
 
+// src/utils/svelte-version.ts
+import { VERSION } from "svelte/compiler";
+var svelteVersion = parseVersion(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 {
@@ -816,7 +674,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 fs4.readFile(filename, "utf8");
+        const code = await fs3.readFile(filename, "utf8");
         try {
           const contents = await compileSvelte(options, { filename, code });
           return { contents };
@@ -828,9 +686,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"
@@ -917,7 +779,7 @@ async function buildSourceMap(from, to, filename) {
 }
 
 // src/utils/preprocess.ts
-import path3 from "path";
+import path2 from "path";
 var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
 var supportedScriptLangs = ["ts"];
 function createViteScriptPreprocessor() {
@@ -950,7 +812,7 @@ function createViteStylePreprocessor(config) {
     const moduleId = `${filename}.${lang}`;
     const result = await transform(content, moduleId);
     if (result.map?.sources?.[0] === moduleId) {
-      result.map.sources[0] = path3.basename(filename);
+      result.map.sources[0] = path2.basename(filename);
     }
     return {
       code: result.code,
@@ -997,7 +859,7 @@ function createInjectScopeEverythingRulePreprocessorGroup() {
       return {
         code: s.toString(),
         map: s.generateDecodedMap({
-          source: filename ? path3.basename(filename) : void 0,
+          source: filename ? path2.basename(filename) : void 0,
           hires: true
         })
       };
@@ -1121,6 +983,78 @@ function validateSourceMapOutputWrapper(group, i) {
 
 // src/utils/options.ts
 import deepmerge from "deepmerge";
+import {
+  crawlFrameworkPkgs,
+  isDepExcluded,
+  isDepExternaled,
+  isDepIncluded,
+  isDepNoExternaled
+} from "vitefu";
+
+// src/utils/dependencies.ts
+import path3 from "path";
+import fs4 from "fs/promises";
+import { findDepPkgJsonPath } from "vitefu";
+async function resolveDependencyData(dep, parent) {
+  const depDataPath = await findDepPkgJsonPath(dep, parent);
+  if (!depDataPath)
+    return void 0;
+  try {
+    return {
+      dir: path3.dirname(depDataPath),
+      pkg: JSON.parse(await fs4.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",
@@ -1238,13 +1172,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
     }
   };
@@ -1272,11 +1207,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) {
@@ -1289,11 +1226,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;
       }
     }
   }
@@ -1331,16 +1270,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) {
@@ -1354,100 +1286,118 @@ function handleDeprecatedOptions(options) {
 function resolveViteRoot(viteConfig) {
   return normalizePath2(viteConfig.root ? path4.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) => !isDepExcluded(dep, extraSvelteConfig.optimizeDeps.exclude)
+      )
+    ],
+    exclude: [
+      ...extraSvelteConfig.optimizeDeps.exclude,
+      ...extraDepsConfig.optimizeDeps.exclude.filter(
+        (dep) => !isDepIncluded(dep, extraSvelteConfig.optimizeDeps.include)
+      )
+    ]
+  };
+  extraViteConfig.ssr = {
+    external: [
+      ...extraSvelteConfig.ssr.external,
+      ...extraDepsConfig.ssr.external.filter(
+        (dep) => !isDepNoExternaled(dep, extraSvelteConfig.ssr.noExternal)
+      )
+    ],
+    noExternal: [
+      ...extraSvelteConfig.ssr.noExternal,
+      ...extraDepsConfig.ssr.noExternal.filter(
+        (dep) => !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 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) => 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 (!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 = createRequire3(`${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 (!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(
@@ -1644,15 +1594,14 @@ function ensureWatchedFile(watcher, file, root) {
 
 // src/utils/resolve.ts
 import path6 from "path";
-import { builtinModules, createRequire as createRequire4 } from "module";
-function resolveViaPackageJsonSvelte(importee, importer, cache) {
-  if (importer && isBareImport(importee) && !isNodeInternal(importee) && !is_common_without_svelte_field(importee)) {
+import { builtinModules } from "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 = createRequire4(importer);
-    const pkgData = resolveDependencyData(importee, localRequire);
+    const pkgData = await resolveDependencyData(importee, importer);
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
@@ -1858,7 +1807,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;
       },
@@ -1930,19 +1879,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") && !isDepExcluded2(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) {