@sveltejs/vite-plugin-svelte 1.1.1 → 1.3.0

package/dist/index.js

@@ -7,7 +7,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import fs8 from "fs";
+import fs7 from "fs";
+import { isDepExcluded as isDepExcluded2 } from "vitefu";
 
 // src/utils/log.ts
 import { cyan, yellow, red } from "kleur/colors";
@@ -288,80 +289,105 @@ function toSafe(base64) {
 
 // src/utils/compile.ts
 var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
-var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequest, code, options) {
-  const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
-  const { emitCss = true } = options;
-  const dependencies = [];
-  const compileOptions = {
-    ...options.compilerOptions,
-    filename,
-    generate: ssr ? "ssr" : "dom",
-    format: "esm"
-  };
-  if (options.hot && options.emitCss) {
-    const hash = `s-${safeBase64Hash(normalizedFilename)}`;
-    log.debug(`setting cssHash ${hash} for ${normalizedFilename}`);
-    compileOptions.cssHash = () => hash;
-  }
-  if (ssr && compileOptions.enableSourcemap !== false) {
-    if (typeof compileOptions.enableSourcemap === "object") {
-      compileOptions.enableSourcemap.css = false;
-    } else {
-      compileOptions.enableSourcemap = { js: true, css: false };
+var _createCompileSvelte = (makeHot) => {
+  let stats;
+  return async function compileSvelte2(svelteRequest, code, options) {
+    const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
+    const { emitCss = true } = options;
+    const dependencies = [];
+    if (options.stats) {
+      if (options.isBuild) {
+        if (!stats) {
+          stats = options.stats.startCollection(`${ssr ? "ssr" : "dom"} compile`, {
+            logInProgress: () => false
+          });
+        }
+      } else {
+        if (ssr && !stats) {
+          stats = options.stats.startCollection("ssr compile");
+        }
+        if (!ssr && stats) {
+          stats.finish();
+          stats = void 0;
+        }
+      }
     }
-  }
-  let preprocessed;
-  if (options.preprocess) {
-    try {
-      preprocessed = await preprocess(code, options.preprocess, { filename });
-    } catch (e) {
-      e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
-      throw e;
+    const compileOptions = {
+      ...options.compilerOptions,
+      filename,
+      generate: ssr ? "ssr" : "dom",
+      format: "esm"
+    };
+    if (options.hot && options.emitCss) {
+      const hash = `s-${safeBase64Hash(normalizedFilename)}`;
+      log.debug(`setting cssHash ${hash} for ${normalizedFilename}`);
+      compileOptions.cssHash = () => hash;
     }
-    if (preprocessed.dependencies)
-      dependencies.push(...preprocessed.dependencies);
-    if (preprocessed.map)
-      compileOptions.sourcemap = preprocessed.map;
-  }
-  const finalCode = preprocessed ? preprocessed.code : code;
-  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)}`
-    );
-  }
-  const finalCompileOptions = dynamicCompileOptions ? {
-    ...compileOptions,
-    ...dynamicCompileOptions
-  } : compileOptions;
-  const compiled = compile(finalCode, finalCompileOptions);
-  if (emitCss && compiled.css.code) {
-    compiled.js.code += `
+    if (ssr && compileOptions.enableSourcemap !== false) {
+      if (typeof compileOptions.enableSourcemap === "object") {
+        compileOptions.enableSourcemap.css = false;
+      } else {
+        compileOptions.enableSourcemap = { js: true, css: false };
+      }
+    }
+    let preprocessed;
+    if (options.preprocess) {
+      try {
+        preprocessed = await preprocess(code, options.preprocess, { filename });
+      } catch (e) {
+        e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
+        throw e;
+      }
+      if (preprocessed.dependencies)
+        dependencies.push(...preprocessed.dependencies);
+      if (preprocessed.map)
+        compileOptions.sourcemap = preprocessed.map;
+    }
+    const finalCode = preprocessed ? preprocessed.code : code;
+    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)}`
+      );
+    }
+    const finalCompileOptions = dynamicCompileOptions ? {
+      ...compileOptions,
+      ...dynamicCompileOptions
+    } : compileOptions;
+    const endStat = stats?.start(filename);
+    const compiled = compile(finalCode, finalCompileOptions);
+    if (endStat) {
+      endStat();
+    }
+    const hasCss = compiled.css?.code?.trim().length > 0;
+    if (emitCss && hasCss) {
+      compiled.js.code += `
 import ${JSON.stringify(cssId)};
 `;
-  }
-  if (!ssr && makeHot) {
-    compiled.js.code = makeHot({
-      id: filename,
-      compiledCode: compiled.js.code,
-      hotOptions: options.hot,
+    }
+    if (!ssr && makeHot) {
+      compiled.js.code = makeHot({
+        id: filename,
+        compiledCode: compiled.js.code,
+        hotOptions: { ...options.hot, injectCss: options.hot?.injectCss === true && hasCss },
+        compiled,
+        originalCode: code,
+        compileOptions: finalCompileOptions
+      });
+    }
+    compiled.js.dependencies = dependencies;
+    return {
+      filename,
+      normalizedFilename,
+      lang: code.match(scriptLangRE)?.[1] || "js",
       compiled,
-      originalCode: code,
-      compileOptions: finalCompileOptions
-    });
-  }
-  compiled.js.dependencies = dependencies;
-  return {
-    filename,
-    normalizedFilename,
-    lang: code.match(scriptLangRE)?.[1] || "js",
-    compiled,
-    ssr,
-    dependencies
+      ssr,
+      dependencies
+    };
   };
 };
 function buildMakeHot(options) {
@@ -461,9 +487,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";
@@ -571,185 +595,13 @@ var SVELTE_HMR_IMPORTS = [
   "svelte-hmr/runtime/proxy-adapter-dom.js",
   "svelte-hmr"
 ];
+var SVELTE_EXPORT_CONDITIONS = ["svelte"];
 
 // 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 { readFileSync } from "fs";
 import { compile as compile2, preprocess as preprocess2 } from "svelte/compiler";
 
 // src/utils/error.ts
@@ -805,7 +657,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 {
@@ -815,22 +698,35 @@ function esbuildSveltePlugin(options) {
         return;
       const svelteExtensions = (options.extensions ?? [".svelte"]).map((ext) => ext.slice(1));
       const svelteFilter = new RegExp(`\\.(` + svelteExtensions.join("|") + `)(\\?.*)?$`);
+      let statsCollection;
+      build.onStart(() => {
+        statsCollection = options.stats?.startCollection("prebundle libraries", {
+          logResult: (c) => c.stats.length > 1
+        });
+      });
       build.onLoad({ filter: svelteFilter }, async ({ path: filename }) => {
-        const code = await fs4.readFile(filename, "utf8");
+        const code = readFileSync(filename, "utf8");
         try {
-          const contents = await compileSvelte(options, { filename, code });
+          const contents = await compileSvelte(options, { filename, code }, statsCollection);
           return { contents };
         } catch (e) {
           return { errors: [toESBuildError(e, options)] };
         }
       });
+      build.onEnd(() => {
+        statsCollection?.finish();
+      });
     }
   };
 }
-async function compileSvelte(options, { filename, code }) {
+async function compileSvelte(options, { filename, code }, statsCollection) {
+  let css = options.compilerOptions.css;
+  if (css !== "none") {
+    css = isCssString ? "injected" : true;
+  }
   const compileOptions = {
     ...options.compilerOptions,
-    css: true,
+    css,
     filename,
     format: "esm",
     generate: "dom"
@@ -859,7 +755,11 @@ async function compileSvelte(options, { filename, code }) {
     ...compileOptions,
     ...dynamicCompileOptions
   } : compileOptions;
+  const endStat = statsCollection?.start(filename);
   const compiled = compile2(finalCode, finalCompileOptions);
+  if (endStat) {
+    endStat();
+  }
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
@@ -917,7 +817,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 +850,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 +897,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 +1021,231 @@ 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 fs3 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 fs3.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/vite-plugin-svelte-stats.ts
+import { findClosestPkgJsonPath } from "vitefu";
+import { readFileSync as readFileSync2 } from "fs";
+import { performance } from "perf_hooks";
+var defaultCollectionOptions = {
+  logInProgress: (c, now) => now - c.collectionStart > 500 && c.stats.length > 1,
+  logResult: () => true
+};
+function humanDuration(n) {
+  return n < 100 ? `${n.toFixed(1)}ms` : `${(n / 1e3).toFixed(2)}s`;
+}
+function formatPackageStats(pkgStats) {
+  const statLines = pkgStats.map((pkgStat) => {
+    const duration = pkgStat.duration;
+    const avg = duration / pkgStat.files;
+    return [pkgStat.pkg, `${pkgStat.files}`, humanDuration(duration), humanDuration(avg)];
+  });
+  statLines.unshift(["package", "files", "time", "avg"]);
+  const columnWidths = statLines.reduce(
+    (widths, row) => {
+      for (let i = 0; i < row.length; i++) {
+        const cell = row[i];
+        if (widths[i] < cell.length) {
+          widths[i] = cell.length;
+        }
+      }
+      return widths;
+    },
+    statLines[0].map(() => 0)
+  );
+  const table = statLines.map(
+    (row) => row.map((cell, i) => {
+      if (i === 0) {
+        return cell.padEnd(columnWidths[i], " ");
+      } else {
+        return cell.padStart(columnWidths[i], " ");
+      }
+    }).join("	")
+  ).join("\n");
+  return table;
+}
+var VitePluginSvelteStats = class {
+  constructor() {
+    this._packages = [];
+    this._collections = [];
+  }
+  startCollection(name, opts) {
+    const options = {
+      ...defaultCollectionOptions,
+      ...opts
+    };
+    const stats = [];
+    const collectionStart = performance.now();
+    const _this = this;
+    let hasLoggedProgress = false;
+    const collection = {
+      name,
+      options,
+      stats,
+      collectionStart,
+      finished: false,
+      start(file) {
+        if (collection.finished) {
+          throw new Error("called after finish() has been used");
+        }
+        const start = performance.now();
+        const stat = { file, start, end: start };
+        return () => {
+          const now = performance.now();
+          stat.end = now;
+          stats.push(stat);
+          if (!hasLoggedProgress && options.logInProgress(collection, now)) {
+            hasLoggedProgress = true;
+            log.info(`${name} in progress ...`);
+          }
+        };
+      },
+      async finish() {
+        await _this._finish(collection);
+      }
+    };
+    _this._collections.push(collection);
+    return collection;
+  }
+  async finishAll() {
+    await Promise.all(this._collections.map((c) => c.finish()));
+  }
+  async _finish(collection) {
+    collection.finished = true;
+    const now = performance.now();
+    collection.duration = now - collection.collectionStart;
+    const logResult = collection.options.logResult(collection);
+    if (logResult) {
+      await this._aggregateStatsResult(collection);
+      log.info(`${collection.name} done.`, formatPackageStats(collection.packageStats));
+    }
+    const index = this._collections.indexOf(collection);
+    this._collections.splice(index, 1);
+    collection.stats.length = 0;
+    collection.stats = [];
+    if (collection.packageStats) {
+      collection.packageStats.length = 0;
+      collection.packageStats = [];
+    }
+    collection.start = () => () => {
+    };
+    collection.finish = () => {
+    };
+  }
+  async _aggregateStatsResult(collection) {
+    const stats = collection.stats;
+    for (const stat of stats) {
+      let pkg = this._packages.find((p) => stat.file.startsWith(p.path));
+      if (!pkg) {
+        let pkgPath = await findClosestPkgJsonPath(stat.file);
+        if (pkgPath) {
+          let path9 = pkgPath?.replace(/package.json$/, "");
+          let name = JSON.parse(readFileSync2(pkgPath, "utf-8")).name;
+          if (!name) {
+            pkgPath = await findClosestPkgJsonPath(path9);
+            if (pkgPath) {
+              path9 = pkgPath?.replace(/package.json$/, "");
+              name = JSON.parse(readFileSync2(pkgPath, "utf-8")).name;
+            }
+          }
+          if (path9 && name) {
+            pkg = { path: path9, name };
+            this._packages.push(pkg);
+          }
+        }
+      }
+      stat.pkg = pkg?.name ?? "$unknown";
+    }
+    const grouped = {};
+    stats.forEach((stat) => {
+      const pkg = stat.pkg;
+      let group = grouped[pkg];
+      if (!group) {
+        group = grouped[pkg] = {
+          files: 0,
+          duration: 0,
+          pkg
+        };
+      }
+      group.files += 1;
+      group.duration += stat.end - stat.start;
+    });
+    const groups = Object.values(grouped);
+    groups.sort((a, b) => b.duration - a.duration);
+    collection.packageStats = groups;
+  }
+};
+
+// src/utils/options.ts
+var cssAsString = atLeastSvelte("3.53.0");
 var allowedPluginOptions = /* @__PURE__ */ new Set([
   "include",
   "exclude",
@@ -1204,16 +1329,18 @@ async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
     ...viteUserConfig,
     root: resolveViteRoot(viteUserConfig)
   };
+  const isBuild = viteEnv.command === "build";
   const defaultOptions = {
     extensions: [".svelte"],
-    emitCss: true
+    emitCss: true,
+    prebundleSvelteLibraries: !isBuild
   };
   const svelteConfig = convertPluginOptions(
     await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions)
   );
   const extraOptions = {
     root: viteConfigWithResolvedRoot.root,
-    isBuild: viteEnv.command === "build",
+    isBuild,
     isServe: viteEnv.command === "serve",
     isDebug: process.env.DEBUG != null
   };
@@ -1238,13 +1365,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
     }
   };
@@ -1259,6 +1387,12 @@ function resolveOptions(preResolveOptions2, viteConfig) {
   addExtraPreprocessors(merged, viteConfig);
   enforceOptionsForHmr(merged);
   enforceOptionsForProduction(merged);
+  const isLogLevelInfo = [void 0, "info"].includes(viteConfig.logLevel);
+  const disableCompileStats = merged.experimental?.disableCompileStats;
+  const statsEnabled = disableCompileStats !== true && disableCompileStats !== (merged.isBuild ? "build" : "dev");
+  if (statsEnabled && isLogLevelInfo) {
+    merged.stats = new VitePluginSvelteStats();
+  }
   return merged;
 }
 function enforceOptionsForHmr(options) {
@@ -1272,11 +1406,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 +1425,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 +1469,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,19 +1485,44 @@ 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]
+      dedupe: [...SVELTE_IMPORTS, ...SVELTE_HMR_IMPORTS],
+      conditions: [...SVELTE_EXPORT_CONDITIONS]
     }
   };
-  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,
@@ -1377,77 +1533,111 @@ function buildExtraViteConfig(options, config) {
       }
     };
   }
-  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 };
   }
+  validateViteConfig(extraViteConfig, config, options);
   return extraViteConfig;
 }
-function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
+function validateViteConfig(extraViteConfig, config, options) {
+  const { prebundleSvelteLibraries, isBuild } = options;
+  if (prebundleSvelteLibraries) {
+    const isEnabled = (option) => option !== true && option !== (isBuild ? "build" : "dev");
+    const logWarning = (name, value, recommendation) => log.warn.once(
+      `Incompatible options: \`prebundleSvelteLibraries: true\` and vite \`${name}: ${JSON.stringify(
+        value
+      )}\` ${isBuild ? "during build." : "."} ${recommendation}`
+    );
+    const viteOptimizeDepsDisabled = config.optimizeDeps?.disabled ?? "build";
+    const isOptimizeDepsEnabled = isEnabled(viteOptimizeDepsDisabled);
+    if (!isBuild && !isOptimizeDepsEnabled) {
+      logWarning(
+        "optimizeDeps.disabled",
+        viteOptimizeDepsDisabled,
+        'Forcing `optimizeDeps.disabled: "build"`. Disable prebundleSvelteLibraries or update your vite config to enable optimizeDeps during dev.'
+      );
+      extraViteConfig.optimizeDeps.disabled = "build";
+    } else if (isBuild && isOptimizeDepsEnabled) {
+      logWarning(
+        "optimizeDeps.disabled",
+        viteOptimizeDepsDisabled,
+        "Disable optimizeDeps or prebundleSvelteLibraries for build if you experience errors."
+      );
+    }
+  }
+}
+async function buildExtraConfigForDependencies(options, config) {
+  const depsConfig = await crawlFrameworkPkgs({
+    root: options.root,
+    isBuild: options.isBuild,
+    viteUserConfig: config,
+    isFrameworkPkgByJson(pkgJson) {
+      let hasSvelteCondition = false;
+      if (typeof pkgJson.exports === "object") {
+        JSON.stringify(pkgJson.exports, (key, value) => {
+          if (SVELTE_EXPORT_CONDITIONS.includes(key)) {
+            hasSvelteCondition = true;
+          }
+          return value;
+        });
+      }
+      return hasSvelteCondition || !!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(
@@ -1458,113 +1648,8 @@ function patchResolvedViteConfig(viteConfig, options) {
   }
 }
 
-// src/utils/vite-plugin-svelte-cache.ts
-var VitePluginSvelteCache = class {
-  constructor() {
-    this._css = /* @__PURE__ */ new Map();
-    this._js = /* @__PURE__ */ new Map();
-    this._dependencies = /* @__PURE__ */ new Map();
-    this._dependants = /* @__PURE__ */ new Map();
-    this._resolvedSvelteFields = /* @__PURE__ */ new Map();
-    this._errors = /* @__PURE__ */ new Map();
-  }
-  update(compileData) {
-    this._errors.delete(compileData.normalizedFilename);
-    this.updateCSS(compileData);
-    this.updateJS(compileData);
-    this.updateDependencies(compileData);
-  }
-  has(svelteRequest) {
-    const id = svelteRequest.normalizedFilename;
-    return this._errors.has(id) || this._js.has(id) || this._css.has(id);
-  }
-  setError(svelteRequest, error) {
-    this.remove(svelteRequest, true);
-    this._errors.set(svelteRequest.normalizedFilename, error);
-  }
-  updateCSS(compileData) {
-    this._css.set(compileData.normalizedFilename, compileData.compiled.css);
-  }
-  updateJS(compileData) {
-    if (!compileData.ssr) {
-      this._js.set(compileData.normalizedFilename, compileData.compiled.js);
-    }
-  }
-  updateDependencies(compileData) {
-    const id = compileData.normalizedFilename;
-    const prevDependencies = this._dependencies.get(id) || [];
-    const dependencies = compileData.dependencies;
-    this._dependencies.set(id, dependencies);
-    const removed = prevDependencies.filter((d) => !dependencies.includes(d));
-    const added = dependencies.filter((d) => !prevDependencies.includes(d));
-    added.forEach((d) => {
-      if (!this._dependants.has(d)) {
-        this._dependants.set(d, /* @__PURE__ */ new Set());
-      }
-      this._dependants.get(d).add(compileData.filename);
-    });
-    removed.forEach((d) => {
-      this._dependants.get(d).delete(compileData.filename);
-    });
-  }
-  remove(svelteRequest, keepDependencies = false) {
-    const id = svelteRequest.normalizedFilename;
-    let removed = false;
-    if (this._errors.delete(id)) {
-      removed = true;
-    }
-    if (this._js.delete(id)) {
-      removed = true;
-    }
-    if (this._css.delete(id)) {
-      removed = true;
-    }
-    if (!keepDependencies) {
-      const dependencies = this._dependencies.get(id);
-      if (dependencies) {
-        removed = true;
-        dependencies.forEach((d) => {
-          const dependants = this._dependants.get(d);
-          if (dependants && dependants.has(svelteRequest.filename)) {
-            dependants.delete(svelteRequest.filename);
-          }
-        });
-        this._dependencies.delete(id);
-      }
-    }
-    return removed;
-  }
-  getCSS(svelteRequest) {
-    return this._css.get(svelteRequest.normalizedFilename);
-  }
-  getJS(svelteRequest) {
-    if (!svelteRequest.ssr) {
-      return this._js.get(svelteRequest.normalizedFilename);
-    }
-  }
-  getError(svelteRequest) {
-    return this._errors.get(svelteRequest.normalizedFilename);
-  }
-  getDependants(path9) {
-    const dependants = this._dependants.get(path9);
-    return dependants ? [...dependants] : [];
-  }
-  getResolvedSvelteField(name, importer) {
-    return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
-  }
-  setResolvedSvelteField(importee, importer = void 0, resolvedSvelte) {
-    this._resolvedSvelteFields.set(
-      this._getResolvedSvelteFieldKey(importee, importer),
-      resolvedSvelte
-    );
-  }
-  _getResolvedSvelteFieldKey(importee, importer) {
-    return importer ? `${importer} > ${importee}` : importee;
-  }
-};
-
 // src/utils/watch.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import path5 from "path";
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
@@ -1576,7 +1661,7 @@ function setupWatchers(options, cache, requestParser) {
   const emitChangeEventOnDependants = (filename) => {
     const dependants = cache.getDependants(filename);
     dependants.forEach((dependant) => {
-      if (fs5.existsSync(dependant)) {
+      if (fs4.existsSync(dependant)) {
         log.debug(
           `emitting virtual change event for "${dependant}" because depdendency "${filename}" changed`
         );
@@ -1637,22 +1722,21 @@ function setupWatchers(options, cache, requestParser) {
   });
 }
 function ensureWatchedFile(watcher, file, root) {
-  if (file && !file.startsWith(root + "/") && !file.includes("\0") && fs5.existsSync(file)) {
+  if (file && !file.startsWith(root + "/") && !file.includes("\0") && fs4.existsSync(file)) {
     watcher.add(path5.resolve(file));
   }
 }
 
 // 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) {
@@ -1682,7 +1766,7 @@ function isBareImport(importee) {
 }
 
 // src/utils/optimizer.ts
-import { promises as fs6 } from "fs";
+import { promises as fs5 } from "fs";
 import path7 from "path";
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
@@ -1700,11 +1784,11 @@ async function saveSvelteMetadata(cacheDir, options) {
   });
   let existingSvelteMetadata;
   try {
-    existingSvelteMetadata = await fs6.readFile(svelteMetadataPath, "utf8");
+    existingSvelteMetadata = await fs5.readFile(svelteMetadataPath, "utf8");
   } catch {
   }
-  await fs6.mkdir(cacheDir, { recursive: true });
-  await fs6.writeFile(svelteMetadataPath, currentSvelteMetadata);
+  await fs5.mkdir(cacheDir, { recursive: true });
+  await fs5.writeFile(svelteMetadataPath, currentSvelteMetadata);
   return currentSvelteMetadata !== existingSvelteMetadata;
 }
 function generateSvelteMetadata(options) {
@@ -1719,7 +1803,7 @@ function generateSvelteMetadata(options) {
 import { normalizePath as normalizePath3 } from "vite";
 import path8 from "path";
 import { fileURLToPath } from "url";
-import fs7 from "fs";
+import fs6 from "fs";
 
 // src/ui/inspector/utils.ts
 var FS_PREFIX = `/@fs/`;
@@ -1796,8 +1880,8 @@ function svelteInspector() {
         return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
       } else if (id.startsWith(inspectorPath)) {
         const file = idToFile(id);
-        if (fs7.existsSync(file)) {
-          return await fs7.promises.readFile(file, "utf-8");
+        if (fs6.existsSync(file)) {
+          return await fs6.promises.readFile(file, "utf-8");
         } else {
           log.error(`failed to find file for svelte-inspector: ${file}, referenced by id ${id}.`);
         }
@@ -1833,6 +1917,111 @@ import 'virtual:svelte-inspector-path:load-inspector.js'` };
   };
 }
 
+// src/utils/vite-plugin-svelte-cache.ts
+var VitePluginSvelteCache = class {
+  constructor() {
+    this._css = /* @__PURE__ */ new Map();
+    this._js = /* @__PURE__ */ new Map();
+    this._dependencies = /* @__PURE__ */ new Map();
+    this._dependants = /* @__PURE__ */ new Map();
+    this._resolvedSvelteFields = /* @__PURE__ */ new Map();
+    this._errors = /* @__PURE__ */ new Map();
+  }
+  update(compileData) {
+    this._errors.delete(compileData.normalizedFilename);
+    this.updateCSS(compileData);
+    this.updateJS(compileData);
+    this.updateDependencies(compileData);
+  }
+  has(svelteRequest) {
+    const id = svelteRequest.normalizedFilename;
+    return this._errors.has(id) || this._js.has(id) || this._css.has(id);
+  }
+  setError(svelteRequest, error) {
+    this.remove(svelteRequest, true);
+    this._errors.set(svelteRequest.normalizedFilename, error);
+  }
+  updateCSS(compileData) {
+    this._css.set(compileData.normalizedFilename, compileData.compiled.css);
+  }
+  updateJS(compileData) {
+    if (!compileData.ssr) {
+      this._js.set(compileData.normalizedFilename, compileData.compiled.js);
+    }
+  }
+  updateDependencies(compileData) {
+    const id = compileData.normalizedFilename;
+    const prevDependencies = this._dependencies.get(id) || [];
+    const dependencies = compileData.dependencies;
+    this._dependencies.set(id, dependencies);
+    const removed = prevDependencies.filter((d) => !dependencies.includes(d));
+    const added = dependencies.filter((d) => !prevDependencies.includes(d));
+    added.forEach((d) => {
+      if (!this._dependants.has(d)) {
+        this._dependants.set(d, /* @__PURE__ */ new Set());
+      }
+      this._dependants.get(d).add(compileData.filename);
+    });
+    removed.forEach((d) => {
+      this._dependants.get(d).delete(compileData.filename);
+    });
+  }
+  remove(svelteRequest, keepDependencies = false) {
+    const id = svelteRequest.normalizedFilename;
+    let removed = false;
+    if (this._errors.delete(id)) {
+      removed = true;
+    }
+    if (this._js.delete(id)) {
+      removed = true;
+    }
+    if (this._css.delete(id)) {
+      removed = true;
+    }
+    if (!keepDependencies) {
+      const dependencies = this._dependencies.get(id);
+      if (dependencies) {
+        removed = true;
+        dependencies.forEach((d) => {
+          const dependants = this._dependants.get(d);
+          if (dependants && dependants.has(svelteRequest.filename)) {
+            dependants.delete(svelteRequest.filename);
+          }
+        });
+        this._dependencies.delete(id);
+      }
+    }
+    return removed;
+  }
+  getCSS(svelteRequest) {
+    return this._css.get(svelteRequest.normalizedFilename);
+  }
+  getJS(svelteRequest) {
+    if (!svelteRequest.ssr) {
+      return this._js.get(svelteRequest.normalizedFilename);
+    }
+  }
+  getError(svelteRequest) {
+    return this._errors.get(svelteRequest.normalizedFilename);
+  }
+  getDependants(path9) {
+    const dependants = this._dependants.get(path9);
+    return dependants ? [...dependants] : [];
+  }
+  getResolvedSvelteField(name, importer) {
+    return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
+  }
+  setResolvedSvelteField(importee, importer = void 0, resolvedSvelte) {
+    this._resolvedSvelteFields.set(
+      this._getResolvedSvelteFieldKey(importee, importer),
+      resolvedSvelte
+    );
+  }
+  _getResolvedSvelteFieldKey(importee, importer) {
+    return importer ? `${importer} > ${importee}` : importee;
+  }
+};
+
 // src/index.ts
 function svelte(inlineOptions) {
   if (process.env.DEBUG != null) {
@@ -1858,7 +2047,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;
       },
@@ -1897,7 +2086,7 @@ function svelte(inlineOptions) {
           }
           if (viteConfig.assetsInclude(filename)) {
             log.debug(`load returns raw content for ${filename}`);
-            return fs8.readFileSync(filename, "utf-8");
+            return fs7.readFileSync(filename, "utf-8");
           }
         }
       },
@@ -1930,19 +2119,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) {
@@ -1987,6 +2180,9 @@ function svelte(inlineOptions) {
             throw toRollupError(e, options);
           }
         }
+      },
+      async buildEnd() {
+        await options.stats?.finishAll();
       }
     }
   ];