vite 5.2.7 → 5.2.9

package/dist/node/chunks/{dep-C-KAszbv.js → dep-_QLjGPdL.js}

@@ -7559,21 +7559,29 @@ class MagicString {
 		if (searchValue.global) {
 			const matches = matchAll(searchValue, this.original);
 			matches.forEach((match) => {
-				if (match.index != null)
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(
+							match.index,
+							match.index + match[0].length,
+							replacement
+						);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
 					this.overwrite(
 						match.index,
 						match.index + match[0].length,
-						getReplacement(match, this.original),
+						replacement
 					);
-			});
-		} else {
-			const match = this.original.match(searchValue);
-			if (match && match.index != null)
-				this.overwrite(
-					match.index,
-					match.index + match[0].length,
-					getReplacement(match, this.original),
-				);
+				}
+			}
 		}
 		return this;
 	}
@@ -7605,7 +7613,9 @@ class MagicString {
 			index !== -1;
 			index = original.indexOf(string, index + stringLength)
 		) {
-			this.overwrite(index, index + stringLength, replacement);
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement)
+				this.overwrite(index, index + stringLength, replacement);
 		}
 
 		return this;
@@ -9998,7 +10008,7 @@ function makeUrl(scheme, user, host, port, path, query, hash) {
         type: 7 /* Absolute */,
     };
 }
-function parseUrl$2(input) {
+function parseUrl$3(input) {
     if (isSchemeRelativeUrl(input)) {
         const url = parseAbsoluteUrl('http:' + input);
         url.scheme = '';
@@ -10112,10 +10122,10 @@ function normalizePath$4(url, type) {
 function resolve$2(input, base) {
     if (!input && !base)
         return '';
-    const url = parseUrl$2(input);
+    const url = parseUrl$3(input);
     let inputType = url.type;
     if (base && inputType !== 7 /* Absolute */) {
-        const baseUrl = parseUrl$2(base);
+        const baseUrl = parseUrl$3(base);
         const baseType = baseUrl.type;
         switch (inputType) {
             case 1 /* Empty */:
@@ -10354,6 +10364,14 @@ class TraceMap {
 function cast$2(map) {
     return map;
 }
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+function encodedMappings(map) {
+    var _a;
+    var _b;
+    return ((_a = (_b = cast$2(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = encode$1(cast$2(map)._decoded)));
+}
 /**
  * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
  */
@@ -10402,6 +10420,32 @@ function originalPositionFor$1(map, needle) {
     const { names, resolvedSources } = map;
     return OMapping(resolvedSources[segment[SOURCES_INDEX$1]], segment[SOURCE_LINE$1] + 1, segment[SOURCE_COLUMN$1], segment.length === 5 ? names[segment[NAMES_INDEX$1]] : null);
 }
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function decodedMap(map) {
+    return clone(map, decodedMappings(map));
+}
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function encodedMap(map) {
+    return clone(map, encodedMappings(map));
+}
+function clone(map, mappings) {
+    return {
+        version: map.version,
+        file: map.file,
+        names: map.names,
+        sourceRoot: map.sourceRoot,
+        sources: map.sources,
+        sourcesContent: map.sourcesContent,
+        mappings,
+        ignoreList: map.ignoreList || map.x_google_ignoreList,
+    };
+}
 function OMapping(source, line, column, name) {
     return { source, line, column, name };
 }
@@ -19258,10 +19302,10 @@ var string$2 = {};
 
 Object.defineProperty(string$2, "__esModule", { value: true });
 string$2.isEmpty = string$2.isString = void 0;
-function isString(input) {
+function isString$1(input) {
     return typeof input === 'string';
 }
-string$2.isString = isString;
+string$2.isString = isString$1;
 function isEmpty$1(input) {
     return input === '';
 }
@@ -29291,7 +29335,7 @@ var postcssrc = /*@__PURE__*/getDefaultExportFromCjs(src$1);
 
 // Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
 // License: MIT.
-var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
 RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]|[^\/\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
 Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
 Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
@@ -29302,6 +29346,7 @@ WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu;
 LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
 MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
 SingleLineComment = /\/\/.*/y;
+HashbangComment = /^#!.*/;
 JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
 JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu;
 JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
@@ -29322,6 +29367,13 @@ var jsTokens_1 = function*(input, {jsx = false} = {}) {
 	braces = [];
 	parenNesting = 0;
 	postfixIncDec = false;
+	if (match = HashbangComment.exec(input)) {
+		yield ({
+			type: "HashbangComment",
+			value: match[0]
+		});
+		lastIndex = match[0].length;
+	}
 	while (lastIndex < length) {
 		mode = stack[stack.length - 1];
 		switch (mode.tag) {
@@ -29697,6 +29749,10 @@ function stripLiteralJsTokens(code, options) {
       continue;
     }
     if (token.type === "StringLiteral") {
+      if (!token.closed) {
+        result += token.value;
+        continue;
+      }
       const body = token.value.slice(1, -1);
       if (filter(body)) {
         result += token.value[0] + FILL.repeat(body.length) + token.value[token.value.length - 1];
@@ -31185,7 +31241,10 @@ function injectNonceAttributeTagHook(config) {
                 (node.nodeName === 'link' &&
                     node.attrs.some((attr) => attr.name === 'rel' &&
                         parseRelAttr(attr.value).some((a) => processRelType.has(a))))) {
-                s.appendRight(node.sourceCodeLocation.startTag.endOffset - 1, ` nonce="${nonce}"`);
+                // if the closing of the start tag includes a `/`, the offset should be 2 so the nonce
+                // is appended prior to the `/`
+                const appendOffset = html[node.sourceCodeLocation.startTag.endOffset - 2] === '/' ? 2 : 1;
+                s.appendRight(node.sourceCodeLocation.startTag.endOffset - appendOffset, ` nonce="${nonce}"`);
             }
         });
         return s.toString();
@@ -31873,6 +31932,7 @@ function cssPostPlugin(config) {
                 for (const file in bundle) {
                     const chunk = bundle[file];
                     if (chunk.type === 'chunk') {
+                        let chunkImportsPureCssChunk = false;
                         // remove pure css chunk from other chunk's imports,
                         // and also register the emitted CSS files under the importer
                         // chunks instead.
@@ -31881,11 +31941,14 @@ function cssPostPlugin(config) {
                                 const { importedCss, importedAssets } = bundle[file].viteMetadata;
                                 importedCss.forEach((file) => chunk.viteMetadata.importedCss.add(file));
                                 importedAssets.forEach((file) => chunk.viteMetadata.importedAssets.add(file));
+                                chunkImportsPureCssChunk = true;
                                 return false;
                             }
                             return true;
                         });
-                        chunk.code = replaceEmptyChunk(chunk.code);
+                        if (chunkImportsPureCssChunk) {
+                            chunk.code = replaceEmptyChunk(chunk.code);
+                        }
                     }
                 }
                 const removedPureCssFiles = removedPureCssFilesCache.get(config);
@@ -32293,8 +32356,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-C1QONNHf.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-ThQVBShq.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-DHU7GEFN.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-DbzVZKyq.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -33190,12 +33253,13 @@ async function compileLightningCSS(id, src, config, urlReplacer) {
         switch (dep.type) {
             case 'url':
                 if (skipUrlReplacer(dep.url)) {
-                    css = css.replace(dep.placeholder, dep.url);
+                    css = css.replace(dep.placeholder, () => dep.url);
                     break;
                 }
                 deps.add(dep.url);
                 if (urlReplacer) {
-                    css = css.replace(dep.placeholder, await urlReplacer(dep.url, id));
+                    const replaceUrl = await urlReplacer(dep.url, id);
+                    css = css.replace(dep.placeholder, () => replaceUrl);
                 }
                 break;
             default:
@@ -42286,7 +42350,7 @@ var debug$e = srcExports('finalhandler');
 var encodeUrl = encodeurl;
 var escapeHtml = escapeHtml_1;
 var onFinished = onFinishedExports;
-var parseUrl$1 = parseurlExports;
+var parseUrl$2 = parseurlExports;
 var statuses = statuses$1;
 var unpipe = unpipe_1;
 
@@ -42490,7 +42554,7 @@ function getErrorStatusCode (err) {
 
 function getResourceName (req) {
   try {
-    return parseUrl$1.original(req).pathname
+    return parseUrl$2.original(req).pathname
   } catch (e) {
     return 'resource'
   }
@@ -42649,7 +42713,7 @@ var EventEmitter$3 = require$$0$5.EventEmitter;
 var finalhandler = finalhandler_1;
 var http$4 = require$$1;
 var merge = utilsMergeExports;
-var parseUrl = parseurlExports;
+var parseUrl$1 = parseurlExports;
 
 /**
  * Module exports.
@@ -42784,7 +42848,7 @@ proto.handle = function handle(req, res, out) {
     }
 
     // route data
-    var path = parseUrl(req).pathname || '/';
+    var path = parseUrl$1(req).pathname || '/';
     var route = layer.route;
 
     // skip this layer if the route doesn't match
@@ -49063,6 +49127,23 @@ async function replaceDefine(code, id, define, config) {
         sourcefile: id,
         sourcemap: config.command === 'build' ? !!config.build.sourcemap : true,
     });
+    // remove esbuild's <define:...> source entries
+    // since they would confuse source map remapping/collapsing which expects a single source
+    if (result.map.includes('<define:')) {
+        const originalMap = new TraceMap(result.map);
+        if (originalMap.sources.length >= 2) {
+            const sourceIndex = originalMap.sources.indexOf(id);
+            const decoded = decodedMap(originalMap);
+            decoded.sources = [id];
+            decoded.mappings = decoded.mappings.map((segments) => segments.filter((segment) => {
+                // modify and filter
+                const index = segment[1];
+                segment[1] = 0;
+                return index === sourceIndex;
+            }));
+            result.map = JSON.stringify(encodedMap(new TraceMap(decoded)));
+        }
+    }
     for (const marker in replacementMarkers) {
         result.code = result.code.replaceAll(marker, replacementMarkers[marker]);
     }
@@ -51428,12 +51509,10 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                 // Avoid matching the content of the comment
                 raw = raw.replace(commentRE, '<!---->');
                 const isHtml = p.endsWith('.html');
-                scriptRE.lastIndex = 0;
                 let js = '';
                 let scriptId = 0;
-                let match;
-                while ((match = scriptRE.exec(raw))) {
-                    const [, openTag, content] = match;
+                const matches = raw.matchAll(scriptRE);
+                for (const [, openTag, content] of matches) {
                     const typeMatch = openTag.match(typeRE);
                     const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
                     const langMatch = openTag.match(langRE);
@@ -52565,9 +52644,13 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr) {
             // No need to wait, we can clean up in the background because temp folders
             // are unique per run
             debug$7?.(colors$1.green(`removing cache dir ${processingCacheDir}`));
-            fsp.rm(processingCacheDir, { recursive: true, force: true }).catch(() => {
+            try {
+                // When exiting the process, `fsp.rm` may not take effect, so we use `fs.rmSync`
+                fs$l.rmSync(processingCacheDir, { recursive: true, force: true });
+            }
+            catch (error) {
                 // Ignore errors
-            });
+            }
         }
     };
     const successfulResult = {
@@ -54644,7 +54727,7 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                     identifiers.push([node, parentStack.slice(0)]);
                 }
             }
-            else if (isFunction(node)) {
+            else if (isFunction$1(node)) {
                 // If it is a function declaration, it could be shadowing an import
                 // Add its name to the scope so it won't get replaced
                 if (node.type === 'FunctionDeclaration') {
@@ -54724,7 +54807,7 @@ function isRefIdentifier(id, parent, parentStack) {
             parent.id === id)) {
         return false;
     }
-    if (isFunction(parent)) {
+    if (isFunction$1(parent)) {
         // function declaration/expression id
         if (parent.id === id) {
             return false;
@@ -54769,7 +54852,7 @@ function isRefIdentifier(id, parent, parentStack) {
 const isStaticProperty = (node) => node && node.type === 'Property' && !node.computed;
 const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
 const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/;
-function isFunction(node) {
+function isFunction$1(node) {
     return functionNodeTypeRE.test(node.type);
 }
 const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/;
@@ -54777,7 +54860,7 @@ function isBlock(node) {
     return blockNodeTypeRE.test(node.type);
 }
 function findParentScope(parentStack, isVar = false) {
-    return parentStack.find(isVar ? isFunction : isBlock);
+    return parentStack.find(isVar ? isFunction$1 : isBlock);
 }
 function isInDestructuringAssignment(parent, parentStack) {
     if (parent &&
@@ -62050,6 +62133,30 @@ var Writable = require$$0$7.Writable;
 var assert = require$$5;
 var debug$5 = debug_1;
 
+// Whether to use the native URL object or the legacy url module
+var useNativeURL = false;
+try {
+  assert(new URL$1());
+}
+catch (error) {
+  useNativeURL = error.code === "ERR_INVALID_URL";
+}
+
+// URL fields to preserve in copy operations
+var preservedUrlFields = [
+  "auth",
+  "host",
+  "hostname",
+  "href",
+  "path",
+  "pathname",
+  "port",
+  "protocol",
+  "query",
+  "search",
+  "hash",
+];
+
 // Create handlers that pass events from native requests
 var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
 var eventHandlers = Object.create(null);
@@ -62060,13 +62167,19 @@ events.forEach(function (event) {
 });
 
 // Error types with codes
+var InvalidUrlError = createErrorType(
+  "ERR_INVALID_URL",
+  "Invalid URL",
+  TypeError
+);
 var RedirectionError = createErrorType(
   "ERR_FR_REDIRECTION_FAILURE",
   "Redirected request failed"
 );
 var TooManyRedirectsError = createErrorType(
   "ERR_FR_TOO_MANY_REDIRECTS",
-  "Maximum number of redirects exceeded"
+  "Maximum number of redirects exceeded",
+  RedirectionError
 );
 var MaxBodyLengthExceededError = createErrorType(
   "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
@@ -62077,6 +62190,9 @@ var WriteAfterEndError = createErrorType(
   "write after end"
 );
 
+// istanbul ignore next
+var destroy = Writable.prototype.destroy || noop;
+
 // An HTTP(S) request that can be redirected
 function RedirectableRequest(options, responseCallback) {
   // Initialize the request
@@ -62098,7 +62214,13 @@ function RedirectableRequest(options, responseCallback) {
   // React to responses of native requests
   var self = this;
   this._onNativeResponse = function (response) {
-    self._processResponse(response);
+    try {
+      self._processResponse(response);
+    }
+    catch (cause) {
+      self.emit("error", cause instanceof RedirectionError ?
+        cause : new RedirectionError({ cause: cause }));
+    }
   };
 
   // Perform the first request
@@ -62107,10 +62229,17 @@ function RedirectableRequest(options, responseCallback) {
 RedirectableRequest.prototype = Object.create(Writable.prototype);
 
 RedirectableRequest.prototype.abort = function () {
-  abortRequest(this._currentRequest);
+  destroyRequest(this._currentRequest);
+  this._currentRequest.abort();
   this.emit("abort");
 };
 
+RedirectableRequest.prototype.destroy = function (error) {
+  destroyRequest(this._currentRequest, error);
+  destroy.call(this, error);
+  return this;
+};
+
 // Writes buffered data to the current native request
 RedirectableRequest.prototype.write = function (data, encoding, callback) {
   // Writing is not allowed if end has been called
@@ -62119,10 +62248,10 @@ RedirectableRequest.prototype.write = function (data, encoding, callback) {
   }
 
   // Validate input and shift parameters if necessary
-  if (!(typeof data === "string" || typeof data === "object" && ("length" in data))) {
+  if (!isString(data) && !isBuffer(data)) {
     throw new TypeError("data should be a string, Buffer or Uint8Array");
   }
-  if (typeof encoding === "function") {
+  if (isFunction(encoding)) {
     callback = encoding;
     encoding = null;
   }
@@ -62151,11 +62280,11 @@ RedirectableRequest.prototype.write = function (data, encoding, callback) {
 // Ends the current native request
 RedirectableRequest.prototype.end = function (data, encoding, callback) {
   // Shift parameters if necessary
-  if (typeof data === "function") {
+  if (isFunction(data)) {
     callback = data;
     data = encoding = null;
   }
-  else if (typeof encoding === "function") {
+  else if (isFunction(encoding)) {
     callback = encoding;
     encoding = null;
   }
@@ -62223,6 +62352,7 @@ RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
     self.removeListener("abort", clearTimer);
     self.removeListener("error", clearTimer);
     self.removeListener("response", clearTimer);
+    self.removeListener("close", clearTimer);
     if (callback) {
       self.removeListener("timeout", callback);
     }
@@ -62249,6 +62379,7 @@ RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
   this.on("abort", clearTimer);
   this.on("error", clearTimer);
   this.on("response", clearTimer);
+  this.on("close", clearTimer);
 
   return this;
 };
@@ -62307,8 +62438,7 @@ RedirectableRequest.prototype._performRequest = function () {
   var protocol = this._options.protocol;
   var nativeProtocol = this._options.nativeProtocols[protocol];
   if (!nativeProtocol) {
-    this.emit("error", new TypeError("Unsupported protocol " + protocol));
-    return;
+    throw new TypeError("Unsupported protocol " + protocol);
   }
 
   // If specified, use the agent corresponding to the protocol
@@ -62318,21 +62448,26 @@ RedirectableRequest.prototype._performRequest = function () {
     this._options.agent = this._options.agents[scheme];
   }
 
-  // Create the native request
+  // Create the native request and set up its event handlers
   var request = this._currentRequest =
         nativeProtocol.request(this._options, this._onNativeResponse);
-  this._currentUrl = url.format(this._options);
-
-  // Set up event handlers
   request._redirectable = this;
-  for (var e = 0; e < events.length; e++) {
-    request.on(events[e], eventHandlers[events[e]]);
+  for (var event of events) {
+    request.on(event, eventHandlers[event]);
   }
 
+  // RFC7230§5.3.1: When making a request directly to an origin server, […]
+  // a client MUST send only the absolute path […] as the request-target.
+  this._currentUrl = /^\//.test(this._options.path) ?
+    url.format(this._options) :
+    // When making a request to a proxy, […]
+    // a client MUST send the target URI in absolute-form […].
+    this._options.path;
+
   // End a redirected request
   // (The first request must be ended explicitly with RedirectableRequest#end)
   if (this._isRedirect) {
-    // Write the request entity and end.
+    // Write the request entity and end
     var i = 0;
     var self = this;
     var buffers = this._requestBodyBuffers;
@@ -62395,15 +62530,14 @@ RedirectableRequest.prototype._processResponse = function (response) {
   }
 
   // The response is a redirect, so abort the current request
-  abortRequest(this._currentRequest);
+  destroyRequest(this._currentRequest);
   // Discard the remainder of the response to avoid waiting for data
   response.destroy();
 
   // RFC7231§6.4: A client SHOULD detect and intervene
   // in cyclical redirections (i.e., "infinite" redirection loops).
   if (++this._redirectCount > this._options.maxRedirects) {
-    this.emit("error", new TooManyRedirectsError());
-    return;
+    throw new TooManyRedirectsError();
   }
 
   // Store the request headers if applicable
@@ -62437,38 +62571,28 @@ RedirectableRequest.prototype._processResponse = function (response) {
   var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
 
   // If the redirect is relative, carry over the host of the last request
-  var currentUrlParts = url.parse(this._currentUrl);
+  var currentUrlParts = parseUrl(this._currentUrl);
   var currentHost = currentHostHeader || currentUrlParts.host;
   var currentUrl = /^\w+:/.test(location) ? this._currentUrl :
     url.format(Object.assign(currentUrlParts, { host: currentHost }));
 
-  // Determine the URL of the redirection
-  var redirectUrl;
-  try {
-    redirectUrl = url.resolve(currentUrl, location);
-  }
-  catch (cause) {
-    this.emit("error", new RedirectionError(cause));
-    return;
-  }
-
   // Create the redirected request
-  debug$5("redirecting to", redirectUrl);
+  var redirectUrl = resolveUrl(location, currentUrl);
+  debug$5("redirecting to", redirectUrl.href);
   this._isRedirect = true;
-  var redirectUrlParts = url.parse(redirectUrl);
-  Object.assign(this._options, redirectUrlParts);
+  spreadUrlObject(redirectUrl, this._options);
 
   // Drop confidential headers when redirecting to a less secure protocol
   // or to a different domain that is not a superdomain
-  if (redirectUrlParts.protocol !== currentUrlParts.protocol &&
-     redirectUrlParts.protocol !== "https:" ||
-     redirectUrlParts.host !== currentHost &&
-     !isSubdomain(redirectUrlParts.host, currentHost)) {
-    removeMatchingHeaders(/^(?:authorization|cookie)$/i, this._options.headers);
+  if (redirectUrl.protocol !== currentUrlParts.protocol &&
+     redirectUrl.protocol !== "https:" ||
+     redirectUrl.host !== currentHost &&
+     !isSubdomain(redirectUrl.host, currentHost)) {
+    removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
   }
 
   // Evaluate the beforeRedirect callback
-  if (typeof beforeRedirect === "function") {
+  if (isFunction(beforeRedirect)) {
     var responseDetails = {
       headers: response.headers,
       statusCode: statusCode,
@@ -62478,23 +62602,12 @@ RedirectableRequest.prototype._processResponse = function (response) {
       method: method,
       headers: requestHeaders,
     };
-    try {
-      beforeRedirect(this._options, responseDetails, requestDetails);
-    }
-    catch (err) {
-      this.emit("error", err);
-      return;
-    }
+    beforeRedirect(this._options, responseDetails, requestDetails);
     this._sanitizeOptions(this._options);
   }
 
   // Perform the redirected request
-  try {
-    this._performRequest();
-  }
-  catch (cause) {
-    this.emit("error", new RedirectionError(cause));
-  }
+  this._performRequest();
 };
 
 // Wraps the key/value object of protocols with redirect functionality
@@ -62514,26 +62627,19 @@ function wrap(protocols) {
 
     // Executes a request, following redirects
     function request(input, options, callback) {
-      // Parse parameters
-      if (typeof input === "string") {
-        var urlStr = input;
-        try {
-          input = urlToOptions(new URL$1(urlStr));
-        }
-        catch (err) {
-          /* istanbul ignore next */
-          input = url.parse(urlStr);
-        }
+      // Parse parameters, ensuring that input is an object
+      if (isURL(input)) {
+        input = spreadUrlObject(input);
       }
-      else if (URL$1 && (input instanceof URL$1)) {
-        input = urlToOptions(input);
+      else if (isString(input)) {
+        input = spreadUrlObject(parseUrl(input));
       }
       else {
         callback = options;
-        options = input;
+        options = validateUrl(input);
         input = { protocol: protocol };
       }
-      if (typeof options === "function") {
+      if (isFunction(options)) {
         callback = options;
         options = null;
       }
@@ -62544,6 +62650,9 @@ function wrap(protocols) {
         maxBodyLength: exports.maxBodyLength,
       }, input, options);
       options.nativeProtocols = nativeProtocols;
+      if (!isString(options.host) && !isString(options.hostname)) {
+        options.hostname = "::1";
+      }
 
       assert.equal(options.protocol, protocol, "protocol mismatch");
       debug$5("options", options);
@@ -62566,27 +62675,57 @@ function wrap(protocols) {
   return exports;
 }
 
-/* istanbul ignore next */
 function noop() { /* empty */ }
 
-// from https://github.com/nodejs/node/blob/master/lib/internal/url.js
-function urlToOptions(urlObject) {
-  var options = {
-    protocol: urlObject.protocol,
-    hostname: urlObject.hostname.startsWith("[") ?
-      /* istanbul ignore next */
-      urlObject.hostname.slice(1, -1) :
-      urlObject.hostname,
-    hash: urlObject.hash,
-    search: urlObject.search,
-    pathname: urlObject.pathname,
-    path: urlObject.pathname + urlObject.search,
-    href: urlObject.href,
-  };
-  if (urlObject.port !== "") {
-    options.port = Number(urlObject.port);
+function parseUrl(input) {
+  var parsed;
+  /* istanbul ignore else */
+  if (useNativeURL) {
+    parsed = new URL$1(input);
+  }
+  else {
+    // Ensure the URL is valid and absolute
+    parsed = validateUrl(url.parse(input));
+    if (!isString(parsed.protocol)) {
+      throw new InvalidUrlError({ input });
+    }
+  }
+  return parsed;
+}
+
+function resolveUrl(relative, base) {
+  /* istanbul ignore next */
+  return useNativeURL ? new URL$1(relative, base) : parseUrl(url.resolve(base, relative));
+}
+
+function validateUrl(input) {
+  if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
+    throw new InvalidUrlError({ input: input.href || input });
   }
-  return options;
+  if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+    throw new InvalidUrlError({ input: input.href || input });
+  }
+  return input;
+}
+
+function spreadUrlObject(urlObject, target) {
+  var spread = target || {};
+  for (var key of preservedUrlFields) {
+    spread[key] = urlObject[key];
+  }
+
+  // Fix IPv6 hostname
+  if (spread.hostname.startsWith("[")) {
+    spread.hostname = spread.hostname.slice(1, -1);
+  }
+  // Ensure port is a number
+  if (spread.port !== "") {
+    spread.port = Number(spread.port);
+  }
+  // Concatenate path
+  spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+
+  return spread;
 }
 
 function removeMatchingHeaders(regex, headers) {
@@ -62601,37 +62740,60 @@ function removeMatchingHeaders(regex, headers) {
     undefined : String(lastValue).trim();
 }
 
-function createErrorType(code, defaultMessage) {
-  function CustomError(cause) {
+function createErrorType(code, message, baseClass) {
+  // Create constructor
+  function CustomError(properties) {
     Error.captureStackTrace(this, this.constructor);
-    if (!cause) {
-      this.message = defaultMessage;
-    }
-    else {
-      this.message = defaultMessage + ": " + cause.message;
-      this.cause = cause;
-    }
+    Object.assign(this, properties || {});
+    this.code = code;
+    this.message = this.cause ? message + ": " + this.cause.message : message;
   }
-  CustomError.prototype = new Error();
-  CustomError.prototype.constructor = CustomError;
-  CustomError.prototype.name = "Error [" + code + "]";
-  CustomError.prototype.code = code;
+
+  // Attach constructor and set default properties
+  CustomError.prototype = new (baseClass || Error)();
+  Object.defineProperties(CustomError.prototype, {
+    constructor: {
+      value: CustomError,
+      enumerable: false,
+    },
+    name: {
+      value: "Error [" + code + "]",
+      enumerable: false,
+    },
+  });
   return CustomError;
 }
 
-function abortRequest(request) {
-  for (var e = 0; e < events.length; e++) {
-    request.removeListener(events[e], eventHandlers[events[e]]);
+function destroyRequest(request, error) {
+  for (var event of events) {
+    request.removeListener(event, eventHandlers[event]);
   }
   request.on("error", noop);
-  request.abort();
+  request.destroy(error);
 }
 
 function isSubdomain(subdomain, domain) {
-  const dot = subdomain.length - domain.length - 1;
+  assert(isString(subdomain) && isString(domain));
+  var dot = subdomain.length - domain.length - 1;
   return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
 }
 
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+function isBuffer(value) {
+  return typeof value === "object" && ("length" in value);
+}
+
+function isURL(value) {
+  return URL$1 && value instanceof URL$1;
+}
+
 // Exports
 followRedirects$1.exports = wrap({ http: http$1, https: https$1 });
 followRedirects$1.exports.wrap = wrap;
@@ -64055,6 +64217,13 @@ class ModuleNode {
     ssrModule = null;
     ssrError = null;
     lastHMRTimestamp = 0;
+    /**
+     * `import.meta.hot.invalidate` is called by the client.
+     * If there's multiple clients, multiple `invalidate` request is received.
+     * This property is used to dedupe those request to avoid multiple updates happening.
+     * @internal
+     */
+    lastHMRInvalidationReceived = false;
     lastInvalidationTimestamp = 0;
     /**
      * If the module only needs to update its imports timestamp (e.g. within an HMR chain),
@@ -64179,6 +64348,7 @@ class ModuleGraph {
         seen.add(mod);
         if (isHmr) {
             mod.lastHMRTimestamp = timestamp;
+            mod.lastHMRInvalidationReceived = false;
         }
         else {
             // Save the timestamp for this invalidation, so we can avoid caching the result of possible already started
@@ -64802,7 +64972,11 @@ async function _createServer(inlineConfig = {}, options) {
     });
     hot.on('vite:invalidate', async ({ path, message }) => {
         const mod = moduleGraph.urlToModuleMap.get(path);
-        if (mod && mod.isSelfAccepting && mod.lastHMRTimestamp > 0) {
+        if (mod &&
+            mod.isSelfAccepting &&
+            mod.lastHMRTimestamp > 0 &&
+            !mod.lastHMRInvalidationReceived) {
+            mod.lastHMRInvalidationReceived = true;
             config.logger.info(colors$1.yellow(`hmr invalidate `) +
                 colors$1.dim(path) +
                 (message ? ` ${message}` : ''), { timestamp: true });
@@ -65488,6 +65662,7 @@ function handlePrunedModules(mods, { hot }) {
     const t = Date.now();
     mods.forEach((mod) => {
         mod.lastHMRTimestamp = t;
+        mod.lastHMRInvalidationReceived = false;
         debugHmr?.(`[dispose] ${colors$1.dim(mod.file)}`);
     });
     hot.send({
@@ -66800,13 +66975,7 @@ function buildImportAnalysisPlugin(config) {
                         const fileDepsCode = `[${fileDeps
                             .map((fileDep) => fileDep.runtime ? fileDep.url : JSON.stringify(fileDep.url))
                             .join(',')}]`;
-                        const mapDepsCode = `\
-function __vite__mapDeps(indexes) {
-  if (!__vite__mapDeps.viteFileDeps) {
-    __vite__mapDeps.viteFileDeps = ${fileDepsCode}
-  }
-  return indexes.map((i) => __vite__mapDeps.viteFileDeps[i])
-}\n`;
+                        const mapDepsCode = `const __vite__fileDeps=${fileDepsCode},__vite__mapDeps=i=>i.map(i=>__vite__fileDeps[i]);\n`;
                         // inject extra code at the top or next line of hashbang
                         if (code.startsWith('#!')) {
                             s.prependLeft(code.indexOf('\n') + 1, mapDepsCode);