sindresorhus · benzaria · May 26, 2025 · Jun 1, 2025 · Jun 1, 2025 · Jun 3, 2025
diff --git a/source/array-reverse.d.ts b/source/array-reverse.d.ts
@@ -0,0 +1,6 @@
+import type {UnknownArray} from './unknown-array.d.ts';
+
+export type ArrayReverse<Array_ extends UnknownArray> =
+	Array_ extends [...infer Head, infer Tail]
+		? [Tail, ...ArrayReverse<Head>]
+		: [];
diff --git a/source/array-splice.d.ts b/source/array-splice.d.ts
@@ -55,7 +55,7 @@ type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
 // type B = [[], [1, 2, 3, 4]];
 ```
 */
-type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
+export type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
 	SplitIndex extends 0
 		? [[], T]
 		: number extends T['length']

diff --git a/source/count-of.d.ts b/source/count-of.d.ts
@@ -0,0 +1,7 @@
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {AllIndexOf} from './index-of.d.ts';
+
+export type CountOf<Array_ extends UnknownArray, Item, FromIndex extends number = 0> =
+	AllIndexOf<Array_, Item, FromIndex> extends infer Indexs extends number[]
+		? Indexs['length']
+		: 0;
diff --git a/source/includes.d.ts b/source/includes.d.ts
@@ -1,4 +1,5 @@
-import type {IsEqual} from './is-equal.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {IndexOf} from './index-of.d.ts';
 
 /**
 Returns a boolean for whether the given array includes the given item.
@@ -14,9 +15,5 @@ type hasRed<array extends any[]> = Includes<array, 'red'>;
 
 @category Array
 */
-export type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
+export type Includes<Array_ extends UnknownArray, Item, FromIndex extends number = 0> =
+	IndexOf<Array_, Item, FromIndex> extends -1 ? false : true;
diff --git a/source/index-of.d.ts b/source/index-of.d.ts
@@ -0,0 +1,60 @@
+import type {SplitArrayByIndex} from './array-splice.d.ts';
+import type {SubtractPositives} from './subtract.d.ts';
+import type {ArrayReverse} from './array-reverse.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {SumPositives} from './sum.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+
+/**
+Simpler version of Sum<T, 1>, without the extra logic.
+*/
+export type Increment<T extends number> = SumPositives<T, 1>;
+
+type _IndexOf<
+	Array_ extends UnknownArray, Item,
+	FromIndex extends number = 0,
+	Index extends number = 0,
+> = (
+	Array_ extends readonly [infer Head, ...infer Tail]
+		? IsEqual<Head, Item> extends true
+			? SumPositives<Index, FromIndex>
+			: _IndexOf<Tail, Item, FromIndex, Increment<Index>>
+		: -1 // Same as `indexOf`
+);
+
+type _AllIndexOf<
+	Array_ extends UnknownArray, Item,
+	FromIndex extends number = 0,
+	Indexs extends number[] = [],
+> = (
+	IndexOf<Array_, Item, FromIndex> extends infer Index extends number
+		? Index extends -1
+			? Indexs
+			: _AllIndexOf<Array_, Item, Increment<Index>, [...Indexs, Index]>
+		: never
+);
+
+// TODO: Add `ToIndex` parameter
+export type IndexOf<
+	Array_ extends UnknownArray, Item,
+	FromIndex extends number = 0,
+> = _IndexOf<SplitArrayByIndex<Array_, FromIndex>[1], Item, FromIndex>;
+//	 Return's never If `FromIndex > ArrayLength`
+
+// TODO: Add `ToIndex` parameter
+export type AllIndexOf<
+	Array_ extends UnknownArray, Item,
+	FromIndex extends number = 0,
+> = _AllIndexOf<Array_, Item, FromIndex>;
+
+// TODO: Add `ToIndex` parameter
+export type LastIndexOf<
+	Array_ extends UnknownArray, Item,
+	FromIndex extends number = 0,
+> = (
+	IndexOf<ArrayReverse<Array_>, Item, FromIndex> extends infer Index extends number
+		? Index extends -1
+			? -1
+			: SubtractPositives<Array_['length'], Increment<Index>>
+		: never
+);
diff --git a/source/internal/type.d.ts b/source/internal/type.d.ts
@@ -1,7 +1,8 @@
-import type {If} from '../if.d.ts';
-import type {IsAny} from '../is-any.d.ts';
-import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {IsAny} from '../is-any.d.ts';
+import type {Or} from '../or.d.ts';
+import type {If} from '../if.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -13,6 +14,13 @@ Matches non-recursive types.
 */
 export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 
+/**
+ * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
+ * 1. If either type is `never`, the result is `true` iff the other type is also `never`.
+ * 2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends<string | number, number>` => `false | true` => `boolean`.
+ */
+export type Extends<Left, Right> = IsNever<Left> extends true ? IsNever<Right> : [Left] extends [Right] ? true : false;
+
 /**
 Returns a boolean for whether the two given types extends the base type.
 */
@@ -40,9 +48,19 @@ export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknow
 		: false;
 
 /**
-Returns a boolean for whether the given `boolean` is not `false`.
+Returns a boolean for whether the given `boolean` Union containe's `false`.
 */
-export type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+export type IsNotFalse<T extends boolean> = Not<IsFalse<T>>;
+
+/**
+Returns a boolean for whether the given `boolean` Union members are all `true`.
+*/
+export type IsTrue<T extends boolean> = Extends<T, true>;
+
+/**
+Returns a boolean for whether the given `boolean` Union members are all `false`.
+*/
+export type IsFalse<T extends boolean> = Extends<T, false>;
 
 /**
 Returns a boolean for whether the given type is primitive value or primitive type.
@@ -59,7 +77,7 @@ IsPrimitive<Object>
 //=> false
 ```
 */
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
+export type IsPrimitive<T> = Extends<T, Primitive>;
 
 /**
 Returns a boolean for whether A is false.
@@ -99,3 +117,8 @@ type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 */
 export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
 	If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+
+/**
+Determines if a type is either `never` or `any`.
+*/
+export type IsAnyOrNever<T> = Or<IsAny<T>, IsNever<T>>;
diff --git a/source/subtract.d.ts b/source/subtract.d.ts
@@ -67,7 +67,7 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNeg
 /**
 Subtracts two positive numbers.
 */
-type SubtractPositives<A extends number, B extends number> =
+export type SubtractPositives<A extends number, B extends number> =
 	LessThan<A, B> extends true
 		// When A < B we can reverse the result of B - A
 		? ReverseSign<SubtractIfAGreaterThanB<B, A>>

diff --git a/source/sum.d.ts b/source/sum.d.ts
@@ -72,7 +72,7 @@ type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative
 /**
 Adds two positive numbers.
 */
-type SumPositives<A extends number, B extends number> =
+export type SumPositives<A extends number, B extends number> =
 	[...BuildTuple<A>, ...BuildTuple<B>]['length'] extends infer Result extends number
 		? Result
 		: never;