vite 6.0.0-beta.2 → 6.0.0-beta.4

package/dist/node/chunks/dep-mtw2NpNs.js

@@ -0,0 +1,589 @@
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+var parse;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse;
+	hasRequiredParse = 1;
+	var openParentheses = "(".charCodeAt(0);
+	var closeParentheses = ")".charCodeAt(0);
+	var singleQuote = "'".charCodeAt(0);
+	var doubleQuote = '"'.charCodeAt(0);
+	var backslash = "\\".charCodeAt(0);
+	var slash = "/".charCodeAt(0);
+	var comma = ",".charCodeAt(0);
+	var colon = ":".charCodeAt(0);
+	var star = "*".charCodeAt(0);
+	var uLower = "u".charCodeAt(0);
+	var uUpper = "U".charCodeAt(0);
+	var plus = "+".charCodeAt(0);
+	var isUnicodeRange = /^[a-f0-9?-]+$/i;
+
+	parse = function(input) {
+	  var tokens = [];
+	  var value = input;
+
+	  var next,
+	    quote,
+	    prev,
+	    token,
+	    escape,
+	    escapePos,
+	    whitespacePos,
+	    parenthesesOpenPos;
+	  var pos = 0;
+	  var code = value.charCodeAt(pos);
+	  var max = value.length;
+	  var stack = [{ nodes: tokens }];
+	  var balanced = 0;
+	  var parent;
+
+	  var name = "";
+	  var before = "";
+	  var after = "";
+
+	  while (pos < max) {
+	    // Whitespaces
+	    if (code <= 32) {
+	      next = pos;
+	      do {
+	        next += 1;
+	        code = value.charCodeAt(next);
+	      } while (code <= 32);
+	      token = value.slice(pos, next);
+
+	      prev = tokens[tokens.length - 1];
+	      if (code === closeParentheses && balanced) {
+	        after = token;
+	      } else if (prev && prev.type === "div") {
+	        prev.after = token;
+	        prev.sourceEndIndex += token.length;
+	      } else if (
+	        code === comma ||
+	        code === colon ||
+	        (code === slash &&
+	          value.charCodeAt(next + 1) !== star &&
+	          (!parent ||
+	            (parent && parent.type === "function" && parent.value !== "calc")))
+	      ) {
+	        before = token;
+	      } else {
+	        tokens.push({
+	          type: "space",
+	          sourceIndex: pos,
+	          sourceEndIndex: next,
+	          value: token
+	        });
+	      }
+
+	      pos = next;
+
+	      // Quotes
+	    } else if (code === singleQuote || code === doubleQuote) {
+	      next = pos;
+	      quote = code === singleQuote ? "'" : '"';
+	      token = {
+	        type: "string",
+	        sourceIndex: pos,
+	        quote: quote
+	      };
+	      do {
+	        escape = false;
+	        next = value.indexOf(quote, next + 1);
+	        if (~next) {
+	          escapePos = next;
+	          while (value.charCodeAt(escapePos - 1) === backslash) {
+	            escapePos -= 1;
+	            escape = !escape;
+	          }
+	        } else {
+	          value += quote;
+	          next = value.length - 1;
+	          token.unclosed = true;
+	        }
+	      } while (escape);
+	      token.value = value.slice(pos + 1, next);
+	      token.sourceEndIndex = token.unclosed ? next : next + 1;
+	      tokens.push(token);
+	      pos = next + 1;
+	      code = value.charCodeAt(pos);
+
+	      // Comments
+	    } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+	      next = value.indexOf("*/", pos);
+
+	      token = {
+	        type: "comment",
+	        sourceIndex: pos,
+	        sourceEndIndex: next + 2
+	      };
+
+	      if (next === -1) {
+	        token.unclosed = true;
+	        next = value.length;
+	        token.sourceEndIndex = next;
+	      }
+
+	      token.value = value.slice(pos + 2, next);
+	      tokens.push(token);
+
+	      pos = next + 2;
+	      code = value.charCodeAt(pos);
+
+	      // Operation within calc
+	    } else if (
+	      (code === slash || code === star) &&
+	      parent &&
+	      parent.type === "function" &&
+	      parent.value === "calc"
+	    ) {
+	      token = value[pos];
+	      tokens.push({
+	        type: "word",
+	        sourceIndex: pos - before.length,
+	        sourceEndIndex: pos + token.length,
+	        value: token
+	      });
+	      pos += 1;
+	      code = value.charCodeAt(pos);
+
+	      // Dividers
+	    } else if (code === slash || code === comma || code === colon) {
+	      token = value[pos];
+
+	      tokens.push({
+	        type: "div",
+	        sourceIndex: pos - before.length,
+	        sourceEndIndex: pos + token.length,
+	        value: token,
+	        before: before,
+	        after: ""
+	      });
+	      before = "";
+
+	      pos += 1;
+	      code = value.charCodeAt(pos);
+
+	      // Open parentheses
+	    } else if (openParentheses === code) {
+	      // Whitespaces after open parentheses
+	      next = pos;
+	      do {
+	        next += 1;
+	        code = value.charCodeAt(next);
+	      } while (code <= 32);
+	      parenthesesOpenPos = pos;
+	      token = {
+	        type: "function",
+	        sourceIndex: pos - name.length,
+	        value: name,
+	        before: value.slice(parenthesesOpenPos + 1, next)
+	      };
+	      pos = next;
+
+	      if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+	        next -= 1;
+	        do {
+	          escape = false;
+	          next = value.indexOf(")", next + 1);
+	          if (~next) {
+	            escapePos = next;
+	            while (value.charCodeAt(escapePos - 1) === backslash) {
+	              escapePos -= 1;
+	              escape = !escape;
+	            }
+	          } else {
+	            value += ")";
+	            next = value.length - 1;
+	            token.unclosed = true;
+	          }
+	        } while (escape);
+	        // Whitespaces before closed
+	        whitespacePos = next;
+	        do {
+	          whitespacePos -= 1;
+	          code = value.charCodeAt(whitespacePos);
+	        } while (code <= 32);
+	        if (parenthesesOpenPos < whitespacePos) {
+	          if (pos !== whitespacePos + 1) {
+	            token.nodes = [
+	              {
+	                type: "word",
+	                sourceIndex: pos,
+	                sourceEndIndex: whitespacePos + 1,
+	                value: value.slice(pos, whitespacePos + 1)
+	              }
+	            ];
+	          } else {
+	            token.nodes = [];
+	          }
+	          if (token.unclosed && whitespacePos + 1 !== next) {
+	            token.after = "";
+	            token.nodes.push({
+	              type: "space",
+	              sourceIndex: whitespacePos + 1,
+	              sourceEndIndex: next,
+	              value: value.slice(whitespacePos + 1, next)
+	            });
+	          } else {
+	            token.after = value.slice(whitespacePos + 1, next);
+	            token.sourceEndIndex = next;
+	          }
+	        } else {
+	          token.after = "";
+	          token.nodes = [];
+	        }
+	        pos = next + 1;
+	        token.sourceEndIndex = token.unclosed ? next : pos;
+	        code = value.charCodeAt(pos);
+	        tokens.push(token);
+	      } else {
+	        balanced += 1;
+	        token.after = "";
+	        token.sourceEndIndex = pos + 1;
+	        tokens.push(token);
+	        stack.push(token);
+	        tokens = token.nodes = [];
+	        parent = token;
+	      }
+	      name = "";
+
+	      // Close parentheses
+	    } else if (closeParentheses === code && balanced) {
+	      pos += 1;
+	      code = value.charCodeAt(pos);
+
+	      parent.after = after;
+	      parent.sourceEndIndex += after.length;
+	      after = "";
+	      balanced -= 1;
+	      stack[stack.length - 1].sourceEndIndex = pos;
+	      stack.pop();
+	      parent = stack[balanced];
+	      tokens = parent.nodes;
+
+	      // Words
+	    } else {
+	      next = pos;
+	      do {
+	        if (code === backslash) {
+	          next += 1;
+	        }
+	        next += 1;
+	        code = value.charCodeAt(next);
+	      } while (
+	        next < max &&
+	        !(
+	          code <= 32 ||
+	          code === singleQuote ||
+	          code === doubleQuote ||
+	          code === comma ||
+	          code === colon ||
+	          code === slash ||
+	          code === openParentheses ||
+	          (code === star &&
+	            parent &&
+	            parent.type === "function" &&
+	            parent.value === "calc") ||
+	          (code === slash &&
+	            parent.type === "function" &&
+	            parent.value === "calc") ||
+	          (code === closeParentheses && balanced)
+	        )
+	      );
+	      token = value.slice(pos, next);
+
+	      if (openParentheses === code) {
+	        name = token;
+	      } else if (
+	        (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) &&
+	        plus === token.charCodeAt(1) &&
+	        isUnicodeRange.test(token.slice(2))
+	      ) {
+	        tokens.push({
+	          type: "unicode-range",
+	          sourceIndex: pos,
+	          sourceEndIndex: next,
+	          value: token
+	        });
+	      } else {
+	        tokens.push({
+	          type: "word",
+	          sourceIndex: pos,
+	          sourceEndIndex: next,
+	          value: token
+	        });
+	      }
+
+	      pos = next;
+	    }
+	  }
+
+	  for (pos = stack.length - 1; pos; pos -= 1) {
+	    stack[pos].unclosed = true;
+	    stack[pos].sourceEndIndex = value.length;
+	  }
+
+	  return stack[0].nodes;
+	};
+	return parse;
+}
+
+var walk;
+var hasRequiredWalk;
+
+function requireWalk () {
+	if (hasRequiredWalk) return walk;
+	hasRequiredWalk = 1;
+	walk = function walk(nodes, cb, bubble) {
+	  var i, max, node, result;
+
+	  for (i = 0, max = nodes.length; i < max; i += 1) {
+	    node = nodes[i];
+	    if (!bubble) {
+	      result = cb(node, i, nodes);
+	    }
+
+	    if (
+	      result !== false &&
+	      node.type === "function" &&
+	      Array.isArray(node.nodes)
+	    ) {
+	      walk(node.nodes, cb, bubble);
+	    }
+
+	    if (bubble) {
+	      cb(node, i, nodes);
+	    }
+	  }
+	};
+	return walk;
+}
+
+var stringify_1;
+var hasRequiredStringify;
+
+function requireStringify () {
+	if (hasRequiredStringify) return stringify_1;
+	hasRequiredStringify = 1;
+	function stringifyNode(node, custom) {
+	  var type = node.type;
+	  var value = node.value;
+	  var buf;
+	  var customResult;
+
+	  if (custom && (customResult = custom(node)) !== undefined) {
+	    return customResult;
+	  } else if (type === "word" || type === "space") {
+	    return value;
+	  } else if (type === "string") {
+	    buf = node.quote || "";
+	    return buf + value + (node.unclosed ? "" : buf);
+	  } else if (type === "comment") {
+	    return "/*" + value + (node.unclosed ? "" : "*/");
+	  } else if (type === "div") {
+	    return (node.before || "") + value + (node.after || "");
+	  } else if (Array.isArray(node.nodes)) {
+	    buf = stringify(node.nodes, custom);
+	    if (type !== "function") {
+	      return buf;
+	    }
+	    return (
+	      value +
+	      "(" +
+	      (node.before || "") +
+	      buf +
+	      (node.after || "") +
+	      (node.unclosed ? "" : ")")
+	    );
+	  }
+	  return value;
+	}
+
+	function stringify(nodes, custom) {
+	  var result, i;
+
+	  if (Array.isArray(nodes)) {
+	    result = "";
+	    for (i = nodes.length - 1; ~i; i -= 1) {
+	      result = stringifyNode(nodes[i], custom) + result;
+	    }
+	    return result;
+	  }
+	  return stringifyNode(nodes, custom);
+	}
+
+	stringify_1 = stringify;
+	return stringify_1;
+}
+
+var unit;
+var hasRequiredUnit;
+
+function requireUnit () {
+	if (hasRequiredUnit) return unit;
+	hasRequiredUnit = 1;
+	var minus = "-".charCodeAt(0);
+	var plus = "+".charCodeAt(0);
+	var dot = ".".charCodeAt(0);
+	var exp = "e".charCodeAt(0);
+	var EXP = "E".charCodeAt(0);
+
+	// Check if three code points would start a number
+	// https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+	function likeNumber(value) {
+	  var code = value.charCodeAt(0);
+	  var nextCode;
+
+	  if (code === plus || code === minus) {
+	    nextCode = value.charCodeAt(1);
+
+	    if (nextCode >= 48 && nextCode <= 57) {
+	      return true;
+	    }
+
+	    var nextNextCode = value.charCodeAt(2);
+
+	    if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  if (code === dot) {
+	    nextCode = value.charCodeAt(1);
+
+	    if (nextCode >= 48 && nextCode <= 57) {
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  if (code >= 48 && code <= 57) {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	// Consume a number
+	// https://www.w3.org/TR/css-syntax-3/#consume-number
+	unit = function(value) {
+	  var pos = 0;
+	  var length = value.length;
+	  var code;
+	  var nextCode;
+	  var nextNextCode;
+
+	  if (length === 0 || !likeNumber(value)) {
+	    return false;
+	  }
+
+	  code = value.charCodeAt(pos);
+
+	  if (code === plus || code === minus) {
+	    pos++;
+	  }
+
+	  while (pos < length) {
+	    code = value.charCodeAt(pos);
+
+	    if (code < 48 || code > 57) {
+	      break;
+	    }
+
+	    pos += 1;
+	  }
+
+	  code = value.charCodeAt(pos);
+	  nextCode = value.charCodeAt(pos + 1);
+
+	  if (code === dot && nextCode >= 48 && nextCode <= 57) {
+	    pos += 2;
+
+	    while (pos < length) {
+	      code = value.charCodeAt(pos);
+
+	      if (code < 48 || code > 57) {
+	        break;
+	      }
+
+	      pos += 1;
+	    }
+	  }
+
+	  code = value.charCodeAt(pos);
+	  nextCode = value.charCodeAt(pos + 1);
+	  nextNextCode = value.charCodeAt(pos + 2);
+
+	  if (
+	    (code === exp || code === EXP) &&
+	    ((nextCode >= 48 && nextCode <= 57) ||
+	      ((nextCode === plus || nextCode === minus) &&
+	        nextNextCode >= 48 &&
+	        nextNextCode <= 57))
+	  ) {
+	    pos += nextCode === plus || nextCode === minus ? 3 : 2;
+
+	    while (pos < length) {
+	      code = value.charCodeAt(pos);
+
+	      if (code < 48 || code > 57) {
+	        break;
+	      }
+
+	      pos += 1;
+	    }
+	  }
+
+	  return {
+	    number: value.slice(0, pos),
+	    unit: value.slice(pos)
+	  };
+	};
+	return unit;
+}
+
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	var parse = requireParse();
+	var walk = requireWalk();
+	var stringify = requireStringify();
+
+	function ValueParser(value) {
+	  if (this instanceof ValueParser) {
+	    this.nodes = parse(value);
+	    return this;
+	  }
+	  return new ValueParser(value);
+	}
+
+	ValueParser.prototype.toString = function() {
+	  return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+	};
+
+	ValueParser.prototype.walk = function(cb, bubble) {
+	  walk(this.nodes, cb, bubble);
+	  return this;
+	};
+
+	ValueParser.unit = requireUnit();
+
+	ValueParser.walk = walk;
+
+	ValueParser.stringify = stringify;
+
+	lib = ValueParser;
+	return lib;
+}
+
+export { requireLib as r };

package/dist/node/cli.js

@@ -2,22 +2,19 @@ import path from 'node:path';
 import fs__default from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { K as colors, E as createLogger, r as resolveConfig } from './chunks/dep-BHXIdTzn.js';
+import { K as colors, E as createLogger, r as resolveConfig } from './chunks/dep-Cpgpmu8-.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 import 'node:url';
 import 'node:util';
 import 'node:module';
-import 'tty';
 import 'esbuild';
 import 'path';
 import 'fs';
-import 'node:events';
-import 'node:stream';
-import 'node:string_decoder';
 import 'node:child_process';
 import 'node:http';
 import 'node:https';
+import 'tty';
 import 'util';
 import 'net';
 import 'url';
@@ -31,12 +28,14 @@ import 'node:dns';
 import 'vite/module-runner';
 import 'rollup/parseAst';
 import 'node:readline';
+import 'node:process';
+import 'node:buffer';
+import 'node:events';
 import 'crypto';
 import 'module';
 import 'node:assert';
 import 'node:v8';
 import 'node:worker_threads';
-import 'node:buffer';
 import 'zlib';
 import 'buffer';
 import 'https';
@@ -705,10 +704,15 @@ function cleanGlobalCLIOptions(options) {
   delete ret.filter;
   delete ret.m;
   delete ret.mode;
+  delete ret.w;
   if ("sourcemap" in ret) {
     const sourcemap = ret.sourcemap;
     ret.sourcemap = sourcemap === "true" ? true : sourcemap === "false" ? false : ret.sourcemap;
   }
+  if ("watch" in ret) {
+    const watch = ret.watch;
+    ret.watch = watch ? {} : void 0;
+  }
   return ret;
 }
 function cleanBuilderCLIOptions(options) {
@@ -736,7 +740,7 @@ cli.command("[root]", "start dev server").alias("serve").alias("dev").option("--
   `[boolean] force the optimizer to ignore the cache and re-bundle`
 ).action(async (root, options) => {
   filterDuplicateOptions(options);
-  const { createServer } = await import('./chunks/dep-BHXIdTzn.js').then(function (n) { return n.O; });
+  const { createServer } = await import('./chunks/dep-Cpgpmu8-.js').then(function (n) { return n.O; });
   try {
     const server = await createServer({
       root,
@@ -826,10 +830,10 @@ cli.command("build [root]", "build for production").option("--target <target>",
 ).option("--manifest [name]", `[boolean | string] emit build manifest json`).option("--ssrManifest [name]", `[boolean | string] emit ssr manifest json`).option(
   "--emptyOutDir",
   `[boolean] force empty outDir when it's outside of root`
-).option("-w, --watch", `[boolean] rebuilds when modules have changed on disk`).option("--app", `[boolean] same as builder.entireApp`).action(
+).option("-w, --watch", `[boolean] rebuilds when modules have changed on disk`).option("--app", `[boolean] same as \`builder: {}\``).action(
   async (root, options) => {
     filterDuplicateOptions(options);
-    const build = await import('./chunks/dep-BHXIdTzn.js').then(function (n) { return n.P; });
+    const { createBuilder } = await import('./chunks/dep-Cpgpmu8-.js').then(function (n) { return n.P; });
     const buildOptions = cleanGlobalCLIOptions(
       cleanBuilderCLIOptions(options)
     );
@@ -842,30 +846,10 @@ cli.command("build [root]", "build for production").option("--target <target>",
         logLevel: options.logLevel,
         clearScreen: options.clearScreen,
         build: buildOptions,
-        ...options.app ? { builder: { entireApp: true } } : {}
+        ...options.app ? { builder: {} } : {}
       };
-      const patchConfig = (resolved) => {
-        if (resolved.builder.entireApp) {
-          return;
-        }
-        const environmentName = resolved.build.ssr ? "ssr" : "client";
-        resolved.build = {
-          ...resolved.environments[environmentName].build
-        };
-      };
-      const config = await build.resolveConfigToBuild(
-        inlineConfig,
-        patchConfig
-      );
-      if (config.builder.entireApp) {
-        const builder = await build.createBuilderWithResolvedConfig(
-          inlineConfig,
-          config
-        );
-        await builder.buildApp();
-      } else {
-        await build.buildWithResolvedConfig(config);
-      }
+      const builder = await createBuilder(inlineConfig, null);
+      await builder.buildApp();
     } catch (e) {
       createLogger(options.logLevel).error(
         colors.red(`error during build:
@@ -884,7 +868,7 @@ cli.command("optimize [root]", "pre-bundle dependencies").option(
 ).action(
   async (root, options) => {
     filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-BHXIdTzn.js').then(function (n) { return n.N; });
+    const { optimizeDeps } = await import('./chunks/dep-Cpgpmu8-.js').then(function (n) { return n.N; });
     try {
       const config = await resolveConfig(
         {
@@ -910,7 +894,7 @@ ${e.stack}`),
 cli.command("preview [root]", "locally preview production build").option("--host [host]", `[string] specify hostname`, { type: [convertHost] }).option("--port <port>", `[number] specify port`).option("--strictPort", `[boolean] exit if specified port is already in use`).option("--open [path]", `[boolean | string] open browser on startup`).option("--outDir <dir>", `[string] output directory (default: dist)`).action(
   async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-BHXIdTzn.js').then(function (n) { return n.Q; });
+    const { preview } = await import('./chunks/dep-Cpgpmu8-.js').then(function (n) { return n.Q; });
     try {
       const server = await preview({
         root,