Do not normalize all function names to lowercase

This is a prerequisite to add support for mixins, whose name is case-sensitive.

The name of a function in its grammar definition is now processed as an actual
grammar definition rather than just a string directly matched against the input
function name.

Author: cdoublev

lib/parse/grammar.js

@@ -252,30 +252,28 @@ function matchSimpleBlock(block, node, parser) {
  * @returns {object|null}
  */
 function matchFunction(fn, node, parser) {
-    if (fn.types[0] === '<function>') {
-        const { context, definition: { name, value }, input } = node
-        const { functions: { aliases, mappings } } = compatibility
-        if (name && aliases?.get(fn.name) === name) {
-            fn = { ...fn, name }
+    let { name, types, value } = fn
+    if (types[0] !== '<function>') {
+        return null
+    }
+    const { context, definition, input } = node
+    const ctx = { ...context, function: node }
+    if (definition.name) {
+        name = parser.parseCSSValue(name, definition.name, ctx)
+        if (name === null || name instanceof SyntaxError) {
+            return name
         }
-        if (!name || name === fn.name || mappings?.get(fn.name) === name) {
-            if (value) {
-                const match = parser.parseCSSValue(
-                    new Stream(fn.value, input.source),
-                    value,
-                    { ...context, function: node })
-                if (match instanceof SyntaxError) {
-                    return match
-                }
-                if (match) {
-                    return { ...fn, value: match }
-                }
-            } else {
-                return fn
-            }
+        fn = { ...fn, name: name.value }
+    }
+    if (definition.value) {
+        value = new Stream(value, input.source)
+        value = parser.parseCSSValue(value, definition.value, ctx)
+        if (value === null || value instanceof SyntaxError) {
+            return value
         }
+        fn = { ...fn, value }
     }
-    return null
+    return fn
 }
 
 /**

lib/parse/postprocess.js

@@ -787,6 +787,16 @@ function postParseKeyword(keyword, { context, definition: { range } }) {
     if (lowercase === range.toLowerCase()) {
         return { ...keyword, value: lowercase }
     }
+    if (context.function?.definition.name === range) {
+        const { values: { functions: { aliases, mappings } } } = compatibility
+        if (aliases?.get(lowercase) === range) {
+            return { ...keyword, value: range }
+        }
+        if (mappings?.has(lowercase) === range) {
+            return { ...keyword, value: lowercase }
+        }
+        return null
+    }
     const { aliases, mappings } = compatibility.values.keywords[context.declaration?.definition.name] ?? {}
     if (aliases?.get(lowercase) === range) {
         return { ...keyword, value: range }

lib/parse/tokenize.js

@@ -284,7 +284,7 @@ function consumeIdentifierLike(chars) {
             }
             return consumeUrl(chars, identifier)
         }
-        return { end: chars.index + 1, start, types: ['<function-token>'], value: lowercase }
+        return { end: chars.index + 1, start, types: ['<function-token>'], value }
     }
     return identifier
 }

lib/serialize.js

@@ -843,7 +843,7 @@ function serializeFilter({ name, value }) {
  * @returns {string}
  */
 function serializeFunction({ name, value }) {
-    return `${name}(${serializeCSSComponentValue(value, name)})`
+    return `${serializeIdentifier({ value: name })}(${serializeCSSComponentValue(value, name)})`
 }
 
 /**