@sveltejs/vite-plugin-svelte 1.0.0-next.31 → 1.0.0-next.35

package/dist/index.cjs

@@ -23,36 +23,42 @@ var __spreadValues = (a, b) => {
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
-  __markAsModule(target);
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, desc) => {
+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) && key !== "default")
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
         __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
   }
   return target;
 };
-var __toModule = (module2) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+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);
 
 // src/index.ts
-__export(exports, {
+var src_exports = {};
+__export(src_exports, {
   svelte: () => svelte
 });
 
-// ../../node_modules/.pnpm/tsup@5.10.1_typescript@4.5.2/node_modules/tsup/assets/cjs_shims.js
-var importMetaUrlShim = typeof document === "undefined" ? new URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+// ../../node_modules/.pnpm/tsup@5.11.11_typescript@4.5.4/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/index.ts
-var import_fs6 = __toModule(require("fs"));
+var import_fs6 = __toESM(require("fs"), 1);
 
 // src/utils/log.ts
-var import_colors = __toModule(require("kleur/colors"));
-var import_debug = __toModule(require("debug"));
+var import_colors = require("kleur/colors");
+var import_debug = __toESM(require("debug"), 1);
 var levels = ["debug", "info", "warn", "error", "silent"];
 var prefix = "vite-plugin-svelte";
 var loggers = {
@@ -111,7 +117,7 @@ function _log(logger, message, payload) {
 function createLogger(level) {
   const logger = loggers[level];
   const logFn = _log.bind(null, logger);
-  const logged = new Set();
+  const logged = /* @__PURE__ */ new Set();
   const once = function(message, payload) {
     if (logged.has(message)) {
       return;
@@ -203,7 +209,7 @@ async function handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, option
   const content = await read();
   const compileData = await compileSvelte2(svelteRequest, content, options);
   cache.update(compileData);
-  const affectedModules = new Set();
+  const affectedModules = /* @__PURE__ */ new Set();
   const cssModule = server.moduleGraph.getModuleById(svelteRequest.cssId);
   const mainModule = server.moduleGraph.getModuleById(svelteRequest.id);
   const cssUpdated = cssModule && cssChanged(cachedCss, compileData.compiled.css);
@@ -263,12 +269,12 @@ function normalizeJsCode(code) {
 }
 
 // src/utils/compile.ts
-var import_compiler = __toModule(require("svelte/compiler"));
-var import_svelte_hmr = __toModule(require("svelte-hmr"));
+var import_compiler = require("svelte/compiler");
+var import_svelte_hmr = require("svelte-hmr");
 
 // src/utils/hash.ts
-var crypto = __toModule(require("crypto"));
-var hashes = Object.create(null);
+var crypto = __toESM(require("crypto"), 1);
+var hashes = /* @__PURE__ */ Object.create(null);
 var hash_length = 12;
 function safeBase64Hash(input) {
   if (hashes[input]) {
@@ -375,9 +381,9 @@ function createCompileSvelte(options) {
 }
 
 // src/utils/id.ts
-var import_pluginutils = __toModule(require("@rollup/pluginutils"));
-var import_vite = __toModule(require("vite"));
-var fs = __toModule(require("fs"));
+var import_pluginutils = require("@rollup/pluginutils");
+var import_vite = require("vite");
+var fs = __toESM(require("fs"), 1);
 var VITE_FS_PREFIX = "/@fs/";
 var IS_WINDOWS = process.platform === "win32";
 function splitId(id) {
@@ -453,13 +459,13 @@ function buildIdParser(options) {
 }
 
 // src/utils/options.ts
-var import_vite2 = __toModule(require("vite"));
+var import_vite3 = require("vite");
 
 // src/utils/load-svelte-config.ts
-var import_module = __toModule(require("module"));
-var import_path = __toModule(require("path"));
-var import_fs = __toModule(require("fs"));
-var import_url = __toModule(require("url"));
+var import_module = require("module");
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_url = require("url");
 var esmRequire;
 var knownSvelteConfigNames = [
   "svelte.config.js",
@@ -488,7 +494,7 @@ async function loadSvelteConfig(viteConfig, inlineOptions) {
     }
     if (!configFile.endsWith(".mjs")) {
       try {
-        const _require = importMetaUrlShim ? esmRequire ?? (esmRequire = (0, import_module.createRequire)(importMetaUrlShim)) : require;
+        const _require = importMetaUrl ? esmRequire ?? (esmRequire = (0, import_module.createRequire)(importMetaUrl)) : require;
         delete _require.cache[_require.resolve(configFile)];
         const result = _require(configFile);
         if (result != null) {
@@ -548,12 +554,12 @@ var SVELTE_HMR_IMPORTS = [
 ];
 
 // src/utils/options.ts
-var import_path3 = __toModule(require("path"));
+var import_path3 = __toESM(require("path"), 1);
 
 // src/utils/dependencies.ts
-var import_path2 = __toModule(require("path"));
-var import_fs2 = __toModule(require("fs"));
-var import_module2 = __toModule(require("module"));
+var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_module2 = require("module");
 function findRootSvelteDependencies(root, cwdFallback = true) {
   log.debug(`findSvelteDependencies: searching svelte dependencies in ${root}`);
   const pkgFile = import_path2.default.join(root, "package.json");
@@ -578,7 +584,7 @@ function findRootSvelteDependencies(root, cwdFallback = true) {
   ].filter((dep) => !is_common_without_svelte_field(dep));
   return getSvelteDependencies(deps, root);
 }
-function getSvelteDependencies(deps, pkgDir, path6 = []) {
+function getSvelteDependencies(deps, pkgDir, path7 = []) {
   const result = [];
   const localRequire = (0, import_module2.createRequire)(`${pkgDir}/package.json`);
   const resolvedDeps = deps.map((dep) => resolveDependencyData(dep, localRequire)).filter(Boolean);
@@ -586,18 +592,18 @@ function getSvelteDependencies(deps, pkgDir, path6 = []) {
     const type = getSvelteDependencyType(pkg);
     if (!type)
       continue;
-    result.push({ name: pkg.name, type, pkg, dir, path: path6 });
+    result.push({ name: pkg.name, type, pkg, dir, path: path7 });
     if (type === "component-library" && pkg.dependencies) {
       let dependencyNames = Object.keys(pkg.dependencies);
-      const circular = dependencyNames.filter((name) => path6.includes(name));
+      const circular = dependencyNames.filter((name) => path7.includes(name));
       if (circular.length > 0) {
-        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path6.concat(x).join(">")));
-        dependencyNames = dependencyNames.filter((name) => !path6.includes(name));
+        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));
       }
-      if (path6.length === 3) {
-        log.debug.once(`encountered deep svelte dependency tree: ${path6.join(">")}`);
+      if (path7.length === 3) {
+        log.debug.once(`encountered deep svelte dependency tree: ${path7.join(">")}`);
       }
-      result.push(...getSvelteDependencies(dependencyNames, dir, path6.concat(pkg.name)));
+      result.push(...getSvelteDependencies(dependencyNames, dir, path7.concat(pkg.name)));
     }
   }
   return result;
@@ -696,15 +702,19 @@ function needsOptimization(dep, localRequire) {
   if (!depData)
     return false;
   const pkg = depData.pkg;
-  return pkg.main && !pkg.module && !pkg.exports;
+  const isCjs = pkg.main && !pkg.module && !pkg.exports;
+  if (!isCjs)
+    return false;
+  const entryExt = import_path2.default.extname(pkg.main);
+  return !entryExt || entryExt === ".js" || entryExt === ".cjs";
 }
 
 // src/utils/options.ts
-var import_module3 = __toModule(require("module"));
+var import_module3 = require("module");
 
 // src/utils/esbuild.ts
-var import_fs3 = __toModule(require("fs"));
-var import_compiler2 = __toModule(require("svelte/compiler"));
+var import_fs3 = require("fs");
+var import_compiler2 = require("svelte/compiler");
 
 // src/utils/error.ts
 function toRollupError(error) {
@@ -757,6 +767,7 @@ function formatFrameForVite(frame) {
 }
 
 // src/utils/esbuild.ts
+var facadeEsbuildSveltePluginName = "vite-plugin-svelte:facade";
 function esbuildSveltePlugin(options) {
   return {
     name: "vite-plugin-svelte:optimize-svelte",
@@ -798,6 +809,7 @@ async function compileSvelte(options, { filename, code }) {
   const compileOptions = __spreadProps(__spreadValues({}, options.compilerOptions), {
     css: true,
     filename,
+    format: "esm",
     generate: "dom"
   });
   let preprocessed;
@@ -820,8 +832,235 @@ async function compileSvelte(options, { filename, code }) {
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
+// src/utils/preprocess.ts
+var import_vite2 = require("vite");
+var import_magic_string2 = __toESM(require("magic-string"), 1);
+var import_compiler3 = require("svelte/compiler");
+
+// src/utils/sourcemap.ts
+var import_magic_string = __toESM(require("magic-string"), 1);
+async function buildMagicString(from, to, options) {
+  let diff_match_patch, DIFF_DELETE, DIFF_INSERT;
+  try {
+    const dmpPkg = await import("diff-match-patch");
+    diff_match_patch = dmpPkg.diff_match_patch;
+    DIFF_INSERT = dmpPkg.DIFF_INSERT;
+    DIFF_DELETE = dmpPkg.DIFF_DELETE;
+  } catch (e) {
+    log.error.once('Failed to import optional dependency "diff-match-patch". Please install it to enable generated sourcemaps.');
+    return null;
+  }
+  const dmp = new diff_match_patch();
+  const diffs = dmp.diff_main(from, to);
+  dmp.diff_cleanupSemantic(diffs);
+  const m = new import_magic_string.default(from, options);
+  let pos = 0;
+  for (let i = 0; i < diffs.length; i++) {
+    const diff = diffs[i];
+    const nextDiff = diffs[i + 1];
+    if (diff[0] === DIFF_DELETE) {
+      if ((nextDiff == null ? void 0 : nextDiff[0]) === DIFF_INSERT) {
+        m.overwrite(pos, pos + diff[1].length, nextDiff[1]);
+        i++;
+      } else {
+        m.remove(pos, pos + diff[1].length);
+      }
+      pos += diff[1].length;
+    } else if (diff[0] === DIFF_INSERT) {
+      if (nextDiff) {
+        m.appendRight(pos, diff[1]);
+      } else {
+        m.append(diff[1]);
+      }
+    } else {
+      pos += diff[1].length;
+    }
+  }
+  return m;
+}
+async function buildSourceMap(from, to, filename) {
+  const m = await buildMagicString(from, to, { filename });
+  return m ? m.generateDecodedMap({ source: filename, hires: true, includeContent: false }) : null;
+}
+
+// src/utils/preprocess.ts
+var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
+var supportedScriptLangs = ["ts"];
+function createViteScriptPreprocessor() {
+  return async ({ attributes, content, filename = "" }) => {
+    const lang = attributes.lang;
+    if (!supportedScriptLangs.includes(lang))
+      return;
+    const transformResult = await (0, import_vite2.transformWithEsbuild)(content, filename, {
+      loader: lang,
+      tsconfigRaw: {
+        compilerOptions: {
+          importsNotUsedAsValues: "preserve",
+          preserveValueImports: true
+        }
+      }
+    });
+    return {
+      code: transformResult.code,
+      map: transformResult.map
+    };
+  };
+}
+function createViteStylePreprocessor(config) {
+  const pluginName = "vite:css";
+  const plugin = config.plugins.find((p) => p.name === pluginName);
+  if (!plugin) {
+    throw new Error(`failed to find plugin ${pluginName}`);
+  }
+  if (!plugin.transform) {
+    throw new Error(`plugin ${pluginName} has no transform`);
+  }
+  const pluginTransform = plugin.transform.bind(null);
+  return async ({ attributes, content, filename = "" }) => {
+    var _a, _b;
+    const lang = attributes.lang;
+    if (!supportedStyleLangs.includes(lang))
+      return;
+    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;
+    }
+    return {
+      code: transformResult.code,
+      map: transformResult.map ?? void 0
+    };
+  };
+}
+function createVitePreprocessorGroup(config) {
+  return {
+    markup({ content, filename }) {
+      return (0, import_compiler3.preprocess)(content, {
+        script: createViteScriptPreprocessor(),
+        style: createViteStylePreprocessor(config)
+      }, { filename });
+    }
+  };
+}
+function createInjectScopeEverythingRulePreprocessorGroup() {
+  return {
+    style({ content, filename }) {
+      const s = new import_magic_string2.default(content);
+      s.append(" *{}");
+      return {
+        code: s.toString(),
+        map: s.generateDecodedMap({ source: filename, hires: true })
+      };
+    }
+  };
+}
+function buildExtraPreprocessors(options, config) {
+  var _a, _b;
+  const prependPreprocessors = [];
+  const appendPreprocessors = [];
+  if ((_a = options.experimental) == null ? void 0 : _a.useVitePreprocess) {
+    log.debug("adding vite preprocessor");
+    prependPreprocessors.push(createVitePreprocessorGroup(config));
+  }
+  const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p == null ? void 0 : p.sveltePreprocess);
+  if (pluginsWithPreprocessorsDeprecated.length > 0) {
+    log.warn(`The following plugins use the deprecated 'plugin.sveltePreprocess' field. Please contact their maintainers and ask them to move it to 'plugin.api.sveltePreprocess': ${pluginsWithPreprocessorsDeprecated.map((p) => p.name).join(", ")}`);
+    pluginsWithPreprocessorsDeprecated.forEach((p) => {
+      if (!p.api) {
+        p.api = {};
+      }
+      if (p.api.sveltePreprocess === void 0) {
+        p.api.sveltePreprocess = p.sveltePreprocess;
+      } else {
+        log.error(`ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`);
+      }
+    });
+  }
+  const pluginsWithPreprocessors = config.plugins.filter((p) => {
+    var _a2;
+    return (_a2 = p == null ? void 0 : p.api) == null ? void 0 : _a2.sveltePreprocess;
+  });
+  const ignored = [], included = [];
+  for (const p of pluginsWithPreprocessors) {
+    if (options.ignorePluginPreprocessors === true || Array.isArray(options.ignorePluginPreprocessors) && ((_b = options.ignorePluginPreprocessors) == null ? void 0 : _b.includes(p.name))) {
+      ignored.push(p);
+    } else {
+      included.push(p);
+    }
+  }
+  if (ignored.length > 0) {
+    log.debug(`Ignoring svelte preprocessors defined by these vite plugins: ${ignored.map((p) => p.name).join(", ")}`);
+  }
+  if (included.length > 0) {
+    log.debug(`Adding svelte preprocessors defined by these vite plugins: ${included.map((p) => p.name).join(", ")}`);
+    appendPreprocessors.push(...pluginsWithPreprocessors.map((p) => p.api.sveltePreprocess));
+  }
+  if (options.hot && options.emitCss) {
+    appendPreprocessors.push(createInjectScopeEverythingRulePreprocessorGroup());
+  }
+  return { prependPreprocessors, appendPreprocessors };
+}
+function addExtraPreprocessors(options, config) {
+  var _a;
+  const { prependPreprocessors, appendPreprocessors } = buildExtraPreprocessors(options, config);
+  if (prependPreprocessors.length > 0 || appendPreprocessors.length > 0) {
+    if (!options.preprocess) {
+      options.preprocess = [...prependPreprocessors, ...appendPreprocessors];
+    } else if (Array.isArray(options.preprocess)) {
+      options.preprocess.unshift(...prependPreprocessors);
+      options.preprocess.push(...appendPreprocessors);
+    } else {
+      options.preprocess = [...prependPreprocessors, options.preprocess, ...appendPreprocessors];
+    }
+  }
+  const generateMissingSourceMaps = !!((_a = options.experimental) == null ? void 0 : _a.generateMissingPreprocessorSourcemaps);
+  if (options.preprocess && generateMissingSourceMaps) {
+    options.preprocess = Array.isArray(options.preprocess) ? options.preprocess.map((p, i) => validateSourceMapOutputWrapper(p, i)) : validateSourceMapOutputWrapper(options.preprocess, 0);
+  }
+}
+function validateSourceMapOutputWrapper(group, i) {
+  const wrapper = {};
+  for (const [processorType, processorFn] of Object.entries(group)) {
+    wrapper[processorType] = async (options) => {
+      var _a;
+      const result = await processorFn(options);
+      if (result && result.code !== options.content) {
+        let invalidMap = false;
+        if (!result.map) {
+          invalidMap = true;
+          log.warn.enabled && log.warn.once(`preprocessor at index ${i} did not return a sourcemap for ${processorType} transform`, {
+            filename: options.filename,
+            type: processorType,
+            processor: processorFn.toString()
+          });
+        } else if (((_a = result.map) == null ? void 0 : _a.mappings) === "") {
+          invalidMap = true;
+          log.warn.enabled && log.warn.once(`preprocessor at index ${i} returned an invalid empty sourcemap for ${processorType} transform`, {
+            filename: options.filename,
+            type: processorType,
+            processor: processorFn.toString()
+          });
+        }
+        if (invalidMap) {
+          try {
+            const map = await buildSourceMap(options.content, result.code, options.filename);
+            if (map) {
+              log.debug.enabled && log.debug(`adding generated sourcemap to preprocesor result for ${options.filename}`);
+              result.map = map;
+            }
+          } catch (e) {
+            log.error(`failed to build sourcemap`, e);
+          }
+        }
+      }
+      return result;
+    };
+  }
+  return wrapper;
+}
+
 // src/utils/options.ts
-var knownOptions = new Set([
+var knownOptions = /* @__PURE__ */ new Set([
   "configFile",
   "include",
   "exclude",
@@ -835,28 +1074,53 @@ var knownOptions = new Set([
   "disableDependencyReinclusion",
   "experimental"
 ]);
-function buildDefaultOptions(isProduction, emitCss = true) {
-  const hot = isProduction ? false : {
-    injectCss: !emitCss
-  };
+function validateInlineOptions(inlineOptions) {
+  const invalidKeys = Object.keys(inlineOptions || {}).filter((key) => !knownOptions.has(key));
+  if (invalidKeys.length) {
+    log.warn(`invalid plugin options "${invalidKeys.join(", ")}" in config`, inlineOptions);
+  }
+}
+async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
+  const viteConfigWithResolvedRoot = __spreadProps(__spreadValues({}, viteUserConfig), {
+    root: resolveViteRoot(viteUserConfig)
+  });
   const defaultOptions = {
     extensions: [".svelte"],
-    hot,
-    emitCss,
+    emitCss: true,
     compilerOptions: {
-      format: "esm",
-      css: !emitCss,
-      dev: !isProduction
+      format: "esm"
     }
   };
-  log.debug(`default options for ${isProduction ? "production" : "development"}`, defaultOptions);
-  return defaultOptions;
-}
-function validateInlineOptions(inlineOptions) {
-  const invalidKeys = Object.keys(inlineOptions || {}).filter((key) => !knownOptions.has(key));
-  if (invalidKeys.length) {
-    log.warn(`invalid plugin options "${invalidKeys.join(", ")}" in config`, inlineOptions);
+  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),
+    root: viteConfigWithResolvedRoot.root,
+    isBuild: viteEnv.command === "build",
+    isServe: viteEnv.command === "serve"
+  });
+  if (svelteConfig == null ? void 0 : svelteConfig.configFile) {
+    merged.configFile = svelteConfig.configFile;
   }
+  return merged;
+}
+function resolveOptions(preResolveOptions2, viteConfig) {
+  const defaultOptions = {
+    hot: viteConfig.isProduction ? false : { injectCss: !preResolveOptions2.emitCss },
+    compilerOptions: {
+      css: !preResolveOptions2.emitCss,
+      dev: !viteConfig.isProduction
+    }
+  };
+  const merged = __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), preResolveOptions2), {
+    compilerOptions: __spreadValues(__spreadValues({}, defaultOptions.compilerOptions), preResolveOptions2.compilerOptions),
+    root: viteConfig.root,
+    isProduction: viteConfig.isProduction
+  });
+  addExtraPreprocessors(merged, viteConfig);
+  enforceOptionsForHmr(merged);
+  enforceOptionsForProduction(merged);
+  return merged;
 }
 function enforceOptionsForHmr(options) {
   if (options.hot) {
@@ -901,33 +1165,8 @@ function enforceOptionsForProduction(options) {
     }
   }
 }
-function mergeOptions(defaultOptions, svelteConfig, inlineOptions, viteConfig, viteEnv) {
-  const merged = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, defaultOptions), svelteConfig), inlineOptions), {
-    compilerOptions: __spreadValues(__spreadValues(__spreadValues({}, defaultOptions.compilerOptions), (svelteConfig == null ? void 0 : svelteConfig.compilerOptions) || {}), (inlineOptions == null ? void 0 : inlineOptions.compilerOptions) || {}),
-    experimental: __spreadValues(__spreadValues({}, (svelteConfig == null ? void 0 : svelteConfig.experimental) || {}), (inlineOptions == null ? void 0 : inlineOptions.experimental) || {}),
-    root: viteConfig.root,
-    isProduction: viteEnv.mode === "production",
-    isBuild: viteEnv.command === "build",
-    isServe: viteEnv.command === "serve"
-  });
-  if (svelteConfig == null ? void 0 : svelteConfig.configFile) {
-    merged.configFile = svelteConfig.configFile;
-  }
-  return merged;
-}
-async function resolveOptions(inlineOptions = {}, viteConfig, viteEnv) {
-  const viteConfigWithResolvedRoot = __spreadProps(__spreadValues({}, viteConfig), {
-    root: resolveViteRoot(viteConfig)
-  });
-  const svelteConfig = await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions) || {};
-  const defaultOptions = buildDefaultOptions(viteEnv.mode === "production", inlineOptions.emitCss ?? svelteConfig.emitCss);
-  const resolvedOptions = mergeOptions(defaultOptions, svelteConfig, inlineOptions, viteConfigWithResolvedRoot, viteEnv);
-  enforceOptionsForProduction(resolvedOptions);
-  enforceOptionsForHmr(resolvedOptions);
-  return resolvedOptions;
-}
 function resolveViteRoot(viteConfig) {
-  return (0, import_vite2.normalizePath)(viteConfig.root ? import_path3.default.resolve(viteConfig.root) : process.cwd());
+  return (0, import_vite3.normalizePath)(viteConfig.root ? import_path3.default.resolve(viteConfig.root) : process.cwd());
 }
 function buildExtraViteConfig(options, config, configEnv) {
   const svelteDeps = findRootSvelteDependencies(options.root);
@@ -943,16 +1182,16 @@ function buildExtraViteConfig(options, config, configEnv) {
   extraViteConfig.ssr = buildSSROptionsForSvelte(svelteDeps, options, config);
   return extraViteConfig;
 }
-function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
+function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps2) {
   const include = [];
   const exclude = ["svelte-hmr"];
   const isIncluded = (dep) => {
     var _a;
-    return include.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.include) == null ? void 0 : _a.includes(dep));
+    return include.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.include) == null ? void 0 : _a.includes(dep));
   };
   const isExcluded = (dep) => {
     var _a;
-    return exclude.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
+    return exclude.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
   };
   if (!isExcluded("svelte")) {
     const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== "svelte/ssr");
@@ -966,7 +1205,8 @@ function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
       include,
       exclude,
       esbuildOptions: {
-        plugins: [esbuildSveltePlugin(options)]
+        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
+        } }]
       }
     };
   }
@@ -1006,14 +1246,22 @@ function buildSSROptionsForSvelte(svelteDeps, options, config) {
     noExternal
   };
 }
+function patchResolvedViteConfig(viteConfig, options) {
+  var _a, _b;
+  const facadeEsbuildSveltePlugin = (_b = (_a = viteConfig.optimizeDeps.esbuildOptions) == null ? void 0 : _a.plugins) == null ? void 0 : _b.find((plugin) => plugin.name === facadeEsbuildSveltePluginName);
+  if (facadeEsbuildSveltePlugin) {
+    Object.assign(facadeEsbuildSveltePlugin, esbuildSveltePlugin(options));
+  }
+}
 
 // src/utils/vite-plugin-svelte-cache.ts
 var VitePluginSvelteCache = class {
   constructor() {
-    this._css = new Map();
-    this._js = new Map();
-    this._dependencies = new Map();
-    this._dependants = new Map();
+    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();
   }
   update(compileData) {
     this.updateCSS(compileData);
@@ -1037,7 +1285,7 @@ var VitePluginSvelteCache = class {
     const added = dependencies.filter((d) => !prevDependencies.includes(d));
     added.forEach((d) => {
       if (!this._dependants.has(d)) {
-        this._dependants.set(d, new Set());
+        this._dependants.set(d, /* @__PURE__ */ new Set());
       }
       this._dependants.get(d).add(compileData.filename);
     });
@@ -1075,22 +1323,31 @@ var VitePluginSvelteCache = class {
       return this._js.get(svelteRequest.normalizedFilename);
     }
   }
-  getDependants(path6) {
-    const dependants = this._dependants.get(path6);
+  getDependants(path7) {
+    const dependants = this._dependants.get(path7);
     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_fs4 = __toModule(require("fs"));
-var import_path4 = __toModule(require("path"));
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
   if (!server) {
     return;
   }
   const { watcher, ws } = server;
-  const { configFile: viteConfigFile, root, server: serverConfig } = server.config;
+  const { root, server: serverConfig } = server.config;
   const emitChangeEventOnDependants = (filename) => {
     const dependants = cache.getDependants(filename);
     dependants.forEach((dependant) => {
@@ -1110,16 +1367,16 @@ function setupWatchers(options, cache, requestParser) {
     }
   };
   const triggerViteRestart = (filename) => {
-    if (!!viteConfigFile && !serverConfig.middlewareMode) {
-      log.info(`svelte config changed: restarting vite server. - file: ${filename}`);
-      watcher.emit("change", viteConfigFile);
-    } else {
+    if (serverConfig.middlewareMode) {
       const message = "Svelte config change detected, restart your dev process to apply the changes.";
       log.info(message, filename);
       ws.send({
         type: "error",
         err: { message, stack: "", plugin: "vite-plugin-svelte", id: filename }
       });
+    } else {
+      log.info(`svelte config changed: restarting vite server. - file: ${filename}`);
+      server.restart();
     }
   };
   const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => import_path4.default.join(root, cfg));
@@ -1157,20 +1414,30 @@ function ensureWatchedFile(watcher, file, root) {
 }
 
 // src/utils/resolve.ts
-var import_path5 = __toModule(require("path"));
-var import_fs5 = __toModule(require("fs"));
-var import_require_relative = __toModule(require("require-relative"));
-function resolveViaPackageJsonSvelte(importee, importer) {
-  if (importer && isBareImport(importee)) {
-    const importeePkgFile = import_require_relative.default.resolve(`${importee}/package.json`, import_path5.default.dirname(importer));
-    const importeePkg = JSON.parse(import_fs5.default.readFileSync(importeePkgFile, { encoding: "utf-8" }));
-    if (importeePkg.svelte) {
-      return import_path5.default.resolve(import_path5.default.dirname(importeePkgFile), importeePkg.svelte);
+var import_path5 = __toESM(require("path"), 1);
+var import_module4 = require("module");
+function resolveViaPackageJsonSvelte(importee, importer, cache) {
+  if (importer && isBareImport(importee) && !is_common_without_svelte_field(importee)) {
+    const cached = cache.getResolvedSvelteField(importee, importer);
+    if (cached) {
+      return cached;
+    }
+    const localRequire = (0, import_module4.createRequire)(importer);
+    const pkgData = resolveDependencyData(importee, localRequire);
+    if (pkgData) {
+      const { pkg, dir } = pkgData;
+      if (pkg.svelte) {
+        const result = import_path5.default.resolve(dir, pkg.svelte);
+        cache.setResolvedSvelteField(importee, importer, result);
+        return result;
+      }
+    } else {
+      throw new Error(`failed to resolve package.json of ${importee} imported by ${importer}`);
     }
   }
 }
 function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || import_path5.default.isAbsolute(importee)) {
+  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || import_path5.default.isAbsolute(importee)) {
     return false;
   }
   const parts = importee.split("/");
@@ -1184,231 +1451,42 @@ function isBareImport(importee) {
   }
 }
 
-// src/utils/preprocess.ts
-var import_vite3 = __toModule(require("vite"));
-var import_magic_string2 = __toModule(require("magic-string"));
-var import_compiler3 = __toModule(require("svelte/compiler"));
-
-// src/utils/sourcemap.ts
-var import_magic_string = __toModule(require("magic-string"));
-async function buildMagicString(from, to, options) {
-  let diff_match_patch, DIFF_DELETE, DIFF_INSERT;
-  try {
-    const dmpPkg = await import("diff-match-patch");
-    diff_match_patch = dmpPkg.diff_match_patch;
-    DIFF_INSERT = dmpPkg.DIFF_INSERT;
-    DIFF_DELETE = dmpPkg.DIFF_DELETE;
-  } catch (e) {
-    log.error.once('Failed to import optional dependency "diff-match-patch". Please install it to enable generated sourcemaps.');
-    return null;
-  }
-  const dmp = new diff_match_patch();
-  const diffs = dmp.diff_main(from, to);
-  dmp.diff_cleanupSemantic(diffs);
-  const m = new import_magic_string.default(from, options);
-  let pos = 0;
-  for (let i = 0; i < diffs.length; i++) {
-    const diff = diffs[i];
-    const nextDiff = diffs[i + 1];
-    if (diff[0] === DIFF_DELETE) {
-      if ((nextDiff == null ? void 0 : nextDiff[0]) === DIFF_INSERT) {
-        m.overwrite(pos, pos + diff[1].length, nextDiff[1]);
-        i++;
-      } else {
-        m.remove(pos, pos + diff[1].length);
-      }
-      pos += diff[1].length;
-    } else if (diff[0] === DIFF_INSERT) {
-      if (nextDiff) {
-        m.appendRight(pos, diff[1]);
-      } else {
-        m.append(diff[1]);
-      }
-    } else {
-      pos += diff[1].length;
-    }
-  }
-  return m;
-}
-async function buildSourceMap(from, to, filename) {
-  const m = await buildMagicString(from, to, { filename });
-  return m ? m.generateDecodedMap({ source: filename, hires: true, includeContent: false }) : null;
-}
-
-// src/utils/preprocess.ts
-var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
-var supportedScriptLangs = ["ts"];
-function createViteScriptPreprocessor() {
-  return async ({ attributes, content, filename = "" }) => {
-    const lang = attributes.lang;
-    if (!supportedScriptLangs.includes(lang))
-      return;
-    const transformResult = await (0, import_vite3.transformWithEsbuild)(content, filename, {
-      loader: lang,
-      tsconfigRaw: {
-        compilerOptions: {
-          importsNotUsedAsValues: "preserve"
-        }
-      }
-    });
-    return {
-      code: transformResult.code,
-      map: transformResult.map
-    };
-  };
-}
-function createViteStylePreprocessor(config) {
-  const pluginName = "vite:css";
-  const plugin = config.plugins.find((p) => p.name === pluginName);
-  if (!plugin) {
-    throw new Error(`failed to find plugin ${pluginName}`);
-  }
-  if (!plugin.transform) {
-    throw new Error(`plugin ${pluginName} has no transform`);
-  }
-  const pluginTransform = plugin.transform.bind(null);
-  return async ({ attributes, content, filename = "" }) => {
-    var _a, _b;
-    const lang = attributes.lang;
-    if (!supportedStyleLangs.includes(lang))
-      return;
-    const moduleId = `${filename}.${lang}`;
-    const transformResult = await pluginTransform(content, moduleId);
-    const hasMap = transformResult.map && transformResult.map.mappings !== "";
-    if (hasMap && ((_b = (_a = transformResult.map) == null ? void 0 : _a.sources) == null ? void 0 : _b[0]) === moduleId) {
-      transformResult.map.sources[0] = filename;
-    }
-    return {
-      code: transformResult.code,
-      map: hasMap ? transformResult.map : void 0
-    };
-  };
-}
-function createVitePreprocessorGroup(config) {
-  return {
-    markup({ content, filename }) {
-      return (0, import_compiler3.preprocess)(content, {
-        script: createViteScriptPreprocessor(),
-        style: createViteStylePreprocessor(config)
-      }, { filename });
-    }
-  };
-}
-function createInjectScopeEverythingRulePreprocessorGroup() {
-  return {
-    style({ content, filename }) {
-      const s = new import_magic_string2.default(content);
-      s.append(" *{}");
-      return {
-        code: s.toString(),
-        map: s.generateDecodedMap({ source: filename, hires: true })
-      };
-    }
-  };
-}
-function buildExtraPreprocessors(options, config) {
-  var _a, _b;
-  const prependPreprocessors = [];
-  const appendPreprocessors = [];
-  if ((_a = options.experimental) == null ? void 0 : _a.useVitePreprocess) {
-    log.debug("adding vite preprocessor");
-    prependPreprocessors.push(createVitePreprocessorGroup(config));
-  }
-  const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p == null ? void 0 : p.sveltePreprocess);
-  if (pluginsWithPreprocessorsDeprecated.length > 0) {
-    log.warn(`The following plugins use the deprecated 'plugin.sveltePreprocess' field. Please contact their maintainers and ask them to move it to 'plugin.api.sveltePreprocess': ${pluginsWithPreprocessorsDeprecated.map((p) => p.name).join(", ")}`);
-    pluginsWithPreprocessorsDeprecated.forEach((p) => {
-      if (!p.api) {
-        p.api = {};
-      }
-      if (p.api.sveltePreprocess === void 0) {
-        p.api.sveltePreprocess = p.sveltePreprocess;
-      } else {
-        log.error(`ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`);
-      }
-    });
-  }
-  const pluginsWithPreprocessors = config.plugins.filter((p) => {
-    var _a2;
-    return (_a2 = p == null ? void 0 : p.api) == null ? void 0 : _a2.sveltePreprocess;
+// src/utils/optimizer.ts
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
+var import_vite4 = require("vite");
+var PREBUNDLE_SENSITIVE_OPTIONS = [
+  "compilerOptions",
+  "configFile",
+  "experimental",
+  "extensions",
+  "ignorePluginPreprocessors",
+  "preprocess"
+];
+async function handleOptimizeDeps(options, viteConfig) {
+  if (!options.experimental.prebundleSvelteLibraries || !viteConfig.cacheDir)
+    return;
+  const viteMetadataPath = import_path6.default.resolve(viteConfig.cacheDir, "_metadata.json");
+  if (!import_fs5.default.existsSync(viteMetadataPath))
+    return;
+  const svelteMetadataPath = import_path6.default.resolve(viteConfig.cacheDir, "_svelte_metadata.json");
+  const currentSvelteMetadata = JSON.stringify(generateSvelteMetadata(options), (_, value) => {
+    return typeof value === "function" ? value.toString() : value;
   });
-  const ignored = [], included = [];
-  for (const p of pluginsWithPreprocessors) {
-    if (options.ignorePluginPreprocessors === true || Array.isArray(options.ignorePluginPreprocessors) && ((_b = options.ignorePluginPreprocessors) == null ? void 0 : _b.includes(p.name))) {
-      ignored.push(p);
-    } else {
-      included.push(p);
-    }
-  }
-  if (ignored.length > 0) {
-    log.debug(`Ignoring svelte preprocessors defined by these vite plugins: ${ignored.map((p) => p.name).join(", ")}`);
-  }
-  if (included.length > 0) {
-    log.debug(`Adding svelte preprocessors defined by these vite plugins: ${included.map((p) => p.name).join(", ")}`);
-    appendPreprocessors.push(...pluginsWithPreprocessors.map((p) => p.api.sveltePreprocess));
-  }
-  if (options.hot && options.emitCss) {
-    appendPreprocessors.push(createInjectScopeEverythingRulePreprocessorGroup());
-  }
-  return { prependPreprocessors, appendPreprocessors };
-}
-function addExtraPreprocessors(options, config) {
-  var _a;
-  const { prependPreprocessors, appendPreprocessors } = buildExtraPreprocessors(options, config);
-  if (prependPreprocessors.length > 0 || appendPreprocessors.length > 0) {
-    if (!options.preprocess) {
-      options.preprocess = [...prependPreprocessors, ...appendPreprocessors];
-    } else if (Array.isArray(options.preprocess)) {
-      options.preprocess.unshift(...prependPreprocessors);
-      options.preprocess.push(...appendPreprocessors);
-    } else {
-      options.preprocess = [...prependPreprocessors, options.preprocess, ...appendPreprocessors];
-    }
-  }
-  const generateMissingSourceMaps = !!((_a = options.experimental) == null ? void 0 : _a.generateMissingPreprocessorSourcemaps);
-  if (options.preprocess && generateMissingSourceMaps) {
-    options.preprocess = Array.isArray(options.preprocess) ? options.preprocess.map((p, i) => validateSourceMapOutputWrapper(p, i)) : validateSourceMapOutputWrapper(options.preprocess, 0);
+  if (import_fs5.default.existsSync(svelteMetadataPath)) {
+    const existingSvelteMetadata = import_fs5.default.readFileSync(svelteMetadataPath, "utf8");
+    if (existingSvelteMetadata === currentSvelteMetadata)
+      return;
   }
+  await (0, import_vite4.optimizeDeps)(viteConfig, true);
+  import_fs5.default.writeFileSync(svelteMetadataPath, currentSvelteMetadata);
 }
-function validateSourceMapOutputWrapper(group, i) {
-  const wrapper = {};
-  for (const [processorType, processorFn] of Object.entries(group)) {
-    wrapper[processorType] = async (options) => {
-      var _a;
-      const result = await processorFn(options);
-      if (result && result.code !== options.content) {
-        let invalidMap = false;
-        if (!result.map) {
-          invalidMap = true;
-          log.warn.enabled && log.warn.once(`preprocessor at index ${i} did not return a sourcemap for ${processorType} transform`, {
-            filename: options.filename,
-            type: processorType,
-            processor: processorFn.toString()
-          });
-        } else if (((_a = result.map) == null ? void 0 : _a.mappings) === "") {
-          invalidMap = true;
-          log.warn.enabled && log.warn.once(`preprocessor at index ${i} returned an invalid empty sourcemap for ${processorType} transform`, {
-            filename: options.filename,
-            type: processorType,
-            processor: processorFn.toString()
-          });
-        }
-        if (invalidMap) {
-          try {
-            const map = await buildSourceMap(options.content, result.code, options.filename);
-            if (map) {
-              log.debug.enabled && log.debug(`adding generated sourcemap to preprocesor result for ${options.filename}`);
-              result.map = map;
-            }
-          } catch (e) {
-            log.error(`failed to build sourcemap`, e);
-          }
-        }
-      }
-      return result;
-    };
+function generateSvelteMetadata(options) {
+  const metadata = {};
+  for (const key of PREBUNDLE_SENSITIVE_OPTIONS) {
+    metadata[key] = options[key];
   }
-  return wrapper;
+  return metadata;
 }
 
 // src/index.ts
@@ -1418,7 +1496,7 @@ function svelte(inlineOptions) {
   }
   validateInlineOptions(inlineOptions);
   const cache = new VitePluginSvelteCache();
-  const pkg_export_errors = new Set();
+  const pkg_resolve_errors = /* @__PURE__ */ new Set();
   let requestParser;
   let options;
   let viteConfig;
@@ -1433,18 +1511,22 @@ function svelte(inlineOptions) {
       } else if (config.logLevel) {
         log.setLevel(config.logLevel);
       }
-      options = await resolveOptions(inlineOptions, config, configEnv);
+      options = await preResolveOptions(inlineOptions, config, configEnv);
       const extraViteConfig = buildExtraViteConfig(options, config, configEnv);
       log.debug("additional vite config", extraViteConfig);
       return extraViteConfig;
     },
     async configResolved(config) {
-      addExtraPreprocessors(options, 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);
@@ -1467,9 +1549,9 @@ function svelte(inlineOptions) {
         }
       }
     },
-    async resolveId(importee, importer, opts, _ssr) {
-      const ssr = _ssr === true || opts.ssr;
-      const svelteRequest = requestParser(importee, !!ssr);
+    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}`);
@@ -1491,27 +1573,19 @@ function svelte(inlineOptions) {
         return resolvedSvelteSSR;
       }
       try {
-        const resolved = resolveViaPackageJsonSvelte(importee, importer);
+        const resolved = resolveViaPackageJsonSvelte(importee, importer, cache);
         if (resolved) {
           log.debug(`resolveId resolved ${resolved} via package.json svelte field of ${importee}`);
           return resolved;
         }
       } catch (err) {
-        switch (err.code) {
-          case "ERR_PACKAGE_PATH_NOT_EXPORTED":
-            pkg_export_errors.add(importee);
-            return null;
-          case "MODULE_NOT_FOUND":
-            return null;
-          default:
-            throw err;
-        }
+        pkg_resolve_errors.add(importee);
       }
     },
     async transform(code, id, opts) {
       var _a;
-      const ssr = opts === true || (opts == null ? void 0 : opts.ssr);
-      const svelteRequest = requestParser(id, !!ssr);
+      const ssr = !!(opts == null ? void 0 : opts.ssr);
+      const svelteRequest = requestParser(id, ssr);
       if (!svelteRequest) {
         return;
       }
@@ -1553,14 +1627,17 @@ function svelte(inlineOptions) {
       }
     },
     buildEnd() {
-      if (pkg_export_errors.size > 0) {
-        log.warn(`The following packages did not export their \`package.json\` file so we could not check the "svelte" field. If you had difficulties importing svelte components from a package, then please contact the author and ask them to export the package.json file.`, Array.from(pkg_export_errors, (s) => `- ${s}`).join("\n"));
+      if (pkg_resolve_errors.size > 0) {
+        log.warn(`vite-plugin-svelte was unable to find package.json of the following packages and wasn't able to resolve via their "svelte" field.
+					If you had difficulties importing svelte components from a package, then please contact the author and ask them to export the package.json file.
+					${Array.from(pkg_resolve_errors, (s) => `- ${s}`).join("\n")}`.replace(/\t/g, ""));
       }
     }
   };
 }
+module.exports = __toCommonJS(src_exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   svelte
 });
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map