type-plus 7.6.0 → 8.0.0-beta.0

package/ts/array/array.some.ts

@@ -23,7 +23,7 @@ import type { UnionOfValues } from './union_of_values.js'
  * ```
  */
 export type Some<
-	A extends any[],
+	A extends readonly unknown[],
 	Criteria,
 	Mode extends 'strict' | 'loose' = 'loose',
 	Then = true,
@@ -31,37 +31,37 @@ export type Some<
 > = Mode extends 'strict' ? Some.Strict<A, Criteria, Then, Else> : Some.Loose<A, Criteria, Then, Else>
 
 export namespace Some {
-	export type Strict<A extends unknown[], Criteria, Then, Else> = number extends A['length']
+	export type Strict<A extends readonly unknown[], Criteria, Then, Else> = number extends A['length']
 		? StrictArray<A, Criteria, Then, Else>
 		: StrictTuple<A, Criteria, Then, Else>
 
-	export type StrictArray<A extends unknown[], Criteria, Then, Else> = IsEqual<
+	export type StrictArray<A extends readonly unknown[], Criteria, Then, Else> = IsEqual<
 		UnionOfValues<A>,
 		Criteria,
 		Then,
 		Else
 	>
 
-	export type StrictTuple<A extends unknown[], Criteria, Then, Else> = A['length'] extends 0
+	export type StrictTuple<A extends readonly unknown[], Criteria, Then, Else> = A['length'] extends 0
 		? Else
-		: IsEqual<A[0], Criteria> extends true
-		? Then
-		: StrictTuple<Tail<A>, Criteria, Then, Else>
+		: (IsEqual<A[0], Criteria> extends true
+			? Then
+			: StrictTuple<Tail<A>, Criteria, Then, Else>)
 
-	export type Loose<A extends unknown[], Criteria, Then, Else> = number extends A['length']
+	export type Loose<A extends readonly unknown[], Criteria, Then, Else> = number extends A['length']
 		? LooseArray<A, Criteria, Then, Else>
 		: LooseTuple<A, Criteria, Then, Else>
 
-	export type LooseArray<A extends unknown[], Criteria, Then, Else> = CanAssign<
+	export type LooseArray<A extends readonly unknown[], Criteria, Then, Else> = CanAssign<
 		UnionOfValues<A>,
 		Criteria,
 		Then,
 		Else
 	>
 
-	export type LooseTuple<A extends unknown[], Criteria, Then, Else> = A['length'] extends 0
+	export type LooseTuple<A extends readonly unknown[], Criteria, Then, Else> = A['length'] extends 0
 		? Else
-		: A[0] extends Criteria
-		? Then
-		: LooseTuple<Tail<A>, Criteria, Then, Else>
+		: (A[0] extends Criteria
+			? Then
+			: LooseTuple<Tail<A>, Criteria, Then, Else>)
 }

package/ts/array/array_plus.common_prop_keys.ts

@@ -15,15 +15,15 @@ import type { KeyTypes } from '../object/KeyTypes.js'
  * type R = ArrayPlus.CommonPropKeys<Array<{ a: 1, b: 1 } | { a: 1, c: 1 }>> // 'a'
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  */
 export type CommonPropKeys<
-	A extends Record<KeyTypes, unknown>[],
+	A extends readonly Record<KeyTypes, unknown>[],
 	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
 > = NeverType<A,
-	Options['caseNever'],
-	A extends Array<infer R extends Record<KeyTypes, unknown>> ? keyof R : never
+	Options['$never'],
+	A extends Readonly<Array<infer R extends Record<KeyTypes, unknown>>> ? keyof R : never
 >
 
 export namespace CommonPropKeys {

package/ts/array/array_plus.concat.ts

@@ -12,4 +12,4 @@
  * type R = Concat<[1], [2, 3]> // [1, 2, 3]
  * ```
  */
-export type Concat<A extends unknown[], B extends unknown[]> = [...A, ...B]
+export type Concat<A extends Readonly<unknown[]>, B extends Readonly<unknown[]>> = [...A, ...B]

package/ts/array/array_plus.drop_match.ts

@@ -1,6 +1,9 @@
 import type { NonNull } from '../utils/NonNull.js'
 import type { NonUndefined } from '../utils/NonUndefined.js'
 
+/**
+ * ⚗️ *transform*
+ */
 export type DropMatch<A extends Readonly<Array<unknown>>, Criteria> = A[0] extends Criteria
 	? never[]
 	: (undefined extends Criteria

package/ts/array/array_plus.element_match.ts

@@ -1,6 +1,6 @@
 import type { IsNever } from '../never/never_type.js'
 import type { IsUnion } from '../union/union.js'
-import type { MergeOptions } from '../utils/options.js'
+import type { TypePlusOptions } from '../utils/options.js'
 
 /**
  * 🦴 *utilities*
@@ -12,13 +12,13 @@ import type { MergeOptions } from '../utils/options.js'
  * e.g. `number, 1` -> `1 | undefined`.
  * Default to `true`.
  *
- * @typeParam Options['caseNotMatch'] Return value when `T` does not match `Criteria`.
+ * @typeParam Options['$notMatch'] Return value when `T` does not match `Criteria`.
  * Default to `never`.
  *
- * @typeParam Options['caseWiden'] Return value when `widen` is true.
+ * @typeParam Options['$widen'] Return value when `widen` is true.
  * Default to `Criteria | undefined`.
  *
- * @typeParam Options['caseUnionNotMatch'] Return value when a branch of the union `T` does not match `Criteria`.
+ * @typeParam Options['$unionNotMatch'] Return value when a branch of the union `T` does not match `Criteria`.
  * Default to `never`.
  *
  * If you want the type to behave more like JavaScript,
@@ -33,29 +33,29 @@ export type ElementMatch<
 	Options extends ElementMatch.Options = ElementMatch.DefaultOptions<Criteria>
 > = [T] extends [Criteria]
 	? T
-	: (MergeOptions<Options, ElementMatch.DefaultOptions<Criteria>> extends infer C extends Record<keyof ElementMatch.Options, unknown>
+	: (TypePlusOptions.Merge<Options, ElementMatch.DefaultOptions<Criteria>> extends infer C extends Record<keyof ElementMatch.Options, unknown>
 		? ((T extends Criteria
 			? T
 			: (C['widen'] extends true
 				? (Criteria extends T
-					? C['caseWiden']
-					: C['caseNotMatch'])
-				: C['caseNotMatch'])) extends infer R
-			? IsUnion<T, IsNever<R, R, R | C['caseUnionNotMatch']>, R>
-			: C['caseNotMatch'])
+					? C['$widen']
+					: C['$notMatch'])
+				: C['$notMatch'])) extends infer R
+			? IsUnion<T, IsNever<R, R, R | C['$unionNotMatch']>, R>
+			: C['$notMatch'])
 		: never)
 
 export namespace ElementMatch {
 	export interface Options {
 		widen?: boolean | undefined,
-		caseNotMatch?: unknown,
-		caseWiden?: unknown,
-		caseUnionNotMatch?: unknown
+		$notMatch?: unknown,
+		$widen?: unknown,
+		$unionNotMatch?: unknown
 	}
 	export interface DefaultOptions<Criteria> {
 		widen: true,
-		caseNotMatch: never,
-		caseWiden: Criteria | undefined,
-		caseUnionNotMatch: never
+		$notMatch: never,
+		$widen: Criteria | undefined,
+		$unionNotMatch: never
 	}
 }

package/ts/array/array_plus.filter.ts

@@ -1,5 +1,49 @@
-export type Filter<A extends unknown[], Criteria> = A[0] extends Criteria
-	? A
-	: Criteria extends A[0]
-	? Array<Criteria>
-	: never[]
+// import type { IsEqual } from '../equal/equal.js'
+
+// /**
+//  * Filters an array or tuple based on criteria
+//  */
+// export type Filter<A extends readonly unknown[], Criteria = true> = Filter._<A, Criteria, []>
+
+import type { IsEqual } from '../equal/equal.js'
+import type { NeverType } from '../never/never_type.js'
+import type { TypePlusOptions } from '../utils/options.js'
+
+/**
+ * ⚗️ *transform*
+ * 🔢 *customizable*
+ *
+ * Filter the array `A`, keeping entries satisfying `Criteria`.
+ *
+ * @example
+ * ```ts
+ * type R = Filter<Array<string | undefined>, string> // string[]
+ * ```
+ */
+export type Filter<
+	A extends readonly unknown[],
+	Criteria = true,
+	Options extends Filter.Options = Filter.DefaultOptions
+> = TypePlusOptions.Merge<Options, Filter.DefaultOptions> extends infer O extends Filter.Options
+	? (NeverType<
+		A,
+		O['$never'],
+		(A[0] extends Criteria
+			? A
+			: Criteria extends A[0] ? Array<Criteria> : O['$notArray'])>)
+	: never
+
+export namespace Filter {
+	export interface Options extends TypePlusOptions.NotArray, NeverType.Options { }
+
+	export interface DefaultOptions {
+		$never: never,
+		$notArray: never[]
+	}
+
+	export type _<A extends readonly unknown[], Criteria, Result extends unknown[]> = A['length'] extends 0
+		? Result
+		: (A extends [infer H, ...infer Rest]
+			? IsEqual<H, Criteria, _<Rest, Criteria, [...Result, H]>, _<Rest, Criteria, Result>>
+			: never)
+}

package/ts/array/array_plus.find.ts

@@ -1,6 +1,6 @@
 import type { NeverType } from '../never/never_type.js'
 import type { TupleType } from '../tuple/tuple_type.js'
-import type { MergeOptions } from '../utils/options.js'
+import type { TypePlusOptions } from '../utils/options.js'
 import type { ElementMatch } from './array_plus.element_match.js'
 
 /**
@@ -25,20 +25,20 @@ import type { ElementMatch } from './array_plus.element_match.js'
  * With widen match, a narrowed type will match its widen type.
  * e.g. matching `1` against `number` yields `1 | undefined`
  *
- * The widen behavior can be customized by `Options['caseWiden']`
+ * The widen behavior can be customized by `Options['$widen']`
  *
- * @typeParam Options['caseNever'] return type when `A` is `never`. Default to `never`.
+ * @typeParam Options['$never'] return type when `A` is `never`. Default to `never`.
  *
- * @typeParam Options['caseNotMatch'] Return value when `T` does not match `Criteria`.
+ * @typeParam Options['$notMatch'] Return value when `T` does not match `Criteria`.
  * Default to `never`.
  *
- * @typeParam Options['caseTuple'] return type when `A` is a tuple. Default to `not supported` message.
+ * @typeParam Options['$tuple'] return type when `A` is a tuple. Default to `not supported` message.
  *
- * @typeParam Options['caseWiden'] return type when `T` in `A` is a widen type of `Criteria`.
+ * @typeParam Options['$widen'] return type when `T` in `A` is a widen type of `Criteria`.
  * Default to `Criteria | undefined`.
  * Set it to `never` for a more type-centric behavior
  *
- * @typeParam Options['caseUnionNotMatch'] Return value when a branch of the union `T` does not match `Criteria`.
+ * @typeParam Options['$unionNotMatch'] Return value when a branch of the union `T` does not match `Criteria`.
  * Default to `never`.
  *
  * If you want the type to behave more like JavaScript,
@@ -47,25 +47,25 @@ import type { ElementMatch } from './array_plus.element_match.js'
  * Since it is a union, the result will be joined to the matched branch as union.
  */
 export type Find<
-	A extends unknown[],
+	A extends readonly unknown[],
 	Criteria,
 	Options extends Find.Options = Find.DefaultOptions<Criteria>
 > =
-	MergeOptions<Options, Find.DefaultOptions<Criteria>> extends infer O extends Find.Options
+	TypePlusOptions.Merge<Options, Find.DefaultOptions<Criteria>> extends infer O extends Find.Options
 	? TupleType<
 		A,
-		O['caseTuple'],
-		A extends Array<infer T> ? ElementMatch<T, Criteria, O> : never,
+		O['$tuple'],
+		A extends Readonly<Array<infer T>> ? ElementMatch<T, Criteria, O> : never,
 		O
 	>
 	: never
 
 export namespace Find {
 	export interface Options extends ElementMatch.Options, NeverType.Options {
-		caseTuple?: unknown,
+		$tuple?: unknown,
 	}
 
 	export interface DefaultOptions<Criteria> extends ElementMatch.DefaultOptions<Criteria>, NeverType.DefaultOptions {
-		caseTuple: 'does not support tuple. Please use `FindFirst` or `TuplePlus.Find` instead.',
+		$tuple: 'does not support tuple. Please use `FindFirst` or `TuplePlus.Find` instead.',
 	}
 }

package/ts/array/{array_index.ts → array_plus.index_at.ts}

@@ -9,8 +9,11 @@ import type { Integer } from '../numeric/integer.js'
 import type { Negative } from '../numeric/negative.js'
 
 /**
+ * 🦴 *utilities*
+ *
  * Gets the normalized index to access the element of an array or tuple.
  *
+ * @example
  * ```ts
  * type R = IndexAt<['a', 'b', 'c'], 2> // 2
  * type R = IndexAt<['a', 'b', 'c'], -2> // 1
@@ -20,7 +23,7 @@ import type { Negative } from '../numeric/negative.js'
  * ```
  */
 export type IndexAt<
-	A extends Array<unknown>,
+	A extends readonly unknown[],
 	N extends number,
 	Fail = never,
 	Upper = A['length'],
@@ -29,7 +32,7 @@ export type IndexAt<
 
 export namespace IndexAt {
 	export type _<
-		A extends Array<unknown>,
+		A extends readonly unknown[],
 		N extends number,
 		Fail = never,
 		Upper = A['length'],
@@ -64,20 +67,3 @@ export namespace IndexAt {
 		>
 	>
 }
-
-/**
- * Is N an out of bound index of A.
- *
- * ```ts
- * type R = IsIndexOutOfBound<[1], 0> // false
- * type R = IsIndexOutOfBound<[1], -1> // false
-
- * type R = IsIndexOutOfBound<[1], 1> // true
- * type R = IsIndexOutOfBound<[1], -2> // true
- * ```
- */
-export type IsIndexOutOfBound<A extends unknown[], N extends number, Then = true, Else = false> = IsNever<
-	IndexAt<A, N, never, never, never>,
-	Then,
-	Else
->

package/ts/array/array_plus.is_index_out_of_bound.ts

@@ -0,0 +1,22 @@
+import type { IsNever } from '../never/never_type.js'
+import type { IndexAt } from './array_plus.index_at.js'
+
+/**
+ * 🎭 *validate*
+ *
+ * Is `N` an out of bound index of `A`.
+ *
+ * @example
+ * ```ts
+ * type R = IsIndexOutOfBound<[1], 0> // false
+ * type R = IsIndexOutOfBound<[1], -1> // false
+ *
+ * type R = IsIndexOutOfBound<[1], 1> // true
+ * type R = IsIndexOutOfBound<[1], -2> // true
+ * ```
+ */
+export type IsIndexOutOfBound<A extends readonly unknown[], N extends number, Then = true, Else = false> = IsNever<
+	IndexAt<A, N, never, never, never>,
+	Then,
+	Else
+>

package/ts/array/array_plus.is_readonly.ts

@@ -0,0 +1,46 @@
+import type { NeverType } from '../never/never_type.js'
+import type { TypePlusOptions } from '../utils/options.js'
+import type { LooseArrayType } from './loose_array_type.js'
+
+/**
+ * 🎭 *validate*
+ * 🔢 *customizable*
+ *
+ * Checks if `A` is a readonly array or tuple
+ *
+ * @example
+ * ```ts
+ * type R = IsReadonly<readonly string[]> // true
+ * type R = IsReadonly<readonly [1, 2, 3, 4, 5]> // true
+ *
+ * type R = IsReadonly<[1, 2, 3, 4, 5]> // false
+ * type R = IsReadonly<readonly string[] | number> // boolean
+ * ```
+ */
+export type IsReadonly<
+	A,
+	Options extends IsReadonly.Options = IsReadonly.DefaultOptions
+> =
+	TypePlusOptions.Merge<Options, IsReadonly.DefaultOptions> extends infer O extends IsReadonly.Options ?
+	NeverType<
+		A,
+		O['$never'],
+		A extends any ?
+		LooseArrayType<A,
+			Readonly<A> extends A ? O['$then'] : O['$else'],
+			O['$notArray']
+		> : never
+	>
+	: never
+
+export namespace IsReadonly {
+	export interface Options
+		extends NeverType.Options, TypePlusOptions.Selection, TypePlusOptions.NotArray { }
+
+	export interface DefaultOptions {
+		$then: true,
+		$else: false,
+		$never: false,
+		$notArray: false
+	}
+}

package/ts/array/array_plus.pad_start.ts

@@ -3,7 +3,7 @@ import type { CreateTuple } from '../tuple/create_tuple.js'
 import type { UnionOfValues } from './union_of_values.js'
 
 export type PadStart<
-	A extends unknown[],
+	A extends readonly unknown[],
 	MaxLength extends number,
 	PadWith = unknown
 > = MaxLength extends 0

package/ts/array/array_plus.split_at.ts

@@ -1,6 +1,6 @@
 import type { NeverType } from '../never/never_type.js'
 import type { IsTuple } from '../tuple/tuple_type.js'
-import type { IndexAt } from './array_index.js'
+import type { IndexAt } from './array_plus.index_at.js'
 import type { ArrayType } from './array_type.js'
 
 /**
@@ -28,10 +28,10 @@ import type { ArrayType } from './array_type.js'
  * ```
  */
 export type SplitAt<
-	A extends unknown[],
+	A extends readonly unknown[],
 	Index extends number,
 	DeleteCount extends number | never = never,
-	Insert extends unknown[] | never = never
+	Insert extends readonly unknown[] | never = never
 > = ArrayType<
 	A,
 	[A, A],
@@ -40,35 +40,35 @@ export type SplitAt<
 
 export namespace SplitAt {
 	export type _<
-		A extends unknown[],
-		B extends unknown[],
-		C extends unknown[],
+		A extends readonly unknown[],
+		B extends readonly unknown[],
+		C extends readonly unknown[],
 		Index extends number,
 		DeleteCount,
-		Insert extends unknown[],
+		Insert extends readonly unknown[],
 	> = 0 extends A['length']
 		? IsTuple<Insert, [[...Insert, ...B], C], [B, C]>
 		: (Index extends B['length']
-			? _D<A, B, C, DeleteCount, Insert>
-			: (A extends [infer Head, ...infer Tail]
+			? NeverType<
+				DeleteCount,
+				[B, A],
+				_D<A, B, C, DeleteCount, Insert>>
+			: (A extends readonly [infer Head, ...infer Tail]
 				? _<Tail, [...B, Head], [], Index, DeleteCount, Insert>
 				: 'unexpected: A does not extends [Head, ...Tail]'))
 
 	export type _D<
-		A extends unknown[],
-		B extends unknown[],
-		C extends unknown[],
+		A extends readonly unknown[],
+		B extends readonly unknown[],
+		C extends readonly unknown[],
 		DeleteCount,
-		Insert extends unknown[],
-	> = NeverType<
-		DeleteCount,
-		[B, A],
-		DeleteCount extends C['length']
+		Insert extends readonly unknown[],
+	> = DeleteCount extends C['length']
 		? IsTuple<Insert, [[...B, ...Insert, ...A], C], [[...B, ...A], C]>
-		: (A extends [infer Head, ...infer Tail]
+		: (A extends readonly [infer Head, ...infer Tail]
 			? _D<Tail, B, [...C, Head], DeleteCount, Insert>
 			: IsTuple<Insert, [[...Insert, ...B], C], [B, C]>
 		)
-	>
+
 }
 

package/ts/array/array_plus.ts

@@ -3,12 +3,14 @@ export type { Entries } from './array.entries.js'
 export type { FindLast } from './array.find_last.js'
 export type { Reverse } from './array.reverse.js'
 export type { Some } from './array.some.js'
-export type { IndexAt, IsIndexOutOfBound } from './array_index.js'
 export type { CommonPropKeys } from './array_plus.common_prop_keys.js'
 export type { Concat } from './array_plus.concat.js'
 export type { DropMatch } from './array_plus.drop_match.js'
 export type { ElementMatch } from './array_plus.element_match.js'
 export type { Filter } from './array_plus.filter.js'
 export type { Find } from './array_plus.find.js'
+export type { IndexAt } from './array_plus.index_at.js'
+export type { IsIndexOutOfBound } from './array_plus.is_index_out_of_bound.js'
+export type { IsReadonly } from './array_plus.is_readonly.js'
 export type { PadStart } from './array_plus.pad_start.js'
 export type { SplitAt } from './array_plus.split_at.js'

package/ts/array/array_type.ts

@@ -18,7 +18,11 @@ import type { StrictNumberType } from '../number/strict_number_type.js'
 export type ArrayType<T, Then = T, Else = never> = IsNever<
 	T,
 	Else,
-	[any[]] extends [T] ? ([T] extends [any[]] ? StrictNumberType<T['length'], Then, Else> : Else) : Else
+	[never[]] extends [T]
+	? ([T] extends [readonly any[]]
+		? StrictNumberType<T['length'], Then, Else>
+		: Else)
+	: Else
 >
 
 /**

package/ts/array/filter.ts

@@ -12,7 +12,7 @@ import type { Filter as FilterArray } from './array_plus.filter.js'
  * type R = Filter<Array<string | undefined>, string> // string[]
  * ```
  */
-export type Filter<A extends unknown[], Criteria> = number extends A['length']
+export type Filter<A extends readonly unknown[], Criteria> = number extends A['length']
 	? FilterArray<A, Criteria>
 	: FilterTuple<A, Criteria>
 
@@ -29,4 +29,4 @@ export type Filter<A extends unknown[], Criteria> = number extends A['length']
  * type R = KeepMatch<Array<string|undefined>, string> // string[]
  * ```
  */
-export type KeepMatch<A extends unknown[], Criteria> = Filter<A, Criteria>
+export type KeepMatch<A extends readonly unknown[], Criteria> = Filter<A, Criteria>

package/ts/array/find_first.ts

@@ -31,26 +31,26 @@ import type { Find as ArrayFind } from './array_plus.find.js'
  * With widen match, a narrowed type will match its widen type.
  * e.g. matching `1` against `number` yields `1 | undefined`
  *
- * The widen behavior can be customized by `Options['caseWiden']`
+ * The widen behavior can be customized by `Options['$widen']`
  *
  * @typeParam Options['caseEmptyTuple'] return type when `A` is an empty tuple.
  * Default to `never`.
  *
- * @typeParam Options['caseNever'] return type when `A` is `never`. Default to `never`.
+ * @typeParam Options['$never'] return type when `A` is `never`. Default to `never`.
  *
- * @typeParam Options['caseNoMatch'] Return value when `T` does not match `Criteria`.
+ * @typeParam Options['$noMatch'] Return value when `T` does not match `Criteria`.
  * Default to `never`.
  *
- * @typeParam Options['caseWiden'] return type when `T` in `A` is a widen type of `Criteria`.
+ * @typeParam Options['$widen'] return type when `T` in `A` is a widen type of `Criteria`.
  * Default to `Criteria | undefined`.
  * Set it to `never` for a more type-centric behavior
  *
- * @typeParam Options['caseUnionMiss'] Return value when a branch of the union `T` does not match `Criteria`.
+ * @typeParam Options['$unionMiss'] Return value when a branch of the union `T` does not match `Criteria`.
  * Default to `undefined`.
  * Since it is a union, the result will be join to the matched branch as union.
  */
 export type FindFirst<
-	A extends unknown[],
+	A extends readonly unknown[],
 	Criteria, Options extends FindFirst.Options = FindFirst.DefaultOptions<Criteria>
 > = TupleType<
 	A,

package/ts/array/head.ts

@@ -14,18 +14,18 @@ import type { NeverType } from '../never/never_type.js'
  * type R = Head<[]> // never
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  *
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
  * Default to `never`.
  */
 export type Head<
-	T extends unknown[],
+	T extends readonly unknown[],
 	Options extends Head.Options = Head.DefaultOptions
 > = NeverType<
 	T,
-	Options['caseNever'],
+	Options['$never'],
 	T['length'] extends 0 ? Options['caseEmptyTuple'] : T[0]
 >
 

package/ts/array/intersect_of_props.ts

@@ -6,7 +6,7 @@ import type { Tail } from '../tuple/tail.js'
  *
  * Gets the intersect of properties of the elements in `A`.
  */
-export type IntersectOfProps<A extends Record<any, unknown>[], P extends KeyTypes> = number extends A['length']
+export type IntersectOfProps<A extends readonly  Record<any, unknown>[], P extends KeyTypes> = number extends A['length']
 	? A[0][P]
 	: A['length'] extends 0
 	? never

package/ts/array/last.ts

@@ -13,18 +13,20 @@ import type { NeverType } from '../never/never_type.js'
  * type R = Last<[]> // never
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  *
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
  * Default to `never`.
  */
 export type Last<
-	T extends unknown[],
+	T extends readonly unknown[],
 	Options extends Last.Options = Last.DefaultOptions
 > = NeverType<T,
-	Options['caseNever'],
-	T['length'] extends 0 ? Options['caseEmptyTuple'] : T extends [...unknown[], infer R] ? R : T[0]
+	Options['$never'],
+	T['length'] extends 0
+	? Options['caseEmptyTuple']
+	: T extends readonly [...unknown[], infer R] ? R : T[0]
 >
 
 export namespace Last {