vite 6.0.0-alpha.18 → 6.0.0-alpha.19

package/dist/node-cjs/publicUtils.cjs

@@ -14,17 +14,18 @@ var readline = require('node:readline');
 var require$$2 = require('os');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-const { version: version$2 } = JSON.parse(fs$1.readFileSync(new URL('../../package.json', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString());
+const { version: version$2 } = JSON.parse(
+  fs$1.readFileSync(new URL("../../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString()
+);
 const VERSION = version$2;
-/**
- * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
- */
 const FS_PREFIX = `/@fs/`;
 const VITE_PACKAGE_DIR = path$3.resolve(
-// import.meta.url is `dist/node/constants.js` after bundle
-node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))), '../../..');
-const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, 'dist/client/client.mjs');
-path$3.resolve(VITE_PACKAGE_DIR, 'dist/client/env.mjs');
+  // import.meta.url is `dist/node/constants.js` after bundle
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))),
+  "../../.."
+);
+const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
+path$3.resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
 path$3.dirname(CLIENT_ENTRY);
 
 const comma = ','.charCodeAt(0);
@@ -3353,364 +3354,318 @@ const builtins = 'arguments Infinity NaN undefined null true false eval uneval i
 const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
 forbiddenIdentifiers.add('');
 
-const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
 const windowsSlashRE = /\\/g;
 function slash(p) {
-    return p.replace(windowsSlashRE, '/');
+  return p.replace(windowsSlashRE, "/");
 }
 const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
-    return url.replace(postfixRE, '');
+  return url.replace(postfixRE, "");
 }
 function withTrailingSlash(path) {
-    if (path[path.length - 1] !== '/') {
-        return `${path}/`;
-    }
-    return path;
+  if (path[path.length - 1] !== "/") {
+    return `${path}/`;
+  }
+  return path;
 }
 
 if (process.versions.pnp) {
-    try {
-        node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))('pnpapi');
-    }
-    catch { }
+  try {
+    node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))("pnpapi");
+  } catch {
+  }
 }
 
 const createFilter = createFilter$1;
-// Some runtimes like Bun injects namespaced modules here, which is not a node builtin
-node_module.builtinModules.filter((id) => !id.includes(':'));
+node_module.builtinModules.filter((id) => !id.includes(":"));
 function isInNodeModules(id) {
-    return id.includes('node_modules');
+  return id.includes("node_modules");
 }
-// TODO: use import()
 const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
-function resolveDependencyVersion(dep, pkgRelativePath = '../../package.json') {
-    const pkgPath = path$3.resolve(_require.resolve(dep), pkgRelativePath);
-    return JSON.parse(fs$1.readFileSync(pkgPath, 'utf-8')).version;
+function resolveDependencyVersion(dep, pkgRelativePath = "../../package.json") {
+  const pkgPath = path$3.resolve(_require.resolve(dep), pkgRelativePath);
+  return JSON.parse(fs$1.readFileSync(pkgPath, "utf-8")).version;
 }
-const rollupVersion = resolveDependencyVersion('rollup');
-// set in bin/vite.js
+const rollupVersion = resolveDependencyVersion("rollup");
 const filter = process.env.VITE_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
-    const log = debug$2(namespace);
-    const { onlyWhenFocused } = options;
-    let enabled = log.enabled;
-    if (enabled && onlyWhenFocused) {
-        const ns = typeof onlyWhenFocused === 'string' ? onlyWhenFocused : namespace;
-        enabled = !!DEBUG?.includes(ns);
-    }
-    if (enabled) {
-        return (...args) => {
-            if (!filter || args.some((a) => a?.includes?.(filter))) {
-                log(...args);
-            }
-        };
-    }
+  const log = debug$2(namespace);
+  const { onlyWhenFocused } = options;
+  let enabled = log.enabled;
+  if (enabled && onlyWhenFocused) {
+    const ns = typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace;
+    enabled = !!DEBUG?.includes(ns);
+  }
+  if (enabled) {
+    return (...args) => {
+      if (!filter || args.some((a) => a?.includes?.(filter))) {
+        log(...args);
+      }
+    };
+  }
 }
 function testCaseInsensitiveFS() {
-    if (!CLIENT_ENTRY.endsWith('client.mjs')) {
-        throw new Error(`cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`);
-    }
-    if (!fs$1.existsSync(CLIENT_ENTRY)) {
-        throw new Error('cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: ' +
-            CLIENT_ENTRY);
-    }
-    return fs$1.existsSync(CLIENT_ENTRY.replace('client.mjs', 'cLiEnT.mjs'));
+  if (!CLIENT_ENTRY.endsWith("client.mjs")) {
+    throw new Error(
+      `cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`
+    );
+  }
+  if (!fs$1.existsSync(CLIENT_ENTRY)) {
+    throw new Error(
+      "cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: " + CLIENT_ENTRY
+    );
+  }
+  return fs$1.existsSync(CLIENT_ENTRY.replace("client.mjs", "cLiEnT.mjs"));
 }
 const isCaseInsensitiveFS = testCaseInsensitiveFS();
 const VOLUME_RE = /^[A-Z]:/i;
 function normalizePath(id) {
-    return path$3.posix.normalize(isWindows ? slash(id) : id);
+  return path$3.posix.normalize(isWindows ? slash(id) : id);
 }
 function fsPathFromId(id) {
-    const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id);
-    return fsPath[0] === '/' || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+  const fsPath = normalizePath(
+    id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id
+  );
+  return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
 }
 function fsPathFromUrl(url) {
-    return fsPathFromId(cleanUrl(url));
+  return fsPathFromId(cleanUrl(url));
 }
-/**
- * Check if dir is a parent of file
- *
- * Warning: parameters are not validated, only works with normalized absolute paths
- *
- * @param dir - normalized absolute path
- * @param file - normalized absolute path
- * @returns true if dir is a parent of file
- */
 function isParentDirectory(dir, file) {
-    dir = withTrailingSlash(dir);
-    return (file.startsWith(dir) ||
-        (isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase())));
+  dir = withTrailingSlash(dir);
+  return file.startsWith(dir) || isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase());
 }
-/**
- * Check if 2 file name are identical
- *
- * Warning: parameters are not validated, only works with normalized absolute paths
- *
- * @param file1 - normalized absolute path
- * @param file2 - normalized absolute path
- * @returns true if both files url are identical
- */
 function isSameFileUri(file1, file2) {
-    return (file1 === file2 ||
-        (isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase()));
+  return file1 === file2 || isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase();
 }
 const trailingSeparatorRE = /[?&]$/;
 const timestampRE = /\bt=\d{13}&?\b/;
 function removeTimestampQuery(url) {
-    return url.replace(timestampRE, '').replace(trailingSeparatorRE, '');
+  return url.replace(timestampRE, "").replace(trailingSeparatorRE, "");
 }
 function isObject$1(value) {
-    return Object.prototype.toString.call(value) === '[object Object]';
+  return Object.prototype.toString.call(value) === "[object Object]";
 }
 function tryStatSync(file) {
-    try {
-        // The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
-        return fs$1.statSync(file, { throwIfNoEntry: false });
-    }
-    catch {
-        // Ignore errors
-    }
+  try {
+    return fs$1.statSync(file, { throwIfNoEntry: false });
+  } catch {
+  }
 }
-const splitRE = /\r?\n/g;
 function isFileReadable(filename) {
-    if (!tryStatSync(filename)) {
-        return false;
-    }
-    try {
-        // Check if current process has read permission to the file
-        fs$1.accessSync(filename, fs$1.constants.R_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
+  if (!tryStatSync(filename)) {
+    return false;
+  }
+  try {
+    fs$1.accessSync(filename, fs$1.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function arraify(target) {
-    return Array.isArray(target) ? target : [target];
+  return Array.isArray(target) ? target : [target];
 }
 path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
 function backwardCompatibleWorkerPlugins(plugins) {
-    if (Array.isArray(plugins)) {
-        return plugins;
-    }
-    if (typeof plugins === 'function') {
-        return plugins();
-    }
-    return [];
+  if (Array.isArray(plugins)) {
+    return plugins;
+  }
+  if (typeof plugins === "function") {
+    return plugins();
+  }
+  return [];
 }
 function mergeConfigRecursively(defaults, overrides, rootPath) {
-    const merged = { ...defaults };
-    for (const key in overrides) {
-        const value = overrides[key];
-        if (value == null) {
-            continue;
-        }
-        const existing = merged[key];
-        if (existing == null) {
-            merged[key] = value;
-            continue;
-        }
-        // fields that require special handling
-        if (key === 'alias' && (rootPath === 'resolve' || rootPath === '')) {
-            merged[key] = mergeAlias(existing, value);
-            continue;
-        }
-        else if (key === 'assetsInclude' && rootPath === '') {
-            merged[key] = [].concat(existing, value);
-            continue;
-        }
-        else if (key === 'noExternal' && // TODO: environments
-            rootPath === 'ssr' &&
-            (existing === true || value === true)) {
-            merged[key] = true;
-            continue;
-        }
-        else if (key === 'plugins' && rootPath === 'worker') {
-            merged[key] = () => [
-                ...backwardCompatibleWorkerPlugins(existing),
-                ...backwardCompatibleWorkerPlugins(value),
-            ];
-            continue;
-        }
-        if (Array.isArray(existing) || Array.isArray(value)) {
-            merged[key] = [...arraify(existing), ...arraify(value)];
-            continue;
-        }
-        if (isObject$1(existing) && isObject$1(value)) {
-            merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
-            continue;
-        }
-        merged[key] = value;
+  const merged = { ...defaults };
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
     }
-    return merged;
+    const existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "alias" && (rootPath === "resolve" || rootPath === "")) {
+      merged[key] = mergeAlias(existing, value);
+      continue;
+    } else if (key === "assetsInclude" && rootPath === "") {
+      merged[key] = [].concat(existing, value);
+      continue;
+    } else if (key === "noExternal" && // TODO: environments
+    rootPath === "ssr" && (existing === true || value === true)) {
+      merged[key] = true;
+      continue;
+    } else if (key === "plugins" && rootPath === "worker") {
+      merged[key] = () => [
+        ...backwardCompatibleWorkerPlugins(existing),
+        ...backwardCompatibleWorkerPlugins(value)
+      ];
+      continue;
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing), ...arraify(value)];
+      continue;
+    }
+    if (isObject$1(existing) && isObject$1(value)) {
+      merged[key] = mergeConfigRecursively(
+        existing,
+        value,
+        rootPath ? `${rootPath}.${key}` : key
+      );
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
 }
 function mergeConfig(defaults, overrides, isRoot = true) {
-    if (typeof defaults === 'function' || typeof overrides === 'function') {
-        throw new Error(`Cannot merge config in form of callback`);
-    }
-    return mergeConfigRecursively(defaults, overrides, isRoot ? '' : '.');
+  if (typeof defaults === "function" || typeof overrides === "function") {
+    throw new Error(`Cannot merge config in form of callback`);
+  }
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
 }
 function mergeAlias(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    if (isObject$1(a) && isObject$1(b)) {
-        return { ...a, ...b };
-    }
-    // the order is flipped because the alias is resolved from top-down,
-    // where the later should have higher priority
-    return [...normalizeAlias(b), ...normalizeAlias(a)];
+  if (!a) return b;
+  if (!b) return a;
+  if (isObject$1(a) && isObject$1(b)) {
+    return { ...a, ...b };
+  }
+  return [...normalizeAlias(b), ...normalizeAlias(a)];
 }
 function normalizeAlias(o = []) {
-    return Array.isArray(o)
-        ? o.map(normalizeSingleAlias)
-        : Object.keys(o).map((find) => normalizeSingleAlias({
-            find,
-            replacement: o[find],
-        }));
+  return Array.isArray(o) ? o.map(normalizeSingleAlias) : Object.keys(o).map(
+    (find) => normalizeSingleAlias({
+      find,
+      replacement: o[find]
+    })
+  );
 }
-// https://github.com/vitejs/vite/issues/1363
-// work around https://github.com/rollup/plugins/issues/759
-function normalizeSingleAlias({ find, replacement, customResolver, }) {
-    if (typeof find === 'string' &&
-        find[find.length - 1] === '/' &&
-        replacement[replacement.length - 1] === '/') {
-        find = find.slice(0, find.length - 1);
-        replacement = replacement.slice(0, replacement.length - 1);
-    }
-    const alias = {
-        find,
-        replacement,
-    };
-    if (customResolver) {
-        alias.customResolver = customResolver;
-    }
-    return alias;
+function normalizeSingleAlias({
+  find,
+  replacement,
+  customResolver
+}) {
+  if (typeof find === "string" && find[find.length - 1] === "/" && replacement[replacement.length - 1] === "/") {
+    find = find.slice(0, find.length - 1);
+    replacement = replacement.slice(0, replacement.length - 1);
+  }
+  const alias = {
+    find,
+    replacement
+  };
+  if (customResolver) {
+    alias.customResolver = customResolver;
+  }
+  return alias;
 }
 
-// This file will be built for both ESM and CJS. Avoid relying on other modules as possible.
-// copy from constants.ts
-const CSS_LANGS_RE = 
-// eslint-disable-next-line regexp/no-unused-capturing-group
-/\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const CSS_LANGS_RE = (
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/
+);
 const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
-// Use splitVendorChunkPlugin() to get the same manualChunks strategy as Vite 2.7
-// We don't recommend using this strategy as a general solution moving forward
-// splitVendorChunk is a simple index/vendor strategy that was used in Vite
-// until v2.8. It is exposed to let people continue to use it in case it was
-// working well for their setups.
-// The cache needs to be reset on buildStart for watch mode to work correctly
-// Don't use this manualChunks strategy for ssr, lib mode, and 'umd' or 'iife'
-/**
- * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
- */
 class SplitVendorChunkCache {
-    cache;
-    constructor() {
-        this.cache = new Map();
-    }
-    reset() {
-        this.cache = new Map();
-    }
+  cache;
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
 }
-/**
- * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
- */
 function splitVendorChunk(options = {}) {
-    const cache = options.cache ?? new SplitVendorChunkCache();
-    return (id, { getModuleInfo }) => {
-        if (isInNodeModules(id) &&
-            !isCSSRequest(id) &&
-            staticImportedByEntry(id, getModuleInfo, cache.cache)) {
-            return 'vendor';
-        }
-    };
+  const cache = options.cache ?? new SplitVendorChunkCache();
+  return (id, { getModuleInfo }) => {
+    if (isInNodeModules(id) && !isCSSRequest(id) && staticImportedByEntry(id, getModuleInfo, cache.cache)) {
+      return "vendor";
+    }
+  };
 }
 function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
-    if (cache.has(id)) {
-        return cache.get(id);
-    }
-    if (importStack.includes(id)) {
-        // circular deps!
-        cache.set(id, false);
-        return false;
-    }
-    const mod = getModuleInfo(id);
-    if (!mod) {
-        cache.set(id, false);
-        return false;
-    }
-    if (mod.isEntry) {
-        cache.set(id, true);
-        return true;
-    }
-    const someImporterIs = mod.importers.some((importer) => staticImportedByEntry(importer, getModuleInfo, cache, importStack.concat(id)));
-    cache.set(id, someImporterIs);
-    return someImporterIs;
+  if (cache.has(id)) {
+    return cache.get(id);
+  }
+  if (importStack.includes(id)) {
+    cache.set(id, false);
+    return false;
+  }
+  const mod = getModuleInfo(id);
+  if (!mod) {
+    cache.set(id, false);
+    return false;
+  }
+  if (mod.isEntry) {
+    cache.set(id, true);
+    return true;
+  }
+  const someImporterIs = mod.importers.some(
+    (importer) => staticImportedByEntry(
+      importer,
+      getModuleInfo,
+      cache,
+      importStack.concat(id)
+    )
+  );
+  cache.set(id, someImporterIs);
+  return someImporterIs;
 }
-/**
- * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
- */
 function splitVendorChunkPlugin() {
-    const caches = [];
-    function createSplitVendorChunk(output, config) {
-        const cache = new SplitVendorChunkCache();
-        caches.push(cache);
-        const build = config.build ?? {};
-        const format = output?.format;
-        if (!build.ssr && !build.lib && format !== 'umd' && format !== 'iife') {
-            return splitVendorChunk({ cache });
-        }
+  const caches = [];
+  function createSplitVendorChunk(output, config) {
+    const cache = new SplitVendorChunkCache();
+    caches.push(cache);
+    const build = config.build ?? {};
+    const format = output?.format;
+    if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
+      return splitVendorChunk({ cache });
     }
-    return {
-        name: 'vite:split-vendor-chunk',
-        config(config) {
-            let outputs = config?.build?.rollupOptions?.output;
-            if (outputs) {
-                outputs = arraify(outputs);
-                for (const output of outputs) {
-                    const viteManualChunks = createSplitVendorChunk(output, config);
-                    if (viteManualChunks) {
-                        if (output.manualChunks) {
-                            if (typeof output.manualChunks === 'function') {
-                                const userManualChunks = output.manualChunks;
-                                output.manualChunks = (id, api) => {
-                                    return userManualChunks(id, api) ?? viteManualChunks(id, api);
-                                };
-                            }
-                            else {
-                                // else, leave the object form of manualChunks untouched, as
-                                // we can't safely replicate rollup handling.
-                                // eslint-disable-next-line no-console
-                                console.warn("(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead.");
-                            }
-                        }
-                        else {
-                            output.manualChunks = viteManualChunks;
-                        }
-                    }
-                }
-            }
-            else {
-                return {
-                    build: {
-                        rollupOptions: {
-                            output: {
-                                manualChunks: createSplitVendorChunk({}, config),
-                            },
-                        },
-                    },
+  }
+  return {
+    name: "vite:split-vendor-chunk",
+    config(config) {
+      let outputs = config?.build?.rollupOptions?.output;
+      if (outputs) {
+        outputs = arraify(outputs);
+        for (const output of outputs) {
+          const viteManualChunks = createSplitVendorChunk(output, config);
+          if (viteManualChunks) {
+            if (output.manualChunks) {
+              if (typeof output.manualChunks === "function") {
+                const userManualChunks = output.manualChunks;
+                output.manualChunks = (id, api) => {
+                  return userManualChunks(id, api) ?? viteManualChunks(id, api);
                 };
+              } else {
+                console.warn(
+                  "(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead."
+                );
+              }
+            } else {
+              output.manualChunks = viteManualChunks;
             }
-        },
-        buildStart() {
-            caches.forEach((cache) => cache.reset());
-        },
-    };
+          }
+        }
+      } else {
+        return {
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
+            }
+          }
+        };
+      }
+    },
+    buildStart() {
+      caches.forEach((cache) => cache.reset());
+    }
+  };
 }
 
 var convertSourceMap$1 = {};
@@ -5330,319 +5285,291 @@ class MagicString {
 	}
 }
 
-const debug$1 = createDebugger('vite:sourcemap', {
-    onlyWhenFocused: true,
+const debug$1 = createDebugger("vite:sourcemap", {
+  onlyWhenFocused: true
 });
 function genSourceMapUrl(map) {
-    if (typeof map !== 'string') {
-        map = JSON.stringify(map);
-    }
-    return `data:application/json;base64,${Buffer.from(map).toString('base64')}`;
+  if (typeof map !== "string") {
+    map = JSON.stringify(map);
+  }
+  return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
 }
 function getCodeWithSourcemap(type, code, map) {
-    if (debug$1) {
-        code += `\n/*${JSON.stringify(map, null, 2).replace(/\*\//g, '*\\/')}*/\n`;
-    }
-    if (type === 'js') {
-        code += `\n//# sourceMappingURL=${genSourceMapUrl(map)}`;
-    }
-    else if (type === 'css') {
-        code += `\n/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
-    }
-    return code;
+  if (debug$1) {
+    code += `
+/*${JSON.stringify(map, null, 2).replace(/\*\//g, "*\\/")}*/
+`;
+  }
+  if (type === "js") {
+    code += `
+//# sourceMappingURL=${genSourceMapUrl(map)}`;
+  } else if (type === "css") {
+    code += `
+/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
+  }
+  return code;
 }
 
-const debug = createDebugger('vite:send', {
-    onlyWhenFocused: true,
+const debug = createDebugger("vite:send", {
+  onlyWhenFocused: true
 });
 const alias = {
-    js: 'text/javascript',
-    css: 'text/css',
-    html: 'text/html',
-    json: 'application/json',
+  js: "text/javascript",
+  css: "text/css",
+  html: "text/html",
+  json: "application/json"
 };
 function send(req, res, content, type, options) {
-    const { etag = getEtag(content, { weak: true }), cacheControl = 'no-cache', headers, map, } = options;
-    if (res.writableEnded) {
-        return;
-    }
-    if (req.headers['if-none-match'] === etag) {
-        res.statusCode = 304;
-        res.end();
-        return;
-    }
-    res.setHeader('Content-Type', alias[type] || type);
-    res.setHeader('Cache-Control', cacheControl);
-    res.setHeader('Etag', etag);
-    if (headers) {
-        for (const name in headers) {
-            res.setHeader(name, headers[name]);
-        }
+  const {
+    etag = getEtag(content, { weak: true }),
+    cacheControl = "no-cache",
+    headers,
+    map
+  } = options;
+  if (res.writableEnded) {
+    return;
+  }
+  if (req.headers["if-none-match"] === etag) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  res.setHeader("Content-Type", alias[type] || type);
+  res.setHeader("Cache-Control", cacheControl);
+  res.setHeader("Etag", etag);
+  if (headers) {
+    for (const name in headers) {
+      res.setHeader(name, headers[name]);
     }
-    // inject source map reference
-    if (map && 'version' in map && map.mappings) {
-        if (type === 'js' || type === 'css') {
-            content = getCodeWithSourcemap(type, content.toString(), map);
-        }
+  }
+  if (map && "version" in map && map.mappings) {
+    if (type === "js" || type === "css") {
+      content = getCodeWithSourcemap(type, content.toString(), map);
     }
-    // inject fallback sourcemap for js for improved debugging
-    // https://github.com/vitejs/vite/pull/13514#issuecomment-1592431496
-    else if (type === 'js' && (!map || map.mappings !== '')) {
-        const code = content.toString();
-        // if the code has existing inline sourcemap, assume it's correct and skip
-        if (convertSourceMap.mapFileCommentRegex.test(code)) {
-            debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
-        }
-        else {
-            const urlWithoutTimestamp = removeTimestampQuery(req.url);
-            const ms = new MagicString(code);
-            content = getCodeWithSourcemap(type, code, ms.generateMap({
-                source: path$3.basename(urlWithoutTimestamp),
-                hires: 'boundary',
-                includeContent: true,
-            }));
-        }
+  } else if (type === "js" && (!map || map.mappings !== "")) {
+    const code = content.toString();
+    if (convertSourceMap.mapFileCommentRegex.test(code)) {
+      debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+    } else {
+      const urlWithoutTimestamp = removeTimestampQuery(req.url);
+      const ms = new MagicString(code);
+      content = getCodeWithSourcemap(
+        type,
+        code,
+        ms.generateMap({
+          source: path$3.basename(urlWithoutTimestamp),
+          hires: "boundary",
+          includeContent: true
+        })
+      );
     }
-    res.statusCode = 200;
-    res.end(content);
-    return;
+  }
+  res.statusCode = 200;
+  res.end(content);
+  return;
 }
 
-/* eslint no-console: 0 */
 const LogLevels = {
-    silent: 0,
-    error: 1,
-    warn: 2,
-    info: 3,
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3
 };
 let lastType;
 let lastMsg;
 let sameCount = 0;
 function clearScreen() {
-    const repeatCount = process.stdout.rows - 2;
-    const blank = repeatCount > 0 ? '\n'.repeat(repeatCount) : '';
-    console.log(blank);
-    readline.cursorTo(process.stdout, 0, 0);
-    readline.clearScreenDown(process.stdout);
+  const repeatCount = process.stdout.rows - 2;
+  const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+  console.log(blank);
+  readline.cursorTo(process.stdout, 0, 0);
+  readline.clearScreenDown(process.stdout);
 }
-// Only initialize the timeFormatter when the timestamp option is used, and
-// reuse it across all loggers
 let timeFormatter;
 function getTimeFormatter() {
-    timeFormatter ??= new Intl.DateTimeFormat(undefined, {
-        hour: 'numeric',
-        minute: 'numeric',
-        second: 'numeric',
-    });
-    return timeFormatter;
+  timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  return timeFormatter;
 }
-const MAX_LOG_CHAR = 5000;
-function createLogger(level = 'info', options = {}) {
-    if (options.customLogger) {
-        return options.customLogger;
-    }
-    const loggedErrors = new WeakSet();
-    const { prefix = '[vite]', allowClearScreen = true } = options;
-    const thresh = LogLevels[level];
-    const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
-    const clear = canClearScreen ? clearScreen : () => { };
-    function preventOverflow(msg) {
-        if (msg.length > MAX_LOG_CHAR) {
-            const shorten = msg.slice(0, MAX_LOG_CHAR);
-            const lines = msg.slice(MAX_LOG_CHAR).match(splitRE)?.length || 0;
-            return `${shorten}\n... and ${lines} lines more`;
-        }
-        return msg;
+function createLogger(level = "info", options = {}) {
+  if (options.customLogger) {
+    return options.customLogger;
+  }
+  const loggedErrors = /* @__PURE__ */ new WeakSet();
+  const { prefix = "[vite]", allowClearScreen = true } = options;
+  const thresh = LogLevels[level];
+  const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+  const clear = canClearScreen ? clearScreen : () => {
+  };
+  function format(type, msg, options2 = {}) {
+    if (options2.timestamp) {
+      let tag = "";
+      if (type === "info") {
+        tag = colors.cyan(colors.bold(prefix));
+      } else if (type === "warn") {
+        tag = colors.yellow(colors.bold(prefix));
+      } else {
+        tag = colors.red(colors.bold(prefix));
+      }
+      const environment = options2.environment ? options2.environment + " " : "";
+      return `${colors.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
+    } else {
+      return msg;
     }
-    function format(type, rawMsg, options = {}) {
-        const msg = preventOverflow(rawMsg);
-        if (options.timestamp) {
-            const color = type === 'info'
-                ? colors.cyan
-                : type === 'warn'
-                    ? colors.yellow
-                    : colors.red;
-            const tag = color(colors.bold(prefix));
-            const environment = options.environment ? options.environment + ' ' : '';
-            return `${colors.dim(getTimeFormatter().format(new Date()))} ${tag} ${environment}${msg}`;
-        }
-        else {
-            return msg;
+  }
+  function output(type, msg, options2 = {}) {
+    if (thresh >= LogLevels[type]) {
+      const method = type === "info" ? "log" : type;
+      if (options2.error) {
+        loggedErrors.add(options2.error);
+      }
+      if (canClearScreen) {
+        if (type === lastType && msg === lastMsg) {
+          sameCount++;
+          clear();
+          console[method](
+            format(type, msg, options2),
+            colors.yellow(`(x${sameCount + 1})`)
+          );
+        } else {
+          sameCount = 0;
+          lastMsg = msg;
+          lastType = type;
+          if (options2.clear) {
+            clear();
+          }
+          console[method](format(type, msg, options2));
         }
+      } else {
+        console[method](format(type, msg, options2));
+      }
     }
-    function output(type, msg, options = {}) {
-        if (thresh >= LogLevels[type]) {
-            const method = type === 'info' ? 'log' : type;
-            if (options.error) {
-                loggedErrors.add(options.error);
-            }
-            if (canClearScreen) {
-                if (type === lastType && msg === lastMsg) {
-                    sameCount++;
-                    clear();
-                    console[method](format(type, msg, options), colors.yellow(`(x${sameCount + 1})`));
-                }
-                else {
-                    sameCount = 0;
-                    lastMsg = msg;
-                    lastType = type;
-                    if (options.clear) {
-                        clear();
-                    }
-                    console[method](format(type, msg, options));
-                }
-            }
-            else {
-                console[method](format(type, msg, options));
-            }
-        }
+  }
+  const warnedMessages = /* @__PURE__ */ new Set();
+  const logger = {
+    hasWarned: false,
+    info(msg, opts) {
+      output("info", msg, opts);
+    },
+    warn(msg, opts) {
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+    },
+    warnOnce(msg, opts) {
+      if (warnedMessages.has(msg)) return;
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+      warnedMessages.add(msg);
+    },
+    error(msg, opts) {
+      logger.hasWarned = true;
+      output("error", msg, opts);
+    },
+    clearScreen(type) {
+      if (thresh >= LogLevels[type]) {
+        clear();
+      }
+    },
+    hasErrorLogged(error) {
+      return loggedErrors.has(error);
     }
-    const warnedMessages = new Set();
-    const logger = {
-        hasWarned: false,
-        info(msg, opts) {
-            output('info', msg, opts);
-        },
-        warn(msg, opts) {
-            logger.hasWarned = true;
-            output('warn', msg, opts);
-        },
-        warnOnce(msg, opts) {
-            if (warnedMessages.has(msg))
-                return;
-            logger.hasWarned = true;
-            output('warn', msg, opts);
-            warnedMessages.add(msg);
-        },
-        error(msg, opts) {
-            logger.hasWarned = true;
-            output('error', msg, opts);
-        },
-        clearScreen(type) {
-            if (thresh >= LogLevels[type]) {
-                clear();
-            }
-        },
-        hasErrorLogged(error) {
-            return loggedErrors.has(error);
-        },
-    };
-    return logger;
+  };
+  return logger;
 }
 
-// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
 const ROOT_FILES = [
-    // '.git',
-    // https://pnpm.io/workspaces/
-    'pnpm-workspace.yaml',
-    // https://rushjs.io/pages/advanced/config_files/
-    // 'rush.json',
-    // https://nx.dev/latest/react/getting-started/nx-setup
-    // 'workspace.json',
-    // 'nx.json',
-    // https://github.com/lerna/lerna#lernajson
-    'lerna.json',
+  // '.git',
+  // https://pnpm.io/workspaces/
+  "pnpm-workspace.yaml",
+  // https://rushjs.io/pages/advanced/config_files/
+  // 'rush.json',
+  // https://nx.dev/latest/react/getting-started/nx-setup
+  // 'workspace.json',
+  // 'nx.json',
+  // https://github.com/lerna/lerna#lernajson
+  "lerna.json"
 ];
-// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
-// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
 function hasWorkspacePackageJSON(root) {
-    const path = path$3.join(root, 'package.json');
-    if (!isFileReadable(path)) {
-        return false;
-    }
-    try {
-        const content = JSON.parse(fs$1.readFileSync(path, 'utf-8')) || {};
-        return !!content.workspaces;
-    }
-    catch {
-        return false;
-    }
+  const path = path$3.join(root, "package.json");
+  if (!isFileReadable(path)) {
+    return false;
+  }
+  try {
+    const content = JSON.parse(fs$1.readFileSync(path, "utf-8")) || {};
+    return !!content.workspaces;
+  } catch {
+    return false;
+  }
 }
 function hasRootFile(root) {
-    return ROOT_FILES.some((file) => fs$1.existsSync(path$3.join(root, file)));
+  return ROOT_FILES.some((file) => fs$1.existsSync(path$3.join(root, file)));
 }
 function hasPackageJSON(root) {
-    const path = path$3.join(root, 'package.json');
-    return fs$1.existsSync(path);
+  const path = path$3.join(root, "package.json");
+  return fs$1.existsSync(path);
 }
-/**
- * Search up for the nearest `package.json`
- */
 function searchForPackageRoot(current, root = current) {
-    if (hasPackageJSON(current))
-        return current;
-    const dir = path$3.dirname(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForPackageRoot(dir, root);
+  if (hasPackageJSON(current)) return current;
+  const dir = path$3.dirname(current);
+  if (!dir || dir === current) return root;
+  return searchForPackageRoot(dir, root);
 }
-/**
- * Search up for the nearest workspace root
- */
 function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
-    if (hasRootFile(current))
-        return current;
-    if (hasWorkspacePackageJSON(current))
-        return current;
-    const dir = path$3.dirname(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForWorkspaceRoot(dir, root);
+  if (hasRootFile(current)) return current;
+  if (hasWorkspacePackageJSON(current)) return current;
+  const dir = path$3.dirname(current);
+  if (!dir || dir === current) return root;
+  return searchForWorkspaceRoot(dir, root);
 }
 
-const safeModulePathsCache = new WeakMap();
+const safeModulePathsCache = /* @__PURE__ */ new WeakMap();
 function isSafeModulePath(config, filePath) {
-    let safeModulePaths = safeModulePathsCache.get(config);
-    if (!safeModulePaths) {
-        safeModulePaths = new Set();
-        safeModulePathsCache.set(config, safeModulePaths);
-    }
-    return safeModulePaths.has(filePath);
+  let safeModulePaths = safeModulePathsCache.get(config);
+  if (!safeModulePaths) {
+    safeModulePaths = /* @__PURE__ */ new Set();
+    safeModulePathsCache.set(config, safeModulePaths);
+  }
+  return safeModulePaths.has(filePath);
 }
-const fsDenyGlobCache = new WeakMap();
+const fsDenyGlobCache = /* @__PURE__ */ new WeakMap();
 function fsDenyGlob(config, filePath) {
-    let matcher = fsDenyGlobCache.get(config);
-    if (!matcher) {
-        (matcher = picomatch$1(
-        // matchBase: true does not work as it's documented
-        // https://github.com/micromatch/picomatch/issues/89
-        // convert patterns without `/` on our side for now
-        config.server.fs.deny.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`), {
-            matchBase: false,
-            nocase: true,
-            dot: true,
-        })),
-            fsDenyGlobCache.set(config, matcher);
-    }
-    return matcher(filePath);
+  let matcher = fsDenyGlobCache.get(config);
+  if (!matcher) {
+    matcher = picomatch$1(
+      // matchBase: true does not work as it's documented
+      // https://github.com/micromatch/picomatch/issues/89
+      // convert patterns without `/` on our side for now
+      config.server.fs.deny.map(
+        (pattern) => pattern.includes("/") ? pattern : `**/${pattern}`
+      ),
+      {
+        matchBase: false,
+        nocase: true,
+        dot: true
+      }
+    ), fsDenyGlobCache.set(config, matcher);
+  }
+  return matcher(filePath);
 }
-/**
- * Check if the url is allowed to be served, via the `server.fs` config.
- * @deprecated use isFileLoadingAllowed
- */
 function isFileServingAllowed(url, server) {
-    const { config } = server;
-    if (!config.server.fs.strict)
-        return true;
-    const filePath = fsPathFromUrl(url);
-    return isFileLoadingAllowed(config, filePath);
+  const { config } = server;
+  if (!config.server.fs.strict) return true;
+  const filePath = fsPathFromUrl(url);
+  return isFileLoadingAllowed(config, filePath);
 }
 function isUriInFilePath(uri, filePath) {
-    return isSameFileUri(uri, filePath) || isParentDirectory(uri, filePath);
+  return isSameFileUri(uri, filePath) || isParentDirectory(uri, filePath);
 }
 function isFileLoadingAllowed(config, filePath) {
-    const { fs } = config.server;
-    if (!fs.strict)
-        return true;
-    if (fsDenyGlob(config, filePath))
-        return false;
-    if (isSafeModulePath(config, filePath))
-        return true;
-    if (fs.allow.some((uri) => isUriInFilePath(uri, filePath)))
-        return true;
-    return false;
+  const { fs } = config.server;
+  if (!fs.strict) return true;
+  if (fsDenyGlob(config, filePath)) return false;
+  if (isSafeModulePath(config, filePath)) return true;
+  if (fs.allow.some((uri) => isUriInFilePath(uri, filePath))) return true;
+  return false;
 }
 
 var main$1 = {exports: {}};
@@ -6178,62 +6105,65 @@ function expand (options) {
 var expand_1 = expand;
 
 function getEnvFilesForMode(mode, envDir) {
-    return [
-        /** default file */ `.env`,
-        /** local file */ `.env.local`,
-        /** mode file */ `.env.${mode}`,
-        /** mode local file */ `.env.${mode}.local`,
-    ].map((file) => normalizePath(path$3.join(envDir, file)));
+  return [
+    /** default file */
+    `.env`,
+    /** local file */
+    `.env.local`,
+    /** mode file */
+    `.env.${mode}`,
+    /** mode local file */
+    `.env.${mode}.local`
+  ].map((file) => normalizePath(path$3.join(envDir, file)));
 }
-function loadEnv(mode, envDir, prefixes = 'VITE_') {
-    if (mode === 'local') {
-        throw new Error(`"local" cannot be used as a mode name because it conflicts with ` +
-            `the .local postfix for .env files.`);
-    }
-    prefixes = arraify(prefixes);
-    const env = {};
-    const envFiles = getEnvFilesForMode(mode, envDir);
-    const parsed = Object.fromEntries(envFiles.flatMap((filePath) => {
-        if (!tryStatSync(filePath)?.isFile())
-            return [];
-        return Object.entries(parse_1(fs$1.readFileSync(filePath)));
-    }));
-    // test NODE_ENV override before expand as otherwise process.env.NODE_ENV would override this
-    if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === undefined) {
-        process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
-    }
-    // support BROWSER and BROWSER_ARGS env variables
-    if (parsed.BROWSER && process.env.BROWSER === undefined) {
-        process.env.BROWSER = parsed.BROWSER;
-    }
-    if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === undefined) {
-        process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
-    }
-    // let environment variables use each other. make a copy of `process.env` so that `dotenv-expand`
-    // doesn't re-assign the expanded values to the global `process.env`.
-    const processEnv = { ...process.env };
-    expand_1({ parsed, processEnv });
-    // only keys that start with prefix are exposed to client
-    for (const [key, value] of Object.entries(parsed)) {
-        if (prefixes.some((prefix) => key.startsWith(prefix))) {
-            env[key] = value;
-        }
+function loadEnv(mode, envDir, prefixes = "VITE_") {
+  if (mode === "local") {
+    throw new Error(
+      `"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
+    );
+  }
+  prefixes = arraify(prefixes);
+  const env = {};
+  const envFiles = getEnvFilesForMode(mode, envDir);
+  const parsed = Object.fromEntries(
+    envFiles.flatMap((filePath) => {
+      if (!tryStatSync(filePath)?.isFile()) return [];
+      return Object.entries(parse_1(fs$1.readFileSync(filePath)));
+    })
+  );
+  if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) {
+    process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
+  }
+  if (parsed.BROWSER && process.env.BROWSER === void 0) {
+    process.env.BROWSER = parsed.BROWSER;
+  }
+  if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === void 0) {
+    process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
+  }
+  const processEnv = { ...process.env };
+  expand_1({ parsed, processEnv });
+  for (const [key, value] of Object.entries(parsed)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = value;
     }
-    // check if there are actual env variables starting with VITE_*
-    // these are typically provided inline and should be prioritized
-    for (const key in process.env) {
-        if (prefixes.some((prefix) => key.startsWith(prefix))) {
-            env[key] = process.env[key];
-        }
+  }
+  for (const key in process.env) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = process.env[key];
     }
-    return env;
+  }
+  return env;
 }
-function resolveEnvPrefix({ envPrefix = 'VITE_', }) {
-    envPrefix = arraify(envPrefix);
-    if (envPrefix.includes('')) {
-        throw new Error(`envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`);
-    }
-    return envPrefix;
+function resolveEnvPrefix({
+  envPrefix = "VITE_"
+}) {
+  envPrefix = arraify(envPrefix);
+  if (envPrefix.includes("")) {
+    throw new Error(
+      `envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
+    );
+  }
+  return envPrefix;
 }
 
 exports.esbuildVersion = esbuild.version;