vite 2.8.0-beta.4 → 2.8.0-beta.5

package/dist/node/chunks/{dep-7b4d034a.js → dep-aff09a4c.js}

@@ -10,7 +10,7 @@ var require$$0$5 = require('url');
 var require$$1$3 = require('http');
 var require$$0$8 = require('stream');
 var require$$1 = require('os');
-var resolve$3 = require('resolve');
+var resolve$4 = require('resolve');
 var require$$0$6 = require('module');
 var perf_hooks = require('perf_hooks');
 var require$$1$4 = require('https');
@@ -50,7 +50,7 @@ var require$$0__default$5 = /*#__PURE__*/_interopDefaultLegacy(require$$0$5);
 var require$$1__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$1$3);
 var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$8);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
-var resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve$3);
+var resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve$4);
 var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$6);
 var require$$1__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$1$4);
 var require$$0__default$6 = /*#__PURE__*/_interopDefaultLegacy(require$$0$7);
@@ -1222,10 +1222,10 @@ const KNOWN_ASSET_TYPES = [
 const DEFAULT_ASSETS_RE = new RegExp(`\\.(` + KNOWN_ASSET_TYPES.join('|') + `)(\\?.*)?$`);
 const DEP_VERSION_RE = /[\?&](v=[\w\.-]+)\b/;
 
-var charToInteger$1 = {};
-var chars$2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$3 = 0; i$3 < chars$2.length; i$3++) {
-    charToInteger$1[chars$2.charCodeAt(i$3)] = i$3;
+var charToInteger = {};
+var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+for (var i$2 = 0; i$2 < chars$1.length; i$2++) {
+    charToInteger[chars$1.charCodeAt(i$2)] = i$2;
 }
 function decode(mappings) {
     var decoded = [];
@@ -1252,7 +1252,7 @@ function decode(mappings) {
             segment[0] = 0;
         }
         else {
-            var integer = charToInteger$1[c];
+            var integer = charToInteger[c];
             if (integer === undefined) {
                 throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
             }
@@ -1293,7 +1293,7 @@ function segmentify(line, segment, j) {
     else if (j === 1)
         line.push([segment[0]]);
 }
-function encode$1(decoded) {
+function encode(decoded) {
     var sourceFileIndex = 0; // second field
     var sourceCodeLine = 0; // third field
     var sourceCodeColumn = 0; // fourth field
@@ -1309,19 +1309,19 @@ function encode$1(decoded) {
         var lineMappings = [];
         for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
             var segment = line_1[_i];
-            var segmentMappings = encodeInteger$1(segment[0] - generatedCodeColumn);
+            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
             generatedCodeColumn = segment[0];
             if (segment.length > 1) {
                 segmentMappings +=
-                    encodeInteger$1(segment[1] - sourceFileIndex) +
-                        encodeInteger$1(segment[2] - sourceCodeLine) +
-                        encodeInteger$1(segment[3] - sourceCodeColumn);
+                    encodeInteger(segment[1] - sourceFileIndex) +
+                        encodeInteger(segment[2] - sourceCodeLine) +
+                        encodeInteger(segment[3] - sourceCodeColumn);
                 sourceFileIndex = segment[1];
                 sourceCodeLine = segment[2];
                 sourceCodeColumn = segment[3];
             }
             if (segment.length === 5) {
-                segmentMappings += encodeInteger$1(segment[4] - nameIndex);
+                segmentMappings += encodeInteger(segment[4] - nameIndex);
                 nameIndex = segment[4];
             }
             lineMappings.push(segmentMappings);
@@ -1330,7 +1330,7 @@ function encode$1(decoded) {
     }
     return mappings;
 }
-function encodeInteger$1(num) {
+function encodeInteger(num) {
     var result = '';
     num = num < 0 ? (-num << 1) | 1 : num << 1;
     do {
@@ -1339,11 +1339,186 @@ function encodeInteger$1(num) {
         if (num > 0) {
             clamped |= 32;
         }
-        result += chars$2[clamped];
+        result += chars$1[clamped];
     } while (num > 0);
     return result;
 }
 
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ */
+const urlRegex = /^([\w+.-]+:)\/\/([^@]*@)?([^:/]*)(:\d+)?(\/[^#?]*)?/;
+function isAbsoluteUrl(input) {
+    return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+    return input.startsWith('//');
+}
+function isAbsolutePath(input) {
+    return input.startsWith('/');
+}
+function parseAbsoluteUrl(input) {
+    const match = urlRegex.exec(input);
+    return {
+        scheme: match[1],
+        user: match[2] || '',
+        host: match[3],
+        port: match[4] || '',
+        path: match[5] || '/',
+        relativePath: false,
+    };
+}
+function parseUrl$2(input) {
+    if (isSchemeRelativeUrl(input)) {
+        const url = parseAbsoluteUrl('http:' + input);
+        url.scheme = '';
+        return url;
+    }
+    if (isAbsolutePath(input)) {
+        const url = parseAbsoluteUrl('http://foo.com' + input);
+        url.scheme = '';
+        url.host = '';
+        return url;
+    }
+    if (!isAbsoluteUrl(input)) {
+        const url = parseAbsoluteUrl('http://foo.com/' + input);
+        url.scheme = '';
+        url.host = '';
+        url.relativePath = true;
+        return url;
+    }
+    return parseAbsoluteUrl(input);
+}
+function stripPathFilename(path) {
+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
+    // paths. It's not a file, so we can't strip it.
+    if (path.endsWith('/..'))
+        return path;
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+    // If we're not a relative path, then we're an absolute path, and it doesn't matter what base is.
+    if (!url.relativePath)
+        return;
+    normalizePath$5(base);
+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+    // path).
+    if (url.path === '/') {
+        url.path = base.path;
+    }
+    else {
+        // Resolution happens relative to the base path's directory, not the file.
+        url.path = stripPathFilename(base.path) + url.path;
+    }
+    // If the base path is absolute, then our path is now absolute too.
+    url.relativePath = base.relativePath;
+}
+/**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+function normalizePath$5(url) {
+    const { relativePath } = url;
+    const pieces = url.path.split('/');
+    // We need to preserve the first piece always, so that we output a leading slash. The item at
+    // pieces[0] is an empty string.
+    let pointer = 1;
+    // Positive is the number of real directories we've output, used for popping a parent directory.
+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+    let positive = 0;
+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+    // real directory, we won't need to append, unless the other conditions happen again.
+    let addTrailingSlash = false;
+    for (let i = 1; i < pieces.length; i++) {
+        const piece = pieces[i];
+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
+        if (!piece) {
+            addTrailingSlash = true;
+            continue;
+        }
+        // If we encounter a real directory, then we don't need to append anymore.
+        addTrailingSlash = false;
+        // A current directory, which we can always drop.
+        if (piece === '.')
+            continue;
+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
+        // have an excess of parents, and we'll need to keep the "..".
+        if (piece === '..') {
+            if (positive) {
+                addTrailingSlash = true;
+                positive--;
+                pointer--;
+            }
+            else if (relativePath) {
+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                pieces[pointer++] = piece;
+            }
+            continue;
+        }
+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+        // any popped or dropped directories.
+        pieces[pointer++] = piece;
+        positive++;
+    }
+    let path = '';
+    for (let i = 1; i < pointer; i++) {
+        path += '/' + pieces[i];
+    }
+    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+        path += '/';
+    }
+    url.path = path;
+}
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+function resolve$3(input, base) {
+    if (!input && !base)
+        return '';
+    const url = parseUrl$2(input);
+    // If we have a base, and the input isn't already an absolute URL, then we need to merge.
+    if (base && !url.scheme) {
+        const baseUrl = parseUrl$2(base);
+        url.scheme = baseUrl.scheme;
+        // If there's no host, then we were just a path.
+        if (!url.host || baseUrl.scheme === 'file:') {
+            // The host, user, and port are joined, you can't copy one without the others.
+            url.user = baseUrl.user;
+            url.host = baseUrl.host;
+            url.port = baseUrl.port;
+        }
+        mergePaths(url, baseUrl);
+    }
+    normalizePath$5(url);
+    // If the input (and base, if there was one) are both relative, then we need to output a relative.
+    if (url.relativePath) {
+        // The first char is always a "/".
+        const path = url.path.slice(1);
+        if (!path)
+            return '.';
+        // If base started with a leading ".", or there is no base and input started with a ".", then we
+        // need to ensure that the relative path starts with a ".". We don't know if relative starts
+        // with a "..", though, so check before prepending.
+        const keepRelative = (base || input).startsWith('.');
+        return !keepRelative || path.startsWith('.') ? path : './' + path;
+    }
+    // If there's no host (and no scheme/user/port), then we need to output an absolute path.
+    if (!url.scheme && !url.host)
+        return url.path;
+    // We're outputting either an absolute URL, or a protocol relative one.
+    return `${url.scheme}//${url.user}${url.host}${url.port}${url.path}`;
+}
+
 /**
  * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
  *
@@ -1468,150 +1643,6 @@ class OriginalSource {
     }
 }
 
-/* istanbul ignore next */
-const Url$1 = (typeof URL !== 'undefined' ? URL : require('url').URL);
-// Matches "..", which must be preceeded by "/" or the start of the string, and
-// must be followed by a "/". We do not eat the following "/", so that the next
-// iteration can match on it.
-const parentRegex = /(^|\/)\.\.(?=\/|$)/g;
-function isAbsoluteUrl(url) {
-    try {
-        return !!new Url$1(url);
-    }
-    catch (e) {
-        return false;
-    }
-}
-/**
- * Creates a directory name that is guaranteed to not be in `str`.
- */
-function uniqInStr(str) {
-    let uniq = String(Math.random()).slice(2);
-    while (str.indexOf(uniq) > -1) {
-        /* istanbul ignore next */
-        uniq += uniq;
-    }
-    return uniq;
-}
-/**
- * Removes the filename from the path (everything trailing the last "/"). This
- * is only safe to call on a path, never call with an absolute or protocol
- * relative URL.
- */
-function stripPathFilename(path) {
-    path = normalizePath$5(path);
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-/**
- * Normalizes a protocol-relative URL, but keeps it protocol relative by
- * stripping out the protocl before returning it.
- */
-function normalizeProtocolRelative(input, absoluteBase) {
-    const { href, protocol } = new Url$1(input, absoluteBase);
-    return href.slice(protocol.length);
-}
-/**
- * Normalizes a simple path (one that has no ".."s, or is absolute so ".."s can
- * be normalized absolutely).
- */
-function normalizeSimplePath(input) {
-    const { href } = new Url$1(input, 'https://foo.com/');
-    return href.slice('https://foo.com/'.length);
-}
-/**
- * Normalizes a path, ensuring that excess ".."s are preserved for relative
- * paths in the output.
- *
- * If the input is absolute, this will return an absolutey normalized path, but
- * it will not have a leading "/".
- *
- * If the input has a leading "..", the output will have a leading "..".
- *
- * If the input has a leading ".", the output will not have a leading "."
- * unless there are too many ".."s, in which case there will be a leading "..".
- */
-function normalizePath$5(input) {
-    // If there are no ".."s, we can treat this as if it were an absolute path.
-    // The return won't be an absolute path, so it's easy.
-    if (!parentRegex.test(input))
-        return normalizeSimplePath(input);
-    // We already found one "..". Let's see how many there are.
-    let total = 1;
-    while (parentRegex.test(input))
-        total++;
-    // If there are ".."s, we need to prefix the the path with the same number of
-    // unique directories. This is to ensure that we "remember" how many parent
-    // directories we are accessing. Eg, "../../.." must keep 3, and "foo/../.."
-    // must keep 1.
-    const uniqDirectory = `z${uniqInStr(input)}/`;
-    // uniqDirectory is just a "z", followed by numbers, followed by a "/". So
-    // generating a runtime regex from it is safe. We'll use this search regex to
-    // strip out our uniq directory names and insert any needed ".."s.
-    const search = new RegExp(`^(?:${uniqDirectory})*`);
-    // Now we can resolve the total path. If there are excess ".."s, they will
-    // eliminate one or more of the unique directories we prefix with.
-    const relative = normalizeSimplePath(uniqDirectory.repeat(total) + input);
-    // We can now count the number of unique directories that were eliminated. If
-    // there were 3, and 1 was eliminated, we know we only need to add 1 "..". If
-    // 2 were eliminated, we need to insert 2 ".."s. If all 3 were eliminated,
-    // then we need 3, etc. This replace is guranteed to match (it may match 0 or
-    // more times), and we can count the total match to see how many were eliminated.
-    return relative.replace(search, (all) => {
-        const leftover = all.length / uniqDirectory.length;
-        return '../'.repeat(total - leftover);
-    });
-}
-/**
- * Attempts to resolve `input` URL relative to `base`.
- */
-function resolve$2(input, base) {
-    if (!base)
-        base = '';
-    // Absolute URLs are very easy to resolve right.
-    if (isAbsoluteUrl(input))
-        return new Url$1(input).href;
-    if (base) {
-        // Absolute URLs are easy...
-        if (isAbsoluteUrl(base))
-            return new Url$1(input, base).href;
-        // If base is protocol relative, we'll resolve with it but keep the result
-        // protocol relative.
-        if (base.startsWith('//'))
-            return normalizeProtocolRelative(input, `https:${base}`);
-    }
-    // Normalize input, but keep it protocol relative. We know base doesn't supply
-    // a protocol, because that would have been handled above.
-    if (input.startsWith('//'))
-        return normalizeProtocolRelative(input, 'https://foo.com/');
-    // We now know that base (if there is one) and input are paths. We've handled
-    // both absolute and protocol-relative variations above.
-    // Absolute paths don't need any special handling, because they cannot have
-    // extra "." or ".."s. That'll all be stripped away. Input takes priority here,
-    // because if input is an absolute path, base path won't affect it in any way.
-    if (input.startsWith('/'))
-        return '/' + normalizeSimplePath(input);
-    // Since input and base are paths, we need to join them to do any further
-    // processing. Paths are joined at the directory level, so we need to remove
-    // the base's filename before joining. We also know that input does not have a
-    // leading slash, and that the stripped base will have a trailing slash if
-    // there are any directories (or it'll be empty).
-    const joined = stripPathFilename(base) + input;
-    // If base is an absolute path, then input will be relative to it.
-    if (base.startsWith('/'))
-        return '/' + normalizeSimplePath(joined);
-    // We now know both base (if there is one) and input are relative paths.
-    const relative = normalizePath$5(joined);
-    // If base started with a leading ".", or there is no base and input started
-    // with a ".", then we need to ensure that the relative path starts with a
-    // ".". We don't know if relative starts with a "..", though, so check before
-    // prepending.
-    if ((base || input).startsWith('.') && !relative.startsWith('.')) {
-        return './' + relative;
-    }
-    return relative;
-}
-
 /**
  * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
  *
@@ -1627,13 +1658,13 @@ function resolve$2(input, base) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function resolve$1$1(input, base) {
+function resolve$2(input, base) {
     // The base is always treated as a directory, if it's not empty.
     // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
     // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
     if (base && !base.endsWith('/'))
         base += '/';
-    return resolve$2(input, base);
+    return resolve$3(input, base);
 }
 
 /**
@@ -1952,7 +1983,7 @@ function buildSourceMapTree(input, loader, relativeRoot) {
     const children = sources.map((sourceFile, i) => {
         // Each source file is loaded relative to the sourcemap's own sourceRoot,
         // which is itself relative to the sourcemap's parent.
-        const uri = resolve$1$1(sourceFile || '', resolve$1$1(sourceRoot || '', stripFilename(relativeRoot)));
+        const uri = resolve$2(sourceFile || '', resolve$2(sourceRoot || '', stripFilename(relativeRoot)));
         // Use the provided loader callback to retrieve the file's sourcemap.
         // TODO: We should eventually support async loading of sourcemap files.
         const sourceMap = loader(uri);
@@ -1999,7 +2030,7 @@ class SourceMap$1 {
         this.version = 3; // SourceMap spec says this should be first.
         if ('file' in map)
             this.file = map.file;
-        this.mappings = options.decodedMappings ? map.mappings : encode$1(map.mappings);
+        this.mappings = options.decodedMappings ? map.mappings : encode(map.mappings);
         this.names = map.names;
         // TODO: We first need to make all source URIs relative to the sourceRoot
         // before we can support a sourceRoot.
@@ -2059,7 +2090,7 @@ function unwrapId$1(id) {
     return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length) : id;
 }
 const flattenId = (id) => id.replace(/(\s*>\s*)/g, '__').replace(/[\/\.]/g, '_');
-const normalizeId$1 = (id) => id.replace(/(\s*>\s*)/g, ' > ');
+const normalizeId = (id) => id.replace(/(\s*>\s*)/g, ' > ');
 //TODO: revisit later to see if the edge case that "compiling using node v12 code to be run in node v16 in the server" is what we intend to support.
 const builtins$2 = new Set([
     ...require$$0$6.builtinModules,
@@ -2827,62 +2858,6 @@ function throttle(fn) {
     };
 }
 
-var charToInteger = {};
-var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$2 = 0; i$2 < chars$1.length; i$2++) {
-    charToInteger[chars$1.charCodeAt(i$2)] = i$2;
-}
-function encode(decoded) {
-    var sourceFileIndex = 0; // second field
-    var sourceCodeLine = 0; // third field
-    var sourceCodeColumn = 0; // fourth field
-    var nameIndex = 0; // fifth field
-    var mappings = '';
-    for (var i = 0; i < decoded.length; i++) {
-        var line = decoded[i];
-        if (i > 0)
-            mappings += ';';
-        if (line.length === 0)
-            continue;
-        var generatedCodeColumn = 0; // first field
-        var lineMappings = [];
-        for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
-            var segment = line_1[_i];
-            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
-            generatedCodeColumn = segment[0];
-            if (segment.length > 1) {
-                segmentMappings +=
-                    encodeInteger(segment[1] - sourceFileIndex) +
-                        encodeInteger(segment[2] - sourceCodeLine) +
-                        encodeInteger(segment[3] - sourceCodeColumn);
-                sourceFileIndex = segment[1];
-                sourceCodeLine = segment[2];
-                sourceCodeColumn = segment[3];
-            }
-            if (segment.length === 5) {
-                segmentMappings += encodeInteger(segment[4] - nameIndex);
-                nameIndex = segment[4];
-            }
-            lineMappings.push(segmentMappings);
-        }
-        mappings += lineMappings.join(',');
-    }
-    return mappings;
-}
-function encodeInteger(num) {
-    var result = '';
-    num = num < 0 ? (-num << 1) | 1 : num << 1;
-    do {
-        var clamped = num & 31;
-        num >>>= 5;
-        if (num > 0) {
-            clamped |= 32;
-        }
-        result += chars$1[clamped];
-    } while (num > 0);
-    return result;
-}
-
 var BitSet = function BitSet(arg) {
 	this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
 };
@@ -5363,7 +5338,7 @@ const toRegexRange = toRegexRange_1;
 
 const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
-const transform = toNumber => {
+const transform$1 = toNumber => {
   return value => toNumber === true ? Number(value) : String(value);
 };
 
@@ -5500,7 +5475,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
   let padded = zeros(startString) || zeros(endString) || zeros(stepString);
   let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
   let toNumber = padded === false && stringify$7(start, end, options) === false;
-  let format = options.transform || transform(toNumber);
+  let format = options.transform || transform$1(toNumber);
 
   if (options.toRegex && step === 1) {
     return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
@@ -5685,7 +5660,7 @@ const append$1 = (queue = '', stash = '', enclose = false) => {
   return utils$g.flatten(result);
 };
 
-const expand$3 = (ast, options = {}) => {
+const expand$4 = (ast, options = {}) => {
   let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
 
   let walk = (node, parent = {}) => {
@@ -5765,7 +5740,7 @@ const expand$3 = (ast, options = {}) => {
   return utils$g.flatten(walk(ast));
 };
 
-var expand_1 = expand$3;
+var expand_1$1 = expand$4;
 
 var constants$6 = {
   MAX_LENGTH: 1024 * 64,
@@ -6154,7 +6129,7 @@ var parse_1$2 = parse$m;
 
 const stringify$4 = stringify$8;
 const compile = compile_1;
-const expand$2 = expand_1;
+const expand$3 = expand_1$1;
 const parse$l = parse_1$2;
 
 /**
@@ -6274,7 +6249,7 @@ braces$2.expand = (input, options = {}) => {
     input = braces$2.parse(input, options);
   }
 
-  let result = expand$2(input, options);
+  let result = expand$3(input, options);
 
   // filter out empty strings if specified
   if (options.noempty === true) {
@@ -8850,10 +8825,10 @@ const micromatch = micromatch_1;
 const GLOBSTAR$2 = '**';
 const ESCAPE_SYMBOL = '\\';
 const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
-const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[.*]/;
-const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\(.*\|.*\)/;
-const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\(.*\)/;
-const BRACE_EXPANSIONS_SYMBOLS_RE = /{.*(?:,|\.\.).*}/;
+const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
 function isStaticPattern(pattern, options = {}) {
     return !isDynamicPattern(pattern, options);
 }
@@ -8880,12 +8855,24 @@ function isDynamicPattern(pattern, options = {}) {
     if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
         return true;
     }
-    if (options.braceExpansion !== false && BRACE_EXPANSIONS_SYMBOLS_RE.test(pattern)) {
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
         return true;
     }
     return false;
 }
 pattern$1.isDynamicPattern = isDynamicPattern;
+function hasBraceExpansion(pattern) {
+    const openingBraceIndex = pattern.indexOf('{');
+    if (openingBraceIndex === -1) {
+        return false;
+    }
+    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+        return false;
+    }
+    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+}
 function convertToPositivePattern(pattern) {
     return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
 }
@@ -9272,6 +9259,29 @@ function convertPatternGroupToTask(base, positive, negative, dynamic) {
 }
 tasks.convertPatternGroupToTask = convertPatternGroupToTask;
 
+var patterns = {};
+
+Object.defineProperty(patterns, "__esModule", { value: true });
+patterns.removeDuplicateSlashes = patterns.transform = void 0;
+/**
+ * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+ * The latter is due to the presence of the device path at the beginning of the UNC path.
+ * @todo rewrite to negative lookbehind with the next major release.
+ */
+const DOUBLE_SLASH_RE$1 = /(?!^)\/{2,}/g;
+function transform(patterns) {
+    return patterns.map((pattern) => removeDuplicateSlashes(pattern));
+}
+patterns.transform = transform;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE$1, '/');
+}
+patterns.removeDuplicateSlashes = removeDuplicateSlashes;
+
 var async$6 = {};
 
 var stream$2 = {};
@@ -9834,8 +9844,8 @@ function fastqueue (context, worker, concurrency) {
 
   var self = {
     push: push,
-    drain: noop$3,
-    saturated: noop$3,
+    drain: noop$2,
+    saturated: noop$2,
     pause: pause,
     paused: false,
     concurrency: concurrency,
@@ -9845,7 +9855,7 @@ function fastqueue (context, worker, concurrency) {
     length: length,
     getQueue: getQueue,
     unshift: unshift,
-    empty: noop$3,
+    empty: noop$2,
     kill: kill,
     killAndDrain: killAndDrain,
     error: error
@@ -9904,7 +9914,7 @@ function fastqueue (context, worker, concurrency) {
     current.context = context;
     current.release = release;
     current.value = value;
-    current.callback = done || noop$3;
+    current.callback = done || noop$2;
     current.errorHandler = errorHandler;
 
     if (_running === self.concurrency || self.paused) {
@@ -9928,7 +9938,7 @@ function fastqueue (context, worker, concurrency) {
     current.context = context;
     current.release = release;
     current.value = value;
-    current.callback = done || noop$3;
+    current.callback = done || noop$2;
 
     if (_running === self.concurrency || self.paused) {
       if (queueHead) {
@@ -9972,14 +9982,14 @@ function fastqueue (context, worker, concurrency) {
   function kill () {
     queueHead = null;
     queueTail = null;
-    self.drain = noop$3;
+    self.drain = noop$2;
   }
 
   function killAndDrain () {
     queueHead = null;
     queueTail = null;
     self.drain();
-    self.drain = noop$3;
+    self.drain = noop$2;
   }
 
   function error (handler) {
@@ -9987,13 +9997,13 @@ function fastqueue (context, worker, concurrency) {
   }
 }
 
-function noop$3 () {}
+function noop$2 () {}
 
 function Task () {
   this.value = null;
-  this.callback = noop$3;
+  this.callback = noop$2;
   this.next = null;
-  this.release = noop$3;
+  this.release = noop$2;
   this.context = null;
   this.errorHandler = null;
 
@@ -10004,7 +10014,7 @@ function Task () {
     var errorHandler = self.errorHandler;
     var val = self.value;
     self.value = null;
-    self.callback = noop$3;
+    self.callback = noop$2;
     if (self.errorHandler) {
       errorHandler(err, val);
     }
@@ -10052,7 +10062,7 @@ function queueAsPromised (context, worker, concurrency) {
     // Let's fork the promise chain to
     // make the error bubble up to the user but
     // not lead to a unhandledRejection
-    p.catch(noop$3);
+    p.catch(noop$2);
 
     return p
   }
@@ -10071,7 +10081,7 @@ function queueAsPromised (context, worker, concurrency) {
     // Let's fork the promise chain to
     // make the error bubble up to the user but
     // not lead to a unhandledRejection
-    p.catch(noop$3);
+    p.catch(noop$2);
 
     return p
   }
@@ -10740,9 +10750,13 @@ class EntryFilter {
         const fullpath = utils$3.path.makeAbsolute(this._settings.cwd, entryPath);
         return utils$3.pattern.matchAny(fullpath, patternsRe);
     }
+    /**
+     * First, just trying to apply patterns to the path.
+     * Second, trying to apply patterns to the path with final slash.
+     */
     _isMatchToPatterns(entryPath, patternsRe) {
         const filepath = utils$3.path.removeLeadingDotSegment(entryPath);
-        return utils$3.pattern.matchAny(filepath, patternsRe);
+        return utils$3.pattern.matchAny(filepath, patternsRe) || utils$3.pattern.matchAny(filepath + '/', patternsRe);
     }
 }
 entry$1.default = EntryFilter;
@@ -11033,6 +11047,7 @@ exports.default = Settings;
 }(settings));
 
 const taskManager = tasks;
+const patternManager = patterns;
 const async_1 = async$6;
 const stream_1 = stream;
 const sync_1 = sync$5;
@@ -11066,7 +11081,7 @@ async function FastGlob(source, options) {
     FastGlob.stream = stream;
     function generateTasks(source, options) {
         assertPatternsInput(source);
-        const patterns = [].concat(source);
+        const patterns = patternManager.transform([].concat(source));
         const settings = new settings_1.default(options);
         return taskManager.generate(patterns, settings);
     }
@@ -11084,7 +11099,7 @@ async function FastGlob(source, options) {
     FastGlob.escapePath = escapePath;
 })(FastGlob || (FastGlob = {}));
 function getWorks(source, _Provider, options) {
-    const patterns = [].concat(source);
+    const patterns = patternManager.transform([].concat(source));
     const settings = new settings_1.default(options);
     const tasks = taskManager.generate(patterns, settings);
     const provider = new _Provider(settings);
@@ -18857,7 +18872,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-4ef300ce.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-ae5bfd1c.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21280,7 +21295,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-2451c479.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-ba706304.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -21348,30 +21363,11 @@ function buildHtmlPlugin(config) {
         checkPublicFile(url, config);
     // Same reason with `htmlInlineProxyPlugin`
     isAsyncScriptMap.set(config, new Map());
-    const inputFiles = new Set();
     return {
         name: 'vite:build-html',
-        buildStart({ input }) {
-            isAsyncScriptMap.set(config, new Map());
-            let allInputs;
-            if (typeof input === 'string') {
-                allInputs = [input];
-            }
-            else if (Array.isArray(input)) {
-                allInputs = input;
-            }
-            else {
-                allInputs = Object.values(input);
-            }
-            for (const filename of allInputs) {
-                if (filename.endsWith('.html')) {
-                    inputFiles.add(normalizePath$4(filename));
-                }
-            }
-        },
         async transform(html, id) {
             var _a, _b;
-            if (inputFiles.has(id)) {
+            if (id.endsWith('.html')) {
                 const publicPath = `/${slash$1(path__default.relative(config.root, id))}`;
                 // pre-transform
                 html = await applyHtmlTransforms(html, preHooks, {
@@ -22018,14 +22014,13 @@ function stripBom(string) {
 }
 var POSIX_SEP_RE = new RegExp("\\" + path__default.posix.sep, "g");
 var NATIVE_SEP_RE = new RegExp("\\" + path__default.sep, "g");
-var PATTERN_REGEX_CACHE = new Map();
+var PATTERN_REGEX_CACHE = /* @__PURE__ */ new Map();
 var GLOB_ALL_PATTERN = `**/*`;
 var DEFAULT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
 var DEFAULT_EXTENSIONS_RE_GROUP = `\\.(?:${DEFAULT_EXTENSIONS.map((ext) => ext.substring(1)).join("|")})`;
 new Function("path", "return import(path).then(m => m.default)");
 async function resolveTSConfig(filename) {
-  const basename = path__default.basename(filename);
-  if (basename !== "tsconfig.json") {
+  if (path__default.extname(filename) !== ".json") {
     return;
   }
   const tsconfig = path__default.resolve(filename);
@@ -23687,7 +23682,7 @@ function expandTop(str) {
     str = '\\{\\}' + str.substr(2);
   }
 
-  return expand$1(escapeBraces(str), true).map(unescapeBraces);
+  return expand$2(escapeBraces(str), true).map(unescapeBraces);
 }
 
 function embrace(str) {
@@ -23704,7 +23699,7 @@ function gte(i, y) {
   return i >= y;
 }
 
-function expand$1(str, isTop) {
+function expand$2(str, isTop) {
   var expansions = [];
 
   var m = balanced('{', '}', str);
@@ -23718,7 +23713,7 @@ function expand$1(str, isTop) {
     // {a},b}
     if (m.post.match(/,.*\}/)) {
       str = m.pre + '{' + m.body + escClose + m.post;
-      return expand$1(str);
+      return expand$2(str);
     }
     return [str];
   }
@@ -23730,10 +23725,10 @@ function expand$1(str, isTop) {
     n = parseCommaParts(m.body);
     if (n.length === 1) {
       // x{{a,b}}y ==> x{a}y x{b}y
-      n = expand$1(n[0], false).map(embrace);
+      n = expand$2(n[0], false).map(embrace);
       if (n.length === 1) {
         var post = m.post.length
-          ? expand$1(m.post, false)
+          ? expand$2(m.post, false)
           : [''];
         return post.map(function(p) {
           return m.pre + n[0] + p;
@@ -23748,7 +23743,7 @@ function expand$1(str, isTop) {
   // no need to expand pre, since it is guaranteed to be free of brace-sets
   var pre = m.pre;
   var post = m.post.length
-    ? expand$1(m.post, false)
+    ? expand$2(m.post, false)
     : [''];
 
   var N;
@@ -23792,7 +23787,7 @@ function expand$1(str, isTop) {
       N.push(c);
     }
   } else {
-    N = concatMap(n, function(el) { return expand$1(el, false) });
+    N = concatMap(n, function(el) { return expand$2(el, false) });
   }
 
   for (var j = 0; j < N.length; j++) {
@@ -23815,7 +23810,7 @@ try {
 } catch (er) {}
 
 var GLOBSTAR$1 = minimatch$3.GLOBSTAR = Minimatch$1.GLOBSTAR = {};
-var expand = braceExpansion;
+var expand$1 = braceExpansion;
 
 var plTypes = {
   '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
@@ -24060,7 +24055,7 @@ function braceExpand (pattern, options) {
     return [pattern]
   }
 
-  return expand(pattern)
+  return expand$1(pattern)
 }
 
 // parse a component of the expanded set.
@@ -27681,7 +27676,7 @@ function getRequireStringArg(node) {
 function hasDynamicModuleForPath(source, id, dynamicRequireModuleSet) {
   if (!/^(?:\.{0,2}[/\\]|[A-Za-z]:[/\\])/.test(source)) {
     try {
-      const resolvedPath = normalizePathSlashes(resolve$3.sync(source, { basedir: path$r.dirname(id) }));
+      const resolvedPath = normalizePathSlashes(resolve$4.sync(source, { basedir: path$r.dirname(id) }));
       if (dynamicRequireModuleSet.has(resolvedPath)) {
         return true;
       }
@@ -43254,7 +43249,15 @@ async _handleSymlink(entry, directory, path, item) {
   if (!this.fsw.options.followSymlinks) {
     // watch symlink directly (don't follow) and detect changes
     this.fsw._incrReadyCount();
-    const linkPath = await fsrealpath(path);
+
+    let linkPath;
+    try {
+      linkPath = await fsrealpath(path);
+    } catch (e) {
+      this.fsw._emitReady();
+      return true;
+    }
+
     if (this.fsw.closed) return;
     if (dir.has(item)) {
       if (this.fsw._symlinkPaths.get(full) !== linkPath) {
@@ -45037,7 +45040,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await Promise.resolve().then(function () { return require('./dep-778bed46.js'); })).createCertificate();
+        const content = (await Promise.resolve().then(function () { return require('./dep-6c133e83.js'); })).createCertificate();
         fs$n.promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => fs$n.promises.writeFile(cachePath, content))
@@ -45577,7 +45580,7 @@ class PerMessageDeflate$4 {
   /**
    * Compress data. Concurrency limited.
    *
-   * @param {Buffer} data Data to compress
+   * @param {(Buffer|String)} data Data to compress
    * @param {Boolean} fin Specifies whether or not this is the last fragment
    * @param {Function} callback Callback
    * @public
@@ -45659,7 +45662,7 @@ class PerMessageDeflate$4 {
   /**
    * Compress data.
    *
-   * @param {Buffer} data Data to compress
+   * @param {(Buffer|String)} data Data to compress
    * @param {Boolean} fin Specifies whether or not this is the last fragment
    * @param {Function} callback Callback
    * @private
@@ -46524,6 +46527,7 @@ const { EMPTY_BUFFER: EMPTY_BUFFER$1 } = constants;
 const { isValidStatusCode } = validation.exports;
 const { mask: applyMask, toBuffer: toBuffer$2 } = bufferUtil$1.exports;
 
+const kByteLength = Symbol('kByteLength');
 const maskBuffer = Buffer.alloc(4);
 
 /**
@@ -46559,7 +46563,7 @@ class Sender$1 {
   /**
    * Frames a piece of data according to the HyBi WebSocket protocol.
    *
-   * @param {Buffer} data The data to frame
+   * @param {(Buffer|String)} data The data to frame
    * @param {Object} options Options object
    * @param {Boolean} [options.fin=false] Specifies whether or not to set the
    *     FIN bit
@@ -46574,7 +46578,7 @@ class Sender$1 {
    *     modified
    * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
    *     RSV1 bit
-   * @return {Buffer[]} The framed data as a list of `Buffer` instances
+   * @return {(Buffer|String)[]} The framed data
    * @public
    */
   static frame(data, options) {
@@ -46593,22 +46597,37 @@ class Sender$1 {
       }
 
       skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
-      if (options.readOnly && !skipMasking) merge = true;
-
       offset = 6;
     }
 
-    let payloadLength = data.length;
+    let dataLength;
 
-    if (data.length >= 65536) {
+    if (typeof data === 'string') {
+      if (
+        (!options.mask || skipMasking) &&
+        options[kByteLength] !== undefined
+      ) {
+        dataLength = options[kByteLength];
+      } else {
+        data = Buffer.from(data);
+        dataLength = data.length;
+      }
+    } else {
+      dataLength = data.length;
+      merge = options.mask && options.readOnly && !skipMasking;
+    }
+
+    let payloadLength = dataLength;
+
+    if (dataLength >= 65536) {
       offset += 8;
       payloadLength = 127;
-    } else if (data.length > 125) {
+    } else if (dataLength > 125) {
       offset += 2;
       payloadLength = 126;
     }
 
-    const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+    const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
 
     target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
     if (options.rsv1) target[0] |= 0x40;
@@ -46616,10 +46635,10 @@ class Sender$1 {
     target[1] = payloadLength;
 
     if (payloadLength === 126) {
-      target.writeUInt16BE(data.length, 2);
+      target.writeUInt16BE(dataLength, 2);
     } else if (payloadLength === 127) {
       target[2] = target[3] = 0;
-      target.writeUIntBE(data.length, 4, 6);
+      target.writeUIntBE(dataLength, 4, 6);
     }
 
     if (!options.mask) return [target, data];
@@ -46633,11 +46652,11 @@ class Sender$1 {
     if (skipMasking) return [target, data];
 
     if (merge) {
-      applyMask(data, mask, target, offset, data.length);
+      applyMask(data, mask, target, offset, dataLength);
       return [target];
     }
 
-    applyMask(data, mask, data, 0, data.length);
+    applyMask(data, mask, data, 0, dataLength);
     return [target, data];
   }
 
@@ -46677,36 +46696,24 @@ class Sender$1 {
       }
     }
 
+    const options = {
+      [kByteLength]: buf.length,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x08,
+      readOnly: false,
+      rsv1: false
+    };
+
     if (this._deflating) {
-      this.enqueue([this.doClose, buf, mask, cb]);
+      this.enqueue([this.dispatch, buf, false, options, cb]);
     } else {
-      this.doClose(buf, mask, cb);
+      this.sendFrame(Sender$1.frame(buf, options), cb);
     }
   }
 
-  /**
-   * Frames and sends a close message.
-   *
-   * @param {Buffer} data The message to send
-   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-   * @param {Function} [cb] Callback
-   * @private
-   */
-  doClose(data, mask, cb) {
-    this.sendFrame(
-      Sender$1.frame(data, {
-        fin: true,
-        rsv1: false,
-        opcode: 0x08,
-        mask,
-        maskBuffer: this._maskBuffer,
-        generateMask: this._generateMask,
-        readOnly: false
-      }),
-      cb
-    );
-  }
-
   /**
    * Sends a ping message to the other peer.
    *
@@ -46716,43 +46723,40 @@ class Sender$1 {
    * @public
    */
   ping(data, mask, cb) {
-    const buf = toBuffer$2(data);
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else {
+      data = toBuffer$2(data);
+      byteLength = data.length;
+      readOnly = toBuffer$2.readOnly;
+    }
 
-    if (buf.length > 125) {
+    if (byteLength > 125) {
       throw new RangeError('The data size must not be greater than 125 bytes');
     }
 
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x09,
+      readOnly,
+      rsv1: false
+    };
+
     if (this._deflating) {
-      this.enqueue([this.doPing, buf, mask, toBuffer$2.readOnly, cb]);
+      this.enqueue([this.dispatch, data, false, options, cb]);
     } else {
-      this.doPing(buf, mask, toBuffer$2.readOnly, cb);
+      this.sendFrame(Sender$1.frame(data, options), cb);
     }
   }
 
-  /**
-   * Frames and sends a ping message.
-   *
-   * @param {Buffer} data The message to send
-   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-   * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
-   * @param {Function} [cb] Callback
-   * @private
-   */
-  doPing(data, mask, readOnly, cb) {
-    this.sendFrame(
-      Sender$1.frame(data, {
-        fin: true,
-        rsv1: false,
-        opcode: 0x09,
-        mask,
-        maskBuffer: this._maskBuffer,
-        generateMask: this._generateMask,
-        readOnly
-      }),
-      cb
-    );
-  }
-
   /**
    * Sends a pong message to the other peer.
    *
@@ -46762,43 +46766,40 @@ class Sender$1 {
    * @public
    */
   pong(data, mask, cb) {
-    const buf = toBuffer$2(data);
+    let byteLength;
+    let readOnly;
 
-    if (buf.length > 125) {
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else {
+      data = toBuffer$2(data);
+      byteLength = data.length;
+      readOnly = toBuffer$2.readOnly;
+    }
+
+    if (byteLength > 125) {
       throw new RangeError('The data size must not be greater than 125 bytes');
     }
 
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x0a,
+      readOnly,
+      rsv1: false
+    };
+
     if (this._deflating) {
-      this.enqueue([this.doPong, buf, mask, toBuffer$2.readOnly, cb]);
+      this.enqueue([this.dispatch, data, false, options, cb]);
     } else {
-      this.doPong(buf, mask, toBuffer$2.readOnly, cb);
+      this.sendFrame(Sender$1.frame(data, options), cb);
     }
   }
 
-  /**
-   * Frames and sends a pong message.
-   *
-   * @param {Buffer} data The message to send
-   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-   * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
-   * @param {Function} [cb] Callback
-   * @private
-   */
-  doPong(data, mask, readOnly, cb) {
-    this.sendFrame(
-      Sender$1.frame(data, {
-        fin: true,
-        rsv1: false,
-        opcode: 0x0a,
-        mask,
-        maskBuffer: this._maskBuffer,
-        generateMask: this._generateMask,
-        readOnly
-      }),
-      cb
-    );
-  }
-
   /**
    * Sends a data message to the other peer.
    *
@@ -46816,11 +46817,22 @@ class Sender$1 {
    * @public
    */
   send(data, options, cb) {
-    const buf = toBuffer$2(data);
     const perMessageDeflate = this._extensions[PerMessageDeflate$2.extensionName];
     let opcode = options.binary ? 2 : 1;
     let rsv1 = options.compress;
 
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else {
+      data = toBuffer$2(data);
+      byteLength = data.length;
+      readOnly = toBuffer$2.readOnly;
+    }
+
     if (this._firstFragment) {
       this._firstFragment = false;
       if (
@@ -46832,7 +46844,7 @@ class Sender$1 {
             : 'client_no_context_takeover'
         ]
       ) {
-        rsv1 = buf.length >= perMessageDeflate._threshold;
+        rsv1 = byteLength >= perMessageDeflate._threshold;
       }
       this._compress = rsv1;
     } else {
@@ -46844,30 +46856,32 @@ class Sender$1 {
 
     if (perMessageDeflate) {
       const opts = {
+        [kByteLength]: byteLength,
         fin: options.fin,
-        rsv1,
-        opcode,
+        generateMask: this._generateMask,
         mask: options.mask,
         maskBuffer: this._maskBuffer,
-        generateMask: this._generateMask,
-        readOnly: toBuffer$2.readOnly
+        opcode,
+        readOnly,
+        rsv1
       };
 
       if (this._deflating) {
-        this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+        this.enqueue([this.dispatch, data, this._compress, opts, cb]);
       } else {
-        this.dispatch(buf, this._compress, opts, cb);
+        this.dispatch(data, this._compress, opts, cb);
       }
     } else {
       this.sendFrame(
-        Sender$1.frame(buf, {
+        Sender$1.frame(data, {
+          [kByteLength]: byteLength,
           fin: options.fin,
-          rsv1: false,
-          opcode,
+          generateMask: this._generateMask,
           mask: options.mask,
           maskBuffer: this._maskBuffer,
-          generateMask: this._generateMask,
-          readOnly: toBuffer$2.readOnly
+          opcode,
+          readOnly,
+          rsv1: false
         }),
         cb
       );
@@ -46875,13 +46889,12 @@ class Sender$1 {
   }
 
   /**
-   * Dispatches a data message.
+   * Dispatches a message.
    *
-   * @param {Buffer} data The message to send
+   * @param {(Buffer|String)} data The message to send
    * @param {Boolean} [compress=false] Specifies whether or not to compress
    *     `data`
    * @param {Object} options Options object
-   * @param {Number} options.opcode The opcode
    * @param {Boolean} [options.fin=false] Specifies whether or not to set the
    *     FIN bit
    * @param {Function} [options.generateMask] The function used to generate the
@@ -46890,6 +46903,7 @@ class Sender$1 {
    *     `data`
    * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
    *     key
+   * @param {Number} options.opcode The opcode
    * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
    *     modified
    * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
@@ -46905,7 +46919,7 @@ class Sender$1 {
 
     const perMessageDeflate = this._extensions[PerMessageDeflate$2.extensionName];
 
-    this._bufferedBytes += data.length;
+    this._bufferedBytes += options[kByteLength];
     this._deflating = true;
     perMessageDeflate.compress(data, options.fin, (_, buf) => {
       if (this._socket.destroyed) {
@@ -46916,7 +46930,8 @@ class Sender$1 {
         if (typeof cb === 'function') cb(err);
 
         for (let i = 0; i < this._queue.length; i++) {
-          const callback = this._queue[i][4];
+          const params = this._queue[i];
+          const callback = params[params.length - 1];
 
           if (typeof callback === 'function') callback(err);
         }
@@ -46924,7 +46939,7 @@ class Sender$1 {
         return;
       }
 
-      this._bufferedBytes -= data.length;
+      this._bufferedBytes -= options[kByteLength];
       this._deflating = false;
       options.readOnly = false;
       this.sendFrame(Sender$1.frame(buf, options), cb);
@@ -46941,7 +46956,7 @@ class Sender$1 {
     while (!this._deflating && this._queue.length) {
       const params = this._queue.shift();
 
-      this._bufferedBytes -= params[1].length;
+      this._bufferedBytes -= params[3][kByteLength];
       Reflect.apply(params[0], this, params.slice(1));
     }
   }
@@ -46953,7 +46968,7 @@ class Sender$1 {
    * @private
    */
   enqueue(params) {
-    this._bufferedBytes += params[1].length;
+    this._bufferedBytes += params[3][kByteLength];
     this._queue.push(params);
   }
 
@@ -47453,7 +47468,7 @@ const http$3 = require$$1__default$2;
 const net = require$$3__default;
 const tls = require$$4__default;
 const { randomBytes, createHash: createHash$1 } = require$$1__default$3;
-const { URL: URL$2 } = require$$0__default$5;
+const { URL: URL$1 } = require$$0__default$5;
 
 const PerMessageDeflate$1 = permessageDeflate;
 const Receiver = receiver;
@@ -48106,12 +48121,12 @@ function initAsClient(websocket, address, protocols, options) {
 
   let parsedUrl;
 
-  if (address instanceof URL$2) {
+  if (address instanceof URL$1) {
     parsedUrl = address;
     websocket._url = address.href;
   } else {
     try {
-      parsedUrl = new URL$2(address);
+      parsedUrl = new URL$1(address);
     } catch (e) {
       throw new SyntaxError(`Invalid URL: ${address}`);
     }
@@ -48245,7 +48260,7 @@ function initAsClient(websocket, address, protocols, options) {
       let addr;
 
       try {
-        addr = new URL$2(location, address);
+        addr = new URL$1(location, address);
       } catch (e) {
         const err = new SyntaxError(`Invalid URL: ${location}`);
         emitErrorAndClose(websocket, err);
@@ -50155,7 +50170,7 @@ var debug_1 = function () {
 };
 
 var url$1 = require$$0__default$5;
-var URL$1 = url$1.URL;
+var URL = url$1.URL;
 var http$1 = require$$1__default$2;
 var https$1 = require$$1__default$4;
 var Writable = require$$0__default$2.Writable;
@@ -50606,14 +50621,14 @@ function wrap(protocols) {
       if (typeof input === "string") {
         var urlStr = input;
         try {
-          input = urlToOptions(new URL$1(urlStr));
+          input = urlToOptions(new URL(urlStr));
         }
         catch (err) {
           /* istanbul ignore next */
           input = url$1.parse(urlStr);
         }
       }
-      else if (URL$1 && (input instanceof URL$1)) {
+      else if (URL && (input instanceof URL)) {
         input = urlToOptions(input);
       }
       else {
@@ -50655,7 +50670,7 @@ function wrap(protocols) {
 }
 
 /* istanbul ignore next */
-function noop$2() { /* empty */ }
+function noop$1() { /* empty */ }
 
 // from https://github.com/nodejs/node/blob/master/lib/internal/url.js
 function urlToOptions(urlObject) {
@@ -50711,7 +50726,7 @@ function abortRequest(request) {
   for (var e = 0; e < events.length; e++) {
     request.removeListener(events[e], eventHandlers[events[e]]);
   }
-  request.on("error", noop$2);
+  request.on("error", noop$1);
   request.abort();
 }
 
@@ -52508,7 +52523,7 @@ function parse$5(req) {
 	return req._parsedUrl = { pathname, search, query, raw };
 }
 
-const noop$1 = () => {};
+const noop = () => {};
 
 function isMatch(uri, arr) {
 	for (let i=0; i < arr.length; i++) {
@@ -52619,7 +52634,7 @@ function sirv (dir, opts={}) {
 	dir = path$r.resolve(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
-	let setHeaders = opts.setHeaders || noop$1;
+	let setHeaders = opts.setHeaders || noop;
 
 	let extensions = opts.extensions || ['html', 'htm'];
 	let gzips = opts.gzip && extensions.map(x => `${x}.gz`).concat('gz');
@@ -55690,7 +55705,7 @@ ssr) {
         for (const id of include) {
             // normalize 'foo   >bar` as 'foo > bar' to prevent same id being added
             // and for pretty printing
-            const normalizedId = normalizeId$1(id);
+            const normalizedId = normalizeId(id);
             if (!deps[normalizedId]) {
                 const entry = await resolve(id);
                 if (entry) {
@@ -69474,7 +69489,6 @@ async function preview(inlineConfig) {
     };
 }
 
-const noop = () => null;
 function matches(pattern, importee) {
     if (pattern instanceof RegExp) {
         return pattern.test(importee);
@@ -69485,36 +69499,35 @@ function matches(pattern, importee) {
     if (importee === pattern) {
         return true;
     }
-    const importeeStartsWithKey = importee.indexOf(pattern) === 0;
-    const importeeHasSlashAfterKey = importee.substring(pattern.length)[0] === '/';
-    return importeeStartsWithKey && importeeHasSlashAfterKey;
+    // eslint-disable-next-line prefer-template
+    return importee.startsWith(pattern + '/');
 }
-function normalizeId(id) {
-    return id;
-}
-function getEntries({ entries }) {
+function getEntries({ entries, customResolver }) {
     if (!entries) {
         return [];
     }
+    const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
     if (Array.isArray(entries)) {
-        return entries;
+        return entries.map((entry) => {
+            return {
+                find: entry.find,
+                replacement: entry.replacement,
+                resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+            };
+        });
     }
     return Object.entries(entries).map(([key, value]) => {
-        return { find: key, replacement: value };
+        return { find: key, replacement: value, resolverFunction: resolverFunctionFromOptions };
     });
 }
-function getCustomResolver({ customResolver }, options) {
-    if (typeof customResolver === 'function') {
-        return customResolver;
-    }
-    if (customResolver && typeof customResolver.resolveId === 'function') {
-        return customResolver.resolveId;
-    }
-    if (typeof options.customResolver === 'function') {
-        return options.customResolver;
-    }
-    if (options.customResolver && typeof options.customResolver.resolveId === 'function') {
-        return options.customResolver.resolveId;
+function resolveCustomResolver(customResolver) {
+    if (customResolver) {
+        if (typeof customResolver === 'function') {
+            return customResolver;
+        }
+        if (typeof customResolver.resolveId === 'function') {
+            return customResolver.resolveId;
+        }
     }
     return null;
 }
@@ -69523,39 +69536,31 @@ function alias(options = {}) {
     if (entries.length === 0) {
         return {
             name: 'alias',
-            resolveId: noop
+            resolveId: () => null
         };
     }
     return {
         name: 'alias',
-        buildStart(inputOptions) {
-            return Promise.all([...entries, options].map(({ customResolver }) => customResolver &&
+        async buildStart(inputOptions) {
+            await Promise.all([...(Array.isArray(options.entries) ? options.entries : []), options].map(({ customResolver }) => customResolver &&
                 typeof customResolver === 'object' &&
                 typeof customResolver.buildStart === 'function' &&
-                customResolver.buildStart.call(this, inputOptions))).then(() => {
-                // enforce void return value
-            });
+                customResolver.buildStart.call(this, inputOptions)));
         },
         resolveId(importee, importer, resolveOptions) {
-            const importeeId = normalizeId(importee);
-            const importerId = normalizeId(importer);
+            if (!importer) {
+                return null;
+            }
             // First match is supposed to be the correct one
-            const matchedEntry = entries.find((entry) => matches(entry.find, importeeId));
-            if (!matchedEntry || !importerId) {
+            const matchedEntry = entries.find((entry) => matches(entry.find, importee));
+            if (!matchedEntry) {
                 return null;
             }
-            const updatedId = normalizeId(importeeId.replace(matchedEntry.find, matchedEntry.replacement));
-            const customResolver = getCustomResolver(matchedEntry, options);
-            if (customResolver) {
-                return customResolver.call(this, updatedId, importerId, resolveOptions);
+            const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+            if (matchedEntry.resolverFunction) {
+                return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
             }
-            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => {
-                let finalResult = resolved;
-                if (!finalResult) {
-                    finalResult = { id: updatedId };
-                }
-                return finalResult;
-            });
+            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => resolved || { id: updatedId });
         }
     };
 }
@@ -70559,7 +70564,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
     ].filter(Boolean);
 }
 
-var main$1 = {exports: {}};
+var main = {exports: {}};
 
 const fs = fs__default;
 const path = path__default;
@@ -70700,56 +70705,70 @@ const DotenvModule = {
   parse
 };
 
-main$1.exports.config = DotenvModule.config;
-main$1.exports.parse = DotenvModule.parse;
-main$1.exports = DotenvModule;
+main.exports.config = DotenvModule.config;
+main.exports.parse = DotenvModule.parse;
+main.exports = DotenvModule;
 
-var dotenv = main$1.exports;
+var dotenv = main.exports;
 
-var dotenvExpand = function (config) {
-  // if ignoring process.env, use a blank object
-  var environment = config.ignoreProcessEnv ? {} : process.env;
-
-  var interpolate = function (envValue) {
-    var matches = envValue.match(/(.?\${?(?:[a-zA-Z0-9_]+)?}?)/g) || [];
+function _interpolate (envValue, environment, config) {
+  const matches = envValue.match(/(.?\${*[\w]*(?::-)?[\w]*}*)/g) || [];
 
-    return matches.reduce(function (newEnv, match) {
-      var parts = /(.?)\${?([a-zA-Z0-9_]+)?}?/g.exec(match);
-      var prefix = parts[1];
+  return matches.reduce(function (newEnv, match, index) {
+    const parts = /(.?)\${*([\w]*(?::-)?[\w]*)?}*/g.exec(match);
+    if (!parts || parts.length === 0) {
+      return newEnv
+    }
 
-      var value, replacePart;
+    const prefix = parts[1];
 
-      if (prefix === '\\') {
-        replacePart = parts[0];
-        value = replacePart.replace('\\$', '$');
-      } else {
-        var key = parts[2];
-        replacePart = parts[0].substring(prefix.length);
-        // process.env value 'wins' over .env file's value
-        value = environment.hasOwnProperty(key) ? environment[key] : (config.parsed[key] || '');
+    let value, replacePart;
 
-        // Resolve recursive interpolations
-        value = interpolate(value);
+    if (prefix === '\\') {
+      replacePart = parts[0];
+      value = replacePart.replace('\\$', '$');
+    } else {
+      const keyParts = parts[2].split(':-');
+      const key = keyParts[0];
+      replacePart = parts[0].substring(prefix.length);
+      // process.env value 'wins' over .env file's value
+      value = Object.prototype.hasOwnProperty.call(environment, key)
+        ? environment[key]
+        : (config.parsed[key] || keyParts[1] || '');
+
+      // If the value is found, remove nested expansions.
+      if (keyParts.length > 1 && value) {
+        const replaceNested = matches[index + 1];
+        matches[index + 1] = '';
+
+        newEnv = newEnv.replace(replaceNested, '');
       }
+      // Resolve recursive interpolations
+      value = _interpolate(value, environment, config);
+    }
 
-      return newEnv.replace(replacePart, value)
-    }, envValue)
-  };
+    return newEnv.replace(replacePart, value)
+  }, envValue)
+}
 
-  for (var configKey in config.parsed) {
-    var value = environment.hasOwnProperty(configKey) ? environment[configKey] : config.parsed[configKey];
+function expand (config) {
+  // if ignoring process.env, use a blank object
+  const environment = config.ignoreProcessEnv ? {} : process.env;
+
+  for (const configKey in config.parsed) {
+    const value = Object.prototype.hasOwnProperty.call(environment, configKey) ? environment[configKey] : config.parsed[configKey];
 
-    config.parsed[configKey] = interpolate(value);
+    config.parsed[configKey] = _interpolate(value, environment, config);
   }
 
-  for (var processKey in config.parsed) {
+  for (const processKey in config.parsed) {
     environment[processKey] = config.parsed[processKey];
   }
 
   return config
-};
+}
 
-var main = dotenvExpand;
+var expand_1 = expand;
 
 const debug = createDebugger('vite:config');
 /**
@@ -71363,7 +71382,7 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
                 debug: ((_a = process.env.DEBUG) === null || _a === void 0 ? void 0 : _a.includes('vite:dotenv')) || undefined
             });
             // let environment variables use each other
-            main({
+            expand_1({
                 parsed,
                 // prevent process.env mutation
                 ignoreProcessEnv: true