type-plus 6.8.0 → 7.0.0

package/ts/testing/test_type.ts

@@ -1,181 +1,224 @@
 import type { IsAny } from '../any/any_type.js'
+import type { IsArray } from '../array/array_type.js'
 import type { IsBigint } from '../bigint/bigint_type.js'
 import type { IsStrictBigint } from '../bigint/strict_bigint_type.js'
 import type { IsBoolean } from '../boolean/boolean_type.js'
 import type { IsFalse } from '../boolean/false_type.js'
 import type { IsStrictBoolean } from '../boolean/strict_boolean_type.js'
 import type { IsTrue } from '../boolean/true_type.js'
-import type { Equal } from '../equal/equal.js'
+import type { IsEqual } from '../equal/equal.js'
+import type { IsFunction } from '../function/function_type.js'
+import type { IsStrictFunction } from '../function/strict_function_type.js'
 import type { IsNever } from '../never/never_type.js'
 import type { IsNull } from '../null/null_type.js'
 import type { IsNumber } from '../number/number_type.js'
 import type { IsStrictNumber } from '../number/strict_number_type.js'
-import type { CanAssign } from '../predicates/CanAssign.js'
+import type { IsObject } from '../object/object_type.js'
+import type { CanAssign, StrictCanAssign } from '../predicates/CanAssign.js'
 import type { IsStrictString } from '../string/strict_string_type.js'
 import type { IsString } from '../string/string_type.js'
+import type { IsSymbol } from '../symbol/symbol_type.js'
+import type { IsTuple } from '../tuple/tuple_type.js'
 import type { IsUndefined } from '../undefined/undefined_type.js'
 import type { IsUnknown } from '../unknown/unknown_type.js'
 import type { IsVoid } from '../void/void_type.js'
 
-/**
- * Check if type `A` is equal to type `B` and `C`.
- *
- * @return `expected` as `A` for type inspection.
- */
-function equal<A, B, C>(expected: Equal<A, B> & Equal<A, C>): A
-/**
- * Check if type `A` is equal to type `B`.
- *
- * @return `expected` as `A` for type inspection.
- */
-function equal<A, B>(expected: Equal<A, B>): A
-function equal(expected: unknown) {
-	return expected
-}
-
-/**
- * Test utilities for types.
- *
- * This is designed specifically for testing.
- * The return value is the input `expected` parameter asserted as the first type parameter,
- * so that the type can be further inspected.
- */
-export const testType = {
+interface TestType {
 	/**
-	 * Check if type `T` is exactly `any`.
+	 * Check if type `A` is equal to type `B` and `C`.
 	 *
-	 * @return `expected` as `T` for type inspection.
+	 * @return `expected` as `A` for type inspection.
 	 */
-	any<T>(expected: IsAny<T>) {
-		return expected as T
-	},
+	equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A
 	/**
-	 * Check if type `T` is exactly `unknown`.
+	 * Check if type `A` is equal to type `B`.
+	 *
+	 * @return `expected` as `A` for type inspection.
+	 */
+	equal<A, B>(expected: IsEqual<A, B>): A
+	/**
+	 * Check if `A` can assign to `B`.
+	 *
+	 * If `A` is a union,
+	 * the check is distributive.
+	 *
+	 * Meaning the result can be `boolean`,
+	 * meaning both `true` and `false` will pass.
+	 *
+	 * If you want to avoid the distributivity,
+	 * use `testType.strictCanAssign()` instead.
+	 *
+	 * @example
+	 * ```ts
+	 * testType.canAssign<123, number> // true
+	 *
+	 * testType.canAssign<number | string, number> // boolean
+	 * ```
+	 *
+	 * @return `expected` as `A` for type inspection.
+	 */
+	canAssign<A, B>(expected: CanAssign<A, B>): A
+	/**
+	 * Check if `A` can fully assign to `B`.
+	 *
+	 * This checks all branches in an union `A` are assignable to `B`.
+	 *
+	 * @example
+	 * ```ts
+	 * testType.strictCanAssign<number | string, number | string> // true
+	 *
+	 * testType.strictCanAssign<number | string, number> // false
+	 * ```
+	 *
+	 * @return `expected` as `A` for type inspection.
+	 */
+	strictCanAssign<A, B>(expected: StrictCanAssign<A, B>): A
+	/**
+	 * Check if type `T` is exactly `any`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	unknown<T>(expected: IsUnknown<T>) {
-		return expected as T
-	},
+	any<T>(expected: IsAny<T>): T
 	/**
-	 * Check if type `T` is exactly `never`.
+	 * Check if type `T` is exactly `array`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	never<T>(expected: IsNever<T>) {
-		return expected as T
-	},
+	array<T>(expected: IsArray<T>): T
 	/**
-	 * Check if type `T` is exactly `void`.
+	 * Check if type `T` is exactly `bigint`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	void<T>(expected: IsVoid<T>) {
-		return expected as T
-	},
-	equal,
+	strictBigint<T>(expected: IsStrictBigint<T>): T
 	/**
-	 * Check if `A` can assign to `B`.
+	 * Check if type `T` is `bigint` or bigint literals.
 	 *
-	 * @return `expected` as `A` for type inspection.
+	 * @return `expected` as `T` for type inspection.
 	 */
-	canAssign<A, B>(expected: CanAssign<A, B>) {
-		return expected as A
-	},
+	bigint<T>(expected: IsBigint<T>): T
 	/**
 	 * Check if type `T` is exactly `boolean`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	strictBoolean<T>(expected: IsStrictBoolean<T>) {
-		return expected as T
-	},
+	strictBoolean<T>(expected: IsStrictBoolean<T>): T
 	/**
 	 * Check if type `T` is `boolean` and boolean literals.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	boolean<T>(expected: IsBoolean<T>) {
-		return expected as T
-	},
+	boolean<T>(expected: IsBoolean<T>): T
 	/**
 	 * Check if type `T` is exactly `true`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	true<T>(expected: IsTrue<T>) {
-		return expected as T
-	},
+	true<T>(expected: IsTrue<T>): T
 	/**
 	 * Check if type `T` is exactly `false`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	false<T>(expected: IsFalse<T>) {
-		return expected as T
-	},
+	false<T>(expected: IsFalse<T>): T
+	/**
+	 * Check if type `T` is exactly `boolean`.
+	 *
+	 * @return `expected` as `T` for type inspection.
+	 */
+	strictFunction<T>(expected: IsStrictFunction<T>): T
+	/**
+	 * Check if type `T` is `boolean` and boolean literals.
+	 *
+	 * @return `expected` as `T` for type inspection.
+	 */
+	function<T>(expected: IsFunction<T>): T
+	/**
+	 * Check if type `T` is exactly `never`.
+	 *
+	 * @return `expected` as `T` for type inspection.
+	 */
+	never<T>(expected: IsNever<T>): T
+	/**
+	 * Check if type `T` is exactly `null`.
+	 *
+	 * @return `expected` as `T` for type inspection.
+	 */
+	null<T>(expected: IsNull<T>): T
 	/**
 	 * Check if type `T` is exactly `number`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	strictNumber<T>(expected: IsStrictNumber<T>) {
-		return expected as T
-	},
+	strictNumber<T>(expected: IsStrictNumber<T>): T
 	/**
 	 * Check if type `T` is `number` or number literals.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	number<T>(expected: IsNumber<T>) {
-		return expected as T
-	},
+	number<T>(expected: IsNumber<T>): T
+	/**
+	 * Check if type `T` is `object`.
+	 *
+	 * Note that `Function`, `Array`, and *tuple* are also `object`.
+	 *
+	 * @return `expected` as `T` for type inspection.
+	 */
+	object<T>(expected: IsObject<T>): T
 	/**
 	 * Check if type `T` is exactly `string`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	strictString<T>(expected: IsStrictString<T>) {
-		return expected as T
-	},
+	strictString<T>(expected: IsStrictString<T>): T
 	/**
 	 * Check if type `T` is `string` or string literals.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	string<T>(expected: IsString<T>) {
-		return expected as T
-	},
+	string<T>(expected: IsString<T>): T
 	/**
-	 * Check if type `T` is exactly `bigint`.
+	 * Check if type `T` is a `symbol`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	strictBigint<T>(expected: IsStrictBigint<T>) {
-		return expected as T
-	},
+	symbol<T>(expected: IsSymbol<T>): T
 	/**
-	 * Check if type `T` is `bigint` or bigint literals.
+	 * Check if type `T` is a *tuple*.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	bigint<T>(expected: IsBigint<T>) {
-		return expected as T
-	},
+	tuple<T>(expected: IsTuple<T>): T
 	/**
 	 * Check if type `T` is exactly `undefined`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	undefined<T>(expected: IsUndefined<T>) {
-		return expected as T
-	},
+	undefined<T>(expected: IsUndefined<T>): T
+	// hasUndefined<T>(expected: CanAssign<T, undefined>): T
 	/**
-	 * Check if type `T` is exactly `null`.
+	 * Check if type `T` is exactly `unknown`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	null<T>(expected: IsNull<T>) {
-		return expected as T
-	}
+	unknown<T>(expected: IsUnknown<T>): T
+	/**
+	 * Check if type `T` is exactly `void`.
+	 *
+	 * @return `expected` as `T` for type inspection.
+	 */
+	void<T>(expected: IsVoid<T>): T
 }
+
+/**
+ * Test utilities for types.
+ *
+ * This is designed specifically for testing.
+ * The return value is the input `expected` parameter asserted as the first type parameter,
+ * so that the type can be further inspected.
+ */
+export const testType = new Proxy({} as TestType, {
+	get(_target, _prop, _receiver) {
+		return (expected: unknown) => expected
+	}
+})

package/ts/tuple/create_tuple.ts

@@ -0,0 +1,42 @@
+import type { DigitArray } from '../math/numeric_struct.js'
+import type { IsInteger } from '../numeric/integer.js'
+import type { IsPositive } from '../numeric/positive.js'
+
+/**
+ * Creates `Tuple<T>` with `L` number of elements.
+ * @note Other cool implementations by @lazytype, @jcalz:
+ * @see https://github.com/microsoft/TypeScript/issues/26223#issuecomment-674514787
+ * @see https://github.com/microsoft/TypeScript/issues/47874#issuecomment-1039157322
+ */
+export type CreateTuple<L extends number, T = unknown, Fail = never> = number extends L
+	? T[]
+	: IsPositive<L> extends true
+	? IsInteger<L> extends true
+		? ToTuple<[], DigitArray.FromString<`${L}`>, T>
+		: Fail
+	: Fail
+export type ToTuple<R extends any[], S extends number[], X = any> = S['length'] extends 0
+	? R
+	: S['length'] extends 1
+	? [...R, ...DigitToTuple<X>[S[0]]]
+	: S extends [any, ...infer T]
+	? T extends any[]
+		? ToTuple<Multi10<[...R, ...DigitToTuple<X>[S[0]]]>, T>
+		: never
+	: never
+
+type DigitToTuple<T = 1> = {
+	[k in number]: any[]
+} & {
+	0: []
+	1: [T]
+	2: [T, T]
+	3: [T, T, T]
+	4: [T, T, T, T]
+	5: [T, T, T, T, T]
+	6: [T, T, T, T, T, T]
+	7: [T, T, T, T, T, T, T]
+	8: [T, T, T, T, T, T, T, T]
+	9: [T, T, T, T, T, T, T, T, T]
+}
+type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C]

package/ts/tuple/readme.md

@@ -1,7 +1,6 @@
-# unknown
+# Tuple
 
-`unknown` is one of the top type in TypeScript.
-It is a "safer" variant of `any` that you cannot use the value until there are some type guards or type assertions to the value.
+A *tuple type* is another sort of `Array` type that knows exactly how many elements it contains, and exactly which types it contains at specific positions.
 
 ## Type Checking
 
@@ -10,18 +9,20 @@ The `TupleType<T>` and friends are used to check if `T` is a tuple, excluding ar
 ```ts
 import type { TupleType } from 'type-plus'
 
-type R = TupleType<unknown> // unknown
+type R = TupleType<[]> // []
+type R = TupleType<[1]> // [1]
 
-type R = TupleType<1> // never
+type R = TupleType<number[]> // never
+type R = TupleType<number> // never
 ```
 
-- [`TupleType<T, Then = T, Else = never>`](unknown_type.ts#L16): check if `T` is `unknown`.
-- [`IsUnknown<T, Then = true, Else = false`](unknown_type.ts#L35): is `T` `unknown`.
-- [`NotUnknownType<T, Then = T, Else = never>`](unknown_type.ts#L50): check if `T` is not `unknown`.
-- [`IsNotUnknown<T, Then = true, Else = false>`](unknown_type.ts#L65): is `T` not `unknown`.
+- [`TupleType<T, Then = T, Else = never>`](tuple_type.ts#L16): check if `T` is a *tuple*.
+- [`IsTuple<T, Then = true, Else = false`](tuple_type.ts#L35): is `T` *tuple*.
+- [`NotTupleType<T, Then = T, Else = never>`](tuple_type.ts#L50): check if `T` is not *tuple*.
+- [`IsNotTuple<T, Then = true, Else = false>`](tuple_type.ts#L65): is `T` not *tuple*.
 
 ## References
 
 - [Handbook]
 
-[handbook]: https://www.typescriptlang.org/docs/handbook/2/functions.html#unknown
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types

package/ts/tuple/tuple_plus.pad_start.ts

@@ -0,0 +1,42 @@
+/**
+ * Pads the start of a tuple with `PadWith`.
+ *
+ * If the `MaxLength` is less than the length of the tuple,
+ * the `Tuple` will be returned unchanged.
+ *
+ * @example
+ * ```ts
+ * PadStart<[1, 2, 3], 5, 0> // [0, 0, 1, 2, 3]
+ *
+ * // Ignore if MaxLength is less than the length of the tuple
+ * PadStart<[1, 2, 3], 5, 0> // [0, 0, 1, 2, 3]
+ *
+ * // Default to unknown
+ * PadStart<[1, 2, 3], 5> // [unknown, unknown, 1, 2, 3]
+ * ```
+ */
+export type PadStart<Tuple extends unknown[], MaxLength extends number, PadWith = unknown> = PadStartDevice<
+	Tuple,
+	MaxLength,
+	PadWith,
+	[]
+>
+
+type PadStartDevice<
+	Source extends unknown[],
+	MaxLength extends number,
+	PadWith,
+	Result extends unknown[]
+> = Result['length'] extends MaxLength
+	? Source extends []
+		? Result
+		: Source extends [...infer Head, infer Tail]
+		? [Tail, ...Result] extends infer R extends unknown[]
+			? PadStartDevice<Head, R['length'], PadWith, R>
+			: never
+		: never
+	: Source extends []
+	? PadStartDevice<Source, MaxLength, PadWith, [PadWith, ...Result]>
+	: Source extends [...infer Head, infer Tail]
+	? PadStartDevice<Head, MaxLength, PadWith, [Tail, ...Result]>
+	: Source

package/ts/tuple/tuple_plus.ts

@@ -0,0 +1 @@
+export * from './tuple_plus.pad_start.js'

package/ts/{predicates/isType.ts → type-guard/is_type.ts}

@@ -1,4 +1,4 @@
-import type { Equal } from '../equal/equal.js'
+import type { IsEqual } from '../equal/equal.js'
 
 /**
  * Is the subject of type T
@@ -12,20 +12,28 @@ export function isType(subject: unknown, validator?: (s: unknown) => unknown) {
 	return validator ? !!validator(subject) : true
 }
 
+/**
+ * @deprecated use `isType<T>()` or `testType.true<T>()` instead
+ */
 isType.t = function <T extends true>(subject?: T) {
 	return subject === undefined || subject === true
 }
 
+/**
+ * @deprecated use `isType<T>()` or `testType.false<T>()` instead
+ */
 isType.f = function <T extends false>(subject?: T) {
 	return subject === undefined || subject === false
 }
 
 /**
  * Check is the type `never`
+ * @deprecated use `isType<T>()` or `testType.never<T>()` instead
  */
 function isNever<S extends never>(): unknown
 /**
  * Check is the value is type `never`
+ * @deprecated use `isType<T>()` or `testType.never<T>()` instead
  */
 function isNever(subject: never): subject is never
 function isNever(subject?: unknown): subject is never {
@@ -39,6 +47,6 @@ isType.never = isNever
  * Easier to use than `isType.t<>()` and `isType.f<>()`,
  * when doing type level only equality comparison as you don't have to import `Equal<>`.
  *
- * @deprecated use `type.equal()` instead
+ * @deprecated use `testType.equal()` instead
  */
-isType.equal = function <C extends Equal<A, B>, A, B>() {}
+isType.equal = function <C extends IsEqual<A, B>, A, B>() {}

package/ts/type-guard/readme.md

@@ -0,0 +1,37 @@
+# Type Guard
+
+[User-defined type guard functions][type_guard] is a function which its return type is specified as `x as T`.
+
+It is introduced in TypeScript 1.6.
+
+For example:
+
+```ts
+function isBool(x: unknown): x is boolean {
+  return typeof x === 'boolean';
+}
+```
+
+## isType
+
+> `isType<T>(subject: T): subject is T`
+
+✔️ `immediate`
+
+It ensures `subject` satisfies `T`.
+You need to specify `T`.
+
+> `isType<T>(subject: unknown, validator: (s: T) => unknown): subject is T`
+
+It is a generic type guard.
+You can use it for do quick type guard without creating a custom one.
+
+```ts
+const s: unknown = 1
+
+if (isType<1>(s, v => v === 1)) {
+  // s is narrowed to type `1` here.
+}
+```
+
+[type_guard]: https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates

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

@@ -1 +0,0 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../ts/array/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,EAAE,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,MAAM,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,SAAS,MAAM,CAAC,GACtG,CAAC,SAAS,MAAM,GACf,CAAC,CAAC,CAAC,CAAC,GACJ,IAAI,GACL,KAAK,CAAA;AAER;;;;;;;;;;GAUG;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.js.map

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

package/cjs/array/create_tuple.d.ts

@@ -1,11 +0,0 @@
-import type { DigitArray } from '../math/index.js';
-import type { IsInteger } from '../number/integer.js';
-import type { IsPositive } from '../number/positive.js';
-/**
- * Creates `Tuple<T>` with `L` number of elements.
- * @note Other cool implementations by @lazytype, @jcalz:
- * @see https://github.com/microsoft/TypeScript/issues/26223#issuecomment-674514787
- * @see https://github.com/microsoft/TypeScript/issues/47874#issuecomment-1039157322
- */
-export type CreateTuple<L extends number, T = unknown, Fail = never> = number extends L ? T[] : IsPositive<L> extends true ? IsInteger<L> extends true ? DigitArray.ToTuple<[], DigitArray.FromNumber<L>, T> : Fail : Fail;
-//# sourceMappingURL=create_tuple.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create_tuple.d.ts","sourceRoot":"","sources":["../../ts/array/create_tuple.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,GAAG,OAAO,EAAE,IAAI,GAAG,KAAK,IAAI,MAAM,SAAS,CAAC,GACpF,CAAC,EAAE,GACH,UAAU,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1B,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GACxB,UAAU,CAAC,OAAO,CAAC,EAAE,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GACnD,IAAI,GACL,IAAI,CAAA"}

package/cjs/array/find_first.d.ts

@@ -1,6 +0,0 @@
-export type FindFirst<A extends Array<any>, Criteria> = number extends A['length'] ? A[0] extends Criteria ? A[0] : never : A['length'] extends 0 ? never : A extends [any, ...infer Tail] ? A[0] extends Criteria ? A[0] : FindFirst<Tail, Criteria> : never;
-/**
- * @deprecated use FindFirst
- */
-export type First<A extends any[], Criteria> = FindFirst<A, Criteria>;
-//# sourceMappingURL=find_first.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"find_first.d.ts","sourceRoot":"","sources":["../../ts/array/find_first.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,QAAQ,IAAI,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GAC/E,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GACpB,CAAC,CAAC,CAAC,CAAC,GACJ,KAAK,GACN,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACrB,KAAK,GACL,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,MAAM,IAAI,CAAC,GAC9B,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GACpB,CAAC,CAAC,CAAC,CAAC,GACJ,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,GAC1B,KAAK,CAAA;AAER;;GAEG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,QAAQ,IAAI,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAA"}

package/cjs/array/find_first.js.map

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

package/cjs/array/find_last.d.ts

@@ -1,2 +0,0 @@
-export type FindLast<A extends Array<any>, Criteria> = number extends A['length'] ? A[0] extends Criteria ? A[0] : never : A['length'] extends 0 ? never : A extends [...infer Heads, infer Last] ? Last extends Criteria ? Last : FindLast<Heads, Criteria> : never;
-//# sourceMappingURL=find_last.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"find_last.d.ts","sourceRoot":"","sources":["../../ts/array/find_last.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,QAAQ,IAAI,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GAC9E,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GACpB,CAAC,CAAC,CAAC,CAAC,GACJ,KAAK,GACN,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACrB,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,CAAA"}

package/cjs/array/find_last.js.map

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

package/cjs/array/pad_left.d.ts

@@ -1,6 +0,0 @@
-import type { IsAny } from '../any/any_type.js';
-import type { Equal } from '../equal/equal.js';
-import type { CreateTuple } from './create_tuple.js';
-import type { UnionOfValues } from './union_of_values.js';
-export type PadLeft<A extends any[], Total extends number, PadWith = any> = number extends A['length'] ? IsAny<UnionOfValues<A>> extends true ? A : Equal<UnionOfValues<A>, PadWith> extends true ? A : PadLeft<[...CreateTuple<Total, PadWith>, ...A], Total, PadWith> : CreateTuple<Total, any> extends [...infer U, ...A] ? number extends U['length'] ? A : [...CreateTuple<U['length'], PadWith>, ...A] : A;
-//# sourceMappingURL=pad_left.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pad_left.d.ts","sourceRoot":"","sources":["../../ts/array/pad_left.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,KAAK,SAAS,MAAM,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACnG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACnC,CAAC,GACD,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAC7C,CAAC,GACD,OAAO,CAAC,CAAC,GAAG,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,GAChE,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,GAClD,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACzB,CAAC,GACD,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,GAC7C,CAAC,CAAA"}

package/cjs/array/pad_left.js.map

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

package/cjs/array/some.d.ts

@@ -1,8 +0,0 @@
-import type { Equal } from '../equal/equal.js';
-import type { Tail } from './tail.js';
-import type { UnionOfValues } from './union_of_values.js';
-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> : number extends A['length'] ? UnionOfValues<A> extends Criteria ? Then : Else : A['length'] extends 0 ? Else : A[0] extends Criteria ? Then : Some<Tail<A>, Criteria, 'loose', Then, Else>;
-export declare namespace Some {
-    type Strict<A extends any[], Criteria, Then, Else> = number extends A['length'] ? Equal<UnionOfValues<A>, Criteria> extends true ? Then : Else : A['length'] extends 0 ? Else : Equal<A[0], Criteria> extends true ? Then : Strict<Tail<A>, Criteria, Then, Else>;
-}
-//# sourceMappingURL=some.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"some.d.ts","sourceRoot":"","sources":["../../ts/array/some.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,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,GACtB,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,GACpC,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GAC1B,aAAa,CAAC,CAAC,CAAC,SAAS,QAAQ,GAChC,IAAI,GACJ,IAAI,GACL,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACrB,IAAI,GACJ,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GACrB,IAAI,GACJ,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE/C,yBAAiB,IAAI,CAAC;IACrB,KAAY,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACnF,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,IAAI,GAC7C,IAAI,GACJ,IAAI,GACL,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACrB,IAAI,GACJ,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,IAAI,GAClC,IAAI,GACJ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;CACxC"}

package/cjs/array/some.js.map

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

package/cjs/math/Abs.d.ts

@@ -1,3 +0,0 @@
-import type { DigitArray } from './Digit.js';
-export type Abs<N extends number, Fail = never> = number extends N ? Fail : `${N}` extends `-${infer P}` ? DigitArray.ToNumber<DigitArray.FromString<P>> : N;
-//# sourceMappingURL=Abs.d.ts.map

package/cjs/math/Abs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Abs.d.ts","sourceRoot":"","sources":["../../ts/math/Abs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,GAAG,KAAK,IAAI,MAAM,SAAS,CAAC,GAC/D,IAAI,GACJ,GAAG,CAAC,EAAE,SAAS,IAAI,MAAM,CAAC,EAAE,GAC5B,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAC7C,CAAC,CAAA"}

package/cjs/math/Abs.js.map

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

package/cjs/math/Add.d.ts

@@ -1,19 +0,0 @@
-import type { PadLeft } from '../array/index.js';
-import type { IsInteger } from '../number/integer.js';
-import type { IsPositive } from '../number/positive.js';
-import type { And } from '../predicates/index.js';
-import type { Digit, DigitArray } from './Digit.js';
-import type { Max } from './Max.js';
-/**
- * Add two number literals.
- */
-export type Add<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsInteger<A>>, And<IsPositive<B>, IsInteger<B>>> extends false ? Fail : DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? DigitArray.ToNumber<Add.DigitArray<PDA, PDB>> : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail;
-export declare namespace Add {
-    type DigitArray<A extends number[], B extends number[]> = A extends [any, ...infer ATail] ? ATail extends number[] ? B extends [any, ...infer BTail] ? BTail extends number[] ? [Digit<A[0], B[0]>, ...DigitArray<ATail, BTail>] : [] : [A[0], ...DigitArray<[], ATail>] : [] : B extends [any, ...infer BTail] ? BTail extends number[] ? [B[0], ...DigitArray<[], BTail>] : [] : [];
-    type Digit<A extends number, B extends number> = [...Digit.ToTuple[A], ...Digit.ToTuple[B]]['length'];
-}
-/**
- * Increment `A` by 1.
- */
-export type Increment<A extends number, Fail = never> = Add<A, 1, Fail>;
-//# sourceMappingURL=Add.d.ts.map

package/cjs/math/Add.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Add.d.ts","sourceRoot":"","sources":["../../ts/math/Add.ts"],"names":[],"mappings":"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"}

package/cjs/math/Add.js.map

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