type-plus 7.6.0 → 8.0.0-beta.0

package/ts/array/loose_array_type.ts

@@ -0,0 +1,69 @@
+import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
+
+/**
+ * 🌪️ *filter*
+ * 🚧 *temporary*
+ *
+ * Filter `T` to ensure it is an array or tuple.
+ *
+ * This is a temporary type before `ArrayType` is adjusted to loose check in the next version.
+ *
+ * @example
+ * ```ts
+ * type R = LooseArrayType<number[]> // number[]
+ * type R = LooseArrayType<[1]> // [1]
+ * type R = LooseArrayType<number[] | 1> // number[]
+ * type R = LooseArrayType<number[] & 1> // number[]s
+ *
+ * type R = LooseArrayType<string> // never
+ * ```
+ */export type LooseArrayType<T, Then = T, Else = never> = IsAnyOrNever<
+	T,
+	Else,
+	T extends readonly any[] ? Then : Else
+>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is an array or tuple.
+ *
+ * @example
+ * ```ts
+ * type R = IsLooseArray<number[]> // true
+ * type R = IsLooseArray<[1]> // true
+ *
+ * type R = IsLooseArray<number> // false
+ * ```
+ */
+export type IsLooseArray<T, Then = true, Else = false> = LooseArrayType<T, Then, Else>
+
+/**
+ * 🌪️ *filter*
+ *
+ * Filter `T` to ensure it is not an array nor tuple.
+ *
+ * @example
+ * ```ts
+ * type R = NotLooseArrayType<number[]> // never
+ * type R = NotLooseArrayType<[1]> // never
+ *
+ * type R = NotLooseArrayType<number> // number
+ * ```
+ */
+export type NotLooseArrayType<T, Then = T, Else = never> = LooseArrayType<T, Else, Then>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is not an array nor tuple.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotLooseArray<number[]> // false
+ * type R = IsNotLooseArray<[1]> // false
+ *
+ * type R = IsNotLooseArray<number> // true
+ * ```
+ */
+export type IsNotLooseArray<T, Then = true, Else = false> = LooseArrayType<T, Else, Then>

package/ts/array/pad_start.ts

@@ -26,7 +26,7 @@ import type { PadStart as PadStartArray } from './array_plus.pad_start.js'
  * ```
  */
 export type PadStart<
-	A extends unknown[],
+	A extends readonly unknown[],
 	MaxLength extends number,
 	PadWith = unknown
 > = number extends A['length']

package/ts/array/readme.md

@@ -14,7 +14,7 @@ The `ArrayType<T>` and friends are used to check if a type is exactly `Array<T>`
 They are strict type checks, meaning they match only the type `Array<T>`,
 and not [tuple], [union], or intersection types.
 
-### [ArrayType](./array_type.ts#18)
+### [ArrayType](./array_type.ts#l18)
 
 `ArrayType<T, Then = T, Else = never>`
 
@@ -32,7 +32,7 @@ type R = ArrayType<number[] | 1> // never
 type R = ArrayType<number[] & { a: 1 }> // never
 ```
 
-### [IsArray](./array_type.ts#37)
+### [IsArray](./array_type.ts#l41)
 
 `IsArray<T, Then = true, Else = false>`
 
@@ -49,7 +49,7 @@ type R = IsArray<number> // false
 type R = IsArray<[1]> // false
 ```
 
-### [NotArrayType](./array_type.ts#54)
+### [NotArrayType](./array_type.ts#l58)
 
 `NotArrayType<T, Then = T, Else = never>`
 
@@ -66,7 +66,7 @@ type R = NotArrayType<number> // number
 type R = NotArrayType<[1]> // [1]
 ```
 
-### [IsNotArrayType](./array_type.ts#71)
+### [IsNotArrayType](./array_type.ts#l75)
 
 `IsNotArrayType<T, Then = true, Else = false>`
 
@@ -113,7 +113,7 @@ If the `N` is out of bound,
 or `N` is not a valid index,
 `ArrayPlus.At` will return the `Fail` case, which defaults to `never`.
 
-## [`Concat`](./array.concat.ts#L12)
+## [`Concat`](./array_plus.concat.ts#l15)
 
 `Concat<A, B>`
 
@@ -129,7 +129,7 @@ You are encouraged to use `[...A, ...B]` directly.
 
 ## [`FindFirst`](./find_first.ts#l52)
 
-`FindFirst<A, Criteria, Options = { widen, caseEmptyTuple, caseNever, caseNoMatch, caseWiden, caseUnionMiss }>`
+`FindFirst<A, Criteria, Options = { widen, caseEmptyTuple, $never, $noMatch, $widen, $unionMiss }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -154,14 +154,14 @@ type R = FindFirst<string[], number> // never
 
 // customization
 type R = FindFirst<[number], 1, { widen: false }> // never
-type R = FindFirst<[number], 1, { caseWiden: never }> // never
+type R = FindFirst<[number], 1, { $widen: never }> // never
 type R = FindFirst<[], 1, { caseEmptyTuple: 2 }> // 2
-type R = FindFirst<never, 1, { caseNever: 2 }> // 2
-type R = FindFirst<[string], number, { caseNotMatch: 2 }> // 2
-type R = FindFirst<[string | number], number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = FindFirst<never, 1, { $never: 2 }> // 2
+type R = FindFirst<[string], number, { $notMatch: 2 }> // 2
+type R = FindFirst<[string | number], number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
-## [`FindLast`](./array.find_last.ts)
+## [`FindLast`](./array.find_last.tsl19)
 
 ## [`Some`](./array.some.ts)
 
@@ -198,7 +198,7 @@ type R = KeepMatch<Array<string | undefined>, string> // string[]
 
 ## [`Head`](./head.ts#l23)
 
-`Head<T, Options = { caseNever, caseEmptyTuple }>`
+`Head<T, Options = { $never, caseEmptyTuple }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -210,11 +210,11 @@ import type { Head } from 'type-plus'
 
 type R = Head<[1, 2, 3]> // 1
 type R = Head<string[]> // string
-type R = Head<never> // caseNever: never
+type R = Head<never> // $never: never
 type R = Head<[]> // caseEmptyTuple: never
 
 // customization
-type R = Head<never, { caseNever: 1 }> // 1
+type R = Head<never, { $never: 1 }> // 1
 type R = Head<[], { caseEmptyTuple: undefined }> // undefined
 ```
 
@@ -224,7 +224,7 @@ type R = Head<[], { caseEmptyTuple: undefined }> // undefined
 
 ## [`Last`](./last.ts#l23)
 
-`Last<T, Options = { caseNever, caseEmptyTuple }>`
+`Last<T, Options = { $never, caseEmptyTuple }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -236,11 +236,11 @@ import type { Last } from 'type-plus'
 
 type R = Last<[1, 2, 3]> // 3
 type R = Last<string[]> // string
-type R = Last<never> // caseNever: never
+type R = Last<never> // $never: never
 type R = Last<[]> // caseEmptyTuple: never
 
 // customization
-type R = Last<never, { caseNever: 1 }> // 1
+type R = Last<never, { $never: 1 }> // 1
 type R = Last<[], { caseEmptyTuple: undefined }> // undefined
 ```
 
@@ -273,9 +273,9 @@ please check [`TuplePlus`](../tuple/readme.md#TuplePlus).
 
 Alias of [At](#at).
 
-## [ArrayPlus.CommonPropKeys](./array_plus.common_prop_keys.ts#l21)
+### [ArrayPlus.CommonPropKeys](./array_plus.common_prop_keys.ts#l21)
 
-`ArrayPlus.CommonPropKeys<T extends Record[], Options = { caseNever }>`
+`ArrayPlus.CommonPropKeys<T extends Record[], Options = { $never }>`
 
 ⚗️ *transform*
 🔢 *customizable*
@@ -289,7 +289,7 @@ type R = ArrayPlus.CommonPropKeys<Array<{ a: 1 }>> // 'a'
 type R = ArrayPlus.CommonPropKeys<Array<{ a: 1, b: 1 } | { a: 1, c: 1 }>> // 'a'
 
 // customization
-type R = ArrayPlus.CommonPropKeys<never, { caseNever: 1 }> // 1
+type R = ArrayPlus.CommonPropKeys<never, { $never: 1 }> // 1
 ```
 
 ### [`ArrayPlus.Concat`](./array.concat.ts#l12)
@@ -300,7 +300,7 @@ Alias of [Concat](#concat).
 
 ### [`ArrayPlus.ElementMatch`](./array_plus.element_match.ts#l30)
 
-`ArrayPlus.ElementMatch<T, Criteria, Options = { widen, caseNotMatch, caseWiden, caseUnionNotMatch }>`
+`ArrayPlus.ElementMatch<T, Criteria, Options = { widen, $notMatch, $widen, $unionNotMatch }>`
 
 🌪️ *filter*
 🔢 *customizable*
@@ -317,10 +317,10 @@ type R = ArrayPlus.ElementMatch<number, 1> // widen: 1
 type R = ArrayPlus.ElementMatch<number | string, number> // unionNotMatch: number
 
 // customization
-type R = ArrayPlus.ElementMatch<number, string, { caseNotMatch: 1 }> // 1
+type R = ArrayPlus.ElementMatch<number, string, { $notMatch: 1 }> // 1
 type R = ArrayPlus.ElementMatch<number, 1, { widen: false }> // never
-type R = ArrayPlus.ElementMatch<number, 1, { caseWiden: never }> // never
-type R = ArrayPlus.ElementMatch<number | string, number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = ArrayPlus.ElementMatch<number, 1, { $widen: never }> // never
+type R = ArrayPlus.ElementMatch<number | string, number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
 ### [`ArrayPlus.Entries`](./array.entries.ts#L14)
@@ -337,9 +337,26 @@ type R = ArrayPlus.Entries<Array<string | number>> // Array<[number, string | nu
 type R = ArrayPlus.Entries<[1, 2, 3]> // [[0, 1], [1, 2], [2, 3]]
 ```
 
+### [`ArrayPlus.Filter`](./array_plus.filter.ts#l11)
+
+`ArrayPlus.Filter<A, Criteria, Options = { $notArray }>`
+
+⚗️ *transform*
+🔢 *customizable*
+
+Filter the array `A`, keeping entries satisfying `Criteria`.
+
+```ts
+type R = Filter<Array<string | undefined>, string> // string[]
+
+// customization
+type R = Filter<never, string, { caseNever: 1 }> // 1
+type R = Filter<['x'], string, { $notArray: 1 }> // 1
+```
+
 ### [`ArrayPlus.Find`](./array_plus.find.ts#l49)
 
-`ArrayPlus.Find<A, Criteria, Options { widen, caseNever, caseNotMatch, caseTuple, caseWiden, caseUnionNotMatch }>`
+`ArrayPlus.Find<A, Criteria, Options { widen, $never, $notMatch, $tuple, $widen, $unionNotMatch }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -359,11 +376,11 @@ type R = ArrayPlus.Find<string[], number> // never
 
 // customization
 type R = ArrayPlus.Find<number[], 1, { widen: false }> // never
-type R = ArrayPlus.Find<number[], 1, { caseWiden: never }> // never
-type R = ArrayPlus.Find<never, 1, { caseNever: 2 }> // 2
-type R = ArrayPlus.Find<string[], number, { caseNotMatch: 2 }> // 2
-type R = ArrayPlus.Find<[], 1, { caseTuple: 2 }> // 2
-type R = ArrayPlus.Find<Array<string | number>, number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = ArrayPlus.Find<number[], 1, { $widen: never }> // never
+type R = ArrayPlus.Find<never, 1, { $never: 2 }> // 2
+type R = ArrayPlus.Find<string[], number, { $notMatch: 2 }> // 2
+type R = ArrayPlus.Find<[], 1, { $tuple: 2 }> // 2
+type R = ArrayPlus.Find<Array<string | number>, number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
 ### [`ArrayPlus.FindLast`](./array.find_last.ts#L17)
@@ -382,7 +399,60 @@ ArrayPlus.FindLast<Array<1 | 2 | 'x'>, number> // 1 | 2 | undefined
 ArrayPlus.FindLast<[true, 123, 'x', 321], number> // 321
 ```
 
-### [`ArrayPlus.Reverse`](./array.reverse.ts#L14)
+### [`ArrayPlus.IndexAt](./array_plus.index_at.ts#l25)
+
+`ArrayPlus.IndexAt<A, Index>`
+
+🦴 *utilities*
+
+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
+```
+
+### [`ArrayPlus.IsIndexOutOfBound](./array_plus.is_index_out_of_bound.ts#l18)
+
+🎭 *validate*
+
+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
+```
+
+### [`ArrayPlus.IsReadonly](./array_plus.is_readonly.ts#l19)
+
+`ArrayPlus.IsReadonly<A, Options = { $then, $else, $never, $notArray }>`
+
+🎭 *validate*
+🔢 *customizable*
+
+Checks if `A` is a readonly array or tuple.
+
+```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
+
+// customization
+type R = IsReadonly<readonly string[], { $then: 1 }> // 1
+type R = IsReadonly<string[], { $else: 1 }> // 1
+type R = IsReadonly<number, { $notArray: 1 }> // 1
+type R = IsReadonly<never, { $never: 1 }> // 1
+```
+
+### [`ArrayPlus.Reverse`](./array.reverse.ts#l14)
 
 > `ArrayPlus.Reverse<A>`
 

package/ts/array/strict_array_type.ts

@@ -0,0 +1,75 @@
+import type { IsNever } from '../never/never_type.js'
+import type { StrictNumberType } from '../number/strict_number_type.js'
+
+/**
+ * 🌪️ *filter*
+ *
+ * Filter `T` to ensure it is an array, excluding tuple.
+ *
+ * @example
+ * ```ts
+ * type R = StrictArrayType<number[]> // number[]
+ *
+ * type R = StrictArrayType<[1]> // never
+ * type R = StrictArrayType<number[] | 1> // never
+ * type R = StrictArrayType<number[] & { a: 1 }> // never
+ * ```
+ */
+export type StrictArrayType<T, Then = T, Else = never> = IsNever<
+	T,
+	Else,
+	[any[]] extends [T]
+	? ([T] extends [readonly any[]]
+		? StrictNumberType<T['length'], Then, Else>
+		: Else)
+	: Else
+>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is an array, excluding tuple.
+ *
+ * @example
+ * ```ts
+ * type R = IsStrictArray<number[]> // true
+ *
+ * type R = IsStrictArray<number> // false
+ * type R = IsStrictArray<[1]> // false
+ * ```
+ */
+export type IsStrictArray<T, Then = true, Else = false> = StrictArrayType<T, Then, Else>
+
+/**
+ * 🌪️ *filter*
+ *
+ * Filter `T` to ensure it is not an array, excluding tuple.
+ *
+ * i.e. *tuple* will pass through this filter.
+ *
+ * @example
+ * ```ts
+ * type R = NotStrictArrayType<number[]> // never
+ *
+ * type R = NotStrictArrayType<number> // number
+ * type R = NotStrictArrayType<[1]> // [1]
+ * ```
+ */
+export type NotStrictArrayType<T, Then = T, Else = never> = StrictArrayType<T, Else, Then>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is not an array, excluding tuple.
+ *
+ * i.e. *tuple* will pass through this filter.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotStrictArray<number[]> // false
+ *
+ * type R = IsNotStrictArray<number> // true
+ * type R = IsNotStrictArray<[1]> // true
+ * ```
+ */
+export type IsNotStrictArray<T, Then = true, Else = false> = StrictArrayType<T, Else, Then>

package/ts/array/union_of_props.ts

@@ -4,7 +4,7 @@ import type { Tail } from '../tuple/tail.js'
 /**
  * Gets the union of properties of the elements in `A`
  */
-export type UnionOfProps<A extends Record<any, any>[], P extends KeyTypes> = A['length'] extends 0
+export type UnionOfProps<A extends readonly Record<any, any>[], P extends KeyTypes> = A['length'] extends 0
 	? never
 	: A['length'] extends 1
 	? A[0][P]
@@ -14,4 +14,4 @@ export type UnionOfProps<A extends Record<any, any>[], P extends KeyTypes> = A['
  * Gets the union of properties in the element of `A`
  * This will be deprecated in 4.0. Please use UnionOfProps instead.
  */
-export type PropUnion<A extends Record<any, any>[], P extends KeyTypes> = UnionOfProps<A, P>
+export type PropUnion<A extends readonly Record<any, any>[], P extends KeyTypes> = UnionOfProps<A, P>

package/ts/array/union_of_values.ts

@@ -1,7 +1,7 @@
 /**
  * Gets the union of value types in `A`
  */
-export type UnionOfValues<A extends Array<any>> = A extends Array<infer E> ? E : never
+export type UnionOfValues<A extends readonly unknown[]> = A extends Readonly<Array<infer E>> ? E : never
 
 // alternative implementation
 // export type UnionOfValues<A extends readonly any[]> = (A)[number]
@@ -11,4 +11,4 @@ export type UnionOfValues<A extends Array<any>> = A extends Array<infer E> ? E :
  * Gets the union of value types in `A`
  * @deprecated Please use `UnionOfValues` instead.
  */
-export type ArrayValue<A extends any[]> = UnionOfValues<A>
+export type ArrayValue<A extends readonly unknown[]> = UnionOfValues<A>

package/ts/equal/equal.ts

@@ -4,6 +4,7 @@ import type { IsObject } from '../object/object_type.js'
 import type { Properties } from '../object/properties.js'
 import type { And, Or } from '../predicates/logical.js'
 import type { IsSymbol } from '../symbol/symbol_type.js'
+import type { IdentityEqual } from './identity_equal.js'
 
 type BothNever<A, B, Both, One, None> = And<
 	IsNever<A>,
@@ -14,14 +15,6 @@ type BothNever<A, B, Both, One, None> = And<
 
 type BothAny<A, B, Both, One, None> = And<IsAny<A>, IsAny<B>, Both, Or<IsAny<A>, IsAny<B>, One, None>>
 
-type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2) extends <_>() => _ extends
-	| (B & _)
-	| _
-	? 1
-	: 2
-	? Then
-	: Else
-
 /**
  * Checks `A` and `B` are equal.
  *
@@ -44,37 +37,37 @@ type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2)
  */
 export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
 	? BothNever<
+		A,
+		B,
+		Then,
+		Else,
+		BothAny<
 			A,
 			B,
 			Then,
 			Else,
-			BothAny<
+			IdentityEqual<
 				A,
 				B,
 				Then,
-				Else,
-				IdentityEqual<
-					A,
-					B,
-					Then,
-					And<
-						IsObject<A>,
-						IsObject<B>,
-						IdentityEqual<
-							Properties<A>,
-							Properties<B>,
-							[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
-								? IsEqual<P1, P2, Then, Else>
-								: Then,
-							Else
-						>,
-						// `A` and `B` are narrowed, need to check again.
-						// This is fixed in TS 5.0.2, but keeping it to support older versions.
-						[A, B] extends [B, A] ? Then : Else
-					>
+				And<
+					IsObject<A>,
+					IsObject<B>,
+					IdentityEqual<
+						Properties<A>,
+						Properties<B>,
+						[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+						? IsEqual<P1, P2, Then, Else>
+						: Then,
+						Else
+					>,
+					// `A` and `B` are narrowed, need to check again.
+					// This is fixed in TS 5.0.2, but keeping it to support older versions.
+					[A, B] extends [B, A] ? Then : Else
 				>
 			>
-	  >
+		>
+	>
 	: And<IsSymbol<A>, IsSymbol<B>, Then, Else>
 
 /**

package/ts/equal/identity_equal.ts

@@ -0,0 +1,9 @@
+
+/**
+ * This is a common equal check.
+ * It is good for some basic cases, but not for all.
+ */
+export type IdentityEqual<A, B, Then, Else> =
+	(<_>() => _ extends (A & _) | _ ? 1 : 2) extends (<_>() => _ extends | (B & _) | _ ? 1 : 2)
+	? Then
+	: Else

package/ts/index.ts

@@ -11,9 +11,11 @@ export type { Head } from './array/head.js'
 export type { IntersectOfProps, MapToProp } from './array/intersect_of_props.js'
 export type { Last } from './array/last.js'
 export { literalArray } from './array/literal_array.js'
+export type { IsLooseArray, IsNotLooseArray, LooseArrayType, NotLooseArrayType } from './array/loose_array_type.js'
 export type { PadStart } from './array/pad_start.js'
 export { reduceWhile } from './array/reduce_while.js'
 export type { Reverse } from './array/reverse.js'
+export type { IsNotStrictArray, IsStrictArray, NotStrictArrayType, StrictArrayType } from './array/strict_array_type.js'
 export type { PropUnion, UnionOfProps } from './array/union_of_props.js'
 export type { UnionOfValues } from './array/union_of_values.js'
 export { assertType } from './assertion/assert_type.js'
@@ -50,7 +52,9 @@ export * from './functional/index.js'
 export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
 export type { Abs, Add, Decrement, GreaterThan, Increment, Max, Multiply, Subtract } from './math/index.js'
 export * as MathPlus from './math/math_plus.js'
+export * from './mix_types/merge.js'
 export type { AnyOrNeverType, IsAnyOrNever } from './mix_types/any_or_never_type.js'
+export type * from './mix_types/box.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'
@@ -79,6 +83,8 @@ export type {
 export type { IsNotPositive, IsPositive, NonPositive, Positive } from './numeric/positive.js'
 export type { Required, RequiredExcept, RequiredPick } from './object/Required.js'
 export * from './object/index.js'
+export type * from './object/is_strict_object.js'
+export * as ObjectPlus from './object/object_plus.js'
 export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
 export * from './predicates/index.js'
 export type { PrimitiveTypes } from './primitive.js'
@@ -116,6 +122,6 @@ export type { UnionKeys } from './union_keys.js'
 export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
 export * from './unpartial.js'
 export * from './utils/index.js'
-export type { MergeOptions as MergeCases } from './utils/options.js'
+export type { TypePlusOptions } from './utils/options.js'
 export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'