vite 6.0.0-beta.8 → 6.0.0-beta.9

package/dist/node/chunks/{dep-qU9-vqRp.js → dep-BLfo3Ie2.js}

@@ -1,4 +1,4 @@
-import { M as commonjsGlobal, L as getDefaultExportFromCjs } from './dep-Ddvoc4zx.js';
+import { M as commonjsGlobal, L as getDefaultExportFromCjs } from './dep-CG5ueZZV.js';
 import require$$0$1 from 'fs';
 import require$$0 from 'postcss';
 import sysPath__default from 'path';
@@ -1432,54 +1432,63 @@ function requireSrc$3 () {
 	          });
 
 	          root.walkDecls(/^composes$/, (declaration) => {
-	            const matches = declaration.value.match(matchImports);
+	            const multiple = declaration.value.split(",");
+	            const values = [];
 
-	            if (!matches) {
-	              return;
-	            }
+	            multiple.forEach((value) => {
+	              const matches = value.trim().match(matchImports);
 
-	            let tmpSymbols;
-	            let [
-	              ,
-	              /*match*/ symbols,
-	              doubleQuotePath,
-	              singleQuotePath,
-	              global,
-	            ] = matches;
-
-	            if (global) {
-	              // Composing globals simply means changing these classes to wrap them in global(name)
-	              tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
-	            } else {
-	              const importPath = doubleQuotePath || singleQuotePath;
+	              if (!matches) {
+	                values.push(value);
 
-	              let parent = declaration.parent;
-	              let parentIndexes = "";
-
-	              while (parent.type !== "root") {
-	                parentIndexes =
-	                  parent.parent.index(parent) + "_" + parentIndexes;
-	                parent = parent.parent;
+	                return;
 	              }
 
-	              const { selector } = declaration.parent;
-	              const parentRule = `_${parentIndexes}${selector}`;
-
-	              addImportToGraph(importPath, parentRule, graph, visited);
+	              let tmpSymbols;
+	              let [
+	                ,
+	                /*match*/ symbols,
+	                doubleQuotePath,
+	                singleQuotePath,
+	                global,
+	              ] = matches;
+
+	              if (global) {
+	                // Composing globals simply means changing these classes to wrap them in global(name)
+	                tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
+	              } else {
+	                const importPath = doubleQuotePath || singleQuotePath;
 
-	              importDecls[importPath] = declaration;
-	              imports[importPath] = imports[importPath] || {};
+	                let parent = declaration.parent;
+	                let parentIndexes = "";
 
-	              tmpSymbols = symbols.split(/\s+/).map((s) => {
-	                if (!imports[importPath][s]) {
-	                  imports[importPath][s] = createImportedName(s, importPath);
+	                while (parent.type !== "root") {
+	                  parentIndexes =
+	                    parent.parent.index(parent) + "_" + parentIndexes;
+	                  parent = parent.parent;
 	                }
 
-	                return imports[importPath][s];
-	              });
-	            }
+	                const { selector } = declaration.parent;
+	                const parentRule = `_${parentIndexes}${selector}`;
+
+	                addImportToGraph(importPath, parentRule, graph, visited);
+
+	                importDecls[importPath] = declaration;
+	                imports[importPath] = imports[importPath] || {};
 
-	            declaration.value = tmpSymbols.join(" ");
+	                tmpSymbols = symbols.split(/\s+/).map((s) => {
+	                  if (!imports[importPath][s]) {
+	                    imports[importPath][s] = createImportedName(s, importPath);
+	                  }
+
+	                  return imports[importPath][s];
+	                });
+	              }
+
+	              values.push(tmpSymbols.join(" "));
+	            });
+
+	            declaration.value = values.join(", ");
 	          });
 
 	          const importsOrder = topologicalSort(graph, failOnWrongOrder);
@@ -6093,9 +6102,19 @@ function requireSrc$2 () {
 	              hasLocals: false,
 	              explicit: context.explicit,
 	            };
-	            newNodes = node.map((childNode) =>
-	              transform(childNode, childContext)
-	            );
+	            newNodes = node.map((childNode) => {
+	              const newContext = {
+	                ...childContext,
+	                enforceNoSpacing: false,
+	              };
+
+	              const result = transform(childNode, newContext);
+
+	              childContext.global = newContext.global;
+	              childContext.hasLocals = newContext.hasLocals;
+
+	              return result;
+	            });
 
 	            node = node.clone();
 	            node.nodes = normalizeNodeArray(newNodes);
@@ -6164,6 +6183,11 @@ function requireSrc$2 () {
 
 	        break;
 	      }
+	      case "nesting": {
+	        if (node.value === "&") {
+	          context.hasLocals = true;
+	        }
+	      }
 	    }
 
 	    context.lastWasSpacing = false;
@@ -6236,19 +6260,34 @@ function requireSrc$2 () {
 	  return node;
 	}
 
-	function isWordAFunctionArgument(wordNode, functionNode) {
-	  return functionNode
-	    ? functionNode.nodes.some(
-	        (functionNodeChild) =>
-	          functionNodeChild.sourceIndex === wordNode.sourceIndex
-	      )
-	    : false;
-	}
+	// `none` is special value, other is global values
+	const specialKeywords = [
+	  "none",
+	  "inherit",
+	  "initial",
+	  "revert",
+	  "revert-layer",
+	  "unset",
+	];
 
 	function localizeDeclarationValues(localize, declaration, context) {
 	  const valueNodes = valueParser(declaration.value);
 
 	  valueNodes.walk((node, index, nodes) => {
+	    if (
+	      node.type === "function" &&
+	      (node.value.toLowerCase() === "var" || node.value.toLowerCase() === "env")
+	    ) {
+	      return false;
+	    }
+
+	    if (
+	      node.type === "word" &&
+	      specialKeywords.includes(node.value.toLowerCase())
+	    ) {
+	      return;
+	    }
+
 	    const subContext = {
 	      options: context.options,
 	      global: context.global,
@@ -6265,57 +6304,80 @@ function requireSrc$2 () {
 	  const isAnimation = /animation$/i.test(declaration.prop);
 
 	  if (isAnimation) {
-	    const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;
+	    // letter
+	    // An uppercase letter or a lowercase letter.
+	    //
+	    // ident-start code point
+	    // A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+	    //
+	    // ident code point
+	    // An ident-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+
+	    // We don't validate `hex digits`, because we don't need it, it is work of linters.
+	    const validIdent =
+	      /^-?([a-z\u0080-\uFFFF_]|(\\[^\r\n\f])|-(?![0-9]))((\\[^\r\n\f])|[a-z\u0080-\uFFFF_0-9-])*$/i;
 
 	    /*
 	    The spec defines some keywords that you can use to describe properties such as the timing
 	    function. These are still valid animation names, so as long as there is a property that accepts
 	    a keyword, it is given priority. Only when all the properties that can take a keyword are
 	    exhausted can the animation name be set to the keyword. I.e.
-	  
+
 	    animation: infinite infinite;
-	  
+
 	    The animation will repeat an infinite number of times from the first argument, and will have an
 	    animation name of infinite from the second.
 	    */
 	    const animationKeywords = {
+	      // animation-direction
+	      $normal: 1,
+	      $reverse: 1,
 	      $alternate: 1,
 	      "$alternate-reverse": 1,
+	      // animation-fill-mode
+	      $forwards: 1,
 	      $backwards: 1,
 	      $both: 1,
+	      // animation-iteration-count
+	      $infinite: 1,
+	      // animation-play-state
+	      $paused: 1,
+	      $running: 1,
+	      // animation-timing-function
 	      $ease: 1,
 	      "$ease-in": 1,
-	      "$ease-in-out": 1,
 	      "$ease-out": 1,
-	      $forwards: 1,
-	      $infinite: 1,
+	      "$ease-in-out": 1,
 	      $linear: 1,
-	      $none: Infinity, // No matter how many times you write none, it will never be an animation name
-	      $normal: 1,
-	      $paused: 1,
-	      $reverse: 1,
-	      $running: 1,
 	      "$step-end": 1,
 	      "$step-start": 1,
+	      // Special
+	      $none: Infinity, // No matter how many times you write none, it will never be an animation name
+	      // Global values
 	      $initial: Infinity,
 	      $inherit: Infinity,
 	      $unset: Infinity,
+	      $revert: Infinity,
+	      "$revert-layer": Infinity,
 	    };
 	    let parsedAnimationKeywords = {};
-	    let stepsFunctionNode = null;
 	    const valueNodes = valueParser(declaration.value).walk((node) => {
-	      /* If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh. */
+	      // If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh.
 	      if (node.type === "div") {
 	        parsedAnimationKeywords = {};
+
+	        return;
+	      }
+	      // Do not handle nested functions
+	      else if (node.type === "function") {
+	        return false;
 	      }
-	      if (node.type === "function" && node.value.toLowerCase() === "steps") {
-	        stepsFunctionNode = node;
+	      // Ignore all except word
+	      else if (node.type !== "word") {
+	        return;
 	      }
-	      const value =
-	        node.type === "word" &&
-	        !isWordAFunctionArgument(node, stepsFunctionNode)
-	          ? node.value.toLowerCase()
-	          : null;
+
+	      const value = node.type === "word" ? node.value.toLowerCase() : null;
 
 	      let shouldParseAnimationName = false;
 
@@ -6340,6 +6402,7 @@ function requireSrc$2 () {
 	        localizeNextItem: shouldParseAnimationName && !context.global,
 	        localAliasMap: context.localAliasMap,
 	      };
+
 	      return localizeDeclNode(node, subContext);
 	    });
 
@@ -6414,10 +6477,12 @@ function requireSrc$2 () {
 	              } else if (localMatch) {
 	                atRule.params = localMatch[0];
 	                globalKeyframes = false;
-	              } else if (!globalMode) {
-	                if (atRule.params && !localAliasMap.has(atRule.params)) {
-	                  atRule.params = ":local(" + atRule.params + ")";
-	                }
+	              } else if (
+	                atRule.params &&
+	                !globalMode &&
+	                !localAliasMap.has(atRule.params)
+	              ) {
+	                atRule.params = ":local(" + atRule.params + ")";
 	              }
 
 	              atRule.walkDecls((declaration) => {
@@ -6427,6 +6492,44 @@ function requireSrc$2 () {
 	                  global: globalKeyframes,
 	                });
 	              });
+	            } else if (/scope$/i.test(atRule.name)) {
+	              if (atRule.params) {
+	                atRule.params = atRule.params
+	                  .split("to")
+	                  .map((item) => {
+	                    const selector = item.trim().slice(1, -1).trim();
+	                    const context = localizeNode(
+	                      selector,
+	                      options.mode,
+	                      localAliasMap
+	                    );
+
+	                    context.options = options;
+	                    context.localAliasMap = localAliasMap;
+
+	                    if (pureMode && context.hasPureGlobals) {
+	                      throw atRule.error(
+	                        'Selector in at-rule"' +
+	                          selector +
+	                          '" is not pure ' +
+	                          "(pure selectors must contain at least one local class or id)"
+	                      );
+	                    }
+
+	                    return `(${context.selector})`;
+	                  })
+	                  .join(" to ");
+	              }
+
+	              atRule.nodes.forEach((declaration) => {
+	                if (declaration.type === "decl") {
+	                  localizeDeclaration(declaration, {
+	                    localAliasMap,
+	                    options: options,
+	                    global: globalMode,
+	                  });
+	                }
+	              });
 	            } else if (atRule.nodes) {
 	              atRule.nodes.forEach((declaration) => {
 	                if (declaration.type === "decl") {
@@ -6493,7 +6596,23 @@ function requireSrc$1 () {
 
 	const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-	function getSingleLocalNamesForComposes(root) {
+	function isNestedRule(rule) {
+	  if (!rule.parent || rule.parent.type === "root") {
+	    return false;
+	  }
+
+	  if (rule.parent.type === "rule") {
+	    return true;
+	  }
+
+	  return isNestedRule(rule.parent);
+	}
+
+	function getSingleLocalNamesForComposes(root, rule) {
+	  if (isNestedRule(rule)) {
+	    throw new Error(`composition is not allowed in nested rule \n\n${rule}`);
+	  }
+
 	  return root.nodes.map((node) => {
 	    if (node.type !== "selector" || node.nodes.length !== 1) {
 	      throw new Error(
@@ -6580,17 +6699,19 @@ function requireSrc$1 () {
 	    Once(root, { rule }) {
 	      const exports = Object.create(null);
 
-	      function exportScopedName(name, rawName) {
+	      function exportScopedName(name, rawName, node) {
 	        const scopedName = generateScopedName(
 	          rawName ? rawName : name,
 	          root.source.input.from,
-	          root.source.input.css
+	          root.source.input.css,
+	          node
 	        );
 	        const exportEntry = generateExportEntry(
 	          rawName ? rawName : name,
 	          scopedName,
 	          root.source.input.from,
-	          root.source.input.css
+	          root.source.input.css,
+	          node
 	        );
 	        const { key, value } = exportEntry;
 
@@ -6606,23 +6727,35 @@ function requireSrc$1 () {
 	      function localizeNode(node) {
 	        switch (node.type) {
 	          case "selector":
-	            node.nodes = node.map(localizeNode);
+	            node.nodes = node.map((item) => localizeNode(item));
 	            return node;
 	          case "class":
 	            return selectorParser.className({
 	              value: exportScopedName(
 	                node.value,
-	                node.raws && node.raws.value ? node.raws.value : null
+	                node.raws && node.raws.value ? node.raws.value : null,
+	                node
 	              ),
 	            });
 	          case "id": {
 	            return selectorParser.id({
 	              value: exportScopedName(
 	                node.value,
-	                node.raws && node.raws.value ? node.raws.value : null
+	                node.raws && node.raws.value ? node.raws.value : null,
+	                node
 	              ),
 	            });
 	          }
+	          case "attribute": {
+	            if (node.attribute === "class" && node.operator === "=") {
+	              return selectorParser.attribute({
+	                attribute: node.attribute,
+	                operator: node.operator,
+	                quoteMark: "'",
+	                value: exportScopedName(node.value, null, null),
+	              });
+	            }
+	          }
 	        }
 
 	        throw new Error(
@@ -6639,7 +6772,7 @@ function requireSrc$1 () {
 	              }
 
 	              const selector = localizeNode(node.first);
-	              // move the spaces that were around the psuedo selector to the first
+	              // move the spaces that were around the pseudo selector to the first
 	              // non-container node
 	              selector.first.spaces = node.spaces;
 
@@ -6661,7 +6794,7 @@ function requireSrc$1 () {
 	          /* falls through */
 	          case "root":
 	          case "selector": {
-	            node.each(traverseNode);
+	            node.each((item) => traverseNode(item));
 	            break;
 	          }
 	          case "id":
@@ -6689,32 +6822,39 @@ function requireSrc$1 () {
 
 	        rule.selector = traverseNode(parsedSelector.clone()).toString();
 
-	        rule.walkDecls(/composes|compose-with/i, (decl) => {
-	          const localNames = getSingleLocalNamesForComposes(parsedSelector);
-	          const classes = decl.value.split(/\s+/);
+	        rule.walkDecls(/^(composes|compose-with)$/i, (decl) => {
+	          const localNames = getSingleLocalNamesForComposes(
+	            parsedSelector,
+	            decl.parent
+	          );
+	          const multiple = decl.value.split(",");
 
-	          classes.forEach((className) => {
-	            const global = /^global\(([^)]+)\)$/.exec(className);
+	          multiple.forEach((value) => {
+	            const classes = value.trim().split(/\s+/);
 
-	            if (global) {
-	              localNames.forEach((exportedName) => {
-	                exports[exportedName].push(global[1]);
-	              });
-	            } else if (hasOwnProperty.call(importedNames, className)) {
-	              localNames.forEach((exportedName) => {
-	                exports[exportedName].push(className);
-	              });
-	            } else if (hasOwnProperty.call(exports, className)) {
-	              localNames.forEach((exportedName) => {
-	                exports[className].forEach((item) => {
-	                  exports[exportedName].push(item);
+	            classes.forEach((className) => {
+	              const global = /^global\(([^)]+)\)$/.exec(className);
+
+	              if (global) {
+	                localNames.forEach((exportedName) => {
+	                  exports[exportedName].push(global[1]);
 	                });
-	              });
-	            } else {
-	              throw decl.error(
-	                `referenced class name "${className}" in ${decl.prop} not found`
-	              );
-	            }
+	              } else if (hasOwnProperty.call(importedNames, className)) {
+	                localNames.forEach((exportedName) => {
+	                  exports[exportedName].push(className);
+	                });
+	              } else if (hasOwnProperty.call(exports, className)) {
+	                localNames.forEach((exportedName) => {
+	                  exports[className].forEach((item) => {
+	                    exports[exportedName].push(item);
+	                  });
+	                });
+	              } else {
+	                throw decl.error(
+	                  `referenced class name "${className}" in ${decl.prop} not found`
+	                );
+	              }
+	            });
 	          });
 
 	          decl.remove();
@@ -6766,6 +6906,27 @@ function requireSrc$1 () {
 	        atRule.params = exportScopedName(localMatch[1]);
 	      });
 
+	      root.walkAtRules(/scope$/i, (atRule) => {
+	        if (atRule.params) {
+	          atRule.params = atRule.params
+	            .split("to")
+	            .map((item) => {
+	              const selector = item.trim().slice(1, -1).trim();
+
+	              const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(selector);
+
+	              if (!localMatch) {
+	                return `(${selector})`;
+	              }
+
+	              let parsedSelector = selectorParser().astSync(selector);
+
+	              return `(${traverseNode(parsedSelector).toString()})`;
+	            })
+	            .join(" to ");
+	        }
+	      });
+
 	      // If we found any :locals, insert an :export rule
 	      const exportedNames = Object.keys(exports);