type-plus 6.8.1 → 7.0.0

package/ts/assertion/readme.md

@@ -1,12 +1,143 @@
-# Assertion Functions
+# Assertion
 
 [Assertion Functions][assertion_functions] are special functions that asserts certain conditions of your program.
 
+It is introduced in TypeScript 3.7.
+
 They throw an error if the condition is not met, and return nothing otherwise.
 
 These assertion functions are typically used in runtime,
 so that that type of the value can be narrowed down.
 
+## assertType
+
+`assertType<T>(subject)`:
+
+✔️ `immediate`
+
+It ensures `subject` satisfies `T`.
+It is similar to `const x: T = subject` without introducing an unused variable.
+You need to specify `T` for it to work.
+
+`assertType<T>(subject, validator)`:
+
+`assertType<T>(subject, Class)`:
+
+✔️ `assertion function`, `runtime`
+
+These overloads of `assertType` allow you to specify a `validator`.
+With these overloads, `subject` can be `unknown` or `any`.
+
+If `subject` fails the assertion,
+a standard `TypeError` will be thrown and provide better error info.
+For example:
+
+```ts
+const s: unknown = 1
+
+// TypeError: subject fails to satisfy s => typeof s === 'boolean'
+assertType<boolean>(s, s => typeof s === 'boolean')
+```
+
+The message beautification is provided by [`tersify`](https://github.com/unional/tersify).
+
+`assertType.isUndefined(subject)`:
+
+`assertType.isNull(subject)`:
+
+`assertType.isNumber(subject)`:
+
+`assertType.isBoolean(subject)`:
+
+`assertType.isTrue(subject)`:
+
+`assertType.isFalse(subject)`:
+
+`assertType.isString(subject)`:
+
+`assertType.isFunction(subject)`:
+
+`assertType.isConstructor(subject)`:
+
+`assertType.isError(subject)`:
+
+✔️ `immediate`, `assertion function`, `runtime`
+
+Compiler and runtime assertion with type narrowing from `any`.
+They assert the type of `subject` is that specific type.
+i.e. union type will fail at type level:
+
+```ts
+const s: number | undefined = undefined
+assertType.isUndefined(s) // TypeScript complains
+```
+
+They accept `any` and will be narrowed to the specific type.
+
+```ts
+const s: any = undefined
+assertType.isUndefined(s)
+s // type is undefined
+```
+
+`assertType.isNever(subject)`:
+
+✔️ `immediate`
+
+Check if the subject type is `never`.
+This function is not very useful in actual code as TypeScript will indicate the error.
+But it can be useful when writing tests for types.
+
+This is useful for variables. For type level only check, do the following:
+
+```ts
+assertType.isTrue(true as Equal<YourType, never>)
+```
+
+`assertType.noUndefined(subject)`:
+
+`assertType.noNull(subject)`:
+
+`assertType.noNumber(subject)`:
+
+`assertType.noBoolean(subject)`:
+
+`assertType.noTrue(subject)`:
+
+`assertType.noFalse(subject)`:
+
+`assertType.noString(subject)`:
+
+`assertType.noFunction(subject)`:
+
+`assertType.noError(subject)`:
+
+✔️ `immediate`, `runtime`
+
+Compiler and runtime assertion.
+Assert `subject` type does not contain the specific type.
+Work against unions.
+
+```ts
+const s: number | undefined = 1
+assertType.noUndefined(s) // TypeScript complains
+```
+
+They accept `subject` with type `any` or `unknown`,
+the assertion will happen in runtime to ensure `subject` is the specific type.
+
+`assertType.as<T>(subject)`:
+
+✔️ `immediate`
+
+Assert `subject` as `T` inline.
+This is useful to help TypeScript to adjust the type on the fly.
+
+```ts
+let s: number | undefined = 1
+assertType.as<1>(s) // `s` type is now `1`
+```
+
 ## References
 
 - [Handbook][assertion_functions]

package/ts/bigint/cast.ts

@@ -0,0 +1,13 @@
+/**
+ * Cast a string to a bigint literal type if possible.
+ *
+ * ```ts
+ * StringToBigint<'1n'> // 1n
+ * StringToBigint<'-1n'> // -1n
+ * ```
+ */
+export type StringToBigint<S extends string, Fail = never> = S extends `-0n`
+	? 0n
+	: S extends `${infer N extends bigint}n`
+	? N
+	: Fail

package/ts/bigint/readme.md

@@ -4,45 +4,45 @@
 
 ## Type Checking
 
-The `BigIntType<T>` and friends are used to check if a type is `bigint` or not.
+The `BigintType<T>` and friends are used to check if a type is `bigint` or not.
 
 They are loose type checks, meaning they match `bigint` and bigint literals,
 as well as intersection types.
 
 ```ts
-import type { BigIntType } from 'type-plus'
+import type { BigintType } from 'type-plus'
 
-type R = BigIntType<bigint> // bigint
+type R = BigintType<bigint> // bigint
 
-type R = BigIntType<1n> // bigint
-type R = BigIntType<bigint & { a: 1}> // bigint
+type R = BigintType<1n> // bigint
+type R = BigintType<bigint & { a: 1}> // bigint
 ```
 
-- [`BigIntType<T, Then = T, Else = never>`](bigint_type.ts#L15): check if `T` is `bigint` or bigint literal.
-- [`IsBigInt<T, Then = true, Else = false`](bigint_type.ts#L33): is `T` `bigint`.
-- [`NotBigIntType<T, Then = T, Else = never>`](bigint_type.ts#L47): check if `T` is not `bigint`.
+- [`BigintType<T, Then = T, Else = never>`](bigint_type.ts#L15): check if `T` is `bigint` or bigint literal.
+- [`IsBigint<T, Then = true, Else = false`](bigint_type.ts#L33): is `T` `bigint`.
+- [`NotBigintType<T, Then = T, Else = never>`](bigint_type.ts#L47): check if `T` is not `bigint`.
 - [`IsNotBigInt<T, Then = true, Else = false>`](bigint_type.ts#L61): is `T` not `bigint`.
 
 ---
 
-The `StrictBigIntType<T>` and friends are used to check if a type is exactly `bigint` or not.
+The `StrictBigintType<T>` and friends are used to check if a type is exactly `bigint` or not.
 
 They are strict type checks, meaning they match only the type `bigint`,
 and not bigint literals or intersection types.
 
 ```ts
-import type { StrictBigIntType } from 'type-plus'
+import type { StrictBigintType } from 'type-plus'
 
-type R = StrictBigIntType<bigint> // bigint
+type R = StrictBigintType<bigint> // bigint
 
-type R = StrictBigIntType<1n> // never
-type R = StrictBigIntType<bigint & { a: 1}> // never
+type R = StrictBigintType<1n> // never
+type R = StrictBigintType<bigint & { a: 1}> // never
 ```
 
-- [`StrictBigIntType<T, Then = T, Else = never>`](strict_bigint_type.ts#L15): check if `T` is exactly `bigint`.
-- [`IsStrictBigInt<T, Then = true, Else = false`](strict_bigint_type.ts#L33): is `T` exactly `bigint`.
-- [`NotStrictBigIntType<T, Then = T, Else = never>`](strict_bigint_type.ts#L47): check if `T` is not exactly `bigint`.
-- [`IsNotStrictBigInt<T, Then = true, Else = false>`](strict_bigint_type.ts#L61): is `T` not exactly `bigint`.
+- [`StrictBigintType<T, Then = T, Else = never>`](strict_bigint_type.ts#L15): check if `T` is exactly `bigint`.
+- [`IsStrictBigint<T, Then = true, Else = false`](strict_bigint_type.ts#L33): is `T` exactly `bigint`.
+- [`NotStrictBigintType<T, Then = T, Else = never>`](strict_bigint_type.ts#L47): check if `T` is not exactly `bigint`.
+- [`IsNotStrictBigint<T, Then = true, Else = false>`](strict_bigint_type.ts#L61): is `T` not exactly `bigint`.
 
 ## References
 

package/ts/equal/equal.ts

@@ -37,8 +37,12 @@ type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2)
  * type R = Equal<[any], [1]> // false
  * type R = Equal<{ a: 1 }, { a: 1; b: 2 }> // false
  * ```
+ *
+ * Note that intersection type checks only works at first level.
+ * It cannot be check recursively,
+ * or else will run into infinite recursion if the type includes recursive types.
  */
-export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
+export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
 	? BothNever<
 			A,
 			B,
@@ -60,7 +64,7 @@ export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
 							Properties<A>,
 							Properties<B>,
 							[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
-								? Equal<P1, P2, Then, Else>
+								? IsEqual<P1, P2, Then, Else>
 								: Then,
 							Else
 						>,
@@ -88,5 +92,51 @@ export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
  * type R = NotEqual<[any], [1]> // true
  * type R = NotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
  * ```
+ *
+ * Note that intersection type checks only works at first level.
+ * It cannot be check recursively,
+ * or else will run into infinite recursion if the type includes recursive types.
+ */
+export type IsNotEqual<A, B, Then = true, Else = false> = IsEqual<A, B, Else, Then>
+
+/**
+ * Checks `A` and `B` are equal.
+ *
+ * @deprecated this will be changed to `filter` variant in the future.
+ * Please use `IsEqual` for the `predicate` behavior.
+ *
+ * ```ts
+ * type R = Equal<1, 1> // true
+ * type R = Equal<any, any> // true
+ * type R = Equal<boolean, boolean> // true
+ * type R = Equal<true, true> // true
+ * type R = Equal<[1], [1]> // true
+ *
+ * type R = Equal<boolean, true> // false
+ * type R = Equal<any, 1> // false
+ * type R = Equal<[any], [1]> // false
+ * type R = Equal<{ a: 1 }, { a: 1; b: 2 }> // false
+ * ```
+ */
+export type Equal<A, B, Then = true, Else = false> = IsEqual<A, B, Then, Else>
+
+/**
+ * Checks `A` and `B` are not equal.
+ *
+ * @deprecated this will be changed to `filter` variant in the future.
+ * Please use `IsNotEqual` for the `predicate` behavior.
+ *
+ * ```ts
+ * type R = NotEqual<1, 1> // false
+ * type R = NotEqual<any, any> // false
+ * type R = NotEqual<boolean, boolean> // false
+ * type R = NotEqual<true, true> // false
+ * type R = NotEqual<[1], [1]> // false
+ *
+ * type R = NotEqual<boolean, true> // true
+ * type R = NotEqual<any, 1> // true
+ * type R = NotEqual<[any], [1]> // true
+ * type R = NotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * ```
  */
-export type NotEqual<A, B, Then = true, Else = false> = Equal<A, B, Else, Then>
+export type NotEqual<A, B, Then = true, Else = false> = IsNotEqual<A, B, Then, Else>

package/ts/equal/readme.md

@@ -1,27 +1,41 @@
-# Equal
+# IsEqual
 
-`Equal<A, B>` and friends check if `A` and `B` are equal.
+`IsEqual<A, B>` and friends check if `A` and `B` are equal.
 
 It is a type-level version of `===`.
 It handles special types (`any`, `unknown`, `never`, `void`) correctly.
 
 ```ts
-import { type Equal } from 'type-plus'
-
-type R = Equal<1, 1> // true
-type R = Equal<any, any> // true
-type R = Equal<boolean, boolean> // true
-type R = Equal<true, true> // true
-type R = Equal<[1], [1]> // true
-
-type R = Equal<boolean, true> // false
-type R = Equal<any, 1> // false
-type R = Equal<[any], [1]> // false
-type R = Equal<{ a: 1 }, { a: 1; b: 2 }> // false
+import { type IsEqual } from 'type-plus'
+
+type R = IsEqual<1, 1> // true
+type R = IsEqual<any, any> // true
+type R = IsEqual<boolean, boolean> // true
+type R = IsEqual<true, true> // true
+type R = IsEqual<[1], [1]> // true
+
+type R = IsEqual<boolean, true> // false
+type R = IsEqual<any, 1> // false
+type R = IsEqual<[any], [1]> // false
+type R = IsEqual<{ a: 1 }, { a: 1; b: 2 }> // false
 ```
 
-- [`Equal<A, B, Then = true, Else = false>`](equal.ts#L27): check if `A` and `B` are equal.
-- [`NotEqual<A, B, Then = true, Else = false>`](equal.ts#L88): check if `A` and `B` are not equal.
+Note that intersection type checks only works at first level.
+It cannot be check recursively,
+or else will run into infinite recursion if the type includes recursive types.
+
+i.e.
+
+```ts
+// true
+IsEqual<{ a: 1 } & { b: 2 }, { a: 1; b: 2 }>
+
+// false
+IsEqual<{ nested: { a: number; b: string } }, { nested: { a: number } & { b: string } }>
+```
+
+- [`IsEqual<A, B, Then = true, Else = false>`](equal.ts#L27): check if `A` and `B` are equal.
+- [`IsNotEqual<A, B, Then = true, Else = false>`](equal.ts#L88): check if `A` and `B` are not equal.
 
 ---
 

package/ts/functional/Maybe.ts

@@ -1,5 +1,5 @@
 import type { Brand } from '../nominal/index.js'
-import type { Equal } from '../equal/equal.js'
+import type { IsEqual } from '../equal/equal.js'
 import type { Widen } from '../utils/index.js'
 
 export type Maybe<T> = Just<T> | None<T>
@@ -8,7 +8,7 @@ export type None<T> = Brand<'maybe', void> & { unwrap(): T }
 
 export function just<T>(
 	value: T
-): Equal<T, undefined | null> extends true ? None<T> : Just<Widen<NonNullable<T>>> {
+): IsEqual<T, undefined | null> extends true ? None<T> : Just<Widen<NonNullable<T>>> {
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
 	return {
 		unwrap() {

package/ts/index.ts

@@ -1,12 +1,14 @@
 export { required, requiredDeep, unpartial } from 'unpartial'
 export type { IsAnyOrNever } from './any/any_or_never.js'
 export type { AnyType, IsAny, IsNotAny, NotAnyType } from './any/any_type.js'
-export type { At, Concat } from './array/array.js'
+export type { At } from './array/array.at.js'
+export type { Concat } from './array/array.concat.js'
 export * as ArrayPlus from './array/array_plus.js'
 export type { ArrayType, IsArray, IsNotArray, NotArrayType } from './array/array_type.js'
 export * from './array/index.js'
 export * from './assertion/assert_type.js'
 export type { BigintType, IsBigint, IsNotBigint, NotBigintType } from './bigint/bigint_type.js'
+export type { StringToBigint } from './bigint/cast.js'
 export type {
 	IsNotStrictBigint,
 	IsStrictBigint,
@@ -24,7 +26,7 @@ export type {
 export type { IsNotTrue, IsTrue, NotTrueType, TrueType } from './boolean/true_type.js'
 export * from './class/index.js'
 export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
-export type { Equal, NotEqual } from './equal/equal.js'
+export type { Equal, IsEqual, IsNotEqual, NotEqual } from './equal/equal.js'
 export type { AnyFunction } from './function/any_function.js'
 export * from './function/extract_function.js'
 export type { FunctionType, IsFunction, IsNotFunction, NotFunctionType } from './function/function_type.js'
@@ -36,25 +38,25 @@ export type {
 } from './function/strict_function_type.js'
 export * from './functional/index.js'
 export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
-export type {
-	Abs,
-	Add,
-	Decrement,
-	Digit,
-	DigitArray,
-	GreaterThan,
-	Increment,
-	Max,
-	Subtract
-} from './math/index.js'
+export type { Abs, Add, Decrement, GreaterThan, Increment, Max, Multiply, Subtract } from './math/index.js'
+export * as MathPlus from './math/math_plus.js'
 export type { IsNever, IsNotNever, Is_Never, NeverType, NotNeverType, Not_Never } from './never/never_type.js'
 export * from './nodejs/index.js'
 export * from './nominal/index.js'
 export type { IsNotNull, IsNull, NotNullType, NullType } from './null/null_type.js'
-export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './number/integer.js'
-export type { IsNegative, IsNotNegative, Negative, NotNegative } from './number/negative.js'
+export type { StringToNumber } from './number/cast.js'
 export * as NumberPlus from './number/number_plus.js'
 export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number/number_type.js'
+export type {
+	IsNotStrictNumber,
+	IsStrictNumber,
+	NotStrictNumberType,
+	StrictNumberType
+} from './number/strict_number_type.js'
+export type { NumericToString, StringToNumeric } from './numeric/cast.js'
+export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './numeric/integer.js'
+export type { IsNegative, IsNotNegative, Negative, NotNegative } from './numeric/negative.js'
+export * as NumericPlus from './numeric/numeric_plus.js'
 export type {
 	IsNotNumeric,
 	IsNumeric,
@@ -62,14 +64,8 @@ export type {
 	Numeric,
 	NumericType,
 	Zero
-} from './number/numeric_type.js'
-export type { IsNotPositive, IsPositive, NonPositive, Positive } from './number/positive.js'
-export type {
-	IsNotStrictNumber,
-	IsStrictNumber,
-	NotStrictNumberType,
-	StrictNumberType
-} from './number/strict_number_type.js'
+} from './numeric/numeric_type.js'
+export type { IsNotPositive, IsPositive, NonPositive, Positive } from './numeric/positive.js'
 export * from './object/index.js'
 export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
 export * from './predicates/index.js'
@@ -87,7 +83,10 @@ export type { IsNotString, IsString, NotStringType, StringType } from './string/
 export type { IsNotSymbol, IsSymbol, NotSymbolType, SymbolType } from './symbol/symbol_type.js'
 export * from './testing/stub.js'
 export * from './testing/test_type.js'
+export * from './tuple/create_tuple.js'
+export * as TuplePlus from './tuple/tuple_plus.js'
 export type { IsNotTuple, IsTuple, NotTupleType, TupleType } from './tuple/tuple_type.js'
+export * from './type-guard/is_type.js'
 export type { Failed, FailedT } from './type/failed.js'
 export type { NoInfer } from './type/no_infer.js'
 export type {
@@ -100,4 +99,3 @@ export type { UnionKeys } from './union_keys.js'
 export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
 export * from './utils/index.js'
 export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
-

package/ts/math/README.md

@@ -1,7 +1,97 @@
-# Math
-
-## References
-
-- [Implementing Arithmetic Within TypeScript’s Type System](https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f)
-- [typepark](https://github.com/kgtkr/typepark)
-- [typical](https://github.com/KiaraGrouwstra/typical/tree/master/src)
+# Math
+
+## Add
+
+> `Add<A, B>` | `MathPlus.Add<A, B>`
+
+Performs `A + B` which can be either `number` or `bigint`.
+
+It supports positive, negative, floating point numbers.
+It will perform coerce conversion if the necessary.
+
+```ts
+Add<1, 2> // 3
+Add<1.2, -2> // -0.8
+Add<1n, 2.3> // 3.3 <-- converted to `number`
+Add<9007199254740992, 1> // 9007199254740993n <-- converted to `bigint`
+```
+
+## Subtract
+
+> `Subtract<A, B>` | `MathPlus.Subtract<A, B>`
+
+Performs `A - B` which can be either `number` or `bigint`.
+
+It supports positive, negative, floating point numbers.
+It will perform coerce conversion if the necessary.
+
+```ts
+Subtract<100, 2> // 98
+Subtract<1.2, 2> // -0.8
+Subtract<1n, 2.3> // -1.3 <-- converted to `number`
+```
+
+## Multiply
+
+> `Multiply<A, B>` | `MathPlus.Multiply<A, B>`
+
+Performs `A * B` which can be either `number` or `bigint`.
+
+It supports positive, negative, floating point numbers.
+It will perform coerce conversion if the necessary.
+
+```ts
+Multiply<100, 2> // 200
+Multiply<1.2, 2> // 2.4
+Multiply<1n, 2.3> // 2.3 <-- converted to `number`
+```
+
+## GreaterThan
+
+> `GreaterThan<A, B>` | `MathPlus.GreaterThan<A, B>`
+
+Performs `A > B` which can be either `number` or `bigint`.
+
+```ts
+GreaterThan<100, 2> // true
+GreaterThan<-1, 2> // false
+GreaterThan<1.2, 2> // false
+```
+
+## Max
+
+> `Max<A, B>` | `MathPlus.Max<A, B>`
+
+Performs `Math.max(A, B)` which can be either `number` or `bigint`.
+
+```ts
+Max<100, 2> // 100
+Max<-1, 2> // 2
+Max<1.2, 2> // 2
+```
+
+## MathPlus
+
+`MathPlus` contains all types and type utilities related to math.
+
+### [`MathPlus.ToNegative`](./math.to-negative.ts#L12)
+
+> `MathPlus.ToNegative<N>`
+
+Converts a number or bigint `N` to negative.
+If `N` is already negative, it returns itself.
+
+```ts
+MathPlus.ToNegative<5> // -5
+MathPlus.ToNegative<0> // 0
+MathPlus.ToNegative<-5> // -5
+```
+
+## References
+
+- [Implementing Arithmetic Within TypeScript’s Type System](https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f)
+- [typepark](https://github.com/kgtkr/typepark)
+- [typical](https://github.com/KiaraGrouwstra/typical/tree/master/src)
+
+- <https://stackoverflow.com/questions/3060064/how-computer-multiplies-2-numbers>
+- <https://en.wikipedia.org/wiki/Binary_multiplier>

package/ts/math/abs.ts

@@ -0,0 +1,18 @@
+import type { IsBigint } from '../bigint/bigint_type.js'
+import type { IsNumber } from '../number/number_type.js'
+
+/*
+ * Returns the absolute value of a number or bigint `N`.
+ *
+ * @example
+ * ```ts
+ * Abs<-5> // 5
+ * Abs<5> // 5
+ * Abs<-1n> // 1n  // Where `1n` is a bigint
+ * ```
+ */
+export type Abs<N extends number | bigint, Fail = never> = IsNumber<
+	N,
+	[number] extends [N] ? Fail : `${N}` extends `-${infer P extends number}` ? P : N,
+	IsBigint<N, [bigint] extends [N] ? Fail : `${N}` extends `-${infer P extends bigint}` ? P : N, Fail>
+>

package/ts/math/add.ts

@@ -0,0 +1,14 @@
+import type { NumericStruct } from './numeric_struct.js'
+
+export type Add<A extends number | bigint, B extends number | bigint, Fail = never> = [
+	NumericStruct.FromNumeric<A, Fail>,
+	NumericStruct.FromNumeric<B, Fail>
+] extends [infer MA, infer MB]
+	? MA extends NumericStruct
+		? MB extends NumericStruct
+			? NumericStruct.ToNumeric<NumericStruct.Add<MA, MB>>
+			: Fail
+		: Fail
+	: never
+
+export type Increment<N extends number | bigint> = Add<N, 1>

package/ts/math/greater_than.ts

@@ -0,0 +1,12 @@
+import type { IsPositive } from '../numeric/positive.js'
+import type { Subtract } from './subtract.js'
+
+export type GreaterThan<A extends number | bigint, B extends number | bigint, Fail = never> = Subtract<
+	A,
+	B,
+	'fail'
+> extends infer R extends number
+	? R extends 0
+		? false
+		: IsPositive<R>
+	: Fail

package/ts/math/index.ts

@@ -1,6 +1,7 @@
-export type { Abs } from './Abs.js'
-export type { Add, Increment } from './Add.js'
-export type { Digit, DigitArray } from './Digit.js'
-export type { GreaterThan } from './GreaterThan.js'
-export type { Max } from './Max.js'
-export type { Decrement, Subtract } from './Subtract.js'
+export type { Abs } from './abs.js'
+// export type { Digit, DigitArray } from './Digit.js'
+export type { GreaterThan } from './greater_than.js'
+export type { Max } from './max.js'
+export type { Add, Increment } from './add.js'
+export type { Multiply } from './multiply.js'
+export type { Decrement, Subtract } from './subtract.js'

package/ts/math/math_plus.to_negative.ts

@@ -0,0 +1,22 @@
+/**
+ * Converts a number or bigint `N` to negative.
+ * If `N` is already negative, it returns itself.
+ *
+ * @example
+ * ```ts
+ * ToNegative<5> // -5
+ * ToNegative<0> // 0
+ * ToNegative<-5> // -5
+ * ```
+ */
+export type ToNegative<N extends number | bigint> = N extends number
+	? N extends 0
+		? 0
+		: `-${N}` extends `${infer W extends number}`
+		? W
+		: N
+	: N extends 0n
+	? 0n
+	: `-${N}` extends `${infer W extends bigint}`
+	? W
+	: N

package/ts/math/math_plus.ts

@@ -0,0 +1,4 @@
+export type { Add, Increment } from './add.js'
+export type { ToNegative } from './math_plus.to_negative.js'
+export type { Multiply } from './multiply.js'
+export type { Decrement, Subtract } from './subtract.js'