improve typing of element finding utils

move BitArray in its namerspace
sync
2025-05-24 13:22:09 +02:00 · 2025-05-24 13:21:23 +02:00 · 2025-05-24 12:11:44 +02:00 · 2024-10-14 07:38:23 +02:00
27 changed files with 1947 additions and 1032 deletions
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,16 +9,16 @@
      "version": "1.0.0",
      "license": "ISC",
      "devDependencies": {
-        "@types/node": "^20.14.15",
-        "esbuild": "^0.23.0",
-        "tsx": "^4.17.0",
-        "typescript": "^5.5.4"
+        "@types/node": "^22.15.21",
+        "esbuild": "^0.25.4",
+        "tsx": "^4.19.4",
+        "typescript": "^5.8.3"
      }
    },
    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.23.0.tgz",
-      "integrity": "sha512-3sG8Zwa5fMcA9bgqB8AfWPQ+HFke6uD3h1s3RIwUNK8EG7a4buxvuFTs3j1IMs2NXAk9F30C/FF4vxRgQCcmoQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz",
+      "integrity": "sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==",
      "cpu": [
        "ppc64"
      ],
@@ -33,9 +33,9 @@
      }
    },
    "node_modules/@esbuild/android-arm": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.23.0.tgz",
-      "integrity": "sha512-+KuOHTKKyIKgEEqKbGTK8W7mPp+hKinbMBeEnNzjJGyFcWsfrXjSTNluJHCY1RqhxFurdD8uNXQDei7qDlR6+g==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.4.tgz",
+      "integrity": "sha512-QNdQEps7DfFwE3hXiU4BZeOV68HHzYwGd0Nthhd3uCkkEKK7/R6MTgM0P7H7FAs5pU/DIWsviMmEGxEoxIZ+ZQ==",
      "cpu": [
        "arm"
      ],
@@ -50,9 +50,9 @@
      }
    },
    "node_modules/@esbuild/android-arm64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.23.0.tgz",
-      "integrity": "sha512-EuHFUYkAVfU4qBdyivULuu03FhJO4IJN9PGuABGrFy4vUuzk91P2d+npxHcFdpUnfYKy0PuV+n6bKIpHOB3prQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.4.tgz",
+      "integrity": "sha512-bBy69pgfhMGtCnwpC/x5QhfxAz/cBgQ9enbtwjf6V9lnPI/hMyT9iWpR1arm0l3kttTr4L0KSLpKmLp/ilKS9A==",
      "cpu": [
        "arm64"
      ],
@@ -67,9 +67,9 @@
      }
    },
    "node_modules/@esbuild/android-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.23.0.tgz",
-      "integrity": "sha512-WRrmKidLoKDl56LsbBMhzTTBxrsVwTKdNbKDalbEZr0tcsBgCLbEtoNthOW6PX942YiYq8HzEnb4yWQMLQuipQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.4.tgz",
+      "integrity": "sha512-TVhdVtQIFuVpIIR282btcGC2oGQoSfZfmBdTip2anCaVYcqWlZXGcdcKIUklfX2wj0JklNYgz39OBqh2cqXvcQ==",
      "cpu": [
        "x64"
      ],
@@ -84,9 +84,9 @@
      }
    },
    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.23.0.tgz",
-      "integrity": "sha512-YLntie/IdS31H54Ogdn+v50NuoWF5BDkEUFpiOChVa9UnKpftgwzZRrI4J132ETIi+D8n6xh9IviFV3eXdxfow==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz",
+      "integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==",
      "cpu": [
        "arm64"
      ],
@@ -101,9 +101,9 @@
      }
    },
    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.23.0.tgz",
-      "integrity": "sha512-IMQ6eme4AfznElesHUPDZ+teuGwoRmVuuixu7sv92ZkdQcPbsNHzutd+rAfaBKo8YK3IrBEi9SLLKWJdEvJniQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.4.tgz",
+      "integrity": "sha512-CJsry8ZGM5VFVeyUYB3cdKpd/H69PYez4eJh1W/t38vzutdjEjtP7hB6eLKBoOdxcAlCtEYHzQ/PJ/oU9I4u0A==",
      "cpu": [
        "x64"
      ],
@@ -118,9 +118,9 @@
      }
    },
    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.23.0.tgz",
-      "integrity": "sha512-0muYWCng5vqaxobq6LB3YNtevDFSAZGlgtLoAc81PjUfiFz36n4KMpwhtAd4he8ToSI3TGyuhyx5xmiWNYZFyw==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-yYq+39NlTRzU2XmoPW4l5Ifpl9fqSk0nAJYM/V/WUGPEFfek1epLHJIkTQM6bBs1swApjO5nWgvr843g6TjxuQ==",
      "cpu": [
        "arm64"
      ],
@@ -135,9 +135,9 @@
      }
    },
    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.23.0.tgz",
-      "integrity": "sha512-XKDVu8IsD0/q3foBzsXGt/KjD/yTKBCIwOHE1XwiXmrRwrX6Hbnd5Eqn/WvDekddK21tfszBSrE/WMaZh+1buQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.4.tgz",
+      "integrity": "sha512-0FgvOJ6UUMflsHSPLzdfDnnBBVoCDtBTVyn/MrWloUNvq/5SFmh13l3dvgRPkDihRxb77Y17MbqbCAa2strMQQ==",
      "cpu": [
        "x64"
      ],
@@ -152,9 +152,9 @@
      }
    },
    "node_modules/@esbuild/linux-arm": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.23.0.tgz",
-      "integrity": "sha512-SEELSTEtOFu5LPykzA395Mc+54RMg1EUgXP+iw2SJ72+ooMwVsgfuwXo5Fn0wXNgWZsTVHwY2cg4Vi/bOD88qw==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.4.tgz",
+      "integrity": "sha512-kro4c0P85GMfFYqW4TWOpvmF8rFShbWGnrLqlzp4X1TNWjRY3JMYUfDCtOxPKOIY8B0WC8HN51hGP4I4hz4AaQ==",
      "cpu": [
        "arm"
      ],
@@ -169,9 +169,9 @@
      }
    },
    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.23.0.tgz",
-      "integrity": "sha512-j1t5iG8jE7BhonbsEg5d9qOYcVZv/Rv6tghaXM/Ug9xahM0nX/H2gfu6X6z11QRTMT6+aywOMA8TDkhPo8aCGw==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.4.tgz",
+      "integrity": "sha512-+89UsQTfXdmjIvZS6nUnOOLoXnkUTB9hR5QAeLrQdzOSWZvNSAXAtcRDHWtqAUtAmv7ZM1WPOOeSxDzzzMogiQ==",
      "cpu": [
        "arm64"
      ],
@@ -186,9 +186,9 @@
      }
    },
    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.23.0.tgz",
-      "integrity": "sha512-P7O5Tkh2NbgIm2R6x1zGJJsnacDzTFcRWZyTTMgFdVit6E98LTxO+v8LCCLWRvPrjdzXHx9FEOA8oAZPyApWUA==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.4.tgz",
+      "integrity": "sha512-yTEjoapy8UP3rv8dB0ip3AfMpRbyhSN3+hY8mo/i4QXFeDxmiYbEKp3ZRjBKcOP862Ua4b1PDfwlvbuwY7hIGQ==",
      "cpu": [
        "ia32"
      ],
@@ -203,9 +203,9 @@
      }
    },
    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.23.0.tgz",
-      "integrity": "sha512-InQwepswq6urikQiIC/kkx412fqUZudBO4SYKu0N+tGhXRWUqAx+Q+341tFV6QdBifpjYgUndV1hhMq3WeJi7A==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.4.tgz",
+      "integrity": "sha512-NeqqYkrcGzFwi6CGRGNMOjWGGSYOpqwCjS9fvaUlX5s3zwOtn1qwg1s2iE2svBe4Q/YOG1q6875lcAoQK/F4VA==",
      "cpu": [
        "loong64"
      ],
@@ -220,9 +220,9 @@
      }
    },
    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.23.0.tgz",
-      "integrity": "sha512-J9rflLtqdYrxHv2FqXE2i1ELgNjT+JFURt/uDMoPQLcjWQA5wDKgQA4t/dTqGa88ZVECKaD0TctwsUfHbVoi4w==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.4.tgz",
+      "integrity": "sha512-IcvTlF9dtLrfL/M8WgNI/qJYBENP3ekgsHbYUIzEzq5XJzzVEV/fXY9WFPfEEXmu3ck2qJP8LG/p3Q8f7Zc2Xg==",
      "cpu": [
        "mips64el"
      ],
@@ -237,9 +237,9 @@
      }
    },
    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.23.0.tgz",
-      "integrity": "sha512-cShCXtEOVc5GxU0fM+dsFD10qZ5UpcQ8AM22bYj0u/yaAykWnqXJDpd77ublcX6vdDsWLuweeuSNZk4yUxZwtw==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.4.tgz",
+      "integrity": "sha512-HOy0aLTJTVtoTeGZh4HSXaO6M95qu4k5lJcH4gxv56iaycfz1S8GO/5Jh6X4Y1YiI0h7cRyLi+HixMR+88swag==",
      "cpu": [
        "ppc64"
      ],
@@ -254,9 +254,9 @@
      }
    },
    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.23.0.tgz",
-      "integrity": "sha512-HEtaN7Y5UB4tZPeQmgz/UhzoEyYftbMXrBCUjINGjh3uil+rB/QzzpMshz3cNUxqXN7Vr93zzVtpIDL99t9aRw==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.4.tgz",
+      "integrity": "sha512-i8JUDAufpz9jOzo4yIShCTcXzS07vEgWzyX3NH2G7LEFVgrLEhjwL3ajFE4fZI3I4ZgiM7JH3GQ7ReObROvSUA==",
      "cpu": [
        "riscv64"
      ],
@@ -271,9 +271,9 @@
      }
    },
    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.23.0.tgz",
-      "integrity": "sha512-WDi3+NVAuyjg/Wxi+o5KPqRbZY0QhI9TjrEEm+8dmpY9Xir8+HE/HNx2JoLckhKbFopW0RdO2D72w8trZOV+Wg==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.4.tgz",
+      "integrity": "sha512-jFnu+6UbLlzIjPQpWCNh5QtrcNfMLjgIavnwPQAfoGx4q17ocOU9MsQ2QVvFxwQoWpZT8DvTLooTvmOQXkO51g==",
      "cpu": [
        "s390x"
      ],
@@ -288,9 +288,9 @@
      }
    },
    "node_modules/@esbuild/linux-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.23.0.tgz",
-      "integrity": "sha512-a3pMQhUEJkITgAw6e0bWA+F+vFtCciMjW/LPtoj99MhVt+Mfb6bbL9hu2wmTZgNd994qTAEw+U/r6k3qHWWaOQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.4.tgz",
+      "integrity": "sha512-6e0cvXwzOnVWJHq+mskP8DNSrKBr1bULBvnFLpc1KY+d+irZSgZ02TGse5FsafKS5jg2e4pbvK6TPXaF/A6+CA==",
      "cpu": [
        "x64"
      ],
@@ -304,10 +304,27 @@
        "node": ">=18"
      }
    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-vUnkBYxZW4hL/ie91hSqaSNjulOnYXE1VSLusnvHg2u3jewJBz3YzB9+oCw8DABeVqZGg94t9tyZFoHma8gWZQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.23.0.tgz",
-      "integrity": "sha512-cRK+YDem7lFTs2Q5nEv/HHc4LnrfBCbH5+JHu6wm2eP+d8OZNoSMYgPZJq78vqQ9g+9+nMuIsAO7skzphRXHyw==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-XAg8pIQn5CzhOB8odIcAm42QsOfa98SBeKUdo4xa8OvX8LbMZqEtgeWE9P/Wxt7MlG2QqvjGths+nq48TrUiKw==",
      "cpu": [
        "x64"
      ],
@@ -322,9 +339,9 @@
      }
    },
    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.23.0.tgz",
-      "integrity": "sha512-suXjq53gERueVWu0OKxzWqk7NxiUWSUlrxoZK7usiF50C6ipColGR5qie2496iKGYNLhDZkPxBI3erbnYkU0rQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-Ct2WcFEANlFDtp1nVAXSNBPDxyU+j7+tId//iHXU2f/lN5AmO4zLyhDcpR5Cz1r08mVxzt3Jpyt4PmXQ1O6+7A==",
      "cpu": [
        "arm64"
      ],
@@ -339,9 +356,9 @@
      }
    },
    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.23.0.tgz",
-      "integrity": "sha512-6p3nHpby0DM/v15IFKMjAaayFhqnXV52aEmv1whZHX56pdkK+MEaLoQWj+H42ssFarP1PcomVhbsR4pkz09qBg==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-xAGGhyOQ9Otm1Xu8NT1ifGLnA6M3sJxZ6ixylb+vIUVzvvd6GOALpwQrYrtlPouMqd/vSbgehz6HaVk4+7Afhw==",
      "cpu": [
        "x64"
      ],
@@ -356,9 +373,9 @@
      }
    },
    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.23.0.tgz",
-      "integrity": "sha512-BFelBGfrBwk6LVrmFzCq1u1dZbG4zy/Kp93w2+y83Q5UGYF1d8sCzeLI9NXjKyujjBBniQa8R8PzLFAUrSM9OA==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.4.tgz",
+      "integrity": "sha512-Mw+tzy4pp6wZEK0+Lwr76pWLjrtjmJyUB23tHKqEDP74R3q95luY/bXqXZeYl4NYlvwOqoRKlInQialgCKy67Q==",
      "cpu": [
        "x64"
      ],
@@ -373,9 +390,9 @@
      }
    },
    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.23.0.tgz",
-      "integrity": "sha512-lY6AC8p4Cnb7xYHuIxQ6iYPe6MfO2CC43XXKo9nBXDb35krYt7KGhQnOkRGar5psxYkircpCqfbNDB4uJbS2jQ==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.4.tgz",
+      "integrity": "sha512-AVUP428VQTSddguz9dO9ngb+E5aScyg7nOeJDrF1HPYu555gmza3bDGMPhmVXL8svDSoqPCsCPjb265yG/kLKQ==",
      "cpu": [
        "arm64"
      ],
@@ -390,9 +407,9 @@
      }
    },
    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.23.0.tgz",
-      "integrity": "sha512-7L1bHlOTcO4ByvI7OXVI5pNN6HSu6pUQq9yodga8izeuB1KcT2UkHaH6118QJwopExPn0rMHIseCTx1CRo/uNA==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.4.tgz",
+      "integrity": "sha512-i1sW+1i+oWvQzSgfRcxxG2k4I9n3O9NRqy8U+uugaT2Dy7kLO9Y7wI72haOahxceMX8hZAzgGou1FhndRldxRg==",
      "cpu": [
        "ia32"
      ],
@@ -407,9 +424,9 @@
      }
    },
    "node_modules/@esbuild/win32-x64": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.23.0.tgz",
-      "integrity": "sha512-Arm+WgUFLUATuoxCJcahGuk6Yj9Pzxd6l11Zb/2aAuv5kWWvvfhLFo2fni4uSK5vzlUdCGZ/BdV5tH8klj8p8g==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.4.tgz",
+      "integrity": "sha512-nOT2vZNw6hJ+z43oP1SPea/G/6AbN6X+bGNhNuq8NtRHy4wsMhw765IKLNmnjek7GvjWBYQ8Q5VBoYTFg9y1UQ==",
      "cpu": [
        "x64"
      ],
@@ -424,19 +441,19 @@
      }
    },
    "node_modules/@types/node": {
-      "version": "20.14.15",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.14.15.tgz",
-      "integrity": "sha512-Fz1xDMCF/B00/tYSVMlmK7hVeLh7jE5f3B7X1/hmV0MJBwE27KlS7EvD/Yp+z1lm8mVhwV5w+n8jOZG8AfTlKw==",
+      "version": "22.15.21",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz",
+      "integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "undici-types": "~5.26.4"
+        "undici-types": "~6.21.0"
      }
    },
    "node_modules/esbuild": {
-      "version": "0.23.0",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.23.0.tgz",
-      "integrity": "sha512-1lvV17H2bMYda/WaFb2jLPeHU3zml2k4/yagNMG8Q/YtfMjCwEUZa2eXXMgZTVSL5q1n4H7sQ0X6CdJDqqeCFA==",
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz",
+      "integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==",
      "dev": true,
      "hasInstallScript": true,
      "license": "MIT",
@@ -447,30 +464,31 @@
        "node": ">=18"
      },
      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.23.0",
-        "@esbuild/android-arm": "0.23.0",
-        "@esbuild/android-arm64": "0.23.0",
-        "@esbuild/android-x64": "0.23.0",
-        "@esbuild/darwin-arm64": "0.23.0",
-        "@esbuild/darwin-x64": "0.23.0",
-        "@esbuild/freebsd-arm64": "0.23.0",
-        "@esbuild/freebsd-x64": "0.23.0",
-        "@esbuild/linux-arm": "0.23.0",
-        "@esbuild/linux-arm64": "0.23.0",
-        "@esbuild/linux-ia32": "0.23.0",
-        "@esbuild/linux-loong64": "0.23.0",
-        "@esbuild/linux-mips64el": "0.23.0",
-        "@esbuild/linux-ppc64": "0.23.0",
-        "@esbuild/linux-riscv64": "0.23.0",
-        "@esbuild/linux-s390x": "0.23.0",
-        "@esbuild/linux-x64": "0.23.0",
-        "@esbuild/netbsd-x64": "0.23.0",
-        "@esbuild/openbsd-arm64": "0.23.0",
-        "@esbuild/openbsd-x64": "0.23.0",
-        "@esbuild/sunos-x64": "0.23.0",
-        "@esbuild/win32-arm64": "0.23.0",
-        "@esbuild/win32-ia32": "0.23.0",
-        "@esbuild/win32-x64": "0.23.0"
+        "@esbuild/aix-ppc64": "0.25.4",
+        "@esbuild/android-arm": "0.25.4",
+        "@esbuild/android-arm64": "0.25.4",
+        "@esbuild/android-x64": "0.25.4",
+        "@esbuild/darwin-arm64": "0.25.4",
+        "@esbuild/darwin-x64": "0.25.4",
+        "@esbuild/freebsd-arm64": "0.25.4",
+        "@esbuild/freebsd-x64": "0.25.4",
+        "@esbuild/linux-arm": "0.25.4",
+        "@esbuild/linux-arm64": "0.25.4",
+        "@esbuild/linux-ia32": "0.25.4",
+        "@esbuild/linux-loong64": "0.25.4",
+        "@esbuild/linux-mips64el": "0.25.4",
+        "@esbuild/linux-ppc64": "0.25.4",
+        "@esbuild/linux-riscv64": "0.25.4",
+        "@esbuild/linux-s390x": "0.25.4",
+        "@esbuild/linux-x64": "0.25.4",
+        "@esbuild/netbsd-arm64": "0.25.4",
+        "@esbuild/netbsd-x64": "0.25.4",
+        "@esbuild/openbsd-arm64": "0.25.4",
+        "@esbuild/openbsd-x64": "0.25.4",
+        "@esbuild/sunos-x64": "0.25.4",
+        "@esbuild/win32-arm64": "0.25.4",
+        "@esbuild/win32-ia32": "0.25.4",
+        "@esbuild/win32-x64": "0.25.4"
      }
    },
    "node_modules/fsevents": {
@@ -512,13 +530,13 @@
      }
    },
    "node_modules/tsx": {
-      "version": "4.17.0",
-      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.17.0.tgz",
-      "integrity": "sha512-eN4mnDA5UMKDt4YZixo9tBioibaMBpoxBkD+rIPAjVmYERSG0/dWEY1CEFuV89CgASlKL499q8AhmkMnnjtOJg==",
+      "version": "4.19.4",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.4.tgz",
+      "integrity": "sha512-gK5GVzDkJK1SI1zwHf32Mqxf2tSJkNx+eYcNly5+nHvWqXUJYUkWBQtKauoESz3ymezAI++ZwT855x5p5eop+Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "esbuild": "~0.23.0",
+        "esbuild": "~0.25.0",
        "get-tsconfig": "^4.7.5"
      },
      "bin": {
@@ -532,9 +550,9 @@
      }
    },
    "node_modules/typescript": {
-      "version": "5.5.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
-      "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
      "dev": true,
      "license": "Apache-2.0",
      "bin": {
@@ -546,9 +564,9 @@
      }
    },
    "node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
      "dev": true,
      "license": "MIT"
    }
--- a/package.json
+++ b/package.json
@@ -12,9 +12,9 @@
  "author": "Hervé BECHER",
  "license": "ISC",
  "devDependencies": {
-    "@types/node": "^20.14.15",
-    "esbuild": "^0.23.0",
-    "tsx": "^4.17.0",
-    "typescript": "^5.5.4"
+    "@types/node": "^22.15.21",
+    "esbuild": "^0.25.4",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
  }
 }
--- a/src/async/impl.ts
+++ b/src/async/impl.ts
--- a/src/async/index.ts
+++ b/src/async/index.ts
@@ -33,7 +33,7 @@ export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
  return new WrappedObjectAsync(obj);
 }

-export function array<T>(array: MaybePromiseLike<T>[]): AsyncSequence<T> {
+export function array<T>(array: ReadonlyArray<MaybePromiseLike<T>>): AsyncSequence<T> {
  return new WrappedArrayAsync(array);
 }

--- a/src/async/types.ts
+++ b/src/async/types.ts
@@ -1,11 +1,15 @@
 import { Collector } from "../collector/types.js";
+import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
+import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
 import { AsyncRandomOptions } from "../random/types.js";
-import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js";
+
+export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;

 export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
  iterator(): AsyncIterator<TElement>;

-  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
+  apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult>;

  count(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<number>;
  nonEnumeratedCount(): Promise<number>;
@@ -13,30 +17,31 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
  maxCount(): Promise<number>;

  select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
-  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult>;
+  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;

+  where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>;
  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;

-  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
+  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
+  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;

-  join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[TElement, TOther]>;
-  join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;
+  join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<[TElement, TOther]>;
+  join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>;

-  groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;
+  groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
+  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>;

-  contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
+  contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;

-  sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
+  sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;

  append(obj: TElement): AsyncSequence<TElement>;

  prepend(obj: TElement): AsyncSequence<TElement>;

-  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
+  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;

-  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement>;
+  concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;

  first(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
  firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -60,26 +65,29 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
  max(): Promise<TElement>;
  maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;

-  order(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
-  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
+  bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>): Promise<[min: TElement, max: TElement]>;
+  boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): Promise<[min: TElement, max: TElement]>;

-  orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
-  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
+  order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;

-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>>;
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>>;
+  orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;

-  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
+  partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>>;
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>>;

-  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
+  distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
+  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;

-  except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
+  union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
+  unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;

-  intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
+  except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
+  exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
+
+  intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
+  intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;

  all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
  any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
@@ -99,14 +107,14 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {

  forEach(action: MaybeAsyncAction<TElement>): Promise<void>;

-  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]>;
+  zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;

  indexed(): AsyncSequence<[number, TElement]>;

  reversed(): AsyncSequence<TElement>;

-  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
-  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
+  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
+  chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;

  random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;

@@ -129,13 +137,13 @@ export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TEle
 }

 export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
-  get comparer(): MaybeAsyncComparer<TElement>;
+  get comparer(): AsyncComparer<TElement>;

-  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
+  thenSelf(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;

-  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
+  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;

-  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
+  thenSelfDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;

-  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
+  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
 }
--- a/src/bitarray/index.ts
+++ b/src/bitarray/index.ts
@@ -2,27 +2,47 @@ import { asArray } from "../utils.js";
 import { EmptyBitArray, BitArrayImpl } from "./impl.js";
 import { BitArray } from "./types.js";

-export const EMPTY = new EmptyBitArray();
+namespace BitArray {
+  export const EMPTY: BitArray = new EmptyBitArray();

-export function create(length: number): BitArray {
-  if (length < 0) {
-    throw new Error("length < 0");
+  export function create(length: number): BitArray {
+    if (length < 0) {
+      throw new Error("length < 0");
+    }
+
+    return length === 0 ? EMPTY : new BitArrayImpl(length);
  }

-  return length === 0 ? EMPTY : new BitArrayImpl(length);
-}
+  export function from(bits: Iterable<boolean>) {
+    const arr = asArray(bits);
+    const result = create(arr.length);

-export function from(bits: Iterable<boolean>): BitArray {
-  const arr = asArray(bits);
-  const result = create(arr.length);
+    for (let i = 0; i < arr.length; i++) {
+      result.set(i, arr[i]);
+    }

-  for (let i = 0; i < arr.length; i++) {
-    result.set(i, arr[i]);
+    return result;
  }

-  return result;
+  export function of(...bits: boolean[]) {
+    return from(bits);
+  }
+
+  export function and(a: BitArray, b: BitArray) {
+    return a.copy().and(b);
+  }
+
+  export function or(a: BitArray, b: BitArray) {
+    return a.copy().or(b);
+  }
+
+  export function xor(a: BitArray, b: BitArray) {
+    return a.copy().xor(b);
+  }
+
+  export function not(a: BitArray) {
+    return a.copy().not();
+  }
 }

-export function of(...bits: boolean[]): BitArray {
-  return from(bits);
-}
+export { BitArray };
--- a/src/collector/impl.ts
+++ b/src/collector/impl.ts
@@ -65,6 +65,37 @@ export class ToObjectCollector<TElement, TKey extends PropertyKey, TValue> imple
  }
 }

+export class ToObjectListCollector<TElement, TKey extends PropertyKey, TValue> implements Collector<TElement, Record<TKey, TValue[]>, Record<TKey, TValue[]>> {
+  readonly #keySelector: Converter<TElement, TKey>;
+  readonly #valueSelector: Converter<TElement, TValue>;
+
+  constructor(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+    this.#keySelector = keySelector;
+    this.#valueSelector = valueSelector;
+  }
+
+  initialize() {
+    return {} as Record<TKey, TValue[]>;
+  }
+
+  accumulate(accumulator: Record<TKey, TValue[]>, element: TElement) {
+    const key = this.#keySelector(element);
+    const value = this.#valueSelector(element);
+
+    const l = accumulator[key];
+
+    if (l) {
+      l.push(value);
+    } else {
+      accumulator[key] = [value];
+    }
+  }
+
+  finalize(accumulator: Record<TKey, TValue[]>) {
+    return accumulator;
+  }
+}
+
 export class ToMapCollector<TElement, TKey, TValue> implements Collector<TElement, Map<TKey, TValue>, Map<TKey, TValue>> {
  readonly #keySelector: Converter<TElement, TKey>;
  readonly #valueSelector: Converter<TElement, TValue>;
@@ -90,6 +121,37 @@ export class ToMapCollector<TElement, TKey, TValue> implements Collector<TElemen
  }
 }

+export class ToMapListCollector<TElement, TKey, TValue> implements Collector<TElement, Map<TKey, TValue[]>, Map<TKey, TValue[]>> {
+  readonly #keySelector: Converter<TElement, TKey>;
+  readonly #valueSelector: Converter<TElement, TValue>;
+
+  constructor(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+    this.#keySelector = keySelector;
+    this.#valueSelector = valueSelector;
+  }
+
+  initialize() {
+    return new Map<TKey, TValue[]>();
+  }
+
+  accumulate(accumulator: Map<TKey, TValue[]>, element: TElement) {
+    const key = this.#keySelector(element);
+    const value = this.#valueSelector(element);
+
+    const l = accumulator.get(key);
+
+    if (l) {
+      l.push(value);
+    } else {
+      accumulator.set(key, [value]);
+    }
+  }
+
+  finalize(accumulator: Map<TKey, TValue[]>) {
+    return accumulator;
+  }
+}
+
 export class ToSetCollector<TElement> implements Collector<TElement, Set<TElement>, Set<TElement>> {
  initialize() {
    return new Set<TElement>();
@@ -128,60 +190,60 @@ export class JoinCollector implements Collector<any, any[], string> {
  }
 }

-export class SumCollector implements Collector<number, { sum: number }, number> {
+export class SumCollector implements Collector<number, { sum: number; }, number> {
  initialize() {
    return { sum: 0 };
  }

-  accumulate(accumulator: { sum: number }, element: number) {
+  accumulate(accumulator: { sum: number; }, element: number) {
    accumulator.sum += element;
  }

-  finalize(accumulator: { sum: number }) {
+  finalize(accumulator: { sum: number; }) {
    return accumulator.sum;
  }
 }

-export class BigIntSumCollector implements Collector<bigint, { sum: bigint }, bigint> {
+export class BigIntSumCollector implements Collector<bigint, { sum: bigint; }, bigint> {
  initialize() {
    return { sum: 0n, };
  }

-  accumulate(accumulator: { sum: bigint }, element: bigint) {
+  accumulate(accumulator: { sum: bigint; }, element: bigint) {
    accumulator.sum += element;
  }

-  finalize(accumulator: { sum: bigint }) {
+  finalize(accumulator: { sum: bigint; }) {
    return accumulator.sum;
  }
 }

-export class AverageCollector implements Collector<number, { count: number, sum: number }, number> {
+export class AverageCollector implements Collector<number, { count: number, sum: number; }, number> {
  initialize() {
    return { count: 0, sum: 0 };
  }

-  accumulate(accumulator: { count: number, sum: number }, element: number) {
+  accumulate(accumulator: { count: number, sum: number; }, element: number) {
    accumulator.count++;
    accumulator.sum += element;
  }

-  finalize(accumulator: { count: number, sum: number }) {
+  finalize(accumulator: { count: number, sum: number; }) {
    return accumulator.count === 0 ? 0 : accumulator.sum / accumulator.count;
  }
 }

-export class BigIntAverageCollector implements Collector<bigint, { count: number, sum: bigint }, bigint> {
+export class BigIntAverageCollector implements Collector<bigint, { count: number, sum: bigint; }, bigint> {
  initialize() {
    return { count: 0, sum: 0n };
  }

-  accumulate(accumulator: { count: number, sum: bigint }, element: bigint) {
+  accumulate(accumulator: { count: number, sum: bigint; }, element: bigint) {
    accumulator.count++;
    accumulator.sum += element;
  }

-  finalize(accumulator: { count: number, sum: bigint }) {
+  finalize(accumulator: { count: number, sum: bigint; }) {
    return accumulator.count === 0 ? 0n : accumulator.sum / BigInt(accumulator.count);
  }
 }
--- a/src/collector/index.ts
+++ b/src/collector/index.ts
@@ -1,5 +1,5 @@
 import { Converter } from "../types.js";
-import { SimpleCollector, ToArrayCollector, ToObjectCollector, ToMapCollector, ToSetCollector, JoinCollector, SumCollector, BigIntSumCollector, AverageCollector, BigIntAverageCollector } from "./impl.js";
+import { SimpleCollector, ToArrayCollector, ToObjectCollector, ToMapCollector, ToSetCollector, JoinCollector, SumCollector, BigIntSumCollector, AverageCollector, BigIntAverageCollector, ToObjectListCollector, ToMapListCollector } from "./impl.js";
 import { Collector } from "./types.js";

 export function create<TElement, TAccumulator, TResult>(initialize: () => TAccumulator, accumulate: (accumulator: TAccumulator, element: TElement) => void,
@@ -17,10 +17,18 @@ export function toObject<TElement, TKey extends PropertyKey, TValue>(keySelector
  return new ToObjectCollector<TElement, TKey, TValue>(keySelector, valueSelector);
 }

+export function toObjectList<TElement, TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Collector<TElement, any, Record<TKey, TValue[]>> {
+  return new ToObjectListCollector<TElement, TKey, TValue>(keySelector, valueSelector);
+}
+
 export function toMap<TElement, TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Collector<TElement, any, Map<TKey, TValue>> {
  return new ToMapCollector<TElement, TKey, TValue>(keySelector, valueSelector);
 }

+export function toMapList<TElement, TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Collector<TElement, any, Map<TKey, TValue[]>> {
+  return new ToMapListCollector<TElement, TKey, TValue>(keySelector, valueSelector);
+}
+
 const toSetCollector = new ToSetCollector<any>();

 export function toSet<TElement>(): Collector<TElement, any, Set<TElement>> {
--- a/src/collector/v2/impl.ts
+++ b/src/collector/v2/impl.ts
@@ -0,0 +1,219 @@
+// import { Converter } from "../../types.js";
+// import { CollectorFactory, CollectorInstance } from "./types.js";
+
+// export class ToArrayCollectorFactory<TElement> implements CollectorFactory<TElement, TElement[]> {
+//   initialize() {
+//     return new ToArrayCollectorInstance<TElement>();
+//   }
+// };
+
+// class ToArrayCollectorInstance<TElement> implements CollectorInstance<TElement, TElement[]> {
+//   readonly #accumulator: TElement[];
+
+//   constructor() {
+//     this.#accumulator = [];
+//   }
+
+//   accumulate(element: TElement) {
+//     this.#accumulator.push(element);
+//   }
+
+//   finalize() {
+//     return this.#accumulator;
+//   }
+// }
+
+// export class ToObjectCollectorFactory<TElement, TKey extends PropertyKey, TValue> implements CollectorFactory<TElement, Record<TKey, TValue>> {
+//   readonly #keySelector: Converter<TElement, TKey>;
+//   readonly #valueSelector: Converter<TElement, TValue>;
+
+//   constructor(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+//     this.#keySelector = keySelector;
+//     this.#valueSelector = valueSelector;
+//   }
+
+//   get keySelector() {
+//     return this.#keySelector;
+//   }
+
+//   get valueSelector() {
+//     return this.#valueSelector;
+//   }
+
+//   initialize() {
+//     return new ToObjectCollectorInstance<TElement, TKey, TValue>(this);
+//   }
+// }
+
+// class ToObjectCollectorInstance<TElement, TKey extends PropertyKey, TValue> implements CollectorInstance<TElement, Record<TKey, TValue>> {
+//   readonly #factory: ToObjectCollectorFactory<TElement, TKey, TValue>;
+//   readonly #accumulator = <Record<TKey, TValue>>{};
+
+//   constructor(factory: ToObjectCollectorFactory<TElement, TKey, TValue>) {
+//     this.#factory = factory;
+//   }
+
+//   accumulate(element: TElement) {
+//     const key = this.#factory.keySelector(element);
+//     const value = this.#factory.valueSelector(element);
+
+//     this.#accumulator[key] = value;
+//   }
+
+//   finalize() {
+//     return this.#accumulator;
+//   }
+// }
+
+// export class ToMapCollectorFactory<TElement, TKey extends PropertyKey, TValue> implements CollectorFactory<TElement, Map<TKey, TValue>> {
+//   readonly #keySelector: Converter<TElement, TKey>;
+//   readonly #valueSelector: Converter<TElement, TValue>;
+
+//   constructor(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+//     this.#keySelector = keySelector;
+//     this.#valueSelector = valueSelector;
+//   }
+
+//   get keySelector() {
+//     return this.#keySelector;
+//   }
+
+//   get valueSelector() {
+//     return this.#valueSelector;
+//   }
+
+//   initialize() {
+//     return new ToMapCollectorInstance<TElement, TKey, TValue>(this);
+//   }
+// }
+
+// class ToMapCollectorInstance<TElement, TKey extends PropertyKey, TValue> implements CollectorInstance<TElement, Map<TKey, TValue>> {
+//   readonly #factory: ToMapCollectorFactory<TElement, TKey, TValue>;
+//   readonly #accumulator = new Map<TKey, TValue>();
+
+//   constructor(factory: ToMapCollectorFactory<TElement, TKey, TValue>) {
+//     this.#factory = factory;
+//   }
+
+//   accumulate(element: TElement) {
+//     const key = this.#factory.keySelector(element);
+//     const value = this.#factory.valueSelector(element);
+
+//     this.#accumulator.set(key, value);
+//   }
+
+//   finalize() {
+//     return this.#accumulator;
+//   }
+// }
+
+// export class ToSetCollectorFactory<TElement> implements CollectorFactory<TElement, Set<TElement>> {
+//   initialize() {
+//     return new ToSetCollectorInstance<TElement>();
+//   }
+// }
+
+// class ToSetCollectorInstance<TElement> implements CollectorInstance<TElement, Set<TElement>> {
+//   readonly #accumulator = new Set<TElement>();
+
+//   accumulate(element: TElement) {
+//     this.#accumulator.add(element);
+//   }
+
+//   finalize() {
+//     return this.#accumulator;
+//   }
+// }
+
+// export class JoinCollectorFactory implements CollectorFactory<any, string> {
+//   readonly #delimiter: string;
+//   readonly #prefix: string;
+//   readonly #suffix: string;
+
+//   constructor(delimiter?: string, prefix?: string, suffix?: string) {
+//     this.#delimiter = delimiter ?? "";
+//     this.#prefix = prefix ?? "";
+//     this.#suffix = suffix ?? "";
+//   }
+
+//   accumulate(element: string) {
+//     this.#accumulator.push(element);
+//   }
+
+//   finalize() {
+//     return this.#prefix + this.#accumulator.join(this.#delimiter) + this.#suffix;
+//   }
+// }
+
+// class JoinCollectorInstance implements CollectorInstance<any, string> {
+//   readonly #delimiter: string;
+//   readonly #prefix: string;
+//   readonly #suffix: string;
+//   readonly #accumulator: any[] = [];
+
+//   constructor(delimiter: string, prefix: string, suffix: string) {
+//     this.#delimiter = delimiter ?? "";
+//     this.#prefix = prefix ?? "";
+//     this.#suffix = suffix ?? "";
+//   }
+
+//   accumulate(element: string) {
+//     this.#accumulator.push(element);
+//   }
+
+//   finalize() {
+//     return this.#prefix + this.#accumulator.join(this.#delimiter) + this.#suffix;
+//   }
+// }
+
+// export class SumCollectorInstance implements CollectorInstance<number, number> {
+//   #accumulator = 0;
+
+//   accumulate(element: number) {
+//     this.#accumulator += element;
+//   }
+
+//   finalize() {
+//     return this.#accumulator;
+//   }
+// }
+
+// export class BigIntSumCollectorInstance implements CollectorInstance<bigint, bigint> {
+//   #accumulator = 0n;
+
+//   accumulate(element: bigint) {
+//     this.#accumulator += element;
+//   }
+
+//   finalize() {
+//     return this.#accumulator;
+//   }
+// }
+
+// export class AverageCollectorInstance implements CollectorInstance<number, number> {
+//   #count = 0;
+//   #sum = 0;
+
+//   accumulate(element: number) {
+//     this.#count++;
+//     this.#sum += element;
+//   }
+
+//   finalize() {
+//     return this.#count === 0 ? 0 : this.#sum / this.#count;
+//   }
+// }
+
+// export class BigIntAverageCollectorInstance implements CollectorInstance<bigint, bigint> {
+//   #count = 0n;
+//   #sum = 0n;
+
+//   accumulate(element: bigint) {
+//     this.#count++;
+//     this.#sum += element;
+//   }
+
+//   finalize() {
+//     return this.#count === 0n ? 0n : this.#sum / this.#count;
+//   }
+// }
--- a/src/collector/v2/index.ts
+++ b/src/collector/v2/index.ts
@@ -0,0 +1,57 @@
+// import { Converter } from "../../types.js";
+// import { ToArrayCollectorInstance, ToObjectCollectorInstance, ToMapCollectorInstance, ToSetCollectorInstance, JoinCollectorInstance, SumCollectorInstance, BigIntSumCollectorInstance, AverageCollectorInstance, BigIntAverageCollectorInstance, ToArrayCollectorFactory } from "./impl.js";
+// import { CollectorFactory } from "./types.js";
+
+// const toArrayCollectorFactory = new ToArrayCollectorFactory<any>();
+
+// export function toArray<TElement>(): CollectorFactory<TElement, TElement[]> {
+//   return toArrayCollectorFactory;
+// }
+
+// export function toObject<TElement, TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): CollectorFactory<TElement, Record<TKey, TValue>> {
+//   return () => toObjectCollectorFactory<TElement, TKey, TValue>(keySelector, valueSelector);
+// }
+
+// export function toMap<TElement, TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): CollectorFactory<TElement, Map<TKey, TValue>> {
+//   return () => new ToMapCollectorInstance<TElement, TKey, TValue>(keySelector, valueSelector);
+// }
+
+// export function toSet<TElement>(): CollectorFactory<TElement, Set<TElement>> {
+//   return () => new ToSetCollectorInstance<TElement>();
+// }
+
+// export function join(delimiter?: string, prefix?: string, suffix?: string): CollectorFactory<any, string> {
+//   return () => new JoinCollectorInstance(delimiter, prefix, suffix);
+// }
+
+// function sumCollectorFactory() {
+//   return new SumCollectorInstance();
+// }
+
+// export function sum(): CollectorFactory<number, number> {
+//   return sumCollectorFactory;
+// }
+
+// function bigintSumCollectorFactory() {
+//   return new BigIntSumCollectorInstance();
+// }
+
+// export function bigintSum(): CollectorFactory<bigint | number, bigint> {
+//   return bigintSumCollectorFactory;
+// }
+
+// function averageCollectorFactory() {
+//   return new AverageCollectorInstance();
+// }
+
+// export function average(): CollectorFactory<number, number> {
+//   return averageCollectorFactory;
+// }
+
+// function bigintAverageCollectorFactory() {
+//   return new BigIntAverageCollectorInstance();
+// }
+
+// export function bigintAverage(): CollectorFactory<bigint, bigint> {
+//   return bigintAverageCollectorFactory;
+// }
--- a/src/collector/v2/types.ts
+++ b/src/collector/v2/types.ts
@@ -0,0 +1,8 @@
+// export interface CollectorFactory<TElement, TResult> {
+//   initialize(): CollectorInstance<TElement, TResult>;
+// }
+
+// export interface CollectorInstance<TElement, TResult> {
+//   accumulate(element: TElement): void;
+//   finalize(): TResult;
+// }
--- a/src/comparer/async.ts
+++ b/src/comparer/async.ts
@@ -0,0 +1,245 @@
+import { MaybeAsyncConverter } from "../types.js";
+import { Nullable } from "../utils.js";
+import { AsyncComparer, MaybeAsyncComparisonOrComparer, Comparer, MaybeAsyncComparison, AsyncComparison } from "./types.js";
+
+export function isAsyncComparer<T>(obj: any): obj is AsyncComparer<T> {
+  return obj instanceof BaseAsyncComparer;
+}
+
+export function asAsyncComparer<T>(comparer: MaybeAsyncComparisonOrComparer<T>): AsyncComparer<T> {
+  return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : new WrappedAsyncComparer(comparer);
+}
+
+export function fromSync<T>(comparer: Comparer<T>): AsyncComparer<T> {
+  return new WrappedAsyncComparer(comparer);
+}
+
+export function createAsyncComparer<T>(comparison: MaybeAsyncComparison<T>): AsyncComparer<T> {
+  return new SimpleAsyncComparer(comparison);
+}
+
+export function createAsyncComparerUsing<T, U>(projection: MaybeAsyncConverter<T, U>, comparison?: MaybeAsyncComparisonOrComparer<U>): AsyncComparer<T> {
+  return new MappedAsyncComparer(projection, comparison);
+}
+
+export function combineNullableAsyncComparers<T>(comparers: Nullable<MaybeAsyncComparisonOrComparer<T>>[]): AsyncComparer<T> | undefined {
+  let result = defaultAsyncComparer;
+
+  for (const comparer of comparers) {
+    if (!comparer) {
+      continue;
+    }
+
+    result = result.then(asAsyncComparer(comparer));
+  }
+
+  return result === defaultAsyncComparer ? undefined : result;
+}
+
+export abstract class BaseAsyncComparer<T> implements AsyncComparer<T> {
+  #cachedBoundComparison: AsyncComparison<T> | undefined;
+
+  public abstract compare(a: T, b: T): Promise<number>;
+
+  public comparison(): AsyncComparison<T> {
+    return this.#cachedBoundComparison ??= this.compare.bind(this);
+  }
+
+  public reverse(): AsyncComparer<T> {
+    return new ReversedAsyncComparer(this);
+  }
+
+  public then(comparer: AsyncComparer<T>): AsyncComparer<T> {
+    return new ThenAsyncComparer(this, comparer);
+  }
+
+  public thenCompare(comparison: MaybeAsyncComparison<T>): AsyncComparer<T> {
+    return this.then(createAsyncComparer(comparison));
+  }
+
+  public thenCompareUsing<U>(projection: MaybeAsyncConverter<T, U>, comparer?: MaybeAsyncComparisonOrComparer<U>): AsyncComparer<T> {
+    return this.then(createAsyncComparerUsing(projection, comparer));
+  }
+
+  public nullAwareComparer(): AsyncComparer<Nullable<T>> {
+    return new NullAwareAsyncComparer(this);
+  }
+}
+
+class WrappedAsyncComparer<T> extends BaseAsyncComparer<T> {
+  readonly #base: Comparer<T>;
+
+  constructor(base: Comparer<T>) {
+    super();
+
+    this.#base = base;
+  }
+
+  public override async compare(a: T, b: T) {
+    return this.#base.compare(a, b);
+  }
+}
+
+class SimpleAsyncComparer<T> extends BaseAsyncComparer<T> {
+  readonly #comparison: MaybeAsyncComparison<T>;
+
+  public constructor(comparison: MaybeAsyncComparison<T>) {
+    super();
+
+    this.#comparison = comparison;
+  }
+
+  public async compare(a: T, b: T) {
+    return await this.#comparison(a, b);
+  }
+}
+
+class MappedAsyncComparer<T, U> extends BaseAsyncComparer<T> {
+  readonly #projection: MaybeAsyncConverter<T, U>;
+  readonly #comparer: AsyncComparer<U>;
+
+  public constructor(projection: MaybeAsyncConverter<T, U>, comparer?: MaybeAsyncComparisonOrComparer<U>) {
+    super();
+
+    this.#projection = projection;
+    this.#comparer = comparer ? asAsyncComparer(comparer) : defaultAsyncComparer;
+  }
+
+  public async compare(a: T, b: T) {
+    return await this.#comparer.compare(await this.#projection(a), await this.#projection(b));
+  }
+}
+
+class ReversedAsyncComparer<T> extends BaseAsyncComparer<T> {
+  readonly #base: AsyncComparer<T>;
+
+  public constructor(base: AsyncComparer<T>) {
+    super();
+
+    this.#base = base;
+  }
+
+  public async compare(a: T, b: T) {
+    return await this.#base.compare(b, a);
+  }
+
+  public override reverse() {
+    return this.#base;
+  }
+}
+
+class ThenAsyncComparer<T> extends BaseAsyncComparer<T> {
+  readonly #base: AsyncComparer<T>;
+  readonly #comparer: AsyncComparer<T>;
+
+  public constructor(base: AsyncComparer<T>, comparer: AsyncComparer<T>) {
+    super();
+
+    this.#base = base;
+    this.#comparer = comparer;
+  }
+
+  public async compare(a: T, b: T) {
+    return await this.#base.compare(a, b) || await this.#comparer.compare(a, b);
+  }
+}
+
+export const defaultAsyncComparer: AsyncComparer<any> = new class DefaultAsyncComparer extends BaseAsyncComparer<any> {
+  public override async compare(a: any, b: any): Promise<number> {
+    if (a === undefined) {
+      if (b === undefined) {
+        return 0;
+      }
+
+      return 1;
+    }
+
+    if (b === undefined) {
+      return -1;
+    }
+
+    const aStr = `${a}`, bStr = `${b}`;
+
+    return aStr > bStr ? 1 : aStr < bStr ? -1 : 0;
+  }
+};
+
+export function getDefaultAsyncComparer<T>(): AsyncComparer<T> {
+  return defaultAsyncComparer;
+}
+
+class NullAwareAsyncComparer<T> extends BaseAsyncComparer<Nullable<T>> {
+  readonly #base: AsyncComparer<T>;
+
+  constructor(baseComparer: AsyncComparer<T>) {
+    super();
+
+    this.#base = baseComparer;
+  }
+
+  public override async compare(a: Nullable<T>, b: Nullable<T>): Promise<number> {
+    if (a === undefined) {
+      if (b === undefined) {
+        return 0;
+      }
+
+      return 1;
+    }
+
+    if (b === undefined) {
+      return -1;
+    }
+
+    if (a === null) {
+      if (b === null) {
+        return 0;
+      }
+
+      return 1;
+    }
+
+    if (b === null) {
+      return -1;
+    }
+
+    return await this.#base.compare(a, b);
+  }
+
+  public override nullAwareComparer(): AsyncComparer<Nullable<T>> {
+    return this;
+  }
+}
+
+export function nullAwareComparer<T>(baseComparer: AsyncComparer<T>): AsyncComparer<Nullable<T>> {
+  return new NullAwareAsyncComparer(baseComparer);
+}
+
+export const stringAsyncComparer: AsyncComparer<string> = new class StringAsyncComparer extends BaseAsyncComparer<string> {
+  public override async compare(a: string, b: string): Promise<number> {
+    return a.localeCompare(b);
+  }
+};
+
+export const numberAsyncComparer: AsyncComparer<number> = new class NumberAsyncComparer extends BaseAsyncComparer<number> {
+  public override async compare(a: number, b: number): Promise<number> {
+    return a - b;
+  }
+};
+
+export const bigintAsyncComparer: AsyncComparer<bigint> = new class BigIntAsyncComparer extends BaseAsyncComparer<bigint> {
+  public override async compare(a: bigint, b: bigint): Promise<number> {
+    return Number(a - b);
+  }
+};
+
+export const booleanAsyncComparer: AsyncComparer<boolean> = new class BooleanAsyncComparer extends BaseAsyncComparer<boolean> {
+  public override async compare(a: boolean, b: boolean): Promise<number> {
+    return Number(a) - Number(b);
+  }
+};
+
+export const dateAsyncComparer: AsyncComparer<Date> = new class DateAsyncComparer extends BaseAsyncComparer<Date> {
+  public override async compare(a: Date, b: Date): Promise<number> {
+    return a.getTime() - b.getTime();
+  }
+};
--- a/src/comparer/sync.ts
+++ b/src/comparer/sync.ts
@@ -0,0 +1,244 @@
+import { Converter } from "../types.js";
+import { Nullable } from "../utils.js";
+import { fromSync } from "./async.js";
+import { Comparer, ComparisonOrComparer, Comparison, AsyncComparer } from "./types.js";
+
+export function isComparer<T>(obj: any): obj is Comparer<T> {
+  return obj instanceof BaseComparer;
+}
+
+export function asComparer<T>(comparer: ComparisonOrComparer<T>) {
+  return typeof comparer === "function" ? createComparer(comparer) : comparer;
+}
+
+export function asComparison<T>(comparer: ComparisonOrComparer<T>) {
+  return typeof comparer === "function" ? comparer : comparer.comparison();
+}
+
+export function createComparer<T>(comparison: Comparison<T>): Comparer<T> {
+  return new SimpleComparer(comparison);
+}
+
+export function createComparerUsing<T, U>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T> {
+  return new MappedComparer(projection, comparison);
+}
+
+export function reverseComparison<T>(comparison: Comparison<T>): Comparison<T> {
+  return (a, b) => comparison(b, a);
+}
+
+export function combineNullableComparers<T>(comparers: Nullable<ComparisonOrComparer<T>>[]) {
+  let result = defaultComparer;
+
+  for (const comparer of comparers) {
+    if (!comparer) {
+      continue;
+    }
+
+    result = result.then(asComparer(comparer));
+  }
+
+  return result === defaultComparer ? undefined : result;
+}
+
+export abstract class BaseComparer<T> implements Comparer<T> {
+  #cachedBoundComparison: Comparison<T> | undefined;
+
+  public abstract compare(a: T, b: T): number;
+
+  public comparison(): Comparison<T> {
+    return this.#cachedBoundComparison ??= this.compare.bind(this);
+  }
+
+  public reverse(): Comparer<T> {
+    return new ReversedComparer(this);
+  }
+
+  public then(comparer: Comparer<T>): Comparer<T> {
+    return new ThenComparer(this, comparer);
+  }
+
+  public thenCompare(comparison: Comparison<T>): Comparer<T> {
+    return this.then(createComparer(comparison));
+  }
+
+  public thenCompareUsing<U>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T> {
+    return this.then(createComparerUsing(projection, comparison));
+  }
+
+  public toAsync(): AsyncComparer<T> {
+    return fromSync<T>(this);
+  }
+
+  public nullAwareComparer(): Comparer<Nullable<T>> {
+    return new NullAwareComparer(this);
+  }
+}
+
+class SimpleComparer<T> extends BaseComparer<T> {
+  readonly #comparison: Comparison<T>;
+
+  public constructor(comparison: Comparison<T>) {
+    super();
+
+    this.#comparison = comparison;
+  }
+
+  public override compare(a: T, b: T) {
+    return this.#comparison(a, b);
+  }
+
+  public override comparison() {
+    return this.#comparison;
+  }
+}
+
+class MappedComparer<T, U> extends BaseComparer<T> {
+  readonly #projection: Converter<T, U>;
+  readonly #comparison: Comparer<U>;
+
+  public constructor(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>) {
+    super();
+
+    this.#projection = projection;
+    this.#comparison = comparison ? asComparer(comparison) : defaultComparer;
+  }
+
+  public override compare(a: T, b: T) {
+    return this.#comparison.compare(this.#projection(a), this.#projection(b));
+  }
+}
+
+class ReversedComparer<T> extends BaseComparer<T> {
+  readonly #base: Comparer<T>;
+
+  public constructor(base: Comparer<T>) {
+    super();
+
+    this.#base = base;
+  }
+
+  public override compare(a: T, b: T): number {
+    return this.#base.compare(b, a);
+  }
+
+  public override reverse(): Comparer<T> {
+    return this.#base;
+  }
+}
+
+class ThenComparer<T> extends BaseComparer<T> {
+  readonly #base: Comparer<T>;
+  readonly #comparer: Comparer<T>;
+
+  public constructor(base: Comparer<T>, comparer: Comparer<T>) {
+    super();
+
+    this.#base = base;
+    this.#comparer = comparer;
+  }
+
+  public override compare(a: T, b: T) {
+    return this.#base.compare(a, b) || this.#comparer.compare(a, b);
+  }
+}
+
+export const defaultComparer: Comparer<any> = new class DefaultComparer extends BaseComparer<any> {
+  public override compare(a: any, b: any): number {
+    if (a === undefined) {
+      if (b === undefined) {
+        return 0;
+      }
+
+      return 1;
+    }
+
+    if (b === undefined) {
+      return -1;
+    }
+
+    const aStr = `${a}`, bStr = `${b}`;
+
+    return aStr > bStr ? 1 : aStr < bStr ? -1 : 0;
+  }
+};
+
+export function getDefaultComparer<T>(): Comparer<T> {
+  return defaultComparer;
+}
+
+class NullAwareComparer<T> extends BaseComparer<Nullable<T>> {
+  readonly #base: Comparer<T>;
+
+  constructor(baseComparer: Comparer<T>) {
+    super();
+
+    this.#base = baseComparer;
+  }
+
+  public override compare(a: Nullable<T>, b: Nullable<T>): number {
+    if (a === undefined) {
+      if (b === undefined) {
+        return 0;
+      }
+
+      return 1;
+    }
+
+    if (b === undefined) {
+      return -1;
+    }
+
+    if (a === null) {
+      if (b === null) {
+        return 0;
+      }
+
+      return 1;
+    }
+
+    if (b === null) {
+      return -1;
+    }
+
+    return this.#base.compare(a, b);
+  }
+
+  public override nullAwareComparer(): Comparer<Nullable<T>> {
+    return this;
+  }
+}
+
+export function nullAwareComparer<T>(baseComparer: Comparer<T>): Comparer<Nullable<T>> {
+  return new NullAwareComparer(baseComparer);
+}
+
+export const stringComparer: Comparer<string> = new class StringComparer extends BaseComparer<string> {
+  public override compare(a: string, b: string): number {
+    return a.localeCompare(b);
+  }
+};
+
+export const numberComparer: Comparer<number> = new class NumberComparer extends BaseComparer<number> {
+  public override compare(a: number, b: number): number {
+    return a - b;
+  }
+};
+
+export const bigintComparer: Comparer<bigint> = new class BigIntComparer extends BaseComparer<bigint> {
+  public override compare(a: bigint, b: bigint): number {
+    return Number(a - b);
+  }
+};
+
+export const booleanComparer: Comparer<boolean> = new class BooleanComparer extends BaseComparer<boolean> {
+  public override compare(a: boolean, b: boolean): number {
+    return Number(a) - Number(b);
+  }
+};
+
+export const dateComparer: Comparer<Date> = new class DateComparer extends BaseComparer<Date> {
+  public override compare(a: Date, b: Date): number {
+    return a.getTime() - b.getTime();
+  }
+};
--- a/src/comparer/types.ts
+++ b/src/comparer/types.ts
@@ -0,0 +1,35 @@
+import { AsyncFunction, Converter, MaybeAsyncConverter, MaybeAsyncFunction } from "../types.js";
+import { Nullable } from "../utils.js";
+
+export interface Comparer<T> {
+  compare(a: T, b: T): number;
+  comparison(): Comparison<T>;
+  reverse(): Comparer<T>;
+  then(comparer: Comparer<T>): Comparer<T>;
+  thenCompare(comparison: Comparison<T>): Comparer<T>;
+  thenCompareUsing<U>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T>;
+  toAsync(): AsyncComparer<T>;
+  nullAwareComparer(): Comparer<Nullable<T>>;
+}
+
+export interface AsyncComparer<T> {
+  compare(a: T, b: T): Promise<number>;
+  comparison(): AsyncComparison<T>;
+  reverse(): AsyncComparer<T>;
+  then(comparer: AsyncComparer<T>): AsyncComparer<T>;
+  thenCompare(comparison: AsyncComparison<T>): AsyncComparer<T>;
+  thenCompareUsing<U>(projection: MaybeAsyncConverter<T, U>, comparison?: AsyncComparisonOrComparer<U>): AsyncComparer<T>;
+  nullAwareComparer(): AsyncComparer<Nullable<T>>;
+}
+
+export type Comparison<T> = (first: T, second: T) => number;
+export type ComparisonOrComparer<T> = Comparison<T> | Comparer<T>;
+export type Equater<T> = (first: T, second: T) => boolean;
+
+export type AsyncComparison<T> = AsyncFunction<Comparison<T>>;
+export type MaybeAsyncComparison<T> = MaybeAsyncFunction<Comparison<T>>;
+export type AsyncComparisonOrComparer<T> = AsyncComparison<T> | AsyncComparer<T>;
+export type MaybeAsyncComparisonOrComparer<T> = MaybeAsyncComparison<T> | Comparer<T> | AsyncComparer<T>;
+export type AsyncEquater<T> = AsyncFunction<Equater<T>>;
+export type MaybeAsyncEquater<T> = MaybeAsyncFunction<Equater<T>>;
+
--- a/src/equality-comparer/index.ts
+++ b/src/equality-comparer/index.ts
@@ -0,0 +1,15 @@
+export function identity<T>(obj: T) {
+  return obj;
+}
+
+export function looseEquals<T>(a: T, b: T) {
+  return a == b;
+}
+
+export function strictEquals<T>(a: T, b: T) {
+  return a === b;
+}
+
+export function sameValue<T>(a: T, b: T) {
+  return Object.is(a, b);
+}
--- a/src/equality-comparer/types.ts
+++ b/src/equality-comparer/types.ts
@@ -0,0 +1,6 @@
+import { AsyncFunction, MaybeAsyncFunction } from "../types.js";
+
+export type EqualityComparison<T> = (first: T, second: T) => boolean;
+
+export type AsyncEqualityComparison<T> = AsyncFunction<EqualityComparison<T>>;
+export type MaybeAsyncEqualityComparison<T> = MaybeAsyncFunction<EqualityComparison<T>>;
--- a/src/equality-map.ts
+++ b/src/equality-map.ts
@@ -1,15 +1,19 @@
-import { Equater, MaybeAsyncEquater } from "./types.js";
+import { EqualityComparison, MaybeAsyncEqualityComparison } from "./equality-comparer/types.js";
+import { MaybeAsyncIterable } from "./types.js";

-export interface EqualityMap<K, V> extends Iterable<[K, V]> {
+export type Entry<K, V> = [key: K, value: V];
+
+export interface EqualityMap<K, V> extends Iterable<Entry<K, V>> {
  readonly size: number;
  get(key: K): V | undefined;
  set(key: K, value: V): V | undefined;
+  setAll(entries: Iterable<Entry<K, V>>): void;
  contains(key: K): boolean;
  remove(key: K): V | undefined;
  clear(): void;
  keys(): IterableIterator<K>;
  values(): IterableIterator<V>;
-  entries(): IterableIterator<[K, V]>;
+  entries(): IterableIterator<Entry<K, V>>;
 }

 class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
@@ -29,6 +33,12 @@ class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
    return existing;
  }

+  setAll(entries: Iterable<Entry<K, V>>) {
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+  }
+
  contains(key: K) {
    return this.#map.has(key);
  }
@@ -61,10 +71,10 @@ class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
 }

 class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
-  readonly #list: [K, V][] = [];
-  readonly #keyComparer: Equater<K>;
+  readonly #list: Entry<K, V>[] = [];
+  readonly #keyComparer: EqualityComparison<K>;

-  constructor(keyComparer: Equater<K>) {
+  constructor(keyComparer: EqualityComparison<K>) {
    this.#keyComparer = keyComparer;
  }

@@ -96,6 +106,12 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
    return undefined;
  }

+  setAll(entries: Iterable<Entry<K, V>>) {
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+  }
+
  contains(key: K) {
    for (const entry of this.#list) {
      if (this.#keyComparer(key, entry[0])) {
@@ -139,25 +155,26 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {

  *[Symbol.iterator]() {
    for (const entry of this.#list) {
-      yield entry.slice() as [K, V]; // no entry mutation allowed!
+      yield entry.slice() as Entry<K, V>; // no entry mutation allowed!
    }
  }
 }

-export function createEqualityMap<K, V>(keyComparer?: Equater<K>): EqualityMap<K, V> {
+export function createEqualityMap<K, V>(keyComparer?: EqualityComparison<K>): EqualityMap<K, V> {
  return keyComparer ? new CustomEqualityMap<K, V>(keyComparer) : new NativeEqualityMap<K, V>();
 }

-export interface AsyncEqualityMap<K, V> extends Iterable<[K, V]> {
+export interface AsyncEqualityMap<K, V> extends Iterable<Entry<K, V>> {
  readonly size: number;
  get(key: K): Promise<V | undefined>;
  set(key: K, value: V): Promise<V | undefined>;
+  setAll(entries: MaybeAsyncIterable<Entry<K, V>>): Promise<void>;
  contains(key: K): Promise<boolean>;
  remove(key: K): Promise<V | undefined>;
  clear(): void;
  keys(): IterableIterator<K>;
  values(): IterableIterator<V>;
-  entries(): IterableIterator<[K, V]>;
+  entries(): IterableIterator<Entry<K, V>>;
 }

 class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
@@ -177,6 +194,12 @@ class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
    return existing;
  }

+  async setAll(entries: MaybeAsyncIterable<Entry<K, V>>) {
+    for await (const [key, value] of entries) {
+      await this.set(key, value);
+    }
+  }
+
  async contains(key: K) {
    return this.#map.has(key);
  }
@@ -209,10 +232,10 @@ class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
 }

 class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
-  readonly #list: [K, V][] = [];
-  readonly #keyComparer: MaybeAsyncEquater<K>;
+  readonly #list: Entry<K, V>[] = [];
+  readonly #keyComparer: MaybeAsyncEqualityComparison<K>;

-  constructor(keyComparer: MaybeAsyncEquater<K>) {
+  constructor(keyComparer: MaybeAsyncEqualityComparison<K>) {
    this.#keyComparer = keyComparer;
  }

@@ -244,6 +267,12 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
    return undefined;
  }

+  async setAll(entries: MaybeAsyncIterable<Entry<K, V>>) {
+    for await (const [key, value] of entries) {
+      await this.set(key, value);
+    }
+  }
+
  async contains(key: K) {
    for (const entry of this.#list) {
      if (await this.#keyComparer(key, entry[0])) {
@@ -287,11 +316,11 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {

  *[Symbol.iterator]() {
    for (const entry of this.#list) {
-      yield entry.slice() as [K, V]; // no entry mutation allowed!
+      yield entry.slice() as Entry<K, V>; // no entry mutation allowed!
    }
  }
 }

-export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEquater<K>): AsyncEqualityMap<K, V> {
+export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparison<K>): AsyncEqualityMap<K, V> {
  return keyComparer ? new CustomAsyncEqualityMap<K, V>(keyComparer) : new NativeAsyncEqualityMap<K, V>();
 }
--- a/src/equality-set.ts
+++ b/src/equality-set.ts
@@ -1,10 +1,12 @@
-import { Equater, MaybeAsyncEquater } from "./types.js";
+import { EqualityComparison, MaybeAsyncEqualityComparison } from "./equality-comparer/types.js";
+import { MaybeAsyncIterable } from "./types.js";

 export interface EqualitySet<T> extends Iterable<T> {
  readonly size: number;
-  add(obj: T): boolean;
-  contains(obj: T): boolean;
-  remove(obj: T): boolean;
+  add(value: T): boolean;
+  addAll(values: Iterable<T>): number;
+  contains(value: T): boolean;
+  remove(value: T): boolean;
  clear(): void;
  values(): IterableIterator<T>;
 }
@@ -16,18 +18,30 @@ class NativeEqualitySet<T> implements EqualitySet<T> {
    return this.#set.size;
  }

-  add(obj: T) {
-    const exists = this.contains(obj);
-    this.#set.add(obj);
+  add(value: T) {
+    const exists = this.contains(value);
+    this.#set.add(value);
    return !exists;
  }

-  contains(obj: T) {
-    return this.#set.has(obj);
+  addAll(values: Iterable<T>) {
+    let result = 0;
+
+    for (const value of values) {
+      if (this.add(value)) {
+        result++;
+      }
+    }
+
+    return result;
  }

-  remove(obj: T) {
-    return this.#set.delete(obj);
+  contains(value: T) {
+    return this.#set.has(value);
+  }
+
+  remove(value: T) {
+    return this.#set.delete(value);
  }

  clear() {
@@ -45,9 +59,9 @@ class NativeEqualitySet<T> implements EqualitySet<T> {

 class CustomEqualitySet<T> implements EqualitySet<T> {
  readonly #list: T[] = [];
-  readonly #equater: Equater<T>;
+  readonly #equater: EqualityComparison<T>;

-  constructor(equater: Equater<T>) {
+  constructor(equater: EqualityComparison<T>) {
    this.#equater = equater;
  }

@@ -55,19 +69,31 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
    return this.#list.length;
  }

-  add(obj: T) {
-    if (this.contains(obj)) {
+  add(value: T) {
+    if (this.contains(value)) {
      return false;
    }

-    this.#list.push(obj);
+    this.#list.push(value);

    return true;
  }

-  contains(obj: T) {
+  addAll(values: Iterable<T>) {
+    let result = 0;
+
+    for (const value of values) {
+      if (this.add(value)) {
+        result++;
+      }
+    }
+
+    return result;
+  }
+
+  contains(value: T) {
    for (const val of this.#list) {
-      if (this.#equater(obj, val)) {
+      if (this.#equater(value, val)) {
        return true;
      }
    }
@@ -75,11 +101,11 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
    return false;
  }

-  remove(obj: T) {
+  remove(value: T) {
    const length = this.#list.length;

    for (let i = 0; i < length; i++) {
-      if (this.#equater(obj, this.#list[i])) {
+      if (this.#equater(value, this.#list[i])) {
        this.#list.splice(i, 1);
        return true;
      }
@@ -93,7 +119,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
  }

  values() {
-    return this[Symbol.iterator]();
+    return this.#list.values();
  }

  [Symbol.iterator]() {
@@ -101,15 +127,16 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
  }
 }

-export function createEqualitySet<T>(equater?: Equater<T>): EqualitySet<T> {
+export function createEqualitySet<T>(equater?: EqualityComparison<T>): EqualitySet<T> {
  return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
 }

 export interface AsyncEqualitySet<T> extends Iterable<T> {
  readonly size: number;
-  add(obj: T): Promise<boolean>;
-  contains(obj: T): Promise<boolean>;
-  remove(obj: T): Promise<boolean>;
+  add(value: T): Promise<boolean>;
+  addAll(values: MaybeAsyncIterable<T>): Promise<number>;
+  contains(value: T): Promise<boolean>;
+  remove(value: T): Promise<boolean>;
  clear(): void;
  values(): IterableIterator<T>;
 }
@@ -121,18 +148,30 @@ class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
    return this.#set.size;
  }

-  async add(obj: T) {
-    const exists = await this.contains(obj);
-    this.#set.add(obj);
+  async add(value: T) {
+    const exists = await this.contains(value);
+    this.#set.add(value);
    return !exists;
  }

-  async contains(obj: T) {
-    return this.#set.has(obj);
+  async addAll(values: MaybeAsyncIterable<T>) {
+    let result = 0;
+
+    for await (const value of values) {
+      if (await this.add(value)) {
+        result++;
+      }
+    }
+
+    return result;
  }

-  async remove(obj: T) {
-    return this.#set.delete(obj);
+  async contains(value: T) {
+    return this.#set.has(value);
+  }
+
+  async remove(value: T) {
+    return this.#set.delete(value);
  }

  clear() {
@@ -150,9 +189,9 @@ class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {

 class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
  readonly #list: T[] = [];
-  readonly #equater: MaybeAsyncEquater<T>;
+  readonly #equater: MaybeAsyncEqualityComparison<T>;

-  constructor(equater: MaybeAsyncEquater<T>) {
+  constructor(equater: MaybeAsyncEqualityComparison<T>) {
    this.#equater = equater;
  }

@@ -160,19 +199,31 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
    return this.#list.length;
  }

-  async add(obj: T) {
-    if (await this.contains(obj)) {
+  async add(value: T) {
+    if (await this.contains(value)) {
      return false;
    }

-    this.#list.push(obj);
+    this.#list.push(value);

    return true;
  }

-  async contains(obj: T) {
+  async addAll(values: MaybeAsyncIterable<T>) {
+    let result = 0;
+
+    for await (const value of values) {
+      if (await this.add(value)) {
+        result++;
+      }
+    }
+
+    return result;
+  }
+
+  async contains(value: T) {
    for (const val of this.#list) {
-      if (await this.#equater(obj, val)) {
+      if (await this.#equater(value, val)) {
        return true;
      }
    }
@@ -180,11 +231,11 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
    return false;
  }

-  async remove(obj: T) {
+  async remove(value: T) {
    const length = this.#list.length;

    for (let i = 0; i < length; i++) {
-      if (await this.#equater(obj, this.#list[i])) {
+      if (await this.#equater(value, this.#list[i])) {
        this.#list.splice(i, 1);
        return true;
      }
@@ -206,6 +257,6 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
  }
 }

-export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEquater<T>): AsyncEqualitySet<T> {
+export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparison<T>): AsyncEqualitySet<T> {
  return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
 }
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,7 @@
-export { BaseSequence, DelegatedSequence } from "./sync/impl.js";
+export { BaseSequence } from "./sync/impl.js";
 export * as Sequences from "./sync/index.js";
 export * from "./sync/types.js";
-export { BaseAsyncSequence, DelegatedAsyncSequence } from "./async/impl.js";
+export { BaseAsyncSequence } from "./async/impl.js";
 export * as AsyncSequences from "./async/index.js";
 export * from "./async/types.js";
 export * as Collectors from "./collector/index.js";
@@ -10,3 +10,10 @@ export * as BitArrays from "./bitarray/index.js";
 export * from "./bitarray/types.js";
 export * as Random from "./random/index.js";
 export * from "./random/types.js";
+export { BaseComparer } from "./comparer/sync.js";
+export * as Comparers from "./comparer/sync.js";
+export { BaseAsyncComparer } from "./comparer/async.js";
+export * as AsyncComparers from "./comparer/async.js";
+export * from "./comparer/types.js";
+export * as EqualityComparers from "./equality-comparer/index.js";
+export * from "./equality-comparer/types.js";
--- a/src/random/index.ts
+++ b/src/random/index.ts
@@ -1,5 +1,4 @@
-import { create as createBitArray } from "../bitarray/index.js";
-import { BitArray } from "../bitarray/types.js";
+import { BitArray } from "../bitarray/index.js";
 import { asArray } from "../utils.js";
 import { AsyncRandomOptions, ElementPredicate, ElementWeight, RandomGenerator, RandomOptions } from "./types.js";

@@ -121,7 +120,7 @@ export class RandomPicker<T> {

  public constructor(elements: Iterable<T>, length: number, options?: RandomOptions<T>) {
    this.#elements = elements;
-    this.#flags = createBitArray(length);
+    this.#flags = BitArray.create(length);
    this.#options = withDefaultOptions(mergeOptions({ predicate: i => this.#flags.get(i) }, options));

    this.reset();
--- a/src/sorting.ts
+++ b/src/sorting.ts
@@ -1,8 +1,8 @@
-import { MaybeAsyncComparer } from "./types.js";
-import { reverseAsyncComparer } from "./utils.js";
+import { asAsyncComparer } from "./comparer/async.js";
+import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "./comparer/types.js";

 export interface AsyncSorter {
-  sort<T>(array: T[], descending: boolean, comparer: MaybeAsyncComparer<T>): Promise<void>;
+  sort<T>(array: T[], descending: boolean, comparer: MaybeAsyncComparisonOrComparer<T>): Promise<void>;
 }

 function swap(array: any[], i: number, j: number) {
@@ -12,20 +12,26 @@ function swap(array: any[], i: number, j: number) {
 }

 abstract class BaseAsyncSorter implements AsyncSorter {
-  async sort<T>(array: T[], descending: boolean, comparer: MaybeAsyncComparer<T>) {
-    await this._sort(array, descending ? reverseAsyncComparer(comparer) : comparer);
+  async sort<T>(array: T[], descending: boolean, comparer: MaybeAsyncComparisonOrComparer<T>) {
+    comparer = asAsyncComparer(comparer);
+
+    if (descending) {
+      comparer = comparer.reverse();
+    }
+
+    await this._sort(array, comparer);
  }

-  protected abstract _sort<T>(array: T[], comparer: MaybeAsyncComparer<T>): Promise<void>;
+  protected abstract _sort<T>(array: T[], comparer: AsyncComparer<T>): Promise<void>;
 }

-class InsertionSorter extends BaseAsyncSorter {
-  protected override async _sort<T>(array: T[], comparer: MaybeAsyncComparer<T>) {
+export const insertionSorter: AsyncSorter = new class InsertionSorter extends BaseAsyncSorter {
+  protected override async _sort<T>(array: T[], comparer: AsyncComparer<T>) {
    for (let i = 1; i < array.length; i++) {
      const obj = array[i];

      for (let j = i - 1; j >= 0; j--) {
-        if (await comparer(obj, array[j]) < 0) {
+        if (await comparer.compare(obj, array[j]) < 0) {
          for (let k = i; k > j; k--) {
            swap(array, k - 1, k);
          }
@@ -35,10 +41,10 @@ class InsertionSorter extends BaseAsyncSorter {
      }
    }
  }
-}
+};

-class SelectionSorter extends BaseAsyncSorter {
-  protected async _sort<T>(array: T[], comparer: MaybeAsyncComparer<T>) {
+export const selectionSorter: AsyncSorter = new class SelectionSorter extends BaseAsyncSorter {
+  protected async _sort<T>(array: T[], comparer: AsyncComparer<T>) {
    for (let i = 0; i < array.length; i++) {
      let smallest = array[i];
      let smallestIndex = i;
@@ -46,7 +52,7 @@ class SelectionSorter extends BaseAsyncSorter {
      for (let j = i; j < array.length; j++) {
        const current = array[j];

-        if (await comparer(current, smallest) < 0) {
+        if (await comparer.compare(current, smallest) < 0) {
          smallest = current;
          smallestIndex = j;
        }
@@ -57,10 +63,10 @@ class SelectionSorter extends BaseAsyncSorter {
      }
    }
  }
-}
+};

-class BubbleSorter extends BaseAsyncSorter {
-  protected async _sort<T>(array: T[], comparer: MaybeAsyncComparer<T>) {
+export const bubbleSorter: AsyncSorter = new class BubbleSorter extends BaseAsyncSorter {
+  protected async _sort<T>(array: T[], comparer: AsyncComparer<T>) {
    const length = array.length;

    for (let k = length - 2; k >= 0; k--) {
@@ -70,7 +76,7 @@ class BubbleSorter extends BaseAsyncSorter {
        const j = i + 1;
        const a = array[i], b = array[j];

-        if (await comparer(a, b) > 0) {
+        if (await comparer.compare(a, b) > 0) {
          swap(array, i, j);
          hasSwaped = true;
        }
@@ -81,8 +87,4 @@ class BubbleSorter extends BaseAsyncSorter {
      }
    }
  }
-}
-
-export const insertionSorter: AsyncSorter = new InsertionSorter();
-export const selectionSorter: AsyncSorter = new SelectionSorter();
-export const bubbleSorter: AsyncSorter = new BubbleSorter();
+};
--- a/src/sync/impl.ts
+++ b/src/sync/impl.ts
--- a/src/sync/index.ts
+++ b/src/sync/index.ts
@@ -1,6 +1,6 @@
 import { mathRandom } from "../random/index.js";
 import { RandomGenerator } from "../random/types.js";
-import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedReadonlyArray, EMPTY } from "./impl.js";
+import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedArray, EMPTY, ZippedSequence } from "./impl.js";
 import { Sequence } from "./types.js";

 export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
@@ -36,7 +36,7 @@ export function single<T>(obj: T): Sequence<T> {
 }

 export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
-  return new WrappedReadonlyArray(array);
+  return new WrappedArray(array);
 }

 export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
@@ -74,6 +74,10 @@ export function keys(o: object): Sequence<string> {
  return array(Object.keys(o));
 }

+export function values(o: object): Sequence<any> {
+  return array(Object.values(o));
+}
+
 export function func<T>(f: () => T): Sequence<T> {
  return new FunctionSequence(f);
 }
@@ -138,8 +142,12 @@ export function randomSequence(random?: RandomGenerator): Sequence<number> {
  return new FunctionSequence(random ?? mathRandom);
 }

-export function concat<T>(...sequences: Sequence<T>[]): Sequence<T> {
-  return new ConcatSequence(sequences);
+export function concat<T>(...sequences: Iterable<T>[]): Sequence<T> {
+  return new ConcatSequence(sequences.map(wrap));
+}
+
+export function zip<T>(first: Sequence<T>, second: Sequence<T>): Sequence<[T, T]> {
+  return new ZippedSequence(first, second);
 }

 export function isSequence<T = any>(obj: any): obj is Sequence<T> {
--- a/src/sync/types.ts
+++ b/src/sync/types.ts
@@ -1,7 +1,9 @@
 import { AsyncSequence } from "../async/types.js";
 import { Collector } from "../collector/types.js";
+import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
+import { EqualityComparison } from "../equality-comparer/types.js";
 import { RandomOptions } from "../random/types.js";
-import { AnyPredicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
+import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";

 export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult;

@@ -18,31 +20,31 @@ export interface Sequence<TElement> extends Iterable<TElement> {
  maxCount(): number;

  select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
-  selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>): Sequence<TResult>;
+  selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Sequence<TResult>;

-  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
+  where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
  where(predicate: AnyPredicate<TElement>): Sequence<TElement>;

-  groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
+  groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
+  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>>;

-  join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
-  join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
+  join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<[TElement, TOther]>;
+  join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>;

-  groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
+  groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
+  groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>;

-  contains(obj: TElement, equater?: Equater<TElement>): boolean;
+  contains(obj: TElement, equater?: EqualityComparison<TElement>): boolean;

-  sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>): boolean;
+  sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): boolean;

  append(obj: TElement): Sequence<TElement>;

  prepend(obj: TElement): Sequence<TElement>;

-  remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement>;
+  remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement>;

-  concat(...sequences: Sequence<TElement>[]): Sequence<TElement>;
+  concat(...sequences: Iterable<TElement>[]): Sequence<TElement>;

  first(predicate?: AnyPredicate<TElement>): TElement;
  firstOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
@@ -60,32 +62,35 @@ export interface Sequence<TElement> extends Iterable<TElement> {
  aggregate<TAccumulator>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator): TAccumulator;
  aggregate<TAccumulator, TResult>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: Converter<TAccumulator, TResult>): TResult;

-  min(comparer?: Comparer<TElement>): TElement;
-  minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;
+  min(comparer?: ComparisonOrComparer<TElement>): TElement;
+  minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): TElement;

-  max(comparer?: Comparer<TElement>): TElement;
-  maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;
+  max(comparer?: ComparisonOrComparer<TElement>): TElement;
+  maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): TElement;

-  order(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
-  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
+  bounds(comparer?: ComparisonOrComparer<TElement>): [min: TElement, max: TElement];
+  boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): [min: TElement, max: TElement];

-  orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
-  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
+  order(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
+  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;

-  partition(equater?: Equater<TElement>): Sequence<Sequence<TElement>>;
-  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<Sequence<TElement>>;
+  orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
+  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;

-  distinct(equater?: Equater<TElement>): Sequence<TElement>;
-  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>>;
+  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>>;

-  union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
-  unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  distinct(equater?: EqualityComparison<TElement>): Sequence<TElement>;
+  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;

-  except(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
-  exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
+  unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;

-  intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
-  intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
+  exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
+
+  intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
+  intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;

  all(predicate: AnyPredicate<TElement>): boolean;
  any(predicate: AnyPredicate<TElement>): boolean;
@@ -105,14 +110,15 @@ export interface Sequence<TElement> extends Iterable<TElement> {

  forEach(action: Action<TElement>): void;

-  zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]>;
+  zip<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;

  indexed(): Sequence<[number, TElement]>;

  reversed(): Sequence<TElement>;

-  chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
+  chunked(size: number): Sequence<Sequence<TElement>>;
  chunked(size: number, asArray: true): Sequence<TElement[]>;
+  chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;

  random(options?: RandomOptions<TElement>): TElement | undefined;

@@ -136,13 +142,13 @@ export interface GroupedSequence<TKey, TElement> extends Sequence<TElement> {
 }

 export interface OrderedSequence<TElement> extends Sequence<TElement> {
-  get comparer(): Comparer<TElement> | undefined;
+  get comparer(): Comparer<TElement>;

-  thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
+  thenSelf(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;

-  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
+  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;

-  thenSelfDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
+  thenSelfDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;

-  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
+  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;
 }
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,15 +1,10 @@
-import { AsyncSequence } from "./async/types.js";
-import { Sequence } from "./sync/types.js";
-
 export type Predicate<T> = (obj: T) => boolean;
 export type AnyPredicate<T> = (obj: T) => unknown;
-export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
+export type TypePredicate<TElement, TType extends TElement> = (obj: TElement) => obj is TType;
 export type Converter<TFrom, TTo> = (obj: TFrom) => TTo;
 export type BiConverter<TFromFirst, TFromSecond, TTo> = (first: TFromFirst, second: TFromSecond) => TTo;
-export type Action<T> = (obj: T) => void;
+export type Action<T> = (obj: T) => unknown;
 export type Accumulator<TElement, TAccumulator> = (acc: TAccumulator, obj: TElement) => TAccumulator;
-export type Comparer<T> = (first: T, second: T) => number;
-export type Equater<T> = (first: T, second: T) => boolean;

 export type MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
 export type MaybeAsyncIterator<T> = Iterator<T> | AsyncIterator<T>;
@@ -18,12 +13,13 @@ export type AsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (
 export type MaybePromise<T> = T | Promise<T>;
 export type MaybePromiseLike<T> = T | PromiseLike<T>;
 export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => MaybePromise<R> : never;
-export type MaybeAsyncSequence<T> = Sequence<T> | AsyncSequence<T>;

 export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
 export type AsyncAnyPredicate<T> = AsyncFunction<AnyPredicate<T>>;
+export type AsyncTypePredicate<TElement, TType extends TElement> = AsyncFunction<TypePredicate<TElement, TType>>;
 export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;
 export type MaybeAsyncAnyPredicate<T> = MaybeAsyncFunction<AnyPredicate<T>>;
+export type MaybeAsyncTypePredicate<TElement, TType extends TElement> = MaybeAsyncFunction<TypePredicate<TElement, TType>>;
 export type AsyncConverter<TFrom, TTo> = AsyncFunction<Converter<TFrom, TTo>>;
 export type MaybeAsyncConverter<TFrom, TTo> = MaybeAsyncFunction<Converter<TFrom, TTo>>;
 export type AsyncBiConverter<TFromFirst, TFromSecond, TTo> = AsyncFunction<BiConverter<TFromFirst, TFromSecond, TTo>>;
@@ -32,7 +28,4 @@ export type AsyncAction<T> = AsyncFunction<Action<T>>;
 export type MaybeAsyncAction<T> = MaybeAsyncFunction<Action<T>>;
 export type AsyncAccumulator<TElement, TAccumulator> = AsyncFunction<Accumulator<TElement, TAccumulator>>;
 export type MaybeAsyncAccumulator<T, U> = MaybeAsyncFunction<Accumulator<T, U>>;
-export type AsyncComparer<T> = AsyncFunction<Comparer<T>>;
-export type MaybeAsyncComparer<T> = MaybeAsyncFunction<Comparer<T>>;
-export type AsyncEquater<T> = AsyncFunction<Equater<T>>;
-export type MaybeAsyncEquater<T> = MaybeAsyncFunction<Equater<T>>;
+
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,95 +1,17 @@
-import { Comparer, MaybeAsyncComparer, AsyncComparer, MaybeAsyncIterator } from "./types.js";
+export type Nullable<T> = T | null | undefined;

 export function isDefined<T = any>(obj: T): obj is NonNullable<T> {
  return obj !== undefined && obj !== null;
 }

-export function isIterable<T = any>(obj: any): obj is Iterable<T> {
-  return isDefined(obj) && typeof obj[Symbol.iterator] === "function";
-}
-
 export function isAsyncIterable<T = any>(obj: any): obj is AsyncIterable<T> {
  return isDefined(obj) && typeof obj[Symbol.asyncIterator] === "function";
 }

-export function identity<T>(obj: T) {
-  return obj;
-}
-
-export function looseEquals<T>(a: T, b: T) {
-  return a == b;
-}
-
-export function strictEquals<T>(a: T, b: T) {
-  return a === b;
-}
-
-export function referenceEquals<T>(a: T, b: T) {
-  return Object.is(a, b);
-}
-
-export function numberCompare<T extends number | bigint>(a: T, b: T) {
-  return a - b;
-}
-
-export function operatorCompare(a: any, b: any) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
-export function defaultArrayComparer<T>(a: T, b: T) {
-  if (a === undefined) {
-    if (b === undefined) {
-      return 0;
-    }
-
-    return 1;
-  }
-
-  if (b === undefined) {
-    return -1;
-  }
-
-  const aStr = `${a}`, bStr = `${b}`;
-
-  return aStr > bStr ? 1 : aStr < bStr ? -1 : 0;
-}
-
-export function combineComparers<T>(first: Comparer<T>, second: Comparer<T>): Comparer<T> {
-  return (a, b) => first(a, b) || second(a, b);
-}
-
-export function combineAsyncComparers<T>(first: MaybeAsyncComparer<T>, second: MaybeAsyncComparer<T>): AsyncComparer<T> {
-  return async (a, b) => await first(a, b) || await second(a, b);
-}
-
-export function reverseComparer<T>(comparer: Comparer<T>): Comparer<T> {
-  return (a, b) => comparer(b, a);
-}
-
-export function reverseAsyncComparer<T>(comparer: MaybeAsyncComparer<T>): AsyncComparer<T> {
-  return async (a, b) => await comparer(b, a);
-}
-
 export function asArray<T>(iterable: Iterable<T>) {
  return Array.isArray(iterable) ? <T[]>iterable : Array.from(iterable);
 }

-class WrappedIterator<T> implements Iterable<T> {
-  readonly #iterator: Iterator<T>;
-
-  constructor(iterator: Iterator<T>) {
-    this.#iterator = iterator;
-  }
-
-  [Symbol.iterator]() {
-    return this.#iterator;
-  }
-}
-
-export function asIterable<T>(iterator: Iterator<T>): Iterable<T> {
-  return isIterable<T>(iterator) ? iterator : new WrappedIterator(iterator);
-}
-
 class WrappedAsyncIterator<T> implements AsyncIterable<T> {
  readonly #iterator: AsyncIterator<T>;

@@ -115,15 +37,26 @@ const _emptyIterableIterator = new class EmptyIterableIterator implements Iterab
    return { done: true, value: undefined };
  }

-  return(value?: any): IteratorResult<any, any> {
+  return(_value?: any): IteratorResult<any, any> {
    throw new Error("Method not implemented.");
  }

-  throw(e?: any): IteratorResult<any, any> {
+  throw(_e?: any): IteratorResult<any, any> {
    throw new Error("Method not implemented.");
  }
-}
+};

 export function emptyIterableIterator<T>(): IterableIterator<T> {
  return _emptyIterableIterator;
 }
+
+type FindElementSuccess<T> = {
+  found: true;
+  element: T;
+};
+type FindElementFail = {
+  found: false;
+  element?: never;
+  reason?: number;
+};
+export type FindElementResult<T> = FindElementSuccess<T> | FindElementFail;
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,8 +1,8 @@
 {
  "compilerOptions": {
-    "module": "Node16",
-    "target": "ES2023",
-    "moduleResolution": "Node16",
+    "module": "NodeNext",
+    "target": "ESNext",
+    "moduleResolution": "nodenext",
    "rootDir": "src",
    "outDir": "build",
    "outFile": "build/index.ts",
@@ -13,7 +13,8 @@
    "allowUnreachableCode": true,
    "declaration": true,
    "declarationMap": true,
-    "emitDeclarationOnly": true
+    "emitDeclarationOnly": true,
+    "composite": true
  },
  "include": [
    "src"
Author	SHA1	Message	Date
Hervé BECHER	afa56b7adf	improve typing of element finding utils	2025-05-24 13:22:09 +02:00
Hervé BECHER	1f7c246faf	move BitArray in its namerspace	2025-05-24 13:21:23 +02:00
Herve BECHER	0fd0e3bada	sync	2025-05-24 12:11:44 +02:00
Herve BECHER	e5e6bffe1e	sync	2024-10-14 07:38:23 +02:00