vite 6.0.0-beta.1 → 6.0.0-beta.10

package/dist/node/chunks/{dep-BZeeNeMJ.js → dep-ifLmJA8Z.js}

@@ -1,19 +1,11 @@
-import { K as commonjsGlobal, J as getDefaultExportFromCjs } from './dep-BZ_CwQkz.js';
-import require$$0__default from 'fs';
+import { O as commonjsGlobal, N as getDefaultExportFromCjs } from './dep-DiRA7B7B.js';
+import require$$0$2 from 'fs';
 import require$$0 from 'postcss';
 import require$$0$1 from 'path';
 import require$$3 from 'crypto';
-import require$$0$2 from 'util';
-import { l as lib } from './dep-IQS-Za7F.js';
+import require$$1 from 'util';
+import { l as lib } from './dep-3RmXg9uo.js';
 
-import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
-import { dirname as __cjs_dirname } from 'node:path';
-import { createRequire as __cjs_createRequire } from 'node:module';
-
-const __filename = __cjs_fileURLToPath(import.meta.url);
-const __dirname = __cjs_dirname(__filename);
-const require = __cjs_createRequire(import.meta.url);
-const __require = require;
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     var e = m[i];
@@ -1327,54 +1319,63 @@ src$3.exports = (options = {}) => {
           });
 
           root.walkDecls(/^composes$/, (declaration) => {
-            const matches = declaration.value.match(matchImports$1);
+            const multiple = declaration.value.split(",");
+            const values = [];
 
-            if (!matches) {
-              return;
-            }
+            multiple.forEach((value) => {
+              const matches = value.trim().match(matchImports$1);
 
-            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;
-
-              let parent = declaration.parent;
-              let parentIndexes = "";
+              if (!matches) {
+                values.push(value);
 
-              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] || {};
+
+                tmpSymbols = symbols.split(/\s+/).map((s) => {
+                  if (!imports[importPath][s]) {
+                    imports[importPath][s] = createImportedName(s, importPath);
+                  }
 
-            declaration.value = tmpSymbols.join(" ");
+                  return imports[importPath][s];
+                });
+              }
+
+              values.push(tmpSymbols.join(" "));
+            });
+
+            declaration.value = values.join(", ");
           });
 
           const importsOrder = topologicalSort(graph, failOnWrongOrder);
@@ -2026,12 +2027,17 @@ function getHashDigest$1(buffer, algorithm, digestType, maxLength) {
     digestType === "base49" ||
     digestType === "base52" ||
     digestType === "base58" ||
-    digestType === "base62"
+    digestType === "base62" ||
+    digestType === "base64safe"
   ) {
-    return encodeBufferToBase(hash.digest(), digestType.substr(4), maxLength);
-  } else {
-    return hash.digest(digestType || "hex").substr(0, maxLength);
+    return encodeBufferToBase(
+      hash.digest(),
+      digestType === "base64safe" ? 64 : digestType.substr(4),
+      maxLength
+    );
   }
+
+  return hash.digest(digestType || "hex").substr(0, maxLength);
 }
 
 var getHashDigest_1 = getHashDigest$1;
@@ -2087,9 +2093,10 @@ function interpolateName$1(loaderContext, name, options = {}) {
       directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
     }
 
-    if (directory.length === 1) {
+    if (directory.length <= 1) {
       directory = "";
-    } else if (directory.length > 1) {
+    } else {
+      // directory.length > 1
       folder = path$1.basename(directory);
     }
   }
@@ -2112,7 +2119,7 @@ function interpolateName$1(loaderContext, name, options = {}) {
       // `hash` and `contenthash` are same in `loader-utils` context
       // let's keep `hash` for backward compatibility
       .replace(
-        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*))?(?::(\d+))?\]/gi,
+        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*(?:safe)?))?(?::(\d+))?\]/gi,
         (all, hashType, digestType, maxLength) =>
           getHashDigest(content, hashType, digestType, parseInt(maxLength, 10))
       );
@@ -3393,7 +3400,7 @@ var attribute$1 = {};
  * For Node.js, simply re-export the core `util.deprecate` function.
  */
 
-var node = require$$0$2.deprecate;
+var node = require$$1.deprecate;
 
 (function (exports) {
 
@@ -4743,7 +4750,7 @@ tokenTypes.combinator = combinator$1;
 	    }
 	    // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
 	    var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
-	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
+	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
 	      var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
 	      if (nodes.length > 0) {
 	        var last = this.current.last;
@@ -5767,9 +5774,19 @@ function localizeNode(rule, mode, localAliasMap) {
               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);
@@ -5838,6 +5855,11 @@ function localizeNode(rule, mode, localAliasMap) {
 
         break;
       }
+      case "nesting": {
+        if (node.value === "&") {
+          context.hasLocals = true;
+        }
+      }
     }
 
     context.lastWasSpacing = false;
@@ -5910,19 +5932,34 @@ function localizeDeclNode(node, context) {
   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,
@@ -5939,57 +5976,80 @@ function localizeDeclaration(declaration, context) {
   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;
 
@@ -6014,6 +6074,7 @@ function localizeDeclaration(declaration, context) {
         localizeNextItem: shouldParseAnimationName && !context.global,
         localAliasMap: context.localAliasMap,
       };
+
       return localizeDeclNode(node, subContext);
     });
 
@@ -6088,10 +6149,12 @@ src$2.exports = (options = {}) => {
               } 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) => {
@@ -6101,6 +6164,44 @@ src$2.exports = (options = {}) => {
                   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") {
@@ -6160,7 +6261,23 @@ const selectorParser = distExports;
 
 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(
@@ -6247,17 +6364,19 @@ const plugin = (options = {}) => {
     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;
 
@@ -6273,23 +6392,35 @@ const plugin = (options = {}) => {
       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(
@@ -6306,7 +6437,7 @@ const plugin = (options = {}) => {
               }
 
               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;
 
@@ -6328,7 +6459,7 @@ const plugin = (options = {}) => {
           /* falls through */
           case "root":
           case "selector": {
-            node.each(traverseNode);
+            node.each((item) => traverseNode(item));
             break;
           }
           case "id":
@@ -6356,32 +6487,39 @@ const plugin = (options = {}) => {
 
         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();
@@ -6433,6 +6571,27 @@ const plugin = (options = {}) => {
         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);
 
@@ -6816,7 +6975,7 @@ function makePlugin(opts) {
   };
 }
 
-var _fs = require$$0__default;
+var _fs = require$$0$2;
 
 var _fs2 = fs;