vite 6.1.0 → 6.1.1

package/dist/node/chunks/{dep-CfG9u7Cn.js → dep-Cg8OuIew.js}

@@ -7,7 +7,7 @@ import { promisify as promisify$4, format as format$2, inspect, stripVTControlCh
 import { performance } from 'node:perf_hooks';
 import require$$0$6, { createRequire as createRequire$1, builtinModules } from 'node:module';
 import crypto$2 from 'node:crypto';
-import esbuild, { transform as transform$1, formatMessages, build as build$b } from 'esbuild';
+import esbuild, { transform as transform$1, formatMessages, build as build$j } from 'esbuild';
 import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, ENV_ENTRY, DEP_VERSION_RE, SPECIAL_QUERY_RE, DEV_PROD_CONDITION, JS_TYPES_RE, KNOWN_ASSET_TYPES, CSS_LANGS_RE, METADATA_FILENAME, ESBUILD_MODULES_TARGET, ERR_OPTIMIZE_DEPS_PROCESSING_ERROR, ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, defaultAllowedOrigins, CLIENT_DIR, VERSION, ROLLUP_HOOKS, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES, DEFAULT_CLIENT_MAIN_FIELDS, DEFAULT_SERVER_MAIN_FIELDS, DEFAULT_CLIENT_CONDITIONS, DEFAULT_SERVER_CONDITIONS } from '../constants.js';
 import require$$0$2, { posix, win32, isAbsolute, resolve as resolve$3, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join, sep } from 'path';
 import require$$0$3, { existsSync, readFileSync, statSync, readdirSync } from 'fs';
@@ -24,6 +24,7 @@ import require$$0$8 from 'stream';
 import require$$2 from 'os';
 import require$$2$1 from 'child_process';
 import os$3 from 'node:os';
+import net$1 from 'node:net';
 import { promises } from 'node:dns';
 import { ModuleRunner, ESModulesEvaluator } from 'vite/module-runner';
 import { parseAstAsync, parseAst } from 'rollup/parseAst';
@@ -40,7 +41,6 @@ import zlib$1 from 'zlib';
 import require$$0$9 from 'buffer';
 import require$$1$3 from 'https';
 import require$$4$2 from 'tls';
-import net$1 from 'node:net';
 import require$$4$3 from 'assert';
 import * as qs from 'node:querystring';
 import { gzip } from 'node:zlib';
@@ -135,7 +135,7 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 var colors$1 = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
-var utils$d = {};
+var utils$e = {};
 
 const WIN_SLASH$1 = '\\\\/';
 const WIN_NO_SLASH$1 = `[^${WIN_SLASH$1}]`;
@@ -388,9 +388,9 @@ var constants$8 = {
 
 	  return last;
 	}; 
-} (utils$d));
+} (utils$e));
 
-const utils$c = utils$d;
+const utils$d = utils$e;
 const {
   CHAR_ASTERISK: CHAR_ASTERISK$1,             /* * */
   CHAR_AT: CHAR_AT$1,                   /* @ */
@@ -707,10 +707,10 @@ const scan$3 = (input, options) => {
   }
 
   if (opts.unescape === true) {
-    if (glob) glob = utils$c.removeBackslashes(glob);
+    if (glob) glob = utils$d.removeBackslashes(glob);
 
     if (base && backslashes === true) {
-      base = utils$c.removeBackslashes(base);
+      base = utils$d.removeBackslashes(base);
     }
   }
 
@@ -781,7 +781,7 @@ const scan$3 = (input, options) => {
 var scan_1$1 = scan$3;
 
 const constants$7 = constants$8;
-const utils$b = utils$d;
+const utils$c = utils$e;
 
 /**
  * Constants
@@ -899,7 +899,7 @@ const parse$h = (input, options) => {
     tokens
   };
 
-  input = utils$b.removePrefix(input, state);
+  input = utils$c.removePrefix(input, state);
   len = input.length;
 
   const extglobs = [];
@@ -1092,7 +1092,7 @@ const parse$h = (input, options) => {
       return state;
     }
 
-    state.output = utils$b.wrapOutput(output, state, options);
+    state.output = utils$c.wrapOutput(output, state, options);
     return state;
   }
 
@@ -1205,7 +1205,7 @@ const parse$h = (input, options) => {
      */
 
     if (state.quotes === 1 && value !== '"') {
-      value = utils$b.escapeRegex(value);
+      value = utils$c.escapeRegex(value);
       prev.value += value;
       append({ value });
       continue;
@@ -1295,11 +1295,11 @@ const parse$h = (input, options) => {
 
       // when literal brackets are explicitly disabled
       // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$b.hasRegexChars(prevValue)) {
+      if (opts.literalBrackets === false || utils$c.hasRegexChars(prevValue)) {
         continue;
       }
 
-      const escaped = utils$b.escapeRegex(prev.value);
+      const escaped = utils$c.escapeRegex(prev.value);
       state.output = state.output.slice(0, -prev.value.length);
 
       // when literal brackets are explicitly enabled
@@ -1727,19 +1727,19 @@ const parse$h = (input, options) => {
 
   while (state.brackets > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ']'));
-    state.output = utils$b.escapeLast(state.output, '[');
+    state.output = utils$c.escapeLast(state.output, '[');
     decrement('brackets');
   }
 
   while (state.parens > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ')'));
-    state.output = utils$b.escapeLast(state.output, '(');
+    state.output = utils$c.escapeLast(state.output, '(');
     decrement('parens');
   }
 
   while (state.braces > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', '}'));
-    state.output = utils$b.escapeLast(state.output, '{');
+    state.output = utils$c.escapeLast(state.output, '{');
     decrement('braces');
   }
 
@@ -1845,7 +1845,7 @@ parse$h.fastpaths = (input, options) => {
     }
   };
 
-  const output = utils$b.removePrefix(input, state);
+  const output = utils$c.removePrefix(input, state);
   let source = create(output);
 
   if (source && opts.strictSlashes !== true) {
@@ -1859,7 +1859,7 @@ var parse_1$4 = parse$h;
 
 const scan$2 = scan_1$1;
 const parse$g = parse_1$4;
-const utils$a = utils$d;
+const utils$b = utils$e;
 const constants$6 = constants$8;
 const isObject$4 = val => val && typeof val === 'object' && !Array.isArray(val);
 
@@ -1980,7 +1980,7 @@ picomatch$6.test = (input, regex, options, { glob, posix } = {}) => {
   }
 
   const opts = options || {};
-  const format = opts.format || (posix ? utils$a.toPosixSlashes : null);
+  const format = opts.format || (posix ? utils$b.toPosixSlashes : null);
   let match = input === glob;
   let output = (match && format) ? format(input) : input;
 
@@ -2016,7 +2016,7 @@ picomatch$6.test = (input, regex, options, { glob, posix } = {}) => {
 
 picomatch$6.matchBase = (input, glob, options) => {
   const regex = glob instanceof RegExp ? glob : picomatch$6.makeRe(glob, options);
-  return regex.test(utils$a.basename(input));
+  return regex.test(utils$b.basename(input));
 };
 
 /**
@@ -2198,13 +2198,13 @@ picomatch$6.constants = constants$6;
 var picomatch_1$2 = picomatch$6;
 
 const pico = picomatch_1$2;
-const utils$9 = utils$d;
+const utils$a = utils$e;
 
 function picomatch$4(glob, options, returnState = false) {
   // default to os.platform()
   if (options && (options.windows === null || options.windows === undefined)) {
     // don't mutate the original options object
-    options = { ...options, windows: utils$9.isWindows() };
+    options = { ...options, windows: utils$a.isWindows() };
   }
 
   return pico(glob, options, returnState);
@@ -2610,23 +2610,23 @@ function ensureArray(thing) {
 }
 
 const normalizePathRegExp = new RegExp(`\\${win32.sep}`, 'g');
-const normalizePath$6 = function normalizePath(filename) {
+const normalizePath$7 = function normalizePath(filename) {
     return filename.replace(normalizePathRegExp, posix.sep);
 };
 
 function getMatcherString(id, resolutionBase) {
     if (resolutionBase === false || isAbsolute(id) || id.startsWith('**')) {
-        return normalizePath$6(id);
+        return normalizePath$7(id);
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath$6(resolve$3(resolutionBase || ''))
+    const basePath = normalizePath$7(resolve$3(resolutionBase || ''))
         // escape all possible (posix + win) path characters that might interfere with regex
         .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
     // Note that we use posix.join because:
     // 1. the basePath has been normalized to use /
     // 2. the incoming glob (id) matcher, also uses /
     // otherwise Node will force backslash (\) on windows
-    return posix.join(basePath, normalizePath$6(id));
+    return posix.join(basePath, normalizePath$7(id));
 }
 const createFilter$1 = function createFilter(include, exclude, options) {
     const resolutionBase = options && options.resolve;
@@ -2650,7 +2650,7 @@ const createFilter$1 = function createFilter(include, exclude, options) {
             return false;
         if (id.includes('\0'))
             return false;
-        const pathId = normalizePath$6(id);
+        const pathId = normalizePath$7(id);
         for (let i = 0; i < excludeMatchers.length; ++i) {
             const matcher = excludeMatchers[i];
             if (matcher instanceof RegExp) {
@@ -2830,98 +2830,98 @@ var commondir = function (basedir, relfiles) {
 
 var getCommonDir = /*@__PURE__*/getDefaultExportFromCjs(commondir);
 
-var dist = {};
+var dist$1 = {};
 
-var builder = {};
+var builder$1 = {};
 
-var apiBuilder = {};
+var apiBuilder$1 = {};
 
-var async = {};
+var async$1 = {};
 
-var walker = {};
+var walker$1 = {};
 
-var utils$8 = {};
+var utils$9 = {};
 
-Object.defineProperty(utils$8, "__esModule", { value: true });
-utils$8.normalizePath = utils$8.convertSlashes = utils$8.cleanPath = undefined;
-const path_1$4 = require$$0$2;
-function cleanPath(path) {
-    let normalized = (0, path_1$4.normalize)(path);
+Object.defineProperty(utils$9, "__esModule", { value: true });
+utils$9.normalizePath = utils$9.convertSlashes = utils$9.cleanPath = undefined;
+const path_1$9 = require$$0$2;
+function cleanPath$1(path) {
+    let normalized = (0, path_1$9.normalize)(path);
     // we have to remove the last path separator
     // to account for / root path
-    if (normalized.length > 1 && normalized[normalized.length - 1] === path_1$4.sep)
+    if (normalized.length > 1 && normalized[normalized.length - 1] === path_1$9.sep)
         normalized = normalized.substring(0, normalized.length - 1);
     return normalized;
 }
-utils$8.cleanPath = cleanPath;
-const SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path, separator) {
-    return path.replace(SLASHES_REGEX, separator);
+utils$9.cleanPath = cleanPath$1;
+const SLASHES_REGEX$1 = /[\\/]/g;
+function convertSlashes$1(path, separator) {
+    return path.replace(SLASHES_REGEX$1, separator);
 }
-utils$8.convertSlashes = convertSlashes;
-function normalizePath$5(path, options) {
+utils$9.convertSlashes = convertSlashes$1;
+function normalizePath$6(path, options) {
     const { resolvePaths, normalizePath, pathSeparator } = options;
     const pathNeedsCleaning = (process.platform === "win32" && path.includes("/")) ||
         path.startsWith(".");
     if (resolvePaths)
-        path = (0, path_1$4.resolve)(path);
+        path = (0, path_1$9.resolve)(path);
     if (normalizePath || pathNeedsCleaning)
-        path = cleanPath(path);
+        path = cleanPath$1(path);
     if (path === ".")
         return "";
     const needsSeperator = path[path.length - 1] !== pathSeparator;
-    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+    return convertSlashes$1(needsSeperator ? path + pathSeparator : path, pathSeparator);
 }
-utils$8.normalizePath = normalizePath$5;
+utils$9.normalizePath = normalizePath$6;
 
-var joinPath$2 = {};
+var joinPath$5 = {};
 
-Object.defineProperty(joinPath$2, "__esModule", { value: true });
-joinPath$2.build = joinPath$2.joinDirectoryPath = joinPath$2.joinPathWithBasePath = undefined;
-const path_1$3 = require$$0$2;
-const utils_1$1 = utils$8;
-function joinPathWithBasePath(filename, directoryPath) {
+Object.defineProperty(joinPath$5, "__esModule", { value: true });
+joinPath$5.build = joinPath$5.joinDirectoryPath = joinPath$5.joinPathWithBasePath = undefined;
+const path_1$8 = require$$0$2;
+const utils_1$3 = utils$9;
+function joinPathWithBasePath$1(filename, directoryPath) {
     return directoryPath + filename;
 }
-joinPath$2.joinPathWithBasePath = joinPathWithBasePath;
-function joinPathWithRelativePath(root, options) {
+joinPath$5.joinPathWithBasePath = joinPathWithBasePath$1;
+function joinPathWithRelativePath$1(root, options) {
     return function (filename, directoryPath) {
         const sameRoot = directoryPath.startsWith(root);
         if (sameRoot)
             return directoryPath.replace(root, "") + filename;
         else
-            return ((0, utils_1$1.convertSlashes)((0, path_1$3.relative)(root, directoryPath), options.pathSeparator) +
+            return ((0, utils_1$3.convertSlashes)((0, path_1$8.relative)(root, directoryPath), options.pathSeparator) +
                 options.pathSeparator +
                 filename);
     };
 }
-function joinPath$1(filename) {
+function joinPath$4(filename) {
     return filename;
 }
-function joinDirectoryPath(filename, directoryPath, separator) {
+function joinDirectoryPath$1(filename, directoryPath, separator) {
     return directoryPath + filename + separator;
 }
-joinPath$2.joinDirectoryPath = joinDirectoryPath;
-function build$a(root, options) {
+joinPath$5.joinDirectoryPath = joinDirectoryPath$1;
+function build$i(root, options) {
     const { relativePaths, includeBasePath } = options;
     return relativePaths && root
-        ? joinPathWithRelativePath(root, options)
+        ? joinPathWithRelativePath$1(root, options)
         : includeBasePath
-            ? joinPathWithBasePath
-            : joinPath$1;
+            ? joinPathWithBasePath$1
+            : joinPath$4;
 }
-joinPath$2.build = build$a;
+joinPath$5.build = build$i;
 
-var pushDirectory$2 = {};
+var pushDirectory$5 = {};
 
-Object.defineProperty(pushDirectory$2, "__esModule", { value: true });
-pushDirectory$2.build = undefined;
-function pushDirectoryWithRelativePath(root) {
+Object.defineProperty(pushDirectory$5, "__esModule", { value: true });
+pushDirectory$5.build = undefined;
+function pushDirectoryWithRelativePath$1(root) {
     return function (directoryPath, paths) {
         paths.push(directoryPath.substring(root.length) || ".");
     };
 }
-function pushDirectoryFilterWithRelativePath(root) {
+function pushDirectoryFilterWithRelativePath$1(root) {
     return function (directoryPath, paths, filters) {
         const relativePath = directoryPath.substring(root.length) || ".";
         if (filters.every((filter) => filter(relativePath, true))) {
@@ -2929,123 +2929,123 @@ function pushDirectoryFilterWithRelativePath(root) {
         }
     };
 }
-const pushDirectory$1 = (directoryPath, paths) => {
+const pushDirectory$4 = (directoryPath, paths) => {
     paths.push(directoryPath || ".");
 };
-const pushDirectoryFilter = (directoryPath, paths, filters) => {
+const pushDirectoryFilter$1 = (directoryPath, paths, filters) => {
     const path = directoryPath || ".";
     if (filters.every((filter) => filter(path, true))) {
         paths.push(path);
     }
 };
-const empty$2 = () => { };
-function build$9(root, options) {
+const empty$5 = () => { };
+function build$h(root, options) {
     const { includeDirs, filters, relativePaths } = options;
     if (!includeDirs)
-        return empty$2;
+        return empty$5;
     if (relativePaths)
         return filters && filters.length
-            ? pushDirectoryFilterWithRelativePath(root)
-            : pushDirectoryWithRelativePath(root);
-    return filters && filters.length ? pushDirectoryFilter : pushDirectory$1;
+            ? pushDirectoryFilterWithRelativePath$1(root)
+            : pushDirectoryWithRelativePath$1(root);
+    return filters && filters.length ? pushDirectoryFilter$1 : pushDirectory$4;
 }
-pushDirectory$2.build = build$9;
+pushDirectory$5.build = build$h;
 
-var pushFile$2 = {};
+var pushFile$5 = {};
 
-Object.defineProperty(pushFile$2, "__esModule", { value: true });
-pushFile$2.build = undefined;
-const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+Object.defineProperty(pushFile$5, "__esModule", { value: true });
+pushFile$5.build = undefined;
+const pushFileFilterAndCount$1 = (filename, _paths, counts, filters) => {
     if (filters.every((filter) => filter(filename, false)))
         counts.files++;
 };
-const pushFileFilter = (filename, paths, _counts, filters) => {
+const pushFileFilter$1 = (filename, paths, _counts, filters) => {
     if (filters.every((filter) => filter(filename, false)))
         paths.push(filename);
 };
-const pushFileCount = (_filename, _paths, counts, _filters) => {
+const pushFileCount$1 = (_filename, _paths, counts, _filters) => {
     counts.files++;
 };
-const pushFile$1 = (filename, paths) => {
+const pushFile$4 = (filename, paths) => {
     paths.push(filename);
 };
-const empty$1 = () => { };
-function build$8(options) {
+const empty$4 = () => { };
+function build$g(options) {
     const { excludeFiles, filters, onlyCounts } = options;
     if (excludeFiles)
-        return empty$1;
+        return empty$4;
     if (filters && filters.length) {
-        return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+        return onlyCounts ? pushFileFilterAndCount$1 : pushFileFilter$1;
     }
     else if (onlyCounts) {
-        return pushFileCount;
+        return pushFileCount$1;
     }
     else {
-        return pushFile$1;
+        return pushFile$4;
     }
 }
-pushFile$2.build = build$8;
+pushFile$5.build = build$g;
 
-var getArray$2 = {};
+var getArray$5 = {};
 
-Object.defineProperty(getArray$2, "__esModule", { value: true });
-getArray$2.build = undefined;
-const getArray$1 = (paths) => {
+Object.defineProperty(getArray$5, "__esModule", { value: true });
+getArray$5.build = undefined;
+const getArray$4 = (paths) => {
     return paths;
 };
-const getArrayGroup = () => {
+const getArrayGroup$1 = () => {
     return [""].slice(0, 0);
 };
-function build$7(options) {
-    return options.group ? getArrayGroup : getArray$1;
+function build$f(options) {
+    return options.group ? getArrayGroup$1 : getArray$4;
 }
-getArray$2.build = build$7;
+getArray$5.build = build$f;
 
-var groupFiles$2 = {};
+var groupFiles$5 = {};
 
-Object.defineProperty(groupFiles$2, "__esModule", { value: true });
-groupFiles$2.build = undefined;
-const groupFiles$1 = (groups, directory, files) => {
+Object.defineProperty(groupFiles$5, "__esModule", { value: true });
+groupFiles$5.build = undefined;
+const groupFiles$4 = (groups, directory, files) => {
     groups.push({ directory, files, dir: directory });
 };
-const empty = () => { };
-function build$6(options) {
-    return options.group ? groupFiles$1 : empty;
+const empty$3 = () => { };
+function build$e(options) {
+    return options.group ? groupFiles$4 : empty$3;
 }
-groupFiles$2.build = build$6;
+groupFiles$5.build = build$e;
 
-var resolveSymlink$1 = {};
+var resolveSymlink$3 = {};
 
-var __importDefault$1 = (resolveSymlink$1.__importDefault) || function (mod) {
+var __importDefault$3 = (resolveSymlink$3.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-Object.defineProperty(resolveSymlink$1, "__esModule", { value: true });
-resolveSymlink$1.build = undefined;
-const fs_1$1 = __importDefault$1(require$$0$3);
-const path_1$2 = require$$0$2;
-const resolveSymlinksAsync = function (path, state, callback) {
+Object.defineProperty(resolveSymlink$3, "__esModule", { value: true });
+resolveSymlink$3.build = undefined;
+const fs_1$3 = __importDefault$3(require$$0$3);
+const path_1$7 = require$$0$2;
+const resolveSymlinksAsync$1 = function (path, state, callback) {
     const { queue, options: { suppressErrors }, } = state;
     queue.enqueue();
-    fs_1$1.default.realpath(path, (error, resolvedPath) => {
+    fs_1$3.default.realpath(path, (error, resolvedPath) => {
         if (error)
             return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1$1.default.stat(resolvedPath, (error, stat) => {
+        fs_1$3.default.stat(resolvedPath, (error, stat) => {
             if (error)
                 return queue.dequeue(suppressErrors ? null : error, state);
-            if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+            if (stat.isDirectory() && isRecursive$1(path, resolvedPath, state))
                 return queue.dequeue(null, state);
             callback(stat, resolvedPath);
             queue.dequeue(null, state);
         });
     });
 };
-const resolveSymlinks = function (path, state, callback) {
+const resolveSymlinks$1 = function (path, state, callback) {
     const { queue, options: { suppressErrors }, } = state;
     queue.enqueue();
     try {
-        const resolvedPath = fs_1$1.default.realpathSync(path);
-        const stat = fs_1$1.default.statSync(resolvedPath);
-        if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+        const resolvedPath = fs_1$3.default.realpathSync(path);
+        const stat = fs_1$3.default.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive$1(path, resolvedPath, state))
             return;
         callback(stat, resolvedPath);
     }
@@ -3054,16 +3054,16 @@ const resolveSymlinks = function (path, state, callback) {
             throw e;
     }
 };
-function build$5(options, isSynchronous) {
+function build$d(options, isSynchronous) {
     if (!options.resolveSymlinks || options.excludeSymlinks)
         return null;
-    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+    return isSynchronous ? resolveSymlinks$1 : resolveSymlinksAsync$1;
 }
-resolveSymlink$1.build = build$5;
-function isRecursive(path, resolved, state) {
+resolveSymlink$3.build = build$d;
+function isRecursive$1(path, resolved, state) {
     if (state.options.useRealPaths)
-        return isRecursiveUsingRealPaths(resolved, state);
-    let parent = (0, path_1$2.dirname)(path);
+        return isRecursiveUsingRealPaths$1(resolved, state);
+    let parent = (0, path_1$7.dirname)(path);
     let depth = 1;
     while (parent !== state.root && depth < 2) {
         const resolvedPath = state.symlinks.get(parent);
@@ -3074,84 +3074,84 @@ function isRecursive(path, resolved, state) {
         if (isSameRoot)
             depth++;
         else
-            parent = (0, path_1$2.dirname)(parent);
+            parent = (0, path_1$7.dirname)(parent);
     }
     state.symlinks.set(path, resolved);
     return depth > 1;
 }
-function isRecursiveUsingRealPaths(resolved, state) {
+function isRecursiveUsingRealPaths$1(resolved, state) {
     return state.visited.includes(resolved + state.options.pathSeparator);
 }
 
-var invokeCallback$1 = {};
+var invokeCallback$3 = {};
 
-Object.defineProperty(invokeCallback$1, "__esModule", { value: true });
-invokeCallback$1.build = undefined;
-const onlyCountsSync = (state) => {
+Object.defineProperty(invokeCallback$3, "__esModule", { value: true });
+invokeCallback$3.build = undefined;
+const onlyCountsSync$1 = (state) => {
     return state.counts;
 };
-const groupsSync = (state) => {
+const groupsSync$1 = (state) => {
     return state.groups;
 };
-const defaultSync = (state) => {
+const defaultSync$1 = (state) => {
     return state.paths;
 };
-const limitFilesSync = (state) => {
+const limitFilesSync$1 = (state) => {
     return state.paths.slice(0, state.options.maxFiles);
 };
-const onlyCountsAsync = (state, error, callback) => {
-    report(error, callback, state.counts, state.options.suppressErrors);
+const onlyCountsAsync$1 = (state, error, callback) => {
+    report$1(error, callback, state.counts, state.options.suppressErrors);
     return null;
 };
-const defaultAsync = (state, error, callback) => {
-    report(error, callback, state.paths, state.options.suppressErrors);
+const defaultAsync$1 = (state, error, callback) => {
+    report$1(error, callback, state.paths, state.options.suppressErrors);
     return null;
 };
-const limitFilesAsync = (state, error, callback) => {
-    report(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+const limitFilesAsync$1 = (state, error, callback) => {
+    report$1(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
     return null;
 };
-const groupsAsync = (state, error, callback) => {
-    report(error, callback, state.groups, state.options.suppressErrors);
+const groupsAsync$1 = (state, error, callback) => {
+    report$1(error, callback, state.groups, state.options.suppressErrors);
     return null;
 };
-function report(error, callback, output, suppressErrors) {
+function report$1(error, callback, output, suppressErrors) {
     if (error && !suppressErrors)
         callback(error, output);
     else
         callback(null, output);
 }
-function build$4(options, isSynchronous) {
+function build$c(options, isSynchronous) {
     const { onlyCounts, group, maxFiles } = options;
     if (onlyCounts)
         return isSynchronous
-            ? onlyCountsSync
-            : onlyCountsAsync;
+            ? onlyCountsSync$1
+            : onlyCountsAsync$1;
     else if (group)
         return isSynchronous
-            ? groupsSync
-            : groupsAsync;
+            ? groupsSync$1
+            : groupsAsync$1;
     else if (maxFiles)
         return isSynchronous
-            ? limitFilesSync
-            : limitFilesAsync;
+            ? limitFilesSync$1
+            : limitFilesAsync$1;
     else
         return isSynchronous
-            ? defaultSync
-            : defaultAsync;
+            ? defaultSync$1
+            : defaultAsync$1;
 }
-invokeCallback$1.build = build$4;
+invokeCallback$3.build = build$c;
 
-var walkDirectory$1 = {};
+var walkDirectory$3 = {};
 
-var __importDefault = (walkDirectory$1.__importDefault) || function (mod) {
+var __importDefault$2 = (walkDirectory$3.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-Object.defineProperty(walkDirectory$1, "__esModule", { value: true });
-walkDirectory$1.build = undefined;
-const fs_1 = __importDefault(require$$0$3);
-const readdirOpts = { withFileTypes: true };
-const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+Object.defineProperty(walkDirectory$3, "__esModule", { value: true });
+walkDirectory$3.build = undefined;
+const fs_1$2 = __importDefault$2(require$$0$3);
+const readdirOpts$1 = { withFileTypes: true };
+const walkAsync$1 = (state, crawlPath, directoryPath, currentDepth, callback) => {
     if (currentDepth < 0)
         return state.queue.dequeue(null, state);
     state.visited.push(crawlPath);
@@ -3159,19 +3159,19 @@ const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback) => {
     state.queue.enqueue();
     // Perf: Node >= 10 introduced withFileTypes that helps us
     // skip an extra fs.stat call.
-    fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+    fs_1$2.default.readdir(crawlPath || ".", readdirOpts$1, (error, entries = []) => {
         callback(entries, directoryPath, currentDepth);
         state.queue.dequeue(state.options.suppressErrors ? null : error, state);
     });
 };
-const walkSync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+const walkSync$1 = (state, crawlPath, directoryPath, currentDepth, callback) => {
     if (currentDepth < 0)
         return;
     state.visited.push(crawlPath);
     state.counts.directories++;
     let entries = [];
     try {
-        entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
+        entries = fs_1$2.default.readdirSync(crawlPath || ".", readdirOpts$1);
     }
     catch (e) {
         if (!state.options.suppressErrors)
@@ -3179,21 +3179,21 @@ const walkSync = (state, crawlPath, directoryPath, currentDepth, callback) => {
     }
     callback(entries, directoryPath, currentDepth);
 };
-function build$3(isSynchronous) {
-    return isSynchronous ? walkSync : walkAsync;
+function build$b(isSynchronous) {
+    return isSynchronous ? walkSync$1 : walkAsync$1;
 }
-walkDirectory$1.build = build$3;
+walkDirectory$3.build = build$b;
 
-var queue = {};
+var queue$1 = {};
 
-Object.defineProperty(queue, "__esModule", { value: true });
-queue.Queue = undefined;
+Object.defineProperty(queue$1, "__esModule", { value: true });
+queue$1.Queue = undefined;
 /**
  * This is a custom stateless queue to track concurrent async fs calls.
  * It increments a counter whenever a call is queued and decrements it
  * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
  */
-class Queue {
+let Queue$1 = class Queue {
     onQueueEmpty;
     count = 0;
     constructor(onQueueEmpty) {
@@ -3206,14 +3206,14 @@ class Queue {
         if (--this.count <= 0 || error)
             this.onQueueEmpty(error, output);
     }
-}
-queue.Queue = Queue;
+};
+queue$1.Queue = Queue$1;
 
-var counter = {};
+var counter$1 = {};
 
-Object.defineProperty(counter, "__esModule", { value: true });
-counter.Counter = undefined;
-class Counter {
+Object.defineProperty(counter$1, "__esModule", { value: true });
+counter$1.Counter = undefined;
+let Counter$1 = class Counter {
     _files = 0;
     _directories = 0;
     set files(num) {
@@ -3235,10 +3235,10 @@ class Counter {
     get dirs() {
         return this._directories;
     }
-}
-counter.Counter = Counter;
+};
+counter$1.Counter = Counter$1;
 
-var __createBinding = (walker.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+var __createBinding$1 = (walker$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
     if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
@@ -3249,33 +3249,33 @@ var __createBinding = (walker.__createBinding) || (Object.create ? (function(o,
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (walker.__setModuleDefault) || (Object.create ? (function(o, v) {
+var __setModuleDefault$1 = (walker$1.__setModuleDefault) || (Object.create ? (function(o, v) {
     Object.defineProperty(o, "default", { enumerable: true, value: v });
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (walker.__importStar) || function (mod) {
+var __importStar$1 = (walker$1.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding$1(result, mod, k);
+    __setModuleDefault$1(result, mod);
     return result;
 };
-Object.defineProperty(walker, "__esModule", { value: true });
-walker.Walker = undefined;
-const path_1$1 = require$$0$2;
-const utils_1 = utils$8;
-const joinPath = __importStar(joinPath$2);
-const pushDirectory = __importStar(pushDirectory$2);
-const pushFile = __importStar(pushFile$2);
-const getArray = __importStar(getArray$2);
-const groupFiles = __importStar(groupFiles$2);
-const resolveSymlink = __importStar(resolveSymlink$1);
-const invokeCallback = __importStar(invokeCallback$1);
-const walkDirectory = __importStar(walkDirectory$1);
-const queue_1 = queue;
-const counter_1 = counter;
-class Walker {
+Object.defineProperty(walker$1, "__esModule", { value: true });
+walker$1.Walker = undefined;
+const path_1$6 = require$$0$2;
+const utils_1$2 = utils$9;
+const joinPath$3 = __importStar$1(joinPath$5);
+const pushDirectory$3 = __importStar$1(pushDirectory$5);
+const pushFile$3 = __importStar$1(pushFile$5);
+const getArray$3 = __importStar$1(getArray$5);
+const groupFiles$3 = __importStar$1(groupFiles$5);
+const resolveSymlink$2 = __importStar$1(resolveSymlink$3);
+const invokeCallback$2 = __importStar$1(invokeCallback$3);
+const walkDirectory$2 = __importStar$1(walkDirectory$3);
+const queue_1$1 = queue$1;
+const counter_1$1 = counter$1;
+let Walker$1 = class Walker {
     root;
     isSynchronous;
     state;
@@ -3289,16 +3289,16 @@ class Walker {
     callbackInvoker;
     constructor(root, options, callback) {
         this.isSynchronous = !callback;
-        this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
-        this.root = (0, utils_1.normalizePath)(root, options);
+        this.callbackInvoker = invokeCallback$2.build(options, this.isSynchronous);
+        this.root = (0, utils_1$2.normalizePath)(root, options);
         this.state = {
             root: this.root.slice(0, -1),
             // Perf: we explicitly tell the compiler to optimize for String arrays
             paths: [""].slice(0, 0),
             groups: [],
-            counts: new counter_1.Counter(),
+            counts: new counter_1$1.Counter(),
             options,
-            queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback)),
+            queue: new queue_1$1.Queue((error, state) => this.callbackInvoker(state, error, callback)),
             symlinks: new Map(),
             visited: [""].slice(0, 0),
         };
@@ -3307,13 +3307,13 @@ class Walker {
          * performance boost. Since these functions are so small, they are automatically inlined
          * by the javascript engine so there's no function call overhead (in most cases).
          */
-        this.joinPath = joinPath.build(this.root, options);
-        this.pushDirectory = pushDirectory.build(this.root, options);
-        this.pushFile = pushFile.build(options);
-        this.getArray = getArray.build(options);
-        this.groupFiles = groupFiles.build(options);
-        this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
-        this.walkDirectory = walkDirectory.build(this.isSynchronous);
+        this.joinPath = joinPath$3.build(this.root, options);
+        this.pushDirectory = pushDirectory$3.build(this.root, options);
+        this.pushFile = pushFile$3.build(options);
+        this.getArray = getArray$3.build(options);
+        this.groupFiles = groupFiles$3.build(options);
+        this.resolveSymlink = resolveSymlink$2.build(options, this.isSynchronous);
+        this.walkDirectory = walkDirectory$2.build(this.isSynchronous);
     }
     start() {
         this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
@@ -3333,24 +3333,24 @@ class Walker {
                 this.pushFile(filename, files, this.state.counts, filters);
             }
             else if (entry.isDirectory()) {
-                let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                let path = joinPath$3.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
                 if (exclude && exclude(entry.name, path))
                     continue;
                 this.walkDirectory(this.state, path, path, depth - 1, this.walk);
             }
             else if (entry.isSymbolicLink() && this.resolveSymlink) {
-                let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+                let path = joinPath$3.joinPathWithBasePath(entry.name, directoryPath);
                 this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
                     if (stat.isDirectory()) {
-                        resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
+                        resolvedPath = (0, utils_1$2.normalizePath)(resolvedPath, this.state.options);
                         if (exclude && exclude(entry.name, resolvedPath))
                             return;
                         this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
                     }
                     else {
                         resolvedPath = useRealPaths ? resolvedPath : path;
-                        const filename = (0, path_1$1.basename)(resolvedPath);
-                        const directoryPath = (0, utils_1.normalizePath)((0, path_1$1.dirname)(resolvedPath), this.state.options);
+                        const filename = (0, path_1$6.basename)(resolvedPath);
+                        const directoryPath = (0, utils_1$2.normalizePath)((0, path_1$6.dirname)(resolvedPath), this.state.options);
                         resolvedPath = this.joinPath(filename, directoryPath);
                         this.pushFile(resolvedPath, files, this.state.counts, filters);
                     }
@@ -3359,44 +3359,44 @@ class Walker {
         }
         this.groupFiles(this.state.groups, directoryPath, files);
     };
-}
-walker.Walker = Walker;
+};
+walker$1.Walker = Walker$1;
 
-Object.defineProperty(async, "__esModule", { value: true });
-async.callback = async.promise = undefined;
-const walker_1$1 = walker;
-function promise(root, options) {
+Object.defineProperty(async$1, "__esModule", { value: true });
+async$1.callback = async$1.promise = undefined;
+const walker_1$3 = walker$1;
+function promise$1(root, options) {
     return new Promise((resolve, reject) => {
-        callback(root, options, (err, output) => {
+        callback$1(root, options, (err, output) => {
             if (err)
                 return reject(err);
             resolve(output);
         });
     });
 }
-async.promise = promise;
-function callback(root, options, callback) {
-    let walker = new walker_1$1.Walker(root, options, callback);
+async$1.promise = promise$1;
+function callback$1(root, options, callback) {
+    let walker = new walker_1$3.Walker(root, options, callback);
     walker.start();
 }
-async.callback = callback;
+async$1.callback = callback$1;
 
-var sync$2 = {};
+var sync$4 = {};
 
-Object.defineProperty(sync$2, "__esModule", { value: true });
-sync$2.sync = undefined;
-const walker_1 = walker;
-function sync$1(root, options) {
-    const walker = new walker_1.Walker(root, options);
+Object.defineProperty(sync$4, "__esModule", { value: true });
+sync$4.sync = undefined;
+const walker_1$2 = walker$1;
+function sync$3(root, options) {
+    const walker = new walker_1$2.Walker(root, options);
     return walker.start();
 }
-sync$2.sync = sync$1;
+sync$4.sync = sync$3;
 
-Object.defineProperty(apiBuilder, "__esModule", { value: true });
-apiBuilder.APIBuilder = undefined;
-const async_1 = async;
-const sync_1 = sync$2;
-class APIBuilder {
+Object.defineProperty(apiBuilder$1, "__esModule", { value: true });
+apiBuilder$1.APIBuilder = undefined;
+const async_1$1 = async$1;
+const sync_1$1 = sync$4;
+let APIBuilder$1 = class APIBuilder {
     root;
     options;
     constructor(root, options) {
@@ -3404,36 +3404,36 @@ class APIBuilder {
         this.options = options;
     }
     withPromise() {
-        return (0, async_1.promise)(this.root, this.options);
+        return (0, async_1$1.promise)(this.root, this.options);
     }
     withCallback(cb) {
-        (0, async_1.callback)(this.root, this.options, cb);
+        (0, async_1$1.callback)(this.root, this.options, cb);
     }
     sync() {
-        return (0, sync_1.sync)(this.root, this.options);
+        return (0, sync_1$1.sync)(this.root, this.options);
     }
-}
-apiBuilder.APIBuilder = APIBuilder;
+};
+apiBuilder$1.APIBuilder = APIBuilder$1;
 
-Object.defineProperty(builder, "__esModule", { value: true });
-builder.Builder = undefined;
-const path_1 = require$$0$2;
-const api_builder_1 = apiBuilder;
-var pm = null;
+Object.defineProperty(builder$1, "__esModule", { value: true });
+builder$1.Builder = undefined;
+const path_1$5 = require$$0$2;
+const api_builder_1$1 = apiBuilder$1;
+var pm$1 = null;
 /* c8 ignore next 6 */
 try {
     require.resolve("picomatch");
-    pm = picomatch_1$1;
+    pm$1 = picomatch_1$1;
 }
 catch (_e) {
     // do nothing
 }
-class Builder {
+let Builder$1 = class Builder {
     globCache = {};
     options = {
         maxDepth: Infinity,
         suppressErrors: true,
-        pathSeparator: path_1.sep,
+        pathSeparator: path_1$5.sep,
         filters: [],
     };
     globFunction;
@@ -3509,7 +3509,7 @@ class Builder {
         return this;
     }
     crawl(root) {
-        return new api_builder_1.APIBuilder(root || ".", this.options);
+        return new api_builder_1$1.APIBuilder(root || ".", this.options);
     }
     withGlobFunction(fn) {
         // cast this since we don't have the new type params yet
@@ -3526,7 +3526,7 @@ class Builder {
     /* c8 ignore next 4 */
     crawlWithOptions(root, options) {
         this.options = { ...this.options, ...options };
-        return new api_builder_1.APIBuilder(root || ".", this.options);
+        return new api_builder_1$1.APIBuilder(root || ".", this.options);
     }
     glob(...patterns) {
         if (this.globFunction) {
@@ -3535,7 +3535,7 @@ class Builder {
         return this.globWithOptions(patterns, ...[{ dot: true }]);
     }
     globWithOptions(patterns, ...options) {
-        const globFn = (this.globFunction || pm);
+        const globFn = (this.globFunction || pm$1);
         /* c8 ignore next 5 */
         if (!globFn) {
             throw new Error('Please specify a glob function to use glob matching.');
@@ -3548,15 +3548,15 @@ class Builder {
         this.options.filters.push((path) => isMatch(path));
         return this;
     }
-}
-builder.Builder = Builder;
+};
+builder$1.Builder = Builder$1;
 
-var types$1 = {};
+var types$2 = {};
 
-Object.defineProperty(types$1, "__esModule", { value: true });
+Object.defineProperty(types$2, "__esModule", { value: true });
 
 (function (exports) {
-	var __createBinding = (dist.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	var __createBinding = (dist$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 	    if (k2 === undefined) k2 = k;
 	    var desc = Object.getOwnPropertyDescriptor(m, k);
 	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
@@ -3567,15 +3567,15 @@ Object.defineProperty(types$1, "__esModule", { value: true });
 	    if (k2 === undefined) k2 = k;
 	    o[k2] = m[k];
 	}));
-	var __exportStar = (dist.__exportStar) || function(m, exports) {
+	var __exportStar = (dist$1.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.fdir = undefined;
-	const builder_1 = builder;
+	const builder_1 = builder$1;
 	Object.defineProperty(exports, "fdir", { enumerable: true, get: function () { return builder_1.Builder; } });
-	__exportStar(types$1, exports); 
-} (dist));
+	__exportStar(types$2, exports); 
+} (dist$1));
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -5234,7 +5234,7 @@ function getDynamicRequireModules(patterns, dynamicRequireRoot) {
         ? dynamicRequireModules.delete(targetPath)
         : dynamicRequireModules.set(targetPath, resolvedPath);
     // eslint-disable-next-line new-cap
-    for (const path of new dist.fdir()
+    for (const path of new dist$1.fdir()
       .withBasePath()
       .withDirs()
       .glob(isNegated ? pattern.substr(1) : pattern)
@@ -7492,7 +7492,7 @@ function stripPathFilename(path) {
     return path.slice(0, index + 1);
 }
 function mergePaths(url, base) {
-    normalizePath$4(base, base.type);
+    normalizePath$5(base, base.type);
     // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
     // path).
     if (url.path === '/') {
@@ -7507,7 +7507,7 @@ function mergePaths(url, base) {
  * The path can have empty directories "//", unneeded parents "foo/..", or current directory
  * "foo/.". We need to normalize to a standard representation.
  */
-function normalizePath$4(url, type) {
+function normalizePath$5(url, type) {
     const rel = type <= 4 /* RelativePath */;
     const pieces = url.path.split('/');
     // We need to preserve the first piece always, so that we output a leading slash. The item at
@@ -7596,7 +7596,7 @@ function resolve$2(input, base) {
         if (baseType > inputType)
             inputType = baseType;
     }
-    normalizePath$4(url, inputType);
+    normalizePath$5(url, inputType);
     const queryHash = url.query + url.hash;
     switch (inputType) {
         // This is impossible, because of the empty checks at the start of the function.
@@ -8231,13 +8231,13 @@ function buildSourceMapTree(input, loader) {
                 'Did you specify these with the most recent transformation maps first?');
         }
     }
-    let tree = build$2(map, loader, '', 0);
+    let tree = build$a(map, loader, '', 0);
     for (let i = maps.length - 1; i >= 0; i--) {
         tree = MapSource(maps[i], [tree]);
     }
     return tree;
 }
-function build$2(map, loader, importer, importerDepth) {
+function build$a(map, loader, importer, importerDepth) {
     const { resolvedSources, sourcesContent, ignoreList } = map;
     const depth = importerDepth + 1;
     const children = resolvedSources.map((sourceFile, i) => {
@@ -8258,7 +8258,7 @@ function build$2(map, loader, importer, importerDepth) {
         const { source, content, ignore } = ctx;
         // If there is a sourcemap, then we need to recurse into it to load its source files.
         if (sourceMap)
-            return build$2(new TraceMap(sourceMap, source), loader, source, depth);
+            return build$a(new TraceMap(sourceMap, source), loader, source, depth);
         // Else, it's an unmodified source file.
         // The contents of this unmodified source file can be overridden via the loader context,
         // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
@@ -9368,7 +9368,7 @@ if (process.versions.pnp) {
   }
 }
 function invalidatePackageData(packageCache, pkgPath) {
-  const pkgDir = normalizePath$3(path$d.dirname(pkgPath));
+  const pkgDir = normalizePath$4(path$d.dirname(pkgPath));
   packageCache.forEach((pkg, cacheKey) => {
     if (pkg.dir === pkgDir) {
       packageCache.delete(cacheKey);
@@ -9461,7 +9461,7 @@ function findNearestMainPackageData(basedir, packageCache) {
 }
 function loadPackageData(pkgPath) {
   const data = JSON.parse(stripBomTag(fs__default.readFileSync(pkgPath, "utf-8")));
-  const pkgDir = normalizePath$3(path$d.dirname(pkgPath));
+  const pkgDir = normalizePath$4(path$d.dirname(pkgPath));
   const { sideEffects } = data;
   let hasSideEffects;
   if (typeof sideEffects === "boolean") {
@@ -9715,11 +9715,11 @@ const urlCanParse = (
 );
 const isCaseInsensitiveFS = testCaseInsensitiveFS();
 const VOLUME_RE = /^[A-Z]:/i;
-function normalizePath$3(id) {
+function normalizePath$4(id) {
   return path$d.posix.normalize(isWindows$3 ? slash$1(id) : id);
 }
 function fsPathFromId(id) {
-  const fsPath = normalizePath$3(
+  const fsPath = normalizePath$4(
     id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id
   );
   return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
@@ -10024,7 +10024,7 @@ async function recursiveReaddir(dir) {
   const files = await Promise.all(
     dirents.map((dirent) => {
       const res = path$d.resolve(dir, dirent.name);
-      return dirent.isDirectory() ? recursiveReaddir(res) : normalizePath$3(res);
+      return dirent.isDirectory() ? recursiveReaddir(res) : normalizePath$4(res);
     })
   );
   return files.flat(1);
@@ -10284,7 +10284,9 @@ function extractHostnamesFromSubjectAltName(subjectAltName) {
       /* for , */
       1
     ).trimStart();
-    if (name === "DNS" && value !== "[::1]") {
+    if (name === "DNS" && // [::1] might be included but skip it as it's already included as a local address
+    value !== "[::1]" && // skip *.IPv4 addresses, which is invalid
+    !(value.startsWith("*.") && net$1.isIPv4(value.slice(2)))) {
       hostnames.push(value.replace("*", "vite"));
     }
   }
@@ -10916,7 +10918,7 @@ function buildReporterPlugin(config) {
           const sizePad = displaySize(biggestSize).length;
           const mapPad = displaySize(biggestMap).length;
           const compressPad = displaySize(biggestCompressSize).length;
-          const relativeOutDir = normalizePath$3(
+          const relativeOutDir = normalizePath$4(
             path$d.relative(
               config.root,
               path$d.resolve(
@@ -11358,16 +11360,16 @@ function pattern2regex(resolvedPattern, allowJs) {
 
 /**
  * replace tokens like ${configDir}
- * @param {any} tsconfig
- * @param {string} configDir
- * @returns {any}
- */
-function replaceTokens(tsconfig, configDir) {
-	return JSON.parse(
-		JSON.stringify(tsconfig)
-			// replace ${configDir}
-			.replaceAll(/"\${configDir}/g, `"${native2posix(configDir)}`)
-	);
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ */
+function replaceTokens(result) {
+	if (result.tsconfig) {
+		result.tsconfig = JSON.parse(
+			JSON.stringify(result.tsconfig)
+				// replace ${configDir}
+				.replaceAll(/"\${configDir}/g, `"${native2posix(path$d.dirname(result.tsconfigFile))}`)
+		);
+	}
 }
 
 /**
@@ -11646,7 +11648,7 @@ async function parse$f(filename, options) {
 			result = await parseFile$1(tsconfigFile, cache, filename === tsconfigFile);
 			await Promise.all([parseExtends(result, cache), parseReferences(result, options)]);
 		}
-		result.tsconfig = replaceTokens(result.tsconfig, path$d.dirname(tsconfigFile));
+		replaceTokens(result);
 		resolve(resolveSolutionTSConfig(filename, result));
 	} catch (e) {
 		reject(e);
@@ -11752,6 +11754,7 @@ async function parseReferences(result, options) {
 	await Promise.all(referenced.map((ref) => parseExtends(ref, options?.cache)));
 	referenced.forEach((ref) => {
 		ref.solution = result;
+		replaceTokens(ref);
 	});
 	result.referenced = referenced;
 }
@@ -13110,6 +13113,7 @@ const mimes = {
   "jsonml": "application/jsonml+json",
   "jsx": "text/jsx",
   "jt": "model/jt",
+  "jxl": "image/jxl",
   "jxr": "image/jxr",
   "jxra": "image/jxra",
   "jxrs": "image/jxrs",
@@ -13130,6 +13134,8 @@ const mimes = {
   "m1v": "video/mpeg",
   "m21": "application/mp21",
   "m2a": "audio/mpeg",
+  "m2t": "video/mp2t",
+  "m2ts": "video/mp2t",
   "m2v": "video/mpeg",
   "m3a": "audio/mpeg",
   "m4a": "audio/mp4",
@@ -13190,6 +13196,7 @@ const mimes = {
   "msm": "application/octet-stream",
   "msp": "application/octet-stream",
   "mtl": "model/mtl",
+  "mts": "video/mp2t",
   "musd": "application/mmt-usd+xml",
   "mxf": "application/mxf",
   "mxmf": "audio/mobile-xmf",
@@ -13425,9 +13432,9 @@ function checkPublicFile(url, config) {
   const fileName = cleanUrl(url);
   const publicFiles = getPublicFiles(config);
   if (publicFiles) {
-    return publicFiles.has(fileName) ? normalizePath$3(path$d.join(publicDir, fileName)) : undefined;
+    return publicFiles.has(fileName) ? normalizePath$4(path$d.join(publicDir, fileName)) : undefined;
   }
-  const publicFile = normalizePath$3(path$d.join(publicDir, fileName));
+  const publicFile = normalizePath$4(path$d.join(publicDir, fileName));
   if (!publicFile.startsWith(withTrailingSlash(publicDir))) {
     return;
   }
@@ -13446,7 +13453,6 @@ function registerCustomMime() {
   mimes["cur"] = "image/x-icon";
   mimes["flac"] = "audio/flac";
   mimes["eot"] = "application/vnd.ms-fontobject";
-  mimes["jxl"] = "image/jxl";
 }
 function renderAssetUrlInJS(pluginContext, chunk, opts, code) {
   const { environment } = pluginContext;
@@ -13657,7 +13663,7 @@ async function fileToBuiltUrl(pluginContext, id, skipPublicCheck = false, forceI
   if (shouldInline(environment, file, id, content, pluginContext, forceInline)) {
     url = assetToDataURL(environment, file, content);
   } else {
-    const originalFileName = normalizePath$3(
+    const originalFileName = normalizePath$4(
       path$d.relative(environment.config.root, file)
     );
     const referenceId = pluginContext.emitFile({
@@ -13855,7 +13861,7 @@ function manifestPlugin() {
 }
 function getChunkOriginalFileName(chunk, root, format) {
   if (chunk.facadeModuleId) {
-    let name = normalizePath$3(path$d.relative(root, chunk.facadeModuleId));
+    let name = normalizePath$4(path$d.relative(root, chunk.facadeModuleId));
     if (format === "system" && !chunk.name.includes("-legacy")) {
       const ext = path$d.extname(name);
       const endPos = ext.length !== 0 ? -ext.length : undefined;
@@ -15106,27 +15112,822 @@ var src$1 = rc;
 
 var postcssrc = /*@__PURE__*/getDefaultExportFromCjs(src$1);
 
+var dist = {};
+
+var builder = {};
+
+var apiBuilder = {};
+
+var async = {};
+
+var walker = {};
+
+var utils$8 = {};
+
+Object.defineProperty(utils$8, "__esModule", { value: true });
+utils$8.normalizePath = utils$8.convertSlashes = utils$8.cleanPath = undefined;
+const path_1$4 = require$$0$2;
+function cleanPath(path) {
+    let normalized = (0, path_1$4.normalize)(path);
+    // we have to remove the last path separator
+    // to account for / root path
+    if (normalized.length > 1 && normalized[normalized.length - 1] === path_1$4.sep)
+        normalized = normalized.substring(0, normalized.length - 1);
+    return normalized;
+}
+utils$8.cleanPath = cleanPath;
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+    return path.replace(SLASHES_REGEX, separator);
+}
+utils$8.convertSlashes = convertSlashes;
+function normalizePath$3(path, options) {
+    const { resolvePaths, normalizePath, pathSeparator } = options;
+    const pathNeedsCleaning = (process.platform === "win32" && path.includes("/")) ||
+        path.startsWith(".");
+    if (resolvePaths)
+        path = (0, path_1$4.resolve)(path);
+    if (normalizePath || pathNeedsCleaning)
+        path = cleanPath(path);
+    if (path === ".")
+        return "";
+    const needsSeperator = path[path.length - 1] !== pathSeparator;
+    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+utils$8.normalizePath = normalizePath$3;
+
+var joinPath$2 = {};
+
+Object.defineProperty(joinPath$2, "__esModule", { value: true });
+joinPath$2.build = joinPath$2.joinDirectoryPath = joinPath$2.joinPathWithBasePath = undefined;
+const path_1$3 = require$$0$2;
+const utils_1$1 = utils$8;
+function joinPathWithBasePath(filename, directoryPath) {
+    return directoryPath + filename;
+}
+joinPath$2.joinPathWithBasePath = joinPathWithBasePath;
+function joinPathWithRelativePath(root, options) {
+    return function (filename, directoryPath) {
+        const sameRoot = directoryPath.startsWith(root);
+        if (sameRoot)
+            return directoryPath.replace(root, "") + filename;
+        else
+            return ((0, utils_1$1.convertSlashes)((0, path_1$3.relative)(root, directoryPath), options.pathSeparator) +
+                options.pathSeparator +
+                filename);
+    };
+}
+function joinPath$1(filename) {
+    return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+    return directoryPath + filename + separator;
+}
+joinPath$2.joinDirectoryPath = joinDirectoryPath;
+function build$9(root, options) {
+    const { relativePaths, includeBasePath } = options;
+    return relativePaths && root
+        ? joinPathWithRelativePath(root, options)
+        : includeBasePath
+            ? joinPathWithBasePath
+            : joinPath$1;
+}
+joinPath$2.build = build$9;
+
+var pushDirectory$2 = {};
+
+Object.defineProperty(pushDirectory$2, "__esModule", { value: true });
+pushDirectory$2.build = undefined;
+function pushDirectoryWithRelativePath(root) {
+    return function (directoryPath, paths) {
+        paths.push(directoryPath.substring(root.length) || ".");
+    };
+}
+function pushDirectoryFilterWithRelativePath(root) {
+    return function (directoryPath, paths, filters) {
+        const relativePath = directoryPath.substring(root.length) || ".";
+        if (filters.every((filter) => filter(relativePath, true))) {
+            paths.push(relativePath);
+        }
+    };
+}
+const pushDirectory$1 = (directoryPath, paths) => {
+    paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+    const path = directoryPath || ".";
+    if (filters.every((filter) => filter(path, true))) {
+        paths.push(path);
+    }
+};
+const empty$2 = () => { };
+function build$8(root, options) {
+    const { includeDirs, filters, relativePaths } = options;
+    if (!includeDirs)
+        return empty$2;
+    if (relativePaths)
+        return filters && filters.length
+            ? pushDirectoryFilterWithRelativePath(root)
+            : pushDirectoryWithRelativePath(root);
+    return filters && filters.length ? pushDirectoryFilter : pushDirectory$1;
+}
+pushDirectory$2.build = build$8;
+
+var pushFile$2 = {};
+
+Object.defineProperty(pushFile$2, "__esModule", { value: true });
+pushFile$2.build = undefined;
+const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+    if (filters.every((filter) => filter(filename, false)))
+        counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters) => {
+    if (filters.every((filter) => filter(filename, false)))
+        paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters) => {
+    counts.files++;
+};
+const pushFile$1 = (filename, paths) => {
+    paths.push(filename);
+};
+const empty$1 = () => { };
+function build$7(options) {
+    const { excludeFiles, filters, onlyCounts } = options;
+    if (excludeFiles)
+        return empty$1;
+    if (filters && filters.length) {
+        return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+    }
+    else if (onlyCounts) {
+        return pushFileCount;
+    }
+    else {
+        return pushFile$1;
+    }
+}
+pushFile$2.build = build$7;
+
+var getArray$2 = {};
+
+Object.defineProperty(getArray$2, "__esModule", { value: true });
+getArray$2.build = undefined;
+const getArray$1 = (paths) => {
+    return paths;
+};
+const getArrayGroup = () => {
+    return [""].slice(0, 0);
+};
+function build$6(options) {
+    return options.group ? getArrayGroup : getArray$1;
+}
+getArray$2.build = build$6;
+
+var groupFiles$2 = {};
+
+Object.defineProperty(groupFiles$2, "__esModule", { value: true });
+groupFiles$2.build = undefined;
+const groupFiles$1 = (groups, directory, files) => {
+    groups.push({ directory, files, dir: directory });
+};
+const empty = () => { };
+function build$5(options) {
+    return options.group ? groupFiles$1 : empty;
+}
+groupFiles$2.build = build$5;
+
+var resolveSymlink$1 = {};
+
+var __importDefault$1 = (resolveSymlink$1.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(resolveSymlink$1, "__esModule", { value: true });
+resolveSymlink$1.build = undefined;
+const fs_1$1 = __importDefault$1(require$$0$3);
+const path_1$2 = require$$0$2;
+const resolveSymlinksAsync = function (path, state, callback) {
+    const { queue, options: { suppressErrors }, } = state;
+    queue.enqueue();
+    fs_1$1.default.realpath(path, (error, resolvedPath) => {
+        if (error)
+            return queue.dequeue(suppressErrors ? null : error, state);
+        fs_1$1.default.stat(resolvedPath, (error, stat) => {
+            if (error)
+                return queue.dequeue(suppressErrors ? null : error, state);
+            if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+                return queue.dequeue(null, state);
+            callback(stat, resolvedPath);
+            queue.dequeue(null, state);
+        });
+    });
+};
+const resolveSymlinks = function (path, state, callback) {
+    const { queue, options: { suppressErrors }, } = state;
+    queue.enqueue();
+    try {
+        const resolvedPath = fs_1$1.default.realpathSync(path);
+        const stat = fs_1$1.default.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+            return;
+        callback(stat, resolvedPath);
+    }
+    catch (e) {
+        if (!suppressErrors)
+            throw e;
+    }
+};
+function build$4(options, isSynchronous) {
+    if (!options.resolveSymlinks || options.excludeSymlinks)
+        return null;
+    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+resolveSymlink$1.build = build$4;
+function isRecursive(path, resolved, state) {
+    if (state.options.useRealPaths)
+        return isRecursiveUsingRealPaths(resolved, state);
+    let parent = (0, path_1$2.dirname)(path);
+    let depth = 1;
+    while (parent !== state.root && depth < 2) {
+        const resolvedPath = state.symlinks.get(parent);
+        const isSameRoot = !!resolvedPath &&
+            (resolvedPath === resolved ||
+                resolvedPath.startsWith(resolved) ||
+                resolved.startsWith(resolvedPath));
+        if (isSameRoot)
+            depth++;
+        else
+            parent = (0, path_1$2.dirname)(parent);
+    }
+    state.symlinks.set(path, resolved);
+    return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+    return state.visited.includes(resolved + state.options.pathSeparator);
+}
+
+var invokeCallback$1 = {};
+
+Object.defineProperty(invokeCallback$1, "__esModule", { value: true });
+invokeCallback$1.build = undefined;
+const onlyCountsSync = (state) => {
+    return state.counts;
+};
+const groupsSync = (state) => {
+    return state.groups;
+};
+const defaultSync = (state) => {
+    return state.paths;
+};
+const limitFilesSync = (state) => {
+    return state.paths.slice(0, state.options.maxFiles);
+};
+const onlyCountsAsync = (state, error, callback) => {
+    report(error, callback, state.counts, state.options.suppressErrors);
+    return null;
+};
+const defaultAsync = (state, error, callback) => {
+    report(error, callback, state.paths, state.options.suppressErrors);
+    return null;
+};
+const limitFilesAsync = (state, error, callback) => {
+    report(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+    return null;
+};
+const groupsAsync = (state, error, callback) => {
+    report(error, callback, state.groups, state.options.suppressErrors);
+    return null;
+};
+function report(error, callback, output, suppressErrors) {
+    if (error && !suppressErrors)
+        callback(error, output);
+    else
+        callback(null, output);
+}
+function build$3(options, isSynchronous) {
+    const { onlyCounts, group, maxFiles } = options;
+    if (onlyCounts)
+        return isSynchronous
+            ? onlyCountsSync
+            : onlyCountsAsync;
+    else if (group)
+        return isSynchronous
+            ? groupsSync
+            : groupsAsync;
+    else if (maxFiles)
+        return isSynchronous
+            ? limitFilesSync
+            : limitFilesAsync;
+    else
+        return isSynchronous
+            ? defaultSync
+            : defaultAsync;
+}
+invokeCallback$1.build = build$3;
+
+var walkDirectory$1 = {};
+
+var __importDefault = (walkDirectory$1.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(walkDirectory$1, "__esModule", { value: true });
+walkDirectory$1.build = undefined;
+const fs_1 = __importDefault(require$$0$3);
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+    if (currentDepth < 0)
+        return state.queue.dequeue(null, state);
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    state.queue.enqueue();
+    // Perf: Node >= 10 introduced withFileTypes that helps us
+    // skip an extra fs.stat call.
+    fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+        callback(entries, directoryPath, currentDepth);
+        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+    });
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+    if (currentDepth < 0)
+        return;
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    let entries = [];
+    try {
+        entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
+    }
+    catch (e) {
+        if (!state.options.suppressErrors)
+            throw e;
+    }
+    callback(entries, directoryPath, currentDepth);
+};
+function build$2(isSynchronous) {
+    return isSynchronous ? walkSync : walkAsync;
+}
+walkDirectory$1.build = build$2;
+
+var queue = {};
+
+Object.defineProperty(queue, "__esModule", { value: true });
+queue.Queue = undefined;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+class Queue {
+    onQueueEmpty;
+    count = 0;
+    constructor(onQueueEmpty) {
+        this.onQueueEmpty = onQueueEmpty;
+    }
+    enqueue() {
+        this.count++;
+    }
+    dequeue(error, output) {
+        if (--this.count <= 0 || error)
+            this.onQueueEmpty(error, output);
+    }
+}
+queue.Queue = Queue;
+
+var counter = {};
+
+Object.defineProperty(counter, "__esModule", { value: true });
+counter.Counter = undefined;
+class Counter {
+    _files = 0;
+    _directories = 0;
+    set files(num) {
+        this._files = num;
+    }
+    get files() {
+        return this._files;
+    }
+    set directories(num) {
+        this._directories = num;
+    }
+    get directories() {
+        return this._directories;
+    }
+    /**
+     * @deprecated use `directories` instead
+     */
+    /* c8 ignore next 3 */
+    get dirs() {
+        return this._directories;
+    }
+}
+counter.Counter = Counter;
+
+var __createBinding = (walker.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (walker.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (walker.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(walker, "__esModule", { value: true });
+walker.Walker = undefined;
+const path_1$1 = require$$0$2;
+const utils_1 = utils$8;
+const joinPath = __importStar(joinPath$2);
+const pushDirectory = __importStar(pushDirectory$2);
+const pushFile = __importStar(pushFile$2);
+const getArray = __importStar(getArray$2);
+const groupFiles = __importStar(groupFiles$2);
+const resolveSymlink = __importStar(resolveSymlink$1);
+const invokeCallback = __importStar(invokeCallback$1);
+const walkDirectory = __importStar(walkDirectory$1);
+const queue_1 = queue;
+const counter_1 = counter;
+class Walker {
+    root;
+    isSynchronous;
+    state;
+    joinPath;
+    pushDirectory;
+    pushFile;
+    getArray;
+    groupFiles;
+    resolveSymlink;
+    walkDirectory;
+    callbackInvoker;
+    constructor(root, options, callback) {
+        this.isSynchronous = !callback;
+        this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
+        this.root = (0, utils_1.normalizePath)(root, options);
+        this.state = {
+            root: this.root.slice(0, -1),
+            // Perf: we explicitly tell the compiler to optimize for String arrays
+            paths: [""].slice(0, 0),
+            groups: [],
+            counts: new counter_1.Counter(),
+            options,
+            queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback)),
+            symlinks: new Map(),
+            visited: [""].slice(0, 0),
+        };
+        /*
+         * Perf: We conditionally change functions according to options. This gives a slight
+         * performance boost. Since these functions are so small, they are automatically inlined
+         * by the javascript engine so there's no function call overhead (in most cases).
+         */
+        this.joinPath = joinPath.build(this.root, options);
+        this.pushDirectory = pushDirectory.build(this.root, options);
+        this.pushFile = pushFile.build(options);
+        this.getArray = getArray.build(options);
+        this.groupFiles = groupFiles.build(options);
+        this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
+        this.walkDirectory = walkDirectory.build(this.isSynchronous);
+    }
+    start() {
+        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+    }
+    walk = (entries, directoryPath, depth) => {
+        const { paths, options: { filters, resolveSymlinks, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator, }, } = this.state;
+        if ((signal && signal.aborted) || (maxFiles && paths.length > maxFiles))
+            return;
+        this.pushDirectory(directoryPath, paths, filters);
+        const files = this.getArray(this.state.paths);
+        for (let i = 0; i < entries.length; ++i) {
+            const entry = entries[i];
+            if (entry.isFile() ||
+                (entry.isSymbolicLink() && !resolveSymlinks && !excludeSymlinks)) {
+                const filename = this.joinPath(entry.name, directoryPath);
+                this.pushFile(filename, files, this.state.counts, filters);
+            }
+            else if (entry.isDirectory()) {
+                let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                if (exclude && exclude(entry.name, path))
+                    continue;
+                this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+            }
+            else if (entry.isSymbolicLink() && this.resolveSymlink) {
+                let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+                this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
+                    if (stat.isDirectory()) {
+                        resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
+                        if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator))
+                            return;
+                        this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                    }
+                    else {
+                        resolvedPath = useRealPaths ? resolvedPath : path;
+                        const filename = (0, path_1$1.basename)(resolvedPath);
+                        const directoryPath = (0, utils_1.normalizePath)((0, path_1$1.dirname)(resolvedPath), this.state.options);
+                        resolvedPath = this.joinPath(filename, directoryPath);
+                        this.pushFile(resolvedPath, files, this.state.counts, filters);
+                    }
+                });
+            }
+        }
+        this.groupFiles(this.state.groups, directoryPath, files);
+    };
+}
+walker.Walker = Walker;
+
+Object.defineProperty(async, "__esModule", { value: true });
+async.callback = async.promise = undefined;
+const walker_1$1 = walker;
+function promise(root, options) {
+    return new Promise((resolve, reject) => {
+        callback(root, options, (err, output) => {
+            if (err)
+                return reject(err);
+            resolve(output);
+        });
+    });
+}
+async.promise = promise;
+function callback(root, options, callback) {
+    let walker = new walker_1$1.Walker(root, options, callback);
+    walker.start();
+}
+async.callback = callback;
+
+var sync$2 = {};
+
+Object.defineProperty(sync$2, "__esModule", { value: true });
+sync$2.sync = undefined;
+const walker_1 = walker;
+function sync$1(root, options) {
+    const walker = new walker_1.Walker(root, options);
+    return walker.start();
+}
+sync$2.sync = sync$1;
+
+Object.defineProperty(apiBuilder, "__esModule", { value: true });
+apiBuilder.APIBuilder = undefined;
+const async_1 = async;
+const sync_1 = sync$2;
+class APIBuilder {
+    root;
+    options;
+    constructor(root, options) {
+        this.root = root;
+        this.options = options;
+    }
+    withPromise() {
+        return (0, async_1.promise)(this.root, this.options);
+    }
+    withCallback(cb) {
+        (0, async_1.callback)(this.root, this.options, cb);
+    }
+    sync() {
+        return (0, sync_1.sync)(this.root, this.options);
+    }
+}
+apiBuilder.APIBuilder = APIBuilder;
+
+Object.defineProperty(builder, "__esModule", { value: true });
+builder.Builder = undefined;
+const path_1 = require$$0$2;
+const api_builder_1 = apiBuilder;
+var pm = null;
+/* c8 ignore next 6 */
+try {
+    require.resolve("picomatch");
+    pm = picomatch_1$1;
+}
+catch (_e) {
+    // do nothing
+}
+class Builder {
+    globCache = {};
+    options = {
+        maxDepth: Infinity,
+        suppressErrors: true,
+        pathSeparator: path_1.sep,
+        filters: [],
+    };
+    globFunction;
+    constructor(options) {
+        this.options = { ...this.options, ...options };
+        this.globFunction = this.options.globFunction;
+    }
+    group() {
+        this.options.group = true;
+        return this;
+    }
+    withPathSeparator(separator) {
+        this.options.pathSeparator = separator;
+        return this;
+    }
+    withBasePath() {
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withRelativePaths() {
+        this.options.relativePaths = true;
+        return this;
+    }
+    withDirs() {
+        this.options.includeDirs = true;
+        return this;
+    }
+    withMaxDepth(depth) {
+        this.options.maxDepth = depth;
+        return this;
+    }
+    withMaxFiles(limit) {
+        this.options.maxFiles = limit;
+        return this;
+    }
+    withFullPaths() {
+        this.options.resolvePaths = true;
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withErrors() {
+        this.options.suppressErrors = false;
+        return this;
+    }
+    withSymlinks({ resolvePaths = true } = {}) {
+        this.options.resolveSymlinks = true;
+        this.options.useRealPaths = resolvePaths;
+        return this.withFullPaths();
+    }
+    withAbortSignal(signal) {
+        this.options.signal = signal;
+        return this;
+    }
+    normalize() {
+        this.options.normalizePath = true;
+        return this;
+    }
+    filter(predicate) {
+        this.options.filters.push(predicate);
+        return this;
+    }
+    onlyDirs() {
+        this.options.excludeFiles = true;
+        this.options.includeDirs = true;
+        return this;
+    }
+    exclude(predicate) {
+        this.options.exclude = predicate;
+        return this;
+    }
+    onlyCounts() {
+        this.options.onlyCounts = true;
+        return this;
+    }
+    crawl(root) {
+        return new api_builder_1.APIBuilder(root || ".", this.options);
+    }
+    withGlobFunction(fn) {
+        // cast this since we don't have the new type params yet
+        this.globFunction = fn;
+        return this;
+    }
+    /**
+     * @deprecated Pass options using the constructor instead:
+     * ```ts
+     * new fdir(options).crawl("/path/to/root");
+     * ```
+     * This method will be removed in v7.0
+     */
+    /* c8 ignore next 4 */
+    crawlWithOptions(root, options) {
+        this.options = { ...this.options, ...options };
+        return new api_builder_1.APIBuilder(root || ".", this.options);
+    }
+    glob(...patterns) {
+        if (this.globFunction) {
+            return this.globWithOptions(patterns);
+        }
+        return this.globWithOptions(patterns, ...[{ dot: true }]);
+    }
+    globWithOptions(patterns, ...options) {
+        const globFn = (this.globFunction || pm);
+        /* c8 ignore next 5 */
+        if (!globFn) {
+            throw new Error('Please specify a glob function to use glob matching.');
+        }
+        var isMatch = this.globCache[patterns.join("\0")];
+        if (!isMatch) {
+            isMatch = globFn(patterns, ...options);
+            this.globCache[patterns.join("\0")] = isMatch;
+        }
+        this.options.filters.push((path) => isMatch(path));
+        return this;
+    }
+}
+builder.Builder = Builder;
+
+var types$1 = {};
+
+Object.defineProperty(types$1, "__esModule", { value: true });
+
+(function (exports) {
+	var __createBinding = (dist.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (dist.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.fdir = undefined;
+	const builder_1 = builder;
+	Object.defineProperty(exports, "fdir", { enumerable: true, get: function () { return builder_1.Builder; } });
+	__exportStar(types$1, exports); 
+} (dist));
+
 // src/index.ts
-var ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
-function convertPosixPathToPattern(path2) {
-  return escapePosixPath(path2);
+function getPartialMatcher(patterns, options) {
+  const patternsCount = patterns.length;
+  const patternsParts = Array(patternsCount);
+  const regexes = Array(patternsCount);
+  for (let i = 0; i < patternsCount; i++) {
+    const parts = splitPattern(patterns[i]);
+    patternsParts[i] = parts;
+    const partsCount = parts.length;
+    const partRegexes = Array(partsCount);
+    for (let j = 0; j < partsCount; j++) {
+      partRegexes[j] = picomatch$5.makeRe(parts[j], options);
+    }
+    regexes[i] = partRegexes;
+  }
+  return (input) => {
+    const inputParts = input.split("/");
+    for (let i = 0; i < patterns.length; i++) {
+      const patternParts = patternsParts[i];
+      const regex = regexes[i];
+      const inputPatternCount = inputParts.length;
+      const minParts = Math.min(inputPatternCount, patternParts.length);
+      let j = 0;
+      while (j < minParts) {
+        const part = patternParts[j];
+        if (part.includes("/")) {
+          return true;
+        }
+        const match = regex[j].test(inputParts[j]);
+        if (!match) {
+          break;
+        }
+        if (part === "**") {
+          return true;
+        }
+        j++;
+      }
+      if (j === inputPatternCount) {
+        return true;
+      }
+    }
+    return false;
+  };
 }
-function convertWin32PathToPattern(path2) {
-  return escapeWin32Path(path2).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+var splitPatternOptions = { parts: true };
+function splitPattern(path2) {
+  var _a;
+  const result = picomatch$5.scan(path2, splitPatternOptions);
+  return ((_a = result.parts) == null ? undefined : _a.length) ? result.parts : [path2];
 }
-process.platform === "win32" ? convertWin32PathToPattern : convertPosixPathToPattern;
+var isWin$2 = process.platform === "win32";
 var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
 var WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
 var escapePosixPath = (path2) => path2.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
 var escapeWin32Path = (path2) => path2.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-var escapePath = process.platform === "win32" ? escapeWin32Path : escapePosixPath;
+var escapePath = isWin$2 ? escapeWin32Path : escapePosixPath;
 function isDynamicPattern(pattern, options) {
   const scan = picomatch$5.scan(pattern);
   return scan.isGlob || scan.negated;
 }
+function log(...tasks) {
+  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
+}
 
 // src/index.ts
-function normalizePattern(pattern, expandDirectories, cwd, properties, isIgnore) {
+var PARENT_DIRECTORY = /^(\/?\.\.)+/;
+var ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+var BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
   var _a;
   let result = pattern;
   if (pattern.endsWith("/")) {
@@ -15135,40 +15936,41 @@ function normalizePattern(pattern, expandDirectories, cwd, properties, isIgnore)
   if (!result.endsWith("*") && expandDirectories) {
     result += "/**";
   }
-  if (require$$0$2.isAbsolute(result.replace(/\\(?=[()[\]{}!*+?@|])/g, ""))) {
-    result = posix.relative(cwd, result);
+  if (require$$0$2.isAbsolute(result.replace(ESCAPING_BACKSLASHES, ""))) {
+    result = posix.relative(escapePath(cwd), result);
   } else {
     result = posix.normalize(result);
   }
-  const parentDirectoryMatch = /^(\/?\.\.)+/.exec(result);
+  const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
   if (parentDirectoryMatch == null ? undefined : parentDirectoryMatch[0]) {
     const potentialRoot = posix.join(cwd, parentDirectoryMatch[0]);
-    if (properties.root.length > potentialRoot.length) {
-      properties.root = potentialRoot;
-      properties.depthOffset = -(parentDirectoryMatch[0].length + 1) / 3;
+    if (props.root.length > potentialRoot.length) {
+      props.root = potentialRoot;
+      props.depthOffset = -(parentDirectoryMatch[0].length + 1) / 3;
     }
-  } else if (!isIgnore && properties.depthOffset >= 0) {
-    const current = result.split("/");
-    (_a = properties.commonPath) != null ? _a : properties.commonPath = current;
+  } else if (!isIgnore && props.depthOffset >= 0) {
+    const parts = splitPattern(result);
+    (_a = props.commonPath) != null ? _a : props.commonPath = parts;
     const newCommonPath = [];
-    for (let i = 0; i < Math.min(properties.commonPath.length, current.length); i++) {
-      const part = current[i];
-      if (part === "**" && !current[i + 1]) {
+    const length = Math.min(props.commonPath.length, parts.length);
+    for (let i = 0; i < length; i++) {
+      const part = parts[i];
+      if (part === "**" && !parts[i + 1]) {
         newCommonPath.pop();
         break;
       }
-      if (part !== properties.commonPath[i] || isDynamicPattern(part) || i === current.length - 1) {
+      if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) {
         break;
       }
       newCommonPath.push(part);
     }
-    properties.depthOffset = newCommonPath.length;
-    properties.commonPath = newCommonPath;
-    properties.root = newCommonPath.length > 0 ? `${cwd}/${newCommonPath.join("/")}` : cwd;
+    props.depthOffset = newCommonPath.length;
+    props.commonPath = newCommonPath;
+    props.root = newCommonPath.length > 0 ? `${cwd}/${newCommonPath.join("/")}` : cwd;
   }
   return result;
 }
-function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, properties) {
+function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
   if (typeof patterns === "string") {
     patterns = [patterns];
   } else if (!patterns) {
@@ -15180,24 +15982,27 @@ function processPatterns({ patterns, ignore = [], expandDirectories = true }, cw
   const matchPatterns = [];
   const ignorePatterns = [];
   for (const pattern of ignore) {
-    if (!pattern.startsWith("!") || pattern[1] === "(") {
-      const newPattern = normalizePattern(pattern, expandDirectories, cwd, properties, true);
-      ignorePatterns.push(newPattern);
+    if (!pattern) {
+      continue;
+    }
+    if (pattern[0] !== "!" || pattern[1] === "(") {
+      ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
     }
   }
   for (const pattern of patterns) {
-    if (!pattern.startsWith("!") || pattern[1] === "(") {
-      const newPattern = normalizePattern(pattern, expandDirectories, cwd, properties, false);
-      matchPatterns.push(newPattern);
+    if (!pattern) {
+      continue;
+    }
+    if (pattern[0] !== "!" || pattern[1] === "(") {
+      matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
     } else if (pattern[1] !== "!" || pattern[2] === "(") {
-      const newPattern = normalizePattern(pattern.slice(1), expandDirectories, cwd, properties, true);
-      ignorePatterns.push(newPattern);
+      ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
     }
   }
   return { match: matchPatterns, ignore: ignorePatterns };
 }
 function getRelativePath(path2, cwd, root) {
-  return posix.relative(cwd, `${root}/${path2}`);
+  return posix.relative(cwd, `${root}/${path2}`) || ".";
 }
 function processPath(path2, cwd, root, isDirectory, absolute) {
   const relativePath = absolute ? path2.slice(root.length + 1) || "." : path2;
@@ -15206,32 +16011,75 @@ function processPath(path2, cwd, root, isDirectory, absolute) {
   }
   return getRelativePath(relativePath, cwd, root);
 }
+function formatPaths(paths, cwd, root) {
+  for (let i = paths.length - 1; i >= 0; i--) {
+    const path2 = paths[i];
+    paths[i] = getRelativePath(path2, cwd, root) + (!path2 || path2.endsWith("/") ? "/" : "");
+  }
+  return paths;
+}
 function crawl(options, cwd, sync) {
-  const properties = {
+  if (process.env.TINYGLOBBY_DEBUG) {
+    options.debug = true;
+  }
+  if (options.debug) {
+    log("globbing with options:", options, "cwd:", cwd);
+  }
+  if (Array.isArray(options.patterns) && options.patterns.length === 0) {
+    return sync ? [] : Promise.resolve([]);
+  }
+  const props = {
     root: cwd,
     commonPath: null,
     depthOffset: 0
   };
-  const processed = processPatterns(options, cwd, properties);
+  const processed = processPatterns(options, cwd, props);
+  const nocase = options.caseSensitiveMatch === false;
+  if (options.debug) {
+    log("internal processing patterns:", processed);
+  }
   const matcher = picomatch$5(processed.match, {
     dot: options.dot,
-    nocase: options.caseSensitiveMatch === false,
+    nocase,
     ignore: processed.ignore
   });
-  const exclude = picomatch$5(processed.ignore, {
+  const ignore = picomatch$5(processed.ignore, {
+    dot: options.dot,
+    nocase
+  });
+  const partialMatcher = getPartialMatcher(processed.match, {
     dot: options.dot,
-    nocase: options.caseSensitiveMatch === false
+    nocase
   });
   const fdirOptions = {
     // use relative paths in the matcher
-    filters: [(p, isDirectory) => matcher(processPath(p, cwd, properties.root, isDirectory, options.absolute))],
-    exclude: (_, p) => exclude(processPath(p, cwd, properties.root, true, true)),
+    filters: [
+      options.debug ? (p, isDirectory) => {
+        const path2 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+        const matches = matcher(path2);
+        if (matches) {
+          log(`matched ${path2}`);
+        }
+        return matches;
+      } : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))
+    ],
+    exclude: options.debug ? (_, p) => {
+      const relativePath = processPath(p, cwd, props.root, true, true);
+      const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+      if (!skipped) {
+        log(`crawling ${p}`);
+      }
+      return skipped;
+    } : (_, p) => {
+      const relativePath = processPath(p, cwd, props.root, true, true);
+      return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+    },
     pathSeparator: "/",
     relativePaths: true,
     resolveSymlinks: true
   };
   if (options.deep) {
-    fdirOptions.maxDepth = Math.round(options.deep - properties.depthOffset);
+    fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
   }
   if (options.absolute) {
     fdirOptions.relativePaths = false;
@@ -15248,19 +16096,23 @@ function crawl(options, cwd, sync) {
   } else if (options.onlyFiles === false) {
     fdirOptions.includeDirs = true;
   }
-  properties.root = properties.root.replace(/\\/g, "");
-  const api = new dist.fdir(fdirOptions).crawl(properties.root);
-  if (cwd === properties.root || options.absolute) {
+  props.root = props.root.replace(BACKSLASHES, "");
+  const root = props.root;
+  if (options.debug) {
+    log("internal properties:", props);
+  }
+  const api = new dist.fdir(fdirOptions).crawl(root);
+  if (cwd === root || options.absolute) {
     return sync ? api.sync() : api.withPromise();
   }
-  return sync ? api.sync().map((p) => getRelativePath(p, cwd, properties.root) + (!p || p.endsWith("/") ? "/" : "")) : api.withPromise().then((paths) => paths.map((p) => getRelativePath(p, cwd, properties.root) + (!p || p.endsWith("/") ? "/" : "")));
+  return sync ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths) => formatPaths(paths, cwd, root));
 }
 async function glob(patternsOrOptions, options) {
   if (patternsOrOptions && (options == null ? undefined : options.patterns)) {
     throw new Error("Cannot pass patterns as both an argument and an option");
   }
   const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? { ...options, patterns: patternsOrOptions } : patternsOrOptions;
-  const cwd = opts.cwd ? require$$0$2.resolve(opts.cwd).replace(/\\/g, "/") : process.cwd().replace(/\\/g, "/");
+  const cwd = opts.cwd ? require$$0$2.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
   return crawl(opts, cwd, false);
 }
 function globSync(patternsOrOptions, options) {
@@ -15268,7 +16120,7 @@ function globSync(patternsOrOptions, options) {
     throw new Error("Cannot pass patterns as both an argument and an option");
   }
   const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? { ...options, patterns: patternsOrOptions } : patternsOrOptions;
-  const cwd = opts.cwd ? require$$0$2.resolve(opts.cwd).replace(/\\/g, "/") : process.cwd().replace(/\\/g, "/");
+  const cwd = opts.cwd ? require$$0$2.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
   return crawl(opts, cwd, true);
 }
 
@@ -16041,8 +16893,8 @@ function canExternalizeFile(filePath) {
   return !ext || ext === ".js" || ext === ".mjs" || ext === ".cjs";
 }
 
-const normalizedClientEntry$1 = normalizePath$3(CLIENT_ENTRY);
-const normalizedEnvEntry$1 = normalizePath$3(ENV_ENTRY);
+const normalizedClientEntry$1 = normalizePath$4(CLIENT_ENTRY);
+const normalizedEnvEntry$1 = normalizePath$4(ENV_ENTRY);
 const ERR_RESOLVE_PACKAGE_ENTRY_FAIL = "ERR_RESOLVE_PACKAGE_ENTRY_FAIL";
 const browserExternalId = "__vite-browser-external";
 const optionalPeerDepId = "__vite-optional-peer-dep";
@@ -16078,12 +16930,12 @@ function resolvePlugin(resolveOptions) {
       if (resolvedImports) {
         id = resolvedImports;
         if (resolveOpts.custom?.["vite:import-glob"]?.isSubImportsPattern) {
-          return normalizePath$3(path$d.join(root, id));
+          return normalizePath$4(path$d.join(root, id));
         }
       }
       let res;
       if (asSrc && depsOptimizer?.isOptimizedDepUrl(id)) {
-        const optimizedPath = id.startsWith(FS_PREFIX) ? fsPathFromId(id) : normalizePath$3(path$d.resolve(root, id.slice(1)));
+        const optimizedPath = id.startsWith(FS_PREFIX) ? fsPathFromId(id) : normalizePath$4(path$d.resolve(root, id.slice(1)));
         return optimizedPath;
       }
       if (asSrc && id.startsWith(FS_PREFIX)) {
@@ -16101,7 +16953,7 @@ function resolvePlugin(resolveOptions) {
       if (id[0] === "." || (preferRelative || importer?.endsWith(".html")) && startsWithWordCharRE.test(id)) {
         const basedir = importer ? path$d.dirname(importer) : process.cwd();
         const fsPath = path$d.resolve(basedir, id);
-        const normalizedFsPath = normalizePath$3(fsPath);
+        const normalizedFsPath = normalizePath$4(fsPath);
         if (depsOptimizer?.isOptimizedDepFile(normalizedFsPath)) {
           if (!options.isBuild && !DEP_VERSION_RE.test(normalizedFsPath)) {
             const browserHash = optimizedDepInfoFromFile(
@@ -16475,7 +17327,7 @@ async function tryOptimizedResolve(depsOptimizer, id, importer, preserveSymlinks
         packageCache
       )?.dir;
       if (idPkgDir == null) break;
-      idPkgDir = normalizePath$3(idPkgDir);
+      idPkgDir = normalizePath$4(idPkgDir);
     }
     if (optimizedData.src.startsWith(withTrailingSlash(idPkgDir))) {
       return depsOptimizer.getOptimizedDepId(optimizedData);
@@ -16709,7 +17561,7 @@ function getRealPath(resolved, preserveSymlinks) {
   if (!preserveSymlinks) {
     resolved = safeRealpathSync(resolved);
   }
-  return normalizePath$3(resolved);
+  return normalizePath$4(resolved);
 }
 function isDirectory(path2) {
   const stat = tryStatSync(path2);
@@ -17944,7 +18796,7 @@ async function transformGlobImport(code, id, root, resolveId, restoreQueryExtens
   };
 }
 function globSafePath(path) {
-  return escapePath(normalizePath$3(path));
+  return escapePath(normalizePath$4(path));
 }
 function lastNthChar(str, n) {
   return str.charAt(str.length - 1 - n);
@@ -17973,7 +18825,7 @@ async function toAbsoluteGlob(glob2, root, importer, resolveId) {
   if (glob2.startsWith("../")) return pre + posix$1.join(dir, glob2);
   if (glob2.startsWith("**")) return pre + glob2;
   const isSubImportsPattern = glob2[0] === "#" && glob2.includes("*");
-  const resolved = normalizePath$3(
+  const resolved = normalizePath$4(
     await resolveId(glob2, importer, {
       custom: { "vite:import-glob": { isSubImportsPattern } }
     }) || glob2
@@ -18227,7 +19079,7 @@ function globEntries(pattern, environment) {
   const resolvedPatterns = arraify(pattern);
   if (resolvedPatterns.every((str) => !isDynamicPattern(str))) {
     return resolvedPatterns.map(
-      (p) => normalizePath$3(path$d.resolve(environment.config.root, p))
+      (p) => normalizePath$4(path$d.resolve(environment.config.root, p))
     );
   }
   return glob(pattern, {
@@ -18253,7 +19105,7 @@ function esbuildScanPlugin(environment, depImports, missing, entries) {
   async function resolveId(id, importer) {
     return environment.pluginContainer.resolveId(
       id,
-      importer && normalizePath$3(importer),
+      importer && normalizePath$4(importer),
       { scan: true }
     );
   }
@@ -18363,7 +19215,7 @@ function esbuildScanPlugin(environment, depImports, missing, entries) {
                 loader: "js",
                 // since it is transpiled
                 contents: await doTransformGlobImport(contents, p, loader),
-                resolveDir: normalizePath$3(path$d.dirname(p)),
+                resolveDir: normalizePath$4(path$d.dirname(p)),
                 pluginData: {
                   htmlType: { loader }
                 }
@@ -18372,7 +19224,7 @@ function esbuildScanPlugin(environment, depImports, missing, entries) {
               scripts[key] = {
                 loader,
                 contents,
-                resolveDir: normalizePath$3(path$d.dirname(p)),
+                resolveDir: normalizePath$4(path$d.dirname(p)),
                 pluginData: {
                   htmlType: { loader }
                 }
@@ -18447,7 +19299,7 @@ function esbuildScanPlugin(environment, depImports, missing, entries) {
               return externalUnlessEntry({ path: id });
             }
           } else {
-            missing[id] = normalizePath$3(importer);
+            missing[id] = normalizePath$4(importer);
           }
         }
       );
@@ -19134,7 +19986,7 @@ function depsFromOptimizedDepInfo(depsInfo) {
   return obj;
 }
 function getOptimizedDepPath(environment, id) {
-  return normalizePath$3(
+  return normalizePath$4(
     path$d.resolve(getDepsCacheDir(environment), flattenId(id) + ".js")
   );
 }
@@ -19153,7 +20005,7 @@ function getTempSuffix() {
   );
 }
 function getDepsCacheDirPrefix(environment) {
-  return normalizePath$3(path$d.resolve(environment.config.cacheDir, "deps"));
+  return normalizePath$4(path$d.resolve(environment.config.cacheDir, "deps"));
 }
 function createIsOptimizedDepFile(environment) {
   const depsCacheDirPrefix = getDepsCacheDirPrefix(environment);
@@ -19162,11 +20014,11 @@ function createIsOptimizedDepFile(environment) {
 function createIsOptimizedDepUrl(environment) {
   const { root } = environment.config;
   const depsCacheDir = getDepsCacheDirPrefix(environment);
-  const depsCacheDirRelative = normalizePath$3(path$d.relative(root, depsCacheDir));
+  const depsCacheDirRelative = normalizePath$4(path$d.relative(root, depsCacheDir));
   const depsCacheDirPrefix = depsCacheDirRelative.startsWith("../") ? (
     // if the cache directory is outside root, the url prefix would be something
     // like '/@fs/absolute/path/to/node_modules/.vite'
-    `/@fs/${removeLeadingSlash(normalizePath$3(depsCacheDir))}`
+    `/@fs/${removeLeadingSlash(normalizePath$4(depsCacheDir))}`
   ) : (
     // if the cache directory is inside root, the url prefix would be something
     // like '/node_modules/.vite'
@@ -19179,7 +20031,7 @@ function createIsOptimizedDepUrl(environment) {
 function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
   const { hash, lockfileHash, configHash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
     if (key === "file" || key === "src") {
-      return normalizePath$3(path$d.resolve(depsCacheDir, value));
+      return normalizePath$4(path$d.resolve(depsCacheDir, value));
     }
     return value;
   });
@@ -19240,7 +20092,7 @@ function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
     },
     (key, value) => {
       if (key === "file" || key === "src") {
-        return normalizePath$3(path$d.relative(depsCacheDir, value));
+        return normalizePath$4(path$d.relative(depsCacheDir, value));
       }
       return value;
     },
@@ -19250,7 +20102,7 @@ function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
 function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
   const cwd = process.cwd();
   const flatId = flattenId(id) + ".js";
-  const normalizedOutputPath = normalizePath$3(
+  const normalizedOutputPath = normalizePath$4(
     path$d.relative(cwd, path$d.join(cacheDirOutputPath, flatId))
   );
   const output = outputs[normalizedOutputPath];
@@ -19258,7 +20110,7 @@ function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
     return output;
   }
   for (const [key, value] of Object.entries(outputs)) {
-    if (normalizePath$3(path$d.relative(cwd, key)) === normalizedOutputPath) {
+    if (normalizePath$4(path$d.relative(cwd, key)) === normalizedOutputPath) {
       return value;
     }
   }
@@ -19268,7 +20120,7 @@ async function extractExportsData(environment, filePath) {
   const { optimizeDeps: optimizeDeps2 } = environment.config;
   const esbuildOptions = optimizeDeps2.esbuildOptions ?? {};
   if (optimizeDeps2.extensions?.some((ext) => filePath.endsWith(ext))) {
-    const result = await build$b({
+    const result = await build$j({
       ...esbuildOptions,
       entryPoints: [filePath],
       write: false,
@@ -20237,7 +21089,7 @@ function getEnvFilesForMode(mode, envDir) {
     `.env.${mode}`,
     /** mode local file */
     `.env.${mode}.local`
-  ].map((file) => normalizePath$3(path$d.join(envDir, file)));
+  ].map((file) => normalizePath$4(path$d.join(envDir, file)));
 }
 function loadEnv(mode, envDir, prefixes = "VITE_") {
   if (mode === "local") {
@@ -30177,6 +31029,7 @@ var windows$1 = [
   'Code.exe',
   'Code - Insiders.exe',
   'VSCodium.exe',
+  'Cursor.exe',
   'atom.exe',
   'sublime_text.exe',
   'notepad++.exe',
@@ -30258,7 +31111,10 @@ var guess = function guessEditor (specifiedEditor) {
     } else if (process.platform === 'win32') {
       const output = childProcess$1
         .execSync(
-          'powershell -NoProfile -Command "Get-CimInstance -Query \\"select executablepath from win32_process where executablepath is not null\\" | % { $_.ExecutablePath }"',
+          'powershell -NoProfile -Command "' +
+            '[Console]::OutputEncoding=[Text.Encoding]::UTF8;' +
+            'Get-CimInstance -Query \\"select executablepath from win32_process where executablepath is not null\\" | % { $_.ExecutablePath }' +
+            '"',
           {
             stdio: ['pipe', 'pipe', 'ignore']
           }
@@ -30429,6 +31285,11 @@ function isTerminalEditor (editor) {
 
 const positionRE = /:(\d+)(:(\d+))?$/;
 function parseFile (file) {
+  // support `file://` protocol
+  if (file.startsWith('file://')) {
+    file = require$$0$5.fileURLToPath(file);
+  }
+
   const fileName = file.replace(positionRE, '');
   const match = file.match(positionRE);
   const lineNumber = match && match[1];
@@ -33030,7 +33891,7 @@ function getResolvedOutDirs(root, outDir, outputOptions) {
 function resolveEmptyOutDir(emptyOutDir, root, outDirs, logger) {
   if (emptyOutDir != null) return emptyOutDir;
   for (const outDir of outDirs) {
-    if (!normalizePath$3(outDir).startsWith(withTrailingSlash(root))) {
+    if (!normalizePath$4(outDir).startsWith(withTrailingSlash(root))) {
       logger?.warn(
         colors$1.yellow(
           `
@@ -40960,7 +41821,7 @@ function sirv (dir, opts={}) {
 	};
 }
 
-const knownJavascriptExtensionRE = /\.[tj]sx?$/;
+const knownJavascriptExtensionRE = /\.(?:[tj]sx?|[cm][tj]s)$/;
 const sirvOptions = ({
   getHeaders
 }) => {
@@ -40997,7 +41858,7 @@ function servePublicMiddleware(server, publicFiles) {
       } catch {
       }
     }
-    return normalizePath$3(filePath);
+    return normalizePath$4(filePath);
   };
   return function viteServePublicMiddleware(req, res, next) {
     if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url) || // for `/public-file.js?url` to be transformed
@@ -41621,7 +42482,7 @@ function htmlInlineProxyPlugin(config) {
       if (proxyMatch) {
         const index = Number(proxyMatch[1]);
         const file = cleanUrl(id);
-        const url = file.replace(normalizePath$3(config.root), "");
+        const url = file.replace(normalizePath$4(config.root), "");
         const result = htmlProxyMap.get(config).get(url)?.[index];
         if (result) {
           return { ...result, moduleSideEffects: true };
@@ -41780,8 +42641,8 @@ function buildHtmlPlugin(config) {
     name: "vite:build-html",
     async transform(html, id) {
       if (id.endsWith(".html")) {
-        id = normalizePath$3(id);
-        const relativeUrlPath = normalizePath$3(path$d.relative(config.root, id));
+        id = normalizePath$4(id);
+        const relativeUrlPath = normalizePath$4(path$d.relative(config.root, id));
         const publicPath = `/${relativeUrlPath}`;
         const publicBase = getBaseInHTML(relativeUrlPath, config);
         const publicToRelative = (filename) => publicBase + filename;
@@ -41879,7 +42740,7 @@ import ${JSON.stringify(url)}`;
                 } else if (node.childNodes.length) {
                   const scriptNode = node.childNodes.pop();
                   const contents = scriptNode.value;
-                  const filePath = id.replace(normalizePath$3(config.root), "");
+                  const filePath = id.replace(normalizePath$4(config.root), "");
                   addToHTMLProxyCache(config, filePath, inlineModuleIndex, {
                     code: contents
                   });
@@ -41915,8 +42776,8 @@ import "${id}?html-proxy&index=${inlineModuleIndex}.js"`;
                   const processedEncodedUrl = await processSrcSet(
                     attr.value,
                     async ({ url }) => {
-                      const decodedUrl = decodeURI(url);
-                      if (!isExcludedUrl(decodedUrl)) {
+                      const decodedUrl = decodeURIIfPossible(url);
+                      if (decodedUrl !== undefined && !isExcludedUrl(decodedUrl)) {
                         const result = await processAssetUrl(url);
                         return result !== decodedUrl ? encodeURIPath(result) : url;
                       }
@@ -41929,8 +42790,8 @@ import "${id}?html-proxy&index=${inlineModuleIndex}.js"`;
                 })()
               );
             } else if (attr.type === "src") {
-              const url = decodeURI(attr.value);
-              if (checkPublicFile(url, config)) {
+              const url = decodeURIIfPossible(attr.value);
+              if (url === undefined) ; else if (checkPublicFile(url, config)) {
                 overwriteAttrValue(
                   s,
                   attr.location,
@@ -41975,7 +42836,7 @@ import ${JSON.stringify(url)}`;
           if (inlineStyle) {
             inlineModuleIndex++;
             const code = inlineStyle.attr.value;
-            const filePath = id.replace(normalizePath$3(config.root), "");
+            const filePath = id.replace(normalizePath$4(config.root), "");
             addToHTMLProxyCache(config, filePath, inlineModuleIndex, { code });
             js += `
 import "${id}?html-proxy&inline-css&style-attr&index=${inlineModuleIndex}.css"`;
@@ -41988,7 +42849,7 @@ import "${id}?html-proxy&inline-css&style-attr&index=${inlineModuleIndex}.css"`;
           }
           if (node.nodeName === "style" && node.childNodes.length) {
             const styleNode = node.childNodes.pop();
-            const filePath = id.replace(normalizePath$3(config.root), "");
+            const filePath = id.replace(normalizePath$4(config.root), "");
             inlineModuleIndex++;
             addToHTMLProxyCache(config, filePath, inlineModuleIndex, {
               code: styleNode.value
@@ -42142,7 +43003,7 @@ ${js}`;
         (file) => toStyleSheetLinkTag(file, toOutputPath)
       );
       for (const [normalizedId, html] of processedHtml(this)) {
-        const relativeUrlPath = normalizePath$3(
+        const relativeUrlPath = normalizePath$4(
           path$d.relative(config.root, normalizedId)
         );
         const assetsBase = getBaseInHTML(relativeUrlPath, config);
@@ -42165,7 +43026,7 @@ ${js}`;
         const isAsync = isAsyncScriptMap.get(config).get(normalizedId);
         let result = html;
         const chunk = Object.values(bundle).find(
-          (chunk2) => chunk2.type === "chunk" && chunk2.isEntry && chunk2.facadeModuleId && normalizePath$3(chunk2.facadeModuleId) === normalizedId
+          (chunk2) => chunk2.type === "chunk" && chunk2.isEntry && chunk2.facadeModuleId && normalizePath$4(chunk2.facadeModuleId) === normalizedId
         );
         let canInlineEntry = false;
         if (chunk) {
@@ -42250,13 +43111,13 @@ ${js}`;
             getPublicAssetFilename(fileHash, config)
           );
           return encodeURIPath(
-            urlCanParse(publicAssetPath) ? publicAssetPath : normalizePath$3(publicAssetPath)
+            urlCanParse(publicAssetPath) ? publicAssetPath : normalizePath$4(publicAssetPath)
           );
         });
         if (chunk && canInlineEntry) {
           inlineEntryChunk.add(chunk.fileName);
         }
-        const shortEmitName = normalizePath$3(
+        const shortEmitName = normalizePath$4(
           path$d.relative(config.root, normalizedId)
         );
         this.emitFile({
@@ -42309,7 +43170,7 @@ function preImportMapHook(config) {
     const importMapAppendIndex = html.search(importMapAppendRE);
     if (importMapAppendIndex < 0) return;
     if (importMapAppendIndex < importMapIndex) {
-      const relativeHtml = normalizePath$3(
+      const relativeHtml = normalizePath$4(
         path$d.relative(config.root, ctx.filename)
       );
       config.logger.warnOnce(
@@ -42379,7 +43240,7 @@ function htmlEnvHook(config) {
         return env[key];
       } else {
         if (envPrefix.some((prefix) => key.startsWith(prefix))) {
-          const relativeHtml = normalizePath$3(
+          const relativeHtml = normalizePath$4(
             path$d.relative(config.root, ctx.filename)
           );
           config.logger.warn(
@@ -42653,6 +43514,13 @@ function serializeAttrs(attrs) {
 function incrementIndent(indent = "") {
   return `${indent}${indent[0] === "	" ? "	" : "  "}`;
 }
+function decodeURIIfPossible(input) {
+  try {
+    return decodeURI(input);
+  } catch {
+    return;
+  }
+}
 
 const debugCache = createDebugger("vite:cache");
 const knownIgnoreList = /* @__PURE__ */ new Set(["/", "/favicon.ico"]);
@@ -42698,7 +43566,7 @@ function transformMiddleware(server) {
       if (isSourceMap) {
         const depsOptimizer = environment.depsOptimizer;
         if (depsOptimizer?.isOptimizedDepUrl(url)) {
-          const sourcemapPath = url.startsWith(FS_PREFIX) ? fsPathFromId(url) : normalizePath$3(path$d.resolve(server.config.root, url.slice(1)));
+          const sourcemapPath = url.startsWith(FS_PREFIX) ? fsPathFromId(url) : normalizePath$4(path$d.resolve(server.config.root, url.slice(1)));
           try {
             const map = JSON.parse(
               await fsp.readFile(sourcemapPath, "utf-8")
@@ -42873,7 +43741,7 @@ function getHtmlFilename(url, server) {
     return decodeURIComponent(fsPathFromId(url));
   } else {
     return decodeURIComponent(
-      normalizePath$3(path$d.join(server.config.root, url.slice(1)))
+      normalizePath$4(path$d.join(server.config.root, url.slice(1)))
     );
   }
 }
@@ -42947,7 +43815,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
   const s = new MagicString(html);
   let inlineModuleIndex = -1;
   const proxyCacheUrl = decodeURI(
-    cleanUrl(proxyModulePath).replace(normalizePath$3(config.root), "")
+    cleanUrl(proxyModulePath).replace(normalizePath$4(config.root), "")
   );
   const styleUrl = [];
   const inlineStyles = [];
@@ -44098,7 +44966,7 @@ async function _createServer(inlineConfig = {}, options) {
     }
   };
   const onFileAddUnlink = async (file, isUnlink) => {
-    file = normalizePath$3(file);
+    file = normalizePath$4(file);
     reloadOnTsconfigChange(server, file);
     await pluginContainer.watchChange(file, {
       event: isUnlink ? "delete" : "create"
@@ -44125,7 +44993,7 @@ async function _createServer(inlineConfig = {}, options) {
     await onHMRUpdate(isUnlink ? "delete" : "create", file);
   };
   watcher.on("change", async (file) => {
-    file = normalizePath$3(file);
+    file = normalizePath$4(file);
     reloadOnTsconfigChange(server, file);
     await pluginContainer.watchChange(file, { event: "update" });
     for (const environment of Object.values(server.environments)) {
@@ -44273,7 +45141,7 @@ function createServerCloseFn(server) {
   });
 }
 function resolvedAllowDir(root, dir) {
-  return normalizePath$3(path$d.resolve(root, dir));
+  return normalizePath$4(path$d.resolve(root, dir));
 }
 const serverConfigDefaults = Object.freeze({
   port: DEFAULT_DEV_PORT,
@@ -44438,7 +45306,7 @@ var index = {
 
 const debugHmr = createDebugger("vite:hmr");
 const whitespaceRE = /\s/;
-const normalizedClientDir = normalizePath$3(CLIENT_DIR);
+const normalizedClientDir = normalizePath$4(CLIENT_DIR);
 function getShortName(file, root) {
   return file.startsWith(withTrailingSlash(root)) ? path$d.posix.relative(root, file) : file;
 }
@@ -44612,7 +45480,7 @@ async function handleHMRUpdate(type, file, server) {
     debugHmr?.(`[config change] ${colors$1.dim(shortFile)}`);
     config.logger.info(
       colors$1.green(
-        `${normalizePath$3(
+        `${normalizePath$4(
           path$d.relative(process.cwd(), file)
         )} changed, restarting server...`
       ),
@@ -44773,7 +45641,7 @@ async function handleHMRUpdate(type, file, server) {
           );
           environment.hot.send({
             type: "full-reload",
-            path: config.server.middlewareMode ? "*" : "/" + normalizePath$3(path$d.relative(config.root, file))
+            path: config.server.middlewareMode ? "*" : "/" + normalizePath$4(path$d.relative(config.root, file))
           });
         } else {
           debugHmr?.(
@@ -45770,7 +46638,7 @@ function getAliasPatternMatcher(entries) {
 }
 
 const debug$2 = createDebugger("vite:import-analysis");
-const clientDir = normalizePath$3(CLIENT_DIR);
+const clientDir = normalizePath$4(CLIENT_DIR);
 const skipRE = /\.(?:map|json)(?:$|\?)/;
 const canSkipImportAnalysis = (id) => skipRE.test(id) || isDirectCSSRequest(id);
 const optimizedDepChunkRE = /\/chunk-[A-Z\d]{8}\.js/;
@@ -45940,7 +46808,7 @@ function importAnalysisPlugin(config) {
           importerModule.isSelfAccepting = false;
           moduleGraph._hasResolveFailedErrorModules.add(importerModule);
           return this.error(
-            `Failed to resolve import "${url}" from "${normalizePath$3(
+            `Failed to resolve import "${url}" from "${normalizePath$4(
               path$d.relative(process.cwd(), importerFile)
             )}". Does the file exist?`,
             pos
@@ -46431,8 +47299,8 @@ function __vite__injectQuery(url, queryToInject) {
   return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
 }
 
-const normalizedClientEntry = normalizePath$3(CLIENT_ENTRY);
-const normalizedEnvEntry = normalizePath$3(ENV_ENTRY);
+const normalizedClientEntry = normalizePath$4(CLIENT_ENTRY);
+const normalizedEnvEntry = normalizePath$4(ENV_ENTRY);
 function clientInjectionsPlugin(config) {
   let injectConfigValues;
   const getDefineReplacer = perEnvironmentState((environment) => {
@@ -46586,7 +47454,7 @@ function err(e, pos) {
 }
 function findClosingParen(input, fromIndex) {
   let count = 1;
-  for (let i = fromIndex + 1; i < input.length; i++) {
+  for (let i = fromIndex; i < input.length; i++) {
     if (input[i] === "(") count++;
     if (input[i] === ")") count--;
     if (count === 0) return i;
@@ -47094,10 +47962,10 @@ async function transformDynamicImport(importSource, importer, resolve, root) {
     if (!resolvedFileName) {
       return null;
     }
-    const relativeFileName = normalizePath$3(
+    const relativeFileName = normalizePath$4(
       posix$1.relative(
-        posix$1.dirname(normalizePath$3(importer)),
-        normalizePath$3(resolvedFileName)
+        posix$1.dirname(normalizePath$4(importer)),
+        normalizePath$4(resolvedFileName)
       )
     );
     importSource = "`" + (relativeFileName[0] === "." ? "" : "./") + relativeFileName + "`";
@@ -47551,7 +48419,7 @@ class EnvironmentPluginContainer {
       }
     }
     if (id) {
-      partial.id = isExternalUrl(id) ? id : normalizePath$3(id);
+      partial.id = isExternalUrl(id) ? id : normalizePath$4(id);
       return partial;
     } else {
       return null;
@@ -47833,7 +48701,7 @@ ${err2.stack || err2.message}
         if (!err.frame) {
           let code = this._activeCode;
           if (err.loc.file) {
-            err.id = normalizePath$3(err.loc.file);
+            err.id = normalizePath$4(err.loc.file);
             try {
               code = fs__default.readFileSync(err.loc.file, "utf-8");
             } catch {
@@ -47866,7 +48734,7 @@ ${err2.stack || err2.message}
       if (!err.frame) {
         let code = err.pluginCode;
         if (err.loc.file) {
-          err.id = normalizePath$3(err.loc.file);
+          err.id = normalizePath$4(err.loc.file);
           if (!code) {
             try {
               code = fs__default.readFileSync(err.loc.file, "utf-8");
@@ -48441,7 +49309,7 @@ function cssPostPlugin(config) {
         const relative = config.base === "./" || config.base === "";
         const cssAssetDirname = encodedPublicUrls || relative ? slash$1(getCssAssetDirname(cssAssetName)) : undefined;
         const toRelative = (filename) => {
-          const relativePath = normalizePath$3(
+          const relativePath = normalizePath$4(
             path$d.relative(cssAssetDirname, filename)
           );
           return relativePath[0] === "." ? relativePath : "./" + relativePath;
@@ -48461,7 +49329,7 @@ function cssPostPlugin(config) {
           );
         });
         if (encodedPublicUrls) {
-          const relativePathToPublicFromCSS = normalizePath$3(
+          const relativePathToPublicFromCSS = normalizePath$4(
             path$d.relative(cssAssetDirname, "")
           );
           chunkCSS2 = chunkCSS2.replace(publicAssetUrlRE, (_, hash) => {
@@ -48481,7 +49349,7 @@ function cssPostPlugin(config) {
         return chunkCSS2;
       };
       function ensureFileExt(name, ext) {
-        return normalizePath$3(
+        return normalizePath$4(
           path$d.format({ ...path$d.parse(name), base: undefined, ext })
         );
       }
@@ -48860,10 +49728,10 @@ async function compileCSSPreprocessors(environment, id, lang, code, workerContro
   }
   let deps;
   if (preprocessResult.deps.length > 0) {
-    const normalizedFilename = normalizePath$3(opts.filename);
+    const normalizedFilename = normalizePath$4(opts.filename);
     deps = new Set(
       [...preprocessResult.deps].filter(
-        (dep) => normalizePath$3(dep) !== normalizedFilename
+        (dep) => normalizePath$4(dep) !== normalizedFilename
       )
     );
   }
@@ -48970,10 +49838,11 @@ async function compileCSS(environment, id, code, workerController, urlResolver)
       })
     );
   }
-  if (urlResolver && // if there's an @import, we need to add this plugin
-  // regradless of whether it contains url() or image-set(),
-  // because we don't know the content referenced by @import
-  (needInlineImport || hasUrl)) {
+  if (urlResolver && // when a postcss plugin is used (including the internal postcss plugins),
+  // we need to add this plugin regardless of whether
+  // this file contains url() or image-set(),
+  // because we don't know the content injected by those plugins
+  (postcssPlugins.length > 0 || isModule || hasUrl)) {
     postcssPlugins.push(
       UrlRewritePostcssPlugin({
         resolver: urlResolver,
@@ -49042,7 +49911,7 @@ async function compileCSS(environment, id, code, workerController, urlResolver)
     });
     for (const message of postcssResult.messages) {
       if (message.type === "dependency") {
-        deps.add(normalizePath$3(message.file));
+        deps.add(normalizePath$4(message.file));
       } else if (message.type === "dir-dependency") {
         const { dir, glob: globPattern = "**" } = message;
         const files = globSync(globPattern, {
@@ -49119,8 +49988,8 @@ function createCachedImport(imp) {
     return cached;
   };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-BUK8RJ2R.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-DWzCYIjV.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-CJRd4GTw.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-B42HB7IL.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -49143,7 +50012,7 @@ async function formatPostcssSourceMap(rawMap, file) {
     if (cleanSource[0] === "<" && cleanSource[cleanSource.length - 1] === ">") {
       return `\0${cleanSource}`;
     }
-    return normalizePath$3(path$d.resolve(inputFileDir, cleanSource));
+    return normalizePath$4(path$d.resolve(inputFileDir, cleanSource));
   });
   return {
     file,
@@ -49795,7 +50664,7 @@ const scssProcessor = (maxWorkers) => {
         const map2 = result.map ? JSON.parse(result.map.toString()) : undefined;
         if (map2) {
           map2.sources = map2.sources.map(
-            (url) => url.startsWith("file://") ? normalizePath$3(fileURLToPath$1(url)) : url
+            (url) => url.startsWith("file://") ? normalizePath$4(fileURLToPath$1(url)) : url
           );
         }
         return {
@@ -49844,7 +50713,7 @@ async function rebaseUrls(environment, file, rootFile, alias, variablePrefix, re
     }
     const absolute = await resolver(environment, url, file) || path$d.resolve(fileDir, url);
     const relative = path$d.relative(rootDir, absolute);
-    return normalizePath$3(relative);
+    return normalizePath$4(relative);
   };
   if (hasImportCss) {
     rebased = await rewriteImportCss(content, rebaseFn);
@@ -50111,7 +50980,7 @@ const stylProcessor = (maxWorkers) => {
 function formatStylusSourceMap(mapBefore, root) {
   if (!mapBefore) return undefined;
   const map2 = { ...mapBefore };
-  const resolveFromRoot = (p) => normalizePath$3(path$d.resolve(root, p));
+  const resolveFromRoot = (p) => normalizePath$4(path$d.resolve(root, p));
   if (map2.file) {
     map2.file = resolveFromRoot(map2.file);
   }
@@ -50866,6 +51735,7 @@ function buildImportAnalysisPlugin(config) {
                 chunk.map
               ]);
               map.toUrl = () => genSourceMapUrl(map);
+              const originalDebugId = chunk.map.debugId;
               chunk.map = map;
               if (buildSourcemap === "inline") {
                 chunk.code = chunk.code.replace(
@@ -50875,6 +51745,9 @@ function buildImportAnalysisPlugin(config) {
                 chunk.code += `
 //# sourceMappingURL=${genSourceMapUrl(map)}`;
               } else {
+                if (originalDebugId) {
+                  map.debugId = originalDebugId;
+                }
                 const mapAsset = bundle[chunk.fileName + ".map"];
                 if (mapAsset && mapAsset.type === "asset") {
                   mapAsset.source = map.toString();
@@ -50905,7 +51778,7 @@ function ssrManifestPlugin() {
         const chunk = bundle[file];
         if (chunk.type === "chunk") {
           for (const id in chunk.modules) {
-            const normalizedId = normalizePath$3(relative$2(config.root, id));
+            const normalizedId = normalizePath$4(relative$2(config.root, id));
             const mappedChunks = ssrManifest[normalizedId] ?? (ssrManifest[normalizedId] = []);
             if (!chunk.isEntry) {
               mappedChunks.push(joinUrlSegments(base, chunk.fileName));
@@ -50954,7 +51827,7 @@ function ssrManifestPlugin() {
                     chunk2.imports.forEach(addDeps);
                   }
                 };
-                const normalizedFile = normalizePath$3(
+                const normalizedFile = normalizePath$4(
                   join$1(dirname$2(chunk.fileName), url.slice(1, -1))
                 );
                 addDeps(normalizedFile);
@@ -51782,8 +52655,8 @@ function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config
 const toOutputFilePathInCss = toOutputFilePathWithoutRuntime;
 const toOutputFilePathInHtml = toOutputFilePathWithoutRuntime;
 function areSeparateFolders(a, b) {
-  const na = normalizePath$3(a);
-  const nb = normalizePath$3(b);
+  const na = normalizePath$4(a);
+  const nb = normalizePath$4(b);
   return na !== nb && !na.startsWith(withTrailingSlash(nb)) && !nb.startsWith(withTrailingSlash(na));
 }
 class BuildEnvironment extends BaseEnvironment {
@@ -52790,7 +53663,7 @@ class EnvironmentModuleGraph {
   // need to be represented in the module graph so that they can trigger
   // hmr in the importing css file.
   createFileOnlyEntry(file) {
-    file = normalizePath$3(file);
+    file = normalizePath$4(file);
     let fileMappedModules = this.fileToModulesMap.get(file);
     if (!fileMappedModules) {
       fileMappedModules = /* @__PURE__ */ new Set();
@@ -52894,14 +53767,14 @@ async function warmupFile(server, environment, file) {
 function htmlFileToUrl(file, root) {
   const url = path$d.relative(root, file);
   if (url[0] === ".") return;
-  return "/" + normalizePath$3(url);
+  return "/" + normalizePath$4(url);
 }
 function fileToUrl(file, root) {
   const url = path$d.relative(root, file);
   if (url[0] === ".") {
-    return path$d.posix.join(FS_PREFIX, normalizePath$3(file));
+    return path$d.posix.join(FS_PREFIX, normalizePath$4(file));
   }
-  return "/" + normalizePath$3(url);
+  return "/" + normalizePath$4(url);
 }
 async function mapFiles(files, root) {
   if (!files.length) return [];
@@ -53743,11 +54616,11 @@ function checkBadCharactersInPath(path2, logger) {
 const clientAlias = [
   {
     find: /^\/?@vite\/env/,
-    replacement: path$d.posix.join(FS_PREFIX, normalizePath$3(ENV_ENTRY))
+    replacement: path$d.posix.join(FS_PREFIX, normalizePath$4(ENV_ENTRY))
   },
   {
     find: /^\/?@vite\/client/,
-    replacement: path$d.posix.join(FS_PREFIX, normalizePath$3(CLIENT_ENTRY))
+    replacement: path$d.posix.join(FS_PREFIX, normalizePath$4(CLIENT_ENTRY))
   }
 ];
 function resolveEnvironmentResolveOptions(resolve, alias, preserveSymlinks, logger, consumer, isSsrTargetWebworkerEnvironment) {
@@ -53871,7 +54744,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
     allowClearScreen: config.clearScreen,
     customLogger: config.customLogger
   });
-  const resolvedRoot = normalizePath$3(
+  const resolvedRoot = normalizePath$4(
     config.root ? path$d.resolve(config.root) : process.cwd()
   );
   checkBadCharactersInPath(resolvedRoot, logger);
@@ -53990,7 +54863,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
     patchedConfigSsr,
     resolvedDefaultResolve.preserveSymlinks
   );
-  const envDir = config.envDir ? normalizePath$3(path$d.resolve(resolvedRoot, config.envDir)) : resolvedRoot;
+  const envDir = config.envDir ? normalizePath$4(path$d.resolve(resolvedRoot, config.envDir)) : resolvedRoot;
   const userEnv = inlineConfig.envFile !== false && loadEnv(mode, envDir, resolveEnvPrefix(config));
   const userNodeEnv = process.env.VITE_USER_NODE_ENV;
   if (!isNodeEnvSet && userNodeEnv) {
@@ -54006,12 +54879,12 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
   const relativeBaseShortcut = config.base === "" || config.base === "./";
   const resolvedBase = relativeBaseShortcut ? !isBuild || config.build?.ssr ? "/" : "./" : resolveBaseUrl(config.base, isBuild, logger);
   const pkgDir = findNearestPackageData(resolvedRoot, packageCache)?.dir;
-  const cacheDir = normalizePath$3(
+  const cacheDir = normalizePath$4(
     config.cacheDir ? path$d.resolve(resolvedRoot, config.cacheDir) : pkgDir ? path$d.join(pkgDir, `node_modules/.vite`) : path$d.join(resolvedRoot, `.vite`)
   );
   const assetsFilter = config.assetsInclude && (!Array.isArray(config.assetsInclude) || config.assetsInclude.length) ? createFilter(config.assetsInclude) : () => false;
   const { publicDir } = config;
-  const resolvedPublicDir = publicDir !== false && publicDir !== "" ? normalizePath$3(
+  const resolvedPublicDir = publicDir !== false && publicDir !== "" ? normalizePath$4(
     path$d.resolve(
       resolvedRoot,
       typeof publicDir === "string" ? publicDir : configDefaults.publicDir
@@ -54074,9 +54947,9 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
   const base = withTrailingSlash(resolvedBase);
   const preview = resolvePreviewOptions(config.preview, server);
   resolved = {
-    configFile: configFile ? normalizePath$3(configFile) : undefined,
+    configFile: configFile ? normalizePath$4(configFile) : undefined,
     configFileDependencies: configFileDependencies.map(
-      (name) => normalizePath$3(path$d.resolve(name))
+      (name) => normalizePath$4(path$d.resolve(name))
     ),
     inlineConfig,
     root: resolvedRoot,
@@ -54241,7 +55114,7 @@ assetFileNames isn't equal for every build.rollupOptions.output. A single patter
 `)
     );
   }
-  const resolvedBuildOutDir = normalizePath$3(
+  const resolvedBuildOutDir = normalizePath$4(
     path$d.resolve(resolved.root, resolved.build.outDir)
   );
   if (isParentDirectory(resolvedBuildOutDir, resolved.root) || resolvedBuildOutDir === resolved.root) {
@@ -54325,7 +55198,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
       throw new Error(`config must export or return an object.`);
     }
     return {
-      path: normalizePath$3(resolvedPath),
+      path: normalizePath$4(resolvedPath),
       config,
       dependencies
     };
@@ -54371,7 +55244,7 @@ async function bundleConfigFile(fileName, isESM) {
   const dirnameVarName = "__vite_injected_original_dirname";
   const filenameVarName = "__vite_injected_original_filename";
   const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
-  const result = await build$b({
+  const result = await build$j({
     absWorkingDir: process.cwd(),
     entryPoints: [fileName],
     write: false,
@@ -54593,4 +55466,4 @@ function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optim
   }
 }
 
-export { normalizePath$3 as A, BuildEnvironment as B, mergeConfig as C, DevEnvironment as D, mergeAlias as E, createFilter as F, rollupVersion as G, send$1 as H, createLogger as I, searchForWorkspaceRoot as J, isFileServingAllowed as K, isFileLoadingAllowed as L, loadEnv as M, resolveEnvPrefix as N, colors$1 as O, getDefaultExportFromCjs as P, commonjsGlobal as Q, index$1 as R, index as S, build$1 as T, preview$1 as U, arraify as a, perEnvironmentState as b, createServer as c, defineConfig as d, preview as e, build as f, createBuilder as g, createIdResolver as h, isInNodeModules$1 as i, formatPostcssSourceMap as j, preprocessCSS as k, loadConfigFromFile as l, buildErrorMessage as m, createRunnableDevEnvironment as n, optimizeDeps as o, perEnvironmentPlugin as p, isRunnableDevEnvironment as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, runnerImport as u, fetchModule as v, createServerModuleRunner as w, createServerModuleRunnerTransport as x, createServerHotChannel as y, ssrTransform as z };
+export { normalizePath$4 as A, BuildEnvironment as B, mergeConfig as C, DevEnvironment as D, mergeAlias as E, createFilter as F, rollupVersion as G, send$1 as H, createLogger as I, searchForWorkspaceRoot as J, isFileServingAllowed as K, isFileLoadingAllowed as L, loadEnv as M, resolveEnvPrefix as N, colors$1 as O, getDefaultExportFromCjs as P, commonjsGlobal as Q, index$1 as R, index as S, build$1 as T, preview$1 as U, arraify as a, perEnvironmentState as b, createServer as c, defineConfig as d, preview as e, build as f, createBuilder as g, createIdResolver as h, isInNodeModules$1 as i, formatPostcssSourceMap as j, preprocessCSS as k, loadConfigFromFile as l, buildErrorMessage as m, createRunnableDevEnvironment as n, optimizeDeps as o, perEnvironmentPlugin as p, isRunnableDevEnvironment as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, runnerImport as u, fetchModule as v, createServerModuleRunner as w, createServerModuleRunnerTransport as x, createServerHotChannel as y, ssrTransform as z };