From e2a5164343b84a70ba1c73cd3fc11d36dd352413 Mon Sep 17 00:00:00 2001
From: Divyanshu Bhargava <divyanshub024@gmail.com>
Date: Fri, 15 May 2026 15:32:17 +0530
Subject: [PATCH 1/3] feat: add 21 validators and a sanitizers module for
 validator.js parity

Expands the package toward validator.js coverage by adding 21 new
validators (isLowercase, isUppercase, isHexadecimal, isOctal, isDecimal,
isFloat, isMongoId, isMD5, isPort, isSemVer, isSlug, isMACAddress,
isLatLong, isJWT, isFQDN, isBase64, isByteLength, isStrongPassword, isIn,
matches, contains) and a new sanitizers module (trim, ltrim, rtrim,
escape, unescape, blacklist, whitelist, stripLow, normalizeEmail,
toBoolean, toInt, toFloat, toDate).

Each new validator is wired into all three APIs (top-level function,
String extension, Validator form method). Adds test coverage for every
new validator and sanitizer, plus the 38 previously-untested Validator
form methods.
---
 CHANGELOG.md                                  |  12 +
 README.md                                     |  78 ++++-
 lib/flutter_validators.dart                   |  35 ++-
 lib/form_validator.dart                       | 180 ++++++++++++
 lib/sanitizers.dart                           |  13 +
 lib/validators/base64.dart                    |  34 +++
 lib/validators/byte_length.dart               |  28 ++
 lib/validators/contains.dart                  |  25 ++
 lib/validators/decimal.dart                   |  28 ++
 lib/validators/float.dart                     |  30 ++
 lib/validators/fqdn.dart                      |  43 +++
 lib/validators/hexadecimal.dart               |  26 ++
 lib/validators/in.dart                        |  20 ++
 lib/validators/ip.dart                        |   8 +-
 lib/validators/jwt.dart                       |  31 ++
 lib/validators/lat_long.dart                  |  30 ++
 lib/validators/lowercase.dart                 |  25 ++
 lib/validators/mac_address.dart               |  32 +++
 lib/validators/matches.dart                   |  23 ++
 lib/validators/md5.dart                       |  24 ++
 lib/validators/mongo_id.dart                  |  25 ++
 lib/validators/octal.dart                     |  26 ++
 lib/validators/port.dart                      |  27 ++
 lib/validators/sanitizers/blacklist.dart      |  35 +++
 lib/validators/sanitizers/escape.dart         |  52 ++++
 .../sanitizers/normalize_email.dart           |  42 +++
 lib/validators/sanitizers/strip_low.dart      |  29 ++
 lib/validators/sanitizers/to_boolean.dart     |  26 ++
 lib/validators/sanitizers/to_number.dart      |  46 +++
 lib/validators/sanitizers/trim.dart           |  62 ++++
 lib/validators/semver.dart                    |  32 +++
 lib/validators/slug.dart                      |  27 ++
 lib/validators/strong_password.dart           |  69 +++++
 lib/validators/uppercase.dart                 |  25 ++
 lib/validators/url.dart                       |   4 +-
 lib/validators/uuid.dart                      |   4 +-
 pubspec.yaml                                  |   2 +-
 test/form_validator_test.dart                 | 267 +++++++++++++++++-
 test/validators/base32_test.dart              |   2 +-
 test/validators/base58_test.dart              |  10 +-
 test/validators/base64_test.dart              |  23 ++
 test/validators/byte_length_test.dart         |  19 ++
 test/validators/contains_test.dart            |  26 ++
 test/validators/decimal_test.dart             |  21 ++
 test/validators/float_test.dart               |  25 ++
 test/validators/fqdn_test.dart                |  21 ++
 test/validators/hexadecimal_test.dart         |  21 ++
 test/validators/in_test.dart                  |  18 ++
 test/validators/jwt_test.dart                 |  20 ++
 test/validators/lat_long_test.dart            |  22 ++
 test/validators/lowercase_test.dart           |  20 ++
 test/validators/mac_address_test.dart         |  21 ++
 test/validators/matches_test.dart             |  17 ++
 test/validators/md5_test.dart                 |  18 ++
 test/validators/mongo_id_test.dart            |  19 ++
 test/validators/octal_test.dart               |  20 ++
 test/validators/port_test.dart                |  22 ++
 .../validators/sanitizers/blacklist_test.dart |  16 ++
 test/validators/sanitizers/escape_test.dart   |  21 ++
 .../sanitizers/normalize_email_test.dart      |  20 ++
 .../validators/sanitizers/strip_low_test.dart | Bin 0 -> 487 bytes
 .../sanitizers/to_boolean_test.dart           |  20 ++
 .../validators/sanitizers/to_number_test.dart |  25 ++
 test/validators/sanitizers/trim_test.dart     |  24 ++
 test/validators/semver_test.dart              |  22 ++
 test/validators/slug_test.dart                |  22 ++
 test/validators/strong_password_test.dart     |  38 +++
 test/validators/uppercase_test.dart           |  20 ++
 test/validators/uuid_test.dart                |  72 ++++-
 69 files changed, 2155 insertions(+), 35 deletions(-)
 create mode 100644 lib/sanitizers.dart
 create mode 100644 lib/validators/base64.dart
 create mode 100644 lib/validators/byte_length.dart
 create mode 100644 lib/validators/contains.dart
 create mode 100644 lib/validators/decimal.dart
 create mode 100644 lib/validators/float.dart
 create mode 100644 lib/validators/fqdn.dart
 create mode 100644 lib/validators/hexadecimal.dart
 create mode 100644 lib/validators/in.dart
 create mode 100644 lib/validators/jwt.dart
 create mode 100644 lib/validators/lat_long.dart
 create mode 100644 lib/validators/lowercase.dart
 create mode 100644 lib/validators/mac_address.dart
 create mode 100644 lib/validators/matches.dart
 create mode 100644 lib/validators/md5.dart
 create mode 100644 lib/validators/mongo_id.dart
 create mode 100644 lib/validators/octal.dart
 create mode 100644 lib/validators/port.dart
 create mode 100644 lib/validators/sanitizers/blacklist.dart
 create mode 100644 lib/validators/sanitizers/escape.dart
 create mode 100644 lib/validators/sanitizers/normalize_email.dart
 create mode 100644 lib/validators/sanitizers/strip_low.dart
 create mode 100644 lib/validators/sanitizers/to_boolean.dart
 create mode 100644 lib/validators/sanitizers/to_number.dart
 create mode 100644 lib/validators/sanitizers/trim.dart
 create mode 100644 lib/validators/semver.dart
 create mode 100644 lib/validators/slug.dart
 create mode 100644 lib/validators/strong_password.dart
 create mode 100644 lib/validators/uppercase.dart
 create mode 100644 test/validators/base64_test.dart
 create mode 100644 test/validators/byte_length_test.dart
 create mode 100644 test/validators/contains_test.dart
 create mode 100644 test/validators/decimal_test.dart
 create mode 100644 test/validators/float_test.dart
 create mode 100644 test/validators/fqdn_test.dart
 create mode 100644 test/validators/hexadecimal_test.dart
 create mode 100644 test/validators/in_test.dart
 create mode 100644 test/validators/jwt_test.dart
 create mode 100644 test/validators/lat_long_test.dart
 create mode 100644 test/validators/lowercase_test.dart
 create mode 100644 test/validators/mac_address_test.dart
 create mode 100644 test/validators/matches_test.dart
 create mode 100644 test/validators/md5_test.dart
 create mode 100644 test/validators/mongo_id_test.dart
 create mode 100644 test/validators/octal_test.dart
 create mode 100644 test/validators/port_test.dart
 create mode 100644 test/validators/sanitizers/blacklist_test.dart
 create mode 100644 test/validators/sanitizers/escape_test.dart
 create mode 100644 test/validators/sanitizers/normalize_email_test.dart
 create mode 100644 test/validators/sanitizers/strip_low_test.dart
 create mode 100644 test/validators/sanitizers/to_boolean_test.dart
 create mode 100644 test/validators/sanitizers/to_number_test.dart
 create mode 100644 test/validators/sanitizers/trim_test.dart
 create mode 100644 test/validators/semver_test.dart
 create mode 100644 test/validators/slug_test.dart
 create mode 100644 test/validators/strong_password_test.dart
 create mode 100644 test/validators/uppercase_test.dart

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 165a771..2732955 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+## 1.2.0
+
+* Added 21 new validators inspired by validator.js: `isLowercase`, `isUppercase`,
+  `isHexadecimal`, `isOctal`, `isDecimal`, `isFloat`, `isMongoId`, `isMD5`,
+  `isPort`, `isSemVer`, `isSlug`, `isMACAddress`, `isLatLong`, `isJWT`, `isFQDN`,
+  `isBase64`, `isByteLength`, `isStrongPassword`, `isIn`, `matches` and `contains`.
+* Added a new sanitizers module (`package:flutter_validators/sanitizers.dart`):
+  `trim`, `ltrim`, `rtrim`, `escape`, `unescape`, `blacklist`, `whitelist`,
+  `stripLow`, `normalizeEmail`, `toBoolean`, `toInt`, `toFloat` and `toDate`.
+* Extended the `Validator` form class with methods for every new validator.
+* Added test coverage for all new validators and sanitizers.
+
 ## 1.1.0
 
 * Major upgrade! Added 9 new standard validators (URL, UUID, Date, Numeric, Alpha, IP, Hex Color, Credit Card, Length).
diff --git a/README.md b/README.md
index f249ef4..0343d68 100644
--- a/README.md
+++ b/README.md
@@ -18,12 +18,12 @@
 </p>
 
 <p align="center">
-  Inspired by <a href="https://github.com/validatorjs/validator.js">validator.js</a> · 20+ validators · Works with Flutter Forms out of the box
+  Inspired by <a href="https://github.com/validatorjs/validator.js">validator.js</a> · 40+ validators & sanitizers · Works with Flutter Forms out of the box
 </p>
 
 ---
 
-A pure Dart package with 20+ string validators and sanitizers, from emails and URLs to credit cards and UUIDs. Use them as simple functions, convenient `String` extensions, or plug them directly into Flutter's `TextFormField` with the built-in `Validator` class. Zero dependencies, fully tested.
+A pure Dart package with 40+ string validators and sanitizers, from emails and URLs to credit cards, UUIDs and strong-password checks. Use them as simple functions, convenient `String` extensions, or plug them directly into Flutter's `TextFormField` with the built-in `Validator` class. Zero dependencies, fully tested.
 
 ---
 
@@ -31,7 +31,7 @@ A pure Dart package with 20+ string validators and sanitizers, from emails and U
 
 ```yaml
 dependencies:
-  flutter_validators: ^1.1.0
+  flutter_validators: ^1.2.0
 ```
 
 Then run:
@@ -120,12 +120,63 @@ Every validator is available **both** as a top-level function and as a `String`
 | `isBase58(str)` | `str.isBase58` | Base58 encoded |
 | `isBoolean(str)` | `str.isBoolean` | Boolean string (`true`/`false`/`1`/`0`) |
 | `isHexColor(str)` | `str.isHexColor` | Hex color code (`#fff`, `ff0000`) |
+| `isHexadecimal(str)` | `str.isHexadecimal` | Hexadecimal number |
+| `isOctal(str)` | `str.isOctal` | Octal number |
+| `isDecimal(str)` | `str.isDecimal` | Decimal number |
+| `isFloat(str, {min, max})` | `str.isFloat({min, max})` | Finite float, optionally within range |
 | `isPhone(str)` | `str.isPhone` | Valid phone number |
 | `isLength(str, min, [max])` | `str.isLength(min, [max])` | Length within range |
+| `isByteLength(str, min, [max])` | `str.isByteLength(min, [max])` | UTF-8 byte length within range |
+| `isBase64(str, {urlSafe})` | `str.isBase64({urlSafe})` | Base64 encoded |
+| `isLowercase(str)` | `str.isLowercase` | Entirely lowercase |
+| `isUppercase(str)` | `str.isUppercase` | Entirely uppercase |
+| `isSlug(str)` | `str.isSlug` | URL slug |
+| `isFQDN(str)` | `str.isFQDN` | Fully qualified domain name |
+| `isMACAddress(str)` | `str.isMACAddress` | MAC address |
+| `isLatLong(str)` | `str.isLatLong` | `latitude,longitude` pair |
+| `isPort(str)` | `str.isPort` | Port number (0–65535) |
+| `isSemVer(str)` | `str.isSemVer` | Semantic version |
+| `isMongoId(str)` | `str.isMongoId` | MongoDB ObjectId |
+| `isMD5(str)` | `str.isMD5` | MD5 hash |
+| `isJWT(str)` | `str.isJWT` | JSON Web Token |
+| `isStrongPassword(str, {...})` | `str.isStrongPassword({...})` | Password meets strength rules |
+| `isIn(str, values)` | `str.isIn(values)` | One of the allowed values |
+| `matches(str, pattern)` | `str.matches(pattern)` | Matches a `Pattern`/`RegExp` |
+| `contains(str, seed, {ignoreCase, minOccurrences})` | — | Contains a substring |
 | `equals(str, comparison)` | `str.equals(comparison)` | Exact string match |
 
 ---
 
+## 🧹 Sanitizers
+
+Sanitizers transform or coerce strings. Available both as top-level functions and `String` extensions.
+
+```dart
+trim('  hello  ');             // 'hello'
+escape('<script>');            // '&lt;script&gt;'
+normalizeEmail('A.B+x@GMAIL.com'); // 'ab@gmail.com'
+toBoolean('true');             // true
+toInt('42');                   // 42
+```
+
+| Sanitizer | Returns | Description |
+|---|---|---|
+| `trim(str, [chars])` | `String` | Trim whitespace/chars from both ends |
+| `ltrim(str, [chars])` | `String` | Trim from the start |
+| `rtrim(str, [chars])` | `String` | Trim from the end |
+| `escape(str)` | `String` | Escape HTML-unsafe characters |
+| `unescape(str)` | `String` | Reverse of `escape` |
+| `blacklist(str, chars)` | `String` | Remove the listed characters |
+| `whitelist(str, chars)` | `String` | Keep only the listed characters |
+| `stripLow(str, {keepNewLines})` | `String` | Remove control characters |
+| `normalizeEmail(str)` | `String?` | Canonicalize an email address |
+| `toBoolean(str, {strict})` | `bool` | Convert to a boolean |
+| `toInt(str, {radix})` | `int?` | Parse to an integer |
+| `toFloat(str)` | `double?` | Parse to a double |
+| `toDate(str)` | `DateTime?` | Parse to a `DateTime` |
+
+---
+
 ## 🏗️ Form Validator API Reference
 
 All methods on the `Validator` class return `String? Function(String?)`:
@@ -149,6 +200,27 @@ Validator.ascii({String errorMessage})
 Validator.base32({String errorMessage})
 Validator.base58({String errorMessage})
 Validator.boolean({String errorMessage})
+Validator.base64({bool urlSafe, String errorMessage})
+Validator.hexadecimal({String errorMessage})
+Validator.octal({String errorMessage})
+Validator.decimal({String errorMessage})
+Validator.float({double? min, double? max, String errorMessage})
+Validator.lowercase({String errorMessage})
+Validator.uppercase({String errorMessage})
+Validator.slug({String errorMessage})
+Validator.fqdn({String errorMessage})
+Validator.macAddress({String errorMessage})
+Validator.latLong({String errorMessage})
+Validator.port({String errorMessage})
+Validator.semVer({String errorMessage})
+Validator.mongoId({String errorMessage})
+Validator.md5({String errorMessage})
+Validator.jwt({String errorMessage})
+Validator.strongPassword({int minLength, int minLowercase, int minUppercase, int minNumbers, int minSymbols, String errorMessage})
+Validator.contains(String seed, {bool ignoreCase, int minOccurrences, String errorMessage})
+Validator.matches(Pattern pattern, {String errorMessage})
+Validator.inList(Iterable<String> allowed, {String errorMessage})
+Validator.byteLength(int min, {int? max, String errorMessage})
 Validator.equals(String comparison, {String errorMessage})
 Validator.length(int min, {int? max, String errorMessage})
 ```
diff --git a/lib/flutter_validators.dart b/lib/flutter_validators.dart
index de1d79e..eb74ecb 100644
--- a/lib/flutter_validators.dart
+++ b/lib/flutter_validators.dart
@@ -1,22 +1,45 @@
 library;
 
+export 'validators/alpha.dart';
 export 'validators/ascii.dart';
 export 'validators/base32.dart';
 export 'validators/base58.dart';
+export 'validators/base64.dart';
 export 'validators/boolean.dart';
-export 'validators/email.dart';
-export 'validators/equals.dart';
-export 'validators/int.dart';
-export 'validators/json.dart';
-export 'validators/phone.dart';
-export 'validators/alpha.dart';
+export 'validators/byte_length.dart';
+export 'validators/contains.dart';
 export 'validators/credit_card.dart';
 export 'validators/date.dart';
+export 'validators/decimal.dart';
+export 'validators/email.dart';
+export 'validators/equals.dart';
+export 'validators/float.dart';
+export 'validators/fqdn.dart';
 export 'validators/hex_color.dart';
+export 'validators/hexadecimal.dart';
+export 'validators/in.dart';
+export 'validators/int.dart';
 export 'validators/ip.dart';
+export 'validators/json.dart';
+export 'validators/jwt.dart';
+export 'validators/lat_long.dart';
 export 'validators/length.dart';
+export 'validators/lowercase.dart';
+export 'validators/mac_address.dart';
+export 'validators/matches.dart';
+export 'validators/md5.dart';
+export 'validators/mongo_id.dart';
 export 'validators/numeric.dart';
+export 'validators/octal.dart';
+export 'validators/phone.dart';
+export 'validators/port.dart';
+export 'validators/semver.dart';
+export 'validators/slug.dart';
+export 'validators/strong_password.dart';
+export 'validators/uppercase.dart';
 export 'validators/url.dart';
 export 'validators/uuid.dart';
 
+export 'sanitizers.dart';
+
 export 'form_validator.dart';
diff --git a/lib/form_validator.dart b/lib/form_validator.dart
index e2cd843..6e2f089 100644
--- a/lib/form_validator.dart
+++ b/lib/form_validator.dart
@@ -1,4 +1,5 @@
 import 'package:flutter_validators/flutter_validators.dart';
+import 'package:flutter_validators/validators/contains.dart' as contains_fn;
 
 /// A utility class for Flutter Form validation.
 /// Provides methods that return a validator function suitable for `TextFormField`.
@@ -155,6 +156,185 @@ class Validator {
     return _build(errorMessage, (v) => v.isLength(min, max));
   }
 
+  /// Ensures the string is entirely lowercase.
+  static String? Function(String?) lowercase({
+    String errorMessage = 'Must be lowercase',
+  }) {
+    return _build(errorMessage, (v) => v.isLowercase);
+  }
+
+  /// Ensures the string is entirely uppercase.
+  static String? Function(String?) uppercase({
+    String errorMessage = 'Must be uppercase',
+  }) {
+    return _build(errorMessage, (v) => v.isUppercase);
+  }
+
+  /// Ensures the string is a hexadecimal number.
+  static String? Function(String?) hexadecimal({
+    String errorMessage = 'Please enter a valid hexadecimal number',
+  }) {
+    return _build(errorMessage, (v) => v.isHexadecimal);
+  }
+
+  /// Ensures the string is an octal number.
+  static String? Function(String?) octal({
+    String errorMessage = 'Please enter a valid octal number',
+  }) {
+    return _build(errorMessage, (v) => v.isOctal);
+  }
+
+  /// Ensures the string is a valid MongoDB ObjectId.
+  static String? Function(String?) mongoId({
+    String errorMessage = 'Please enter a valid MongoDB ObjectId',
+  }) {
+    return _build(errorMessage, (v) => v.isMongoId);
+  }
+
+  /// Ensures the string is a valid MD5 hash.
+  static String? Function(String?) md5({
+    String errorMessage = 'Please enter a valid MD5 hash',
+  }) {
+    return _build(errorMessage, (v) => v.isMD5);
+  }
+
+  /// Ensures the string is a valid port number.
+  static String? Function(String?) port({
+    String errorMessage = 'Please enter a valid port number',
+  }) {
+    return _build(errorMessage, (v) => v.isPort);
+  }
+
+  /// Ensures the string is a valid Semantic Version.
+  static String? Function(String?) semVer({
+    String errorMessage = 'Please enter a valid semantic version',
+  }) {
+    return _build(errorMessage, (v) => v.isSemVer);
+  }
+
+  /// Ensures the string is a valid URL slug.
+  static String? Function(String?) slug({
+    String errorMessage = 'Please enter a valid slug',
+  }) {
+    return _build(errorMessage, (v) => v.isSlug);
+  }
+
+  /// Ensures the string is a valid MAC address.
+  static String? Function(String?) macAddress({
+    String errorMessage = 'Please enter a valid MAC address',
+  }) {
+    return _build(errorMessage, (v) => v.isMACAddress);
+  }
+
+  /// Ensures the string is a valid `latitude,longitude` pair.
+  static String? Function(String?) latLong({
+    String errorMessage = 'Please enter valid coordinates',
+  }) {
+    return _build(errorMessage, (v) => v.isLatLong);
+  }
+
+  /// Ensures the string is a valid JSON Web Token.
+  static String? Function(String?) jwt({
+    String errorMessage = 'Please enter a valid JWT',
+  }) {
+    return _build(errorMessage, (v) => v.isJWT);
+  }
+
+  /// Ensures the string is a fully qualified domain name.
+  static String? Function(String?) fqdn({
+    String errorMessage = 'Please enter a valid domain name',
+  }) {
+    return _build(errorMessage, (v) => v.isFQDN);
+  }
+
+  /// Ensures the string is Base64 encoded.
+  static String? Function(String?) base64({
+    bool urlSafe = false,
+    String errorMessage = 'Please enter a valid Base64 encoded string',
+  }) {
+    return _build(errorMessage, (v) => v.isBase64(urlSafe: urlSafe));
+  }
+
+  /// Ensures the string represents a decimal number.
+  static String? Function(String?) decimal({
+    String errorMessage = 'Please enter a valid decimal number',
+  }) {
+    return _build(errorMessage, (v) => v.isDecimal);
+  }
+
+  /// Ensures the string contains the [seed] substring.
+  static String? Function(String?) contains(
+    String seed, {
+    bool ignoreCase = false,
+    int minOccurrences = 1,
+    String errorMessage = 'Required text is missing',
+  }) {
+    return _build(
+      errorMessage,
+      (v) => contains_fn.contains(
+        v,
+        seed,
+        ignoreCase: ignoreCase,
+        minOccurrences: minOccurrences,
+      ),
+    );
+  }
+
+  /// Ensures the string matches the given [pattern].
+  static String? Function(String?) matches(
+    Pattern pattern, {
+    String errorMessage = 'Invalid format',
+  }) {
+    return _build(errorMessage, (v) => v.matches(pattern));
+  }
+
+  /// Ensures the string is one of the [allowed] values.
+  static String? Function(String?) inList(
+    Iterable<String> allowed, {
+    String errorMessage = 'Value is not allowed',
+  }) {
+    return _build(errorMessage, (v) => isIn(v, allowed));
+  }
+
+  /// Ensures the string is a finite floating-point number.
+  static String? Function(String?) float({
+    double? min,
+    double? max,
+    String errorMessage = 'Please enter a valid number',
+  }) {
+    return _build(errorMessage, (v) => v.isFloat(min: min, max: max));
+  }
+
+  /// Ensures the string's UTF-8 byte length falls within a range.
+  static String? Function(String?) byteLength(
+    int min, {
+    int? max,
+    String errorMessage = 'Length is out of range',
+  }) {
+    return _build(errorMessage, (v) => v.isByteLength(min, max));
+  }
+
+  /// Ensures the string is a strong password.
+  static String? Function(String?) strongPassword({
+    int minLength = 8,
+    int minLowercase = 1,
+    int minUppercase = 1,
+    int minNumbers = 1,
+    int minSymbols = 1,
+    String errorMessage = 'Password is not strong enough',
+  }) {
+    return _build(
+      errorMessage,
+      (v) => v.isStrongPassword(
+        minLength: minLength,
+        minLowercase: minLowercase,
+        minUppercase: minUppercase,
+        minNumbers: minNumbers,
+        minSymbols: minSymbols,
+      ),
+    );
+  }
+
   /// Internal helper to construct the validator closure
   static String? Function(String?) _build(
     String errorMessage,
diff --git a/lib/sanitizers.dart b/lib/sanitizers.dart
new file mode 100644
index 0000000..ce4a15d
--- /dev/null
+++ b/lib/sanitizers.dart
@@ -0,0 +1,13 @@
+/// String sanitizers for the flutter_validators package.
+///
+/// Provides functions that transform or coerce strings, mirroring the
+/// sanitizers offered by validator.js.
+library;
+
+export 'validators/sanitizers/blacklist.dart';
+export 'validators/sanitizers/escape.dart';
+export 'validators/sanitizers/normalize_email.dart';
+export 'validators/sanitizers/strip_low.dart';
+export 'validators/sanitizers/to_boolean.dart';
+export 'validators/sanitizers/to_number.dart';
+export 'validators/sanitizers/trim.dart';
diff --git a/lib/validators/base64.dart b/lib/validators/base64.dart
new file mode 100644
index 0000000..5ac7c8f
--- /dev/null
+++ b/lib/validators/base64.dart
@@ -0,0 +1,34 @@
+/// Checks if the string is Base64 encoded.
+///
+/// By default the standard Base64 alphabet is used. Set [urlSafe] to `true`
+/// to validate against the URL- and filename-safe alphabet.
+///
+/// Example:
+/// ```dart
+/// isBase64('aGVsbG8='); // true
+/// isBase64('aGVsbG8'); // false (invalid padding)
+/// isBase64('aGVsbG8', urlSafe: true); // true
+/// ```
+bool isBase64(String str, {bool urlSafe = false}) => _isBase64(str, urlSafe);
+
+/// Extension providing Base64 validation methods on [String].
+extension Base64X on String {
+  /// Checks if the string is Base64 encoded.
+  bool isBase64({bool urlSafe = false}) {
+    return _isBase64(this, urlSafe);
+  }
+}
+
+final _base64Standard = RegExp(
+  r'^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$',
+);
+final _base64UrlSafe = RegExp(r'^[A-Za-z0-9_-]+$');
+
+bool _isBase64(String str, bool urlSafe) {
+  if (str.isEmpty) return false;
+  if (urlSafe) {
+    return _base64UrlSafe.hasMatch(str);
+  }
+  if (str.length % 4 != 0) return false;
+  return _base64Standard.hasMatch(str);
+}
diff --git a/lib/validators/byte_length.dart b/lib/validators/byte_length.dart
new file mode 100644
index 0000000..db58562
--- /dev/null
+++ b/lib/validators/byte_length.dart
@@ -0,0 +1,28 @@
+import 'dart:convert';
+
+/// Checks if the string's UTF-8 byte length falls in a range.
+///
+/// The byte length must be at least [min]. If [max] is provided, it must
+/// also be at most [max].
+///
+/// Example:
+/// ```dart
+/// isByteLength('abc', 2); // true
+/// isByteLength('abc', 4); // false
+/// isByteLength('é', 1, 2); // true ('é' is 2 bytes in UTF-8)
+/// ```
+bool isByteLength(String str, int min, [int? max]) =>
+    _isByteLength(str, min, max);
+
+/// Extension providing byte-length validation methods on [String].
+extension ByteLengthX on String {
+  /// Checks if the string's UTF-8 byte length falls in a range.
+  bool isByteLength(int min, [int? max]) {
+    return _isByteLength(this, min, max);
+  }
+}
+
+bool _isByteLength(String str, int min, int? max) {
+  final length = utf8.encode(str).length;
+  return length >= min && (max == null || length <= max);
+}
diff --git a/lib/validators/contains.dart b/lib/validators/contains.dart
new file mode 100644
index 0000000..40752a7
--- /dev/null
+++ b/lib/validators/contains.dart
@@ -0,0 +1,25 @@
+/// Checks if the string contains the [seed] substring.
+///
+/// Set [ignoreCase] to `true` for a case-insensitive match. [minOccurrences]
+/// requires the seed to appear at least that many times.
+///
+/// Note: this is exposed only as a top-level function because [String]
+/// already provides a built-in `contains` method.
+///
+/// Example:
+/// ```dart
+/// contains('hello world', 'world'); // true
+/// contains('hello world', 'WORLD', ignoreCase: true); // true
+/// contains('a-a-a', 'a', minOccurrences: 3); // true
+/// ```
+bool contains(
+  String str,
+  String seed, {
+  bool ignoreCase = false,
+  int minOccurrences = 1,
+}) {
+  if (seed.isEmpty) return false;
+  final haystack = ignoreCase ? str.toLowerCase() : str;
+  final needle = ignoreCase ? seed.toLowerCase() : seed;
+  return needle.allMatches(haystack).length >= minOccurrences;
+}
diff --git a/lib/validators/decimal.dart b/lib/validators/decimal.dart
new file mode 100644
index 0000000..788e57e
--- /dev/null
+++ b/lib/validators/decimal.dart
@@ -0,0 +1,28 @@
+/// Checks if the string represents a decimal number.
+///
+/// Accepts an optional sign followed by digits with an optional fractional
+/// part (e.g. `1`, `-1.5`, `.5`, `+10.0`).
+///
+/// Example:
+/// ```dart
+/// isDecimal('1.5'); // true
+/// isDecimal('-0.25'); // true
+/// isDecimal('.5'); // true
+/// isDecimal('1.'); // false
+/// isDecimal('abc'); // false
+/// ```
+bool isDecimal(String str) => _isDecimal(str);
+
+/// Extension providing decimal validation methods on [String].
+extension DecimalX on String {
+  /// Checks if the string represents a decimal number.
+  bool get isDecimal {
+    return _isDecimal(this);
+  }
+}
+
+final _decimal = RegExp(r'^[+-]?(\d+(\.\d+)?|\.\d+)$');
+
+bool _isDecimal(String str) {
+  return _decimal.hasMatch(str);
+}
diff --git a/lib/validators/float.dart b/lib/validators/float.dart
new file mode 100644
index 0000000..0296e51
--- /dev/null
+++ b/lib/validators/float.dart
@@ -0,0 +1,30 @@
+/// Checks if the string represents a finite floating-point number.
+///
+/// If [min] and/or [max] are provided, the parsed value must also fall
+/// within that inclusive range.
+///
+/// Example:
+/// ```dart
+/// isFloat('1.5'); // true
+/// isFloat('-3'); // true
+/// isFloat('1.5', min: 0, max: 2); // true
+/// isFloat('5', min: 0, max: 2); // false
+/// isFloat('abc'); // false
+/// ```
+bool isFloat(String str, {double? min, double? max}) => _isFloat(str, min, max);
+
+/// Extension providing float validation methods on [String].
+extension FloatX on String {
+  /// Checks if the string represents a finite floating-point number.
+  bool isFloat({double? min, double? max}) {
+    return _isFloat(this, min, max);
+  }
+}
+
+bool _isFloat(String str, double? min, double? max) {
+  final value = double.tryParse(str);
+  if (value == null || !value.isFinite) return false;
+  if (min != null && value < min) return false;
+  if (max != null && value > max) return false;
+  return true;
+}
diff --git a/lib/validators/fqdn.dart b/lib/validators/fqdn.dart
new file mode 100644
index 0000000..67719d6
--- /dev/null
+++ b/lib/validators/fqdn.dart
@@ -0,0 +1,43 @@
+/// Checks if the string is a fully qualified domain name (FQDN).
+///
+/// Requires at least two labels separated by dots, a valid top-level domain,
+/// and labels that do not start or end with a hyphen.
+///
+/// Example:
+/// ```dart
+/// isFQDN('example.com'); // true
+/// isFQDN('sub.example.co.uk'); // true
+/// isFQDN('localhost'); // false (no TLD)
+/// isFQDN('-bad.com'); // false
+/// ```
+bool isFQDN(String str) => _isFQDN(str);
+
+/// Extension providing FQDN validation methods on [String].
+extension FQDNX on String {
+  /// Checks if the string is a fully qualified domain name (FQDN).
+  bool get isFQDN {
+    return _isFQDN(this);
+  }
+}
+
+final _fqdnLabel = RegExp(r'^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$');
+final _fqdnTld = RegExp(r'^[a-zA-Z]{2,}$|^xn--[a-zA-Z0-9]+$');
+
+bool _isFQDN(String str) {
+  if (str.isEmpty) return false;
+  var domain = str;
+  if (domain.endsWith('.')) {
+    domain = domain.substring(0, domain.length - 1);
+  }
+  final parts = domain.split('.');
+  if (parts.length < 2) return false;
+
+  final tld = parts.removeLast();
+  if (!_fqdnTld.hasMatch(tld)) return false;
+
+  for (final part in parts) {
+    if (part.isEmpty || part.length > 63) return false;
+    if (!_fqdnLabel.hasMatch(part)) return false;
+  }
+  return true;
+}
diff --git a/lib/validators/hexadecimal.dart b/lib/validators/hexadecimal.dart
new file mode 100644
index 0000000..3a6366d
--- /dev/null
+++ b/lib/validators/hexadecimal.dart
@@ -0,0 +1,26 @@
+/// Checks if the string is a hexadecimal number.
+///
+/// Accepts an optional `0x` or `0h` prefix followed by one or more
+/// hexadecimal digits.
+///
+/// Example:
+/// ```dart
+/// isHexadecimal('deadBEEF'); // true
+/// isHexadecimal('0xff'); // true
+/// isHexadecimal('xyz'); // false
+/// ```
+bool isHexadecimal(String str) => _isHexadecimal(str);
+
+/// Extension providing hexadecimal validation methods on [String].
+extension HexadecimalX on String {
+  /// Checks if the string is a hexadecimal number.
+  bool get isHexadecimal {
+    return _isHexadecimal(this);
+  }
+}
+
+final _hexadecimal = RegExp(r'^(0x|0h)?[0-9A-Fa-f]+$');
+
+bool _isHexadecimal(String str) {
+  return _hexadecimal.hasMatch(str);
+}
diff --git a/lib/validators/in.dart b/lib/validators/in.dart
new file mode 100644
index 0000000..ffeaad8
--- /dev/null
+++ b/lib/validators/in.dart
@@ -0,0 +1,20 @@
+/// Checks if the string is one of the [values].
+///
+/// Example:
+/// ```dart
+/// isIn('red', ['red', 'green', 'blue']); // true
+/// isIn('yellow', ['red', 'green', 'blue']); // false
+/// ```
+bool isIn(String str, Iterable<String> values) => _isIn(str, values);
+
+/// Extension providing membership validation methods on [String].
+extension InX on String {
+  /// Checks if the string is one of the [values].
+  bool isIn(Iterable<String> values) {
+    return _isIn(this, values);
+  }
+}
+
+bool _isIn(String str, Iterable<String> values) {
+  return values.contains(str);
+}
diff --git a/lib/validators/ip.dart b/lib/validators/ip.dart
index 9461377..9d1b684 100644
--- a/lib/validators/ip.dart
+++ b/lib/validators/ip.dart
@@ -16,12 +16,12 @@ extension IpX on String {
   bool get isIP {
     return _isIP(this);
   }
-  
+
   /// Checks if the string is a valid IPv4 address.
   bool get isIPv4 {
     return _isIP(this, 4);
   }
-  
+
   /// Checks if the string is a valid IPv6 address.
   bool get isIPv6 {
     return _isIP(this, 6);
@@ -49,6 +49,8 @@ bool _isIPv4(String str) {
 
 bool _isIPv6(String str) {
   // Common robust regex for IPv6 validation
-  final reg = RegExp(r'^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$');
+  final reg = RegExp(
+    r'^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$',
+  );
   return reg.hasMatch(str);
 }
diff --git a/lib/validators/jwt.dart b/lib/validators/jwt.dart
new file mode 100644
index 0000000..66e50be
--- /dev/null
+++ b/lib/validators/jwt.dart
@@ -0,0 +1,31 @@
+/// Checks if the string is a valid JSON Web Token (JWT).
+///
+/// A JWT consists of three base64url-encoded segments separated by dots.
+/// The signature segment may be empty (for unsigned tokens).
+///
+/// Example:
+/// ```dart
+/// isJWT('eyJhbGci.eyJzdWIi.SflKxwRJ'); // true
+/// isJWT('eyJhbGci.eyJzdWIi'); // false (only two segments)
+/// ```
+bool isJWT(String str) => _isJWT(str);
+
+/// Extension providing JWT validation methods on [String].
+extension JWTX on String {
+  /// Checks if the string is a valid JSON Web Token (JWT).
+  bool get isJWT {
+    return _isJWT(this);
+  }
+}
+
+final _base64Url = RegExp(r'^[A-Za-z0-9_-]+$');
+
+bool _isJWT(String str) {
+  final parts = str.split('.');
+  if (parts.length != 3) return false;
+  if (parts[0].isEmpty || parts[1].isEmpty) return false;
+  for (var i = 0; i < 2; i++) {
+    if (!_base64Url.hasMatch(parts[i])) return false;
+  }
+  return parts[2].isEmpty || _base64Url.hasMatch(parts[2]);
+}
diff --git a/lib/validators/lat_long.dart b/lib/validators/lat_long.dart
new file mode 100644
index 0000000..a37ef8d
--- /dev/null
+++ b/lib/validators/lat_long.dart
@@ -0,0 +1,30 @@
+/// Checks if the string is a valid `latitude,longitude` pair.
+///
+/// Latitude must be in the range -90 to 90 and longitude in the range
+/// -180 to 180. The two values are separated by a comma.
+///
+/// Example:
+/// ```dart
+/// isLatLong('40.7128,-74.0060'); // true
+/// isLatLong('0,0'); // true
+/// isLatLong('91,0'); // false (latitude out of range)
+/// ```
+bool isLatLong(String str) => _isLatLong(str);
+
+/// Extension providing latitude/longitude validation methods on [String].
+extension LatLongX on String {
+  /// Checks if the string is a valid `latitude,longitude` pair.
+  bool get isLatLong {
+    return _isLatLong(this);
+  }
+}
+
+bool _isLatLong(String str) {
+  final parts = str.split(',');
+  if (parts.length != 2) return false;
+  final lat = double.tryParse(parts[0].trim());
+  final long = double.tryParse(parts[1].trim());
+  if (lat == null || long == null) return false;
+  if (!lat.isFinite || !long.isFinite) return false;
+  return lat >= -90 && lat <= 90 && long >= -180 && long <= 180;
+}
diff --git a/lib/validators/lowercase.dart b/lib/validators/lowercase.dart
new file mode 100644
index 0000000..5358730
--- /dev/null
+++ b/lib/validators/lowercase.dart
@@ -0,0 +1,25 @@
+/// Checks if the string is entirely lowercase.
+///
+/// A string is considered lowercase if it is unchanged when converted to
+/// lower case. Strings without cased characters (digits, symbols) and the
+/// empty string are considered lowercase.
+///
+/// Example:
+/// ```dart
+/// isLowercase('hello'); // true
+/// isLowercase('hello123'); // true
+/// isLowercase('Hello'); // false
+/// ```
+bool isLowercase(String str) => _isLowercase(str);
+
+/// Extension providing lowercase validation methods on [String].
+extension LowercaseX on String {
+  /// Checks if the string is entirely lowercase.
+  bool get isLowercase {
+    return _isLowercase(this);
+  }
+}
+
+bool _isLowercase(String str) {
+  return str == str.toLowerCase();
+}
diff --git a/lib/validators/mac_address.dart b/lib/validators/mac_address.dart
new file mode 100644
index 0000000..cd42c47
--- /dev/null
+++ b/lib/validators/mac_address.dart
@@ -0,0 +1,32 @@
+/// Checks if the string is a valid MAC address.
+///
+/// Accepts EUI-48 (6-byte) and EUI-64 (8-byte) addresses using `:` or `-`
+/// as separators, as well as the separator-less form.
+///
+/// Example:
+/// ```dart
+/// isMACAddress('00:1B:44:11:3A:B7'); // true
+/// isMACAddress('00-1B-44-11-3A-B7'); // true
+/// isMACAddress('001B44113AB7'); // true
+/// isMACAddress('00:1B:44:11:3A'); // false
+/// ```
+bool isMACAddress(String str) => _isMACAddress(str);
+
+/// Extension providing MAC address validation methods on [String].
+extension MACAddressX on String {
+  /// Checks if the string is a valid MAC address.
+  bool get isMACAddress {
+    return _isMACAddress(this);
+  }
+}
+
+final _macAddress = RegExp(
+  r'^(?:[0-9A-Fa-f]{2}([:-]))(?:[0-9A-Fa-f]{2}\1){4}[0-9A-Fa-f]{2}$'
+  r'|^(?:[0-9A-Fa-f]{2}([:-]))(?:[0-9A-Fa-f]{2}\2){6}[0-9A-Fa-f]{2}$'
+  r'|^[0-9A-Fa-f]{12}$'
+  r'|^[0-9A-Fa-f]{16}$',
+);
+
+bool _isMACAddress(String str) {
+  return _macAddress.hasMatch(str);
+}
diff --git a/lib/validators/matches.dart b/lib/validators/matches.dart
new file mode 100644
index 0000000..a474967
--- /dev/null
+++ b/lib/validators/matches.dart
@@ -0,0 +1,23 @@
+/// Checks if the string matches the given [pattern].
+///
+/// The [pattern] may be a [RegExp] or any [Pattern]. A match anywhere in the
+/// string is sufficient.
+///
+/// Example:
+/// ```dart
+/// matches('abc123', RegExp(r'\d+')); // true
+/// matches('abc', RegExp(r'^\d+$')); // false
+/// ```
+bool matches(String str, Pattern pattern) => _matches(str, pattern);
+
+/// Extension providing pattern matching methods on [String].
+extension MatchesX on String {
+  /// Checks if the string matches the given [pattern].
+  bool matches(Pattern pattern) {
+    return _matches(this, pattern);
+  }
+}
+
+bool _matches(String str, Pattern pattern) {
+  return str.contains(pattern);
+}
diff --git a/lib/validators/md5.dart b/lib/validators/md5.dart
new file mode 100644
index 0000000..0ee4ce7
--- /dev/null
+++ b/lib/validators/md5.dart
@@ -0,0 +1,24 @@
+/// Checks if the string is a valid MD5 hash.
+///
+/// An MD5 hash is a 32-character hexadecimal string.
+///
+/// Example:
+/// ```dart
+/// isMD5('d41d8cd98f00b204e9800998ecf8427e'); // true
+/// isMD5('d41d8cd98f00b204e9800998ecf8427'); // false (too short)
+/// ```
+bool isMD5(String str) => _isMD5(str);
+
+/// Extension providing MD5 hash validation methods on [String].
+extension MD5X on String {
+  /// Checks if the string is a valid MD5 hash.
+  bool get isMD5 {
+    return _isMD5(this);
+  }
+}
+
+final _md5 = RegExp(r'^[0-9a-fA-F]{32}$');
+
+bool _isMD5(String str) {
+  return _md5.hasMatch(str);
+}
diff --git a/lib/validators/mongo_id.dart b/lib/validators/mongo_id.dart
new file mode 100644
index 0000000..09f06ee
--- /dev/null
+++ b/lib/validators/mongo_id.dart
@@ -0,0 +1,25 @@
+/// Checks if the string is a valid MongoDB ObjectId.
+///
+/// A MongoDB ObjectId is a 24-character hexadecimal string.
+///
+/// Example:
+/// ```dart
+/// isMongoId('507f1f77bcf86cd799439011'); // true
+/// isMongoId('507f1f77bcf86cd79943901'); // false (too short)
+/// isMongoId('zzzf1f77bcf86cd799439011'); // false
+/// ```
+bool isMongoId(String str) => _isMongoId(str);
+
+/// Extension providing MongoDB ObjectId validation methods on [String].
+extension MongoIdX on String {
+  /// Checks if the string is a valid MongoDB ObjectId.
+  bool get isMongoId {
+    return _isMongoId(this);
+  }
+}
+
+final _mongoId = RegExp(r'^[0-9a-fA-F]{24}$');
+
+bool _isMongoId(String str) {
+  return _mongoId.hasMatch(str);
+}
diff --git a/lib/validators/octal.dart b/lib/validators/octal.dart
new file mode 100644
index 0000000..f6dafcf
--- /dev/null
+++ b/lib/validators/octal.dart
@@ -0,0 +1,26 @@
+/// Checks if the string is an octal number.
+///
+/// Accepts an optional `0o` prefix followed by one or more octal digits
+/// (0–7).
+///
+/// Example:
+/// ```dart
+/// isOctal('0o123'); // true
+/// isOctal('777'); // true
+/// isOctal('088'); // false
+/// ```
+bool isOctal(String str) => _isOctal(str);
+
+/// Extension providing octal validation methods on [String].
+extension OctalX on String {
+  /// Checks if the string is an octal number.
+  bool get isOctal {
+    return _isOctal(this);
+  }
+}
+
+final _octal = RegExp(r'^(0o)?[0-7]+$');
+
+bool _isOctal(String str) {
+  return _octal.hasMatch(str);
+}
diff --git a/lib/validators/port.dart b/lib/validators/port.dart
new file mode 100644
index 0000000..cdbd822
--- /dev/null
+++ b/lib/validators/port.dart
@@ -0,0 +1,27 @@
+/// Checks if the string is a valid port number.
+///
+/// A valid port is an integer in the range 0–65535 without leading zeros.
+///
+/// Example:
+/// ```dart
+/// isPort('8080'); // true
+/// isPort('0'); // true
+/// isPort('65536'); // false (out of range)
+/// isPort('080'); // false (leading zero)
+/// ```
+bool isPort(String str) => _isPort(str);
+
+/// Extension providing port validation methods on [String].
+extension PortX on String {
+  /// Checks if the string is a valid port number.
+  bool get isPort {
+    return _isPort(this);
+  }
+}
+
+bool _isPort(String str) {
+  if (str.isEmpty) return false;
+  if (str.length > 1 && str.startsWith('0')) return false;
+  final port = int.tryParse(str);
+  return port != null && port >= 0 && port <= 65535;
+}
diff --git a/lib/validators/sanitizers/blacklist.dart b/lib/validators/sanitizers/blacklist.dart
new file mode 100644
index 0000000..4fdaa16
--- /dev/null
+++ b/lib/validators/sanitizers/blacklist.dart
@@ -0,0 +1,35 @@
+/// Removes all characters that appear in [chars] from the string.
+///
+/// Example:
+/// ```dart
+/// blacklist('hello world', 'lo'); // 'he wrd'
+/// ```
+String blacklist(String str, String chars) => _blacklist(str, chars);
+
+/// Removes all characters that do not appear in [chars] from the string.
+///
+/// Example:
+/// ```dart
+/// whitelist('hello world', 'lo'); // 'llool'
+/// ```
+String whitelist(String str, String chars) => _whitelist(str, chars);
+
+/// Extension providing character filtering sanitizers on [String].
+extension BlacklistX on String {
+  /// Removes all characters that appear in [chars] from the string.
+  String blacklist(String chars) => _blacklist(this, chars);
+
+  /// Removes all characters that do not appear in [chars] from the string.
+  String whitelist(String chars) => _whitelist(this, chars);
+}
+
+String _blacklist(String str, String chars) {
+  if (chars.isEmpty) return str;
+  final set = chars.split('').toSet();
+  return str.split('').where((c) => !set.contains(c)).join();
+}
+
+String _whitelist(String str, String chars) {
+  final set = chars.split('').toSet();
+  return str.split('').where(set.contains).join();
+}
diff --git a/lib/validators/sanitizers/escape.dart b/lib/validators/sanitizers/escape.dart
new file mode 100644
index 0000000..58cde31
--- /dev/null
+++ b/lib/validators/sanitizers/escape.dart
@@ -0,0 +1,52 @@
+/// Replaces HTML-unsafe characters with their entity equivalents.
+///
+/// Escapes `&`, `<`, `>`, `"`, `'`, `` ` ``, `/` and `\`.
+///
+/// Example:
+/// ```dart
+/// escape('<script>'); // '&lt;script&gt;'
+/// ```
+String escape(String str) => _escape(str);
+
+/// Converts HTML entities back into their unsafe character equivalents.
+///
+/// Reverses the transformation performed by [escape].
+///
+/// Example:
+/// ```dart
+/// unescape('&lt;script&gt;'); // '<script>'
+/// ```
+String unescape(String str) => _unescape(str);
+
+/// Extension providing HTML escape sanitizers on [String].
+extension EscapeX on String {
+  /// Replaces HTML-unsafe characters with their entity equivalents.
+  String escape() => _escape(this);
+
+  /// Converts HTML entities back into their unsafe character equivalents.
+  String unescape() => _unescape(this);
+}
+
+String _escape(String str) {
+  return str
+      .replaceAll('&', '&amp;')
+      .replaceAll('"', '&quot;')
+      .replaceAll("'", '&#x27;')
+      .replaceAll('<', '&lt;')
+      .replaceAll('>', '&gt;')
+      .replaceAll('/', '&#x2F;')
+      .replaceAll('\\', '&#x5C;')
+      .replaceAll('`', '&#96;');
+}
+
+String _unescape(String str) {
+  return str
+      .replaceAll('&quot;', '"')
+      .replaceAll('&#x27;', "'")
+      .replaceAll('&lt;', '<')
+      .replaceAll('&gt;', '>')
+      .replaceAll('&#x2F;', '/')
+      .replaceAll('&#x5C;', '\\')
+      .replaceAll('&#96;', '`')
+      .replaceAll('&amp;', '&');
+}
diff --git a/lib/validators/sanitizers/normalize_email.dart b/lib/validators/sanitizers/normalize_email.dart
new file mode 100644
index 0000000..b2e9410
--- /dev/null
+++ b/lib/validators/sanitizers/normalize_email.dart
@@ -0,0 +1,42 @@
+import '../email.dart';
+
+/// Canonicalizes an email address.
+///
+/// Lowercases the domain and, for Gmail addresses, lowercases the local
+/// part, removes dots and strips any `+tag` suffix. Returns `null` if the
+/// input is not a valid email address.
+///
+/// Example:
+/// ```dart
+/// normalizeEmail('Test.User+tag@GMAIL.com'); // 'testuser@gmail.com'
+/// normalizeEmail('User@Example.COM'); // 'User@example.com'
+/// normalizeEmail('not-an-email'); // null
+/// ```
+String? normalizeEmail(String str) => _normalizeEmail(str);
+
+/// Extension providing email normalization on [String].
+extension NormalizeEmailX on String {
+  /// Canonicalizes this email address, or returns `null` if invalid.
+  String? normalizeEmail() => _normalizeEmail(this);
+}
+
+String? _normalizeEmail(String str) {
+  if (!isEmail(str)) return null;
+
+  final atIndex = str.lastIndexOf('@');
+  var local = str.substring(0, atIndex);
+  final domain = str.substring(atIndex + 1).toLowerCase();
+
+  const gmailDomains = {'gmail.com', 'googlemail.com'};
+  if (gmailDomains.contains(domain)) {
+    local = local.toLowerCase();
+    final plusIndex = local.indexOf('+');
+    if (plusIndex != -1) {
+      local = local.substring(0, plusIndex);
+    }
+    local = local.replaceAll('.', '');
+    return '$local@gmail.com';
+  }
+
+  return '$local@$domain';
+}
diff --git a/lib/validators/sanitizers/strip_low.dart b/lib/validators/sanitizers/strip_low.dart
new file mode 100644
index 0000000..8518925
--- /dev/null
+++ b/lib/validators/sanitizers/strip_low.dart
@@ -0,0 +1,29 @@
+/// Removes control characters from the string.
+///
+/// Removes ASCII control characters (code points 0–31 and 127). When
+/// [keepNewLines] is `true`, line feed (`\n`), carriage return (`\r`) and
+/// horizontal tab (`\t`) are preserved.
+///
+/// Example:
+/// ```dart
+/// stripLow('hello\x00world'); // 'helloworld'
+/// stripLow('line1\nline2', keepNewLines: true); // 'line1\nline2'
+/// ```
+String stripLow(String str, {bool keepNewLines = false}) =>
+    _stripLow(str, keepNewLines);
+
+/// Extension providing control-character stripping on [String].
+extension StripLowX on String {
+  /// Removes control characters from the string.
+  String stripLow({bool keepNewLines = false}) => _stripLow(this, keepNewLines);
+}
+
+String _stripLow(String str, bool keepNewLines) {
+  return str.split('').where((c) {
+    final code = c.codeUnitAt(0);
+    if (keepNewLines && (code == 9 || code == 10 || code == 13)) {
+      return true;
+    }
+    return code > 31 && code != 127;
+  }).join();
+}
diff --git a/lib/validators/sanitizers/to_boolean.dart b/lib/validators/sanitizers/to_boolean.dart
new file mode 100644
index 0000000..de79c80
--- /dev/null
+++ b/lib/validators/sanitizers/to_boolean.dart
@@ -0,0 +1,26 @@
+/// Converts the string to a boolean.
+///
+/// In loose mode (the default) every value is `true` except `''`, `'0'`
+/// and `'false'`. In [strict] mode only `'1'` and `'true'` are `true` and
+/// everything else is `false`.
+///
+/// Example:
+/// ```dart
+/// toBoolean('true'); // true
+/// toBoolean('0'); // false
+/// toBoolean('yes', strict: true); // false
+/// ```
+bool toBoolean(String str, {bool strict = false}) => _toBoolean(str, strict);
+
+/// Extension providing boolean conversion on [String].
+extension ToBooleanX on String {
+  /// Converts this string to a boolean.
+  bool toBoolean({bool strict = false}) => _toBoolean(this, strict);
+}
+
+bool _toBoolean(String str, bool strict) {
+  if (strict) {
+    return str == '1' || str == 'true';
+  }
+  return str != '0' && str != 'false' && str != '';
+}
diff --git a/lib/validators/sanitizers/to_number.dart b/lib/validators/sanitizers/to_number.dart
new file mode 100644
index 0000000..fd2dce8
--- /dev/null
+++ b/lib/validators/sanitizers/to_number.dart
@@ -0,0 +1,46 @@
+/// Converts the string to an integer.
+///
+/// Returns `null` if the string cannot be parsed. An optional [radix]
+/// between 2 and 36 may be supplied.
+///
+/// Example:
+/// ```dart
+/// toInt('42'); // 42
+/// toInt('ff', radix: 16); // 255
+/// toInt('abc'); // null
+/// ```
+int? toInt(String str, {int? radix}) => int.tryParse(str.trim(), radix: radix);
+
+/// Converts the string to a double.
+///
+/// Returns `null` if the string cannot be parsed.
+///
+/// Example:
+/// ```dart
+/// toFloat('3.14'); // 3.14
+/// toFloat('abc'); // null
+/// ```
+double? toFloat(String str) => double.tryParse(str.trim());
+
+/// Converts the string to a [DateTime].
+///
+/// Returns `null` if the string cannot be parsed.
+///
+/// Example:
+/// ```dart
+/// toDate('2024-01-15'); // DateTime(2024, 1, 15)
+/// toDate('not-a-date'); // null
+/// ```
+DateTime? toDate(String str) => DateTime.tryParse(str.trim());
+
+/// Extension providing numeric and date conversions on [String].
+extension ToNumberX on String {
+  /// Converts this string to an integer, or `null` if it cannot be parsed.
+  int? toInt({int? radix}) => int.tryParse(trim(), radix: radix);
+
+  /// Converts this string to a double, or `null` if it cannot be parsed.
+  double? toFloat() => double.tryParse(trim());
+
+  /// Converts this string to a [DateTime], or `null` if it cannot be parsed.
+  DateTime? toDate() => DateTime.tryParse(trim());
+}
diff --git a/lib/validators/sanitizers/trim.dart b/lib/validators/sanitizers/trim.dart
new file mode 100644
index 0000000..c828248
--- /dev/null
+++ b/lib/validators/sanitizers/trim.dart
@@ -0,0 +1,62 @@
+/// Removes the given [chars] from both ends of the string.
+///
+/// If [chars] is `null`, leading and trailing whitespace is removed.
+///
+/// Example:
+/// ```dart
+/// trim('  hello  '); // 'hello'
+/// trim('xxhelloxx', 'x'); // 'hello'
+/// ```
+String trim(String str, [String? chars]) {
+  return rtrim(ltrim(str, chars), chars);
+}
+
+/// Removes the given [chars] from the start of the string.
+///
+/// If [chars] is `null`, leading whitespace is removed.
+///
+/// Example:
+/// ```dart
+/// ltrim('  hello'); // 'hello'
+/// ltrim('xxhello', 'x'); // 'hello'
+/// ```
+String ltrim(String str, [String? chars]) {
+  if (chars == null) return str.trimLeft();
+  final set = chars.split('').toSet();
+  var start = 0;
+  while (start < str.length && set.contains(str[start])) {
+    start++;
+  }
+  return str.substring(start);
+}
+
+/// Removes the given [chars] from the end of the string.
+///
+/// If [chars] is `null`, trailing whitespace is removed.
+///
+/// Example:
+/// ```dart
+/// rtrim('hello  '); // 'hello'
+/// rtrim('helloxx', 'x'); // 'hello'
+/// ```
+String rtrim(String str, [String? chars]) {
+  if (chars == null) return str.trimRight();
+  final set = chars.split('').toSet();
+  var end = str.length;
+  while (end > 0 && set.contains(str[end - 1])) {
+    end--;
+  }
+  return str.substring(0, end);
+}
+
+/// Extension providing trimming sanitizers on [String].
+extension TrimX on String {
+  /// Removes the given [chars] from both ends of the string.
+  String trimChars(String chars) => trim(this, chars);
+
+  /// Removes the given [chars] from the start of the string.
+  String ltrimChars(String chars) => ltrim(this, chars);
+
+  /// Removes the given [chars] from the end of the string.
+  String rtrimChars(String chars) => rtrim(this, chars);
+}
diff --git a/lib/validators/semver.dart b/lib/validators/semver.dart
new file mode 100644
index 0000000..72f0ca7
--- /dev/null
+++ b/lib/validators/semver.dart
@@ -0,0 +1,32 @@
+/// Checks if the string is a valid Semantic Version (SemVer).
+///
+/// Follows the official Semantic Versioning 2.0.0 specification, including
+/// optional pre-release and build metadata.
+///
+/// Example:
+/// ```dart
+/// isSemVer('1.0.0'); // true
+/// isSemVer('2.1.0-alpha.1'); // true
+/// isSemVer('1.0.0+build.5'); // true
+/// isSemVer('1.0'); // false
+/// ```
+bool isSemVer(String str) => _isSemVer(str);
+
+/// Extension providing SemVer validation methods on [String].
+extension SemVerX on String {
+  /// Checks if the string is a valid Semantic Version (SemVer).
+  bool get isSemVer {
+    return _isSemVer(this);
+  }
+}
+
+final _semver = RegExp(
+  r'^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)'
+  r'(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)'
+  r'(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?'
+  r'(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$',
+);
+
+bool _isSemVer(String str) {
+  return _semver.hasMatch(str);
+}
diff --git a/lib/validators/slug.dart b/lib/validators/slug.dart
new file mode 100644
index 0000000..92f8772
--- /dev/null
+++ b/lib/validators/slug.dart
@@ -0,0 +1,27 @@
+/// Checks if the string is a valid URL slug.
+///
+/// A slug contains only lowercase letters, digits and single hyphens, and
+/// must not start or end with a hyphen.
+///
+/// Example:
+/// ```dart
+/// isSlug('my-blog-post'); // true
+/// isSlug('post-123'); // true
+/// isSlug('-leading'); // false
+/// isSlug('double--hyphen'); // false
+/// ```
+bool isSlug(String str) => _isSlug(str);
+
+/// Extension providing slug validation methods on [String].
+extension SlugX on String {
+  /// Checks if the string is a valid URL slug.
+  bool get isSlug {
+    return _isSlug(this);
+  }
+}
+
+final _slug = RegExp(r'^[a-z0-9]+(?:-[a-z0-9]+)*$');
+
+bool _isSlug(String str) {
+  return _slug.hasMatch(str);
+}
diff --git a/lib/validators/strong_password.dart b/lib/validators/strong_password.dart
new file mode 100644
index 0000000..d16fcd7
--- /dev/null
+++ b/lib/validators/strong_password.dart
@@ -0,0 +1,69 @@
+/// Checks if the string is a strong password.
+///
+/// By default the password must be at least 8 characters long and contain
+/// at least one lowercase letter, one uppercase letter, one digit and one
+/// symbol. Each requirement is configurable.
+///
+/// Example:
+/// ```dart
+/// isStrongPassword('Abcd1234!'); // true
+/// isStrongPassword('weak'); // false
+/// isStrongPassword('abcdefgh', minUppercase: 0, minNumbers: 0, minSymbols: 0); // true
+/// ```
+bool isStrongPassword(
+  String str, {
+  int minLength = 8,
+  int minLowercase = 1,
+  int minUppercase = 1,
+  int minNumbers = 1,
+  int minSymbols = 1,
+}) => _isStrongPassword(
+  str,
+  minLength,
+  minLowercase,
+  minUppercase,
+  minNumbers,
+  minSymbols,
+);
+
+/// Extension providing strong-password validation methods on [String].
+extension StrongPasswordX on String {
+  /// Checks if the string is a strong password.
+  bool isStrongPassword({
+    int minLength = 8,
+    int minLowercase = 1,
+    int minUppercase = 1,
+    int minNumbers = 1,
+    int minSymbols = 1,
+  }) {
+    return _isStrongPassword(
+      this,
+      minLength,
+      minLowercase,
+      minUppercase,
+      minNumbers,
+      minSymbols,
+    );
+  }
+}
+
+final _lowercase = RegExp(r'[a-z]');
+final _uppercase = RegExp(r'[A-Z]');
+final _numbers = RegExp(r'[0-9]');
+final _symbols = RegExp(r'[^a-zA-Z0-9]');
+
+bool _isStrongPassword(
+  String str,
+  int minLength,
+  int minLowercase,
+  int minUppercase,
+  int minNumbers,
+  int minSymbols,
+) {
+  if (str.length < minLength) return false;
+  if (_lowercase.allMatches(str).length < minLowercase) return false;
+  if (_uppercase.allMatches(str).length < minUppercase) return false;
+  if (_numbers.allMatches(str).length < minNumbers) return false;
+  if (_symbols.allMatches(str).length < minSymbols) return false;
+  return true;
+}
diff --git a/lib/validators/uppercase.dart b/lib/validators/uppercase.dart
new file mode 100644
index 0000000..6951cd2
--- /dev/null
+++ b/lib/validators/uppercase.dart
@@ -0,0 +1,25 @@
+/// Checks if the string is entirely uppercase.
+///
+/// A string is considered uppercase if it is unchanged when converted to
+/// upper case. Strings without cased characters (digits, symbols) and the
+/// empty string are considered uppercase.
+///
+/// Example:
+/// ```dart
+/// isUppercase('HELLO'); // true
+/// isUppercase('HELLO123'); // true
+/// isUppercase('Hello'); // false
+/// ```
+bool isUppercase(String str) => _isUppercase(str);
+
+/// Extension providing uppercase validation methods on [String].
+extension UppercaseX on String {
+  /// Checks if the string is entirely uppercase.
+  bool get isUppercase {
+    return _isUppercase(this);
+  }
+}
+
+bool _isUppercase(String str) {
+  return str == str.toUpperCase();
+}
diff --git a/lib/validators/url.dart b/lib/validators/url.dart
index fc9bdb6..5ea0e1e 100644
--- a/lib/validators/url.dart
+++ b/lib/validators/url.dart
@@ -20,5 +20,7 @@ extension UrlX on String {
 bool _isURL(String str) {
   if (str.isEmpty) return false;
   final uri = Uri.tryParse(str);
-  return uri != null && uri.hasAuthority && (uri.scheme == 'http' || uri.scheme == 'https');
+  return uri != null &&
+      uri.hasAuthority &&
+      (uri.scheme == 'http' || uri.scheme == 'https');
 }
diff --git a/lib/validators/uuid.dart b/lib/validators/uuid.dart
index 33ab535..8457d36 100644
--- a/lib/validators/uuid.dart
+++ b/lib/validators/uuid.dart
@@ -18,5 +18,7 @@ extension UuidX on String {
 }
 
 bool _isUUID(String str) {
-  return RegExp(r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1345][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$').hasMatch(str);
+  return RegExp(
+    r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1345][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$',
+  ).hasMatch(str);
 }
diff --git a/pubspec.yaml b/pubspec.yaml
index 93a60a9..5266381 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: flutter_validators
 description: A pure dart package of String validators and sanitizers. Inspired by validator.js.
-version: 1.1.0
+version: 1.2.0
 homepage: https://github.com/divyanshub024/flutter_validator
 repository: https://github.com/divyanshub024/flutter_validator
 
diff --git a/test/form_validator_test.dart b/test/form_validator_test.dart
index 696c73a..d27b2e6 100644
--- a/test/form_validator_test.dart
+++ b/test/form_validator_test.dart
@@ -1,5 +1,5 @@
 import 'package:flutter_validators/form_validator.dart';
-import 'package:test/test.dart';
+import 'package:test/test.dart' hide contains, isIn;
 
 void main() {
   group('Flutter Form Validator Tests', () {
@@ -15,7 +15,10 @@ void main() {
       final email = Validator.email(errorMessage: 'Bad email');
       expect(email('user@example.com'), isNull);
       expect(email('invalid'), equals('Bad email'));
-      expect(email(''), isNull); // Empty strings are treated as valid (use 'required' for emptiness check)
+      expect(
+        email(''),
+        isNull,
+      ); // Empty strings are treated as valid (use 'required' for emptiness check)
       expect(email(null), isNull);
     });
 
@@ -25,5 +28,265 @@ void main() {
       expect(len('ab'), equals('Bad len'));
       expect(len('abcdef'), equals('Bad len'));
     });
+
+    test('Empty values are valid for all non-required validators', () {
+      expect(Validator.url()(''), isNull);
+      expect(Validator.url()(null), isNull);
+      expect(Validator.email()(null), isNull);
+    });
+
+    test('URL validator', () {
+      final url = Validator.url(errorMessage: 'Bad URL');
+      expect(url('https://example.com'), isNull);
+      expect(url('not a url'), equals('Bad URL'));
+    });
+
+    test('IP validator', () {
+      final ip = Validator.ip(errorMessage: 'Bad IP');
+      expect(ip('192.168.1.1'), isNull);
+      expect(ip('999.999.999.999'), equals('Bad IP'));
+      expect(Validator.ip(version: 4)('192.168.1.1'), isNull);
+    });
+
+    test('Date validator', () {
+      final date = Validator.date(errorMessage: 'Bad date');
+      expect(date('2024-01-15'), isNull);
+      expect(date('not-a-date'), equals('Bad date'));
+    });
+
+    test('Numeric validator', () {
+      final numeric = Validator.numeric(errorMessage: 'Bad number');
+      expect(numeric('123.45'), isNull);
+      expect(numeric('abc'), equals('Bad number'));
+    });
+
+    test('Integer validator', () {
+      final integer = Validator.integer(errorMessage: 'Bad int');
+      expect(integer('42'), isNull);
+      expect(integer('4.2'), equals('Bad int'));
+    });
+
+    test('Alpha validator', () {
+      final alpha = Validator.alpha(errorMessage: 'Bad alpha');
+      expect(alpha('abc'), isNull);
+      expect(alpha('abc1'), equals('Bad alpha'));
+    });
+
+    test('Alphanumeric validator', () {
+      final alphanumeric = Validator.alphanumeric(errorMessage: 'Bad');
+      expect(alphanumeric('abc123'), isNull);
+      expect(alphanumeric('abc!'), equals('Bad'));
+    });
+
+    test('Phone validator', () {
+      final phone = Validator.phone(errorMessage: 'Bad phone');
+      expect(phone('+1234567890'), isNull);
+      expect(phone('abc'), equals('Bad phone'));
+    });
+
+    test('Credit card validator', () {
+      final creditCard = Validator.creditCard(errorMessage: 'Bad card');
+      expect(creditCard('4111111111111111'), isNull);
+      expect(creditCard('1234'), equals('Bad card'));
+    });
+
+    test('JSON validator', () {
+      final json = Validator.json(errorMessage: 'Bad JSON');
+      expect(json('{"a":1}'), isNull);
+      expect(json('{bad'), equals('Bad JSON'));
+    });
+
+    test('UUID validator', () {
+      final uuid = Validator.uuid(errorMessage: 'Bad UUID');
+      expect(uuid('550e8400-e29b-41d4-a716-446655440000'), isNull);
+      expect(uuid('not-a-uuid'), equals('Bad UUID'));
+    });
+
+    test('Hex color validator', () {
+      final hexColor = Validator.hexColor(errorMessage: 'Bad color');
+      expect(hexColor('#ff0000'), isNull);
+      expect(hexColor('zzz'), equals('Bad color'));
+    });
+
+    test('ASCII validator', () {
+      final ascii = Validator.ascii(errorMessage: 'Bad ASCII');
+      expect(ascii('hello'), isNull);
+      expect(ascii('héllo'), equals('Bad ASCII'));
+    });
+
+    test('Base32 validator', () {
+      final base32 = Validator.base32(errorMessage: 'Bad base32');
+      expect(base32('JBSWY3DP'), isNull);
+      expect(base32('1'), equals('Bad base32'));
+    });
+
+    test('Base58 validator', () {
+      final base58 = Validator.base58(errorMessage: 'Bad base58');
+      expect(base58('3yDKLZJ4PC1HE4Y8L8Esx'), isNull);
+      expect(base58('0OIl'), equals('Bad base58'));
+    });
+
+    test('Boolean validator', () {
+      final boolean = Validator.boolean(errorMessage: 'Bad boolean');
+      expect(boolean('true'), isNull);
+      expect(boolean('maybe'), equals('Bad boolean'));
+    });
+
+    test('Equals validator', () {
+      final eq = Validator.equals('secret', errorMessage: 'No match');
+      expect(eq('secret'), isNull);
+      expect(eq('other'), equals('No match'));
+    });
+
+    test('Lowercase validator', () {
+      final lowercase = Validator.lowercase(errorMessage: 'Bad case');
+      expect(lowercase('hello'), isNull);
+      expect(lowercase('Hello'), equals('Bad case'));
+    });
+
+    test('Uppercase validator', () {
+      final uppercase = Validator.uppercase(errorMessage: 'Bad case');
+      expect(uppercase('HELLO'), isNull);
+      expect(uppercase('Hello'), equals('Bad case'));
+    });
+
+    test('Hexadecimal validator', () {
+      final hexadecimal = Validator.hexadecimal(errorMessage: 'Bad hex');
+      expect(hexadecimal('deadBEEF'), isNull);
+      expect(hexadecimal('xyz'), equals('Bad hex'));
+    });
+
+    test('Octal validator', () {
+      final octal = Validator.octal(errorMessage: 'Bad octal');
+      expect(octal('777'), isNull);
+      expect(octal('088'), equals('Bad octal'));
+    });
+
+    test('Decimal validator', () {
+      final decimal = Validator.decimal(errorMessage: 'Bad decimal');
+      expect(decimal('1.5'), isNull);
+      expect(decimal('1.'), equals('Bad decimal'));
+    });
+
+    test('Float validator', () {
+      final float = Validator.float(errorMessage: 'Bad float');
+      expect(float('3.14'), isNull);
+      expect(float('abc'), equals('Bad float'));
+      final ranged = Validator.float(min: 0, max: 10, errorMessage: 'Range');
+      expect(ranged('5'), isNull);
+      expect(ranged('20'), equals('Range'));
+    });
+
+    test('MongoId validator', () {
+      final mongoId = Validator.mongoId(errorMessage: 'Bad id');
+      expect(mongoId('507f1f77bcf86cd799439011'), isNull);
+      expect(mongoId('507f1f77'), equals('Bad id'));
+    });
+
+    test('MD5 validator', () {
+      final md5 = Validator.md5(errorMessage: 'Bad hash');
+      expect(md5('d41d8cd98f00b204e9800998ecf8427e'), isNull);
+      expect(md5('abc'), equals('Bad hash'));
+    });
+
+    test('Port validator', () {
+      final port = Validator.port(errorMessage: 'Bad port');
+      expect(port('8080'), isNull);
+      expect(port('65536'), equals('Bad port'));
+    });
+
+    test('SemVer validator', () {
+      final semVer = Validator.semVer(errorMessage: 'Bad version');
+      expect(semVer('1.2.3'), isNull);
+      expect(semVer('1.2'), equals('Bad version'));
+    });
+
+    test('Slug validator', () {
+      final slug = Validator.slug(errorMessage: 'Bad slug');
+      expect(slug('my-blog-post'), isNull);
+      expect(slug('Bad Slug'), equals('Bad slug'));
+    });
+
+    test('MAC address validator', () {
+      final macAddress = Validator.macAddress(errorMessage: 'Bad MAC');
+      expect(macAddress('00:1B:44:11:3A:B7'), isNull);
+      expect(macAddress('00:1B:44'), equals('Bad MAC'));
+    });
+
+    test('LatLong validator', () {
+      final latLong = Validator.latLong(errorMessage: 'Bad coords');
+      expect(latLong('40.7128,-74.0060'), isNull);
+      expect(latLong('91,0'), equals('Bad coords'));
+    });
+
+    test('JWT validator', () {
+      final jwt = Validator.jwt(errorMessage: 'Bad JWT');
+      expect(jwt('eyJhbGci.eyJzdWIi.SflKxwRJ'), isNull);
+      expect(jwt('eyJhbGci.eyJzdWIi'), equals('Bad JWT'));
+    });
+
+    test('FQDN validator', () {
+      final fqdn = Validator.fqdn(errorMessage: 'Bad domain');
+      expect(fqdn('example.com'), isNull);
+      expect(fqdn('localhost'), equals('Bad domain'));
+    });
+
+    test('Base64 validator', () {
+      final base64 = Validator.base64(errorMessage: 'Bad base64');
+      expect(base64('aGVsbG8='), isNull);
+      expect(base64('@@@@'), equals('Bad base64'));
+      final urlSafe = Validator.base64(urlSafe: true, errorMessage: 'Bad url64');
+      expect(urlSafe('a-b_c'), isNull);
+    });
+
+    test('ByteLength validator', () {
+      final byteLength = Validator.byteLength(2, max: 5, errorMessage: 'Bad len');
+      expect(byteLength('abc'), isNull);
+      expect(byteLength('a'), equals('Bad len'));
+      expect(byteLength('abcdef'), equals('Bad len'));
+    });
+
+    test('StrongPassword validator', () {
+      final strongPassword = Validator.strongPassword(errorMessage: 'Weak');
+      expect(strongPassword('Abcd1234!'), isNull);
+      expect(strongPassword('weak'), equals('Weak'));
+      final relaxed = Validator.strongPassword(
+        minUppercase: 0,
+        minNumbers: 0,
+        minSymbols: 0,
+        errorMessage: 'Weak',
+      );
+      expect(relaxed('abcdefgh'), isNull);
+    });
+
+    test('Contains validator', () {
+      final containsWorld = Validator.contains('world', errorMessage: 'Missing');
+      expect(containsWorld('hello world'), isNull);
+      expect(containsWorld('hello there'), equals('Missing'));
+      final caseInsensitive = Validator.contains(
+        'WORLD',
+        ignoreCase: true,
+        errorMessage: 'Missing',
+      );
+      expect(caseInsensitive('hello world'), isNull);
+    });
+
+    test('Matches validator', () {
+      final matches = Validator.matches(
+        RegExp(r'^\d{4}$'),
+        errorMessage: 'Bad format',
+      );
+      expect(matches('1234'), isNull);
+      expect(matches('abc'), equals('Bad format'));
+    });
+
+    test('InList validator', () {
+      final inList = Validator.inList(
+        ['red', 'green', 'blue'],
+        errorMessage: 'Not allowed',
+      );
+      expect(inList('red'), isNull);
+      expect(inList('yellow'), equals('Not allowed'));
+    });
   });
 }
diff --git a/test/validators/base32_test.dart b/test/validators/base32_test.dart
index 18a3d3f..375c8ce 100644
--- a/test/validators/base32_test.dart
+++ b/test/validators/base32_test.dart
@@ -13,7 +13,7 @@ void main() {
       expect('hello world'.isBase32, isFalse);
       expect('JBSWY3DPEHPK3PXP1'.isBase32, isFalse); // contains '1'
       expect(''.isBase32, isFalse);
-      
+
       // Invalid padding (pad counts not in 1, 3, 4, 6)
       expect('ABC====='.isBase32, isFalse); // pad count 5
       expect('ABCDEF=='.isBase32, isFalse); // pad count 2
diff --git a/test/validators/base58_test.dart b/test/validators/base58_test.dart
index 6776ab2..124899d 100644
--- a/test/validators/base58_test.dart
+++ b/test/validators/base58_test.dart
@@ -5,13 +5,19 @@ void main() {
   group('Base58 Validator Tests', () {
     test('Valid base58', () {
       expect('3yDKLZJ4PC1HE4Y8L8Esx'.isBase58, isTrue);
-      expect('1BgGZ9tcN4rm9KBzNd7iFaNWEjc2xewGuk'.isBase58, isTrue); // Bitcoin address
+      expect(
+        '1BgGZ9tcN4rm9KBzNd7iFaNWEjc2xewGuk'.isBase58,
+        isTrue,
+      ); // Bitcoin address
     });
 
     test('Invalid base58', () {
       expect('hello 0OIl world'.isBase58, isFalse);
       expect(''.isBase58, isFalse);
-      expect('1BgGZ9tcN4rm9KBzNd7iFaNWEj02xewGuk'.isBase58, isFalse); // contains '0'
+      expect(
+        '1BgGZ9tcN4rm9KBzNd7iFaNWEj02xewGuk'.isBase58,
+        isFalse,
+      ); // contains '0'
     });
   });
 }
diff --git a/test/validators/base64_test.dart b/test/validators/base64_test.dart
new file mode 100644
index 0000000..24cb1db
--- /dev/null
+++ b/test/validators/base64_test.dart
@@ -0,0 +1,23 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Base64 Validator Tests', () {
+    test('Valid Base64 strings', () {
+      expect('aGVsbG8='.isBase64(), isTrue);
+      expect('aGVsbG8gd29ybGQ='.isBase64(), isTrue);
+      expect(isBase64('Zm9v'), isTrue);
+    });
+
+    test('Valid URL-safe Base64 strings', () {
+      expect('aGVsbG8'.isBase64(urlSafe: true), isTrue);
+      expect(isBase64('a-b_c', urlSafe: true), isTrue);
+    });
+
+    test('Invalid Base64 strings', () {
+      expect('aGVsbG8'.isBase64(), isFalse); // bad padding
+      expect('@@@@'.isBase64(), isFalse);
+      expect(''.isBase64(), isFalse);
+    });
+  });
+}
diff --git a/test/validators/byte_length_test.dart b/test/validators/byte_length_test.dart
new file mode 100644
index 0000000..b755019
--- /dev/null
+++ b/test/validators/byte_length_test.dart
@@ -0,0 +1,19 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('ByteLength Validator Tests', () {
+    test('Within range', () {
+      expect('abc'.isByteLength(2), isTrue);
+      expect('abc'.isByteLength(1, 3), isTrue);
+      expect('é'.isByteLength(2, 2), isTrue); // 2 bytes in UTF-8
+      expect(isByteLength('hello', 0, 10), isTrue);
+    });
+
+    test('Out of range', () {
+      expect('abc'.isByteLength(4), isFalse);
+      expect('abcdef'.isByteLength(1, 3), isFalse);
+      expect('é'.isByteLength(0, 1), isFalse);
+    });
+  });
+}
diff --git a/test/validators/contains_test.dart b/test/validators/contains_test.dart
new file mode 100644
index 0000000..29cc129
--- /dev/null
+++ b/test/validators/contains_test.dart
@@ -0,0 +1,26 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart' hide contains;
+
+void main() {
+  group('Contains Validator Tests', () {
+    test('Substring present', () {
+      expect(contains('hello world', 'world'), isTrue);
+      expect(contains('hello world', 'hello'), isTrue);
+    });
+
+    test('Case-insensitive match', () {
+      expect(contains('Hello World', 'world'), isFalse);
+      expect(contains('Hello World', 'world', ignoreCase: true), isTrue);
+    });
+
+    test('Minimum occurrences', () {
+      expect(contains('a-a-a', 'a', minOccurrences: 3), isTrue);
+      expect(contains('a-a-a', 'a', minOccurrences: 4), isFalse);
+    });
+
+    test('Substring absent', () {
+      expect(contains('hello world', 'xyz'), isFalse);
+      expect(contains('hello', ''), isFalse);
+    });
+  });
+}
diff --git a/test/validators/decimal_test.dart b/test/validators/decimal_test.dart
new file mode 100644
index 0000000..7ca9a41
--- /dev/null
+++ b/test/validators/decimal_test.dart
@@ -0,0 +1,21 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Decimal Validator Tests', () {
+    test('Valid decimal numbers', () {
+      expect('1.5'.isDecimal, isTrue);
+      expect('-0.25'.isDecimal, isTrue);
+      expect('.5'.isDecimal, isTrue);
+      expect('42'.isDecimal, isTrue);
+      expect(isDecimal('+10.0'), isTrue);
+    });
+
+    test('Invalid decimal numbers', () {
+      expect('1.'.isDecimal, isFalse);
+      expect('abc'.isDecimal, isFalse);
+      expect('1.2.3'.isDecimal, isFalse);
+      expect(''.isDecimal, isFalse);
+    });
+  });
+}
diff --git a/test/validators/float_test.dart b/test/validators/float_test.dart
new file mode 100644
index 0000000..d485bb8
--- /dev/null
+++ b/test/validators/float_test.dart
@@ -0,0 +1,25 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Float Validator Tests', () {
+    test('Valid floats', () {
+      expect('1.5'.isFloat(), isTrue);
+      expect('-3'.isFloat(), isTrue);
+      expect('0'.isFloat(), isTrue);
+      expect(isFloat('3.14159'), isTrue);
+    });
+
+    test('Range constraints', () {
+      expect('1.5'.isFloat(min: 0, max: 2), isTrue);
+      expect('5'.isFloat(min: 0, max: 2), isFalse);
+      expect('-1'.isFloat(min: 0), isFalse);
+    });
+
+    test('Invalid floats', () {
+      expect('abc'.isFloat(), isFalse);
+      expect(''.isFloat(), isFalse);
+      expect('Infinity'.isFloat(), isFalse);
+    });
+  });
+}
diff --git a/test/validators/fqdn_test.dart b/test/validators/fqdn_test.dart
new file mode 100644
index 0000000..bfea867
--- /dev/null
+++ b/test/validators/fqdn_test.dart
@@ -0,0 +1,21 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('FQDN Validator Tests', () {
+    test('Valid domain names', () {
+      expect('example.com'.isFQDN, isTrue);
+      expect('sub.example.co.uk'.isFQDN, isTrue);
+      expect('my-site.org'.isFQDN, isTrue);
+      expect(isFQDN('example.com.'), isTrue); // trailing dot allowed
+    });
+
+    test('Invalid domain names', () {
+      expect('localhost'.isFQDN, isFalse);
+      expect('-bad.com'.isFQDN, isFalse);
+      expect('bad-.com'.isFQDN, isFalse);
+      expect('example.c'.isFQDN, isFalse); // TLD too short
+      expect(''.isFQDN, isFalse);
+    });
+  });
+}
diff --git a/test/validators/hexadecimal_test.dart b/test/validators/hexadecimal_test.dart
new file mode 100644
index 0000000..c69bcdf
--- /dev/null
+++ b/test/validators/hexadecimal_test.dart
@@ -0,0 +1,21 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Hexadecimal Validator Tests', () {
+    test('Valid hexadecimal numbers', () {
+      expect('deadBEEF'.isHexadecimal, isTrue);
+      expect('0xff'.isHexadecimal, isTrue);
+      expect('0h1a'.isHexadecimal, isTrue);
+      expect('123abc'.isHexadecimal, isTrue);
+      expect(isHexadecimal('FF'), isTrue);
+    });
+
+    test('Invalid hexadecimal numbers', () {
+      expect('xyz'.isHexadecimal, isFalse);
+      expect(''.isHexadecimal, isFalse);
+      expect('0x'.isHexadecimal, isFalse);
+      expect('12 34'.isHexadecimal, isFalse);
+    });
+  });
+}
diff --git a/test/validators/in_test.dart b/test/validators/in_test.dart
new file mode 100644
index 0000000..90e8e14
--- /dev/null
+++ b/test/validators/in_test.dart
@@ -0,0 +1,18 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart' hide isIn;
+
+void main() {
+  group('In Validator Tests', () {
+    const colors = ['red', 'green', 'blue'];
+
+    test('Value in list', () {
+      expect('red'.isIn(colors), isTrue);
+      expect(isIn('blue', colors), isTrue);
+    });
+
+    test('Value not in list', () {
+      expect('yellow'.isIn(colors), isFalse);
+      expect(isIn('', colors), isFalse);
+    });
+  });
+}
diff --git a/test/validators/jwt_test.dart b/test/validators/jwt_test.dart
new file mode 100644
index 0000000..488b064
--- /dev/null
+++ b/test/validators/jwt_test.dart
@@ -0,0 +1,20 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('JWT Validator Tests', () {
+    test('Valid JWTs', () {
+      expect('eyJhbGci.eyJzdWIi.SflKxwRJ'.isJWT, isTrue);
+      expect('aaa.bbb.'.isJWT, isTrue); // empty signature allowed
+      expect(isJWT('header-1.payload_2.sig3'), isTrue);
+    });
+
+    test('Invalid JWTs', () {
+      expect('eyJhbGci.eyJzdWIi'.isJWT, isFalse); // two segments
+      expect('a.b.c.d'.isJWT, isFalse); // four segments
+      expect('.b.c'.isJWT, isFalse); // empty header
+      expect('a b.c.d'.isJWT, isFalse); // invalid char
+      expect(''.isJWT, isFalse);
+    });
+  });
+}
diff --git a/test/validators/lat_long_test.dart b/test/validators/lat_long_test.dart
new file mode 100644
index 0000000..84dcd74
--- /dev/null
+++ b/test/validators/lat_long_test.dart
@@ -0,0 +1,22 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('LatLong Validator Tests', () {
+    test('Valid coordinates', () {
+      expect('40.7128,-74.0060'.isLatLong, isTrue);
+      expect('0,0'.isLatLong, isTrue);
+      expect('90,180'.isLatLong, isTrue);
+      expect('-90,-180'.isLatLong, isTrue);
+      expect(isLatLong('12.34, 56.78'), isTrue);
+    });
+
+    test('Invalid coordinates', () {
+      expect('91,0'.isLatLong, isFalse);
+      expect('0,181'.isLatLong, isFalse);
+      expect('40.7128'.isLatLong, isFalse);
+      expect('abc,def'.isLatLong, isFalse);
+      expect(''.isLatLong, isFalse);
+    });
+  });
+}
diff --git a/test/validators/lowercase_test.dart b/test/validators/lowercase_test.dart
new file mode 100644
index 0000000..cc3e41c
--- /dev/null
+++ b/test/validators/lowercase_test.dart
@@ -0,0 +1,20 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Lowercase Validator Tests', () {
+    test('Valid lowercase strings', () {
+      expect('hello'.isLowercase, isTrue);
+      expect('hello123'.isLowercase, isTrue);
+      expect('123'.isLowercase, isTrue);
+      expect(''.isLowercase, isTrue);
+      expect(isLowercase('abc'), isTrue);
+    });
+
+    test('Invalid lowercase strings', () {
+      expect('Hello'.isLowercase, isFalse);
+      expect('HELLO'.isLowercase, isFalse);
+      expect(isLowercase('aBc'), isFalse);
+    });
+  });
+}
diff --git a/test/validators/mac_address_test.dart b/test/validators/mac_address_test.dart
new file mode 100644
index 0000000..035ef2d
--- /dev/null
+++ b/test/validators/mac_address_test.dart
@@ -0,0 +1,21 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('MAC Address Validator Tests', () {
+    test('Valid MAC addresses', () {
+      expect('00:1B:44:11:3A:B7'.isMACAddress, isTrue);
+      expect('00-1B-44-11-3A-B7'.isMACAddress, isTrue);
+      expect('001B44113AB7'.isMACAddress, isTrue);
+      expect('00:1B:44:11:3A:B7:8C:9D'.isMACAddress, isTrue); // EUI-64
+      expect(isMACAddress('aa:bb:cc:dd:ee:ff'), isTrue);
+    });
+
+    test('Invalid MAC addresses', () {
+      expect('00:1B:44:11:3A'.isMACAddress, isFalse);
+      expect('00:1B:44:11:3A:GG'.isMACAddress, isFalse);
+      expect('001B44113AB'.isMACAddress, isFalse);
+      expect(''.isMACAddress, isFalse);
+    });
+  });
+}
diff --git a/test/validators/matches_test.dart b/test/validators/matches_test.dart
new file mode 100644
index 0000000..d38f37d
--- /dev/null
+++ b/test/validators/matches_test.dart
@@ -0,0 +1,17 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart' hide matches;
+
+void main() {
+  group('Matches Validator Tests', () {
+    test('Pattern matches', () {
+      expect('abc123'.matches(RegExp(r'\d+')), isTrue);
+      expect('hello'.matches('ell'), isTrue);
+      expect(matches('2024-01-15', RegExp(r'^\d{4}-\d{2}-\d{2}$')), isTrue);
+    });
+
+    test('Pattern does not match', () {
+      expect('abc'.matches(RegExp(r'^\d+$')), isFalse);
+      expect(matches('hello', RegExp(r'\d')), isFalse);
+    });
+  });
+}
diff --git a/test/validators/md5_test.dart b/test/validators/md5_test.dart
new file mode 100644
index 0000000..c0addc9
--- /dev/null
+++ b/test/validators/md5_test.dart
@@ -0,0 +1,18 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('MD5 Validator Tests', () {
+    test('Valid MD5 hashes', () {
+      expect('d41d8cd98f00b204e9800998ecf8427e'.isMD5, isTrue);
+      expect('D41D8CD98F00B204E9800998ECF8427E'.isMD5, isTrue);
+      expect(isMD5('0cc175b9c0f1b6a831c399e269772661'), isTrue);
+    });
+
+    test('Invalid MD5 hashes', () {
+      expect('d41d8cd98f00b204e9800998ecf8427'.isMD5, isFalse); // 31 chars
+      expect('z41d8cd98f00b204e9800998ecf8427e'.isMD5, isFalse);
+      expect(''.isMD5, isFalse);
+    });
+  });
+}
diff --git a/test/validators/mongo_id_test.dart b/test/validators/mongo_id_test.dart
new file mode 100644
index 0000000..000ac26
--- /dev/null
+++ b/test/validators/mongo_id_test.dart
@@ -0,0 +1,19 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('MongoId Validator Tests', () {
+    test('Valid MongoDB ObjectIds', () {
+      expect('507f1f77bcf86cd799439011'.isMongoId, isTrue);
+      expect('507F1F77BCF86CD799439011'.isMongoId, isTrue);
+      expect(isMongoId('aaaaaaaaaaaaaaaaaaaaaaaa'), isTrue);
+    });
+
+    test('Invalid MongoDB ObjectIds', () {
+      expect('507f1f77bcf86cd79943901'.isMongoId, isFalse); // too short
+      expect('507f1f77bcf86cd7994390111'.isMongoId, isFalse); // too long
+      expect('zzzf1f77bcf86cd799439011'.isMongoId, isFalse);
+      expect(''.isMongoId, isFalse);
+    });
+  });
+}
diff --git a/test/validators/octal_test.dart b/test/validators/octal_test.dart
new file mode 100644
index 0000000..4acefad
--- /dev/null
+++ b/test/validators/octal_test.dart
@@ -0,0 +1,20 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Octal Validator Tests', () {
+    test('Valid octal numbers', () {
+      expect('777'.isOctal, isTrue);
+      expect('0o123'.isOctal, isTrue);
+      expect('0'.isOctal, isTrue);
+      expect(isOctal('01234567'), isTrue);
+    });
+
+    test('Invalid octal numbers', () {
+      expect('088'.isOctal, isFalse);
+      expect('9'.isOctal, isFalse);
+      expect(''.isOctal, isFalse);
+      expect('0o'.isOctal, isFalse);
+    });
+  });
+}
diff --git a/test/validators/port_test.dart b/test/validators/port_test.dart
new file mode 100644
index 0000000..7734580
--- /dev/null
+++ b/test/validators/port_test.dart
@@ -0,0 +1,22 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Port Validator Tests', () {
+    test('Valid ports', () {
+      expect('0'.isPort, isTrue);
+      expect('80'.isPort, isTrue);
+      expect('8080'.isPort, isTrue);
+      expect('65535'.isPort, isTrue);
+      expect(isPort('443'), isTrue);
+    });
+
+    test('Invalid ports', () {
+      expect('65536'.isPort, isFalse);
+      expect('-1'.isPort, isFalse);
+      expect('080'.isPort, isFalse); // leading zero
+      expect('abc'.isPort, isFalse);
+      expect(''.isPort, isFalse);
+    });
+  });
+}
diff --git a/test/validators/sanitizers/blacklist_test.dart b/test/validators/sanitizers/blacklist_test.dart
new file mode 100644
index 0000000..98c8292
--- /dev/null
+++ b/test/validators/sanitizers/blacklist_test.dart
@@ -0,0 +1,16 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Blacklist / Whitelist Sanitizer Tests', () {
+    test('blacklist removes listed characters', () {
+      expect(blacklist('hello world', 'lo'), 'he wrd');
+      expect('abc123'.blacklist('123'), 'abc');
+    });
+
+    test('whitelist keeps only listed characters', () {
+      expect(whitelist('hello world', 'lo'), 'llool');
+      expect('abc123'.whitelist('123'), '123');
+    });
+  });
+}
diff --git a/test/validators/sanitizers/escape_test.dart b/test/validators/sanitizers/escape_test.dart
new file mode 100644
index 0000000..51687d7
--- /dev/null
+++ b/test/validators/sanitizers/escape_test.dart
@@ -0,0 +1,21 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart' hide escape;
+
+void main() {
+  group('Escape Sanitizer Tests', () {
+    test('escape HTML-unsafe characters', () {
+      expect(escape('<script>'), '&lt;script&gt;');
+      expect(escape('a & b'), 'a &amp; b');
+      expect('"quote"'.escape(), '&quot;quote&quot;');
+    });
+
+    test('unescape reverses escape', () {
+      expect(unescape('&lt;script&gt;'), '<script>');
+      expect(
+        unescape(escape('<a href="x">& \'/\'</a>')),
+        '<a href="x">& \'/\'</a>',
+      );
+      expect('&amp;'.unescape(), '&');
+    });
+  });
+}
diff --git a/test/validators/sanitizers/normalize_email_test.dart b/test/validators/sanitizers/normalize_email_test.dart
new file mode 100644
index 0000000..26ac146
--- /dev/null
+++ b/test/validators/sanitizers/normalize_email_test.dart
@@ -0,0 +1,20 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('NormalizeEmail Sanitizer Tests', () {
+    test('normalizes Gmail addresses', () {
+      expect(normalizeEmail('Test.User+tag@GMAIL.com'), 'testuser@gmail.com');
+      expect(normalizeEmail('a.b.c@googlemail.com'), 'abc@gmail.com');
+    });
+
+    test('lowercases domain for other providers', () {
+      expect(normalizeEmail('User@Example.COM'), 'User@example.com');
+    });
+
+    test('returns null for invalid emails', () {
+      expect(normalizeEmail('not-an-email'), isNull);
+      expect('bad'.normalizeEmail(), isNull);
+    });
+  });
+}
diff --git a/test/validators/sanitizers/strip_low_test.dart b/test/validators/sanitizers/strip_low_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..469ed28206f80338ae6f8d8da63696434a1b6dce
GIT binary patch
literal 487
zcmaiu!A`?442HQO^(lOFCrz8+xV^%(%Qzw-uQhA5GzpH|BGBHQgqCW913AQU^#5Nz
z(*`dJ7^phai8rsdQ)PMS$(owfOI-hbTGb?q+rs=RD@R@D>nBk3-qg^NapeL&3xJdO
zE|hpsF=6KiIFK`HK3L!>)gmro3Ib$KiNdY#IYQ-~inmZTBvd8Cn=Amo2d=b?6S%~N
zt@U?<7hB_E3FAJk+hmf@R6@Ex;%ctuG#zm<rY>oI$48$tbBN%0u*M~=p<xHYZ(Wk*
t`dWXc&s@xvhi8|^V~S?fo`+oqZ9t{t{PRs{a`=xm_eS)UIY9Qm6kpPSoFf1L

literal 0
HcmV?d00001

diff --git a/test/validators/sanitizers/to_boolean_test.dart b/test/validators/sanitizers/to_boolean_test.dart
new file mode 100644
index 0000000..b71003f
--- /dev/null
+++ b/test/validators/sanitizers/to_boolean_test.dart
@@ -0,0 +1,20 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('ToBoolean Sanitizer Tests', () {
+    test('loose mode', () {
+      expect(toBoolean('true'), isTrue);
+      expect(toBoolean('yes'), isTrue);
+      expect(toBoolean('0'), isFalse);
+      expect(toBoolean('false'), isFalse);
+      expect(toBoolean(''), isFalse);
+    });
+
+    test('strict mode', () {
+      expect('1'.toBoolean(strict: true), isTrue);
+      expect('true'.toBoolean(strict: true), isTrue);
+      expect('yes'.toBoolean(strict: true), isFalse);
+    });
+  });
+}
diff --git a/test/validators/sanitizers/to_number_test.dart b/test/validators/sanitizers/to_number_test.dart
new file mode 100644
index 0000000..2a5d277
--- /dev/null
+++ b/test/validators/sanitizers/to_number_test.dart
@@ -0,0 +1,25 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('ToNumber Sanitizer Tests', () {
+    test('toInt', () {
+      expect(toInt('42'), 42);
+      expect(toInt('ff', radix: 16), 255);
+      expect(toInt('abc'), isNull);
+      expect('  7  '.toInt(), 7);
+    });
+
+    test('toFloat', () {
+      expect(toFloat('3.14'), 3.14);
+      expect(toFloat('abc'), isNull);
+      expect('2.5'.toFloat(), 2.5);
+    });
+
+    test('toDate', () {
+      expect(toDate('2024-01-15'), DateTime(2024, 1, 15));
+      expect(toDate('not-a-date'), isNull);
+      expect('2024-01-15'.toDate(), DateTime(2024, 1, 15));
+    });
+  });
+}
diff --git a/test/validators/sanitizers/trim_test.dart b/test/validators/sanitizers/trim_test.dart
new file mode 100644
index 0000000..6f414af
--- /dev/null
+++ b/test/validators/sanitizers/trim_test.dart
@@ -0,0 +1,24 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Trim Sanitizer Tests', () {
+    test('trim whitespace and custom chars', () {
+      expect(trim('  hello  '), 'hello');
+      expect(trim('xxhelloxx', 'x'), 'hello');
+      expect('xxhelloxx'.trimChars('x'), 'hello');
+    });
+
+    test('ltrim', () {
+      expect(ltrim('  hello'), 'hello');
+      expect(ltrim('xxhello', 'x'), 'hello');
+      expect('--hello'.ltrimChars('-'), 'hello');
+    });
+
+    test('rtrim', () {
+      expect(rtrim('hello  '), 'hello');
+      expect(rtrim('helloxx', 'x'), 'hello');
+      expect('hello--'.rtrimChars('-'), 'hello');
+    });
+  });
+}
diff --git a/test/validators/semver_test.dart b/test/validators/semver_test.dart
new file mode 100644
index 0000000..4649d0e
--- /dev/null
+++ b/test/validators/semver_test.dart
@@ -0,0 +1,22 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('SemVer Validator Tests', () {
+    test('Valid semantic versions', () {
+      expect('1.0.0'.isSemVer, isTrue);
+      expect('0.1.2'.isSemVer, isTrue);
+      expect('2.1.0-alpha.1'.isSemVer, isTrue);
+      expect('1.0.0+build.5'.isSemVer, isTrue);
+      expect(isSemVer('1.2.3-beta+exp.sha.5114f85'), isTrue);
+    });
+
+    test('Invalid semantic versions', () {
+      expect('1.0'.isSemVer, isFalse);
+      expect('1'.isSemVer, isFalse);
+      expect('01.0.0'.isSemVer, isFalse);
+      expect('v1.0.0'.isSemVer, isFalse);
+      expect(''.isSemVer, isFalse);
+    });
+  });
+}
diff --git a/test/validators/slug_test.dart b/test/validators/slug_test.dart
new file mode 100644
index 0000000..1720943
--- /dev/null
+++ b/test/validators/slug_test.dart
@@ -0,0 +1,22 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Slug Validator Tests', () {
+    test('Valid slugs', () {
+      expect('my-blog-post'.isSlug, isTrue);
+      expect('post-123'.isSlug, isTrue);
+      expect('hello'.isSlug, isTrue);
+      expect(isSlug('a-b-c'), isTrue);
+    });
+
+    test('Invalid slugs', () {
+      expect('-leading'.isSlug, isFalse);
+      expect('trailing-'.isSlug, isFalse);
+      expect('double--hyphen'.isSlug, isFalse);
+      expect('Has Spaces'.isSlug, isFalse);
+      expect('UPPER'.isSlug, isFalse);
+      expect(''.isSlug, isFalse);
+    });
+  });
+}
diff --git a/test/validators/strong_password_test.dart b/test/validators/strong_password_test.dart
new file mode 100644
index 0000000..5c0233c
--- /dev/null
+++ b/test/validators/strong_password_test.dart
@@ -0,0 +1,38 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('StrongPassword Validator Tests', () {
+    test('Strong passwords with defaults', () {
+      expect('Abcd1234!'.isStrongPassword(), isTrue);
+      expect(isStrongPassword(r'P@ssw0rd'), isTrue);
+    });
+
+    test('Weak passwords with defaults', () {
+      expect('weak'.isStrongPassword(), isFalse);
+      expect('alllowercase1!'.isStrongPassword(), isFalse); // no uppercase
+      expect('NoNumbers!'.isStrongPassword(), isFalse);
+      expect('NoSymbol123'.isStrongPassword(), isFalse);
+    });
+
+    test('Custom thresholds', () {
+      expect(
+        'abcdefgh'.isStrongPassword(
+          minUppercase: 0,
+          minNumbers: 0,
+          minSymbols: 0,
+        ),
+        isTrue,
+      );
+      expect(
+        'short'.isStrongPassword(
+          minLength: 4,
+          minUppercase: 0,
+          minNumbers: 0,
+          minSymbols: 0,
+        ),
+        isTrue,
+      );
+    });
+  });
+}
diff --git a/test/validators/uppercase_test.dart b/test/validators/uppercase_test.dart
new file mode 100644
index 0000000..32f5c14
--- /dev/null
+++ b/test/validators/uppercase_test.dart
@@ -0,0 +1,20 @@
+import 'package:flutter_validators/flutter_validators.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Uppercase Validator Tests', () {
+    test('Valid uppercase strings', () {
+      expect('HELLO'.isUppercase, isTrue);
+      expect('HELLO123'.isUppercase, isTrue);
+      expect('123'.isUppercase, isTrue);
+      expect(''.isUppercase, isTrue);
+      expect(isUppercase('ABC'), isTrue);
+    });
+
+    test('Invalid uppercase strings', () {
+      expect('Hello'.isUppercase, isFalse);
+      expect('hello'.isUppercase, isFalse);
+      expect(isUppercase('AbC'), isFalse);
+    });
+  });
+}
diff --git a/test/validators/uuid_test.dart b/test/validators/uuid_test.dart
index 4e42e7a..91df4a8 100644
--- a/test/validators/uuid_test.dart
+++ b/test/validators/uuid_test.dart
@@ -4,29 +4,71 @@ import 'package:test/test.dart';
 void main() {
   group('UUID Validator Tests', () {
     test('Valid UUIDs', () {
-      expect('123e4567-e89b-12d3-a456-426614174000'.isUUID, isTrue); // version 1, variant a
-      expect('550e8400-e29b-41d4-a716-446655440000'.isUUID, isTrue); // version 4, variant a
-      expect('8bA4A1C9-5e19-4F5b-b5a8-44243b1E2D4A'.isUUID, isTrue); // version 4, variant b
-      expect('6ba7b810-9dad-11d1-80b4-00c04fd430c8'.isUUID, isTrue); // version 1
-      expect('6ba7b811-9dad-31d1-80b4-00c04fd430c8'.isUUID, isTrue); // version 3
-      expect('6ba7b812-9dad-41d1-80b4-00c04fd430c8'.isUUID, isTrue); // version 4
-      expect('6ba7b814-9dad-51d1-80b4-00c04fd430c8'.isUUID, isTrue); // version 5
+      expect(
+        '123e4567-e89b-12d3-a456-426614174000'.isUUID,
+        isTrue,
+      ); // version 1, variant a
+      expect(
+        '550e8400-e29b-41d4-a716-446655440000'.isUUID,
+        isTrue,
+      ); // version 4, variant a
+      expect(
+        '8bA4A1C9-5e19-4F5b-b5a8-44243b1E2D4A'.isUUID,
+        isTrue,
+      ); // version 4, variant b
+      expect(
+        '6ba7b810-9dad-11d1-80b4-00c04fd430c8'.isUUID,
+        isTrue,
+      ); // version 1
+      expect(
+        '6ba7b811-9dad-31d1-80b4-00c04fd430c8'.isUUID,
+        isTrue,
+      ); // version 3
+      expect(
+        '6ba7b812-9dad-41d1-80b4-00c04fd430c8'.isUUID,
+        isTrue,
+      ); // version 4
+      expect(
+        '6ba7b814-9dad-51d1-80b4-00c04fd430c8'.isUUID,
+        isTrue,
+      ); // version 5
     });
 
     test('Invalid UUIDs', () {
-      expect('8bA4A1C9-5e19-4F5t-b5a8-44243b1E2D4A'.isUUID, isFalse); // invalid hex char 't'
+      expect(
+        '8bA4A1C9-5e19-4F5t-b5a8-44243b1E2D4A'.isUUID,
+        isFalse,
+      ); // invalid hex char 't'
       expect('invalid-uuid'.isUUID, isFalse);
-      expect('123e4567-e89b-12d3-a456-42661417400'.isUUID, isFalse); // Too short
+      expect(
+        '123e4567-e89b-12d3-a456-42661417400'.isUUID,
+        isFalse,
+      ); // Too short
       expect(''.isUUID, isFalse);
 
       // Invalid version (e.g. 2, 6, f)
-      expect('6ba7b812-9dad-21d1-80b4-00c04fd430c8'.isUUID, isFalse); // version 2
-      expect('6ba7b812-9dad-61d1-80b4-00c04fd430c8'.isUUID, isFalse); // version 6
-      expect('6ba7b812-9dad-f1d1-80b4-00c04fd430c8'.isUUID, isFalse); // version f
-      
+      expect(
+        '6ba7b812-9dad-21d1-80b4-00c04fd430c8'.isUUID,
+        isFalse,
+      ); // version 2
+      expect(
+        '6ba7b812-9dad-61d1-80b4-00c04fd430c8'.isUUID,
+        isFalse,
+      ); // version 6
+      expect(
+        '6ba7b812-9dad-f1d1-80b4-00c04fd430c8'.isUUID,
+        isFalse,
+      ); // version f
+
       // Invalid variant (e.g. 7, c)
-      expect('6ba7b812-9dad-41d1-70b4-00c04fd430c8'.isUUID, isFalse); // variant 7
-      expect('6ba7b812-9dad-41d1-c0b4-00c04fd430c8'.isUUID, isFalse); // variant c
+      expect(
+        '6ba7b812-9dad-41d1-70b4-00c04fd430c8'.isUUID,
+        isFalse,
+      ); // variant 7
+      expect(
+        '6ba7b812-9dad-41d1-c0b4-00c04fd430c8'.isUUID,
+        isFalse,
+      ); // variant c
     });
   });
 }

From 82c80952ce3a8db912cf06a25b60b295550bb542 Mon Sep 17 00:00:00 2001
From: Divyanshu Bhargava <divyanshub024@gmail.com>
Date: Fri, 15 May 2026 17:11:11 +0530
Subject: [PATCH 2/3] docs: rewrite README as comprehensive documentation

Restructures the README into a full documentation page: table of
contents, a features list, categorized validator and sanitizer sections
each with runnable examples, a complete Flutter form example, the full
Validator API reference, and a behavior notes / FAQ section.
---
 README.md | 510 ++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 397 insertions(+), 113 deletions(-)

diff --git a/README.md b/README.md
index 0343d68..30751b4 100644
--- a/README.md
+++ b/README.md
@@ -23,12 +23,56 @@
 
 ---
 
-A pure Dart package with 40+ string validators and sanitizers, from emails and URLs to credit cards, UUIDs and strong-password checks. Use them as simple functions, convenient `String` extensions, or plug them directly into Flutter's `TextFormField` with the built-in `Validator` class. Zero dependencies, fully tested.
+**Flutter Validators** is a pure Dart package with **40+ string validators** and **13 sanitizers** — from emails and URLs to credit cards, UUIDs, JWTs and strong-password checks. Every validator works three ways:
+
+- as a **top-level function** — `isEmail('foo@bar.com')`
+- as a **`String` extension** — `'foo@bar.com'.isEmail`
+- as a **Flutter form validator** — `Validator.email()` plugs straight into `TextFormField`
+
+Zero runtime dependencies. Fully tested. Works with both Dart and Flutter.
+
+---
+
+## 📚 Table of Contents
+
+- [✨ Features](#-features)
+- [📦 Installation](#-installation)
+- [🚀 Quick Start](#-quick-start)
+- [🧩 Validators](#-validators)
+  - [Contact and Web](#contact-and-web)
+  - [Numbers](#numbers)
+  - [Text and Format](#text-and-format)
+  - [Encoding and Data](#encoding-and-data)
+  - [Identifiers and Crypto](#identifiers-and-crypto)
+  - [Security](#security)
+- [🧹 Sanitizers](#-sanitizers)
+  - [Trimming](#trimming)
+  - [HTML Escaping](#html-escaping)
+  - [Character Filtering](#character-filtering)
+  - [Type Conversion](#type-conversion)
+  - [Email Normalization](#email-normalization)
+- [📝 Flutter Form Integration](#-flutter-form-integration)
+- [💡 Behavior Notes and FAQ](#-behavior-notes-and-faq)
+- [🤝 Contributing](#-contributing)
+- [📄 License](#-license)
+
+---
+
+## ✨ Features
+
+- **40+ validators** covering email, URL, numbers, encodings, identifiers, crypto hashes and more.
+- **13 sanitizers** for trimming, HTML escaping, character filtering and type conversion.
+- **Three usage styles** — top-level functions, `String` extensions, and Flutter form validators — pick whatever reads best.
+- **First-class Flutter form support** via the `Validator` class, which returns `String? Function(String?)` closures with customizable error messages.
+- **Pure Dart, zero runtime dependencies** — lightweight and safe to add to any project.
+- **Fully tested** — every validator and sanitizer has dedicated test coverage.
 
 ---
 
 ## 📦 Installation
 
+Add the package to your `pubspec.yaml`:
+
 ```yaml
 dependencies:
   flutter_validators: ^1.2.0
@@ -44,193 +88,433 @@ dart pub get
 
 ## 🚀 Quick Start
 
+Import the package:
+
 ```dart
 import 'package:flutter_validators/flutter_validators.dart';
 ```
 
-### Use as String Extensions
+**As `String` extensions** — the most concise style:
 
 ```dart
-'foo@bar.com'.isEmail;        // true
-'https://google.com'.isURL;   // true
+'foo@bar.com'.isEmail;           // true
+'https://google.com'.isURL;      // true
 '4111111111111111'.isCreditCard; // true
-'abc123'.isAlphanumeric;      // true
+'abc123'.isAlphanumeric;         // true
 ```
 
-### Use as Top-Level Functions
+**As top-level functions** — handy when the value isn't a literal:
 
 ```dart
-isEmail('foo@bar.com');       // true
+isEmail('foo@bar.com');     // true
 isURL('https://google.com'); // true
-isIP('192.168.1.1');         // true
+isIP('192.168.1.1');        // true
 ```
 
----
-
-## 📝 Flutter Form Integration
-
-The `Validator` class returns `String? Function(String?)` closures — exactly what `TextFormField.validator` expects. Each method accepts a custom `errorMessage`.
+**As Flutter form validators** — drop straight into `TextFormField`:
 
 ```dart
-Form(
-  child: Column(
-    children: [
-      TextFormField(
-        decoration: const InputDecoration(labelText: 'Email'),
-        validator: Validator.email(errorMessage: 'Enter a valid email'),
-      ),
-      TextFormField(
-        decoration: const InputDecoration(labelText: 'Website'),
-        validator: Validator.url(),
-      ),
-      TextFormField(
-        decoration: const InputDecoration(labelText: 'Age'),
-        validator: Validator.numeric(errorMessage: 'Must be a number'),
-      ),
-    ],
-  ),
+TextFormField(
+  validator: Validator.email(errorMessage: 'Enter a valid email'),
 )
 ```
 
-> **Tip:** Use `Validator.required()` alongside other validators to enforce non-empty fields.
-
-See the [`example/`](example/) directory for a complete working app.
-
 ---
 
-## 📋 All Validators
+## 🧩 Validators
+
+Every validator is available **both** as a top-level function and as a `String` extension. Parameterized validators accept their options as named/positional arguments.
 
-Every validator is available **both** as a top-level function and as a `String` extension.
+### Contact and Web
 
 | Validator | Extension | Description |
 |---|---|---|
 | `isEmail(str)` | `str.isEmail` | Valid email address |
 | `isURL(str)` | `str.isURL` | Valid HTTP/HTTPS URL |
-| `isIP(str, [version])` | `str.isIP` / `str.isIPv4` / `str.isIPv6` | Valid IP address (v4 or v6) |
-| `isUUID(str)` | `str.isUUID` | Valid UUID |
-| `isCreditCard(str)` | `str.isCreditCard` | Credit card number (Luhn algorithm) |
-| `isDate(str)` | `str.isDate` | Parseable date string |
-| `isJson(str)` | `str.isJson` | Valid JSON |
-| `isInt(str)` | `str.isInt` | Valid integer |
-| `isNumeric(str)` | `str.isNumeric` | Valid number (int or float) |
+| `isFQDN(str)` | `str.isFQDN` | Fully qualified domain name |
+| `isPhone(str)` | `str.isPhone` | Phone number (international & US formats) |
+| `isLatLong(str)` | `str.isLatLong` | `latitude,longitude` coordinate pair |
+
+```dart
+'user@example.com'.isEmail;   // true
+'https://dart.dev'.isURL;     // true
+'sub.example.co.uk'.isFQDN;   // true
+'localhost'.isFQDN;           // false (no TLD)
+'(123) 456-7890'.isPhone;     // true
+'40.7128,-74.0060'.isLatLong; // true
+```
+
+### Numbers
+
+| Validator | Extension | Description |
+|---|---|---|
+| `isInt(str)` | `str.isInt` | Integer (positive or negative) |
+| `isNumeric(str)` | `str.isNumeric` | Number (integer or float) |
+| `isFloat(str, {min, max})` | `str.isFloat({min, max})` | Finite float, optionally within a range |
+| `isDecimal(str)` | `str.isDecimal` | Decimal number |
+| `isHexadecimal(str)` | `str.isHexadecimal` | Hexadecimal number |
+| `isOctal(str)` | `str.isOctal` | Octal number |
+| `isPort(str)` | `str.isPort` | Port number (0–65535) |
+
+```dart
+'42'.isInt;                      // true
+'3.14'.isNumeric;                // true
+'1.5'.isFloat();                 // true
+'5'.isFloat(min: 0, max: 2);     // false (out of range)
+'.5'.isDecimal;                  // true
+'deadBEEF'.isHexadecimal;        // true
+'0o17'.isOctal;                  // true
+'8080'.isPort;                   // true
+'65536'.isPort;                  // false (out of range)
+```
+
+### Text and Format
+
+| Validator | Extension | Description |
+|---|---|---|
 | `isAlpha(str)` | `str.isAlpha` | Letters only (a–z, A–Z) |
 | `isAlphanumeric(str)` | `str.isAlphanumeric` | Letters and numbers only |
 | `isAscii(str)` | `str.isAscii` | ASCII characters only |
+| `isLowercase(str)` | `str.isLowercase` | Entirely lowercase |
+| `isUppercase(str)` | `str.isUppercase` | Entirely uppercase |
+| `isLength(str, min, [max])` | `str.isLength(min, [max])` | Length within a range |
+| `isByteLength(str, min, [max])` | `str.isByteLength(min, [max])` | UTF-8 byte length within a range |
+| `isSlug(str)` | `str.isSlug` | URL slug (`my-blog-post`) |
+| `isIn(str, values)` | `str.isIn(values)` | One of an allowed set of values |
+| `matches(str, pattern)` | `str.matches(pattern)` | Matches a `Pattern` / `RegExp` |
+| `contains(str, seed, {ignoreCase, minOccurrences})` | — | Contains a substring |
+| `equals(str, comparison)` | `str.equals(comparison)` | Exact (case-sensitive) string match |
+
+```dart
+'Hello'.isAlpha;                       // true
+'abc123'.isAlphanumeric;               // true
+'héllo'.isAscii;                       // false
+'hello'.isLowercase;                   // true
+'abc'.isLength(2, 5);                  // true
+'é'.isByteLength(2, 2);                // true ('é' is 2 bytes in UTF-8)
+'my-blog-post'.isSlug;                 // true
+'red'.isIn(['red', 'green', 'blue']);  // true
+'abc123'.matches(RegExp(r'\d+'));      // true
+'foo'.equals('foo');                   // true
+
+// `contains` is a top-level function only (see Behavior Notes)
+contains('hello world', 'world');                  // true
+contains('Hello World', 'world', ignoreCase: true); // true
+contains('a-a-a', 'a', minOccurrences: 3);          // true
+```
+
+### Encoding and Data
+
+| Validator | Extension | Description |
+|---|---|---|
 | `isBase32(str)` | `str.isBase32` | Base32 encoded |
 | `isBase58(str)` | `str.isBase58` | Base58 encoded |
-| `isBoolean(str)` | `str.isBoolean` | Boolean string (`true`/`false`/`1`/`0`) |
+| `isBase64(str, {urlSafe})` | `str.isBase64({urlSafe})` | Base64 encoded (standard or URL-safe) |
+| `isJson(str)` | `str.isJson` | Valid JSON |
 | `isHexColor(str)` | `str.isHexColor` | Hex color code (`#fff`, `ff0000`) |
-| `isHexadecimal(str)` | `str.isHexadecimal` | Hexadecimal number |
-| `isOctal(str)` | `str.isOctal` | Octal number |
-| `isDecimal(str)` | `str.isDecimal` | Decimal number |
-| `isFloat(str, {min, max})` | `str.isFloat({min, max})` | Finite float, optionally within range |
-| `isPhone(str)` | `str.isPhone` | Valid phone number |
-| `isLength(str, min, [max])` | `str.isLength(min, [max])` | Length within range |
-| `isByteLength(str, min, [max])` | `str.isByteLength(min, [max])` | UTF-8 byte length within range |
-| `isBase64(str, {urlSafe})` | `str.isBase64({urlSafe})` | Base64 encoded |
-| `isLowercase(str)` | `str.isLowercase` | Entirely lowercase |
-| `isUppercase(str)` | `str.isUppercase` | Entirely uppercase |
-| `isSlug(str)` | `str.isSlug` | URL slug |
-| `isFQDN(str)` | `str.isFQDN` | Fully qualified domain name |
-| `isMACAddress(str)` | `str.isMACAddress` | MAC address |
-| `isLatLong(str)` | `str.isLatLong` | `latitude,longitude` pair |
-| `isPort(str)` | `str.isPort` | Port number (0–65535) |
-| `isSemVer(str)` | `str.isSemVer` | Semantic version |
-| `isMongoId(str)` | `str.isMongoId` | MongoDB ObjectId |
+| `isBoolean(str)` | `str.isBoolean` | Boolean string (`true`/`false`/`1`/`0`) |
+| `isDate(str)` | `str.isDate` | Parseable date string |
+
+```dart
+'JBSWY3DP'.isBase32;             // true
+'aGVsbG8='.isBase64();           // true
+'a-b_cdef'.isBase64(urlSafe: true); // true
+'{"name":"Dart"}'.isJson;        // true
+'#ff0000'.isHexColor;            // true
+'true'.isBoolean;                // true
+'2024-01-15'.isDate;             // true
+```
+
+### Identifiers and Crypto
+
+| Validator | Extension | Description |
+|---|---|---|
+| `isUUID(str)` | `str.isUUID` | UUID (v1, v3, v4, v5) |
+| `isMongoId(str)` | `str.isMongoId` | MongoDB ObjectId (24-char hex) |
 | `isMD5(str)` | `str.isMD5` | MD5 hash |
 | `isJWT(str)` | `str.isJWT` | JSON Web Token |
-| `isStrongPassword(str, {...})` | `str.isStrongPassword({...})` | Password meets strength rules |
-| `isIn(str, values)` | `str.isIn(values)` | One of the allowed values |
-| `matches(str, pattern)` | `str.matches(pattern)` | Matches a `Pattern`/`RegExp` |
-| `contains(str, seed, {ignoreCase, minOccurrences})` | — | Contains a substring |
-| `equals(str, comparison)` | `str.equals(comparison)` | Exact string match |
+| `isCreditCard(str)` | `str.isCreditCard` | Credit card number (Luhn algorithm) |
+| `isMACAddress(str)` | `str.isMACAddress` | MAC address (EUI-48 / EUI-64) |
+| `isSemVer(str)` | `str.isSemVer` | Semantic version |
+
+```dart
+'550e8400-e29b-41d4-a716-446655440000'.isUUID; // true
+'507f1f77bcf86cd799439011'.isMongoId;          // true
+'d41d8cd98f00b204e9800998ecf8427e'.isMD5;      // true
+'eyJhbGci.eyJzdWIi.SflKxwRJ'.isJWT;            // true
+'4111111111111111'.isCreditCard;               // true
+'00:1B:44:11:3A:B7'.isMACAddress;              // true
+'2.1.0-alpha.1'.isSemVer;                       // true
+```
+
+### Security
+
+| Validator | Extension | Description |
+|---|---|---|
+| `isStrongPassword(str, {...})` | `str.isStrongPassword({...})` | Password meets configurable strength rules |
+
+`isStrongPassword` accepts five options, all with sensible defaults:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `minLength` | `8` | Minimum total length |
+| `minLowercase` | `1` | Minimum lowercase letters |
+| `minUppercase` | `1` | Minimum uppercase letters |
+| `minNumbers` | `1` | Minimum digits |
+| `minSymbols` | `1` | Minimum non-alphanumeric symbols |
+
+```dart
+'Abcd1234!'.isStrongPassword();  // true
+'weak'.isStrongPassword();       // false
+
+// Relax the rules — e.g. allow passphrases with no symbols or digits
+'abcdefghij'.isStrongPassword(
+  minUppercase: 0,
+  minNumbers: 0,
+  minSymbols: 0,
+); // true
+```
 
 ---
 
 ## 🧹 Sanitizers
 
-Sanitizers transform or coerce strings. Available both as top-level functions and `String` extensions.
+Sanitizers transform or coerce strings. Like validators, they're available as both top-level functions and `String` extensions. Import them via the main library or directly:
+
+```dart
+import 'package:flutter_validators/flutter_validators.dart';
+// or, sanitizers only:
+import 'package:flutter_validators/sanitizers.dart';
+```
+
+### Trimming
+
+| Sanitizer | Extension | Description |
+|---|---|---|
+| `trim(str, [chars])` | `str.trimChars(chars)` | Trim whitespace/chars from both ends |
+| `ltrim(str, [chars])` | `str.ltrimChars(chars)` | Trim from the start |
+| `rtrim(str, [chars])` | `str.rtrimChars(chars)` | Trim from the end |
+
+```dart
+trim('  hello  ');        // 'hello'
+trim('xxhelloxx', 'x');   // 'hello'
+ltrim('00042', '0');      // '42'
+rtrim('hello!!!', '!');   // 'hello'
+```
+
+### HTML Escaping
+
+| Sanitizer | Extension | Description |
+|---|---|---|
+| `escape(str)` | `str.escape()` | Escape HTML-unsafe characters |
+| `unescape(str)` | `str.unescape()` | Reverse of `escape` |
+
+```dart
+escape('<script>alert(1)</script>');
+// '&lt;script&gt;alert(1)&lt;&#x2F;script&gt;'
+
+unescape('&lt;b&gt;hi&lt;&#x2F;b&gt;'); // '<b>hi</b>'
+```
+
+### Character Filtering
+
+| Sanitizer | Extension | Description |
+|---|---|---|
+| `blacklist(str, chars)` | `str.blacklist(chars)` | Remove the listed characters |
+| `whitelist(str, chars)` | `str.whitelist(chars)` | Keep only the listed characters |
+| `stripLow(str, {keepNewLines})` | `str.stripLow({keepNewLines})` | Remove ASCII control characters |
+
+```dart
+blacklist('hello world', 'lo');              // 'he wrd'
+whitelist('a1b2c3', '0123456789');           // '123'
+stripLow('line1\nline2');                    // 'line1line2'
+stripLow('line1\nline2', keepNewLines: true); // 'line1\nline2'
+```
+
+### Type Conversion
+
+| Sanitizer | Extension | Returns | Description |
+|---|---|---|---|
+| `toBoolean(str, {strict})` | `str.toBoolean({strict})` | `bool` | Convert to a boolean |
+| `toInt(str, {radix})` | `str.toInt({radix})` | `int?` | Parse to an integer |
+| `toFloat(str)` | `str.toFloat()` | `double?` | Parse to a double |
+| `toDate(str)` | `str.toDate()` | `DateTime?` | Parse to a `DateTime` |
 
 ```dart
-trim('  hello  ');             // 'hello'
-escape('<script>');            // '&lt;script&gt;'
-normalizeEmail('A.B+x@GMAIL.com'); // 'ab@gmail.com'
 toBoolean('true');             // true
+toBoolean('0');                // false
+toBoolean('yes', strict: true); // false (strict: only '1'/'true' are true)
 toInt('42');                   // 42
+toInt('ff', radix: 16);        // 255
+toInt('abc');                  // null
+toFloat('3.14');               // 3.14
+toDate('2024-01-15');          // DateTime(2024, 1, 15)
 ```
 
-| Sanitizer | Returns | Description |
-|---|---|---|
-| `trim(str, [chars])` | `String` | Trim whitespace/chars from both ends |
-| `ltrim(str, [chars])` | `String` | Trim from the start |
-| `rtrim(str, [chars])` | `String` | Trim from the end |
-| `escape(str)` | `String` | Escape HTML-unsafe characters |
-| `unescape(str)` | `String` | Reverse of `escape` |
-| `blacklist(str, chars)` | `String` | Remove the listed characters |
-| `whitelist(str, chars)` | `String` | Keep only the listed characters |
-| `stripLow(str, {keepNewLines})` | `String` | Remove control characters |
-| `normalizeEmail(str)` | `String?` | Canonicalize an email address |
-| `toBoolean(str, {strict})` | `bool` | Convert to a boolean |
-| `toInt(str, {radix})` | `int?` | Parse to an integer |
-| `toFloat(str)` | `double?` | Parse to a double |
-| `toDate(str)` | `DateTime?` | Parse to a `DateTime` |
+### Email Normalization
+
+| Sanitizer | Extension | Returns | Description |
+|---|---|---|---|
+| `normalizeEmail(str)` | `str.normalizeEmail()` | `String?` | Canonicalize an email address |
+
+```dart
+normalizeEmail('Test.User+promo@GMAIL.com'); // 'testuser@gmail.com'
+normalizeEmail('User@Example.COM');          // 'User@example.com'
+normalizeEmail('not-an-email');              // null
+```
 
 ---
 
-## 🏗️ Form Validator API Reference
+## 📝 Flutter Form Integration
 
-All methods on the `Validator` class return `String? Function(String?)`:
+The `Validator` class returns `String? Function(String?)` closures — exactly the type `TextFormField.validator` expects. A closure returns `null` when the value is valid, or the error message when it isn't. Every method accepts a custom `errorMessage`.
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter_validators/flutter_validators.dart';
+
+class SignUpForm extends StatefulWidget {
+  const SignUpForm({super.key});
+
+  @override
+  State<SignUpForm> createState() => _SignUpFormState();
+}
+
+class _SignUpFormState extends State<SignUpForm> {
+  final _formKey = GlobalKey<FormState>();
+
+  @override
+  Widget build(BuildContext context) {
+    return Form(
+      key: _formKey,
+      child: Column(
+        children: [
+          // Combine `required` with `email` to enforce a non-empty, valid email.
+          TextFormField(
+            decoration: const InputDecoration(labelText: 'Email'),
+            autovalidateMode: AutovalidateMode.onUserInteraction,
+            validator: (value) {
+              return Validator.required(errorMessage: 'Email is required')(value) ??
+                  Validator.email(errorMessage: 'Enter a valid email')(value);
+            },
+          ),
+          TextFormField(
+            decoration: const InputDecoration(labelText: 'Website'),
+            autovalidateMode: AutovalidateMode.onUserInteraction,
+            validator: Validator.url(),
+          ),
+          TextFormField(
+            decoration: const InputDecoration(labelText: 'Password'),
+            obscureText: true,
+            autovalidateMode: AutovalidateMode.onUserInteraction,
+            validator: Validator.strongPassword(
+              errorMessage: 'Use 8+ chars with upper, lower, number & symbol',
+            ),
+          ),
+          ElevatedButton(
+            onPressed: () {
+              if (_formKey.currentState!.validate()) {
+                ScaffoldMessenger.of(context).showSnackBar(
+                  const SnackBar(content: Text('Form is valid!')),
+                );
+              }
+            },
+            child: const Text('Sign Up'),
+          ),
+        ],
+      ),
+    );
+  }
+}
+```
+
+A complete, runnable app is in the [`example/`](example/) directory.
+
+### Validator API Reference
+
+Every method on the `Validator` class returns `String? Function(String?)`:
 
 ```dart
 Validator.required({String errorMessage})
 Validator.email({String errorMessage})
 Validator.url({String errorMessage})
 Validator.ip({int? version, String errorMessage})
+Validator.fqdn({String errorMessage})
+Validator.phone({String errorMessage})
+Validator.latLong({String errorMessage})
 Validator.date({String errorMessage})
 Validator.numeric({String errorMessage})
 Validator.integer({String errorMessage})
+Validator.float({double? min, double? max, String errorMessage})
+Validator.decimal({String errorMessage})
+Validator.hexadecimal({String errorMessage})
+Validator.octal({String errorMessage})
+Validator.port({String errorMessage})
 Validator.alpha({String errorMessage})
 Validator.alphanumeric({String errorMessage})
-Validator.phone({String errorMessage})
-Validator.creditCard({String errorMessage})
-Validator.json({String errorMessage})
-Validator.uuid({String errorMessage})
-Validator.hexColor({String errorMessage})
 Validator.ascii({String errorMessage})
-Validator.base32({String errorMessage})
-Validator.base58({String errorMessage})
-Validator.boolean({String errorMessage})
-Validator.base64({bool urlSafe, String errorMessage})
-Validator.hexadecimal({String errorMessage})
-Validator.octal({String errorMessage})
-Validator.decimal({String errorMessage})
-Validator.float({double? min, double? max, String errorMessage})
 Validator.lowercase({String errorMessage})
 Validator.uppercase({String errorMessage})
 Validator.slug({String errorMessage})
-Validator.fqdn({String errorMessage})
-Validator.macAddress({String errorMessage})
-Validator.latLong({String errorMessage})
-Validator.port({String errorMessage})
-Validator.semVer({String errorMessage})
-Validator.mongoId({String errorMessage})
-Validator.md5({String errorMessage})
-Validator.jwt({String errorMessage})
-Validator.strongPassword({int minLength, int minLowercase, int minUppercase, int minNumbers, int minSymbols, String errorMessage})
+Validator.length(int min, {int? max, String errorMessage})
+Validator.byteLength(int min, {int? max, String errorMessage})
 Validator.contains(String seed, {bool ignoreCase, int minOccurrences, String errorMessage})
 Validator.matches(Pattern pattern, {String errorMessage})
 Validator.inList(Iterable<String> allowed, {String errorMessage})
-Validator.byteLength(int min, {int? max, String errorMessage})
 Validator.equals(String comparison, {String errorMessage})
-Validator.length(int min, {int? max, String errorMessage})
+Validator.base32({String errorMessage})
+Validator.base58({String errorMessage})
+Validator.base64({bool urlSafe, String errorMessage})
+Validator.json({String errorMessage})
+Validator.hexColor({String errorMessage})
+Validator.boolean({String errorMessage})
+Validator.uuid({String errorMessage})
+Validator.mongoId({String errorMessage})
+Validator.md5({String errorMessage})
+Validator.jwt({String errorMessage})
+Validator.creditCard({String errorMessage})
+Validator.macAddress({String errorMessage})
+Validator.semVer({String errorMessage})
+Validator.strongPassword({int minLength, int minLowercase, int minUppercase, int minNumbers, int minSymbols, String errorMessage})
+```
+
+---
+
+## 💡 Behavior Notes and FAQ
+
+**`Validator` methods treat `null` and empty strings as valid.** This is intentional — it lets you compose validators freely. To make a field mandatory, pair it with `Validator.required()`:
+
+```dart
+validator: (value) {
+  return Validator.required()(value) ?? Validator.email()(value);
+}
 ```
 
+**`contains` is a top-level function only.** Dart's `String` already has a built-in `.contains()` method, so the package does not add a conflicting extension. Use `contains(str, seed)` instead of `str.contains(...)` when you need the case-insensitivity or `minOccurrences` options.
+
+**Trimming extensions are named `trimChars` / `ltrimChars` / `rtrimChars`.** Dart's `String` already provides `.trim()`, `.trimLeft()` and `.trimRight()` for whitespace, so the custom-character variants use distinct names to avoid collisions. The top-level functions keep the plain `trim` / `ltrim` / `rtrim` names.
+
+**`isURL` accepts only `http` and `https` schemes.** Other schemes such as `ftp://` are rejected.
+
+**`isBase64` has a `urlSafe` option.** By default it validates the standard Base64 alphabet (with padding); pass `urlSafe: true` to validate the URL- and filename-safe alphabet instead.
+
+**`isBoolean` accepts `'true'`, `'false'`, `'1'` and `'0'`.** Any other value is not a boolean string.
+
+**`isFloat` rejects non-finite values.** `'Infinity'` and `'NaN'` return `false`, even though Dart's `double.tryParse` can parse them.
+
+**`normalizeEmail` applies Gmail-specific rules.** For `gmail.com` / `googlemail.com` addresses it lowercases the local part, removes dots, and strips any `+tag` suffix. For other providers it only lowercases the domain. It returns `null` if the input isn't a valid email.
+
 ---
 
 ## 🤝 Contributing
 
-Contributions, issues, and feature requests are welcome!
-Feel free to check the [issues page](https://github.com/divyanshub024/flutter_validators/issues).
+Contributions, issues and feature requests are welcome! Check the [issues page](https://github.com/divyanshub024/flutter_validators/issues) to get started.
+
+Before opening a pull request, please run the test suite:
+
+```sh
+dart test
+```
 
 ---
 

From e01704f032e1177c01d79e0eaeaf06d305f3e0d2 Mon Sep 17 00:00:00 2001
From: Divyanshu Bhargava <divyanshub024@gmail.com>
Date: Fri, 15 May 2026 17:11:11 +0530
Subject: [PATCH 3/3] fix: correct Base64 length check and case-insensitive
 toBoolean

isBase64 with urlSafe now rejects strings of length 4n+1, which can
never be valid Base64 (a single base64 char cannot encode any byte).

toBoolean now matches boolean keywords case-insensitively, so values
like 'FALSE' and 'TRUE' are coerced correctly in both loose and strict
modes.
---
 lib/validators/base64.dart                    |  2 ++
 lib/validators/sanitizers/to_boolean.dart     |  7 ++---
 test/form_validator_test.dart                 | 27 +++++++++++++------
 test/validators/base64_test.dart              |  4 ++-
 .../sanitizers/to_boolean_test.dart           |  7 +++++
 5 files changed, 35 insertions(+), 12 deletions(-)

diff --git a/lib/validators/base64.dart b/lib/validators/base64.dart
index 5ac7c8f..ea8c44b 100644
--- a/lib/validators/base64.dart
+++ b/lib/validators/base64.dart
@@ -27,6 +27,8 @@ final _base64UrlSafe = RegExp(r'^[A-Za-z0-9_-]+$');
 bool _isBase64(String str, bool urlSafe) {
   if (str.isEmpty) return false;
   if (urlSafe) {
+    // A base64 string can never have a length of `4n + 1`.
+    if (str.length % 4 == 1) return false;
     return _base64UrlSafe.hasMatch(str);
   }
   if (str.length % 4 != 0) return false;
diff --git a/lib/validators/sanitizers/to_boolean.dart b/lib/validators/sanitizers/to_boolean.dart
index de79c80..dfadb82 100644
--- a/lib/validators/sanitizers/to_boolean.dart
+++ b/lib/validators/sanitizers/to_boolean.dart
@@ -2,7 +2,7 @@
 ///
 /// In loose mode (the default) every value is `true` except `''`, `'0'`
 /// and `'false'`. In [strict] mode only `'1'` and `'true'` are `true` and
-/// everything else is `false`.
+/// everything else is `false`. Keyword matching is case-insensitive.
 ///
 /// Example:
 /// ```dart
@@ -19,8 +19,9 @@ extension ToBooleanX on String {
 }
 
 bool _toBoolean(String str, bool strict) {
+  final normalized = str.toLowerCase();
   if (strict) {
-    return str == '1' || str == 'true';
+    return normalized == '1' || normalized == 'true';
   }
-  return str != '0' && str != 'false' && str != '';
+  return normalized != '0' && normalized != 'false' && normalized != '';
 }
diff --git a/test/form_validator_test.dart b/test/form_validator_test.dart
index d27b2e6..6b941e8 100644
--- a/test/form_validator_test.dart
+++ b/test/form_validator_test.dart
@@ -235,12 +235,19 @@ void main() {
       final base64 = Validator.base64(errorMessage: 'Bad base64');
       expect(base64('aGVsbG8='), isNull);
       expect(base64('@@@@'), equals('Bad base64'));
-      final urlSafe = Validator.base64(urlSafe: true, errorMessage: 'Bad url64');
-      expect(urlSafe('a-b_c'), isNull);
+      final urlSafe = Validator.base64(
+        urlSafe: true,
+        errorMessage: 'Bad url64',
+      );
+      expect(urlSafe('a-b_cdef'), isNull);
     });
 
     test('ByteLength validator', () {
-      final byteLength = Validator.byteLength(2, max: 5, errorMessage: 'Bad len');
+      final byteLength = Validator.byteLength(
+        2,
+        max: 5,
+        errorMessage: 'Bad len',
+      );
       expect(byteLength('abc'), isNull);
       expect(byteLength('a'), equals('Bad len'));
       expect(byteLength('abcdef'), equals('Bad len'));
@@ -260,7 +267,10 @@ void main() {
     });
 
     test('Contains validator', () {
-      final containsWorld = Validator.contains('world', errorMessage: 'Missing');
+      final containsWorld = Validator.contains(
+        'world',
+        errorMessage: 'Missing',
+      );
       expect(containsWorld('hello world'), isNull);
       expect(containsWorld('hello there'), equals('Missing'));
       final caseInsensitive = Validator.contains(
@@ -281,10 +291,11 @@ void main() {
     });
 
     test('InList validator', () {
-      final inList = Validator.inList(
-        ['red', 'green', 'blue'],
-        errorMessage: 'Not allowed',
-      );
+      final inList = Validator.inList([
+        'red',
+        'green',
+        'blue',
+      ], errorMessage: 'Not allowed');
       expect(inList('red'), isNull);
       expect(inList('yellow'), equals('Not allowed'));
     });
diff --git a/test/validators/base64_test.dart b/test/validators/base64_test.dart
index 24cb1db..ddf827b 100644
--- a/test/validators/base64_test.dart
+++ b/test/validators/base64_test.dart
@@ -11,13 +11,15 @@ void main() {
 
     test('Valid URL-safe Base64 strings', () {
       expect('aGVsbG8'.isBase64(urlSafe: true), isTrue);
-      expect(isBase64('a-b_c', urlSafe: true), isTrue);
+      expect(isBase64('a-b_cdef', urlSafe: true), isTrue);
     });
 
     test('Invalid Base64 strings', () {
       expect('aGVsbG8'.isBase64(), isFalse); // bad padding
       expect('@@@@'.isBase64(), isFalse);
       expect(''.isBase64(), isFalse);
+      expect('a'.isBase64(urlSafe: true), isFalse); // impossible length
+      expect('abcde'.isBase64(urlSafe: true), isFalse); // length % 4 == 1
     });
   });
 }
diff --git a/test/validators/sanitizers/to_boolean_test.dart b/test/validators/sanitizers/to_boolean_test.dart
index b71003f..a3f3ac4 100644
--- a/test/validators/sanitizers/to_boolean_test.dart
+++ b/test/validators/sanitizers/to_boolean_test.dart
@@ -16,5 +16,12 @@ void main() {
       expect('true'.toBoolean(strict: true), isTrue);
       expect('yes'.toBoolean(strict: true), isFalse);
     });
+
+    test('keyword matching is case-insensitive', () {
+      expect(toBoolean('FALSE'), isFalse);
+      expect(toBoolean('False'), isFalse);
+      expect('TRUE'.toBoolean(strict: true), isTrue);
+      expect('True'.toBoolean(strict: true), isTrue);
+    });
   });
 }