type-plus 7.5.0 → 8.0.0-beta.0

package/ts/tuple/tuple_plus.common_prop_keys.ts

@@ -16,7 +16,7 @@ import type { Tail } from './tail.js'
  * type R = TuplePlus.CommonPropKeys<[{ a: number, c: 1 }, { b: number, c: 2 }]> // 'c'
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  */
 export type CommonPropKeys<
@@ -24,7 +24,7 @@ export type CommonPropKeys<
 	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
 > = NeverType<
 	T,
-	Options['caseNever'],
+	Options['$never'],
 	(T['length'] extends 0
 		? never
 		: (

package/ts/tuple/tuple_plus.filter.ts

@@ -9,10 +9,10 @@
  * type R = Filter<[1, 2, '3'], true> // []
  * ```
  */
-export type Filter<T extends unknown[], Criteria> = T['length'] extends 0
+export type Filter<T extends readonly unknown[], Criteria = true> = T['length'] extends 0
 	? []
 	: (
-		T extends [infer Head, ...infer Tail]
+		T extends readonly [infer Head, ...infer Tail]
 		? (
 			Tail['length'] extends 0
 			? (

package/ts/tuple/tuple_plus.find.ts

@@ -1,6 +1,6 @@
 import type { ElementMatch } from '../array/array_plus.element_match.js'
 import type { NeverType } from '../never/never_type.js'
-import type { MergeOptions } from '../utils/options.js'
+import type { TypePlusOptions } from '../utils/options.js'
 import type { TupleType } from './tuple_type.js'
 
 /**
@@ -24,23 +24,23 @@ import type { TupleType } from './tuple_type.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['caseArray'] return type when `A` is an array. Default to `not supported` message.
+ * @typeParam Options['$array'] return type when `A` is an array. Default to `not supported` message.
  *
  * @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['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 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,
@@ -49,40 +49,40 @@ import type { TupleType } from './tuple_type.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,
 		A['length'] extends 0
-		? O['caseEmptyTuple']
+		? O['$emptyTuple']
 		: Find.Device<A, Criteria, O>,
-		O['caseArray'],
+		O['$array'],
 		O
 	>
 	: never
 export namespace Find {
 	export type Device<
-		A extends unknown[],
+		A extends readonly unknown[],
 		Criteria,
 		Options extends Find.Options
 	> = A['length'] extends 0
-		? Options['caseNotMatch']
-		: (A extends [infer Head, ...infer Tail]
+		? Options['$notMatch']
+		: (A extends readonly [infer Head, ...infer Tail]
 			? ElementMatch<
 				Head,
 				Criteria,
-				MergeOptions<{ caseNotMatch: Device<Tail, Criteria, Options> }, Options>
+				TypePlusOptions.Merge<{ $notMatch: Device<Tail, Criteria, Options> }, Options>
 			>
 			: never)
 	export interface Options extends ElementMatch.Options, NeverType.Options {
-		caseArray?: unknown,
-		caseEmptyTuple?: unknown,
+		$array?: unknown,
+		$emptyTuple?: unknown,
 	}
 
 	export interface DefaultOptions<Criteria> extends ElementMatch.DefaultOptions<Criteria>, NeverType.DefaultOptions {
-		caseArray: 'does not support array. Please use `FindFirst` or `ArrayPlus.Find` instead.',
-		caseEmptyTuple: never,
+		$array: 'does not support array. Please use `FindFirst` or `ArrayPlus.Find` instead.',
+		$emptyTuple: never,
 	}
 }

package/ts/tuple/tuple_plus.pad_start.ts

@@ -17,16 +17,19 @@
  * PadStart<[1, 2, 3], 5> // [unknown, unknown, 1, 2, 3]
  * ```
  */
-export type PadStart<Tuple extends unknown[], MaxLength extends number, PadWith = unknown> = PadStart.Device<
-	Tuple,
-	MaxLength,
-	PadWith,
-	[]
->
+export type PadStart<
+	Tuple extends readonly unknown[],
+	MaxLength extends number,
+	PadWith = unknown> = PadStart.Device<
+		Tuple,
+		MaxLength,
+		PadWith,
+		[]
+	>
 
 export namespace PadStart {
 	export type Device<
-		Source extends unknown[],
+		Source extends readonly unknown[],
 		MaxLength extends number,
 		PadWith,
 		Result extends unknown[]
@@ -36,7 +39,7 @@ export namespace PadStart {
 			Source extends []
 			? Result
 			: (
-				Source extends [...infer Head, infer Tail]
+				Source extends readonly [...infer Head, infer Tail]
 				? (
 					[Tail, ...Result] extends infer R extends unknown[]
 					? Device<Head, R['length'], PadWith, R>
@@ -49,7 +52,7 @@ export namespace PadStart {
 			Source extends []
 			? Device<Source, MaxLength, PadWith, [PadWith, ...Result]>
 			: (
-				Source extends [...infer Head, infer Tail]
+				Source extends readonly [...infer Head, infer Tail]
 				? Device<Head, MaxLength, PadWith, [Tail, ...Result]>
 				: Source
 			)

package/ts/tuple/tuple_type.ts

@@ -5,7 +5,7 @@ import type { IsNever, NeverType } from '../never/never_type.js'
  *
  * Filter `T` to ensure it is a tuple, excluding array.
  *
- * @typeParam Cases['never'] Return type when `T` is `never`. Default to `Else`.
+ * @typeParam Cases['$never'] Return type when `T` is `never`. Default to `Else`.
  *
  * @example
  * ```ts
@@ -25,8 +25,8 @@ export type TupleType<
 	Options extends TupleType.Options = TupleType.DefaultOptions<Else>
 > = IsNever<
 	T,
-	Options['caseNever'],
-	[T] extends [any[]] ? (number extends T['length'] ? Else : Then) : Else
+	Options['$never'],
+	[T] extends [readonly any[]] ? (number extends T['length'] ? Else : Then) : Else
 >
 
 export namespace TupleType {
@@ -34,7 +34,7 @@ export namespace TupleType {
 	}
 
 	export interface DefaultOptions<Else> {
-		caseNever: Else
+		$never: Else
 	}
 }
 

package/ts/type_plus/cases.ts

@@ -0,0 +1,14 @@
+const $then = Symbol('then')
+export type $Then = typeof $then
+
+const $else = Symbol('else')
+export type $Else = typeof $else
+
+const $never = Symbol('never')
+export type $Never = typeof $never
+
+const $error = Symbol('error')
+export interface $Error<M extends string> {
+	type: typeof $error,
+	message: M
+}

package/ts/utils/options.ts

@@ -1,10 +1,29 @@
+export namespace TypePlusOptions {
+	/**
+	 * 🦴 *utilities*
+	 * ㊙️ *internal*
+	 *
+	 * Merge the input Options `I` with the default Options `D`.
+	 */
+	export type Merge<I, D> = {
+		[k in keyof D]: k extends keyof I ? I[k] : D[k]
+	}
 
-/**
- * 🦴 *utilities*
- * ㊙️ *internal*
- *
- * Merge the input Options `I` with the default Options `D`.
- */
-export type MergeOptions<I, D> = {
-	[k in keyof D]: k extends keyof I ? I[k] : D[k]
+	/**
+	 * 🦴 *utilities*
+	 * ㊙️ *internal*
+	 *
+	 * Selection (if-then-else) options.
+	 *
+	 * The word "selection" refers to the basic elements in structural programming:
+	 * sequence, selection, and iteration.
+	 */
+	export interface Selection {
+		$then?: unknown,
+		$else?: unknown,
+	}
+
+	export interface NotArray {
+		$notArray?: unknown
+	}
 }

package/cjs/any/any_type.d.ts

@@ -1,63 +0,0 @@
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is exactly `any`.
- *
- * @example
- * ```ts
- * type R = AnyType<any> // any
- *
- * type R = AnyType<never> // never
- * type R = AnyType<unknown> // never
- * type R = AnyType<string | boolean> // never
- * ```
- */
-export type AnyType<T, Then = T, Else = never> = 0 extends 1 & T ? Then : Else;
-/**
- * 🎭 *validate*
- *
- * Validate if `T` is exactly `any`.
- *
- * @example
- * ```ts
- * type R = IsAny<any> // true
- *
- * type R = IsAny<never> // false
- * type R = IsAny<unknown> // false
- * type R = IsAny<string | boolean> // false
- * ```
- */
-export type IsAny<T, Then = true, Else = false> = AnyType<T, Then, Else>;
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is not exactly `any`.
- *
- * @example
- * ```ts
- * type R = NotAnyType<any> // never
- *
- * type R = NotAnyType<never> // never
- * type R = NotAnyType<unknown> // unknown
- * type R = NotAnyType<string | boolean> // string | boolean
- * ```
- */
-export type NotAnyType<T, Then = T, Else = never> = AnyType<T, Else, Then>;
-/**
- * 🎭 *validate*
- *
- * Validate if `T` is not exactly `any`.
- *
- * @example
- * ```ts
- * import type { IsNotAny } from 'type-plus'
- *
- * type R = IsNotAny<any> // false
- *
- * type R = IsNotAny<never> // true
- * type R = IsNotAny<unknown> // true
- * type R = IsNotAny<string | boolean> // true
- * ```
- */
-export type IsNotAny<T, Then = true, Else = false> = AnyType<T, Else, Then>;
-//# sourceMappingURL=any_type.d.ts.map

package/cjs/any/any_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"any_type.d.ts","sourceRoot":"","sources":["../../ts/any/any_type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAExE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/cjs/any/any_type.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=any_type.js.map

package/cjs/any/any_type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"any_type.js","sourceRoot":"","sources":["../../ts/any/any_type.ts"],"names":[],"mappings":""}

package/cjs/array/array.at.d.ts

@@ -1,20 +0,0 @@
-import type { IsStrictNumber } from '../number/strict_number_type.js';
-import type { TupleType } from '../tuple/tuple_type.js';
-import type { IndexAt } from './array_index.js';
-/**
- * 🦴 *utilities*
- *
- * Gets the type of the array or tuple at positive or negative index `N`.
- *
- * Like `Array.at()`, this type supports negative numbers.
- *
- * @alias ArrayPlus.At
- * @see https://github.com/microsoft/TypeScript/issues/53345#issuecomment-1477138167
- *
- * ```ts
- * type R = At<[1, 2, 3], 2> // 3
- * type R = At<[1, 2, 3], -1> // 3
- * ```
- */
-export type At<A extends unknown[], N extends number, Fail = never> = IndexAt<A, N, Fail, Fail, Fail> extends infer I ? I extends number ? TupleType<A, IsStrictNumber<I, A[I] | undefined, A[I]>, A[I] | undefined> : Fail : never;
-//# sourceMappingURL=array.at.d.ts.map

package/cjs/array/array.at.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.at.d.ts","sourceRoot":"","sources":["../../ts/array/array.at.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,EAAE,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,MAAM,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAC5E,CAAC,EACD,CAAC,EACD,IAAI,EACJ,IAAI,EACJ,IAAI,CACJ,SAAS,MAAM,CAAC,GACd,CAAC,SAAS,MAAM,GACf,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,GACzE,IAAI,GACL,KAAK,CAAA"}

package/cjs/array/array.at.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array.at.js.map

package/cjs/array/array.at.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.at.js","sourceRoot":"","sources":["../../ts/array/array.at.ts"],"names":[],"mappings":""}

package/cjs/array/array.entries.d.ts

@@ -1,18 +0,0 @@
-import type { IsTuple } from '../tuple/tuple_type.js';
-/**
- * Returns an array of key-value pairs for every entry in the array or tuple.
- *
- * Note that this is not the same as `Array.entries(A)`,
- * which returns an iterable interator.
- *
- * @example
- * ```ts
- * ArrayPlus.Entries<Array<string | number>> // Array<[number, string | number]>
- * ArrayPlus.Entries<[1, 2, 3]> // [[0, 1], [1, 2], [2, 3]]
- * ```
- */
-export type Entries<A extends unknown[]> = IsTuple<A, Entries.Device<A, []>, A extends Array<infer T> ? Array<[number, T]> : never>;
-export declare namespace Entries {
-    type Device<A extends unknown[], R extends unknown[]> = A['length'] extends 0 ? R : A extends [...infer F, infer N] ? Device<F, [[F['length'], N], ...R]> : never;
-}
-//# sourceMappingURL=array.entries.d.ts.map

package/cjs/array/array.entries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.entries.d.ts","sourceRoot":"","sources":["../../ts/array/array.entries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,OAAO,CACjD,CAAC,EACD,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,EACrB,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CACrD,CAAA;AAED,yBAAiB,OAAO,CAAC;IACxB,KAAY,MAAM,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAClF,CAAC,GACD,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAC/B,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GACnC,KAAK,CAAA;CACP"}

package/cjs/array/array.entries.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array.entries.js.map

package/cjs/array/array.entries.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.entries.js","sourceRoot":"","sources":["../../ts/array/array.entries.ts"],"names":[],"mappings":""}

package/cjs/array/array.find_last.d.ts

@@ -1,19 +0,0 @@
-import type { TupleType } from '../tuple/tuple_type.js';
-/**
- * 🦴 *utilities*
- *
- * Gets the last type in the array or tuple that matches the `Criteria`.
- *
- * If the `Criteria` is not met, it will return `never'.
- *
- * For `Array<T>`, it will return `T | undefined` if `T` satisfies `Criteria`.
- *
- * @example
- * ```ts
- * ArrayPlus.Find<Array<1 | 2 | 'x'>, number> // 1 | 2 | undefined
- *
- * ArrayPlus.Find<[true, 123, 'x', 321], number> // 321
- * ```
- */
-export type FindLast<A extends Array<any>, Criteria> = TupleType<A, A['length'] extends 0 ? never : A extends [...infer Heads, infer Last] ? Last extends Criteria ? Last : FindLast<Heads, Criteria> : never, A extends Array<infer T> ? (T extends Criteria ? T | undefined : never) : never>;
-//# sourceMappingURL=array.find_last.d.ts.map

package/cjs/array/array.find_last.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.find_last.d.ts","sourceRoot":"","sources":["../../ts/array/array.find_last.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAEvD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,QAAQ,IAAI,SAAS,CAC/D,CAAC,EACD,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAClB,KAAK,GACL,CAAC,SAAS,CAAC,GAAG,MAAM,KAAK,EAAE,MAAM,IAAI,CAAC,GACtC,IAAI,SAAS,QAAQ,GACpB,IAAI,GACJ,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,GAC1B,KAAK,EACR,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,KAAK,CAAC,GAAG,KAAK,CAC/E,CAAA"}

package/cjs/array/array.find_last.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array.find_last.js.map

package/cjs/array/array.find_last.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.find_last.js","sourceRoot":"","sources":["../../ts/array/array.find_last.ts"],"names":[],"mappings":""}

package/cjs/array/array.reverse.d.ts

@@ -1,2 +0,0 @@
-export type Reverse<A extends unknown[]> = A extends [infer First, ...infer Rest] ? [...Reverse<Rest>, First] : A;
-//# sourceMappingURL=array.reverse.d.ts.map

package/cjs/array/array.reverse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.reverse.d.ts","sourceRoot":"","sources":["../../ts/array/array.reverse.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC9E,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,GACzB,CAAC,CAAA"}

package/cjs/array/array.reverse.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array.reverse.js.map

package/cjs/array/array.reverse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.reverse.js","sourceRoot":"","sources":["../../ts/array/array.reverse.ts"],"names":[],"mappings":""}

package/cjs/array/array.some.d.ts

@@ -1,33 +0,0 @@
-import type { IsEqual } from '../equal/equal.js';
-import type { CanAssign } from '../index.js';
-import type { Tail } from '../tuple/tail.js';
-import type { UnionOfValues } from './union_of_values.js';
-/**
- * Determines whether the array type `A` contains any elements that satisfies the specified `Criteria` type.
- *
- * It operates in `loose` mode by default,
- * which means literal types satisfies their widened counterparts.
- *
- * You can also change it to `strict` mode.
- *
- * 🦴 *utilities*
- *
- * @example
- * ```ts
- * Some<string[], string> // true
- * Some<['a', boolean], boolean> // true
- * Some<['a', true], boolean> //true
- *
- * Some<['a', true], boolean, 'strict'> // false
- * ```
- */
-export type Some<A extends any[], Criteria, Mode extends 'strict' | 'loose' = 'loose', Then = true, Else = false> = Mode extends 'strict' ? Some.Strict<A, Criteria, Then, Else> : Some.Loose<A, Criteria, Then, Else>;
-export declare namespace Some {
-    type Strict<A extends unknown[], Criteria, Then, Else> = number extends A['length'] ? StrictArray<A, Criteria, Then, Else> : StrictTuple<A, Criteria, Then, Else>;
-    type StrictArray<A extends unknown[], Criteria, Then, Else> = IsEqual<UnionOfValues<A>, Criteria, Then, Else>;
-    type StrictTuple<A extends unknown[], Criteria, Then, Else> = A['length'] extends 0 ? Else : IsEqual<A[0], Criteria> extends true ? Then : StrictTuple<Tail<A>, Criteria, Then, Else>;
-    type Loose<A extends unknown[], Criteria, Then, Else> = number extends A['length'] ? LooseArray<A, Criteria, Then, Else> : LooseTuple<A, Criteria, Then, Else>;
-    type LooseArray<A extends unknown[], Criteria, Then, Else> = CanAssign<UnionOfValues<A>, Criteria, Then, Else>;
-    type LooseTuple<A extends unknown[], Criteria, Then, Else> = A['length'] extends 0 ? Else : A[0] extends Criteria ? Then : LooseTuple<Tail<A>, Criteria, Then, Else>;
-}
-//# sourceMappingURL=array.some.d.ts.map

package/cjs/array/array.some.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.some.d.ts","sourceRoot":"","sources":["../../ts/array/array.some.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,IAAI,CACf,CAAC,SAAS,GAAG,EAAE,EACf,QAAQ,EACR,IAAI,SAAS,QAAQ,GAAG,OAAO,GAAG,OAAO,EACzC,IAAI,GAAG,IAAI,EACX,IAAI,GAAG,KAAK,IACT,IAAI,SAAS,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEtG,yBAAiB,IAAI,CAAC;IACrB,KAAY,MAAM,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACvF,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,GACpC,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IAEvC,KAAY,WAAW,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,OAAO,CAC3E,aAAa,CAAC,CAAC,CAAC,EAChB,QAAQ,EACR,IAAI,EACJ,IAAI,CACJ,CAAA;IAED,KAAY,WAAW,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACvF,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,IAAI,GACpC,IAAI,GACJ,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IAE7C,KAAY,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACtF,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,GACnC,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IAEtC,KAAY,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,SAAS,CAC5E,aAAa,CAAC,CAAC,CAAC,EAChB,QAAQ,EACR,IAAI,EACJ,IAAI,CACJ,CAAA;IAED,KAAY,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACtF,IAAI,GACJ,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GACrB,IAAI,GACJ,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;CAC5C"}

package/cjs/array/array.some.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array.some.js.map

package/cjs/array/array.some.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.some.js","sourceRoot":"","sources":["../../ts/array/array.some.ts"],"names":[],"mappings":""}

package/cjs/array/array_index.d.ts

@@ -1,34 +0,0 @@
-import type { IsAny } from '../any/any_type.js';
-import type { IsEqual } from '../equal/equal.js';
-import type { Abs } from '../math/abs.js';
-import type { GreaterThan } from '../math/greater_than.js';
-import type { Subtract } from '../math/subtract.js';
-import type { IsNever } from '../never/never_type.js';
-import type { StrictNumberType } from '../number/strict_number_type.js';
-import type { Integer } from '../numeric/integer.js';
-import type { Negative } from '../numeric/negative.js';
-/**
- * Gets the normalized index to access the element of an array or tuple.
- *
- * ```ts
- * type R = IndexAt<['a', 'b', 'c'], 2> // 2
- * type R = IndexAt<['a', 'b', 'c'], -2> // 1
- *
- * type R = IndexAt<['a', 'b', 'c'], 3> // never
- * type R = IndexAt<['a', 'b', 'c'], -4> // never
- * ```
- */
-export type IndexAt<A extends Array<unknown>, N extends number, Fail = never, Upper = A['length'], Lower = 0> = IsEqual<A['length'], 0, Fail, Integer<N, StrictNumberType<A['length'], N, Negative<N, GreaterThan<Abs<N>, A['length']> extends true ? Lower : Subtract<A['length'], Abs<N>>, GreaterThan<A['length'], N> extends true ? N : Upper>>, IsAny<N, number, StrictNumberType<N, N>>>>;
-/**
- * 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>;
-//# sourceMappingURL=array_index.d.ts.map

package/cjs/array/array_index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_index.d.ts","sourceRoot":"","sources":["../../ts/array/array_index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAEtD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,OAAO,CAClB,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC,EACxB,CAAC,SAAS,MAAM,EAChB,IAAI,GAAG,KAAK,EACZ,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,EACnB,KAAK,GAAG,CAAC,IACN,OAAO,CACV,CAAC,CAAC,QAAQ,CAAC,EACX,CAAC,EACD,IAAI,EACJ,OAAO,CACN,CAAC,EACD,gBAAgB,CACf,CAAC,CAAC,QAAQ,CAAC,EAEX,CAAC,EAED,QAAQ,CACP,CAAC,EACD,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EACrF,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK,CACpD,CACD,EAED,KAAK,CACJ,CAAC,EACD,MAAM,EACN,gBAAgB,CACf,CAAC,EAED,CAAC,CACD,CACD,CACD,CACD,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CACxG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAClC,IAAI,EACJ,IAAI,CACJ,CAAA"}

package/cjs/array/array_index.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array_index.js.map

package/cjs/array/array_index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_index.js","sourceRoot":"","sources":["../../ts/array/array_index.ts"],"names":[],"mappings":""}

package/cjs/array/array_plus.common_prop_keys.d.ts

@@ -1,27 +0,0 @@
-import type { NeverType } from '../never/never_type.js';
-import type { KeyTypes } from '../object/KeyTypes.js';
-/**
- * ⚗️ *transform*
- * 🔢 *customization*
- *
- * Gets the common keys of the record types in the array `A`.
- *
- * @example
- * ```ts
- * import { type ArrayPlus } from 'type-plus'
- *
- * type R = ArrayPlus.CommonPropKeys<Array<{ a: 1 }>> // 'a'
- * type R = ArrayPlus.CommonPropKeys<Array<{ a: 1, b: 1 } | { a: 1, c: 1 }>> // 'a'
- * ```
- *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
- * Default to `never`.
- */
-export type CommonPropKeys<A extends 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>;
-export declare namespace CommonPropKeys {
-    interface Options extends NeverType.Options {
-    }
-    interface DefaultOptions extends NeverType.DefaultOptions {
-    }
-}
-//# sourceMappingURL=array_plus.common_prop_keys.d.ts.map

package/cjs/array/array_plus.common_prop_keys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_plus.common_prop_keys.d.ts","sourceRoot":"","sources":["../../ts/array/array_plus.common_prop_keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,CACzB,CAAC,SAAS,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,EACrC,OAAO,SAAS,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,cAAc,IACnE,SAAS,CAAC,CAAC,EACd,OAAO,CAAC,WAAW,CAAC,EACpB,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,SAAS,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,KAAK,CAC5E,CAAA;AAED,yBAAiB,cAAc,CAAC;IAC/B,UAAiB,OAAQ,SAAQ,SAAS,CAAC,OAAO;KACjD;IAED,UAAiB,cAAe,SAAQ,SAAS,CAAC,cAAc;KAC/D;CACD"}

package/cjs/array/array_plus.common_prop_keys.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array_plus.common_prop_keys.js.map

package/cjs/array/array_plus.common_prop_keys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_plus.common_prop_keys.js","sourceRoot":"","sources":["../../ts/array/array_plus.common_prop_keys.ts"],"names":[],"mappings":""}

package/cjs/array/array_plus.concat.d.ts

@@ -1,16 +0,0 @@
-/**
- * 🦴 *utilities
- * 💀 *deprecated* Will be available only as `ArrayPlus.Concat` in the next version
- *
- * Concats two arrays or tuples.
- *
- * alias of: `[...A, ...B]`
- *
- * @alias ArrayPlus.Concat
- *
- * ```ts
- * type R = Concat<[1], [2, 3]> // [1, 2, 3]
- * ```
- */
-export type Concat<A extends unknown[], B extends unknown[]> = [...A, ...B];
-//# sourceMappingURL=array_plus.concat.d.ts.map

package/cjs/array/array_plus.concat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_plus.concat.d.ts","sourceRoot":"","sources":["../../ts/array/array_plus.concat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA"}

package/cjs/array/array_plus.concat.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=array_plus.concat.js.map

package/cjs/array/array_plus.concat.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_plus.concat.js","sourceRoot":"","sources":["../../ts/array/array_plus.concat.ts"],"names":[],"mappings":""}

package/cjs/array/array_plus.d.ts

@@ -1,15 +0,0 @@
-export type { At } from './array.at.js';
-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 { PadStart } from './array_plus.pad_start.js';
-export type { SplitAt } from './array_plus.split_at.js';
-//# sourceMappingURL=array_plus.d.ts.map