diff --git a/src/async.ts b/src/async.ts
index 77e5909..8c5438c 100644
--- a/src/async.ts
+++ b/src/async.ts
@@ -1,32 +1,11 @@
-import { Accumulator, Action, BiConverter, Comparer, Converter, Enumerable, Equater, Predicate } from "./sync.js";
-import { AsyncFunction, MaybeAsyncFunction, MaybePromise, asAsyncGenerator, combineAsyncComparers, defaultArrayComparer, identity, isAsyncIterable, operatorCompare, strictEquals } from "./utils.js";
+import { Enumerable } from "./sync.js";
+import { asAsyncGenerator, combineAsyncComparers, defaultArrayComparer, identity, isAsyncIterable, operatorCompare, strictEquals } from "./utils.js";
 import { createQueue } from "./queue.js";
 import { selectionSorter } from "./sorting.js";
 import { createAsyncEqualitySet } from "./equality-set.js";
 import { createAsyncEqualityMap } from "./equality-map.js";
 import { Collector } from "./collector.js";
-
-//#region types
-
-export type MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
-export type MaybeAsyncIterator<T> = Iterator<T> | AsyncIterator<T>;
-
-export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
-export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;
-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>>;
-export type MaybeAsyncBiConverter<TFromFirst, TFromSecond, TTo> = MaybeAsyncFunction<BiConverter<TFromFirst, TFromSecond, TTo>>;
-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>>;
-
-//#endregion
+import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction, MaybePromise } from "./types.js";
 
 //#region interfaces
 
@@ -1293,15 +1272,7 @@ abstract class BaseOrderedAsyncEnumerable<TElement> extends BaseAsyncEnumerable<
       arr.push(obj);
     }
 
-    //if (this.#sorter) {
     await selectionSorter.sort(arr, this.#descending, this.#sorter);
-    //} else {
-    //  arr.sort();
-
-    //  if (this.#descending) {
-    //    arr.reverse();
-    //  }
-    //}
 
     yield* arr;
   }
@@ -1504,6 +1475,18 @@ class WrappedEnumerable<T> extends BaseAsyncEnumerable<T> {
     return this.#enumerable.nonEnumeratedCount();
   }
 
+  override async fastCount() {
+    return this.#enumerable.fastCount();
+  }
+
+  override async maxCount() {
+    return this.#enumerable.maxCount();
+  }
+
+  override async asArray() {
+    return this.#enumerable.asArray();
+  }
+
   override async *iterator() {
     yield* this.#enumerable;
   }
diff --git a/src/bitarray.ts b/src/bitarray.ts
index 1aef86f..18ff3a9 100644
--- a/src/bitarray.ts
+++ b/src/bitarray.ts
@@ -1,6 +1,6 @@
 import { Collector } from "./collector.js";
 import { Enumerable } from "./sync.js";
-import { asArray, isDefined } from "./utils.js";
+import { asArray } from "./utils.js";
 
 export interface BitArray extends Iterable<boolean> {
   readonly length: number;
@@ -251,7 +251,7 @@ class BitArrayImpl implements BitArray {
   }
 
   public equals(other: BitArray) {
-    return other === this || isDefined(other) && (other instanceof BitArrayImpl ? Enumerable.arrayLike(this.#bits).sequenceEquals(Enumerable.arrayLike(other.#bits)) : Enumerable.sequence(this).sequenceEquals(Enumerable.sequence(other)));
+    return other === this || other && (other instanceof BitArrayImpl ? Enumerable.arrayLike(this.#bits).sequenceEquals(Enumerable.arrayLike(other.#bits)) : Enumerable.sequence(this).sequenceEquals(Enumerable.sequence(other)));
   }
 
   public toString() {
@@ -493,7 +493,7 @@ class BitArraySlice implements BitArray {
   }
 
   public equals(other: BitArray) {
-    return other === this || isDefined(other) && Enumerable.sequence(this).sequenceEquals(Enumerable.sequence(other));
+    return other === this || other && Enumerable.sequence(this).sequenceEquals(Enumerable.sequence(other));
   }
 
   public toString() {
diff --git a/src/collector.ts b/src/collector.ts
index 3b5b736..4d85630 100644
--- a/src/collector.ts
+++ b/src/collector.ts
@@ -1,4 +1,4 @@
-import { Converter } from "./sync.js";
+import { Converter } from "./types.js";
 
 export interface Collector<TElement, TAccumulator, TResult> {
   initialize(): TAccumulator;
diff --git a/src/equality-map.ts b/src/equality-map.ts
index f03a447..32cc76c 100644
--- a/src/equality-map.ts
+++ b/src/equality-map.ts
@@ -1,5 +1,4 @@
-import { Equater } from "./sync.js";
-import { MaybeAsyncEquater } from "./async.js";
+import { Equater, MaybeAsyncEquater } from "./types.js";
 import { asAsyncGenerator } from "./utils.js";
 
 export interface EqualityMap<K, V> extends Iterable<[K, V]> {
diff --git a/src/equality-set.ts b/src/equality-set.ts
index c905b7d..34e30b3 100644
--- a/src/equality-set.ts
+++ b/src/equality-set.ts
@@ -1,5 +1,4 @@
-import { Equater } from "./sync.js";
-import { MaybeAsyncEquater } from "./async.js";
+import { Equater, MaybeAsyncEquater } from "./types.js";
 import { asAsyncGenerator } from "./utils.js";
 
 export interface EqualitySet<T> extends Iterable<T> {
diff --git a/src/index.ts b/src/index.ts
index 5edb951..d70b577 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,4 +1,4 @@
-export * from "./sync.js";
-export * from "./async.js";
-export * from "./collector.js";
-export * from "./random.js";
+export { BaseEnumerable, Enumerable, GroupedEnumerable, OrderedEnumerable } from "./sync.js";
+export { AsyncEnumerable, BaseAsyncEnumerable, GroupedAsyncEnumerable, OrderedAsyncEnumerable } from "./async.js";
+export { Collector } from "./collector.js";
+export { Random, RandomOptions } from "./random.js";
diff --git a/src/sorting.ts b/src/sorting.ts
index a0af305..1147b81 100644
--- a/src/sorting.ts
+++ b/src/sorting.ts
@@ -1,4 +1,4 @@
-import { MaybeAsyncComparer } from "./async.js";
+import { MaybeAsyncComparer } from "./types.js";
 import { reverseAsyncComparer } from "./utils.js";
 
 export interface AsyncSorter {
diff --git a/src/sync.ts b/src/sync.ts
index 92ade93..0c9f6ea 100644
--- a/src/sync.ts
+++ b/src/sync.ts
@@ -4,15 +4,7 @@ import { RandomGenerator, RandomOptions, Random } from "./random.js";
 import { createQueue } from "./queue.js";
 import { Collector } from "./collector.js";
 import { combineComparers, defaultArrayComparer, identity, operatorCompare, reverseComparer, strictEquals, wrapAsIterable } from "./utils.js";
-
-export type Predicate<T> = (obj: T) => boolean;
-export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
-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 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;
+import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "./types.js";
 
 export interface Enumerable<TElement> extends Iterable<TElement> {
   iterator(): Iterator<TElement>;
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..9a0677a
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,30 @@
+export type Predicate<T> = (obj: T) => boolean;
+export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
+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 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>;
+
+export type AsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => Promise<Awaited<R>> : never;
+export type MaybePromise<T> = T | Promise<T>;
+export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => MaybePromise<R> : never;
+
+export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
+export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;
+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>>;
+export type MaybeAsyncBiConverter<TFromFirst, TFromSecond, TTo> = MaybeAsyncFunction<BiConverter<TFromFirst, TFromSecond, TTo>>;
+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>>;
diff --git a/src/utils.ts b/src/utils.ts
index 948da10..6be9f69 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,9 +1,4 @@
-import { AsyncComparer, MaybeAsyncComparer, MaybeAsyncIterator } from "./async.js";
-import { Comparer } from "./sync.js";
-
-export type AsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => Promise<Awaited<R>> : never;
-export type MaybePromise<T> = T | Promise<T>;
-export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => MaybePromise<R> : never;
+import { Comparer, MaybeAsyncComparer, AsyncComparer, MaybeAsyncIterator } from "./types.js";
 
 export function isDefined<T = any>(obj: T): obj is NonNullable<T> {
   return obj !== undefined && obj !== null;