@sveltejs/vite-plugin-svelte 1.0.0-next.40 → 1.0.0-next.43

package/dist/index.cjs

@@ -21,35 +21,29 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
+  return to;
 };
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   svelte: () => svelte
 });
+module.exports = __toCommonJS(src_exports);
 
-// ../../node_modules/.pnpm/tsup@5.12.1_typescript@4.6.2/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@5.12.5_typescript@4.6.3/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = () => typeof document === "undefined" ? new URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
@@ -285,7 +279,7 @@ function safeBase64Hash(input) {
   }
   const md5 = crypto.createHash("md5");
   md5.update(input);
-  const hash = toSafe(md5.digest("base64")).substr(0, hash_length);
+  const hash = toSafe(md5.digest("base64")).slice(0, hash_length);
   hashes[input] = hash;
   return hash;
 }
@@ -300,8 +294,9 @@ function toSafe(base64) {
 }
 
 // src/utils/compile.ts
+var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
 var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequest, code, options) {
-  var _a, _b;
+  var _a, _b, _c;
   const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
   const { emitCss = true } = options;
   const dependencies = [];
@@ -364,6 +359,7 @@ import ${JSON.stringify(cssId)};
   return {
     filename,
     normalizedFilename,
+    lang: ((_c = code.match(scriptLangRE)) == null ? void 0 : _c[1]) || "js",
     compiled,
     ssr,
     dependencies
@@ -482,6 +478,9 @@ var knownSvelteConfigNames = [
 ];
 var dynamicImportDefault = new Function("path", 'return import(path + "?t=" + Date.now()).then(m => m.default)');
 async function loadSvelteConfig(viteConfig, inlineOptions) {
+  if (inlineOptions.configFile === false) {
+    return;
+  }
   const configFile = findConfigToLoad(viteConfig, inlineOptions);
   if (configFile) {
     let err;
@@ -562,7 +561,7 @@ var SVELTE_HMR_IMPORTS = [
 ];
 
 // src/utils/options.ts
-var import_path3 = __toESM(require("path"), 1);
+var import_path4 = __toESM(require("path"), 1);
 
 // src/utils/dependencies.ts
 var import_path2 = __toESM(require("path"), 1);
@@ -592,7 +591,7 @@ function findRootSvelteDependencies(root, cwdFallback = true) {
   ].filter((dep) => !is_common_without_svelte_field(dep));
   return getSvelteDependencies(deps, root);
 }
-function getSvelteDependencies(deps, pkgDir, path7 = []) {
+function getSvelteDependencies(deps, pkgDir, path8 = []) {
   const result = [];
   const localRequire = (0, import_module2.createRequire)(`${pkgDir}/package.json`);
   const resolvedDeps = deps.map((dep) => resolveDependencyData(dep, localRequire)).filter(Boolean);
@@ -600,18 +599,18 @@ function getSvelteDependencies(deps, pkgDir, path7 = []) {
     const type = getSvelteDependencyType(pkg);
     if (!type)
       continue;
-    result.push({ name: pkg.name, type, pkg, dir, path: path7 });
+    result.push({ name: pkg.name, type, pkg, dir, path: path8 });
     if (type === "component-library" && pkg.dependencies) {
       let dependencyNames = Object.keys(pkg.dependencies);
-      const circular = dependencyNames.filter((name) => path7.includes(name));
+      const circular = dependencyNames.filter((name) => path8.includes(name));
       if (circular.length > 0) {
-        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path7.concat(x).join(">")));
-        dependencyNames = dependencyNames.filter((name) => !path7.includes(name));
+        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path8.concat(x).join(">")));
+        dependencyNames = dependencyNames.filter((name) => !path8.includes(name));
       }
-      if (path7.length === 3) {
-        log.debug.once(`encountered deep svelte dependency tree: ${path7.join(">")}`);
+      if (path8.length === 3) {
+        log.debug.once(`encountered deep svelte dependency tree: ${path8.join(">")}`);
       }
-      result.push(...getSvelteDependencies(dependencyNames, dir, path7.concat(pkg.name)));
+      result.push(...getSvelteDependencies(dependencyNames, dir, path8.concat(pkg.name)));
     }
   }
   return result;
@@ -792,7 +791,9 @@ function esbuildSveltePlugin(options) {
   return {
     name: "vite-plugin-svelte:optimize-svelte",
     setup(build) {
-      disableVitePrebundleSvelte(build);
+      var _a;
+      if ((_a = build.initialOptions.plugins) == null ? void 0 : _a.some((v) => v.name === "vite:dep-scan"))
+        return;
       const svelteExtensions = (options.extensions ?? [".svelte"]).map((ext) => ext.slice(1));
       const svelteFilter = new RegExp(`\\.(` + svelteExtensions.join("|") + `)(\\?.*)?$`);
       build.onLoad({ filter: svelteFilter }, async ({ path: filename }) => {
@@ -807,23 +808,6 @@ function esbuildSveltePlugin(options) {
     }
   };
 }
-function disableVitePrebundleSvelte(build) {
-  var _a;
-  const viteDepPrebundlePlugin = (_a = build.initialOptions.plugins) == null ? void 0 : _a.find((v) => v.name === "vite:dep-pre-bundle");
-  if (!viteDepPrebundlePlugin)
-    return;
-  const _setup = viteDepPrebundlePlugin.setup.bind(viteDepPrebundlePlugin);
-  viteDepPrebundlePlugin.setup = function(build2) {
-    const _onResolve = build2.onResolve.bind(build2);
-    build2.onResolve = function(options, callback) {
-      if (options.filter.source.includes("svelte")) {
-        options.filter = new RegExp(options.filter.source.replace("|svelte", ""), options.filter.flags);
-      }
-      return _onResolve(options, callback);
-    };
-    return _setup(build2);
-  };
-}
 async function compileSvelte(options, { filename, code }) {
   var _a, _b;
   const compileOptions = __spreadProps(__spreadValues({}, options.compilerOptions), {
@@ -909,6 +893,7 @@ async function buildSourceMap(from, to, filename) {
 }
 
 // src/utils/preprocess.ts
+var import_path3 = __toESM(require("path"), 1);
 var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
 var supportedScriptLangs = ["ts"];
 function createViteScriptPreprocessor() {
@@ -949,7 +934,7 @@ function createViteStylePreprocessor(config) {
     const moduleId = `${filename}.${lang}`;
     const transformResult = await pluginTransform(content, moduleId);
     if (((_b = (_a = transformResult.map) == null ? void 0 : _a.sources) == null ? void 0 : _b[0]) === moduleId) {
-      transformResult.map.sources[0] = filename;
+      transformResult.map.sources[0] = import_path3.default.basename(filename);
     }
     return {
       code: transformResult.code,
@@ -974,7 +959,10 @@ function createInjectScopeEverythingRulePreprocessorGroup() {
       s.append(" *{}");
       return {
         code: s.toString(),
-        map: s.generateDecodedMap({ source: filename, hires: true })
+        map: s.generateDecodedMap({
+          source: filename ? import_path3.default.basename(filename) : void 0,
+          hires: true
+        })
       };
     }
   };
@@ -1085,6 +1073,7 @@ function validateSourceMapOutputWrapper(group, i) {
 }
 
 // src/utils/options.ts
+var import_deepmerge = __toESM(require("deepmerge"), 1);
 var knownOptions = /* @__PURE__ */ new Set([
   "configFile",
   "include",
@@ -1097,7 +1086,8 @@ var knownOptions = /* @__PURE__ */ new Set([
   "hot",
   "ignorePluginPreprocessors",
   "disableDependencyReinclusion",
-  "experimental"
+  "experimental",
+  "kit"
 ]);
 function validateInlineOptions(inlineOptions) {
   const invalidKeys = Object.keys(inlineOptions || {}).filter((key) => !knownOptions.has(key));
@@ -1117,19 +1107,27 @@ async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
     }
   };
   const svelteConfig = await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions);
-  const merged = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, defaultOptions), svelteConfig), inlineOptions), {
-    compilerOptions: __spreadValues(__spreadValues(__spreadValues({}, defaultOptions == null ? void 0 : defaultOptions.compilerOptions), svelteConfig == null ? void 0 : svelteConfig.compilerOptions), inlineOptions == null ? void 0 : inlineOptions.compilerOptions),
-    experimental: __spreadValues(__spreadValues(__spreadValues({}, defaultOptions == null ? void 0 : defaultOptions.experimental), svelteConfig == null ? void 0 : svelteConfig.experimental), inlineOptions == null ? void 0 : inlineOptions.experimental),
+  const extraOptions = {
     root: viteConfigWithResolvedRoot.root,
     isBuild: viteEnv.command === "build",
     isServe: viteEnv.command === "serve",
     isDebug: process.env.DEBUG != null
-  });
+  };
+  const merged = mergeConfigs(defaultOptions, svelteConfig, inlineOptions, extraOptions);
   if (svelteConfig == null ? void 0 : svelteConfig.configFile) {
     merged.configFile = svelteConfig.configFile;
   }
   return merged;
 }
+function mergeConfigs(...configs) {
+  let result = {};
+  for (const config of configs.filter(Boolean)) {
+    result = (0, import_deepmerge.default)(result, config, {
+      arrayMerge: (target, source) => source ?? target
+    });
+  }
+  return result;
+}
 function resolveOptions(preResolveOptions2, viteConfig) {
   const defaultOptions = {
     hot: viteConfig.isProduction ? false : { injectCss: !preResolveOptions2.emitCss },
@@ -1138,11 +1136,11 @@ function resolveOptions(preResolveOptions2, viteConfig) {
       dev: !viteConfig.isProduction
     }
   };
-  const merged = __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), preResolveOptions2), {
-    compilerOptions: __spreadValues(__spreadValues({}, defaultOptions.compilerOptions), preResolveOptions2.compilerOptions),
+  const extraOptions = {
     root: viteConfig.root,
     isProduction: viteConfig.isProduction
-  });
+  };
+  const merged = mergeConfigs(defaultOptions, preResolveOptions2, extraOptions);
   addExtraPreprocessors(merged, viteConfig);
   enforceOptionsForHmr(merged);
   enforceOptionsForProduction(merged);
@@ -1192,9 +1190,10 @@ function enforceOptionsForProduction(options) {
   }
 }
 function resolveViteRoot(viteConfig) {
-  return (0, import_vite3.normalizePath)(viteConfig.root ? import_path3.default.resolve(viteConfig.root) : process.cwd());
+  return (0, import_vite3.normalizePath)(viteConfig.root ? import_path4.default.resolve(viteConfig.root) : process.cwd());
 }
 function buildExtraViteConfig(options, config) {
+  var _a;
   const svelteDeps = findRootSvelteDependencies(options.root);
   const extraViteConfig = {
     resolve: {
@@ -1205,19 +1204,29 @@ function buildExtraViteConfig(options, config) {
   if (options.isServe) {
     extraViteConfig.optimizeDeps = buildOptimizeDepsForSvelte(svelteDeps, options, config.optimizeDeps);
   }
+  if ((_a = options.experimental) == null ? void 0 : _a.prebundleSvelteLibraries) {
+    extraViteConfig.optimizeDeps = __spreadProps(__spreadValues({}, extraViteConfig.optimizeDeps), {
+      extensions: options.extensions ?? [".svelte"],
+      esbuildOptions: {
+        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
+        } }]
+      }
+    });
+  }
   extraViteConfig.ssr = buildSSROptionsForSvelte(svelteDeps, options, config, extraViteConfig);
   return extraViteConfig;
 }
-function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps2) {
+function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
+  var _a;
   const include = [];
   const exclude = ["svelte-hmr"];
   const isIncluded = (dep) => {
-    var _a;
-    return include.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.include) == null ? void 0 : _a.includes(dep));
+    var _a2;
+    return include.includes(dep) || ((_a2 = optimizeDeps == null ? void 0 : optimizeDeps.include) == null ? void 0 : _a2.includes(dep));
   };
   const isExcluded = (dep) => {
-    var _a;
-    return exclude.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
+    var _a2;
+    return exclude.includes(dep) || ((_a2 = optimizeDeps == null ? void 0 : optimizeDeps.exclude) == null ? void 0 : _a2.some((id) => dep === id || id.startsWith(`${dep}/`)));
   };
   if (!isExcluded("svelte")) {
     const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== "svelte/ssr");
@@ -1226,15 +1235,8 @@ function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps2) {
   } else {
     log.debug('"svelte" is excluded in optimizeDeps.exclude, skipped adding it to include.');
   }
-  if (options.experimental.prebundleSvelteLibraries) {
-    return {
-      include,
-      exclude,
-      esbuildOptions: {
-        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
-        } }]
-      }
-    };
+  if ((_a = options.experimental) == null ? void 0 : _a.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));
@@ -1356,8 +1358,8 @@ var VitePluginSvelteCache = class {
       return this._js.get(svelteRequest.normalizedFilename);
     }
   }
-  getDependants(path7) {
-    const dependants = this._dependants.get(path7);
+  getDependants(path8) {
+    const dependants = this._dependants.get(path8);
     return dependants ? [...dependants] : [];
   }
   getResolvedSvelteField(name, importer) {
@@ -1373,7 +1375,7 @@ var VitePluginSvelteCache = class {
 
 // src/utils/watch.ts
 var import_fs4 = __toESM(require("fs"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
   if (!server) {
@@ -1412,27 +1414,29 @@ function setupWatchers(options, cache, requestParser) {
       server.restart();
     }
   };
-  const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path4.default.join(root, cfg));
-  const restartOnConfigAdd = (filename) => {
-    if (possibleSvelteConfigs.includes(filename)) {
-      triggerViteRestart(filename);
-    }
-  };
-  const restartOnConfigChange = (filename) => {
-    if (filename === svelteConfigFile) {
-      triggerViteRestart(filename);
-    }
-  };
   const listenerCollection = {
     add: [],
     change: [emitChangeEventOnDependants],
     unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
   };
-  if (svelteConfigFile) {
-    listenerCollection.change.push(restartOnConfigChange);
-    listenerCollection.unlink.push(restartOnConfigChange);
-  } else {
-    listenerCollection.add.push(restartOnConfigAdd);
+  if (svelteConfigFile !== false) {
+    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path5.default.join(root, cfg));
+    const restartOnConfigAdd = (filename) => {
+      if (possibleSvelteConfigs.includes(filename)) {
+        triggerViteRestart(filename);
+      }
+    };
+    const restartOnConfigChange = (filename) => {
+      if (filename === svelteConfigFile) {
+        triggerViteRestart(filename);
+      }
+    };
+    if (svelteConfigFile) {
+      listenerCollection.change.push(restartOnConfigChange);
+      listenerCollection.unlink.push(restartOnConfigChange);
+    } else {
+      listenerCollection.add.push(restartOnConfigAdd);
+    }
   }
   Object.entries(listenerCollection).forEach(([evt, listeners]) => {
     if (listeners.length > 0) {
@@ -1442,12 +1446,12 @@ function setupWatchers(options, cache, requestParser) {
 }
 function ensureWatchedFile(watcher, file, root) {
   if (file && !file.startsWith(root + "/") && !file.includes("\0") && import_fs4.default.existsSync(file)) {
-    watcher.add(import_path4.default.resolve(file));
+    watcher.add(import_path5.default.resolve(file));
   }
 }
 
 // src/utils/resolve.ts
-var import_path5 = __toESM(require("path"), 1);
+var import_path6 = __toESM(require("path"), 1);
 var import_module4 = require("module");
 function resolveViaPackageJsonSvelte(importee, importer, cache) {
   if (importer && isBareImport(importee) && !isNodeInternal(importee) && !is_common_without_svelte_field(importee)) {
@@ -1460,7 +1464,7 @@ function resolveViaPackageJsonSvelte(importee, importer, cache) {
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
-        const result = import_path5.default.resolve(dir, pkg.svelte);
+        const result = import_path6.default.resolve(dir, pkg.svelte);
         cache.setResolvedSvelteField(importee, importer, result);
         return result;
       }
@@ -1471,7 +1475,7 @@ function isNodeInternal(importee) {
   return importee.startsWith("node:") || import_module4.builtinModules.includes(importee);
 }
 function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path5.default.isAbsolute(importee)) {
+  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path6.default.isAbsolute(importee)) {
     return false;
   }
   const parts = importee.split("/");
@@ -1486,9 +1490,8 @@ function isBareImport(importee) {
 }
 
 // src/utils/optimizer.ts
-var import_fs5 = __toESM(require("fs"), 1);
-var import_path6 = __toESM(require("path"), 1);
-var import_vite4 = require("vite");
+var import_fs5 = require("fs");
+var import_path7 = __toESM(require("path"), 1);
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
   "configFile",
@@ -1497,23 +1500,20 @@ var PREBUNDLE_SENSITIVE_OPTIONS = [
   "ignorePluginPreprocessors",
   "preprocess"
 ];
-async function handleOptimizeDeps(options, viteConfig) {
-  if (!options.experimental.prebundleSvelteLibraries || !viteConfig.cacheDir)
-    return;
-  const viteMetadataPath = findViteMetadataPath(viteConfig.cacheDir);
-  if (!viteMetadataPath)
-    return;
-  const svelteMetadataPath = import_path6.default.resolve(viteMetadataPath, "../_svelte_metadata.json");
-  const currentSvelteMetadata = JSON.stringify(generateSvelteMetadata(options), (_, value) => {
+async function saveSvelteMetadata(cacheDir, options) {
+  const svelteMetadata = generateSvelteMetadata(options);
+  const svelteMetadataPath = import_path7.default.resolve(cacheDir, "_svelte_metadata.json");
+  const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
     return typeof value === "function" ? value.toString() : value;
   });
-  if (import_fs5.default.existsSync(svelteMetadataPath)) {
-    const existingSvelteMetadata = import_fs5.default.readFileSync(svelteMetadataPath, "utf8");
-    if (existingSvelteMetadata === currentSvelteMetadata)
-      return;
+  let existingSvelteMetadata;
+  try {
+    existingSvelteMetadata = await import_fs5.promises.readFile(svelteMetadataPath, "utf8");
+  } catch {
   }
-  await (0, import_vite4.optimizeDeps)(viteConfig, true);
-  import_fs5.default.writeFileSync(svelteMetadataPath, currentSvelteMetadata);
+  await import_fs5.promises.mkdir(cacheDir, { recursive: true });
+  await import_fs5.promises.writeFile(svelteMetadataPath, currentSvelteMetadata);
+  return currentSvelteMetadata !== existingSvelteMetadata;
 }
 function generateSvelteMetadata(options) {
   const metadata = {};
@@ -1522,13 +1522,94 @@ function generateSvelteMetadata(options) {
   }
   return metadata;
 }
-function findViteMetadataPath(cacheDir) {
-  const metadataPaths = ["_metadata.json", "deps/_metadata.json"];
-  for (const metadataPath of metadataPaths) {
-    const viteMetadataPath = import_path6.default.resolve(cacheDir, metadataPath);
-    if (import_fs5.default.existsSync(viteMetadataPath))
-      return viteMetadataPath;
-  }
+
+// src/ui/inspector/plugin.ts
+var import_module5 = require("module");
+var defaultInspectorOptions = {
+  toggleKeyCombo: process.platform === "win32" ? "control-shift" : "meta-shift",
+  holdMode: false,
+  showToggleButton: "active",
+  toggleButtonPos: "top-right",
+  customStyles: true
+};
+function svelteInspector() {
+  let root;
+  let rootRequire;
+  let inspectorOptions;
+  let append_to;
+  return {
+    name: "vite-plugin-svelte:inspector",
+    apply: "serve",
+    enforce: "pre",
+    configResolved(config) {
+      var _a, _b, _c;
+      const vps = config.plugins.find((p) => p.name === "vite-plugin-svelte");
+      if ((_c = (_b = (_a = vps == null ? void 0 : vps.api) == null ? void 0 : _a.options) == null ? void 0 : _b.experimental) == null ? void 0 : _c.inspector) {
+        inspectorOptions = __spreadValues(__spreadValues({}, defaultInspectorOptions), vps.api.options.experimental.inspector);
+      }
+      if (!vps || !inspectorOptions) {
+        this.resolveId = this.load = this.transformIndexHtml = this.transform = () => {
+        };
+      } else {
+        root = config.root || process.cwd();
+        rootRequire = (0, import_module5.createRequire)(root);
+        if (vps.api.options.kit && !inspectorOptions.appendTo) {
+          const out_dir = vps.api.options.kit.outDir || ".svelte-kit";
+          inspectorOptions.appendTo = `${out_dir}/runtime/client/start.js`;
+        }
+        append_to = inspectorOptions.appendTo;
+      }
+    },
+    async resolveId(importee, importer, options) {
+      if (options == null ? void 0 : options.ssr) {
+        return;
+      }
+      if (importee === "virtual:svelte-inspector-options") {
+        return importee;
+      }
+      if (importee.startsWith("virtual:svelte-inspector:")) {
+        const file = importee.replace("virtual:svelte-inspector:", "@sveltejs/vite-plugin-svelte/src/ui/inspector/");
+        const path8 = rootRequire.resolve(file);
+        if (path8) {
+          return path8;
+        } else {
+          log.error.once(`failed to resolve ${file} for ${importee} from ${root}`);
+        }
+      }
+    },
+    load(id) {
+      if (id === "virtual:svelte-inspector-options") {
+        return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
+      }
+    },
+    transform(code, id, options) {
+      if ((options == null ? void 0 : options.ssr) || !append_to) {
+        return;
+      }
+      if (id.endsWith(append_to)) {
+        return { code: `${code}
+import 'virtual:svelte-inspector:load-inspector.ts'` };
+      }
+    },
+    transformIndexHtml(html) {
+      if (append_to) {
+        return;
+      }
+      return {
+        html,
+        tags: [
+          {
+            tag: "script",
+            injectTo: "body",
+            attrs: {
+              type: "module",
+              src: "/@id/virtual:svelte-inspector:load-inspector.ts"
+            }
+          }
+        ]
+      };
+    }
+  };
 }
 
 // src/index.ts
@@ -1543,121 +1624,139 @@ function svelte(inlineOptions) {
   let viteConfig;
   let compileSvelte2;
   let resolvedSvelteSSR;
-  return {
-    name: "vite-plugin-svelte",
-    enforce: "pre",
-    async config(config, configEnv) {
-      if (process.env.DEBUG) {
-        log.setLevel("debug");
-      } else if (config.logLevel) {
-        log.setLevel(config.logLevel);
-      }
-      options = await preResolveOptions(inlineOptions, config, configEnv);
-      const extraViteConfig = buildExtraViteConfig(options, config);
-      log.debug("additional vite config", extraViteConfig);
-      return extraViteConfig;
-    },
-    async configResolved(config) {
-      options = resolveOptions(options, config);
-      patchResolvedViteConfig(config, options);
-      requestParser = buildIdParser(options);
-      compileSvelte2 = createCompileSvelte(options);
-      viteConfig = config;
-      log.debug("resolved options", options);
-    },
-    async buildStart() {
-      await handleOptimizeDeps(options, viteConfig);
-    },
-    configureServer(server) {
-      options.server = server;
-      setupWatchers(options, cache, requestParser);
-    },
-    load(id, opts) {
-      const ssr = opts === true || (opts == null ? void 0 : opts.ssr);
-      const svelteRequest = requestParser(id, !!ssr);
-      if (svelteRequest) {
-        const { filename, query } = svelteRequest;
-        if (query.svelte && query.type === "style") {
-          const css = cache.getCSS(svelteRequest);
-          if (css) {
-            log.debug(`load returns css for ${filename}`);
-            return css;
+  const api = {};
+  const plugins = [
+    {
+      name: "vite-plugin-svelte",
+      enforce: "pre",
+      api,
+      async config(config, configEnv) {
+        if (process.env.DEBUG) {
+          log.setLevel("debug");
+        } else if (config.logLevel) {
+          log.setLevel(config.logLevel);
+        }
+        options = await preResolveOptions(inlineOptions, config, configEnv);
+        const extraViteConfig = buildExtraViteConfig(options, config);
+        log.debug("additional vite config", extraViteConfig);
+        return extraViteConfig;
+      },
+      async configResolved(config) {
+        options = resolveOptions(options, config);
+        patchResolvedViteConfig(config, options);
+        requestParser = buildIdParser(options);
+        compileSvelte2 = createCompileSvelte(options);
+        viteConfig = config;
+        api.options = options;
+        log.debug("resolved options", options);
+      },
+      async buildStart() {
+        var _a;
+        if (!((_a = options.experimental) == null ? void 0 : _a.prebundleSvelteLibraries))
+          return;
+        const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
+        if (isSvelteMetadataChanged) {
+          viteConfig.server.force = true;
+        }
+      },
+      configureServer(server) {
+        options.server = server;
+        setupWatchers(options, cache, requestParser);
+      },
+      load(id, opts) {
+        const ssr = opts === true || (opts == null ? void 0 : opts.ssr);
+        const svelteRequest = requestParser(id, !!ssr);
+        if (svelteRequest) {
+          const { filename, query } = svelteRequest;
+          if (query.svelte && query.type === "style") {
+            const css = cache.getCSS(svelteRequest);
+            if (css) {
+              log.debug(`load returns css for ${filename}`);
+              return css;
+            }
+          }
+          if (viteConfig.assetsInclude(filename)) {
+            log.debug(`load returns raw content for ${filename}`);
+            return import_fs6.default.readFileSync(filename, "utf-8");
           }
         }
-        if (viteConfig.assetsInclude(filename)) {
-          log.debug(`load returns raw content for ${filename}`);
-          return import_fs6.default.readFileSync(filename, "utf-8");
+      },
+      async resolveId(importee, importer, opts) {
+        const ssr = !!(opts == null ? void 0 : opts.ssr);
+        const svelteRequest = requestParser(importee, ssr);
+        if (svelteRequest == null ? void 0 : svelteRequest.query.svelte) {
+          if (svelteRequest.query.type === "style") {
+            log.debug(`resolveId resolved virtual css module ${svelteRequest.cssId}`);
+            return svelteRequest.cssId;
+          }
+          log.debug(`resolveId resolved ${importee}`);
+          return importee;
         }
-      }
-    },
-    async resolveId(importee, importer, opts) {
-      const ssr = !!(opts == null ? void 0 : opts.ssr);
-      const svelteRequest = requestParser(importee, ssr);
-      if (svelteRequest == null ? void 0 : svelteRequest.query.svelte) {
-        if (svelteRequest.query.type === "style") {
-          log.debug(`resolveId resolved virtual css module ${svelteRequest.cssId}`);
-          return svelteRequest.cssId;
+        if (ssr && importee === "svelte") {
+          if (!resolvedSvelteSSR) {
+            resolvedSvelteSSR = this.resolve("svelte/ssr", void 0, { skipSelf: true }).then((svelteSSR) => {
+              log.debug("resolved svelte to svelte/ssr");
+              return svelteSSR;
+            }, (err) => {
+              log.debug("failed to resolve svelte to svelte/ssr. Update svelte to a version that exports it", err);
+              return null;
+            });
+          }
+          return resolvedSvelteSSR;
         }
-        log.debug(`resolveId resolved ${importee}`);
-        return importee;
-      }
-      if (ssr && importee === "svelte") {
-        if (!resolvedSvelteSSR) {
-          resolvedSvelteSSR = this.resolve("svelte/ssr", void 0, { skipSelf: true }).then((svelteSSR) => {
-            log.debug("resolved svelte to svelte/ssr");
-            return svelteSSR;
-          }, (err) => {
-            log.debug("failed to resolve svelte to svelte/ssr. Update svelte to a version that exports it", err);
-            return null;
-          });
+        try {
+          const resolved = 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 resolvedSvelteSSR;
-      }
-      try {
-        const resolved = resolveViaPackageJsonSvelte(importee, importer, cache);
-        if (resolved) {
-          log.debug(`resolveId resolved ${resolved} via package.json svelte field of ${importee}`);
-          return resolved;
+      },
+      async transform(code, id, opts) {
+        var _a;
+        const ssr = !!(opts == null ? void 0 : opts.ssr);
+        const svelteRequest = requestParser(id, ssr);
+        if (!svelteRequest || svelteRequest.query.svelte) {
+          return;
         }
-      } catch (e) {
-        log.debug.once(`error trying to resolve ${importee} from ${importer} via package.json svelte field `, e);
-      }
-    },
-    async transform(code, id, opts) {
-      var _a;
-      const ssr = !!(opts == null ? void 0 : opts.ssr);
-      const svelteRequest = requestParser(id, ssr);
-      if (!svelteRequest || svelteRequest.query.svelte) {
-        return;
-      }
-      let compileData;
-      try {
-        compileData = await compileSvelte2(svelteRequest, code, options);
-      } catch (e) {
-        throw toRollupError(e, options);
-      }
-      logCompilerWarnings(compileData.compiled.warnings, options);
-      cache.update(compileData);
-      if (((_a = compileData.dependencies) == null ? void 0 : _a.length) && options.server) {
-        compileData.dependencies.forEach((d) => {
-          ensureWatchedFile(options.server.watcher, d, options.root);
+        let compileData;
+        try {
+          compileData = await compileSvelte2(svelteRequest, code, options);
+        } catch (e) {
+          throw toRollupError(e, options);
+        }
+        logCompilerWarnings(compileData.compiled.warnings, options);
+        cache.update(compileData);
+        if (((_a = compileData.dependencies) == null ? void 0 : _a.length) && options.server) {
+          compileData.dependencies.forEach((d) => {
+            ensureWatchedFile(options.server.watcher, d, options.root);
+          });
+        }
+        log.debug(`transform returns compiled js for ${svelteRequest.filename}`);
+        return __spreadProps(__spreadValues({}, compileData.compiled.js), {
+          meta: {
+            vite: {
+              lang: compileData.lang
+            }
+          }
         });
-      }
-      log.debug(`transform returns compiled js for ${svelteRequest.filename}`);
-      return compileData.compiled.js;
-    },
-    handleHotUpdate(ctx) {
-      if (!options.hot || !options.emitCss) {
-        return;
-      }
-      const svelteRequest = requestParser(ctx.file, false, ctx.timestamp);
-      if (svelteRequest) {
-        return handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, options);
+      },
+      handleHotUpdate(ctx) {
+        if (!options.hot || !options.emitCss) {
+          return;
+        }
+        const svelteRequest = requestParser(ctx.file, false, ctx.timestamp);
+        if (svelteRequest) {
+          return handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, options);
+        }
       }
     }
-  };
+  ];
+  plugins.push(svelteInspector());
+  return plugins.filter(Boolean);
 }
-module.exports = __toCommonJS(src_exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   svelte