diff --git a/README.md b/README.md
index cd76884..9db62b0 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ return new SizeSorter([
 /*
  * Returns:
  * 
- * array: [
+ * Illuminate\Support\Collection([
  *   'XXS',
  *   'XL',
  *   'XXL',
@@ -64,7 +64,7 @@ return new SizeSorter([
  *   '28',
  *   '54',
  *   'ONE SIZE',
- * ]
+ * ])
  */
 ```
 
@@ -72,29 +72,21 @@ return new SizeSorter([
 use DragonCode\SizeSorter\SizeSorter;
 
 // Laravel models collection
-$items = Size::query()->get();
+$items = Size::get();
 
 return new SizeSorter($items)
     ->column('title')
     ->sort();
 ```
 
+The static `items` method is also available:
+
 ```php
 use DragonCode\SizeSorter\SizeSorter;
 
-// Laravel collection
-$items = collect([...]);
-
-return new SizeSorter($items)
-    ->sort();
-
-/*
- * Returns:
- * 
- * Collection: [
- *   // ...
- * ]
- */
+return SizeSorter::items([
+    // ...
+])->sort();
 ```
 
 ### Groups Order
@@ -137,7 +129,10 @@ use DragonCode\SizeSorter\Enum\Group;
 use DragonCode\SizeSorter\SizeSorter;
 
 return new SizeSorter($items)
-    ->orderBy([Group::BraSize, Group::OtherSizes])
+    ->orderBy([
+        Group::BraSize,
+        Group::OtherSizes,
+    ])
     ->sort();
 ```
 
@@ -148,12 +143,98 @@ ascending order:
 3 - 5 - 1 - 2 - 4
 ```
 
+### Custom Column
+
+When working with an array of objects, you can specify which value can be used for sorting.
+
+```php
+use DragonCode\SizeSorter\SizeSorter;
+
+return new SizeSorter($items)
+    ->column('foo')
+    ->sort();
+```
+
+You can also use "dotted" notation:
+
+```php
+use DragonCode\SizeSorter\SizeSorter;
+
+$items = [
+    [
+        'foo' => [
+            'bar' => [
+                'baz' => 'Some value',
+            ]
+        ]
+    ]
+];
+
+return new SizeSorter($items)
+    ->column('foo.bar.baz')
+    ->sort();
+```
+
+And you can use the callback function in the same way:
+
+```php
+use DragonCode\SizeSorter\SizeSorter;
+
+class Foo
+{
+    public function __construct(
+        public int $number,
+        public string $value1,
+        public string $value2,
+    ) {}
+}
+
+$items = [
+    new Foo(1, 'first 1', 'first 2'),
+    new Foo(2, 'second 1', 'second 2'),
+];
+
+return new SizeSorter($items)
+    ->column(function (Foo $item) {
+        return $item->number % 2 === 0
+            ? $item->value1
+            : $item->value2;
+    })
+    ->sort();
+```
+
+And this is also possible:
+
+```php
+use DragonCode\SizeSorter\SizeSorter;
+
+$items = [
+    ['foo' => 'XS'],
+    ['foo' => '2XS'],
+    ['foo' => '3XL'],
+];
+
+return new SizeSorter($items)
+    ->column(function (array $item) {
+        return match ($item['foo']) {
+            '2XS' => 'XXS',
+            '3XL' => 'XXXL',
+            default => $item['foo']
+        };
+    })
+    ->sort();
+```
+
+## Upgrade Guide
+
+You can find the upgrade documentation [here](UPGRADE.md).
+
 ## License
 
 This package is licensed under the [MIT License](LICENSE).
 
 
-[badge_build]:          https://img.shields.io/github/actions/workflow/status/TheDragonCode/size-sorter/phpunit.yml?style=flat-square
+[badge_build]:          https://img.shields.io/github/actions/workflow/status/TheDragonCode/size-sorter/tests.yml?style=flat-square
 
 [badge_downloads]:      https://img.shields.io/packagist/dt/dragon-code/size-sorter.svg?style=flat-square
 
diff --git a/UPGRADE.md b/UPGRADE.md
new file mode 100644
index 0000000..4056dde
--- /dev/null
+++ b/UPGRADE.md
@@ -0,0 +1,67 @@
+# Upgrade Guide
+
+## To 2.x from 1.0
+
+### Updating Dependencies
+
+You should update the following dependencies in your application's `composer.json` file:
+
+- `dragon-code/size-sorter` to `^2.0`
+
+### Changing Namespace
+
+Namespace should be changed:
+
+You should update the namespace and method name to call:
+
+```diff
+-DragonCode\SizeSorter\Sorter::sort()
++DragonCode\SizeSorter\SizeSorter::items()
+
+-use DragonCode\SizeSorter\Enum\Group;
++use DragonCode\SizeSorter\Enums\GroupEnum;
+```
+
+### Changing parameters and call methods
+
+```diff
+-use DragonCode\SizeSorter\Sorter;
+-use DragonCode\SizeSorter\Enum\Group;
++use DragonCode\SizeSorter\SizeSorter;
++use DragonCode\SizeSorter\Enums\GroupEnum;
+
+-$sort1 = Sorter::sort($items, 'column.name', [1, 2]);
+-$sort2 = Sorter::sort($items, 'column.name', [Group::GROUP_1, Group::GROUP_2]);
++
++$sort = SizeSorter::items($items)
++    ->column('column.name')
++    ->orderBy([
++        GroupEnum::LetterClothingSize,
++        GroupEnum::ClothesAndShoes,
++    ])
++    ->sort();
+```
+
+### Groups
+
+> [!WARNING]
+>
+> The array to sort must now consist of GroupEnum objects.
+> Integers are no longer accepted.
+
+'Group::GROUP_1' replaced by `GroupEnum::LetterClothingSize`
+'Group::GROUP_2' replaced by `GroupEnum::ClothesAndShoes`
+'Group::GROUP_3' replaced by `GroupEnum::BraSize`
+'Group::GROUP_4' replaced by `GroupEnum::OverallDimensions`
+'Group::GROUP_5' replaced by `GroupEnum::OtherSizes`
+
+```php
+enum GroupEnum: int
+{
+    case LetterClothingSize = 1;
+    case ClothesAndShoes    = 2;
+    case BraSize            = 3;
+    case OverallDimensions  = 4;
+    case OtherSizes         = 5;
+}
+```
diff --git a/src/Contracts/GroupMatcher.php b/src/Contracts/GroupMatcher.php
deleted file mode 100644
index ff5899b..0000000
--- a/src/Contracts/GroupMatcher.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Contracts;
-
-interface GroupMatcher
-{
-    public static function detect(string $value): bool;
-}
diff --git a/src/Contracts/Sorter.php b/src/Contracts/Sorter.php
deleted file mode 100644
index 4f34ec8..0000000
--- a/src/Contracts/Sorter.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Contracts;
-
-interface Sorter
-{
-    public static function get(string $column, int $arrow = 1): callable;
-}
diff --git a/src/Detectors/Base.php b/src/Detectors/Base.php
deleted file mode 100644
index a54c37d..0000000
--- a/src/Detectors/Base.php
+++ /dev/null
@@ -1,23 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Detectors;
-
-use DragonCode\SizeSorter\Contracts\GroupMatcher;
-use DragonCode\SizeSorter\Services\Str;
-
-abstract class Base implements GroupMatcher
-{
-    protected static array|string $pattern;
-
-    public static function detect(string $value): bool
-    {
-        return Str::match(static::prepare($value), static::$pattern);
-    }
-
-    protected static function prepare(string $value): string
-    {
-        return $value;
-    }
-}
diff --git a/src/Detectors/Group1.php b/src/Detectors/Group1.php
deleted file mode 100644
index 33b1298..0000000
--- a/src/Detectors/Group1.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Detectors;
-
-class Group1 extends Base
-{
-    protected static array|string $pattern = '/^(x*[sml])$/';
-}
diff --git a/src/Detectors/Group2.php b/src/Detectors/Group2.php
deleted file mode 100644
index 37106b5..0000000
--- a/src/Detectors/Group2.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Detectors;
-
-use DragonCode\SizeSorter\Services\Str;
-
-class Group2 extends Base
-{
-    protected static array|string $pattern = '/^(\d+-?\d*)$/';
-
-    protected static function prepare(string $value): string
-    {
-        return Str::slug($value);
-    }
-}
diff --git a/src/Detectors/Group3.php b/src/Detectors/Group3.php
deleted file mode 100644
index 82e4221..0000000
--- a/src/Detectors/Group3.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Detectors;
-
-use DragonCode\SizeSorter\Services\Str;
-
-class Group3 extends Base
-{
-    protected static array|string $pattern = '/^(\d+[a-f]{1,2})$/';
-
-    protected static function prepare(string $value): string
-    {
-        return Str::slug($value);
-    }
-}
diff --git a/src/Detectors/Group4.php b/src/Detectors/Group4.php
deleted file mode 100644
index 938c8fa..0000000
--- a/src/Detectors/Group4.php
+++ /dev/null
@@ -1,38 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Detectors;
-
-use DragonCode\SizeSorter\Services\Resolver;
-use DragonCode\SizeSorter\Services\Str;
-
-class Group4 extends Base
-{
-    protected static array|string $pattern = [
-        '/^([\d\-hx\*]*0s0m)$/',
-        '/^(\d+[a-f])$/',
-    ];
-
-    protected static function prepare(string $value): string
-    {
-        return Str::of($value)
-            ->squish()
-            ->trim()
-            ->replace('\\', '/')
-            ->explode('/')
-            ->map(static fn (string $value) => static::compact($value))
-            ->implode('/')
-            ->toString();
-    }
-
-    protected static function compact(string $value): string
-    {
-        return Str::of($value)
-            ->slug()
-            ->explode('-')
-            ->map(static fn (string $value) => Resolver::size($value))
-            ->implode('-')
-            ->toString();
-    }
-}
diff --git a/src/Enum/Group.php b/src/Enum/Group.php
deleted file mode 100644
index e476868..0000000
--- a/src/Enum/Group.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Enum;
-
-use function array_column;
-
-enum Group: int
-{
-    case LetterClothingSize = 1;
-    case ClothesAndShoes    = 2;
-    case BraSize            = 3;
-    case OverallDimensions  = 4;
-    case OtherSizes         = 5;
-
-    public static function exists(Group|int|string $group): bool
-    {
-        if ($group instanceof self) {
-            return true;
-        }
-
-        return self::tryFrom((int) $group) !== null;
-    }
-
-    public static function values(): array
-    {
-        return array_column(self::cases(), 'value');
-    }
-}
diff --git a/src/Enums/GroupEnum.php b/src/Enums/GroupEnum.php
new file mode 100644
index 0000000..1d593db
--- /dev/null
+++ b/src/Enums/GroupEnum.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Enums;
+
+enum GroupEnum: int
+{
+    case LetterClothingSize = 1;
+    case ClothesAndShoes    = 2;
+    case BraSize            = 3;
+    case OverallDimensions  = 4;
+    case OtherSizes         = 5;
+
+    public static function sorted(): array
+    {
+        return [
+            self::LetterClothingSize,
+            self::ClothesAndShoes,
+            self::BraSize,
+            self::OverallDimensions,
+            self::OtherSizes,
+        ];
+    }
+}
diff --git a/src/Groups/BraGroup.php b/src/Groups/BraGroup.php
new file mode 100644
index 0000000..12bedc0
--- /dev/null
+++ b/src/Groups/BraGroup.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Groups;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+
+class BraGroup extends Group
+{
+    protected static GroupEnum $group = GroupEnum::BraSize;
+
+    protected static array|string $pattern = '/^(\d+[a-f]{1,2})$/';
+}
diff --git a/src/Groups/ClothesAndShoesGroup.php b/src/Groups/ClothesAndShoesGroup.php
new file mode 100644
index 0000000..20268b0
--- /dev/null
+++ b/src/Groups/ClothesAndShoesGroup.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Groups;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+
+class ClothesAndShoesGroup extends Group
+{
+    protected static GroupEnum $group = GroupEnum::ClothesAndShoes;
+
+    protected static array|string $pattern = '/^(\d+_?\d*)$/';
+}
diff --git a/src/Groups/Group.php b/src/Groups/Group.php
new file mode 100644
index 0000000..8fa5c0b
--- /dev/null
+++ b/src/Groups/Group.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Groups;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+use Illuminate\Support\Str;
+use Illuminate\Support\Stringable;
+
+use function implode;
+
+abstract class Group
+{
+    public const Delimiter = '::';
+
+    protected static GroupEnum $group;
+
+    protected static array|string $pattern;
+
+    public static function detect(string $value): bool
+    {
+        return Str::isMatch(static::$pattern, $value);
+    }
+
+    public static function normalize(mixed $value, int|string $key): string
+    {
+        return implode(static::Delimiter, [static::$group->value, $key, static::prepare($value)]);
+    }
+
+    public static function value(string $key): Stringable
+    {
+        return Str::of($key)->afterLast(static::Delimiter);
+    }
+
+    protected static function prepare(mixed $value): string
+    {
+        return $value;
+    }
+}
diff --git a/src/Groups/LetterClothingGroup.php b/src/Groups/LetterClothingGroup.php
new file mode 100644
index 0000000..fc7fa2c
--- /dev/null
+++ b/src/Groups/LetterClothingGroup.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Groups;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+use Illuminate\Support\Str;
+
+use function in_array;
+use function preg_match;
+use function strlen;
+
+class LetterClothingGroup extends Group
+{
+    protected static GroupEnum $group = GroupEnum::LetterClothingSize;
+
+    protected static array|string $pattern = '/^(?\'size\'(([2-9]?[x]{1,9}[sml]{1})|([sml])))(_(?1))?$/';
+
+    protected static array $multiplier = [
+        's' => 100,
+        'm' => 1000,
+        'l' => 10000,
+    ];
+
+    protected static function prepare(mixed $value): string
+    {
+        return Str::of($value)
+            ->explode('_')
+            ->map(static fn (mixed $value) => static::convert($value))
+            ->implode('_');
+    }
+
+    protected static function convert(mixed $value): string
+    {
+        if (in_array($value, ['s', 'm', 'l'])) {
+            return (string) static::multiply($value, 1);
+        }
+
+        if (preg_match('/^(x+)?s$/', $value, $matches)) {
+            $count = isset($matches[1]) ? strlen($matches[1]) : 1;
+
+            return (string) static::multiply('s', $count);
+        }
+
+        if (preg_match('/^(\d+)xs$/', $value, $matches)) {
+            return (string) static::multiply('s', (int) $matches[1], 1);
+        }
+
+        if (preg_match('/^(x+)l$/', $value, $matches)) {
+            $count = strlen($matches[1]);
+
+            return (string) static::multiply('l', $count);
+        }
+
+        if (preg_match('/^(\d+)xl$/', $value, $matches)) {
+            return (string) static::multiply('l', (int) $matches[1], 1);
+        }
+
+        return '0';
+    }
+
+    protected static function multiply(string $key, int $count, int $plus = 0): int
+    {
+        return static::$multiplier[$key] * $count + $plus;
+    }
+}
diff --git a/src/Groups/OtherGroup.php b/src/Groups/OtherGroup.php
new file mode 100644
index 0000000..c294420
--- /dev/null
+++ b/src/Groups/OtherGroup.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Groups;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+
+class OtherGroup extends Group
+{
+    protected static GroupEnum $group = GroupEnum::OtherSizes;
+
+    public static function detect(string $value): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Groups/OverallDimensionsGroup.php b/src/Groups/OverallDimensionsGroup.php
new file mode 100644
index 0000000..4e79bfe
--- /dev/null
+++ b/src/Groups/OverallDimensionsGroup.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Groups;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+
+class OverallDimensionsGroup extends Group
+{
+    protected static GroupEnum $group = GroupEnum::OverallDimensions;
+
+    protected static array|string $pattern = '/^([\d]+x?){1,3}([_\sms]+)$/';
+}
diff --git a/src/Normalizers/KeyNormalizer.php b/src/Normalizers/KeyNormalizer.php
new file mode 100644
index 0000000..e59c98b
--- /dev/null
+++ b/src/Normalizers/KeyNormalizer.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Normalizers;
+
+use DragonCode\SizeSorter\Support\Cache;
+use Illuminate\Support\Str;
+
+use function is_bool;
+use function is_numeric;
+
+class KeyNormalizer extends Normalizer
+{
+    public static function normalize(mixed $value): string
+    {
+        if ($value === null) {
+            return 'null';
+        }
+
+        if (is_bool($value)) {
+            return $value ? 'true' : 'false';
+        }
+
+        if (is_numeric($value)) {
+            return (string) $value;
+        }
+
+        return Cache::remember(
+            $value,
+            static fn () => Str::of($value)
+                ->replaceMatches('/[\W_\s]+/u', ' ')
+                ->trim()
+                ->slug('_')
+                ->toString()
+        );
+    }
+}
diff --git a/src/Normalizers/Normalizer.php b/src/Normalizers/Normalizer.php
new file mode 100644
index 0000000..586a0c3
--- /dev/null
+++ b/src/Normalizers/Normalizer.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Normalizers;
+
+abstract class Normalizer
+{
+    abstract public static function normalize(mixed $value): string;
+}
diff --git a/src/Services/Collection.php b/src/Services/Collection.php
deleted file mode 100644
index a5eec27..0000000
--- a/src/Services/Collection.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Services;
-
-use Illuminate\Support\Collection as IC;
-
-class Collection
-{
-    public static function make(array $items = []): IC
-    {
-        return new IC($items);
-    }
-
-    public static function flatten(IC $items): IC
-    {
-        $result = static::make();
-
-        $items->each(static function (mixed $value, mixed $key) use (&$result) {
-            if (! $value instanceof IC) {
-                $result->put($key, $value);
-
-                return;
-            }
-
-            $result = static::merge($result, static::flatten($value));
-        });
-
-        return $result;
-    }
-
-    public static function merge(IC $result, IC $second): IC
-    {
-        $second->each(
-            static fn (mixed $value, mixed $key) => $result->put($key, $value)
-        );
-
-        return $result;
-    }
-}
diff --git a/src/Services/GroupsDetector.php b/src/Services/GroupsDetector.php
deleted file mode 100644
index 3157b1e..0000000
--- a/src/Services/GroupsDetector.php
+++ /dev/null
@@ -1,36 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Services;
-
-use DragonCode\SizeSorter\Detectors\Base as BaseDetector;
-use DragonCode\SizeSorter\Detectors\Group1;
-use DragonCode\SizeSorter\Detectors\Group2;
-use DragonCode\SizeSorter\Detectors\Group3;
-use DragonCode\SizeSorter\Detectors\Group4;
-use DragonCode\SizeSorter\Enum\Group;
-
-class GroupsDetector
-{
-    /** @var array<class-string|BaseDetector, Group> */
-    protected static array $detectors = [
-        Group1::class => Group::LetterClothingSize,
-        Group2::class => Group::ClothesAndShoes,
-        Group3::class => Group::BraSize,
-        Group4::class => Group::OverallDimensions,
-    ];
-
-    protected static Group $default = Group::OtherSizes;
-
-    public static function detect(string $value): int
-    {
-        foreach (static::$detectors as $detector => $group) {
-            if ($detector::detect($value)) {
-                return $group->value;
-            }
-        }
-
-        return static::$default->value;
-    }
-}
diff --git a/src/Services/MainLogic.php b/src/Services/MainLogic.php
deleted file mode 100644
index 6e35aed..0000000
--- a/src/Services/MainLogic.php
+++ /dev/null
@@ -1,124 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Services;
-
-use DragonCode\SizeSorter\Enum\Group;
-use DragonCode\SizeSorter\Sorters\ArrowSorter;
-use DragonCode\SizeSorter\Sorters\CharSorter;
-use DragonCode\SizeSorter\Sorters\NumberSorter;
-use DragonCode\Support\Helpers\Ables\Stringable;
-use Illuminate\Support\Collection as IC;
-
-class MainLogic
-{
-    public static function sort(iterable $items, string $column = 'value', ?array $groupsOrder = null): IC
-    {
-        return static::flatten(
-            static::handle(collect($items), $column, $groupsOrder)
-        );
-    }
-
-    protected static function handle(IC $items, string $column, array $groupsOrder): IC
-    {
-        return static::orderGroups(static::sorting($items, $column), $groupsOrder);
-    }
-
-    protected static function orderGroups(IC $items, array $order): IC
-    {
-        $result = static::collect();
-
-        foreach ($order as $key) {
-            if ($items->has($key)) {
-                $result->put($key, $items->get($key));
-            }
-        }
-
-        return $result;
-    }
-
-    protected static function sorting(IC $items, string $column = 'value'): IC
-    {
-        return $items
-            ->groupBy(static fn (mixed $size) => static::detectGroup(
-                static::resolveValue($size, $column)->toString()
-            ), true)
-            ->map(static fn (IC $items, int $group) => static::sortByGroup($items, $group, $column));
-    }
-
-    protected static function sortByGroup(IC $items, int $group, string $column): IC
-    {
-        return match ($group) {
-            Group::LetterClothingSize->value => static::sortChars($items, $column),
-            Group::ClothesAndShoes->value    => static::sortNumbers($items, $column),
-            default                          => static::sortArrows($items, $column)
-        };
-    }
-
-    protected static function sortChars(IC $values, string $column): IC
-    {
-        return $values->groupBy(
-            static fn (mixed $size) => static::resolveValue($size, $column)
-                ->match('/(s|m|l)/')
-                ->toString(),
-            true
-        )
-            ->sortKeysDesc()
-            ->map(
-                static fn (IC $values, string $group) => $group === 's'
-                    ? static::sortSmallSizes($values, $column)
-                    : static::sortArrows($values, $column)
-            );
-    }
-
-    protected static function sortSmallSizes(IC $values, string $column): IC
-    {
-        return $values->sort(
-            ArrowSorter::get($column, -1)
-        )
-            ->groupBy(static fn (mixed $size) => static::resolveValue($size, $column)->toString(), true)
-            ->map(static fn (IC $values) => static::sortSpecialChars($values, $column));
-    }
-
-    protected static function sortSpecialChars(IC $values, string $column): IC
-    {
-        return $values->sort(
-            CharSorter::get($column)
-        );
-    }
-
-    protected static function sortArrows(IC $values, string $column): IC
-    {
-        return $values->sort(
-            ArrowSorter::get($column)
-        );
-    }
-
-    protected static function sortNumbers(IC $items, string $column): IC
-    {
-        return $items->sort(
-            NumberSorter::get($column)
-        );
-    }
-
-    protected static function detectGroup(string $value): int
-    {
-        return GroupsDetector::detect($value);
-    }
-
-    protected static function collect(): IC
-    {
-        return Collection::make();
-    }
-
-    protected static function flatten(IC $items): IC
-    {
-        return Collection::flatten($items);
-    }
-
-    protected static function resolveValue(mixed $value, string $column): Stringable
-    {
-        return Resolver::value($value, $column);
-    }
-}
diff --git a/src/Services/Order.php b/src/Services/Order.php
deleted file mode 100644
index f445016..0000000
--- a/src/Services/Order.php
+++ /dev/null
@@ -1,68 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Services;
-
-use DragonCode\SizeSorter\Enum\Group;
-
-class Order
-{
-    public function resolve(?array $groups = null): array
-    {
-        return ! empty($groups)
-            ? $this->fill($groups)
-            : $this->groups();
-    }
-
-    protected function fill(array $groups): array
-    {
-        return $this->fillDefault(
-            $this->fillCustom($groups)
-        );
-    }
-
-    protected function fillCustom(array $groups): array
-    {
-        $result = [];
-
-        foreach ($groups as $group) {
-            $value = $this->resolveValue($group);
-
-            if ($this->existGroup($value)) {
-                $result[] = $value;
-            }
-        }
-
-        return $result;
-    }
-
-    protected function fillDefault(array $groups): array
-    {
-        foreach ($this->groups() as $group) {
-            if (! in_array($group, $groups, true)) {
-                $groups[] = $group;
-            }
-        }
-
-        return $groups;
-    }
-
-    protected function existGroup(int $value): bool
-    {
-        return Group::exists($value);
-    }
-
-    /**
-     * @return Group[]
-     */
-    protected function groups(): array
-    {
-        return Group::values();
-    }
-
-    protected function resolveValue(Group|int $group): int
-    {
-        return $group->value ?? $group;
-    }
-}
diff --git a/src/Services/Processor.php b/src/Services/Processor.php
new file mode 100644
index 0000000..108de1b
--- /dev/null
+++ b/src/Services/Processor.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Services;
+
+use Closure;
+use DragonCode\SizeSorter\Enums\GroupEnum;
+use DragonCode\SizeSorter\Groups\Group;
+use DragonCode\SizeSorter\Support\Map;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
+
+class Processor
+{
+    public function __construct(
+        protected Sort $sort = new Sort
+    ) {}
+
+    public function run(Collection $items, Closure $column, array $orderBy): Collection
+    {
+        $sorted = $this->sortItems($items, $column);
+
+        $map = $this->sortGroups($sorted, $orderBy);
+
+        return Map::apply($items, $map);
+    }
+
+    protected function sortItems(Collection $items, Closure $column): Collection
+    {
+        return $this->map($items, $column)
+            ->groupBy(fn (mixed $value, string $key) => $this->detectGroup($key), true)
+            ->map(fn (Collection $values, int $group) => $this->sortPerGroup($values, $group));
+    }
+
+    protected function sortGroups(Collection $items, array $orderBy): Collection
+    {
+        return Collection::make($orderBy)->map(
+            fn (GroupEnum $group) => $items->get($group->value)
+        )->collapseWithKeys();
+    }
+
+    protected function sortPerGroup(Collection $items, int $group): Collection
+    {
+        return match ($group) {
+            GroupEnum::LetterClothingSize->value,
+            GroupEnum::ClothesAndShoes->value => $this->sort->byNumber($items),
+            default                           => $this->sort->byAlphabet($items),
+        };
+    }
+
+    protected function detectGroup(string $key): int
+    {
+        return (int) Str::before($key, Group::Delimiter);
+    }
+
+    protected function map(Collection $items, Closure $column): Collection
+    {
+        return Map::make($items, $column);
+    }
+}
diff --git a/src/Services/Resolver.php b/src/Services/Resolver.php
deleted file mode 100644
index 40fc9bc..0000000
--- a/src/Services/Resolver.php
+++ /dev/null
@@ -1,82 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Services;
-
-use ArrayAccess;
-use BackedEnum;
-use DragonCode\Support\Facades\Helpers\Arr;
-use DragonCode\Support\Helpers\Ables\Stringable;
-use Stringable as BaseStringable;
-
-class Resolver
-{
-    public static function key(mixed $value, string $column): mixed
-    {
-        return match (true) {
-            $value instanceof BackedEnum => self::fromEnum($value),
-            $value instanceof ArrayAccess,
-            is_array($value)                 => self::fromArray($value, $column),
-            $value instanceof BaseStringable => self::fromStringable($value),
-            default                          => $value->{$column} ?? $value
-        };
-    }
-
-    public static function value(mixed $value, string $column): Stringable
-    {
-        return static::prepare($value, $column)
-            ->replace(['\\', '-'], '/')
-            ->before('/')
-            ->lower();
-    }
-
-    public static function number(mixed $value, string $column): array
-    {
-        return static::prepare($value, $column)
-            ->replace(['\\', '-'], '/')
-            ->explode('/')
-            ->map(static fn (mixed $val) => (int) $val)
-            ->toArray();
-    }
-
-    public static function size(string $value): string
-    {
-        if (Str::match($value, '/(\d+x)/')) {
-            return Str::replace('x', '', $value);
-        }
-
-        if ($count = Str::count($value)) {
-            return Str::replace($value, Str::pad($count), $count);
-        }
-
-        return Str::replace($value, ['s', 'm', 'l'], ['0s', '0m', '0l']);
-    }
-
-    public static function callback(callable $callback, mixed ...$parameters): mixed
-    {
-        return $callback(...$parameters);
-    }
-
-    protected static function prepare(mixed $value, string $column): Stringable
-    {
-        return Str::of(
-            static::key($value, $column)
-        )->squish()->trim();
-    }
-
-    protected static function fromEnum(BackedEnum $item): mixed
-    {
-        return $item->value ?? $item->name;
-    }
-
-    protected static function fromStringable(BaseStringable $item): mixed
-    {
-        return method_exists($item, 'toString') ? $item->toString() : (string) $item;
-    }
-
-    protected static function fromArray(mixed $item, string $column): mixed
-    {
-        return Arr::get($item, $column, $item);
-    }
-}
diff --git a/src/Services/Sort.php b/src/Services/Sort.php
new file mode 100644
index 0000000..7cd5139
--- /dev/null
+++ b/src/Services/Sort.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Services;
+
+use DragonCode\SizeSorter\Sorters\NumberSorter;
+use Illuminate\Support\Collection;
+
+class Sort
+{
+    public function byNumber(Collection $items): Collection
+    {
+        return $items->sortKeysUsing(
+            NumberSorter::callback()
+        );
+    }
+
+    public function byAlphabet(Collection $items): Collection
+    {
+        return $items->sortKeys();
+    }
+}
diff --git a/src/Services/Str.php b/src/Services/Str.php
deleted file mode 100644
index cff4a1e..0000000
--- a/src/Services/Str.php
+++ /dev/null
@@ -1,46 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Services;
-
-use DragonCode\Support\Facades\Helpers\Str as DS;
-use DragonCode\Support\Helpers\Ables\Stringable;
-
-class Str
-{
-    public static function of(mixed $value): Stringable
-    {
-        return DS::of((string) $value);
-    }
-
-    public static function pad(int $length, string $pad = 'x'): string
-    {
-        return str_pad('', $length, $pad);
-    }
-
-    public static function replace(string $value, array|string $search, array|int|string $replace): string
-    {
-        return DS::replace($value, $search, $replace);
-    }
-
-    public static function contains(string $value, string $needle): bool
-    {
-        return DS::contains($value, $needle);
-    }
-
-    public static function match(string $value, array|string $pattern): bool
-    {
-        return DS::matchContains($value, $pattern);
-    }
-
-    public static function slug(string $value): string
-    {
-        return DS::slug($value);
-    }
-
-    public static function count(string $value, string $needle = 'x'): int
-    {
-        return DS::count($value, $needle);
-    }
-}
diff --git a/src/SizeSorter.php b/src/SizeSorter.php
index 9292310..0123f3c 100644
--- a/src/SizeSorter.php
+++ b/src/SizeSorter.php
@@ -4,16 +4,19 @@
 
 namespace DragonCode\SizeSorter;
 
-use DragonCode\SizeSorter\Enum\Group;
-use DragonCode\SizeSorter\Services\MainLogic;
-use DragonCode\SizeSorter\Services\Order;
+use Closure;
+use DragonCode\SizeSorter\Enums\GroupEnum;
+use DragonCode\SizeSorter\Services\Processor;
+use DragonCode\SizeSorter\Support\GroupOrder;
+use DragonCode\SizeSorter\Support\Resolve;
 use DragonCode\SizeSorter\Support\Validator;
+use Illuminate\Support\Collection;
 
 class SizeSorter
 {
-    protected string $column = 'value';
+    protected Closure|string $column = 'value';
 
-    protected ?array $orderBy = null;
+    protected ?iterable $orderBy = null;
 
     public static function items(iterable $items): static
     {
@@ -22,10 +25,10 @@ public static function items(iterable $items): static
 
     public function __construct(
         protected readonly iterable $items,
-        protected readonly Order $order = new Order
+        protected readonly Processor $processor = new Processor,
     ) {}
 
-    public function column(string $name): static
+    public function column(Closure|string $name): static
     {
         $this->column = $name;
 
@@ -33,25 +36,49 @@ public function column(string $name): static
     }
 
     /**
-     * @param  Group[]|null  $order
+     * @param  GroupEnum[]|null  $order
      * @return $this
      */
-    public function orderBy(?array $order): static
+    public function orderBy(?iterable $order): static
     {
-        Validator::ensure($order, Group::class);
+        if (empty($order)) {
+            return $this;
+        }
 
-        $this->orderBy = $this->order->resolve($order);
+        Validator::ensure($order, GroupEnum::class);
+
+        $this->orderBy = $order;
 
         return $this;
     }
 
-    public function sort(): iterable
+    public function sort(): Collection
+    {
+        return $this->processor->run(
+            $this->getItems(),
+            $this->getColumn(),
+            $this->getOrderBy()
+        );
+    }
+
+    protected function getItems(): Collection
     {
-        return MainLogic::sort($this->items, $this->column, $this->getOrderBy());
+        return new Collection($this->items);
+    }
+
+    protected function getColumn(): Closure
+    {
+        if ($this->column instanceof Closure) {
+            return $this->column;
+        }
+
+        return fn (mixed $item) => Resolve::value($item, $this->column);
     }
 
-    protected function getOrderBy(): ?array
+    protected function getOrderBy(): array
     {
-        return $this->orderBy ?? $this->order->resolve();
+        return GroupOrder::get(
+            $this->orderBy
+        );
     }
 }
diff --git a/src/Sorters/ArrowSorter.php b/src/Sorters/ArrowSorter.php
index 77f57a4..ea1e301 100644
--- a/src/Sorters/ArrowSorter.php
+++ b/src/Sorters/ArrowSorter.php
@@ -4,14 +4,13 @@
 
 namespace DragonCode\SizeSorter\Sorters;
 
-class ArrowSorter extends BaseSorter
+use Closure;
+
+class ArrowSorter extends Sorter
 {
-    public static function get(string $column, int $arrow = 1): callable
+    public static function callback(int $arrow = 1): Closure
     {
-        return static function (mixed $a, mixed $b) use ($arrow, $column) {
-            $a = static::key($a, $column);
-            $b = static::key($b, $column);
-
+        return static function (mixed $a, mixed $b) use ($arrow) {
             if ($a === $b) {
                 return 0;
             }
diff --git a/src/Sorters/BaseSorter.php b/src/Sorters/BaseSorter.php
deleted file mode 100644
index b916578..0000000
--- a/src/Sorters/BaseSorter.php
+++ /dev/null
@@ -1,16 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DragonCode\SizeSorter\Sorters;
-
-use DragonCode\SizeSorter\Contracts\Sorter;
-use DragonCode\SizeSorter\Services\Resolver;
-
-abstract class BaseSorter implements Sorter
-{
-    protected static function key(mixed $value, string $column): mixed
-    {
-        return Resolver::key($value, $column);
-    }
-}
diff --git a/src/Sorters/CharSorter.php b/src/Sorters/CharSorter.php
index 8e7aca8..eb376de 100644
--- a/src/Sorters/CharSorter.php
+++ b/src/Sorters/CharSorter.php
@@ -4,30 +4,22 @@
 
 namespace DragonCode\SizeSorter\Sorters;
 
-use DragonCode\SizeSorter\Services\Resolver;
-use DragonCode\SizeSorter\Services\Str;
+use Closure;
+use Illuminate\Support\Str;
 
-class CharSorter extends BaseSorter
+class CharSorter extends Sorter
 {
-    public static function get(string $column, int $arrow = 1): callable
+    public static function callback(int $arrow = 1): Closure
     {
-        return static function (mixed $a, mixed $b) use ($column, $arrow) {
-            $a = static::key($a, $column);
-            $b = static::key($b, $column);
+        return static function (mixed $a, mixed $b) use ($arrow) {
+            $arrow = static::contains($a, '_') ? -1 : 1;
 
-            $arrow = static::contains($a, '/') && static::contains($b, '-') ? -1 : 1;
-
-            return Resolver::callback(static::resolveArrow($arrow, $column), $a, $b);
+            return ArrowSorter::callback($arrow)($a, $b);
         };
     }
 
-    protected static function resolveArrow(int $arrow, string $column): callable
-    {
-        return ArrowSorter::get($column, $arrow);
-    }
-
-    protected static function contains(string $value, string $needle): bool
+    protected static function contains(string $haystack, string $needle): bool
     {
-        return Str::contains($value, $needle);
+        return Str::contains($haystack, $needle);
     }
 }
diff --git a/src/Sorters/NumberSorter.php b/src/Sorters/NumberSorter.php
index 16ddbe6..a531511 100644
--- a/src/Sorters/NumberSorter.php
+++ b/src/Sorters/NumberSorter.php
@@ -4,34 +4,40 @@
 
 namespace DragonCode\SizeSorter\Sorters;
 
-use DragonCode\SizeSorter\Services\Resolver;
+use Closure;
+use DragonCode\SizeSorter\Groups\Group;
+use Illuminate\Support\Str;
 
-class NumberSorter extends BaseSorter
+class NumberSorter extends Sorter
 {
-    public static function get(string $column, int $arrow = 1): callable
+    public static function callback(int $arrow = 1): Closure
     {
-        return static function (mixed $a, mixed $b) use ($column, $arrow) {
-            $a = static::number($a, $column);
-            $b = static::number($b, $column);
+        return static function (mixed $a, mixed $b) use ($arrow) {
+            $a = static::extract($a);
+            $b = static::extract($b);
 
-            if ($a[0] === $b[0]) {
-                if (isset($a[1], $b[1])) {
-                    if ($a[1] === $b[1]) {
-                        return 0;
-                    }
+            if ($a[0] !== $b[0]) {
+                return $a[0] < $b[0] ? -1 * $arrow : $arrow;
+            }
 
-                    return $a[1] < $b[1] ? -1 * $arrow : $arrow;
-                }
+            if (! isset($a[1], $b[1])) {
+                return 0;
+            }
 
+            if ($a[1] === $b[1]) {
                 return 0;
             }
 
-            return $a[0] < $b[0] ? -1 * $arrow : $arrow;
+            return $a[1] < $b[1] ? -1 * $arrow : $arrow;
         };
     }
 
-    protected static function number(mixed $value, string $column): array
+    protected static function extract(int|string $value): array
     {
-        return Resolver::number($value, $column);
+        return Str::of($value)
+            ->afterLast(Group::Delimiter)
+            ->explode('_')
+            ->map(static fn (int|string $value) => (int) $value)
+            ->all();
     }
 }
diff --git a/src/Sorters/Sorter.php b/src/Sorters/Sorter.php
new file mode 100644
index 0000000..0fcab34
--- /dev/null
+++ b/src/Sorters/Sorter.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Sorters;
+
+use Closure;
+
+abstract class Sorter
+{
+    abstract public static function callback(int $arrow = 1): Closure;
+}
diff --git a/src/Support/Cache.php b/src/Support/Cache.php
new file mode 100644
index 0000000..32ff13d
--- /dev/null
+++ b/src/Support/Cache.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Support;
+
+use Closure;
+use Stringable;
+
+class Cache
+{
+    public static array $registry = [];
+
+    public static function remember(string|Stringable $value, Closure $callback): string
+    {
+        return static::$registry[(string) $value] ??= $callback();
+    }
+
+    public static function clear(): void
+    {
+        static::$registry = [];
+    }
+}
diff --git a/src/Support/GroupOrder.php b/src/Support/GroupOrder.php
new file mode 100644
index 0000000..ae3c332
--- /dev/null
+++ b/src/Support/GroupOrder.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Support;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+use Illuminate\Support\Collection;
+
+use function in_array;
+
+class GroupOrder
+{
+    public static function get(?iterable $groups): array
+    {
+        $result = static::normalize($groups);
+
+        foreach (static::fallback() as $group) {
+            if (! in_array($group, $result, true)) {
+                $result[] = $group;
+            }
+        }
+
+        return $result;
+    }
+
+    protected static function fallback(): array
+    {
+        return GroupEnum::sorted();
+    }
+
+    protected static function normalize(?iterable $groups): array
+    {
+        return Collection::make($groups)->all();
+    }
+}
diff --git a/src/Support/Map.php b/src/Support/Map.php
new file mode 100644
index 0000000..25d7934
--- /dev/null
+++ b/src/Support/Map.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Support;
+
+use Closure;
+use DragonCode\SizeSorter\Groups\BraGroup;
+use DragonCode\SizeSorter\Groups\ClothesAndShoesGroup;
+use DragonCode\SizeSorter\Groups\LetterClothingGroup;
+use DragonCode\SizeSorter\Groups\OtherGroup;
+use DragonCode\SizeSorter\Groups\OverallDimensionsGroup;
+use DragonCode\SizeSorter\Normalizers\KeyNormalizer;
+use Illuminate\Support\Collection;
+use Stringable;
+
+class Map
+{
+    public static function make(Collection $items, Closure $column): Collection
+    {
+        $result = [];
+
+        foreach ($items as $key => $value) {
+            $normalized = static::normalize($column($value));
+
+            $name = static::group($normalized, $key);
+
+            $result[$name] = $key;
+        }
+
+        return new Collection($result);
+    }
+
+    public static function apply(Collection $items, Collection $map): Collection
+    {
+        Validator::mapCount($items, $map);
+
+        return $map->mapWithKeys(fn (int|string $index) => [
+            $index => $items->get($index),
+        ]);
+    }
+
+    protected static function group(int|string $value, int|string $key): string
+    {
+        return match (true) {
+            LetterClothingGroup::detect($value)    => LetterClothingGroup::normalize($value, $key),
+            ClothesAndShoesGroup::detect($value)   => ClothesAndShoesGroup::normalize($value, $key),
+            BraGroup::detect($value)               => BraGroup::normalize($value, $key),
+            OverallDimensionsGroup::detect($value) => OverallDimensionsGroup::normalize($value, $key),
+            default                                => OtherGroup::normalize($value, $key)
+        };
+    }
+
+    protected static function normalize(float|int|string|Stringable $value): string
+    {
+        return KeyNormalizer::normalize($value);
+    }
+}
diff --git a/src/Support/Resolve.php b/src/Support/Resolve.php
new file mode 100644
index 0000000..046c29a
--- /dev/null
+++ b/src/Support/Resolve.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\SizeSorter\Support;
+
+use BackedEnum;
+use Illuminate\Support\Arr;
+use Stringable;
+use UnitEnum;
+
+use function is_array;
+use function is_object;
+
+class Resolve
+{
+    public static function value(mixed $item, string $column): mixed
+    {
+        if ($item instanceof BackedEnum) {
+            return $item->value;
+        }
+
+        if ($item instanceof UnitEnum) {
+            return $item->name;
+        }
+
+        if ($item instanceof Stringable) {
+            return (string) $item;
+        }
+
+        if (is_object($item)) {
+            return $item->{$column};
+        }
+
+        if (is_array($item)) {
+            return Arr::get($item, $column);
+        }
+
+        return $item;
+    }
+}
diff --git a/src/Support/Validator.php b/src/Support/Validator.php
index c42ce28..dad44bc 100644
--- a/src/Support/Validator.php
+++ b/src/Support/Validator.php
@@ -5,11 +5,51 @@
 namespace DragonCode\SizeSorter\Support;
 
 use Illuminate\Support\Collection;
+use LengthException;
+use UnexpectedValueException;
+
+use function get_debug_type;
 
 class Validator
 {
-    public static function ensure(?iterable $items, string $class): void
+    /**
+     * @template TEnsureOfType
+     *
+     * @param  class-string<TEnsureOfType>|array<array-key, class-string<TEnsureOfType>>|'string'|'int'|'float'|'bool'|'array'|'null'  $class
+     */
+    public static function ensure(iterable $items, string $class): void
+    {
+        foreach ($items as $index => $value) {
+            if ($value instanceof $class) {
+                continue;
+            }
+
+            $type = get_debug_type($value);
+
+            throw new UnexpectedValueException(
+                vsprintf("Collection should only include [%s] items, but '%s' found at position %d.", [
+                    $class,
+                    $type,
+                    $index,
+                ])
+            );
+        }
+    }
+
+    public static function mapCount(Collection $items, Collection $map): void
     {
-        (new Collection($items))->ensure($class);
+        $itemsCount = $items->count();
+        $mapCount   = $map->count();
+
+        if ($itemsCount === $mapCount) {
+            return;
+        }
+
+        throw new LengthException(
+            vsprintf('The count of items in the map (%d) and collection (%d) should be the same.', [
+                $mapCount,
+                $itemsCount,
+            ])
+        );
     }
 }
diff --git a/tests/Fixtures/Enums/IntegerEnum.php b/tests/Fixtures/Enums/IntegerEnum.php
new file mode 100644
index 0000000..d12a3d7
--- /dev/null
+++ b/tests/Fixtures/Enums/IntegerEnum.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Enums;
+
+enum IntegerEnum: int
+{
+    case Value2  = 2;
+    case Value1  = 1;
+    case Value30 = 30;
+    case Value21 = 21;
+    case Value3  = 3;
+}
diff --git a/tests/Fixtures/Enums/IntegerValue.php b/tests/Fixtures/Enums/IntegerValue.php
deleted file mode 100644
index 1af5136..0000000
--- a/tests/Fixtures/Enums/IntegerValue.php
+++ /dev/null
@@ -1,14 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Fixtures\Enums;
-
-enum IntegerValue: int
-{
-    case VALUE_2  = 2;
-    case VALUE_1  = 1;
-    case VALUE_30 = 30;
-    case VALUE_21 = 21;
-    case VALUE_3  = 3;
-}
diff --git a/tests/Fixtures/Enums/StringEnum.php b/tests/Fixtures/Enums/StringEnum.php
new file mode 100644
index 0000000..3db14fd
--- /dev/null
+++ b/tests/Fixtures/Enums/StringEnum.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Enums;
+
+enum StringEnum: string
+{
+    case ValueOneSize  = 'ONE SIZE';
+    case ValueXxs      = 'XXS';
+    case Value2        = '2';
+    case ValueM        = 'M';
+    case ValueXl_2xl   = 'XL/2XL';
+    case Value80b      = '80B';
+    case Value70b      = '70B';
+    case Value44_46    = '44-46';
+    case ValueSome     = 'some';
+    case Value1        = '1';
+    case Value30       = '30';
+    case ValueXxs_Xs   = 'XXS/XS';
+    case Value52_56    = '52-56';
+    case Value21       = '21';
+    case Value3        = '3';
+    case Value41_38_15 = '41х38х15 см';
+    case Value39_38_15 = '39х38х15 см';
+}
diff --git a/tests/Fixtures/Enums/StringValue.php b/tests/Fixtures/Enums/StringValue.php
deleted file mode 100644
index a57f794..0000000
--- a/tests/Fixtures/Enums/StringValue.php
+++ /dev/null
@@ -1,26 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Fixtures\Enums;
-
-enum StringValue: string
-{
-    case VALUE_ONE_SIZE = 'ONE SIZE';
-    case VALUE_XXS      = 'XXS';
-    case VALUE_2        = '2';
-    case VALUE_M        = 'M';
-    case VALUE_XL_2XL   = 'XL/2XL';
-    case VALUE_80B      = '80B';
-    case VALUE_70B      = '70B';
-    case VALUE_44_46    = '44-46';
-    case VALUE_SOME     = 'some';
-    case VALUE_1        = '1';
-    case VALUE_30       = '30';
-    case VALUE_XXS_XS   = 'XXS/XS';
-    case VALUE_52_56    = '52-56';
-    case VALUE_21       = '21';
-    case VALUE_3        = '3';
-    case VALUE_41_38_15 = '41х38х15 см';
-    case VALUE_39_38_15 = '39х38х15 см';
-}
diff --git a/tests/Fixtures/Enums/UnitEnum.php b/tests/Fixtures/Enums/UnitEnum.php
new file mode 100644
index 0000000..325dea4
--- /dev/null
+++ b/tests/Fixtures/Enums/UnitEnum.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Enums;
+
+enum UnitEnum
+{
+    case Xxs;
+    case Xs;
+    case S;
+    case M;
+    case L;
+    case Xl;
+    case Xxl;
+    case Xxxl;
+}
diff --git a/tests/Fixtures/Laravel/Eloquent/Model.php b/tests/Fixtures/Laravel/Eloquent/Model.php
deleted file mode 100644
index fc5b690..0000000
--- a/tests/Fixtures/Laravel/Eloquent/Model.php
+++ /dev/null
@@ -1,15 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Fixtures\Laravel\Eloquent;
-
-use Illuminate\Database\Eloquent\Model as BaseModel;
-
-class Model extends BaseModel
-{
-    protected $fillable = [
-        'id',
-        'value',
-    ];
-}
diff --git a/tests/Fixtures/Objects/LaravelModel.php b/tests/Fixtures/Objects/LaravelModel.php
new file mode 100644
index 0000000..2f09774
--- /dev/null
+++ b/tests/Fixtures/Objects/LaravelModel.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Objects;
+
+use Illuminate\Database\Eloquent\Model;
+
+/**
+ * @property int $id
+ * @property mixed $value
+ */
+class LaravelModel extends Model
+{
+    protected $fillable = [
+        'id',
+        'value',
+    ];
+}
diff --git a/tests/Fixtures/Helpers/Str.php b/tests/Fixtures/Objects/Stringable.php
similarity index 67%
rename from tests/Fixtures/Helpers/Str.php
rename to tests/Fixtures/Objects/Stringable.php
index a598cb5..9da96bf 100644
--- a/tests/Fixtures/Helpers/Str.php
+++ b/tests/Fixtures/Objects/Stringable.php
@@ -2,11 +2,11 @@
 
 declare(strict_types=1);
 
-namespace Tests\Fixtures\Helpers;
+namespace Tests\Fixtures\Objects;
 
-use Stringable;
+use Stringable as Contract;
 
-class Str implements Stringable
+class Stringable implements Contract
 {
     public function __construct(
         protected mixed $value
diff --git a/tests/Sorters/TypeTest.php b/tests/Sorters/TypeTest.php
deleted file mode 100644
index aea30e5..0000000
--- a/tests/Sorters/TypeTest.php
+++ /dev/null
@@ -1,403 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Sorters;
-
-use DragonCode\SizeSorter\SizeSorter;
-use Illuminate\Database\Eloquent\Collection;
-use Tests\Fixtures\Enums\IntegerValue;
-use Tests\Fixtures\Enums\StringValue;
-use Tests\Fixtures\Helpers\Str;
-use Tests\Fixtures\Laravel\Eloquent\Model;
-use Tests\TestCase;
-
-class TypeTest extends TestCase
-{
-    public function testString(): void
-    {
-        $items = [
-            104 => 'ONE SIZE',
-            105 => 'XXS',
-            106 => '2',
-            110 => 'M',
-            113 => 'XL/2XL',
-            116 => '80B',
-            118 => '70B',
-            130 => '44-46',
-            131 => 'some',
-            132 => '1',
-            133 => '30',
-            136 => '44/46',
-            137 => 'XXS/XS',
-            139 => '52-56',
-            149 => '21',
-            150 => '3',
-            155 => '41х38х15 см',
-            156 => '39х38х15 см',
-        ];
-
-        $this->assertSame(
-            [
-                // 1
-                105 => 'XXS',
-                137 => 'XXS/XS',
-                110 => 'M',
-                113 => 'XL/2XL',
-                // 2
-                132 => '1',
-                106 => '2',
-                150 => '3',
-                149 => '21',
-                133 => '30',
-                130 => '44-46',
-                136 => '44/46',
-                139 => '52-56',
-                // 3
-                118 => '70B',
-                116 => '80B',
-                // 4
-                156 => '39х38х15 см',
-                155 => '41х38х15 см',
-                // 5
-                104 => 'ONE SIZE',
-                131 => 'some',
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-
-    public function testStringable(): void
-    {
-        $items = [
-            104 => new Str('ONE SIZE'),
-            105 => new Str('XXS'),
-            106 => new Str('2'),
-            110 => new Str('M'),
-            113 => new Str('XL/2XL'),
-            116 => new Str('80B'),
-            118 => new Str('70B'),
-            130 => new Str('44-46'),
-            131 => new Str('some'),
-            132 => new Str('1'),
-            133 => new Str('30'),
-            136 => new Str('44/46'),
-            137 => new Str('XXS/XS'),
-            139 => new Str('52-56'),
-            149 => new Str('21'),
-            150 => new Str('3'),
-            155 => new Str('41х38х15 см'),
-            156 => new Str('39х38х15 см'),
-        ];
-
-        $this->assertSame(
-            [
-                // 1
-                105 => $items[105],
-                137 => $items[137],
-                110 => $items[110],
-                113 => $items[113],
-                // 2
-                132 => $items[132],
-                106 => $items[106],
-                150 => $items[150],
-                149 => $items[149],
-                133 => $items[133],
-                130 => $items[130],
-                136 => $items[136],
-                139 => $items[139],
-                // 3
-                118 => $items[118],
-                116 => $items[116],
-                // 4
-                156 => $items[156],
-                155 => $items[155],
-                // 5
-                104 => $items[104],
-                131 => $items[131],
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-
-    public function testInteger(): void
-    {
-        $items = [
-            106 => 2,
-            132 => 1,
-            133 => 30,
-            149 => 21,
-            150 => 3,
-        ];
-
-        $this->assertSame(
-            [
-                // 2
-                132 => 1,
-                106 => 2,
-                150 => 3,
-                149 => 21,
-                133 => 30,
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-
-    public function testFloat(): void
-    {
-        $items = [
-            106 => 2.2,
-            132 => 1.3,
-            133 => 30.5,
-            149 => 21.8,
-            150 => 3.0,
-        ];
-
-        $this->assertSame(
-            [
-                // 2
-                132 => 1.3,
-                106 => 2.2,
-                150 => 3.0,
-                149 => 21.8,
-                133 => 30.5,
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-
-    public function testEnumString(): void
-    {
-        $items = [
-            104 => StringValue::VALUE_ONE_SIZE,
-            105 => StringValue::VALUE_XXS,
-            106 => StringValue::VALUE_2,
-            110 => StringValue::VALUE_M,
-            113 => StringValue::VALUE_XL_2XL,
-            116 => StringValue::VALUE_80B,
-            118 => StringValue::VALUE_70B,
-            130 => StringValue::VALUE_44_46,
-            131 => StringValue::VALUE_SOME,
-            132 => StringValue::VALUE_1,
-            133 => StringValue::VALUE_30,
-            137 => StringValue::VALUE_XXS_XS,
-            139 => StringValue::VALUE_52_56,
-            149 => StringValue::VALUE_21,
-            150 => StringValue::VALUE_3,
-            155 => StringValue::VALUE_41_38_15,
-            156 => StringValue::VALUE_39_38_15,
-        ];
-
-        $this->assertSame(
-            [
-                // 1
-                105 => StringValue::VALUE_XXS,
-                137 => StringValue::VALUE_XXS_XS,
-                110 => StringValue::VALUE_M,
-                113 => StringValue::VALUE_XL_2XL,
-                // 2
-                132 => StringValue::VALUE_1,
-                106 => StringValue::VALUE_2,
-                150 => StringValue::VALUE_3,
-                149 => StringValue::VALUE_21,
-                133 => StringValue::VALUE_30,
-                130 => StringValue::VALUE_44_46,
-                139 => StringValue::VALUE_52_56,
-                // 3
-                118 => StringValue::VALUE_70B,
-                116 => StringValue::VALUE_80B,
-                // 4
-                156 => StringValue::VALUE_39_38_15,
-                155 => StringValue::VALUE_41_38_15,
-                // 5
-                104 => StringValue::VALUE_ONE_SIZE,
-                131 => StringValue::VALUE_SOME,
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-
-    public function testEnumInteger(): void
-    {
-        $items = [
-            106 => IntegerValue::VALUE_2,
-            132 => IntegerValue::VALUE_1,
-            133 => IntegerValue::VALUE_30,
-            149 => IntegerValue::VALUE_21,
-            150 => IntegerValue::VALUE_3,
-        ];
-
-        $this->assertSame(
-            [
-                // 2
-                132 => IntegerValue::VALUE_1,
-                106 => IntegerValue::VALUE_2,
-                150 => IntegerValue::VALUE_3,
-                149 => IntegerValue::VALUE_21,
-                133 => IntegerValue::VALUE_30,
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-
-    public function testNestedArray(): void
-    {
-        $items = [
-            104 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'ONE SIZE']]],
-            105 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'XXS']]],
-            106 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '2']]],
-            110 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'M']]],
-            113 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'XL/2XL']]],
-            116 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '80B']]],
-            118 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '70B']]],
-            130 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '44-46']]],
-            131 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'some']]],
-            132 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '1']]],
-            133 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '30']]],
-            136 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '44/46']]],
-            137 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'XXS/XS']]],
-            139 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '52-56']]],
-            149 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '21']]],
-            150 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '3']]],
-            155 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '41х38х15 см']]],
-            156 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '39х38х15 см']]],
-        ];
-
-        $this->assertSame(
-            [
-                // 1
-                105 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'XXS']]],
-                137 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'XXS/XS']]],
-                110 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'M']]],
-                113 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'XL/2XL']]],
-                // 2
-                132 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '1']]],
-                106 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '2']]],
-                150 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '3']]],
-                149 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '21']]],
-                133 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '30']]],
-                130 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '44-46']]],
-                136 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '44/46']]],
-                139 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '52-56']]],
-                // 3
-                118 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '70B']]],
-                116 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '80B']]],
-                // 4
-                156 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '39х38х15 см']]],
-                155 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => '41х38х15 см']]],
-                // 5
-                104 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'ONE SIZE']]],
-                131 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'some']]],
-            ],
-            SizeSorter::items($items)->column('bar.some.nested')->sort()->toArray()
-        );
-    }
-
-    public function testLaravelModels(): void
-    {
-        $items = Collection::make([
-            104 => 'ONE SIZE',
-            105 => 'XXS',
-            106 => '2',
-            110 => 'M',
-            113 => 'XL/2XL',
-            116 => '80B',
-            118 => '70B',
-            130 => '44-46',
-            131 => 'some',
-            132 => '1',
-            133 => '30',
-            136 => '44/46',
-            137 => 'XXS/XS',
-            139 => '52-56',
-            149 => '21',
-            150 => '3',
-            155 => '41х38х15 см',
-            156 => '39х38х15 см',
-        ])->map(function (string $value, int $id) {
-            return new Model(compact('id', 'value'));
-        });
-
-        $this->assertSame(
-            [
-                // 1
-                105 => 'XXS',
-                137 => 'XXS/XS',
-                110 => 'M',
-                113 => 'XL/2XL',
-                // 2
-                132 => '1',
-                106 => '2',
-                150 => '3',
-                149 => '21',
-                133 => '30',
-                130 => '44-46',
-                136 => '44/46',
-                139 => '52-56',
-                // 3
-                118 => '70B',
-                116 => '80B',
-                // 4
-                156 => '39х38х15 см',
-                155 => '41х38х15 см',
-                // 5
-                104 => 'ONE SIZE',
-                131 => 'some',
-            ],
-            SizeSorter::items($items)->sort()->pluck('value', 'id')->toArray()
-        );
-    }
-
-    public function testCollection(): void
-    {
-        $items = collect([
-            104 => 'ONE SIZE',
-            105 => 'XXS',
-            106 => '2',
-            110 => 'M',
-            113 => 'XL/2XL',
-            116 => '80B',
-            118 => '70B',
-            130 => '44-46',
-            131 => 'some',
-            132 => '1',
-            133 => '30',
-            136 => '44/46',
-            137 => 'XXS/XS',
-            139 => '52-56',
-            149 => '21',
-            150 => '3',
-            155 => '41х38х15 см',
-            156 => '39х38х15 см',
-        ]);
-
-        $this->assertSame(
-            [
-                // 1
-                105 => 'XXS',
-                137 => 'XXS/XS',
-                110 => 'M',
-                113 => 'XL/2XL',
-                // 2
-                132 => '1',
-                106 => '2',
-                150 => '3',
-                149 => '21',
-                133 => '30',
-                130 => '44-46',
-                136 => '44/46',
-                139 => '52-56',
-                // 3
-                118 => '70B',
-                116 => '80B',
-                // 4
-                156 => '39х38х15 см',
-                155 => '41х38х15 см',
-                // 5
-                104 => 'ONE SIZE',
-                131 => 'some',
-            ],
-            SizeSorter::items($items)->sort()->toArray()
-        );
-    }
-}
diff --git a/tests/TestCase.php b/tests/TestCase.php
index 0358aa8..4f480f0 100644
--- a/tests/TestCase.php
+++ b/tests/TestCase.php
@@ -66,5 +66,8 @@ abstract class TestCase extends BaseTestCase
         154 => '40х38х15 см',
         155 => '41х38х15 см',
         156 => '39х38х15 см',
+        157 => '3xl',
+        158 => '2xl',
+        159 => '2xs',
     ];
 }
diff --git a/tests/Unit/Detectors/BraTest.php b/tests/Unit/Detectors/BraTest.php
new file mode 100644
index 0000000..6cf6145
--- /dev/null
+++ b/tests/Unit/Detectors/BraTest.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Detectors;
+
+use DragonCode\SizeSorter\Groups\BraGroup;
+use DragonCode\SizeSorter\Groups\Group as SizeDetector;
+
+class BraTest extends Detector
+{
+    protected SizeDetector|string $detector = BraGroup::class;
+
+    public static function valuesData(): array
+    {
+        return [
+            ['70B', true],
+            ['70C', true],
+            ['75A', true],
+            ['75B', true],
+            ['75C', true],
+            ['80B', true],
+
+            ['XXS'],
+            ['XXS'],
+            ['XXS/XS'],
+            ['XXS-XS'],
+            ['1'],
+            ['2'],
+            [26],
+            [28],
+            ['44-46'],
+            ['44/46'],
+            ['52-56'],
+            ['40х38х15 см'],
+            ['40х38х19 sm'],
+            ['ONE SIZE'],
+            ['some'],
+        ];
+    }
+}
diff --git a/tests/Unit/Detectors/ClothesAndShoesTest.php b/tests/Unit/Detectors/ClothesAndShoesTest.php
new file mode 100644
index 0000000..fb47d0a
--- /dev/null
+++ b/tests/Unit/Detectors/ClothesAndShoesTest.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Detectors;
+
+use DragonCode\SizeSorter\Groups\ClothesAndShoesGroup;
+use DragonCode\SizeSorter\Groups\Group as SizeDetector;
+
+class ClothesAndShoesTest extends Detector
+{
+    protected SizeDetector|string $detector = ClothesAndShoesGroup::class;
+
+    public static function valuesData(): array
+    {
+        return [
+            ['1', true],
+            ['2', true],
+            ['3', true],
+            ['21', true],
+            [26, true],
+            [28, true],
+            ['30', true],
+            ['32', true],
+            ['34', true],
+            ['36', true],
+            [37, true],
+            [38, true],
+            ['39', true],
+            ['40', true],
+            ['44-46', true],
+            ['44/46', true],
+            ['52-56', true],
+            ['54', true],
+            ['90/94', true],
+            ['94-98', true],
+            ['98-102', true],
+            ['102-104', true],
+            ['102-106', true],
+            ['102/106', true],
+            ['106', true],
+            ['110-112', true],
+            ['110-114', true],
+
+            ['XXS'],
+            ['XXS'],
+            ['XXS/XS'],
+            ['XXS-XS'],
+            ['XS'],
+            ['XS/S'],
+            ['S'],
+            ['S/M'],
+            ['M'],
+            ['M/L'],
+            ['L'],
+            ['L/XL'],
+            ['XL'],
+            ['XL/2XL'],
+            ['XXL'],
+            ['70B'],
+            ['70C'],
+            ['75A'],
+            ['75B'],
+            ['75C'],
+            ['80B'],
+            ['39х38х15 см'],
+            ['40х37х19 см'],
+            ['40х37х20 см'],
+            ['40х38х15 см'],
+            ['40х38х19 sm'],
+            ['40х38х19 см'],
+            ['41х38х15 см'],
+            ['ONE SIZE'],
+            ['some'],
+        ];
+    }
+}
diff --git a/tests/Unit/Detectors/Detector.php b/tests/Unit/Detectors/Detector.php
new file mode 100644
index 0000000..d57eab6
--- /dev/null
+++ b/tests/Unit/Detectors/Detector.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Detectors;
+
+use DragonCode\SizeSorter\Groups\Group as SizeDetector;
+use DragonCode\SizeSorter\Normalizers\KeyNormalizer;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Tests\TestCase;
+
+abstract class Detector extends TestCase
+{
+    protected SizeDetector|string $detector;
+
+    #[DataProvider('valuesData')]
+    public function testValues(int|string $value, bool $expected = false): void
+    {
+        $actual = $this->detector::detect(
+            $this->normalize($value)
+        );
+
+        $this->assertSame($expected, $actual);
+    }
+
+    abstract public static function valuesData(): array;
+
+    protected function normalize(int|string $value): string
+    {
+        return KeyNormalizer::normalize($value);
+    }
+}
diff --git a/tests/Unit/Detectors/LetterClothingTest.php b/tests/Unit/Detectors/LetterClothingTest.php
new file mode 100644
index 0000000..4bdcbca
--- /dev/null
+++ b/tests/Unit/Detectors/LetterClothingTest.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Detectors;
+
+use DragonCode\SizeSorter\Groups\Group as SizeDetector;
+use DragonCode\SizeSorter\Groups\LetterClothingGroup;
+
+class LetterClothingTest extends Detector
+{
+    protected SizeDetector|string $detector = LetterClothingGroup::class;
+
+    public static function valuesData(): array
+    {
+        return [
+            ['XXS', true],
+            ['XXS', true],
+            ['XXS/XS', true],
+            ['XXS-XS', true],
+            ['XS', true],
+            ['XS/S', true],
+            ['S', true],
+            ['S/M', true],
+            ['M', true],
+            ['M/L', true],
+            ['L', true],
+            ['L/XL', true],
+            ['XL', true],
+            ['XL/2XL', true],
+            ['XXL', true],
+
+            ['1'],
+            ['2'],
+            ['3'],
+            ['21'],
+            [26],
+            [28],
+            ['30'],
+            ['32'],
+            ['34'],
+            ['36'],
+            [37],
+            [38],
+            ['39'],
+            ['40'],
+            ['44-46'],
+            ['44/46'],
+            ['52-56'],
+            ['54'],
+            ['90/94'],
+            ['94-98'],
+            ['98-102'],
+            ['102-104'],
+            ['102-106'],
+            ['102/106'],
+            ['106'],
+            ['110-112'],
+            ['110-114'],
+            ['70B'],
+            ['70C'],
+            ['75A'],
+            ['75B'],
+            ['75C'],
+            ['80B'],
+            ['39х38х15 см'],
+            ['40х37х19 см'],
+            ['40х37х20 см'],
+            ['40х38х15 см'],
+            ['40х38х19 sm'],
+            ['40х38х19 см'],
+            ['41х38х15 см'],
+            ['ONE SIZE'],
+            ['some'],
+        ];
+    }
+}
diff --git a/tests/Unit/Detectors/OtherTest.php b/tests/Unit/Detectors/OtherTest.php
new file mode 100644
index 0000000..580605e
--- /dev/null
+++ b/tests/Unit/Detectors/OtherTest.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Detectors;
+
+use DragonCode\SizeSorter\Groups\Group as SizeDetector;
+use DragonCode\SizeSorter\Groups\OtherGroup;
+
+class OtherTest extends Detector
+{
+    protected SizeDetector|string $detector = OtherGroup::class;
+
+    public static function valuesData(): array
+    {
+        return [
+            ['XXS', true],
+            ['XXS', true],
+            ['XXS/XS', true],
+            ['XXS-XS', true],
+            ['XS', true],
+            ['XS/S', true],
+            ['S', true],
+            ['S/M', true],
+            ['M', true],
+            ['M/L', true],
+            ['L', true],
+            ['L/XL', true],
+            ['XL', true],
+            ['XL/2XL', true],
+            ['XXL', true],
+            ['1', true],
+            ['2', true],
+            ['3', true],
+            ['21', true],
+            [26, true],
+            [28, true],
+            ['30', true],
+            ['32', true],
+            ['34', true],
+            ['36', true],
+            [37, true],
+            [38, true],
+            ['39', true],
+            ['40', true],
+            ['44-46', true],
+            ['44/46', true],
+            ['52-56', true],
+            ['54', true],
+            ['90/94', true],
+            ['94-98', true],
+            ['98-102', true],
+            ['102-104', true],
+            ['102-106', true],
+            ['102/106', true],
+            ['106', true],
+            ['110-112', true],
+            ['110-114', true],
+            ['70B', true],
+            ['70C', true],
+            ['75A', true],
+            ['75B', true],
+            ['75C', true],
+            ['80B', true],
+            ['39х38х15 см', true],
+            ['40х37х19 см', true],
+            ['40х37х20 см', true],
+            ['40х38х15 см', true],
+            ['40х38х19 sm', true],
+            ['40х38х19 см', true],
+            ['41х38х15 см', true],
+            ['ONE SIZE', true],
+            ['some', true],
+        ];
+    }
+}
diff --git a/tests/Unit/Detectors/OverallDimensionsTest.php b/tests/Unit/Detectors/OverallDimensionsTest.php
new file mode 100644
index 0000000..2da60ae
--- /dev/null
+++ b/tests/Unit/Detectors/OverallDimensionsTest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Detectors;
+
+use DragonCode\SizeSorter\Groups\Group as SizeDetector;
+use DragonCode\SizeSorter\Groups\OverallDimensionsGroup;
+
+class OverallDimensionsTest extends Detector
+{
+    protected SizeDetector|string $detector = OverallDimensionsGroup::class;
+
+    public static function valuesData(): array
+    {
+        return [
+            ['39х38х15 см', true],
+            ['40х37х19 см', true],
+            ['40х37х20 см', true],
+            ['40х38х15 см', true],
+            ['40х38х19 sm', true],
+            ['40х38х19 см', true],
+            ['41х38х15 см', true],
+
+            ['1a'],
+            ['1b'],
+            ['1c'],
+            ['XXS'],
+            ['XXS'],
+            ['XXS/XS'],
+            ['XXS-XS'],
+            ['XS'],
+            ['XS/S'],
+            ['S'],
+            ['S/M'],
+            ['M'],
+            ['M/L'],
+            ['L'],
+            ['L/XL'],
+            ['XL'],
+            ['XL/2XL'],
+            ['XXL'],
+            ['1'],
+            ['2'],
+            ['3'],
+            ['21'],
+            [26],
+            [28],
+            ['30'],
+            ['32'],
+            ['34'],
+            ['36'],
+            [37],
+            [38],
+            ['39'],
+            ['40'],
+            ['44-46'],
+            ['44/46'],
+            ['52-56'],
+            ['54'],
+            ['90/94'],
+            ['94-98'],
+            ['98-102'],
+            ['102-104'],
+            ['102-106'],
+            ['102/106'],
+            ['106'],
+            ['110-112'],
+            ['110-114'],
+            ['70B'],
+            ['70C'],
+            ['75A'],
+            ['75B'],
+            ['75C'],
+            ['80B'],
+            ['ONE SIZE'],
+            ['some'],
+        ];
+    }
+}
diff --git a/tests/Unit/Normalizers/KeyTest.php b/tests/Unit/Normalizers/KeyTest.php
new file mode 100644
index 0000000..3bd3a9a
--- /dev/null
+++ b/tests/Unit/Normalizers/KeyTest.php
@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Normalizers;
+
+use DragonCode\SizeSorter\Normalizers\KeyNormalizer;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Tests\TestCase;
+
+class KeyTest extends TestCase
+{
+    #[DataProvider('valuesData')]
+    public function testValue(string $expected, mixed $input): void
+    {
+        $this->assertSame($expected, KeyNormalizer::normalize($input));
+    }
+
+    public static function valuesData(): array
+    {
+        return [
+            [
+                'expected' => 'foo',
+                'input'    => 'foo',
+            ],
+            [
+                'expected' => 'foo',
+                'input'    => 'FOO',
+            ],
+            [
+                'expected' => 'foo',
+                'input'    => 'FoO',
+            ],
+            [
+                'expected' => '123',
+                'input'    => 123,
+            ],
+            [
+                'expected' => '123.45',
+                'input'    => 123.45,
+            ],
+            [
+                'expected' => 'true',
+                'input'    => true,
+            ],
+            [
+                'expected' => 'false',
+                'input'    => false,
+            ],
+            [
+                'expected' => 'null',
+                'input'    => null,
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo-bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo_bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo/bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo\\bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo+bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo=bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo(bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo)bar',
+            ],
+            [
+                'expected' => 'foo_bar',
+                'input'    => 'foo*bar',
+            ],
+            [
+                'expected' => 'foo_bar_123',
+                'input'    => 'foo bar 123',
+            ],
+            [
+                'expected' => '40x38x19_sm',
+                'input'    => '40х38х19 sm',
+            ],
+            [
+                'expected' => '40x38x15_sm',
+                'input'    => '40х38х15 см',
+            ],
+        ];
+    }
+}
diff --git a/tests/Sorters/SortTest.php b/tests/Unit/SorterTest.php
similarity index 72%
rename from tests/Sorters/SortTest.php
rename to tests/Unit/SorterTest.php
index 02fb37f..91d1f26 100644
--- a/tests/Sorters/SortTest.php
+++ b/tests/Unit/SorterTest.php
@@ -2,107 +2,49 @@
 
 declare(strict_types=1);
 
-namespace Tests\Sorters;
+namespace Tests\Unit;
 
-use DragonCode\SizeSorter\Enum\Group;
+use DragonCode\SizeSorter\Enums\GroupEnum;
 use DragonCode\SizeSorter\SizeSorter;
 use PHPUnit\Framework\Attributes\DataProvider;
 use Tests\TestCase;
 
-class SortTest extends TestCase
+class SorterTest extends TestCase
 {
-    #[DataProvider('sorterData')]
-    public function testArray(?array $order, array $expected): void
+    #[DataProvider('sortData')]
+    public function testDefault(array $expected, ?array $groups = null): void
     {
         $actual = SizeSorter::items($this->values)
-            ->orderBy($order)
+            ->orderBy($groups)
             ->sort()
-            ->toArray();
+            ->all();
 
         $this->assertSame($expected, $actual);
     }
 
-    #[DataProvider('sorterData')]
-    public function testObjects(?array $order, array $expected): void
-    {
-        $items = collect($this->values)->map(fn (mixed $value, int $key) => (object) [
-            'id'     => $key,
-            'value'  => $value,
-            'active' => true,
-        ]);
-
-        $actual = SizeSorter::items($items)
-            ->orderBy($order)
-            ->sort()
-            ->pluck('value', 'id')
-            ->toArray();
-
-        $this->assertSame($expected, $actual);
-    }
-
-    #[DataProvider('sorterData')]
-    public function testCustomColumn(?array $order, array $expected): void
-    {
-        $items = collect($this->values)->map(fn (mixed $value, int $key) => (object) [
-            'id'   => $key,
-            'some' => $value,
-        ]);
-
-        $actual = SizeSorter::items($items)
-            ->orderBy($order)
-            ->column('some')
-            ->sort()
-            ->pluck('some', 'id')
-            ->toArray();
-
-        $this->assertSame($expected, $actual);
-    }
-
-    #[DataProvider('sorterData')]
-    public function testWithSaveKeys(?array $order, array $expected): void
-    {
-        $values = [
-            840 => 'XL',
-            506 => 'XS',
-        ];
-
-        $expected = [
-            506 => 'XS',
-            840 => 'XL',
-        ];
-
-        $actual = SizeSorter::items($values)
-            ->orderBy($order)
-            ->sort()
-            ->toArray();
-
-        $this->assertSame($expected, $actual);
-    }
-
-    public static function sorterData(): array
+    public static function sortData(): array
     {
         return [
-            'simple' => [
-                'order' => null,
-
+            'default' => [
                 'expected' => [
-                    // 1
-                    105 => 'XXS',
-                    138 => 'XXS',
-                    137 => 'XXS/XS',
-                    122 => 'XXS-XS',
                     108 => 'XS',
-                    114 => 'XS/S',
                     109 => 'S',
+                    114 => 'XS/S',
                     127 => 'S/M',
+                    105 => 'XXS',
+                    122 => 'XXS-XS',
+                    137 => 'XXS/XS',
+                    138 => 'XXS',
+                    159 => '2xs',
                     110 => 'M',
                     115 => 'M/L',
+                    103 => 'XL',
                     111 => 'L',
                     112 => 'L/XL',
-                    103 => 'XL',
                     113 => 'XL/2XL',
                     100 => 'XXL',
-                    // 2
+                    158 => '2xl',
+                    157 => '3xl',
                     132 => '1',
                     106 => '2',
                     150 => '3',
@@ -130,56 +72,57 @@ public static function sorterData(): array
                     143 => '106',
                     145 => '110-112',
                     144 => '110-114',
-                    // 3
+                    116 => '80B',
+                    117 => '75C',
                     118 => '70B',
-                    129 => '70C',
                     119 => '75A',
                     120 => '75B',
-                    117 => '75C',
-                    116 => '80B',
-                    // 4
-                    156 => '39х38х15 см',
+                    129 => '70C',
+                    128 => '40х38х19 см',
+                    151 => '40х38х19 sm',
                     152 => '40х37х19 см',
                     153 => '40х37х20 см',
                     154 => '40х38х15 см',
-                    151 => '40х38х19 sm',
-                    128 => '40х38х19 см',
                     155 => '41х38х15 см',
-                    // 5
+                    156 => '39х38х15 см',
                     104 => 'ONE SIZE',
                     131 => 'some',
                 ],
             ],
 
-            'full groups' => [
-                'order' => [
-                    Group::BraSize,
-                    Group::OtherSizes,
-                    Group::OverallDimensions,
-                    Group::ClothesAndShoes,
-                    Group::LetterClothingSize,
+            'partial groups' => [
+                'groups' => [
+                    GroupEnum::OtherSizes,
+                    GroupEnum::BraSize,
                 ],
 
                 'expected' => [
-                    // 3
+                    104 => 'ONE SIZE',
+                    131 => 'some',
+                    116 => '80B',
+                    117 => '75C',
                     118 => '70B',
-                    129 => '70C',
                     119 => '75A',
                     120 => '75B',
-                    117 => '75C',
-                    116 => '80B',
-                    // 5
-                    104 => 'ONE SIZE',
-                    131 => 'some',
-                    // 4
-                    156 => '39х38х15 см',
-                    152 => '40х37х19 см',
-                    153 => '40х37х20 см',
-                    154 => '40х38х15 см',
-                    151 => '40х38х19 sm',
-                    128 => '40х38х19 см',
-                    155 => '41х38х15 см',
-                    // 2
+                    129 => '70C',
+                    108 => 'XS',
+                    109 => 'S',
+                    114 => 'XS/S',
+                    127 => 'S/M',
+                    105 => 'XXS',
+                    122 => 'XXS-XS',
+                    137 => 'XXS/XS',
+                    138 => 'XXS',
+                    159 => '2xs',
+                    110 => 'M',
+                    115 => 'M/L',
+                    103 => 'XL',
+                    111 => 'L',
+                    112 => 'L/XL',
+                    113 => 'XL/2XL',
+                    100 => 'XXL',
+                    158 => '2xl',
+                    157 => '3xl',
                     132 => '1',
                     106 => '2',
                     150 => '3',
@@ -207,59 +150,59 @@ public static function sorterData(): array
                     143 => '106',
                     145 => '110-112',
                     144 => '110-114',
-                    // 1
-                    105 => 'XXS',
-                    138 => 'XXS',
-                    137 => 'XXS/XS',
-                    122 => 'XXS-XS',
-                    108 => 'XS',
-                    114 => 'XS/S',
-                    109 => 'S',
-                    127 => 'S/M',
-                    110 => 'M',
-                    115 => 'M/L',
-                    111 => 'L',
-                    112 => 'L/XL',
-                    103 => 'XL',
-                    113 => 'XL/2XL',
-                    100 => 'XXL',
+                    128 => '40х38х19 см',
+                    151 => '40х38х19 sm',
+                    152 => '40х37х19 см',
+                    153 => '40х37х20 см',
+                    154 => '40х38х15 см',
+                    155 => '41х38х15 см',
+                    156 => '39х38х15 см',
                 ],
             ],
 
-            'partial groups' => [
-                'order' => [
-                    Group::BraSize,
-                    Group::OtherSizes,
+            'full groups' => [
+                'groups' => [
+                    GroupEnum::OtherSizes,
+                    GroupEnum::BraSize,
+                    GroupEnum::OverallDimensions,
+                    GroupEnum::LetterClothingSize,
+                    GroupEnum::ClothesAndShoes,
                 ],
 
                 'expected' => [
-                    // 3
+                    104 => 'ONE SIZE',
+                    131 => 'some',
+                    116 => '80B',
+                    117 => '75C',
                     118 => '70B',
-                    129 => '70C',
                     119 => '75A',
                     120 => '75B',
-                    117 => '75C',
-                    116 => '80B',
-                    // 5
-                    104 => 'ONE SIZE',
-                    131 => 'some',
-                    // 1
-                    105 => 'XXS',
-                    138 => 'XXS',
-                    137 => 'XXS/XS',
-                    122 => 'XXS-XS',
+                    129 => '70C',
+                    128 => '40х38х19 см',
+                    151 => '40х38х19 sm',
+                    152 => '40х37х19 см',
+                    153 => '40х37х20 см',
+                    154 => '40х38х15 см',
+                    155 => '41х38х15 см',
+                    156 => '39х38х15 см',
                     108 => 'XS',
-                    114 => 'XS/S',
                     109 => 'S',
+                    114 => 'XS/S',
                     127 => 'S/M',
+                    105 => 'XXS',
+                    122 => 'XXS-XS',
+                    137 => 'XXS/XS',
+                    138 => 'XXS',
+                    159 => '2xs',
                     110 => 'M',
                     115 => 'M/L',
+                    103 => 'XL',
                     111 => 'L',
                     112 => 'L/XL',
-                    103 => 'XL',
                     113 => 'XL/2XL',
                     100 => 'XXL',
-                    // 2
+                    158 => '2xl',
+                    157 => '3xl',
                     132 => '1',
                     106 => '2',
                     150 => '3',
@@ -287,14 +230,6 @@ public static function sorterData(): array
                     143 => '106',
                     145 => '110-112',
                     144 => '110-114',
-                    // 4
-                    156 => '39х38х15 см',
-                    152 => '40х37х19 см',
-                    153 => '40х37х20 см',
-                    154 => '40х38х15 см',
-                    151 => '40х38х19 sm',
-                    128 => '40х38х19 см',
-                    155 => '41х38х15 см',
                 ],
             ],
         ];
diff --git a/tests/Unit/Support/GroupOrder/GetTest.php b/tests/Unit/Support/GroupOrder/GetTest.php
new file mode 100644
index 0000000..43dca32
--- /dev/null
+++ b/tests/Unit/Support/GroupOrder/GetTest.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Support\GroupOrder;
+
+use DragonCode\SizeSorter\Enums\GroupEnum;
+use DragonCode\SizeSorter\Support\GroupOrder;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Tests\TestCase;
+
+class GetTest extends TestCase
+{
+    #[DataProvider('groupsData')]
+    public function testFill(array $expected, ?array $input): void
+    {
+        $this->assertSame($expected, GroupOrder::get($input));
+    }
+
+    public static function groupsData(): array
+    {
+        return [
+            'empty' => [
+                'expected' => GroupEnum::sorted(),
+                'input'    => null,
+            ],
+
+            'full' => [
+                'expected' => GroupEnum::sorted(),
+                'input'    => GroupEnum::sorted(),
+            ],
+
+            'partial' => [
+                'expected' => [
+                    GroupEnum::OtherSizes,
+                    GroupEnum::BraSize,
+                    GroupEnum::LetterClothingSize,
+                    GroupEnum::ClothesAndShoes,
+                    GroupEnum::OverallDimensions,
+                ],
+
+                'input' => [
+                    GroupEnum::OtherSizes,
+                    GroupEnum::BraSize,
+                ],
+            ],
+
+            'full random' => [
+                'expected' => [
+                    GroupEnum::OtherSizes,
+                    GroupEnum::BraSize,
+                    GroupEnum::ClothesAndShoes,
+                    GroupEnum::OverallDimensions,
+                    GroupEnum::LetterClothingSize,
+                ],
+
+                'input' => [
+                    GroupEnum::OtherSizes,
+                    GroupEnum::BraSize,
+                    GroupEnum::ClothesAndShoes,
+                    GroupEnum::OverallDimensions,
+                    GroupEnum::LetterClothingSize,
+                ],
+            ],
+        ];
+    }
+}
diff --git a/tests/Unit/Support/Map/ApplyTest.php b/tests/Unit/Support/Map/ApplyTest.php
new file mode 100644
index 0000000..55a93f7
--- /dev/null
+++ b/tests/Unit/Support/Map/ApplyTest.php
@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Support\Map;
+
+use DragonCode\SizeSorter\Support\Map;
+use Illuminate\Support\Collection;
+use LengthException;
+use Tests\Fixtures\Objects\LaravelModel;
+use Tests\Fixtures\Objects\Stringable;
+use Tests\TestCase;
+
+class ApplyTest extends TestCase
+{
+    protected array $map = [
+        'baz' => 2,
+        'foo' => 0,
+        'bar' => 1,
+    ];
+
+    public function testString(): void
+    {
+        $input = collect([
+            'foo',
+            'bar',
+            'baz',
+        ]);
+
+        $this->assertSame([
+            2 => 'baz',
+            0 => 'foo',
+            1 => 'bar',
+        ], $this->applyMap($input));
+    }
+
+    public function testStringable(): void
+    {
+        $obj1 = new Stringable('foo');
+        $obj2 = new Stringable('bar');
+        $obj3 = new Stringable('baz');
+
+        $input = collect([
+            $obj1,
+            $obj2,
+            $obj3,
+        ]);
+
+        $this->assertSame([
+            2 => $obj3,
+            0 => $obj1,
+            1 => $obj2,
+        ], $this->applyMap($input));
+    }
+
+    public function testNumber(): void
+    {
+        $input = collect([
+            123,
+            234,
+            345,
+        ]);
+
+        $this->assertSame([
+            2 => 345,
+            0 => 123,
+            1 => 234,
+        ], $this->applyMap($input));
+    }
+
+    public function testObject(): void
+    {
+        $obj1 = (object) ['value' => 'foo'];
+        $obj2 = (object) ['value' => 'bar'];
+        $obj3 = (object) ['value' => 'baz'];
+
+        $input = collect([
+            $obj1,
+            $obj2,
+            $obj3,
+        ]);
+
+        $this->assertSame([
+            2 => $obj3,
+            0 => $obj1,
+            1 => $obj2,
+        ], $this->applyMap($input));
+    }
+
+    public function testLaravelModel(): void
+    {
+        $obj1 = new LaravelModel(['id' => 1, 'value' => 'foo']);
+        $obj2 = new LaravelModel(['id' => 2, 'value' => 'bar']);
+        $obj3 = new LaravelModel(['id' => 3, 'value' => 'baz']);
+
+        $input = collect([
+            $obj1,
+            $obj2,
+            $obj3,
+        ]);
+
+        $this->assertSame([
+            2 => $obj3,
+            0 => $obj1,
+            1 => $obj2,
+        ], $this->applyMap($input));
+    }
+
+    public function testMissingCount(): void
+    {
+        $this->expectException(LengthException::class);
+        $this->expectExceptionMessage('The count of items in the map (2) and collection (3) should be the same.');
+
+        Map::apply(
+            collect([1, 2, 3]),
+            collect([1, 2])
+        );
+    }
+
+    protected function applyMap(Collection $items): array
+    {
+        return Map::apply($items, collect($this->map))->all();
+    }
+}
diff --git a/tests/Unit/Support/Map/MakeTest.php b/tests/Unit/Support/Map/MakeTest.php
new file mode 100644
index 0000000..01a3896
--- /dev/null
+++ b/tests/Unit/Support/Map/MakeTest.php
@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Support\Map;
+
+use Closure;
+use DragonCode\SizeSorter\Groups\Group;
+use DragonCode\SizeSorter\Support\Map;
+use Illuminate\Support\Collection;
+use Tests\Fixtures\Objects\LaravelModel;
+use Tests\Fixtures\Objects\Stringable;
+use Tests\TestCase;
+
+class MakeTest extends TestCase
+{
+    protected array $map = [
+        'foo' => 0,
+        'bar' => 1,
+        'baz' => 2,
+    ];
+
+    public function testString(): void
+    {
+        $input = collect([
+            'foo',
+            'bar',
+            'baz',
+        ]);
+
+        $this->assertSame([
+            $this->prefix('foo', '5::0') => 0,
+            $this->prefix('bar', '5::1') => 1,
+            $this->prefix('baz', '5::2') => 2,
+        ], $this->makeMap($input));
+    }
+
+    public function testLongString(): void
+    {
+        $input = collect([
+            'foo QWE',
+            'bar/RTY',
+            'baz-asd',
+        ]);
+
+        $this->assertSame([
+            $this->prefix('foo_qwe', '5::0') => 0,
+            $this->prefix('bar_rty', '5::1') => 1,
+            $this->prefix('baz_asd', '5::2') => 2,
+        ], $this->makeMap($input));
+    }
+
+    public function testDuplicates(): void
+    {
+        $input = collect([
+            'foo',
+            'bar',
+            'baz',
+            'foo',
+        ]);
+
+        $this->assertSame([
+            $this->prefix('foo', '5::0') => 0,
+            $this->prefix('bar', '5::1') => 1,
+            $this->prefix('baz', '5::2') => 2,
+            $this->prefix('foo', '5::3') => 3,
+        ], $this->makeMap($input));
+    }
+
+    public function testStringable(): void
+    {
+        $input = collect([
+            new Stringable('foo'),
+            new Stringable('bar'),
+            new Stringable('baz'),
+        ]);
+
+        $this->assertSame([
+            $this->prefix('foo', '5::0') => 0,
+            $this->prefix('bar', '5::1') => 1,
+            $this->prefix('baz', '5::2') => 2,
+        ], $this->makeMap($input));
+    }
+
+    public function testNumber(): void
+    {
+        $input = collect([
+            123,
+            234,
+            345,
+        ]);
+
+        $this->assertSame([
+            $this->prefix('123', '2::0') => 0,
+            $this->prefix('234', '2::1') => 1,
+            $this->prefix('345', '2::2') => 2,
+        ], $this->makeMap($input));
+    }
+
+    public function testObject(): void
+    {
+        $column = static fn (object $item) => $item->value;
+
+        $input = collect([
+            (object) ['value' => 'foo'],
+            (object) ['value' => 'bar'],
+            (object) ['value' => 'baz'],
+        ]);
+
+        $this->assertSame([
+            $this->prefix('foo', '5::0') => 0,
+            $this->prefix('bar', '5::1') => 1,
+            $this->prefix('baz', '5::2') => 2,
+        ], $this->makeMap($input, $column));
+    }
+
+    public function testLaravelModel(): void
+    {
+        $column = static fn (object $item) => $item->value;
+
+        $input = collect([
+            new LaravelModel(['id' => 1, 'value' => 'foo']),
+            new LaravelModel(['id' => 2, 'value' => 'bar']),
+            new LaravelModel(['id' => 3, 'value' => 'baz']),
+        ]);
+
+        $this->assertSame([
+            $this->prefix('foo', '5::0') => 0,
+            $this->prefix('bar', '5::1') => 1,
+            $this->prefix('baz', '5::2') => 2,
+        ], $this->makeMap($input, $column));
+    }
+
+    protected function makeMap(Collection $items, ?Closure $column = null): array
+    {
+        $column ??= static fn (int|string|Stringable $value) => $value;
+
+        return Map::make($items, $column)->all();
+    }
+
+    protected function prefix(string $key, int|string $prefix): string
+    {
+        return $prefix . Group::Delimiter . $key;
+    }
+}
diff --git a/tests/Unit/Support/Resolve/ValueTest.php b/tests/Unit/Support/Resolve/ValueTest.php
new file mode 100644
index 0000000..31d95db
--- /dev/null
+++ b/tests/Unit/Support/Resolve/ValueTest.php
@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Support\Resolve;
+
+use DragonCode\SizeSorter\Support\Resolve;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Tests\Fixtures\Enums\IntegerEnum;
+use Tests\Fixtures\Enums\StringEnum;
+use Tests\Fixtures\Enums\UnitEnum;
+use Tests\Fixtures\Objects\Stringable;
+use Tests\TestCase;
+
+class ValueTest extends TestCase
+{
+    #[DataProvider('valuesData')]
+    public function testValue(mixed $expected, mixed $input): void
+    {
+        $this->assertSame($expected, Resolve::value($input, 'value'));
+    }
+
+    public static function valuesData(): array
+    {
+        return [
+            'string' => [
+                'expected' => 'foo',
+                'input'    => 'foo',
+            ],
+
+            'integer' => [
+                'expected' => 123,
+                'input'    => 123,
+            ],
+
+            'float' => [
+                'expected' => 123.45,
+                'input'    => 123.45,
+            ],
+
+            'bool true' => [
+                'expected' => true,
+                'input'    => true,
+            ],
+
+            'bool false' => [
+                'expected' => false,
+                'input'    => false,
+            ],
+
+            'integer enum' => [
+                'expected' => 30,
+                'input'    => IntegerEnum::Value30,
+            ],
+
+            'string enum' => [
+                'expected' => '39х38х15 см',
+                'input'    => StringEnum::Value39_38_15,
+            ],
+
+            'unit enum' => [
+                'expected' => 'Xxxl',
+                'input'    => UnitEnum::Xxxl,
+            ],
+
+            'array' => [
+                'expected' => 'some',
+                'input'    => ['value' => 'some'],
+            ],
+
+            'object' => [
+                'expected' => 'some',
+                'input'    => (object) ['value' => 'some'],
+            ],
+
+            'stringable' => [
+                'expected' => 'some',
+                'input'    => new Stringable('some'),
+            ],
+        ];
+    }
+}
diff --git a/tests/Unit/Support/Validator/EnsureTest.php b/tests/Unit/Support/Validator/EnsureTest.php
new file mode 100644
index 0000000..3bd4dc4
--- /dev/null
+++ b/tests/Unit/Support/Validator/EnsureTest.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Support\Validator;
+
+use DragonCode\SizeSorter\Support\Validator;
+use stdClass;
+use Tests\TestCase;
+use UnexpectedValueException;
+
+class EnsureTest extends TestCase
+{
+    public function testSuccess(): void
+    {
+        Validator::ensure([
+            (object) ['value' => 'foo'],
+            (object) ['value' => 'bar'],
+        ], stdClass::class);
+
+        $this->assertTrue(true);
+    }
+
+    public function testWrong(): void
+    {
+        $this->expectException(UnexpectedValueException::class);
+
+        $this->expectExceptionMessage(
+            "Collection should only include [stdClass] items, but 'string' found at position 1."
+        );
+
+        Validator::ensure([
+            (object) ['value' => 'foo'],
+            'bar',
+        ], stdClass::class);
+    }
+}
diff --git a/tests/Unit/Support/Validator/MapCountTest.php b/tests/Unit/Support/Validator/MapCountTest.php
new file mode 100644
index 0000000..3f6c6b2
--- /dev/null
+++ b/tests/Unit/Support/Validator/MapCountTest.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Support\Validator;
+
+use DragonCode\SizeSorter\Support\Validator;
+use LengthException;
+use Tests\TestCase;
+
+class MapCountTest extends TestCase
+{
+    public function testSuccess(): void
+    {
+        $items = collect([1, 2, 3]);
+
+        Validator::mapCount($items, $items);
+
+        $this->assertTrue(true);
+    }
+
+    public function testWrong(): void
+    {
+        $this->expectException(LengthException::class);
+
+        $this->expectExceptionMessage(
+            'The count of items in the map (2) and collection (3) should be the same.'
+        );
+
+        Validator::mapCount(
+            collect([1, 2, 3]),
+            collect([1, 2]),
+        );
+    }
+}