feat: converting from starting php repo

Author: AaronLayton

README.md

@@ -1,6 +1,8 @@
 # tailwind-merge-nuget
 A TailwindCSS class merge utility similar to Shadcn UI / Tailwind Merge
 
+https://github.com/YieldStudio/tailwind-merge-php/tree/main
+
 **NOTE** this is a __very__ simple implementation of Tailwind class merging and likely has many, many edge cases that are not covered.   It is a simple implementation that works for my current use case. If you find a bug, please submit a PR with a test case and I will strive to update this package. 
 
 ## Usage

TailwindMerge.Tests/ValidatorTests.cs

@@ -0,0 +1,199 @@
+namespace TailwindMerge.Tests;
+using TailwindMerge; // Replace with the namespace of your class library
+
+public class ValidatorTests
+{
+    [Fact]
+    public void IsLengthTests()
+    {
+        Assert.True(Validators.IsLength("1"));
+        Assert.True(Validators.IsLength("1023713"));
+        Assert.True(Validators.IsLength("1.5"));
+        Assert.True(Validators.IsLength("1231.503761"));
+        Assert.True(Validators.IsLength("px"));
+        Assert.True(Validators.IsLength("full"));
+        Assert.True(Validators.IsLength("screen"));
+        Assert.True(Validators.IsLength("1/2"));
+        Assert.True(Validators.IsLength("123/345"));
+
+        Assert.False(Validators.IsLength("[3.7%]"));
+        Assert.False(Validators.IsLength("[481px]"));
+        Assert.False(Validators.IsLength("[19.1rem]"));
+        Assert.False(Validators.IsLength("[50vw]"));
+        Assert.False(Validators.IsLength("[56vh]"));
+        Assert.False(Validators.IsLength("[length:var(--arbitrary)]"));
+        Assert.False(Validators.IsLength("1d5"));
+        Assert.False(Validators.IsLength("[1]"));
+        Assert.False(Validators.IsLength("[12px"));
+        Assert.False(Validators.IsLength("12px]"));
+        Assert.False(Validators.IsLength("one"));
+    }
+
+    [Fact]
+    public void IsArbitraryLengthTests()
+    {
+        Assert.True(Validators.IsArbitraryLength("[3.7%]"));
+        Assert.True(Validators.IsArbitraryLength("[481px]"));
+        Assert.True(Validators.IsArbitraryLength("[19.1rem]"));
+        Assert.True(Validators.IsArbitraryLength("[50vw]"));
+        Assert.True(Validators.IsArbitraryLength("[56vh]"));
+        Assert.True(Validators.IsArbitraryLength("[length:var(--arbitrary)]"));
+
+        Assert.False(Validators.IsArbitraryLength("1"));
+        Assert.False(Validators.IsArbitraryLength("3px"));
+        Assert.False(Validators.IsArbitraryLength("1d5"));
+        Assert.False(Validators.IsArbitraryLength("[1]"));
+        Assert.False(Validators.IsArbitraryLength("[12px"));
+        Assert.False(Validators.IsArbitraryLength("12px]"));
+        Assert.False(Validators.IsArbitraryLength("one"));
+    }
+
+    [Fact]
+    public void IsIntegerTests()
+    {
+        Assert.True(Validators.IsInteger("1"));
+        Assert.True(Validators.IsInteger("123"));
+        Assert.True(Validators.IsInteger("8312"));
+
+        Assert.False(Validators.IsInteger("[8312]"));
+        Assert.False(Validators.IsInteger("[2]"));
+        Assert.False(Validators.IsInteger("[8312px]"));
+        Assert.False(Validators.IsInteger("[8312%]"));
+        Assert.False(Validators.IsInteger("[8312rem]"));
+        Assert.False(Validators.IsInteger("8312.2"));
+        Assert.False(Validators.IsInteger("1.2"));
+        Assert.False(Validators.IsInteger("one"));
+        Assert.False(Validators.IsInteger("1/2"));
+        Assert.False(Validators.IsInteger("1%"));
+        Assert.False(Validators.IsInteger("1px"));
+    }
+
+    [Fact]
+    public void IsArbitraryValueTests()
+    {
+        Assert.True(Validators.IsArbitraryValue("[1]"));
+        Assert.True(Validators.IsArbitraryValue("[bla]"));
+        Assert.True(Validators.IsArbitraryValue("[not-an-arbitrary-value?]"));
+        Assert.True(Validators.IsArbitraryValue("[auto,auto,minmax(0,1fr),calc(100vw-50%)]"));
+
+        Assert.False(Validators.IsArbitraryValue("[]"));
+        Assert.False(Validators.IsArbitraryValue("[1"));
+        Assert.False(Validators.IsArbitraryValue("1]"));
+        Assert.False(Validators.IsArbitraryValue("1"));
+        Assert.False(Validators.IsArbitraryValue("one"));
+        Assert.False(Validators.IsArbitraryValue("o[n]e"));
+    }
+
+    [Fact]
+    public void IsAnyTests()
+    {
+        Assert.True(Validators.IsAny());
+        // TypeScript specific @ts-expect-error tests are not applicable in C#
+    }
+
+    [Fact]
+    public void IsTshirtSizeTests()
+    {
+        Assert.True(Validators.IsTshirtSize("xs"));
+        Assert.True(Validators.IsTshirtSize("sm"));
+        Assert.True(Validators.IsTshirtSize("md"));
+        Assert.True(Validators.IsTshirtSize("lg"));
+        Assert.True(Validators.IsTshirtSize("xl"));
+        Assert.True(Validators.IsTshirtSize("2xl"));
+        Assert.True(Validators.IsTshirtSize("2.5xl"));
+        Assert.True(Validators.IsTshirtSize("10xl"));
+        Assert.True(Validators.IsTshirtSize("2xs"));
+        Assert.True(Validators.IsTshirtSize("2lg"));
+
+        Assert.False(Validators.IsTshirtSize(""));
+        Assert.False(Validators.IsTshirtSize("hello"));
+        Assert.False(Validators.IsTshirtSize("1"));
+        Assert.False(Validators.IsTshirtSize("xl3"));
+        Assert.False(Validators.IsTshirtSize("2xl3"));
+        Assert.False(Validators.IsTshirtSize("-xl"));
+        Assert.False(Validators.IsTshirtSize("[sm]"));
+    }
+
+    [Fact]
+    public void IsArbitrarySizeTests()
+    {
+        Assert.True(Validators.IsArbitrarySize("[size:2px]"));
+        Assert.True(Validators.IsArbitrarySize("[size:bla]"));
+        Assert.True(Validators.IsArbitrarySize("[length:bla]"));
+        Assert.True(Validators.IsArbitrarySize("[percentage:bla]"));
+
+        Assert.False(Validators.IsArbitrarySize("[2px]"));
+        Assert.False(Validators.IsArbitrarySize("[bla]"));
+        Assert.False(Validators.IsArbitrarySize("size:2px"));
+    }
+
+    [Fact]
+    public void IsArbitraryPositionTests()
+    {
+        Assert.True(Validators.IsArbitraryPosition("[position:2px]"));
+        Assert.True(Validators.IsArbitraryPosition("[position:bla]"));
+
+        Assert.False(Validators.IsArbitraryPosition("[2px]"));
+        Assert.False(Validators.IsArbitraryPosition("[bla]"));
+        Assert.False(Validators.IsArbitraryPosition("position:2px"));
+    }
+
+    [Fact]
+    public void IsArbitraryImageTests()
+    {
+        Assert.True(Validators.IsArbitraryImage("[url:var(--my-url)]"));
+        Assert.True(Validators.IsArbitraryImage("[url(something)]"));
+        Assert.True(Validators.IsArbitraryImage("[url:bla]"));
+        Assert.True(Validators.IsArbitraryImage("[image:bla]"));
+        Assert.True(Validators.IsArbitraryImage("[linear-gradient(something)]"));
+        Assert.True(Validators.IsArbitraryImage("[repeating-conic-gradient(something)]"));
+
+        Assert.False(Validators.IsArbitraryImage("[var(--my-url)]"));
+        Assert.False(Validators.IsArbitraryImage("[bla]"));
+        Assert.False(Validators.IsArbitraryImage("url:2px"));
+        Assert.False(Validators.IsArbitraryImage("url(2px)"));
+    }
+
+    [Fact]
+    public void IsArbitraryNumberTests()
+    {
+        Assert.True(Validators.IsArbitraryNumber("[number:black]"));
+        Assert.True(Validators.IsArbitraryNumber("[number:bla]"));
+        Assert.True(Validators.IsArbitraryNumber("[number:230]"));
+        Assert.True(Validators.IsArbitraryNumber("[450]"));
+
+        Assert.False(Validators.IsArbitraryNumber("[2px]"));
+        Assert.False(Validators.IsArbitraryNumber("[bla]"));
+        Assert.False(Validators.IsArbitraryNumber("[black]"));
+        Assert.False(Validators.IsArbitraryNumber("black"));
+        Assert.False(Validators.IsArbitraryNumber("450"));
+    }
+
+    [Fact]
+    public void IsArbitraryShadowTests()
+    {
+        Assert.True(Validators.IsArbitraryShadow("[0_35px_60px_-15px_rgba(0,0,0,0.3)]"));
+        Assert.True(Validators.IsArbitraryShadow("[0_0_#00f]"));
+        Assert.True(Validators.IsArbitraryShadow("[.5rem_0_rgba(5,5,5,5)]"));
+        Assert.True(Validators.IsArbitraryShadow("[-.5rem_0_#123456]"));
+        Assert.True(Validators.IsArbitraryShadow("[0.5rem_-0_#123456]"));
+        Assert.True(Validators.IsArbitraryShadow("[0.5rem_-0.005vh_#123456]"));
+        Assert.True(Validators.IsArbitraryShadow("[0.5rem_-0.005vh]"));
+
+        Assert.False(Validators.IsArbitraryShadow("[rgba(5,5,5,5)]"));
+        Assert.False(Validators.IsArbitraryShadow("[#00f]"));
+        Assert.False(Validators.IsArbitraryShadow("[something-else]"));
+    }
+
+    [Fact]
+    public void IsPercentTests()
+    {
+        Assert.True(Validators.IsPercent("1%"));
+        Assert.True(Validators.IsPercent("100.001%"));
+        Assert.True(Validators.IsPercent(".01%"));
+        Assert.True(Validators.IsPercent("0%"));
+
+        Assert.False(Validators.IsPercent("0"));
+        Assert.False(Validators.IsPercent("one%"));
+    }
+}

TailwindMerge/ClassMapFactory.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using TailwindMerge.Models;
+using TailwindMerge.Interfaces;
+using TailwindMerge.Utilities;
+
+namespace TailwindMerge
+{
+    public abstract class ClassMapFactory
+    {
+        private const string CLASS_PART_SEPARATOR = "-";
+
+        public static ClassPart Create(TailwindMergeConfig config)
+        {
+            ClassPart classMap = new();
+
+            Dictionary<string, List<object>> prefixedClassGroups = GetPrefixedClassGroups(
+                config.ClassGroups,
+                config.Prefix
+            );
+
+            foreach (var (classGroupId, classGroup) in prefixedClassGroups)
+            {
+                ProcessClassesRecursively(classGroup, classMap, classGroupId, config.Theme);
+            }
+
+            return classMap;
+        }
+
+        private static void ProcessClassesRecursively(List<object> classGroup, ClassPart classPart, string classGroupId, Dictionary<string, object> theme)
+        {
+            foreach (var classDefinition in classGroup)
+            {
+                if (classDefinition is string classDefString)
+                {
+                    ClassPart classPartToEdit = classDefString == string.Empty ? classPart : GetPart(classPart, classDefString);
+                    classPartToEdit.SetClassGroupId(classGroupId);
+                    continue;
+                }
+
+                if (classDefinition is ThemeGetter themeGetter)
+                {
+                    Dictionary<string, dynamic> themeResult = themeGetter.Execute(theme);
+
+                    // Convert the themeResult dictionary to a List<object>
+                    List<object> themeList = new List<object>();
+                    foreach (var kvp in themeResult)
+                    {
+                        var themeItem = new Dictionary<string, dynamic>
+                        {
+                            { kvp.Key, kvp.Value }
+                        };
+                        themeList.Add(themeItem);
+                    }
+
+                    ProcessClassesRecursively(
+                        themeList,
+                        classPart,
+                        classGroupId,
+                        theme
+                    );
+                    continue;
+}
+
+                if (classDefinition is IRule ruleInterface)
+                {
+                    classPart.Validators.Add(new ClassValidator(classGroupId, ruleInterface));
+                    continue;
+                }
+
+                if (classDefinition is Dictionary<string, object> classDefDict)
+                {
+                    foreach (var (key, value) in classDefDict)
+                    {
+                        ProcessClassesRecursively(
+                            (List<object>)value,
+                            GetPart(classPart, key),
+                            classGroupId,
+                            theme
+                        );
+                    }
+                }
+            }
+        }
+
+        private static ClassPart GetPart(ClassPart classPart, string path)
+        {
+            ClassPart currentClassPartObject = classPart;
+
+            foreach (string pathPart in path.Split(CLASS_PART_SEPARATOR))
+            {
+                if (!currentClassPartObject.NextPart.ContainsKey(pathPart))
+                {
+                    currentClassPartObject.NextPart[pathPart] = new ClassPart();
+                }
+
+                currentClassPartObject = currentClassPartObject.NextPart[pathPart];
+            }
+
+            return currentClassPartObject;
+        }
+
+        private static Dictionary<string, List<object>> GetPrefixedClassGroups(Dictionary<string, List<object>> classGroups, string prefix)
+        {
+            if (string.IsNullOrEmpty(prefix))
+            {
+                return classGroups;
+            }
+
+            Dictionary<string, List<object>> output = new();
+
+            foreach (var (classGroupId, classGroup) in classGroups)
+            {
+                output[classGroupId] = classGroup.ConvertAll(classDefinition =>
+                {
+                    if (classDefinition is string classDefString)
+                    {
+                        return prefix + classDefString;
+                    }
+
+                    if (classDefinition is Dictionary<string, object> classDefDict)
+                    {
+                        Dictionary<string, object> prefixedClassDefinition = new();
+                        foreach (var (key, value) in classDefDict)
+                        {
+                            prefixedClassDefinition[prefix + key] = value;
+                        }
+                        return prefixedClassDefinition;
+                    }
+
+                    return classDefinition;
+                });
+            }
+
+            return output;
+        }
+    }
+}

TailwindMerge/ClassValidator.cs

@@ -0,0 +1,16 @@
+using TailwindMerge.Interfaces; // Assuming RuleInterface is located here
+
+namespace TailwindMerge
+{
+    public class ClassValidator
+    {
+        public string ClassGroupId { get; }
+        public IRule Rule { get; }
+
+        public ClassValidator(string classGroupId, IRule rule)
+        {
+            ClassGroupId = classGroupId;
+            Rule = rule;
+        }
+    }
+}

TailwindMerge/DefaultConfig.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace TailwindMerge
+{
+    /// <summary>
+    /// Provides methods for merging Tailwind CSS classes.
+    /// </summary>
+    public class DefaultConfig
+    {
+         public DefaultConfig()
+        {
+            var colors = new ThemeGetter("colors");
+            var spacing = new ThemeGetter("spacing");
+            var blur = new ThemeGetter("blur");
+            var brightness = new ThemeGetter("brightness");
+            var borderColor = new ThemeGetter("borderColor");
+            var borderRadius = new ThemeGetter("borderRadius");
+            var borderSpacing = new ThemeGetter("borderSpacing");
+            var borderWidth = new ThemeGetter("borderWidth");
+            var contrast = new ThemeGetter("contrast");
+            var grayscale = new ThemeGetter("grayscale");
+            var hueRotate = new ThemeGetter("hueRotate");
+            var invert = new ThemeGetter("invert");
+            var gap = new ThemeGetter("gap");
+            var gradientColorStops = new ThemeGetter("gradientColorStops");
+            var gradientColorStopPositions = new ThemeGetter("gradientColorStopPositions");
+            var inset = new ThemeGetter("inset");
+            var margin = new ThemeGetter("margin");
+            var opacity = new ThemeGetter("opacity");
+            var padding = new ThemeGetter("padding");
+            var saturate = new ThemeGetter("saturate");
+            var scale = new ThemeGetter("scale");
+            var sepia = new ThemeGetter("sepia");
+            var skew = new ThemeGetter("skew");
+            var space = new ThemeGetter("space");
+            var translate = new ThemeGetter("translate");
+
+
+        }
+    }
+}

TailwindMerge/Exceptions/BadThemeException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace TailwindMerge.Exceptions
+{
+    public class BadThemeException : Exception
+    {
+        public TailwindMergeConfig Config { get; }
+
+        public BadThemeException(string message, TailwindMergeConfig config)
+            : base(message)
+        {
+            Config = config;
+        }
+    }
+}

TailwindMerge/Interfaces/IRule.cs

@@ -0,0 +1,7 @@
+namespace TailwindMerge.Interfaces
+{
+    public interface IRule
+    {
+        bool Execute(string value);
+    }
+}

TailwindMerge/Interfaces/ITailwindMergePlugin.cs

@@ -0,0 +1,7 @@
+namespace TailwindMerge.Interfaces
+{
+    public interface ITailwindMergePlugin
+    {
+        TailwindMergeConfig Invoke(TailwindMergeConfig config);
+    }
+}

TailwindMerge/LruCache.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+
+namespace TailwindMerge
+{
+    public class LruCache
+    {
+        private Dictionary<string, string> cache = new Dictionary<string, string>();
+        private Dictionary<string, string> previousCache = new Dictionary<string, string>();
+        private int cacheSize = 0;
+
+        public LruCache(int maxCacheSize)
+        {
+            MaxCacheSize = maxCacheSize;
+        }
+
+        public int MaxCacheSize { get; }
+
+        public string? Get(string key)
+        {
+            if (cache.ContainsKey(key))
+            {
+                return cache[key];
+            }
+
+            if (previousCache.ContainsKey(key))
+            {
+                string value = previousCache[key];
+                Update(key, value);
+                return value;
+            }
+
+            return null;
+        }
+
+        public LruCache Set(string key, string value)
+        {
+            if (cache.ContainsKey(key))
+            {
+                cache[key] = value;
+            }
+            else
+            {
+                Update(key, value);
+            }
+
+            return this;
+        }
+
+        private void Update(string key, string value)
+        {
+            cache[key] = value;
+            cacheSize++;
+
+            if (cacheSize > MaxCacheSize)
+            {
+                cacheSize = 0;
+                previousCache = new Dictionary<string, string>(cache);
+                cache.Clear();
+            }
+        }
+    }
+}

TailwindMerge/Models/ClassContext.cs

@@ -0,0 +1,20 @@
+namespace TailwindMerge.Models
+{
+    public class ClassContext
+    {
+        public bool IsTailwindClass { get; }
+        public string OriginalClassName { get; }
+        public bool HasPostfixModifier { get; }
+        public string? ModifierId { get; }
+        public string? ClassGroupId { get; }
+
+        public ClassContext(bool isTailwindClass, string originalClassName, bool hasPostfixModifier = false, string? modifierId = null, string? classGroupId = null)
+        {
+            IsTailwindClass = isTailwindClass;
+            OriginalClassName = originalClassName;
+            HasPostfixModifier = hasPostfixModifier;
+            ModifierId = modifierId;
+            ClassGroupId = classGroupId;
+        }
+    }
+}

TailwindMerge/Models/ClassModifiersContext.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+namespace TailwindMerge.Models
+{
+    public class ClassModifiersContext
+    {
+        public IReadOnlyList<string> Modifiers { get; }
+        public bool HasImportantModifier { get; }
+        public string BaseClassName { get; }
+        public int? MaybePostfixModifierPosition { get; }
+
+        public ClassModifiersContext(IReadOnlyList<string> modifiers, bool hasImportantModifier, string baseClassName, int? maybePostfixModifierPosition)
+        {
+            Modifiers = modifiers ?? throw new ArgumentNullException(nameof(modifiers));
+            HasImportantModifier = hasImportantModifier;
+            BaseClassName = baseClassName ?? throw new ArgumentNullException(nameof(baseClassName));
+            MaybePostfixModifierPosition = maybePostfixModifierPosition;
+        }
+    }
+}

TailwindMerge/Models/ClassPart.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace TailwindMerge.Models
+{
+    public class ClassPart
+    {
+        public Dictionary<string, ClassPart> NextPart { get; } = new Dictionary<string, ClassPart>();
+        public List<ClassValidator> Validators { get; } = new List<ClassValidator>();
+        public string? ClassGroupId { get; private set; }
+
+        public ClassPart(string? classGroupId = null)
+        {
+            ClassGroupId = classGroupId;
+        }
+
+        public ClassPart SetClassGroupId(string classGroupId)
+        {
+            ClassGroupId = classGroupId;
+            return this;
+        }
+    }
+}

TailwindMerge/Rules/AnyRule.cs

@@ -0,0 +1,12 @@
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class AnyRule : IRule
+    {
+        public bool Execute(string value)
+        {
+            return true;
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryIntegerRule.cs

@@ -0,0 +1,16 @@
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryIntegerRule : ArbitraryValueRule
+    {
+        protected string Parameter { get; set; } = "number";
+
+        protected override bool TestValue(string value)
+        {
+            if (int.TryParse(value, out _))
+            {
+                return true;
+            }
+            return false;
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryLengthRule.cs

@@ -0,0 +1,16 @@
+using System.Text.RegularExpressions;
+
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryLengthRule : ArbitraryValueRule
+    {
+        private const string LengthUnitRegex = @"\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$";
+
+        protected string Parameter { get; set; } = "length";
+
+        protected override bool TestValue(string value)
+        {
+            return Regex.IsMatch(value, LengthUnitRegex);
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryNumberRule.cs

@@ -0,0 +1,12 @@
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryNumberRule : ArbitraryValueRule
+    {
+        protected string Parameter { get; set; } = "number";
+
+        protected override bool TestValue(string value)
+        {
+            return double.TryParse(value, out _);
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryPositionRule.cs

@@ -0,0 +1,12 @@
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryPositionRule : ArbitraryValueRule
+    {
+        protected string Parameter { get; set; } = "position";
+
+        protected override bool TestValue(string value)
+        {
+            return false;
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryShadowRule.cs

@@ -0,0 +1,14 @@
+using System.Text.RegularExpressions;
+
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryShadowRule : ArbitraryValueRule
+    {
+        private const string ShadowRegex = @"^-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)";
+
+        protected override bool TestValue(string value)
+        {
+            return Regex.IsMatch(value, ShadowRegex);
+        }
+    }
+}

TailwindMerge/Rules/ArbitrarySizeRule.cs

@@ -0,0 +1,12 @@
+namespace TailwindMerge.Rules
+{
+    public class ArbitrarySizeRule : ArbitraryValueRule
+    {
+        protected string Parameter { get; set; } = "size";
+
+        protected override bool TestValue(string value)
+        {
+            return false;
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryUrlRule.cs

@@ -0,0 +1,12 @@
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryUrlRule : ArbitraryValueRule
+    {
+        protected string Parameter { get; set; } = "url";
+
+        protected override bool TestValue(string value)
+        {
+            return value.StartsWith("url(");
+        }
+    }
+}

TailwindMerge/Rules/ArbitraryValueRule.cs

@@ -0,0 +1,34 @@
+using System.Text.RegularExpressions;
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class ArbitraryValueRule : IRule
+    {
+        private const string RegexPattern = @"^\[(?:([a-z-]+):)?(.+)]$";
+
+        protected string Parameter { get; set; }
+
+        public bool Execute(string value)
+        {
+            var matches = Regex.Match(value, RegexPattern);
+
+            if (matches.Success)
+            {
+                if (!string.IsNullOrEmpty(matches.Groups[1].Value))
+                {
+                    return matches.Groups[1].Value == Parameter;
+                }
+
+                return TestValue(matches.Groups[2].Value);
+            }
+
+            return false;
+        }
+
+        protected virtual bool TestValue(string value)
+        {
+            return true;
+        }
+    }
+}

TailwindMerge/Rules/IntegerRule.cs

@@ -0,0 +1,12 @@
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class IntegerRule : IRule
+    {
+        public bool Execute(string value)
+        {
+            return int.TryParse(value, out _);
+        }
+    }
+}

TailwindMerge/Rules/LengthRule.cs

@@ -0,0 +1,18 @@
+using System.Text.RegularExpressions;
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class LengthRule : IRule
+    {
+        private const string FractionRegex = @"^\d+/\d+$";
+        private static readonly string[] StringLengths = { "px", "full", "screen" };
+
+        public bool Execute(string value)
+        {
+            return double.TryParse(value, out _) 
+                   || StringLengths.Contains(value) 
+                   || Regex.IsMatch(value, FractionRegex);
+        }
+    }
+}

TailwindMerge/Rules/NeverRule.cs

@@ -0,0 +1,12 @@
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class NeverRule : IRule
+    {
+        public bool Execute(string value)
+        {
+            return false;
+        }
+    }
+}

TailwindMerge/Rules/NumberRule.cs

@@ -0,0 +1,12 @@
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class NumberRule : IRule
+    {
+        public bool Execute(string value)
+        {
+            return double.TryParse(value, out _);
+        }
+    }
+}

TailwindMerge/Rules/PercentRule.cs

@@ -0,0 +1,18 @@
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class PercentRule : IRule
+    {
+        public bool Execute(string value)
+        {
+            if (string.IsNullOrEmpty(value) || !value.EndsWith("%"))
+            {
+                return false;
+            }
+
+            var numericPart = value.TrimEnd('%');
+            return double.TryParse(numericPart, out _);
+        }
+    }
+}

TailwindMerge/Rules/TshirtSizeRule.cs

@@ -0,0 +1,15 @@
+using System.Text.RegularExpressions;
+using TailwindMerge.Interfaces;
+
+namespace TailwindMerge.Rules
+{
+    public class TshirtSizeRule : IRule
+    {
+        private const string RegexPattern = @"^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$";
+
+        public bool Execute(string value)
+        {
+            return Regex.IsMatch(value, RegexPattern);
+        }
+    }
+}

TailwindMerge/TailwindMerge.cs

@@ -19,6 +19,8 @@
     <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
 
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <!-- Suppress CS1591 warnings -->
+    <NoWarn>$(NoWarn);CS1591</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>

TailwindMerge/TailwindMerge.csproj

@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using TailwindMerge.Models;
+
+namespace TailwindMerge.Utilities
+{
+    public class ClassUtils
+    {
+        private const string IMPORTANT_MODIFIER = "!";
+        private const string ARBITRARY_PROPERTY_REGEX = @"^\[(.+)]";
+
+        private readonly ClassPart classMap;
+        private readonly TailwindMergeConfig _config;
+
+        public ClassUtils(TailwindMergeConfig config)
+        {
+            classMap = ClassMapFactory.Create(config);
+            _config = config;
+        }
+
+        public string? GetClassGroupId(string className)
+        {
+            var classParts = className.Split('-');
+
+            // Classes like "-inset-1" produce an empty string as the first classPart.
+            // We assume that classes for negative values are used correctly and remove it from classParts.
+            if (classParts[0] == "" && classParts.Length != 1)
+            {
+                Array.Copy(classParts, 1, classParts, 0, classParts.Length - 1);
+                Array.Resize(ref classParts, classParts.Length - 1);
+            }
+
+            return GetGroupRecursive(classParts, classMap) ?? GetGroupIdForArbitraryProperty(className);
+        }
+
+        public List<string> GetConflictingClassGroupIds(string classGroupId, bool hasPostfixModifier)
+        {
+            var conflicts = _config.ConflictingClassGroups.GetValueOrDefault(classGroupId) ?? new List<string>();
+
+            if (hasPostfixModifier && _config.ConflictingClassGroupModifiers.ContainsKey(classGroupId))
+            {
+                conflicts.AddRange(_config.ConflictingClassGroupModifiers[classGroupId]);
+            }
+
+            return conflicts;
+        }
+
+        public ClassModifiersContext SplitModifiers(string className)
+        {
+            var separator = _config.Separator;
+            var modifiers = new List<string>();
+            var bracketDepth = 0;
+            var modifierStart = 0;
+            int? postfixModifierPosition = null;
+
+            for (int index = 0; index < className.Length; index++)
+            {
+                var currentCharacter = className[index];
+
+                if (bracketDepth == 0)
+                {
+                    if (currentCharacter == separator[0] &&
+                        (separator.Length == 1 || className.Substring(index, separator.Length) == separator))
+                    {
+                        modifiers.Add(className.Substring(modifierStart, index - modifierStart));
+                        modifierStart = index + separator.Length;
+                        continue;
+                    }
+
+                    if (currentCharacter == '/')
+                    {
+                        postfixModifierPosition = index;
+                        continue;
+                    }
+                }
+
+                if (currentCharacter == '[')
+                {
+                    bracketDepth++;
+                }
+                else if (currentCharacter == ']')
+                {
+                    bracketDepth--;
+                }
+            }
+
+            var baseClassNameWithImportantModifier = modifiers.Count == 0
+                ? className
+                : className.Substring(modifierStart);
+            var hasImportantModifier = baseClassNameWithImportantModifier.StartsWith(IMPORTANT_MODIFIER);
+            var baseClassName = hasImportantModifier
+                ? baseClassNameWithImportantModifier.Substring(1)
+                : baseClassNameWithImportantModifier;
+            int? maybePostfixModifierPosition = postfixModifierPosition > modifierStart
+                ? postfixModifierPosition - modifierStart
+                : null;
+
+            return new ClassModifiersContext(modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition);
+        }
+
+        public IReadOnlyList<string> SortModifiers(IReadOnlyList<string> modifiers)
+        {
+            if (modifiers.Count <= 1)
+            {
+                return modifiers;
+            }
+
+            var sortedModifiers = new List<string>();
+            var unsortedModifiers = new List<string>();
+
+            foreach (var modifier in modifiers)
+            {
+                var isArbitraryVariant = modifier[0] == '[';
+                if (isArbitraryVariant)
+                {
+                    unsortedModifiers.Sort();
+                    sortedModifiers.AddRange(unsortedModifiers);
+                    sortedModifiers.Add(modifier);
+                    unsortedModifiers.Clear();
+                }
+                else
+                {
+                    unsortedModifiers.Add(modifier);
+                }
+            }
+
+            unsortedModifiers.Sort();
+            sortedModifiers.AddRange(unsortedModifiers);
+
+            return sortedModifiers;
+        }
+
+        private string? GetGroupRecursive(string[] classParts, ClassPart classPart)
+        {
+            if (classParts.Length == 0)
+            {
+                return classPart.ClassGroupId;
+            }
+
+            var currentClassPart = classParts[0];
+            if (classPart.NextPart.TryGetValue(currentClassPart, out var nextClassPartObject))
+            {
+                var classGroupFromNextClassPart = GetGroupRecursive(classParts[1..], nextClassPartObject);
+                if (classGroupFromNextClassPart != null)
+                {
+                    return classGroupFromNextClassPart;
+                }
+            }
+
+            if (classPart.Validators.Count == 0)
+            {
+                return null;
+            }
+
+            var classRest = string.Join("-", classParts);
+
+            foreach (var classValidator in classPart.Validators)
+            {
+                if (classValidator.Rule.Execute(classRest))
+                {
+                    return classValidator.ClassGroupId;
+                }
+            }
+
+            return null;
+        }
+
+        private string? GetGroupIdForArbitraryProperty(string className)
+        {
+            var match = System.Text.RegularExpressions.Regex.Match(className, ARBITRARY_PROPERTY_REGEX);
+            if (match.Success)
+            {
+                var arbitraryPropertyClassName = match.Groups[1].Value;
+                if (!string.IsNullOrEmpty(arbitraryPropertyClassName))
+                {
+                    var property = arbitraryPropertyClassName.Substring(0, arbitraryPropertyClassName.IndexOf(':'));
+                    return "arbitrary.." + property;
+                }
+            }
+
+            return null;
+        }
+    }
+}

TailwindMerge/TailwindMergeConfig.cs

@@ -0,0 +1,17 @@
+namespace TailwindMerge.Utilities
+{
+    public class ThemeGetter
+    {
+        public string Key { get; }
+
+        public ThemeGetter(string key)
+        {
+            Key = key;
+        }
+
+        public Dictionary<string, dynamic> Execute(Dictionary<string, dynamic> theme)
+        {
+            return theme.TryGetValue(Key, out var value) ? value : new Dictionary<string, dynamic>();
+        }
+    }
+}

TailwindMerge/Utilities/ClassUtils.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace TailwindMerge
+{
+    /// <summary>
+    /// Provides methods for merging Tailwind CSS classes.
+    /// </summary>
+    public class Validators
+    {
+        private static readonly Regex ArbitraryValueRegex = new Regex(@"^\[(?:([a-z-]+):)?(.+)\]$", RegexOptions.IgnoreCase);
+        private static readonly Regex FractionRegex = new Regex(@"^\d+\/\d+$");
+        private static readonly HashSet<string> StringLengths = new HashSet<string> { "px", "full", "screen" };
+        private static readonly Regex TshirtUnitRegex = new Regex(@"^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$");
+        private static readonly Regex LengthUnitRegex = new Regex(
+            @"\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$");
+        private static readonly Regex ShadowRegex = new Regex(@"^-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)");
+        private static readonly Regex ImageRegex = new Regex(
+            @"^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$");
+
+        public static bool IsLength(string value)
+        {
+            return IsNumber(value) || StringLengths.Contains(value) || FractionRegex.IsMatch(value);
+        }
+
+        public static bool IsArbitraryLength(string value)
+        {
+            return GetIsArbitraryValue(value, "length", IsLengthOnly);
+        }
+
+        public static bool IsNumber(string value)
+        {
+            return !string.IsNullOrEmpty(value) && double.TryParse(value, out _);
+        }
+
+        public static bool IsArbitraryNumber(string value)
+        {
+            return GetIsArbitraryValue(value, "number", IsNumber);
+        }
+
+        public static bool IsInteger(string value)
+        {
+            return !string.IsNullOrEmpty(value) && int.TryParse(value, out _);
+        }
+
+        public static bool IsPercent(string value)
+        {
+            return value.EndsWith("%") && IsNumber(value[..^1]);
+        }
+
+        public static bool IsArbitraryValue(string value)
+        {
+            return ArbitraryValueRegex.IsMatch(value);
+        }
+
+        public static bool IsTshirtSize(string value)
+        {
+            return TshirtUnitRegex.IsMatch(value);
+        }
+
+        private static readonly HashSet<string> SizeLabels = new HashSet<string> { "length", "size", "percentage" };
+
+        public static bool IsArbitrarySize(string value)
+        {
+            return GetIsArbitraryValue(value, SizeLabels, IsNever);
+        }
+
+        public static bool IsArbitraryPosition(string value)
+        {
+            return GetIsArbitraryValue(value, "position", IsNever);
+        }
+
+        private static readonly HashSet<string> ImageLabels = new HashSet<string> { "image", "url" };
+
+        public static bool IsArbitraryImage(string value)
+        {
+            return GetIsArbitraryValue(value, ImageLabels, IsImage);
+        }
+
+        public static bool IsArbitraryShadow(string value)
+        {
+            return GetIsArbitraryValue(value, string.Empty, IsShadow);
+        }
+
+        public static bool IsAny()
+        {
+            return true;
+        }
+
+        private static bool GetIsArbitraryValue(string value, object label, Func<string, bool> testValue)
+        {
+            var match = ArbitraryValueRegex.Match(value);
+
+            if (match.Success)
+            {
+                if (!string.IsNullOrEmpty(match.Groups[1].Value))
+                {
+                    if (label is string strLabel)
+                        return match.Groups[1].Value == strLabel;
+                    if (label is HashSet<string> setLabel)
+                        return setLabel.Contains(match.Groups[1].Value);
+                }
+
+                return testValue(match.Groups[2].Value);
+            }
+
+            return false;
+        }
+
+        private static bool IsLengthOnly(string value)
+        {
+            return LengthUnitRegex.IsMatch(value);
+        }
+
+        private static bool IsNever(string value)
+        {
+            return false;
+        }
+
+        private static bool IsShadow(string value)
+        {
+            return ShadowRegex.IsMatch(value);
+        }
+
+        private static bool IsImage(string value)
+        {
+            return ImageRegex.IsMatch(value);
+        }
+    }
+}