feat(core): add support for COMMENTS and UNICODE_CASE global flags

- Introduced SiftGlobalFlag.COMMENTS (?x) to allow verbose regex validation.
- Introduced SiftGlobalFlag.UNICODE_CASE (?u) for Unicode-aware case-insensitive matching.
- Validated correct flag concatenation and engine propagation via unit tests.

Author: Mirkoddd

sift-core/src/main/java/com/mirkoddd/sift/core/SiftGlobalFlag.java

@@ -19,33 +19,54 @@
  * Inline flags to modify the regular expression engine behavior globally.
  * <p>
  * These flags are applied at the very beginning of the pattern 
- * (e.g., {@code (?im)}) to instruct the Regex engine.
+ * (e.g., {@code (?imx)}) to instruct the Regex engine.
  */
 public enum SiftGlobalFlag {
 
     /**
      * Enables case-insensitive matching ({@code (?i)}).
      * <p>
      * By default, case-insensitive matching assumes that only characters in the US-ASCII charset are being matched.
+     * To enable Unicode-aware case-insensitive matching, combine this with {@link #UNICODE_CASE}.
      */
     CASE_INSENSITIVE("i"),
 
     /**
      * Enables multiline mode ({@code (?m)}).
      * <p>
-     * In multiline mode, the expressions {@code ^} (fromStart) and {@code $} (andNothingElse) 
-     * match just after or just before a line terminator, rather than only at the 
+     * In multiline mode, the expressions {@code ^} (fromStart) and {@code $} (andNothingElse)
+     * match just after or just before a line terminator, rather than only at the
      * beginning or end of the entire input string.
      */
     MULTILINE("m"),
 
     /**
      * Enables dotall mode ({@code (?s)}).
      * <p>
-     * In dotall mode, the {@code .any()} expression matches any character, 
+     * In dotall mode, the {@code .any()} expression matches any character,
      * including a line terminator (which it normally ignores).
      */
-    DOTALL("s");
+    DOTALL("s"),
+
+    /**
+     * Enables verbose/comments mode ({@code (?x)}).
+     * <p>
+     * In this mode, whitespace is ignored, and embedded comments starting with
+     * {@code #} are ignored until the end of a line.
+     * <p>
+     * <i>Note: Sift's internal {@code literal()} generator automatically escapes spaces
+     * and {@code #} characters to ensure your literals remain strictly matched even when
+     * this flag is active.</i>
+     */
+    COMMENTS("x"),
+
+    /**
+     * Enables Unicode-aware case folding ({@code (?u)}).
+     * <p>
+     * When this flag is specified alongside {@link #CASE_INSENSITIVE}, case-insensitive matching,
+     * it will be done in a manner consistent with the Unicode Standard.
+     */
+    UNICODE_CASE("u");
 
     private final String symbol;
 
@@ -56,7 +77,7 @@ public enum SiftGlobalFlag {
     /**
      * Retrieves the regex symbol associated with this flag.
      *
-     * @return The literal character used by the regex engine (e.g., 'i', 'm', 's').
+     * @return The literal character used by the regex engine (e.g., 'i', 'm', 's', 'x', 'u').
      */
     public String getSymbol() {
         return symbol;

sift-core/src/test/java/com/mirkoddd/sift/core/SiftTest.java

@@ -1187,6 +1187,43 @@ void flagsFromWordBoundary() {
             assertRegexMatches(regex, "fatal ERROR occurred");
             assertRegexMatches(regex, "fatal error occurred");
         }
+
+        @Test
+        @DisplayName("Should handle COMMENTS (verbose) mode correctly")
+        void commentsFlag() {
+            String regex = filteringWith(SiftGlobalFlag.COMMENTS)
+                    .fromStart()
+                    .exactly(3).letters()
+                    .andNothingElse()
+                    .shake();
+
+            // Ensure the 'x' flag is correctly injected
+            assertEquals("(?x)^[a-zA-Z]{3}$", regex);
+
+            // Ensure standard matching still works perfectly
+            assertRegexMatches(regex, "abc");
+            assertRegexDoesNotMatch(regex, "a c"); // Space is not matched unless explicitly requested
+        }
+
+        @Test
+        @DisplayName("Should handle UNICODE_CASE mode correctly alongside CASE_INSENSITIVE")
+        void unicodeCaseFlag() {
+            // Unicode Case is usually combined with Case Insensitive
+            String regex = filteringWith(CASE_INSENSITIVE, SiftGlobalFlag.UNICODE_CASE)
+                    .fromStart()
+                    .oneOrMore().lettersUnicode() // Using the \p{L} class
+                    .andNothingElse()
+                    .shake();
+
+            // Ensure 'i' and 'u' are concatenated correctly inside the flag group
+            assertEquals("(?iu)^[\\p{L}]+$", regex);
+
+            // Should match Unicode letters case-insensitively
+            assertRegexMatches(regex, "è");
+            assertRegexMatches(regex, "È");
+            assertRegexMatches(regex, "ω"); // Greek lowercase omega
+            assertRegexMatches(regex, "Ω"); // Greek uppercase omega
+        }
     }
 
     @Test