@sveltejs/vite-plugin-svelte 1.2.0 → 1.3.1

package/dist/index.cjs

@@ -36,8 +36,8 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL("file:" +
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/index.ts
-var import_fs6 = __toESM(require("fs"), 1);
-var import_vitefu3 = require("vitefu");
+var import_fs7 = __toESM(require("fs"), 1);
+var import_vitefu4 = require("vitefu");
 
 // src/utils/log.ts
 var import_colors = require("kleur/colors");
@@ -318,81 +318,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 (0, import_compiler.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 = (0, import_compiler.compile)(finalCode, finalCompileOptions);
-  const hasCss = compiled.css?.code?.trim().length > 0;
-  if (emitCss && hasCss) {
-    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 (0, import_compiler.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 = (0, import_compiler.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, injectCss: options.hot?.injectCss === true && hasCss },
+    }
+    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) {
@@ -492,7 +516,7 @@ function buildIdParser(options) {
 }
 
 // src/utils/options.ts
-var import_vite3 = require("vite");
+var import_vite4 = require("vite");
 
 // src/utils/load-svelte-config.ts
 var import_module = require("module");
@@ -600,9 +624,10 @@ var SVELTE_HMR_IMPORTS = [
   "svelte-hmr/runtime/proxy-adapter-dom.js",
   "svelte-hmr"
 ];
+var SVELTE_EXPORT_CONDITIONS = ["svelte"];
 
 // src/utils/options.ts
-var import_path4 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 
 // src/utils/esbuild.ts
 var import_fs2 = require("fs");
@@ -702,19 +727,28 @@ 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 import_fs2.promises.readFile(filename, "utf8");
+        const code = (0, import_fs2.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;
@@ -750,7 +784,11 @@ async function compileSvelte(options, { filename, code }) {
     ...compileOptions,
     ...dynamicCompileOptions
   } : compileOptions;
+  const endStat = statsCollection?.start(filename);
   const compiled = (0, import_compiler3.compile)(finalCode, finalCompileOptions);
+  if (endStat) {
+    endStat();
+  }
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
@@ -1012,7 +1050,7 @@ function validateSourceMapOutputWrapper(group, i) {
 
 // src/utils/options.ts
 var import_deepmerge = __toESM(require("deepmerge"), 1);
-var import_vitefu2 = require("vitefu");
+var import_vitefu3 = require("vitefu");
 
 // src/utils/dependencies.ts
 var import_path3 = __toESM(require("path"), 1);
@@ -1076,6 +1114,165 @@ function isCommonDepWithoutSvelteField(dependency) {
   );
 }
 
+// src/utils/vite-plugin-svelte-stats.ts
+var import_vitefu2 = require("vitefu");
+var import_fs3 = require("fs");
+var import_path4 = require("path");
+var import_perf_hooks = require("perf_hooks");
+var import_vite3 = require("vite");
+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;
+}
+async function getClosestNamedPackage(file) {
+  let name = "$unknown";
+  let path9 = await (0, import_vitefu2.findClosestPkgJsonPath)(file, (pkgPath) => {
+    const pkg = JSON.parse((0, import_fs3.readFileSync)(pkgPath, "utf-8"));
+    if (pkg.name != null) {
+      name = pkg.name;
+      return true;
+    }
+    return false;
+  });
+  path9 = (0, import_vite3.normalizePath)((0, import_path4.dirname)(path9 ?? file)) + "/";
+  return { name, path: path9 };
+}
+var VitePluginSvelteStats = class {
+  constructor() {
+    this._packages = [];
+    this._collections = [];
+  }
+  startCollection(name, opts) {
+    const options = {
+      ...defaultCollectionOptions,
+      ...opts
+    };
+    const stats = [];
+    const collectionStart = import_perf_hooks.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");
+        }
+        file = (0, import_vite3.normalizePath)(file);
+        const start = import_perf_hooks.performance.now();
+        const stat = { file, start, end: start };
+        return () => {
+          const now = import_perf_hooks.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) {
+    try {
+      collection.finished = true;
+      const now = import_perf_hooks.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 = () => {
+      };
+    } catch (e) {
+      log.debug.once(`failed to finish stats for ${collection.name}`, e);
+    }
+  }
+  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) {
+        pkg = await getClosestNamedPackage(stat.file);
+        this._packages.push(pkg);
+      }
+      stat.pkg = pkg.name;
+    }
+    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([
@@ -1161,16 +1358,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
   };
@@ -1217,6 +1416,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) {
@@ -1307,13 +1512,14 @@ function handleDeprecatedOptions(options) {
   }
 }
 function resolveViteRoot(viteConfig) {
-  return (0, import_vite3.normalizePath)(viteConfig.root ? import_path4.default.resolve(viteConfig.root) : process.cwd());
+  return (0, import_vite4.normalizePath)(viteConfig.root ? import_path5.default.resolve(viteConfig.root) : process.cwd());
 }
 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]
     }
   };
   const extraSvelteConfig = buildExtraConfigForSvelte(config);
@@ -1322,13 +1528,13 @@ async function buildExtraViteConfig(options, config) {
     include: [
       ...extraSvelteConfig.optimizeDeps.include,
       ...extraDepsConfig.optimizeDeps.include.filter(
-        (dep) => !(0, import_vitefu2.isDepExcluded)(dep, extraSvelteConfig.optimizeDeps.exclude)
+        (dep) => !(0, import_vitefu3.isDepExcluded)(dep, extraSvelteConfig.optimizeDeps.exclude)
       )
     ],
     exclude: [
       ...extraSvelteConfig.optimizeDeps.exclude,
       ...extraDepsConfig.optimizeDeps.exclude.filter(
-        (dep) => !(0, import_vitefu2.isDepIncluded)(dep, extraSvelteConfig.optimizeDeps.include)
+        (dep) => !(0, import_vitefu3.isDepIncluded)(dep, extraSvelteConfig.optimizeDeps.include)
       )
     ]
   };
@@ -1336,36 +1542,76 @@ async function buildExtraViteConfig(options, config) {
     external: [
       ...extraSvelteConfig.ssr.external,
       ...extraDepsConfig.ssr.external.filter(
-        (dep) => !(0, import_vitefu2.isDepNoExternaled)(dep, extraSvelteConfig.ssr.noExternal)
+        (dep) => !(0, import_vitefu3.isDepNoExternaled)(dep, extraSvelteConfig.ssr.noExternal)
       )
     ],
     noExternal: [
       ...extraSvelteConfig.ssr.noExternal,
       ...extraDepsConfig.ssr.noExternal.filter(
-        (dep) => !(0, import_vitefu2.isDepExternaled)(dep, extraSvelteConfig.ssr.external)
+        (dep) => !(0, import_vitefu3.isDepExternaled)(dep, extraSvelteConfig.ssr.external)
       )
     ]
   };
   if (options.prebundleSvelteLibraries) {
-    extraViteConfig.optimizeDeps.extensions = options.extensions ?? [".svelte"];
-    extraViteConfig.optimizeDeps.esbuildOptions = {
-      plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
-      } }]
+    extraViteConfig.optimizeDeps = {
+      ...extraViteConfig.optimizeDeps,
+      extensions: options.extensions ?? [".svelte"],
+      esbuildOptions: {
+        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
+        } }]
+      }
     };
   }
   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 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 (0, import_vitefu2.crawlFrameworkPkgs)({
+  const depsConfig = await (0, import_vitefu3.crawlFrameworkPkgs)({
     root: options.root,
     isBuild: options.isBuild,
     viteUserConfig: config,
     isFrameworkPkgByJson(pkgJson) {
-      return !!pkgJson.svelte;
+      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;
@@ -1384,7 +1630,7 @@ async function buildExtraConfigForDependencies(options, config) {
     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));
+      return dep.includes(">") && dep.split(">").slice(0, -1).some((d) => (0, import_vitefu3.isDepExcluded)(d.trim(), userExclude));
     });
   }
   if (options.disableDependencyReinclusion === true) {
@@ -1406,7 +1652,7 @@ async function buildExtraConfigForDependencies(options, config) {
 function buildExtraConfigForSvelte(config) {
   const include = [];
   const exclude = ["svelte-hmr"];
-  if (!(0, import_vitefu2.isDepExcluded)("svelte", config.optimizeDeps?.exclude ?? [])) {
+  if (!(0, import_vitefu3.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(", ")} `
@@ -1417,7 +1663,7 @@ function buildExtraConfigForSvelte(config) {
   }
   const noExternal = [];
   const external = [];
-  if (!(0, import_vitefu2.isDepExternaled)("svelte", config.ssr?.external ?? [])) {
+  if (!(0, import_vitefu3.isDepExternaled)("svelte", config.ssr?.external ?? [])) {
     noExternal.push("svelte", /^svelte\//);
   }
   return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
@@ -1431,114 +1677,9 @@ 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
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path5 = __toESM(require("path"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
   if (!server) {
@@ -1549,7 +1690,7 @@ function setupWatchers(options, cache, requestParser) {
   const emitChangeEventOnDependants = (filename) => {
     const dependants = cache.getDependants(filename);
     dependants.forEach((dependant) => {
-      if (import_fs3.default.existsSync(dependant)) {
+      if (import_fs4.default.existsSync(dependant)) {
         log.debug(
           `emitting virtual change event for "${dependant}" because depdendency "${filename}" changed`
         );
@@ -1585,7 +1726,7 @@ function setupWatchers(options, cache, requestParser) {
     unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
   };
   if (svelteConfigFile !== false) {
-    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path5.default.join(root, cfg));
+    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path6.default.join(root, cfg));
     const restartOnConfigAdd = (filename) => {
       if (possibleSvelteConfigs.includes(filename)) {
         triggerViteRestart(filename);
@@ -1610,13 +1751,13 @@ function setupWatchers(options, cache, requestParser) {
   });
 }
 function ensureWatchedFile(watcher, file, root) {
-  if (file && !file.startsWith(root + "/") && !file.includes("\0") && import_fs3.default.existsSync(file)) {
-    watcher.add(import_path5.default.resolve(file));
+  if (file && !file.startsWith(root + "/") && !file.includes("\0") && import_fs4.default.existsSync(file)) {
+    watcher.add(import_path6.default.resolve(file));
   }
 }
 
 // src/utils/resolve.ts
-var import_path6 = __toESM(require("path"), 1);
+var import_path7 = __toESM(require("path"), 1);
 var import_module2 = require("module");
 async function resolveViaPackageJsonSvelte(importee, importer, cache) {
   if (importer && isBareImport(importee) && !isNodeInternal(importee) && !isCommonDepWithoutSvelteField(importee)) {
@@ -1628,7 +1769,7 @@ async function resolveViaPackageJsonSvelte(importee, importer, cache) {
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
-        const result = import_path6.default.resolve(dir, pkg.svelte);
+        const result = import_path7.default.resolve(dir, pkg.svelte);
         cache.setResolvedSvelteField(importee, importer, result);
         return result;
       }
@@ -1639,7 +1780,7 @@ function isNodeInternal(importee) {
   return importee.startsWith("node:") || import_module2.builtinModules.includes(importee);
 }
 function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path6.default.isAbsolute(importee)) {
+  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path7.default.isAbsolute(importee)) {
     return false;
   }
   const parts = importee.split("/");
@@ -1654,8 +1795,8 @@ function isBareImport(importee) {
 }
 
 // src/utils/optimizer.ts
-var import_fs4 = require("fs");
-var import_path7 = __toESM(require("path"), 1);
+var import_fs5 = require("fs");
+var import_path8 = __toESM(require("path"), 1);
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
   "configFile",
@@ -1666,17 +1807,17 @@ var PREBUNDLE_SENSITIVE_OPTIONS = [
 ];
 async function saveSvelteMetadata(cacheDir, options) {
   const svelteMetadata = generateSvelteMetadata(options);
-  const svelteMetadataPath = import_path7.default.resolve(cacheDir, "_svelte_metadata.json");
+  const svelteMetadataPath = import_path8.default.resolve(cacheDir, "_svelte_metadata.json");
   const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
     return typeof value === "function" ? value.toString() : value;
   });
   let existingSvelteMetadata;
   try {
-    existingSvelteMetadata = await import_fs4.promises.readFile(svelteMetadataPath, "utf8");
+    existingSvelteMetadata = await import_fs5.promises.readFile(svelteMetadataPath, "utf8");
   } catch {
   }
-  await import_fs4.promises.mkdir(cacheDir, { recursive: true });
-  await import_fs4.promises.writeFile(svelteMetadataPath, currentSvelteMetadata);
+  await import_fs5.promises.mkdir(cacheDir, { recursive: true });
+  await import_fs5.promises.writeFile(svelteMetadataPath, currentSvelteMetadata);
   return currentSvelteMetadata !== existingSvelteMetadata;
 }
 function generateSvelteMetadata(options) {
@@ -1688,10 +1829,10 @@ function generateSvelteMetadata(options) {
 }
 
 // src/ui/inspector/plugin.ts
-var import_vite4 = require("vite");
-var import_path8 = __toESM(require("path"), 1);
+var import_vite5 = require("vite");
+var import_path9 = __toESM(require("path"), 1);
 var import_url2 = require("url");
-var import_fs5 = __toESM(require("fs"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
 
 // src/ui/inspector/utils.ts
 var FS_PREFIX = `/@fs/`;
@@ -1716,7 +1857,7 @@ var defaultInspectorOptions = {
   customStyles: true
 };
 function getInspectorPath() {
-  const pluginPath = (0, import_vite4.normalizePath)(import_path8.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl)));
+  const pluginPath = (0, import_vite5.normalizePath)(import_path9.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl)));
   return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
 }
 function svelteInspector() {
@@ -1742,7 +1883,7 @@ function svelteInspector() {
         disabled = true;
       } else {
         if (vps.api.options.kit && !inspectorOptions.appendTo) {
-          const out_dir = import_path8.default.basename(vps.api.options.kit.outDir || ".svelte-kit");
+          const out_dir = import_path9.default.basename(vps.api.options.kit.outDir || ".svelte-kit");
           inspectorOptions.appendTo = `${out_dir}/generated/root.svelte`;
         }
         appendTo = inspectorOptions.appendTo;
@@ -1768,8 +1909,8 @@ function svelteInspector() {
         return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
       } else if (id.startsWith(inspectorPath)) {
         const file = idToFile(id);
-        if (import_fs5.default.existsSync(file)) {
-          return await import_fs5.default.promises.readFile(file, "utf-8");
+        if (import_fs6.default.existsSync(file)) {
+          return await import_fs6.default.promises.readFile(file, "utf-8");
         } else {
           log.error(`failed to find file for svelte-inspector: ${file}, referenced by id ${id}.`);
         }
@@ -1805,6 +1946,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) {
@@ -1869,7 +2115,7 @@ function svelte(inlineOptions) {
           }
           if (viteConfig.assetsInclude(filename)) {
             log.debug(`load returns raw content for ${filename}`);
-            return import_fs6.default.readFileSync(filename, "utf-8");
+            return import_fs7.default.readFileSync(filename, "utf-8");
           }
         }
       },
@@ -1903,7 +2149,7 @@ function svelte(inlineOptions) {
           return resolvedSvelteSSR;
         }
         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 ?? []);
+        const isPrebundled = options.prebundleSvelteLibraries && viteConfig.optimizeDeps?.disabled !== true && viteConfig.optimizeDeps?.disabled !== (options.isBuild ? "build" : "dev") && !(0, import_vitefu4.isDepExcluded)(importee, viteConfig.optimizeDeps?.exclude ?? []);
         if (ssr || scan || !isPrebundled) {
           try {
             const resolved = await resolveViaPackageJsonSvelte(importee, importer, cache);
@@ -1963,6 +2209,9 @@ function svelte(inlineOptions) {
             throw toRollupError(e, options);
           }
         }
+      },
+      async buildEnd() {
+        await options.stats?.finishAll();
       }
     }
   ];