@sveltejs/vite-plugin-svelte 2.2.0 → 2.4.0

package/dist/index.js

@@ -1,2428 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw new Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/index.ts
-import fs8 from "fs";
-import { VERSION as svelteVersion } from "svelte/compiler";
-import {
-  version as viteVersion
-} from "vite";
-import { isDepExcluded as isDepExcluded2 } from "vitefu";
-
-// src/utils/log.ts
-import { cyan, yellow, red } from "kleur/colors";
-import debug from "debug";
-var levels = ["debug", "info", "warn", "error", "silent"];
-var prefix = "vite-plugin-svelte";
-var loggers = {
-  debug: {
-    log: debug(`vite:${prefix}`),
-    enabled: false,
-    isDebug: true
-  },
-  info: {
-    color: cyan,
-    log: console.log,
-    enabled: true
-  },
-  warn: {
-    color: yellow,
-    log: console.warn,
-    enabled: true
-  },
-  error: {
-    color: red,
-    log: console.error,
-    enabled: true
-  },
-  silent: {
-    enabled: false
-  }
-};
-var _level = "info";
-function setLevel(level) {
-  if (level === _level) {
-    return;
-  }
-  const levelIndex = levels.indexOf(level);
-  if (levelIndex > -1) {
-    _level = level;
-    for (let i = 0; i < levels.length; i++) {
-      loggers[levels[i]].enabled = i >= levelIndex;
-    }
-  } else {
-    _log(loggers.error, `invalid log level: ${level} `);
-  }
-}
-function _log(logger, message, payload, namespace) {
-  if (!logger.enabled) {
-    return;
-  }
-  if (logger.isDebug) {
-    const log2 = namespace ? logger.log.extend(namespace) : logger.log;
-    payload !== void 0 ? log2(message, payload) : log2(message);
-  } else {
-    logger.log(
-      logger.color(
-        `${(/* @__PURE__ */ new Date()).toLocaleTimeString()} [${prefix}${namespace ? `:${namespace}` : ""}] ${message}`
-      )
-    );
-    if (payload) {
-      logger.log(payload);
-    }
-  }
-}
-function createLogger(level) {
-  const logger = loggers[level];
-  const logFn = _log.bind(null, logger);
-  const logged = /* @__PURE__ */ new Set();
-  const once = function(message, payload, namespace) {
-    if (!logger.enabled || logged.has(message)) {
-      return;
-    }
-    logged.add(message);
-    logFn.apply(null, [message, payload, namespace]);
-  };
-  Object.defineProperty(logFn, "enabled", {
-    get() {
-      return logger.enabled;
-    }
-  });
-  Object.defineProperty(logFn, "once", {
-    get() {
-      return once;
-    }
-  });
-  return logFn;
-}
-var log = {
-  debug: createLogger("debug"),
-  info: createLogger("info"),
-  warn: createLogger("warn"),
-  error: createLogger("error"),
-  setLevel
-};
-function logCompilerWarnings(svelteRequest, warnings, options) {
-  const { emitCss, onwarn, isBuild } = options;
-  const sendViaWS = !isBuild && options.experimental?.sendWarningsToBrowser;
-  let warn = isBuild ? warnBuild : warnDev;
-  const handledByDefaultWarn = [];
-  const notIgnored = warnings?.filter((w) => !ignoreCompilerWarning(w, isBuild, emitCss));
-  const extra = buildExtraWarnings(warnings, isBuild);
-  const allWarnings = [...notIgnored, ...extra];
-  if (sendViaWS) {
-    const _warn = warn;
-    warn = (w) => {
-      handledByDefaultWarn.push(w);
-      _warn(w);
-    };
-  }
-  allWarnings.forEach((warning) => {
-    if (onwarn) {
-      onwarn(warning, warn);
-    } else {
-      warn(warning);
-    }
-  });
-  if (sendViaWS) {
-    const message = {
-      id: svelteRequest.id,
-      filename: svelteRequest.filename,
-      normalizedFilename: svelteRequest.normalizedFilename,
-      timestamp: svelteRequest.timestamp,
-      warnings: handledByDefaultWarn,
-      // allWarnings filtered by warnings where onwarn did not call the default handler
-      allWarnings,
-      // includes warnings filtered by onwarn and our extra vite plugin svelte warnings
-      rawWarnings: warnings
-      // raw compiler output
-    };
-    log.debug(`sending svelte:warnings message for ${svelteRequest.normalizedFilename}`);
-    options.server?.ws?.send("svelte:warnings", message);
-  }
-}
-function ignoreCompilerWarning(warning, isBuild, emitCss) {
-  return !emitCss && warning.code === "css-unused-selector" || // same as rollup-plugin-svelte
-  !isBuild && isNoScopableElementWarning(warning);
-}
-function isNoScopableElementWarning(warning) {
-  return warning.code === "css-unused-selector" && warning.message.includes('"*"');
-}
-function buildExtraWarnings(warnings, isBuild) {
-  const extraWarnings = [];
-  if (!isBuild) {
-    const noScopableElementWarnings = warnings.filter((w) => isNoScopableElementWarning(w));
-    if (noScopableElementWarnings.length > 0) {
-      const noScopableElementWarning = noScopableElementWarnings[noScopableElementWarnings.length - 1];
-      extraWarnings.push({
-        ...noScopableElementWarning,
-        code: "vite-plugin-svelte-css-no-scopable-elements",
-        message: `No scopable elements found in template. If you're using global styles in the style tag, you should move it into an external stylesheet file and import it in JS. See https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/faq.md#where-should-i-put-my-global-styles.`
-      });
-    }
-  }
-  return extraWarnings;
-}
-function warnDev(w) {
-  log.info.enabled && log.info(buildExtendedLogMessage(w));
-}
-function warnBuild(w) {
-  log.warn.enabled && log.warn(buildExtendedLogMessage(w), w.frame);
-}
-function buildExtendedLogMessage(w) {
-  const parts = [];
-  if (w.filename) {
-    parts.push(w.filename);
-  }
-  if (w.start) {
-    parts.push(":", w.start.line, ":", w.start.column);
-  }
-  if (w.message) {
-    if (parts.length > 0) {
-      parts.push(" ");
-    }
-    parts.push(w.message);
-  }
-  return parts.join("");
-}
-function isDebugNamespaceEnabled(namespace) {
-  return debug.enabled(`vite:${prefix}:${namespace}`);
-}
-
-// src/utils/error.ts
-function toRollupError(error, options) {
-  const { filename, frame, start, code, name, stack } = error;
-  const rollupError = {
-    name,
-    // needed otherwise sveltekit coalesce_to_error turns it into a string
-    id: filename,
-    message: buildExtendedLogMessage(error),
-    // include filename:line:column so that it's clickable
-    frame: formatFrameForVite(frame),
-    code,
-    stack: options.isBuild || options.isDebug || !frame ? stack : ""
-  };
-  if (start) {
-    rollupError.loc = {
-      line: start.line,
-      column: start.column,
-      file: filename
-    };
-  }
-  return rollupError;
-}
-function toESBuildError(error, options) {
-  const { filename, frame, start, stack } = error;
-  const partialMessage = {
-    text: buildExtendedLogMessage(error)
-  };
-  if (start) {
-    partialMessage.location = {
-      line: start.line,
-      column: start.column,
-      file: filename,
-      lineText: lineFromFrame(start.line, frame)
-      // needed to get a meaningful error message on cli
-    };
-  }
-  if (options.isBuild || options.isDebug || !frame) {
-    partialMessage.detail = stack;
-  }
-  return partialMessage;
-}
-function lineFromFrame(lineNo, frame) {
-  if (!frame) {
-    return "";
-  }
-  const lines = frame.split("\n");
-  const errorLine = lines.find((line) => line.trimStart().startsWith(`${lineNo}: `));
-  return errorLine ? errorLine.substring(errorLine.indexOf(": ") + 3) : "";
-}
-function formatFrameForVite(frame) {
-  if (!frame) {
-    return "";
-  }
-  return frame.split("\n").map((line) => line.match(/^\s+\^/) ? "   " + line : " " + line.replace(":", " | ")).join("\n");
-}
-
-// src/handle-hot-update.ts
-async function handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, options) {
-  if (!cache.has(svelteRequest)) {
-    log.debug(`handleHotUpdate called before initial transform for ${svelteRequest.id}`);
-    return;
-  }
-  const { read, server, modules } = ctx;
-  const cachedJS = cache.getJS(svelteRequest);
-  const cachedCss = cache.getCSS(svelteRequest);
-  const content = await read();
-  let compileData;
-  try {
-    compileData = await compileSvelte2(svelteRequest, content, options);
-    cache.update(compileData);
-  } catch (e) {
-    cache.setError(svelteRequest, e);
-    throw toRollupError(e, options);
-  }
-  const affectedModules = [...modules];
-  const cssIdx = modules.findIndex((m) => m.id === svelteRequest.cssId);
-  if (cssIdx > -1) {
-    const cssUpdated = cssChanged(cachedCss, compileData.compiled.css);
-    if (!cssUpdated) {
-      log.debug(`skipping unchanged css for ${svelteRequest.cssId}`);
-      affectedModules.splice(cssIdx, 1);
-    }
-  }
-  const jsIdx = modules.findIndex((m) => m.id === svelteRequest.id);
-  if (jsIdx > -1) {
-    const jsUpdated = jsChanged(cachedJS, compileData.compiled.js, svelteRequest.filename);
-    if (!jsUpdated) {
-      log.debug(`skipping unchanged js for ${svelteRequest.id}`);
-      affectedModules.splice(jsIdx, 1);
-      logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
-    }
-  }
-  const ssrModulesToInvalidate = affectedModules.filter((m) => !!m.ssrTransformResult);
-  if (ssrModulesToInvalidate.length > 0) {
-    log.debug(`invalidating modules ${ssrModulesToInvalidate.map((m) => m.id).join(", ")}`);
-    ssrModulesToInvalidate.forEach((moduleNode) => server.moduleGraph.invalidateModule(moduleNode));
-  }
-  if (affectedModules.length > 0) {
-    log.debug(
-      `handleHotUpdate for ${svelteRequest.id} result: ${affectedModules.map((m) => m.id).join(", ")}`
-    );
-  }
-  return affectedModules;
-}
-function cssChanged(prev, next) {
-  return !isCodeEqual(prev?.code, next?.code);
-}
-function jsChanged(prev, next, filename) {
-  const prevJs = prev?.code;
-  const nextJs = next?.code;
-  const isStrictEqual = isCodeEqual(prevJs, nextJs);
-  if (isStrictEqual) {
-    return false;
-  }
-  const isLooseEqual = isCodeEqual(normalizeJsCode(prevJs), normalizeJsCode(nextJs));
-  if (!isStrictEqual && isLooseEqual) {
-    log.warn(
-      `ignoring compiler output js change for ${filename} as it is equal to previous output after normalization`
-    );
-  }
-  return !isLooseEqual;
-}
-function isCodeEqual(prev, next) {
-  if (!prev && !next) {
-    return true;
-  }
-  if (!prev && next || prev && !next) {
-    return false;
-  }
-  return prev === next;
-}
-function normalizeJsCode(code) {
-  if (!code) {
-    return code;
-  }
-  return code.replace(/\s*\badd_location\s*\([^)]*\)\s*;?/g, "");
-}
-
-// src/utils/compile.ts
-import { compile, preprocess, walk } from "svelte/compiler";
-import { createMakeHot } from "svelte-hmr";
-
-// src/utils/hash.ts
-import * as crypto from "crypto";
-var hashes = /* @__PURE__ */ Object.create(null);
-var hash_length = 12;
-function safeBase64Hash(input) {
-  if (hashes[input]) {
-    return hashes[input];
-  }
-  const md5 = crypto.createHash("md5");
-  md5.update(input);
-  const hash = toSafe(md5.digest("base64")).slice(0, hash_length);
-  hashes[input] = hash;
-  return hash;
-}
-var replacements = {
-  "+": "-",
-  "/": "_",
-  "=": ""
-};
-var replaceRE = new RegExp(`[${Object.keys(replacements).join("")}]`, "g");
-function toSafe(base64) {
-  return base64.replace(replaceRE, (x) => replacements[x]);
-}
-
-// src/utils/preprocess.ts
-import MagicString from "magic-string";
-import path from "path";
-function createInjectScopeEverythingRulePreprocessorGroup() {
-  return {
-    style({ content, filename }) {
-      const s = new MagicString(content);
-      s.append(" *{}");
-      return {
-        code: s.toString(),
-        map: s.generateDecodedMap({
-          source: filename ? path.basename(filename) : void 0,
-          hires: true
-        })
-      };
-    }
-  };
-}
-function buildExtraPreprocessors(options, config) {
-  const prependPreprocessors = [];
-  const appendPreprocessors = [];
-  const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => 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) => p?.api?.sveltePreprocess);
-  const ignored = [], included = [];
-  for (const p of pluginsWithPreprocessors) {
-    if (options.ignorePluginPreprocessors === true || Array.isArray(options.ignorePluginPreprocessors) && options.ignorePluginPreprocessors?.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));
-  }
-  return { prependPreprocessors, appendPreprocessors };
-}
-function addExtraPreprocessors(options, config) {
-  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];
-    }
-  }
-}
-
-// src/utils/sourcemaps.ts
-import path2 from "path";
-var IS_WINDOWS = process.platform === "win32";
-function mapToRelative(map, filename) {
-  if (!map) {
-    return;
-  }
-  const sourceRoot = map.sourceRoot;
-  const dirname2 = path2.dirname(filename);
-  const toRelative = (s) => {
-    if (!s) {
-      return s;
-    }
-    let sourcePath;
-    if (s.startsWith("file:///")) {
-      sourcePath = s.slice(IS_WINDOWS ? 8 : 7);
-    } else if (sourceRoot) {
-      const sep = sourceRoot[sourceRoot.length - 1] === "/" || s[0] === "/" ? "" : "/";
-      sourcePath = `${sourceRoot}${sep}${s}`;
-    } else {
-      sourcePath = s;
-    }
-    return path2.isAbsolute(sourcePath) ? path2.relative(dirname2, sourcePath) : sourcePath;
-  };
-  if (map.file) {
-    map.file = path2.basename(filename);
-  }
-  if (map.sources) {
-    map.sources = map.sources.map(toRelative);
-  }
-  if (map.sourceRoot) {
-    delete map.sourceRoot;
-  }
-}
-function removeLangSuffix(map, suffix) {
-  if (!map) {
-    return;
-  }
-  const removeSuffix = (s) => s?.endsWith(suffix) ? s.slice(0, -1 * suffix.length) : s;
-  if (map.file) {
-    map.file = removeSuffix(map.file);
-  }
-  if (map.sources) {
-    map.sources = map.sources.map(removeSuffix);
-  }
-}
-
-// src/utils/compile.ts
-var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
-var _createCompileSvelte = (makeHot) => {
-  let stats;
-  const devStylePreprocessor = createInjectScopeEverythingRulePreprocessorGroup();
-  return async function compileSvelte2(svelteRequest, code, options) {
-    const { filename, normalizedFilename, cssId, ssr, raw } = 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;
-        }
-      }
-    }
-    const compileOptions = {
-      ...options.compilerOptions,
-      filename: normalizedFilename,
-      // use normalized here to avoid bleeding absolute fs path
-      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 };
-      }
-    }
-    let preprocessed;
-    let preprocessors = options.preprocess;
-    if (!options.isBuild && options.emitCss && options.hot) {
-      if (!Array.isArray(preprocessors)) {
-        preprocessors = preprocessors ? [preprocessors, devStylePreprocessor] : [devStylePreprocessor];
-      } else {
-        preprocessors = preprocessors.concat(devStylePreprocessor);
-      }
-    }
-    if (preprocessors) {
-      try {
-        preprocessed = await preprocess(code, preprocessors, { 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;
-    }
-    if (typeof preprocessed?.map === "object") {
-      mapToRelative(preprocessed?.map, filename);
-    }
-    if (raw && svelteRequest.query.type === "preprocessed") {
-      return { preprocessed: preprocessed ?? { code } };
-    }
-    const finalCode = preprocessed ? preprocessed.code : code;
-    const dynamicCompileOptions = await options.experimental?.dynamicCompileOptions?.({
-      filename,
-      code: finalCode,
-      compileOptions
-    });
-    if (dynamicCompileOptions && log.debug.enabled) {
-      log.debug(
-        `dynamic compile options for  ${filename}: ${JSON.stringify(dynamicCompileOptions)}`
-      );
-    }
-    const finalCompileOptions = dynamicCompileOptions ? {
-      ...compileOptions,
-      ...dynamicCompileOptions
-    } : compileOptions;
-    const endStat = stats?.start(filename);
-    const compiled = compile(finalCode, finalCompileOptions);
-    compiled.js.code = compiled.js.code.replace(
-      /\/\* [@#]__PURE__ \*\/(\s*)$/gm,
-      "               $1"
-    );
-    if (endStat) {
-      endStat();
-    }
-    mapToRelative(compiled.js?.map, filename);
-    mapToRelative(compiled.css?.map, filename);
-    if (!raw) {
-      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,
-          //@ts-expect-error hot isn't a boolean at this point
-          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",
-      // @ts-ignore
-      compiled,
-      ssr,
-      dependencies,
-      preprocessed: preprocessed ?? { code }
-    };
-  };
-};
-function buildMakeHot(options) {
-  const needsMakeHot = options.hot !== false && options.isServe && !options.isProduction;
-  if (needsMakeHot) {
-    const hotApi = options?.hot?.hotApi;
-    const adapter = options?.hot?.adapter;
-    return createMakeHot({
-      walk,
-      hotApi,
-      adapter,
-      hotOptions: { noOverlay: true, ...options.hot }
-    });
-  }
-}
-function createCompileSvelte(options) {
-  const makeHot = buildMakeHot(options);
-  return _createCompileSvelte(makeHot);
-}
-
-// src/utils/id.ts
-import { createFilter } from "vite";
-import { normalizePath } from "vite";
-import * as fs from "fs";
-var VITE_FS_PREFIX = "/@fs/";
-var IS_WINDOWS2 = process.platform === "win32";
-var SUPPORTED_COMPILER_OPTIONS = [
-  "generate",
-  "dev",
-  "css",
-  "hydratable",
-  "customElement",
-  "immutable",
-  "enableSourcemap"
-];
-var TYPES_WITH_COMPILER_OPTIONS = ["style", "script", "all"];
-function splitId(id) {
-  const parts = id.split(`?`, 2);
-  const filename = parts[0];
-  const rawQuery = parts[1];
-  return { filename, rawQuery };
-}
-function parseToSvelteRequest(id, filename, rawQuery, root, timestamp, ssr) {
-  const query = parseRequestQuery(rawQuery);
-  const rawOrDirect = !!(query.raw || query.direct);
-  if (query.url || !query.svelte && rawOrDirect) {
-    return;
-  }
-  const raw = rawOrDirect;
-  const normalizedFilename = normalize(filename, root);
-  const cssId = createVirtualImportId(filename, root, "style");
-  return {
-    id,
-    filename,
-    normalizedFilename,
-    cssId,
-    query,
-    timestamp,
-    ssr,
-    raw
-  };
-}
-function createVirtualImportId(filename, root, type) {
-  const parts = ["svelte", `type=${type}`];
-  if (type === "style") {
-    parts.push("lang.css");
-  }
-  if (existsInRoot(filename, root)) {
-    filename = root + filename;
-  } else if (filename.startsWith(VITE_FS_PREFIX)) {
-    filename = IS_WINDOWS2 ? filename.slice(VITE_FS_PREFIX.length) : filename.slice(VITE_FS_PREFIX.length - 1);
-  }
-  return `${filename}?${parts.join("&")}`;
-}
-function parseRequestQuery(rawQuery) {
-  const query = Object.fromEntries(new URLSearchParams(rawQuery));
-  for (const key in query) {
-    if (query[key] === "") {
-      query[key] = true;
-    }
-  }
-  const compilerOptions = query.compilerOptions;
-  if (compilerOptions) {
-    if (!((query.raw || query.direct) && TYPES_WITH_COMPILER_OPTIONS.includes(query.type))) {
-      throw new Error(
-        `Invalid compilerOptions in query ${rawQuery}. CompilerOptions are only supported for raw or direct queries with type in "${TYPES_WITH_COMPILER_OPTIONS.join(
-          ", "
-        )}" e.g. '?svelte&raw&type=script&compilerOptions={"generate":"ssr","dev":false}`
-      );
-    }
-    try {
-      const parsed = JSON.parse(compilerOptions);
-      const invalid = Object.keys(parsed).filter(
-        (key) => !SUPPORTED_COMPILER_OPTIONS.includes(key)
-      );
-      if (invalid.length) {
-        throw new Error(
-          `Invalid compilerOptions in query ${rawQuery}: ${invalid.join(
-            ", "
-          )}. Supported: ${SUPPORTED_COMPILER_OPTIONS.join(", ")}`
-        );
-      }
-      query.compilerOptions = parsed;
-    } catch (e) {
-      log.error("failed to parse request query compilerOptions", e);
-      throw e;
-    }
-  }
-  return query;
-}
-function normalize(filename, normalizedRoot) {
-  return stripRoot(normalizePath(filename), normalizedRoot);
-}
-function existsInRoot(filename, root) {
-  if (filename.startsWith(VITE_FS_PREFIX)) {
-    return false;
-  }
-  return fs.existsSync(root + filename);
-}
-function stripRoot(normalizedFilename, normalizedRoot) {
-  return normalizedFilename.startsWith(normalizedRoot + "/") ? normalizedFilename.slice(normalizedRoot.length) : normalizedFilename;
-}
-function buildFilter(include, exclude, extensions) {
-  const rollupFilter = createFilter(include, exclude);
-  return (filename) => rollupFilter(filename) && extensions.some((ext) => filename.endsWith(ext));
-}
-function buildIdParser(options) {
-  const { include, exclude, extensions, root } = options;
-  const normalizedRoot = normalizePath(root);
-  const filter = buildFilter(include, exclude, extensions);
-  return (id, ssr, timestamp = Date.now()) => {
-    const { filename, rawQuery } = splitId(id);
-    if (filter(filename)) {
-      return parseToSvelteRequest(id, filename, rawQuery, normalizedRoot, timestamp, ssr);
-    }
-  };
-}
-
-// src/utils/options.ts
-import { normalizePath as normalizePath3 } from "vite";
-
-// src/utils/load-svelte-config.ts
-import { createRequire } from "module";
-import path3 from "path";
-import fs2 from "fs";
-import { pathToFileURL } from "url";
-var esmRequire;
-var knownSvelteConfigNames = [
-  "svelte.config.js",
-  "svelte.config.cjs",
-  "svelte.config.mjs"
-];
-var dynamicImportDefault = new Function(
-  "path",
-  "timestamp",
-  'return import(path + "?t=" + timestamp).then(m => m.default)'
-);
-async function loadSvelteConfig(viteConfig, inlineOptions) {
-  if (inlineOptions?.configFile === false) {
-    return;
-  }
-  const configFile = findConfigToLoad(viteConfig, inlineOptions);
-  if (configFile) {
-    let err;
-    if (configFile.endsWith(".js") || configFile.endsWith(".mjs")) {
-      try {
-        const result = await dynamicImportDefault(
-          pathToFileURL(configFile).href,
-          fs2.statSync(configFile).mtimeMs
-        );
-        if (result != null) {
-          return {
-            ...result,
-            configFile
-          };
-        } else {
-          throw new Error(`invalid export in ${configFile}`);
-        }
-      } catch (e) {
-        log.error(`failed to import config ${configFile}`, e);
-        err = e;
-      }
-    }
-    if (!configFile.endsWith(".mjs")) {
-      try {
-        const _require = import.meta.url ? esmRequire ?? (esmRequire = createRequire(import.meta.url)) : __require;
-        delete _require.cache[_require.resolve(configFile)];
-        const result = _require(configFile);
-        if (result != null) {
-          return {
-            ...result,
-            configFile
-          };
-        } else {
-          throw new Error(`invalid export in ${configFile}`);
-        }
-      } catch (e) {
-        log.error(`failed to require config ${configFile}`, e);
-        if (!err) {
-          err = e;
-        }
-      }
-    }
-    throw err;
-  }
-}
-function findConfigToLoad(viteConfig, inlineOptions) {
-  const root = viteConfig?.root || process.cwd();
-  if (inlineOptions?.configFile) {
-    const abolutePath = path3.isAbsolute(inlineOptions.configFile) ? inlineOptions.configFile : path3.resolve(root, inlineOptions.configFile);
-    if (!fs2.existsSync(abolutePath)) {
-      throw new Error(`failed to find svelte config file ${abolutePath}.`);
-    }
-    return abolutePath;
-  } else {
-    const existingKnownConfigFiles = knownSvelteConfigNames.map((candidate) => path3.resolve(root, candidate)).filter((file) => fs2.existsSync(file));
-    if (existingKnownConfigFiles.length === 0) {
-      log.debug(`no svelte config found at ${root}`);
-      return;
-    } else if (existingKnownConfigFiles.length > 1) {
-      log.warn(
-        `found more than one svelte config file, using ${existingKnownConfigFiles[0]}. you should only have one!`,
-        existingKnownConfigFiles
-      );
-    }
-    return existingKnownConfigFiles[0];
-  }
-}
-
-// src/utils/constants.ts
-var VITE_RESOLVE_MAIN_FIELDS = ["module", "jsnext:main", "jsnext"];
-var SVELTE_RESOLVE_MAIN_FIELDS = ["svelte"];
-var SVELTE_IMPORTS = [
-  "svelte/animate",
-  "svelte/easing",
-  "svelte/internal",
-  "svelte/motion",
-  "svelte/ssr",
-  "svelte/store",
-  "svelte/transition",
-  "svelte"
-];
-var SVELTE_HMR_IMPORTS = [
-  "svelte-hmr/runtime/hot-api-esm.js",
-  "svelte-hmr/runtime/proxy-adapter-dom.js",
-  "svelte-hmr"
-];
-var SVELTE_EXPORT_CONDITIONS = ["svelte"];
-var FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE = "https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/faq.md#conflicts-in-svelte-resolve";
-
-// src/utils/options.ts
-import path5 from "path";
-
-// src/utils/esbuild.ts
-import { readFileSync } from "fs";
-import { compile as compile2, preprocess as preprocess2 } from "svelte/compiler";
-var facadeEsbuildSveltePluginName = "vite-plugin-svelte:facade";
-function esbuildSveltePlugin(options) {
-  return {
-    name: "vite-plugin-svelte:optimize-svelte",
-    setup(build) {
-      if (build.initialOptions.plugins?.some((v) => v.name === "vite:dep-scan"))
-        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 = readFileSync(filename, "utf8");
-        try {
-          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 }, statsCollection) {
-  let css = options.compilerOptions.css;
-  if (css !== "none") {
-    css = "injected";
-  }
-  const compileOptions = {
-    ...options.compilerOptions,
-    css,
-    filename,
-    format: "esm",
-    generate: "dom"
-  };
-  let preprocessed;
-  if (options.preprocess) {
-    try {
-      preprocessed = await preprocess2(code, options.preprocess, { filename });
-    } catch (e) {
-      e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
-      throw e;
-    }
-    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 = statsCollection?.start(filename);
-  const compiled = compile2(finalCode, finalCompileOptions);
-  if (endStat) {
-    endStat();
-  }
-  return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
-}
-
-// src/utils/options.ts
-import deepmerge from "deepmerge";
-import {
-  crawlFrameworkPkgs,
-  isDepExcluded,
-  isDepExternaled,
-  isDepIncluded,
-  isDepNoExternaled
-} from "vitefu";
-
-// src/utils/dependencies.ts
-import path4 from "path";
-import fs3 from "fs/promises";
-import { findDepPkgJsonPath } from "vitefu";
-async function resolveDependencyData(dep, parent) {
-  const depDataPath = await findDepPkgJsonPath(dep, parent);
-  if (!depDataPath)
-    return void 0;
-  try {
-    return {
-      dir: path4.dirname(depDataPath),
-      pkg: JSON.parse(await fs3.readFile(depDataPath, "utf-8"))
-    };
-  } catch {
-    return void 0;
-  }
-}
-var COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD = [
-  "@lukeed/uuid",
-  "@playwright/test",
-  "@sveltejs/vite-plugin-svelte",
-  "@sveltejs/kit",
-  "autoprefixer",
-  "cookie",
-  "dotenv",
-  "esbuild",
-  "eslint",
-  "jest",
-  "mdsvex",
-  "playwright",
-  "postcss",
-  "prettier",
-  "svelte",
-  "svelte-check",
-  "svelte-hmr",
-  "svelte-preprocess",
-  "tslib",
-  "typescript",
-  "vite",
-  "vitest",
-  "__vite-browser-external"
-  // see https://github.com/sveltejs/vite-plugin-svelte/issues/362
-];
-var COMMON_PREFIXES_WITHOUT_SVELTE_FIELD = [
-  "@fontsource/",
-  "@postcss-plugins/",
-  "@rollup/",
-  "@sveltejs/adapter-",
-  "@types/",
-  "@typescript-eslint/",
-  "eslint-",
-  "jest-",
-  "postcss-plugin-",
-  "prettier-plugin-",
-  "rollup-plugin-",
-  "vite-plugin-"
-];
-function isCommonDepWithoutSvelteField(dependency) {
-  return COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD.includes(dependency) || COMMON_PREFIXES_WITHOUT_SVELTE_FIELD.some(
-    (prefix2) => prefix2.startsWith("@") ? dependency.startsWith(prefix2) : dependency.substring(dependency.lastIndexOf("/") + 1).startsWith(prefix2)
-    // check prefix omitting @scope/
-  );
-}
-
-// src/utils/vite-plugin-svelte-stats.ts
-import { performance } from "perf_hooks";
-import { normalizePath as normalizePath2 } from "vite";
-var defaultCollectionOptions = {
-  // log after 500ms and more than one file processed
-  logInProgress: (c, now) => now - c.collectionStart > 500 && c.stats.length > 1,
-  // always log results
-  logResult: () => true
-};
-function humanDuration(n) {
-  return n < 100 ? `${n.toFixed(1)}ms` : `${(n / 1e3).toFixed(2)}s`;
-}
-function formatPackageStats(pkgStats) {
-  const statLines = pkgStats.map((pkgStat) => {
-    const duration = pkgStat.duration;
-    const avg = duration / pkgStat.files;
-    return [pkgStat.pkg, `${pkgStat.files}`, humanDuration(duration), humanDuration(avg)];
-  });
-  statLines.unshift(["package", "files", "time", "avg"]);
-  const columnWidths = statLines.reduce(
-    (widths, row) => {
-      for (let i = 0; i < row.length; i++) {
-        const cell = row[i];
-        if (widths[i] < cell.length) {
-          widths[i] = cell.length;
-        }
-      }
-      return widths;
-    },
-    statLines[0].map(() => 0)
-  );
-  const table = statLines.map(
-    (row) => row.map((cell, i) => {
-      if (i === 0) {
-        return cell.padEnd(columnWidths[i], " ");
-      } else {
-        return cell.padStart(columnWidths[i], " ");
-      }
-    }).join("	")
-  ).join("\n");
-  return table;
-}
-var VitePluginSvelteStats = class {
-  constructor(cache) {
-    this._collections = [];
-    this._cache = cache;
-  }
-  startCollection(name, opts) {
-    const options = {
-      ...defaultCollectionOptions,
-      ...opts
-    };
-    const stats = [];
-    const collectionStart = performance.now();
-    const _this = this;
-    let hasLoggedProgress = false;
-    const collection = {
-      name,
-      options,
-      stats,
-      collectionStart,
-      finished: false,
-      start(file) {
-        if (collection.finished) {
-          throw new Error("called after finish() has been used");
-        }
-        file = normalizePath2(file);
-        const start = performance.now();
-        const stat = { file, start, end: start };
-        return () => {
-          const now = performance.now();
-          stat.end = now;
-          stats.push(stat);
-          if (!hasLoggedProgress && options.logInProgress(collection, now)) {
-            hasLoggedProgress = true;
-            log.debug(`${name} in progress ...`, void 0, "stats");
-          }
-        };
-      },
-      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 = performance.now();
-      collection.duration = now - collection.collectionStart;
-      const logResult = collection.options.logResult(collection);
-      if (logResult) {
-        await this._aggregateStatsResult(collection);
-        log.debug(
-          `${collection.name} done.
-${formatPackageStats(collection.packageStats)}`,
-          void 0,
-          "stats"
-        );
-      }
-      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, "stats");
-    }
-  }
-  async _aggregateStatsResult(collection) {
-    const stats = collection.stats;
-    for (const stat of stats) {
-      stat.pkg = (await this._cache.getPackageInfo(stat.file)).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 allowedPluginOptions = /* @__PURE__ */ new Set([
-  "include",
-  "exclude",
-  "emitCss",
-  "hot",
-  "ignorePluginPreprocessors",
-  "disableDependencyReinclusion",
-  "prebundleSvelteLibraries",
-  "inspector",
-  "experimental"
-]);
-var knownRootOptions = /* @__PURE__ */ new Set(["extensions", "compilerOptions", "preprocess", "onwarn"]);
-var allowedInlineOptions = /* @__PURE__ */ new Set(["configFile", ...allowedPluginOptions, ...knownRootOptions]);
-function validateInlineOptions(inlineOptions) {
-  const invalidKeys = Object.keys(inlineOptions || {}).filter(
-    (key) => !allowedInlineOptions.has(key)
-  );
-  if (invalidKeys.length) {
-    log.warn(`invalid plugin options "${invalidKeys.join(", ")}" in inline config`, inlineOptions);
-  }
-}
-function convertPluginOptions(config) {
-  if (!config) {
-    return;
-  }
-  const invalidRootOptions = Object.keys(config).filter((key) => allowedPluginOptions.has(key));
-  if (invalidRootOptions.length > 0) {
-    throw new Error(
-      `Invalid options in svelte config. Move the following options into 'vitePlugin:{...}': ${invalidRootOptions.join(
-        ", "
-      )}`
-    );
-  }
-  if (!config.vitePlugin) {
-    return config;
-  }
-  const pluginOptions = config.vitePlugin;
-  const pluginOptionKeys = Object.keys(pluginOptions);
-  const rootOptionsInPluginOptions = pluginOptionKeys.filter((key) => knownRootOptions.has(key));
-  if (rootOptionsInPluginOptions.length > 0) {
-    throw new Error(
-      `Invalid options in svelte config under vitePlugin:{...}', move them to the config root : ${rootOptionsInPluginOptions.join(
-        ", "
-      )}`
-    );
-  }
-  const duplicateOptions = pluginOptionKeys.filter(
-    (key) => Object.prototype.hasOwnProperty.call(config, key)
-  );
-  if (duplicateOptions.length > 0) {
-    throw new Error(
-      `Invalid duplicate options in svelte config under vitePlugin:{...}', they are defined in root too and must only exist once: ${duplicateOptions.join(
-        ", "
-      )}`
-    );
-  }
-  const unknownPluginOptions = pluginOptionKeys.filter((key) => !allowedPluginOptions.has(key));
-  if (unknownPluginOptions.length > 0) {
-    log.warn(
-      `ignoring unknown plugin options in svelte config under vitePlugin:{...}: ${unknownPluginOptions.join(
-        ", "
-      )}`
-    );
-    unknownPluginOptions.forEach((unkownOption) => {
-      delete pluginOptions[unkownOption];
-    });
-  }
-  const result = {
-    ...config,
-    ...pluginOptions
-  };
-  delete result.vitePlugin;
-  return result;
-}
-async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
-  const viteConfigWithResolvedRoot = {
-    ...viteUserConfig,
-    root: resolveViteRoot(viteUserConfig)
-  };
-  const isBuild = viteEnv.command === "build";
-  const defaultOptions = {
-    extensions: [".svelte"],
-    emitCss: true,
-    prebundleSvelteLibraries: !isBuild
-  };
-  const svelteConfig = convertPluginOptions(
-    await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions)
-  );
-  const extraOptions = {
-    root: viteConfigWithResolvedRoot.root,
-    isBuild,
-    isServe: viteEnv.command === "serve",
-    isDebug: process.env.DEBUG != null
-  };
-  const merged = mergeConfigs(
-    defaultOptions,
-    svelteConfig,
-    inlineOptions,
-    extraOptions
-  );
-  if (svelteConfig?.configFile) {
-    merged.configFile = svelteConfig.configFile;
-  }
-  return merged;
-}
-function mergeConfigs(...configs) {
-  let result = {};
-  for (const config of configs.filter((x) => x != null)) {
-    result = deepmerge(result, config, {
-      // replace arrays
-      arrayMerge: (target, source) => source ?? target
-    });
-  }
-  return result;
-}
-function resolveOptions(preResolveOptions2, viteConfig, cache) {
-  const css = preResolveOptions2.emitCss ? "external" : "injected";
-  const defaultOptions = {
-    hot: viteConfig.isProduction ? false : {
-      injectCss: css === "injected",
-      partialAccept: !!viteConfig.experimental?.hmrPartialAccept
-    },
-    compilerOptions: {
-      css,
-      dev: !viteConfig.isProduction
-    }
-  };
-  const extraOptions = {
-    root: viteConfig.root,
-    isProduction: viteConfig.isProduction
-  };
-  const merged = mergeConfigs(defaultOptions, preResolveOptions2, extraOptions);
-  removeIgnoredOptions(merged);
-  handleDeprecatedOptions(merged);
-  addExtraPreprocessors(merged, viteConfig);
-  enforceOptionsForHmr(merged);
-  enforceOptionsForProduction(merged);
-  if (log.debug.enabled && isDebugNamespaceEnabled("stats")) {
-    merged.stats = new VitePluginSvelteStats(cache);
-  }
-  return merged;
-}
-function enforceOptionsForHmr(options) {
-  if (options.hot) {
-    if (!options.compilerOptions.dev) {
-      log.warn("hmr is enabled but compilerOptions.dev is false, forcing it to true");
-      options.compilerOptions.dev = true;
-    }
-    if (options.emitCss) {
-      if (options.hot !== true && options.hot.injectCss) {
-        log.warn("hmr and emitCss are enabled but hot.injectCss is true, forcing it to false");
-        options.hot.injectCss = false;
-      }
-      const css = options.compilerOptions.css;
-      if (css === true || css === "injected") {
-        const forcedCss = "external";
-        log.warn(
-          `hmr and emitCss are enabled but compilerOptions.css is ${css}, forcing it to ${forcedCss}`
-        );
-        options.compilerOptions.css = forcedCss;
-      }
-    } else {
-      if (options.hot === true || !options.hot.injectCss) {
-        log.warn(
-          "hmr with emitCss disabled requires option hot.injectCss to be enabled, forcing it to true"
-        );
-        if (options.hot === true) {
-          options.hot = { injectCss: true };
-        } else {
-          options.hot.injectCss = true;
-        }
-      }
-      const css = options.compilerOptions.css;
-      if (!(css === true || css === "injected")) {
-        const forcedCss = "injected";
-        log.warn(
-          `hmr with emitCss disabled requires compilerOptions.css to be enabled, forcing it to ${forcedCss}`
-        );
-        options.compilerOptions.css = forcedCss;
-      }
-    }
-  }
-}
-function enforceOptionsForProduction(options) {
-  if (options.isProduction) {
-    if (options.hot) {
-      log.warn("options.hot is enabled but does not work on production build, forcing it to false");
-      options.hot = false;
-    }
-    if (options.compilerOptions.dev) {
-      log.warn(
-        "you are building for production but compilerOptions.dev is true, forcing it to false"
-      );
-      options.compilerOptions.dev = false;
-    }
-  }
-}
-function removeIgnoredOptions(options) {
-  const ignoredCompilerOptions = ["generate", "format", "filename"];
-  if (options.hot && options.emitCss) {
-    ignoredCompilerOptions.push("cssHash");
-  }
-  const passedCompilerOptions = Object.keys(options.compilerOptions || {});
-  const passedIgnored = passedCompilerOptions.filter((o) => ignoredCompilerOptions.includes(o));
-  if (passedIgnored.length) {
-    log.warn(
-      `The following Svelte compilerOptions are controlled by vite-plugin-svelte and essential to its functionality. User-specified values are ignored. Please remove them from your configuration: ${passedIgnored.join(
-        ", "
-      )}`
-    );
-    passedIgnored.forEach((ignored) => {
-      delete options.compilerOptions[ignored];
-    });
-  }
-}
-function handleDeprecatedOptions(options) {
-  const experimental = options.experimental;
-  if (experimental) {
-    for (const promoted of ["prebundleSvelteLibraries", "inspector"]) {
-      if (experimental[promoted]) {
-        options[promoted] = experimental[promoted];
-        delete experimental[promoted];
-        log.warn(
-          `Option "vitePlugin.experimental.${promoted}" is no longer experimental and has moved to "vitePlugin.${promoted}". Please update your svelte config.`
-        );
-      }
-    }
-    if (experimental.generateMissingPreprocessorSourcemaps) {
-      log.warn("experimental.generateMissingPreprocessorSourcemaps has been removed.");
-    }
-  }
-}
-function resolveViteRoot(viteConfig) {
-  return normalizePath3(viteConfig.root ? path5.resolve(viteConfig.root) : process.cwd());
-}
-async function buildExtraViteConfig(options, config) {
-  if (!config.resolve) {
-    config.resolve = {};
-  }
-  config.resolve.mainFields = [
-    ...SVELTE_RESOLVE_MAIN_FIELDS,
-    ...config.resolve.mainFields ?? VITE_RESOLVE_MAIN_FIELDS
-  ];
-  const extraViteConfig = {
-    resolve: {
-      dedupe: [...SVELTE_IMPORTS, ...SVELTE_HMR_IMPORTS],
-      conditions: [...SVELTE_EXPORT_CONDITIONS]
-    }
-    // this option is still awaiting a PR in vite to be supported
-    // see https://github.com/sveltejs/vite-plugin-svelte/issues/60
-    // @ts-ignore
-    // knownJsSrcExtensions: options.extensions
-  };
-  const extraSvelteConfig = buildExtraConfigForSvelte(config);
-  const extraDepsConfig = await buildExtraConfigForDependencies(options, config);
-  extraViteConfig.optimizeDeps = {
-    include: [
-      ...extraSvelteConfig.optimizeDeps.include,
-      ...extraDepsConfig.optimizeDeps.include.filter(
-        (dep) => !isDepExcluded(dep, extraSvelteConfig.optimizeDeps.exclude)
-      )
-    ],
-    exclude: [
-      ...extraSvelteConfig.optimizeDeps.exclude,
-      ...extraDepsConfig.optimizeDeps.exclude.filter(
-        (dep) => !isDepIncluded(dep, extraSvelteConfig.optimizeDeps.include)
-      )
-    ]
-  };
-  extraViteConfig.ssr = {
-    external: [
-      ...extraSvelteConfig.ssr.external,
-      ...extraDepsConfig.ssr.external.filter(
-        (dep) => !isDepNoExternaled(dep, extraSvelteConfig.ssr.noExternal)
-      )
-    ],
-    noExternal: [
-      ...extraSvelteConfig.ssr.noExternal,
-      ...extraDepsConfig.ssr.noExternal.filter(
-        (dep) => !isDepExternaled(dep, extraSvelteConfig.ssr.external)
-      )
-    ]
-  };
-  if (options.prebundleSvelteLibraries) {
-    extraViteConfig.optimizeDeps = {
-      ...extraViteConfig.optimizeDeps,
-      // Experimental Vite API to allow these extensions to be scanned and prebundled
-      // @ts-ignore
-      extensions: options.extensions ?? [".svelte"],
-      // Add esbuild plugin to prebundle Svelte files.
-      // Currently a placeholder as more information is needed after Vite config is resolved,
-      // the real Svelte plugin is added in `patchResolvedViteConfig()`
-      esbuildOptions: {
-        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
-        } }]
-      }
-    };
-  }
-  if ((options.hot == null || options.hot === true || options.hot && options.hot.partialAccept !== false) && // deviate from svelte-hmr, default to true
-  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 crawlFrameworkPkgs({
-    root: options.root,
-    isBuild: options.isBuild,
-    viteUserConfig: config,
-    isFrameworkPkgByJson(pkgJson) {
-      let hasSvelteCondition = false;
-      if (typeof pkgJson.exports === "object") {
-        JSON.stringify(pkgJson.exports, (key, value) => {
-          if (SVELTE_EXPORT_CONDITIONS.includes(key)) {
-            hasSvelteCondition = true;
-          }
-          return value;
-        });
-      }
-      return hasSvelteCondition || !!pkgJson.svelte;
-    },
-    isSemiFrameworkPkgByJson(pkgJson) {
-      return !!pkgJson.dependencies?.svelte || !!pkgJson.peerDependencies?.svelte;
-    },
-    isFrameworkPkgByName(pkgName) {
-      const isNotSveltePackage = isCommonDepWithoutSvelteField(pkgName);
-      if (isNotSveltePackage) {
-        return false;
-      } else {
-        return void 0;
-      }
-    }
-  });
-  log.debug("extra config for dependencies generated by vitefu", depsConfig);
-  if (options.prebundleSvelteLibraries) {
-    depsConfig.optimizeDeps.exclude = [];
-    const userExclude = config.optimizeDeps?.exclude;
-    depsConfig.optimizeDeps.include = !userExclude ? [] : depsConfig.optimizeDeps.include.filter((dep) => {
-      return dep.includes(">") && dep.split(">").slice(0, -1).some((d) => isDepExcluded(d.trim(), userExclude));
-    });
-  }
-  if (options.disableDependencyReinclusion === true) {
-    depsConfig.optimizeDeps.include = depsConfig.optimizeDeps.include.filter(
-      (dep) => !dep.includes(">")
-    );
-  } else if (Array.isArray(options.disableDependencyReinclusion)) {
-    const disabledDeps = options.disableDependencyReinclusion;
-    depsConfig.optimizeDeps.include = depsConfig.optimizeDeps.include.filter((dep) => {
-      if (!dep.includes(">"))
-        return true;
-      const trimDep = dep.replace(/\s+/g, "");
-      return disabledDeps.some((disabled) => trimDep.includes(`${disabled}>`));
-    });
-  }
-  log.debug("post-processed extra config for dependencies", depsConfig);
-  return depsConfig;
-}
-function buildExtraConfigForSvelte(config) {
-  const include = [];
-  const exclude = ["svelte-hmr"];
-  if (!isDepExcluded("svelte", config.optimizeDeps?.exclude ?? [])) {
-    const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== "svelte/ssr");
-    log.debug(
-      `adding bare svelte packages to optimizeDeps.include: ${svelteImportsToInclude.join(", ")} `
-    );
-    include.push(...svelteImportsToInclude);
-  } else {
-    log.debug('"svelte" is excluded in optimizeDeps.exclude, skipped adding it to include.');
-  }
-  const noExternal = [];
-  const external = [];
-  if (!isDepExternaled("svelte", config.ssr?.external ?? [])) {
-    noExternal.push("svelte", /^svelte\//);
-  }
-  return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
-}
-function patchResolvedViteConfig(viteConfig, options) {
-  if (options.preprocess) {
-    for (const preprocessor of arraify(options.preprocess)) {
-      if (preprocessor.style && "__resolvedConfig" in preprocessor.style) {
-        preprocessor.style.__resolvedConfig = viteConfig;
-      }
-    }
-  }
-  const facadeEsbuildSveltePlugin = viteConfig.optimizeDeps.esbuildOptions?.plugins?.find(
-    (plugin) => plugin.name === facadeEsbuildSveltePluginName
-  );
-  if (facadeEsbuildSveltePlugin) {
-    Object.assign(facadeEsbuildSveltePlugin, esbuildSveltePlugin(options));
-  }
-}
-function arraify(value) {
-  return Array.isArray(value) ? value : [value];
-}
-
-// src/utils/watch.ts
-import fs4 from "fs";
-import path6 from "path";
-function setupWatchers(options, cache, requestParser) {
-  const { server, configFile: svelteConfigFile } = options;
-  if (!server) {
-    return;
-  }
-  const { watcher, ws } = server;
-  const { root, server: serverConfig } = server.config;
-  const emitChangeEventOnDependants = (filename) => {
-    const dependants = cache.getDependants(filename);
-    dependants.forEach((dependant) => {
-      if (fs4.existsSync(dependant)) {
-        log.debug(
-          `emitting virtual change event for "${dependant}" because depdendency "${filename}" changed`
-        );
-        watcher.emit("change", dependant);
-      }
-    });
-  };
-  const removeUnlinkedFromCache = (filename) => {
-    const svelteRequest = requestParser(filename, false);
-    if (svelteRequest) {
-      const removedFromCache = cache.remove(svelteRequest);
-      if (removedFromCache) {
-        log.debug(`cleared VitePluginSvelteCache for deleted file ${filename}`);
-      }
-    }
-  };
-  const triggerViteRestart = (filename) => {
-    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 listenerCollection = {
-    add: [],
-    change: [emitChangeEventOnDependants],
-    unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
-  };
-  if (svelteConfigFile !== false) {
-    const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path6.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) {
-      watcher.on(evt, (filename) => listeners.forEach((listener) => listener(filename)));
-    }
-  });
-}
-function ensureWatchedFile(watcher, file, root) {
-  if (file && // only need to watch if out of root
-  !file.startsWith(root + "/") && // some rollup plugins use null bytes for private resolved Ids
-  !file.includes("\0") && fs4.existsSync(file)) {
-    watcher.add(path6.resolve(file));
-  }
-}
-
-// src/utils/resolve.ts
-import path7 from "path";
-import { builtinModules } from "module";
-import { normalizePath as normalizePath4 } from "vite";
-async function resolveViaPackageJsonSvelte(importee, importer, cache) {
-  if (importer && isBareImport(importee) && !isNodeInternal(importee) && !isCommonDepWithoutSvelteField(importee)) {
-    const cached = cache.getResolvedSvelteField(importee, importer);
-    if (cached) {
-      return cached;
-    }
-    const pkgData = await resolveDependencyData(importee, importer);
-    if (pkgData) {
-      const { pkg, dir } = pkgData;
-      if (pkg.svelte) {
-        const result = normalizePath4(path7.resolve(dir, pkg.svelte));
-        cache.setResolvedSvelteField(importee, importer, result);
-        return result;
-      }
-    }
-  }
-}
-function isNodeInternal(importee) {
-  return importee.startsWith("node:") || builtinModules.includes(importee);
-}
-function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || path7.isAbsolute(importee)) {
-    return false;
-  }
-  const parts = importee.split("/");
-  switch (parts.length) {
-    case 1:
-      return true;
-    case 2:
-      return parts[0].startsWith("@");
-    default:
-      return false;
-  }
-}
-
-// src/utils/optimizer.ts
-import { promises as fs5 } from "fs";
-import path8 from "path";
-var PREBUNDLE_SENSITIVE_OPTIONS = [
-  "compilerOptions",
-  "configFile",
-  "experimental",
-  "extensions",
-  "ignorePluginPreprocessors",
-  "preprocess"
-];
-async function saveSvelteMetadata(cacheDir, options) {
-  const svelteMetadata = generateSvelteMetadata(options);
-  const svelteMetadataPath = path8.resolve(cacheDir, "_svelte_metadata.json");
-  const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
-    return typeof value === "function" ? value.toString() : value;
-  });
-  let existingSvelteMetadata;
-  try {
-    existingSvelteMetadata = await fs5.readFile(svelteMetadataPath, "utf8");
-  } catch {
-  }
-  await fs5.mkdir(cacheDir, { recursive: true });
-  await fs5.writeFile(svelteMetadataPath, currentSvelteMetadata);
-  return currentSvelteMetadata !== existingSvelteMetadata;
-}
-function generateSvelteMetadata(options) {
-  const metadata = {};
-  for (const key of PREBUNDLE_SENSITIVE_OPTIONS) {
-    metadata[key] = options[key];
-  }
-  return metadata;
-}
-
-// src/ui/inspector/plugin.ts
-import { normalizePath as normalizePath5 } from "vite";
-import path9 from "path";
-import { fileURLToPath } from "url";
-import fs6 from "fs";
-
-// src/ui/inspector/utils.ts
-var FS_PREFIX = `/@fs/`;
-var IS_WINDOWS3 = process.platform === "win32";
-var queryRE = /\?.*$/s;
-var hashRE = /#.*$/s;
-function idToFile(id) {
-  if (id.startsWith(FS_PREFIX)) {
-    id = id = id.slice(IS_WINDOWS3 ? FS_PREFIX.length : FS_PREFIX.length - 1);
-  }
-  return id.replace(hashRE, "").replace(queryRE, "");
-}
-
-// src/ui/inspector/options.ts
-import * as process2 from "process";
-import { loadEnv } from "vite";
-var defaultInspectorOptions = {
-  toggleKeyCombo: process2.platform === "darwin" ? "meta-shift" : "control-shift",
-  navKeys: { parent: "ArrowUp", child: "ArrowDown", next: "ArrowRight", prev: "ArrowLeft" },
-  openKey: "Enter",
-  holdMode: true,
-  showToggleButton: "active",
-  toggleButtonPos: "top-right",
-  customStyles: true
-};
-function parseEnvironmentOptions(config) {
-  const env = loadEnv(config.mode, config.envDir ?? process2.cwd(), "SVELTE_INSPECTOR");
-  const options = env?.SVELTE_INSPECTOR_OPTIONS;
-  const toggle = env?.SVELTE_INSPECTOR_TOGGLE;
-  if (options) {
-    try {
-      const parsed = JSON.parse(options);
-      const parsedType = typeof parsed;
-      if (parsedType === "boolean") {
-        return parsed;
-      } else if (parsedType === "object") {
-        if (Array.isArray(parsed)) {
-          throw new Error("invalid type, expected object map but got array");
-        }
-        const parsedKeys = Object.keys(parsed);
-        const defaultKeys = Object.keys(defaultInspectorOptions);
-        const unknownKeys = parsedKeys.filter((k) => !defaultKeys.includes(k));
-        if (unknownKeys.length) {
-          log.warn(
-            `ignoring unknown options in environment SVELTE_INSPECTOR_OPTIONS:  ${unknownKeys.join(
-              ", "
-            )}.`,
-            void 0,
-            "inspector"
-          );
-          for (const key of unknownKeys) {
-            delete parsed[key];
-          }
-        }
-        log.debug("loaded environment config", parsed, "inspector");
-        return parsed;
-      }
-    } catch (e) {
-      log.error(
-        `failed to parse inspector options from environment SVELTE_INSPECTOR_OPTIONS="${options}"`,
-        e,
-        "inspector"
-      );
-    }
-  } else if (toggle) {
-    const keyConfig = {
-      toggleKeyCombo: toggle
-    };
-    log.debug("loaded environment config", keyConfig, "inspector");
-    return keyConfig;
-  }
-}
-
-// src/ui/inspector/plugin.ts
-function getInspectorPath() {
-  const pluginPath = normalizePath5(path9.dirname(fileURLToPath(import.meta.url)));
-  return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
-}
-function svelteInspector() {
-  const inspectorPath = getInspectorPath();
-  log.debug.enabled && log.debug(`svelte inspector path: ${inspectorPath}`);
-  let inspectorOptions;
-  let disabled = false;
-  return {
-    name: "vite-plugin-svelte:inspector",
-    apply: "serve",
-    enforce: "pre",
-    configResolved(config) {
-      const vps = config.plugins.find((p) => p.name === "vite-plugin-svelte");
-      if (!vps) {
-        log.warn("vite-plugin-svelte is missing, inspector disabled", void 0, "inspector");
-        disabled = true;
-        return;
-      }
-      const configFileOptions = vps?.api?.options?.inspector;
-      const environmentOptions = parseEnvironmentOptions(config);
-      if (!configFileOptions && !environmentOptions) {
-        log.debug("no options found, inspector disabled", void 0, "inspector");
-        disabled = true;
-        return;
-      }
-      if (environmentOptions === true) {
-        inspectorOptions = defaultInspectorOptions;
-      } else {
-        inspectorOptions = {
-          ...defaultInspectorOptions,
-          ...configFileOptions,
-          ...environmentOptions || {}
-        };
-      }
-      inspectorOptions.__internal = {
-        base: config.base?.replace(/\/$/, "") || ""
-      };
-    },
-    async resolveId(importee, importer, options) {
-      if (options?.ssr || disabled) {
-        return;
-      }
-      if (importee.startsWith("virtual:svelte-inspector-options")) {
-        return importee;
-      } else if (importee.startsWith("virtual:svelte-inspector-path:")) {
-        const resolved = importee.replace("virtual:svelte-inspector-path:", inspectorPath);
-        log.debug.enabled && log.debug(`resolved ${importee} with ${resolved}`, void 0, "inspector");
-        return resolved;
-      }
-    },
-    async load(id, options) {
-      if (options?.ssr || disabled) {
-        return;
-      }
-      if (id === "virtual:svelte-inspector-options") {
-        return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
-      } else if (id.startsWith(inspectorPath)) {
-        const file = idToFile(id);
-        if (fs6.existsSync(file)) {
-          return await fs6.promises.readFile(file, "utf-8");
-        } else {
-          log.error(
-            `failed to find file for svelte-inspector: ${file}, referenced by id ${id}.`,
-            void 0,
-            "inspector"
-          );
-        }
-      }
-    },
-    transform(code, id, options) {
-      if (options?.ssr || disabled) {
-        return;
-      }
-      if (id.includes("vite/dist/client/client.mjs")) {
-        return { code: `${code}
-import('virtual:svelte-inspector-path:load-inspector.js')` };
-      }
-    }
-  };
-}
-
-// src/utils/vite-plugin-svelte-cache.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname } from "path";
-import { findClosestPkgJsonPath } from "vitefu";
-import { normalizePath as normalizePath6 } from "vite";
-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();
-    this._packageInfos = [];
-  }
-  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(path10) {
-    const dependants = this._dependants.get(path10);
-    return dependants ? [...dependants] : [];
-  }
-  getResolvedSvelteField(name, importer) {
-    return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
-  }
-  hasResolvedSvelteField(name, importer) {
-    return this._resolvedSvelteFields.has(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;
-  }
-  async getPackageInfo(file) {
-    let info = this._packageInfos.find((pi) => file.startsWith(pi.path));
-    if (!info) {
-      info = await findPackageInfo(file);
-      this._packageInfos.push(info);
-    }
-    return info;
-  }
-};
-async function findPackageInfo(file) {
-  const info = {
-    name: "$unknown",
-    version: "0.0.0-unknown",
-    path: "$unknown"
-  };
-  let path10 = await findClosestPkgJsonPath(file, (pkgPath) => {
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-    if (pkg.name != null) {
-      info.name = pkg.name;
-      if (pkg.version != null) {
-        info.version = pkg.version;
-      }
-      info.svelte = pkg.svelte;
-      return true;
-    }
-    return false;
-  });
-  path10 = normalizePath6(dirname(path10 ?? file)) + "/";
-  info.path = path10;
-  return info;
-}
-
-// src/utils/load-raw.ts
-import fs7 from "fs";
-async function loadRaw(svelteRequest, compileSvelte2, options) {
-  const { id, filename, query } = svelteRequest;
-  let compileData;
-  const source = fs7.readFileSync(filename, "utf-8");
-  try {
-    svelteRequest.ssr = query.compilerOptions?.generate === "ssr";
-    const type = query.type;
-    compileData = await compileSvelte2(svelteRequest, source, {
-      ...options,
-      // don't use dynamic vite-plugin-svelte defaults here to ensure stable result between ssr,dev and build
-      compilerOptions: {
-        dev: false,
-        css: false,
-        hydratable: false,
-        enableSourcemap: query.sourcemap ? {
-          js: type === "script" || type === "all",
-          css: type === "style" || type === "all"
-        } : false,
-        ...svelteRequest.query.compilerOptions
-      },
-      hot: false,
-      emitCss: true
-    });
-  } catch (e) {
-    throw toRollupError(e, options);
-  }
-  let result;
-  if (query.type === "style") {
-    result = compileData.compiled.css;
-  } else if (query.type === "script") {
-    result = compileData.compiled.js;
-  } else if (query.type === "preprocessed") {
-    result = compileData.preprocessed;
-  } else if (query.type === "all" && query.raw) {
-    return allToRawExports(compileData, source);
-  } else {
-    throw new Error(
-      `invalid "type=${query.type}" in ${id}. supported are script, style, preprocessed, all`
-    );
-  }
-  if (query.direct) {
-    const supportedDirectTypes = ["script", "style"];
-    if (!supportedDirectTypes.includes(query.type)) {
-      throw new Error(
-        `invalid "type=${query.type}" combined with direct in ${id}. supported are: ${supportedDirectTypes.join(", ")}`
-      );
-    }
-    log.debug(`load returns direct result for ${id}`);
-    let directOutput = result.code;
-    if (query.sourcemap && result.map?.toUrl) {
-      const map = `sourceMappingURL=${result.map.toUrl()}`;
-      if (query.type === "style") {
-        directOutput += `
-
-/*# ${map} */
-`;
-      } else if (query.type === "script") {
-        directOutput += `
-
-//# ${map}
-`;
-      }
-    }
-    return directOutput;
-  } else if (query.raw) {
-    log.debug(`load returns raw result for ${id}`);
-    return toRawExports(result);
-  } else {
-    throw new Error(`invalid raw mode in ${id}, supported are raw, direct`);
-  }
-}
-function allToRawExports(compileData, source) {
-  const exports = {
-    ...compileData,
-    ...compileData.compiled,
-    source
-  };
-  delete exports.compiled;
-  delete exports.filename;
-  return toRawExports(exports);
-}
-function toRawExports(object) {
-  let exports = Object.entries(object).filter(([key, value]) => typeof value !== "function").sort(([a], [b]) => a < b ? -1 : a === b ? 0 : 1).map(([key, value]) => `export const ${key}=${JSON.stringify(value)}`).join("\n") + "\n";
-  if (Object.prototype.hasOwnProperty.call(object, "code")) {
-    exports += `export default code
-`;
-  }
-  return exports;
-}
-
-// src/preprocess.ts
-import { preprocessCSS, resolveConfig, transformWithEsbuild } from "vite";
-var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss", "sss"];
-var supportedScriptLangs = ["ts"];
-var lang_sep = ".vite-preprocess.";
-function vitePreprocess(opts) {
-  const preprocessor = {};
-  if (opts?.script !== false) {
-    preprocessor.script = viteScript().script;
-  }
-  if (opts?.style !== false) {
-    const styleOpts = typeof opts?.style == "object" ? opts?.style : void 0;
-    preprocessor.style = viteStyle(styleOpts).style;
-  }
-  return preprocessor;
-}
-function viteScript() {
-  return {
-    async script({ attributes, content, filename = "" }) {
-      const lang = attributes.lang;
-      if (!supportedScriptLangs.includes(lang))
-        return;
-      const { code, map } = await transformWithEsbuild(content, filename, {
-        loader: lang,
-        target: "esnext",
-        tsconfigRaw: {
-          compilerOptions: {
-            // svelte typescript needs this flag to work with type imports
-            importsNotUsedAsValues: "preserve",
-            preserveValueImports: true
-          }
-        }
-      });
-      mapToRelative(map, filename);
-      return {
-        code,
-        map
-      };
-    }
-  };
-}
-function viteStyle(config = {}) {
-  let transform;
-  const style = async ({ attributes, content, filename = "" }) => {
-    const lang = attributes.lang;
-    if (!supportedStyleLangs.includes(lang))
-      return;
-    if (!transform) {
-      let resolvedConfig;
-      if (style.__resolvedConfig) {
-        resolvedConfig = style.__resolvedConfig;
-      } else if (isResolvedConfig(config)) {
-        resolvedConfig = config;
-      } else {
-        resolvedConfig = await resolveConfig(
-          config,
-          process.env.NODE_ENV === "production" ? "build" : "serve"
-        );
-      }
-      transform = getCssTransformFn(resolvedConfig);
-    }
-    const suffix = `${lang_sep}${lang}`;
-    const moduleId = `${filename}${suffix}`;
-    const { code, map, deps } = await transform(content, moduleId);
-    removeLangSuffix(map, suffix);
-    mapToRelative(map, filename);
-    const dependencies = deps ? Array.from(deps).filter((d) => !d.endsWith(suffix)) : void 0;
-    return {
-      code,
-      map: map ?? void 0,
-      dependencies
-    };
-  };
-  style.__resolvedConfig = null;
-  return { style };
-}
-function getCssTransformFn(config) {
-  return async (code, filename) => {
-    return preprocessCSS(code, filename, config);
-  };
-}
-function isResolvedConfig(config) {
-  return !!config.inlineConfig;
-}
-
-// src/index.ts
-var isVite4_0 = viteVersion.startsWith("4.0");
-var isSvelte3 = svelteVersion.startsWith("3");
-function svelte(inlineOptions) {
-  if (process.env.DEBUG != null) {
-    log.setLevel("debug");
-  }
-  validateInlineOptions(inlineOptions);
-  const cache = new VitePluginSvelteCache();
-  let requestParser;
-  let options;
-  let viteConfig;
-  let compileSvelte2;
-  let resolvedSvelteSSR;
-  let packagesWithResolveWarnings;
-  const api = {};
-  const plugins = [
-    {
-      name: "vite-plugin-svelte",
-      // make sure our resolver runs before vite internal resolver to resolve svelte field correctly
-      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 = await buildExtraViteConfig(options, config);
-        log.debug("additional vite config", extraViteConfig);
-        return extraViteConfig;
-      },
-      async configResolved(config) {
-        options = resolveOptions(options, config, cache);
-        patchResolvedViteConfig(config, options);
-        requestParser = buildIdParser(options);
-        compileSvelte2 = createCompileSvelte(options);
-        viteConfig = config;
-        api.options = options;
-        log.debug("resolved options", options);
-      },
-      async buildStart() {
-        packagesWithResolveWarnings = /* @__PURE__ */ new Set();
-        if (!options.prebundleSvelteLibraries)
-          return;
-        const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
-        if (isSvelteMetadataChanged) {
-          viteConfig.optimizeDeps.force = true;
-        }
-      },
-      configureServer(server) {
-        options.server = server;
-        setupWatchers(options, cache, requestParser);
-      },
-      async load(id, opts) {
-        const ssr = !!opts?.ssr;
-        const svelteRequest = requestParser(id, !!ssr);
-        if (svelteRequest) {
-          const { filename, query, raw } = svelteRequest;
-          if (raw) {
-            return loadRaw(svelteRequest, compileSvelte2, options);
-          } else {
-            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 fs8.readFileSync(filename, "utf-8");
-            }
-          }
-        }
-      },
-      async resolveId(importee, importer, opts) {
-        const ssr = !!opts?.ssr;
-        const svelteRequest = requestParser(importee, ssr);
-        if (svelteRequest?.query.svelte) {
-          if (svelteRequest.query.type === "style" && !svelteRequest.raw) {
-            log.debug(`resolveId resolved virtual css module ${svelteRequest.cssId}`);
-            return svelteRequest.cssId;
-          }
-        }
-        if (isVite4_0 && isSvelte3 && 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;
-        }
-        const scan = !!opts?.scan;
-        const isPrebundled = options.prebundleSvelteLibraries && viteConfig.optimizeDeps?.disabled !== true && viteConfig.optimizeDeps?.disabled !== (options.isBuild ? "build" : "dev") && !isDepExcluded2(importee, viteConfig.optimizeDeps?.exclude ?? []);
-        if (ssr || scan || !isPrebundled) {
-          try {
-            const isFirstResolve = !cache.hasResolvedSvelteField(importee, importer);
-            const resolved = await resolveViaPackageJsonSvelte(importee, importer, cache);
-            if (isFirstResolve && resolved) {
-              const packageInfo = await cache.getPackageInfo(resolved);
-              const packageVersion = `${packageInfo.name}@${packageInfo.version}`;
-              log.debug.once(
-                `resolveId resolved ${importee} to ${resolved} via package.json svelte field of ${packageVersion}`
-              );
-              try {
-                const viteResolved = (await this.resolve(importee, importer, { ...opts, skipSelf: true }))?.id;
-                if (resolved !== viteResolved) {
-                  packagesWithResolveWarnings.add(packageVersion);
-                  log.debug.enabled && log.debug.once(
-                    `resolve difference for ${packageVersion} ${importee} - svelte: "${resolved}", vite: "${viteResolved}"`
-                  );
-                }
-              } catch (e) {
-                packagesWithResolveWarnings.add(packageVersion);
-                log.debug.enabled && log.debug.once(
-                  `resolve error for ${packageVersion} ${importee} - svelte: "${resolved}", vite: ERROR`,
-                  e
-                );
-              }
-            }
-            return resolved;
-          } catch (e) {
-            log.debug.once(
-              `error trying to resolve ${importee} from ${importer} via package.json svelte field `,
-              e
-            );
-          }
-        }
-      },
-      async transform(code, id, opts) {
-        const ssr = !!opts?.ssr;
-        const svelteRequest = requestParser(id, ssr);
-        if (!svelteRequest || svelteRequest.query.type === "style" || svelteRequest.raw) {
-          return;
-        }
-        let compileData;
-        try {
-          compileData = await compileSvelte2(svelteRequest, code, options);
-        } catch (e) {
-          cache.setError(svelteRequest, e);
-          throw toRollupError(e, options);
-        }
-        logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
-        cache.update(compileData);
-        if (compileData.dependencies?.length && options.server) {
-          compileData.dependencies.forEach((d) => {
-            ensureWatchedFile(options.server.watcher, d, options.root);
-          });
-        }
-        log.debug(`transform returns compiled js for ${svelteRequest.filename}`);
-        return {
-          ...compileData.compiled.js,
-          meta: {
-            vite: {
-              lang: compileData.lang
-            }
-          }
-        };
-      },
-      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);
-        }
-      },
-      async buildEnd() {
-        await options.stats?.finishAll();
-        if (!options.experimental?.disableSvelteResolveWarnings && packagesWithResolveWarnings?.size > 0) {
-          log.warn(
-            `WARNING: The following packages use a svelte resolve configuration in package.json that has conflicting results and is going to cause problems future.
-
-${[
-              ...packagesWithResolveWarnings
-            ].join("\n")}
-
-Please see ${FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE} for details.`
-          );
-        }
-      }
-    },
-    svelteInspector()
-  ];
-  return plugins;
-}
-export {
-  loadSvelteConfig,
-  svelte,
-  vitePreprocess
-};
-//# sourceMappingURL=index.js.map