vite 6.0.0-alpha.0 → 6.0.0-alpha.2

package/dist/node/chunks/{dep-hQh5_mg-.js → dep-E4cF1RpV.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 };
 }
@@ -19261,10 +19305,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 === '';
 }
@@ -39082,7 +39126,7 @@ var debug$d = 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;
 
@@ -39286,7 +39330,7 @@ function getErrorStatusCode (err) {
 
 function getResourceName (req) {
   try {
-    return parseUrl$1.original(req).pathname
+    return parseUrl$2.original(req).pathname
   } catch (e) {
     return 'resource'
   }
@@ -39445,7 +39489,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.
@@ -39580,7 +39624,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
@@ -44522,7 +44566,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') {
@@ -44602,7 +44646,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;
@@ -44647,7 +44691,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$/;
@@ -44655,7 +44699,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 &&
@@ -44768,7 +44812,8 @@ async function ssrLoadModule(url, server, context = { global }, urlStack = [], f
     return modulePromise;
 }
 async function instantiateModule(url, server, context = { global }, urlStack = [], fixStacktrace) {
-    const moduleGraph = server.environments.ssr.moduleGraph;
+    const environment = server.environments.ssr;
+    const moduleGraph = environment.moduleGraph;
     const mod = await moduleGraph.ensureEntryFromUrl(url);
     if (mod.ssrError) {
         throw mod.ssrError;
@@ -44776,7 +44821,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     if (mod.ssrModule) {
         return mod.ssrModule;
     }
-    const result = mod.transformResult || (await server.environments.ssr.transformRequest(url));
+    const result = mod.transformResult || (await environment.transformRequest(url));
     if (!result) {
         // TODO more info? is this even necessary?
         throw new Error(`failed to load module for ssr: ${url}`);
@@ -44798,8 +44843,8 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     };
     urlStack = urlStack.concat(url);
     const isCircular = (url) => urlStack.includes(url);
-    const { isProduction, resolve: { dedupe, preserveSymlinks }, root, ssr, } = server.config;
-    const externalConditions = ssr.resolve?.externalConditions || [];
+    const { isProduction, root } = server.config;
+    const { externalConditions, dedupe, preserveSymlinks } = environment.options.resolve;
     const resolveOptions = {
         mainFields: ['main'],
         conditions: [],
@@ -44813,7 +44858,6 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         isBuild: false,
         isProduction,
         root,
-        ssrConfig: ssr,
         legacyProxySsrExternalModules: server.config.legacy?.proxySsrExternalModules,
         packageCache: server.config.packageCache,
     };
@@ -51849,6 +51893,30 @@ var Writable = require$$0$7.Writable;
 var assert = require$$5;
 var debug$a = 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);
@@ -51859,13 +51927,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",
@@ -51876,6 +51950,9 @@ var WriteAfterEndError = createErrorType(
   "write after end"
 );
 
+// istanbul ignore next
+var destroy = Writable.prototype.destroy || noop$2;
+
 // An HTTP(S) request that can be redirected
 function RedirectableRequest(options, responseCallback) {
   // Initialize the request
@@ -51897,7 +51974,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
@@ -51906,10 +51989,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
@@ -51918,10 +52008,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;
   }
@@ -51950,11 +52040,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;
   }
@@ -52022,6 +52112,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);
     }
@@ -52048,6 +52139,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;
 };
@@ -52106,8 +52198,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
@@ -52117,21 +52208,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;
@@ -52194,15 +52290,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
@@ -52236,38 +52331,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$a("redirecting to", redirectUrl);
+  var redirectUrl = resolveUrl(location, currentUrl);
+  debug$a("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,
@@ -52277,23 +52362,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
@@ -52313,26 +52387,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;
       }
@@ -52343,6 +52410,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$a("options", options);
@@ -52365,27 +52435,57 @@ function wrap(protocols) {
   return exports;
 }
 
-/* istanbul ignore next */
 function noop$2() { /* 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 options;
+  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 });
+  }
+  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) {
@@ -52400,37 +52500,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$2);
-  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;
@@ -53877,7 +54000,7 @@ function transformRequest(url, server, options = {}, environment) {
         // Backward compatibility
         options = { ...options, ssr: environment.name !== 'client' };
     }
-    if (server._restartPromise && !options.ssr)
+    if (server._restartPromise && environment?.options.dev.recoverable)
         throwClosedServerError();
     // We could have a cache per environment instead of the global _pendingRequests
     const cacheKey = `${options.html ? 'html:' : ''}${environment.name}:${url}`;
@@ -54019,7 +54142,8 @@ async function loadAndTransform(environment, id, url, server, options, timestamp
         // as string
         // only try the fallback if access is allowed, skip for out of root url
         // like /service-worker.js or /api/users
-        if (options.ssr || isFileServingAllowed(file, server)) {
+        if (environment.options.nodeCompatible ||
+            isFileServingAllowed(file, server)) {
             try {
                 code = await fsp.readFile(file, 'utf-8');
                 debugLoad?.(`${timeFrom(loadStart)} [fs] ${prettyUrl}`);
@@ -54078,7 +54202,7 @@ async function loadAndTransform(environment, id, url, server, options, timestamp
         err.code = isPublicFile ? ERR_LOAD_PUBLIC_URL : ERR_LOAD_URL;
         throw err;
     }
-    if (server._restartPromise && !ssr)
+    if (server._restartPromise && environment.options.dev.recoverable)
         throwClosedServerError();
     // ensure module in graph after successful load
     mod ??= await moduleGraph._ensureEntryFromUrl(url, undefined, resolved);
@@ -54132,7 +54256,7 @@ async function loadAndTransform(environment, id, url, server, options, timestamp
             }
         }
     }
-    if (server._restartPromise && !ssr)
+    if (server._restartPromise && environment.options.dev.recoverable)
         throwClosedServerError();
     const result = ssr && !server.config.experimental.skipSsrTransform
         ? await server.ssrTransform(code, normalizedMap, url, originalCode)
@@ -54220,7 +54344,7 @@ async function handleModuleSoftInvalidation(environment, mod, timestamp, server)
 
 // 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;
@@ -54231,6 +54355,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;
@@ -54251,6 +54376,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) {
@@ -54626,6 +54758,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];
@@ -55523,7 +55659,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();
@@ -56836,8 +56975,8 @@ async function fetchModule(environment, url, importer, options = {}) {
         return { externalize: url, type: 'network' };
     }
     if (url[0] !== '.' && url[0] !== '/') {
-        const { isProduction, resolve: { dedupe, preserveSymlinks }, root, ssr, } = environment.config;
-        const externalConditions = ssr.resolve?.externalConditions || [];
+        const { isProduction, root } = environment.config;
+        const { externalConditions, dedupe, preserveSymlinks } = environment.options.resolve;
         const resolveOptions = {
             mainFields: ['main'],
             conditions: [],
@@ -56851,7 +56990,6 @@ async function fetchModule(environment, url, importer, options = {}) {
             isBuild: false,
             isProduction,
             root,
-            ssrConfig: ssr,
             packageCache: environment.config.packageCache,
         };
         const resolved = tryNodeResolve(url, importer, {
@@ -58203,20 +58341,20 @@ async function _createServer(inlineConfig = {}, options) {
     // Create Environments
     const client_createEnvironment = config.environments.client?.dev?.createEnvironment ??
         ((server, name) => new DevEnvironment(server, name, { hot: ws }));
-    environments.client = client_createEnvironment(server, 'client');
+    environments.client = await client_createEnvironment(server, 'client');
     const ssr_createEnvironment = config.environments.ssr?.dev?.createEnvironment ??
         ((server, name) => createNodeDevEnvironment(server, name, { hot: ssrHotChannel }));
-    environments.ssr = ssr_createEnvironment(server, 'ssr');
-    Object.entries(config.environments).forEach(([name, EnvironmentOptions]) => {
+    environments.ssr = await ssr_createEnvironment(server, 'ssr');
+    for (const [name, EnvironmentOptions] of Object.entries(config.environments)) {
         // TODO: move client and ssr inside the loop?
         if (name !== 'client' && name !== 'ssr') {
             const createEnvironment = EnvironmentOptions.dev?.createEnvironment ??
                 ((server, name) => new DevEnvironment(server, name, {
                     hot: ws, // TODO: what should we use here?
                 }));
-            environments[name] = createEnvironment(server, name);
+            environments[name] = await createEnvironment(server, name);
         }
-    });
+    }
     if (!middlewareMode) {
         exitProcess = async () => {
             try {
@@ -59334,8 +59472,8 @@ function createIsConfiguredAsExternal(environment) {
         isProduction: false,
         isBuild: true,
         conditions: targetConditions,
-        webCompatible: config.ssr.target === 'webworker',
-        nodeCompatible: true,
+        webCompatible: options.webCompatible,
+        nodeCompatible: options.nodeCompatible,
     };
     const isExternalizable = (id, importer, configuredAsExternal) => {
         if (!bareImportRE.test(id) || id.includes('\0')) {
@@ -59449,8 +59587,13 @@ function definePlugin(config) {
             userDefineEnv[key.slice(16)] = config.define[key];
         }
     }
-    function generatePattern(ssr) {
-        const replaceProcessEnv = !ssr || config.ssr?.target === 'webworker';
+    function generatePattern(environment) {
+        // This is equivalent to the old `!ssr || config.ssr?.target === 'webworker'`
+        // TODO: We shouldn't keep options.nodeCompatible and options.webCompatible
+        // This is a place where using `!options.nodeCompatible` fails and it is confusing why
+        // Do we need a per-environment replaceProcessEnv option?
+        // Is it useful to have define be configured per-environment?
+        const replaceProcessEnv = environment.options.webCompatible;
         const define = {
             ...(replaceProcessEnv ? processEnv : {}),
             ...importMetaKeys,
@@ -59458,6 +59601,10 @@ function definePlugin(config) {
             ...importMetaFallbackKeys,
         };
         // Additional define fixes based on `ssr` value
+        // Backward compatibility. Any non client environment will get import.meta.env.SSR = true
+        // TODO: Check if we should only do this for the SSR environment and how to abstract
+        // maybe we need import.meta.env.environmentName ?
+        const ssr = environment.name !== 'client';
         if ('import.meta.env.SSR' in define) {
             define['import.meta.env.SSR'] = ssr + '';
         }
@@ -59481,13 +59628,23 @@ function definePlugin(config) {
             : null;
         return [define, pattern];
     }
-    const defaultPattern = generatePattern(false);
-    const ssrPattern = generatePattern(true);
+    const patternsCache = new WeakMap();
+    function getPattern(environment) {
+        let pattern = patternsCache.get(environment);
+        if (!pattern) {
+            pattern = generatePattern(environment);
+            patternsCache.set(environment, pattern);
+        }
+        return pattern;
+    }
     return {
         name: 'vite:define',
-        async transform(code, id, options) {
-            const ssr = options?.ssr === true;
-            if (!ssr && !isBuild) {
+        async transform(code, id) {
+            const { environment } = this;
+            if (!environment) {
+                return;
+            }
+            if (environment.name === 'client' && !isBuild) {
                 // for dev we inject actual global defines in the vite client to
                 // avoid the transform cost. see the `clientInjection` and
                 // `importAnalysis` plugin.
@@ -59501,7 +59658,7 @@ function definePlugin(config) {
                 config.assetsInclude(id)) {
                 return;
             }
-            const [define, pattern] = ssr ? ssrPattern : defaultPattern;
+            const [define, pattern] = getPattern(environment);
             if (!pattern)
                 return;
             // Check if our code needs any replacements before running esbuild
@@ -59534,6 +59691,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]);
     }
@@ -59989,6 +60163,7 @@ function preAliasPlugin(config) {
         },
     };
 }
+// TODO: environment?
 function optimizeAliasReplacementForSSR(id, optimizeDeps) {
     if (optimizeDeps.include?.includes(id)) {
         return true;
@@ -60959,7 +61134,6 @@ function workerImportMetaUrlPlugin(config) {
         isProduction: config.isProduction,
         isBuild: config.command === 'build',
         packageCache: config.packageCache,
-        ssrConfig: config.ssr,
         asSrc: true,
     };
     return {
@@ -60969,9 +61143,12 @@ function workerImportMetaUrlPlugin(config) {
                 return true;
             }
         },
-        async transform(code, id, options) {
+        async transform(code, id) {
             const { environment } = this;
-            if (environment && !options?.ssr && isIncludeWorkerImportMetaUrl(code)) {
+            // TODO: environment, same as with assetImportMetaUrlPlugin
+            if (environment &&
+                environment.name === 'client' &&
+                isIncludeWorkerImportMetaUrl(code)) {
                 let s;
                 const cleanString = stripLiteral(code);
                 const workerImportMetaUrlRE = /\bnew\s+(?:Worker|SharedWorker)\s*\(\s*(new\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*\))/dg;
@@ -61050,7 +61227,6 @@ function assetImportMetaUrlPlugin(config) {
         isProduction: config.isProduction,
         isBuild: config.command === 'build',
         packageCache: config.packageCache,
-        ssrConfig: config.ssr,
         asSrc: true,
     };
     return {
@@ -61058,7 +61234,8 @@ function assetImportMetaUrlPlugin(config) {
         async transform(code, id, options) {
             const { environment } = this;
             if (environment &&
-                !options?.ssr &&
+                // TODO: Should this be done only for the client or for any webCompatible environment?
+                environment.name === 'client' &&
                 id !== preloadHelperId &&
                 id !== CLIENT_ENTRY &&
                 code.includes('new URL') &&
@@ -62239,7 +62416,6 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             isProduction: config.isProduction,
             isBuild,
             packageCache: config.packageCache,
-            ssrConfig: config.ssr,
             asSrc: true,
             fsUtils: getFsUtils(config),
             optimizeDeps: true,
@@ -62813,7 +62989,7 @@ async function createPluginContainer(config, watcher, environments) {
             let id = null;
             const partial = {};
             for (const plugin of getSortedPlugins('resolveId')) {
-                if (closed && !ssr)
+                if (closed && environment?.options.dev.recoverable)
                     throwClosedServerError();
                 if (!plugin.resolveId)
                     continue;
@@ -62864,7 +63040,7 @@ async function createPluginContainer(config, watcher, environments) {
             ctx.ssr = !!ssr;
             ctx.environment = environment;
             for (const plugin of getSortedPlugins('load')) {
-                if (closed && !ssr)
+                if (closed && environment?.options.dev.recoverable)
                     throwClosedServerError();
                 if (!plugin.load)
                     continue;
@@ -62889,7 +63065,7 @@ async function createPluginContainer(config, watcher, environments) {
             ctx.ssr = !!ssr;
             ctx.environment = environment;
             for (const plugin of getSortedPlugins('transform')) {
-                if (closed && !ssr)
+                if (closed && environment?.options.dev.recoverable)
                     throwClosedServerError();
                 if (!plugin.transform)
                     continue;
@@ -63494,7 +63670,6 @@ function createOptimizeDepsIncludeResolver(environment) {
         asSrc: false,
         scan: true,
         ssrOptimizeCheck: environment.name !== 'client',
-        ssrConfig: config.ssr,
         packageCache: new Map(),
     });
     return async (id) => {
@@ -63802,9 +63977,13 @@ function runOptimizeDeps(environment, depsInfo) {
             // No need to wait, we can clean up in the background because temp folders
             // are unique per run
             debug$2?.(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 = {
@@ -63983,8 +64162,7 @@ async function prepareEsbuildOptimizerRun(environment, depsInfo, processingCache
     const define = {
         'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || config.mode),
     };
-    const ssr = environment.name !== 'client'; // TODO:depsOptimizer
-    const platform = ssr && config.ssr?.target !== 'webworker' ? 'node' : 'browser';
+    const platform = environment.options.webCompatible ? 'browser' : 'node';
     const external = [...(optimizeDeps?.exclude ?? [])];
     const plugins = [...pluginsFromConfig];
     if (external.length) {
@@ -65572,7 +65750,7 @@ function cssPostPlugin(config) {
                 if (isDirectCSSRequest(id)) {
                     return null;
                 }
-                // server only
+                // server only, TODO: environment
                 if (options?.ssr) {
                     return modulesCode || `export default ${JSON.stringify(css)}`;
                 }
@@ -65830,6 +66008,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.
@@ -65838,11 +66017,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);
@@ -66245,8 +66427,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-DUc_OVe8.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-b2YSXG5U.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-DK04Q0H9.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-DKZVy3_n.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -67635,13 +67817,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);
@@ -67817,37 +67993,39 @@ function completeSystemWrapPlugin() {
     };
 }
 
-function resolveBuildOptions(raw, logger, root, environmentName) {
+function resolveBuildOptions(raw, logger, root) {
+    const libMode = raw.lib ?? false;
+    const buildOptions = resolveBuildEnvironmentOptions(raw, logger, root, undefined, libMode);
+    return { ...buildOptions, lib: libMode };
+}
+function resolveBuildEnvironmentOptions(raw, logger, root, environmentName, libMode = false) {
     const deprecatedPolyfillModulePreload = raw?.polyfillModulePreload;
-    if (raw) {
-        const { polyfillModulePreload, ...rest } = raw;
-        raw = rest;
-        if (deprecatedPolyfillModulePreload !== undefined) {
-            logger.warn('polyfillModulePreload is deprecated. Use modulePreload.polyfill instead.');
-        }
-        if (deprecatedPolyfillModulePreload === false &&
-            raw.modulePreload === undefined) {
-            raw.modulePreload = { polyfill: false };
-        }
+    const { polyfillModulePreload, ...rest } = raw;
+    raw = rest;
+    if (deprecatedPolyfillModulePreload !== undefined) {
+        logger.warn('polyfillModulePreload is deprecated. Use modulePreload.polyfill instead.');
+    }
+    if (deprecatedPolyfillModulePreload === false &&
+        raw.modulePreload === undefined) {
+        raw.modulePreload = { polyfill: false };
     }
-    const modulePreload = raw?.modulePreload;
+    const modulePreload = raw.modulePreload;
     const defaultModulePreload = {
         polyfill: true,
     };
-    const defaultBuildOptions = {
+    const defaultBuildEnvironmentOptions = {
         outDir: 'dist',
         assetsDir: 'assets',
         assetsInlineLimit: DEFAULT_ASSETS_INLINE_LIMIT,
-        cssCodeSplit: !raw?.lib,
+        cssCodeSplit: !libMode,
         sourcemap: false,
         rollupOptions: {},
-        minify: raw?.ssr ? false : 'esbuild',
+        minify: raw.ssr ? false : 'esbuild',
         terserOptions: {},
         write: true,
         emptyOutDir: null,
         copyPublicDir: true,
         manifest: false,
-        lib: false,
         ssr: false,
         ssrManifest: false,
         ssrEmitAssets: false,
@@ -67856,23 +68034,23 @@ function resolveBuildOptions(raw, logger, root, environmentName) {
         chunkSizeWarningLimit: 500,
         watch: null,
     };
-    const userBuildOptions = raw
-        ? mergeConfig(defaultBuildOptions, raw)
-        : defaultBuildOptions;
+    const userBuildEnvironmentOptions = raw
+        ? mergeConfig(defaultBuildEnvironmentOptions, raw)
+        : defaultBuildEnvironmentOptions;
     // @ts-expect-error Fallback options instead of merging
     const resolved = {
         target: 'modules',
         cssTarget: false,
-        ...userBuildOptions,
+        ...userBuildEnvironmentOptions,
         commonjsOptions: {
             include: [/node_modules/],
             extensions: ['.js', '.cjs'],
-            ...userBuildOptions.commonjsOptions,
+            ...userBuildEnvironmentOptions.commonjsOptions,
         },
         dynamicImportVarsOptions: {
             warnOnError: true,
             exclude: [/node_modules/],
-            ...userBuildOptions.dynamicImportVarsOptions,
+            ...userBuildEnvironmentOptions.dynamicImportVarsOptions,
         },
         // Resolve to false | object
         modulePreload: modulePreload === false
@@ -67950,17 +68128,27 @@ async function resolveBuildPlugins(config) {
  */
 async function build(inlineConfig = {}) {
     const builder = await createViteBuilder({}, { ...inlineConfig, plugins: () => inlineConfig.plugins ?? [] });
-    const ssr = !!builder.config.build.ssr;
-    const environment = builder.environments[ssr ? 'ssr' : 'client'];
-    return builder.build(environment);
+    if (builder.config.build.lib) {
+        // TODO: temporal workaround. Should we support `libraries: Record<string, LibraryOptions & EnvironmentOptions>`
+        // to build multiple libraries and be able to target different environments (for example for a Svelte components
+        // library generating both client and SSR builds)?
+        return buildEnvironment(builder.config, builder.environments.client, builder.config.build.lib);
+    }
+    else {
+        const ssr = !!builder.config.build.ssr;
+        const environment = builder.environments[ssr ? 'ssr' : 'client'];
+        return builder.build(environment);
+    }
 }
 function resolveConfigToBuild(inlineConfig = {}) {
     return resolveConfig(inlineConfig, 'build', 'production', 'production');
 }
-async function buildEnvironment(config, environment) {
+/**
+ * Build an App environment, or a App library (if librayOptions is provided)
+ **/
+async function buildEnvironment(config, environment, libOptions = false) {
     const options = config.build;
     const ssr = environment.name !== 'client';
-    const libOptions = options.lib;
     config.logger.info(colors$1.cyan(`vite v${VERSION} ${colors$1.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
     const resolve = (p) => path$o.resolve(config.root, p);
     const input = libOptions
@@ -68043,16 +68231,8 @@ async function buildEnvironment(config, environment) {
                 config.logger.warnOnce(colors$1.yellow(`Vite does not support "rollupOptions.output.sourcemap". ` +
                     `Please use "build.sourcemap" instead.`));
             }
-            /**
-             * if (ssr.target === 'webworker') {
-             *   build.rollupOptions.entryFileNames = '[name].js'
-             *   build.rollupOptions.inlineDynamicImports = (typeof input === 'string' || Object.keys(input).length === 1))
-             * }
-             */
-            const ssrNodeBuild = ssr && config.ssr.target === 'node';
-            const ssrWorkerBuild = ssr && config.ssr.target === 'webworker';
             const format = output.format || 'es';
-            const jsExt = ssrNodeBuild || libOptions
+            const jsExt = !environment.options.webCompatible || libOptions
                 ? resolveOutputJsExtension(format, findNearestPackageData(config.root, config.packageCache)?.data
                     .type)
                 : 'js';
@@ -68081,7 +68261,11 @@ async function buildEnvironment(config, environment) {
                     : path$o.posix.join(options.assetsDir, `[name]-[hash].[ext]`),
                 inlineDynamicImports: output.format === 'umd' ||
                     output.format === 'iife' ||
-                    (ssrWorkerBuild &&
+                    // TODO: We need an abstraction for non-client environments?
+                    // We should remove the explicit 'client' hcek here.
+                    // Or maybe `inlineDynamicImports` should be an environment option?
+                    (environment.name !== 'client' &&
+                        environment.options.webCompatible &&
                         (typeof input === 'string' || Object.keys(input).length === 1)),
                 ...output,
             };
@@ -68591,7 +68775,7 @@ async function createViteBuilder(builderOptions = {}, defaultBuilderInlineConfig
         // plugins are built to handle multiple environments concurrently).
         const environmentConfig = await resolveConfig(environmentOptions);
         const environmentBuilder = { ...builder, config: environmentConfig };
-        const environment = createEnvironment(environmentBuilder, name);
+        const environment = await createEnvironment(environmentBuilder, name);
         environments[name] = environment;
     }
     return builder;
@@ -68606,6 +68790,7 @@ var build$1 = {
 	createViteBuilder: createViteBuilder,
 	injectEnvironmentToHooks: injectEnvironmentToHooks,
 	onRollupWarning: onRollupWarning,
+	resolveBuildEnvironmentOptions: resolveBuildEnvironmentOptions,
 	resolveBuildOptions: resolveBuildOptions,
 	resolveBuildOutputs: resolveBuildOutputs,
 	resolveBuildPlugins: resolveBuildPlugins,
@@ -68753,7 +68938,8 @@ function resolvePreviewOptions(preview, server) {
  */
 async function preview(inlineConfig = {}) {
     const config = await resolveConfig(inlineConfig, 'serve', 'production', 'production', true);
-    const distDir = path$o.resolve(config.root, config.build.outDir);
+    const clientOutDir = config.environments.client.build.outDir ?? config.build.outDir;
+    const distDir = path$o.resolve(config.root, clientOutDir);
     if (!fs$l.existsSync(distDir) &&
         // error if no plugins implement `configurePreviewServer`
         config.plugins.every((plugin) => !plugin.configurePreviewServer) &&
@@ -68761,7 +68947,7 @@ async function preview(inlineConfig = {}) {
         // and affect file serving
         process.argv[1]?.endsWith(path$o.normalize('bin/vite.js')) &&
         process.argv[2] === 'preview') {
-        throw new Error(`The directory "${config.build.outDir}" does not exist. Did you build your project?`);
+        throw new Error(`The directory "${clientOutDir}" does not exist. Did you build your project?`);
     }
     const app = connect$1();
     const httpServer = await resolveHttpServer(config.preview, app, await resolveHttpsConfig(config.preview?.https));
@@ -68885,7 +69071,7 @@ const promisifiedRealpath = promisify$4(fs$l.realpath);
 function defineConfig(config) {
     return config;
 }
-function resolveDevOptions(dev, preserverSymlinks) {
+function resolveDevEnvironmentOptions(dev, preserverSymlinks, environmentName) {
     return {
         sourcemap: dev?.sourcemap ?? { js: true },
         sourcemapIgnoreList: dev?.sourcemapIgnoreList === false
@@ -68897,6 +69083,7 @@ function resolveDevOptions(dev, preserverSymlinks) {
         },
         optimizeDeps: resolveOptimizeDepsConfig(dev?.optimizeDeps, preserverSymlinks),
         createEnvironment: dev?.createEnvironment,
+        recoverable: dev?.recoverable ?? environmentName === 'client',
     };
 }
 function resolveEnvironmentOptions(config, resolvedRoot, logger, environmentName) {
@@ -68905,8 +69092,8 @@ function resolveEnvironmentOptions(config, resolvedRoot, logger, environmentName
         resolve,
         nodeCompatible: config.nodeCompatible ?? environmentName !== 'client',
         webCompatible: config.webCompatible ?? environmentName === 'client',
-        dev: resolveDevOptions(config.dev, resolve.preserveSymlinks),
-        build: resolveBuildOptions(config.build, logger, resolvedRoot, environmentName),
+        dev: resolveDevEnvironmentOptions(config.dev, resolve.preserveSymlinks, environmentName),
+        build: resolveBuildEnvironmentOptions(config.build ?? {}, logger, resolvedRoot, environmentName),
     };
 }
 function getDefaultEnvironmentOptions(config) {
@@ -69119,8 +69306,9 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
             ...patchedOptimizeDeps.esbuildOptions,
         },
     };
-    const resolvedDevOptions = resolveDevOptions(config.dev, resolvedDefaultEnvironmentResolve.preserveSymlinks);
-    const resolvedBuildOptions = resolveBuildOptions(config.build, logger, resolvedRoot, undefined);
+    // TODO: Deprecate and remove resolve, dev and build options at the root level of the resolved config
+    const resolvedDevEnvironmentOptions = resolveDevEnvironmentOptions(config.dev, resolvedDefaultEnvironmentResolve.preserveSymlinks, undefined);
+    const resolvedBuildOptions = resolveBuildOptions(config.build ?? {}, logger, resolvedRoot);
     // Backward compatibility: merge config.environments.ssr back into config.ssr
     // so ecosystem SSR plugins continue to work if only environments.ssr is configured
     const patchedConfigSsr = {
@@ -69275,10 +69463,11 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         },
         // Backward compatibility, users should use environment.config.dev.optimizeDeps
         optimizeDeps: backwardCompatibleOptimizeDeps,
+        ssr,
+        // TODO: deprecate and later remove from ResolvedConfig?
         resolve: resolvedDefaultEnvironmentResolve,
-        dev: resolvedDevOptions,
+        dev: resolvedDevEnvironmentOptions,
         build: resolvedBuildOptions,
-        ssr,
         environments: resolvedEnvironments,
         getSortedPlugins: undefined,
         getSortedPluginHooks: undefined,
@@ -69352,13 +69541,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         },
     });
     // validate config
-    if (config.build?.terserOptions &&
-        config.build.minify &&
-        config.build.minify !== 'terser') {
-        logger.warn(colors$1.yellow(`build.terserOptions is specified but build.minify is not set to use Terser. ` +
-            `Note Vite now defaults to use esbuild for minification. If you still ` +
-            `prefer Terser, set build.minify to "terser".`));
-    }
     // Check if all assetFileNames have the same reference.
     // If not, display a warn for user.
     const outputOption = config.build?.rollupOptions?.output ?? [];