type-plus 7.3.0 → 7.4.0

package/ts/array/reverse.ts

@@ -1,3 +1,8 @@
+/**
+ * ⚗️ *transform*
+ *
+ * reverses the order of `A`.
+ */
 export type Reverse<A extends unknown[]> = number extends A['length']
 	? A
 	: A['length'] extends 0

package/ts/array/union_of_props.ts

@@ -1,5 +1,5 @@
 import type { KeyTypes } from '../object/index.js'
-import type { Tail } from './tail.js'
+import type { Tail } from '../tuple/tail.js'
 
 /**
  * Gets the union of properties of the elements in `A`

package/ts/assertion/readme.md

@@ -9,11 +9,11 @@ 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](./assert_type.ts)
 
-`assertType<T>(subject)`:
+`assertType<T>(subject)`
 
-✔️ `immediate`
+💥 `immediate`
 
 It ensures `subject` satisfies `T`.
 It is similar to `const x: T = subject` without introducing an unused variable.

package/ts/functional/compose.ts

@@ -1,4 +1,5 @@
-import type { Head, Last } from '../array/index.js'
+import type { Head } from '../array/head.js'
+import type { Last } from '../array/last.js'
 import type { AnyFunction } from '../function/any_function.js'
 
 /**

package/ts/functional/context.ts

@@ -27,7 +27,7 @@ export type ContextBuilder<Init extends ContextBaseShape, Ctx extends ContextBas
 	 */
 	extend<Additional extends ContextBaseShape = ContextBaseShape>(
 		extender: ContextExtender<Ctx, Additional>
-	): ContextBuilder<Init, LeftJoin<Ctx, Additional>>
+	): ContextBuilder<Init, LeftJoin<Ctx, Additional>>,
 	/**
 	 * Build and return the context.
 	 */

package/ts/index.ts

@@ -1,10 +1,22 @@
 export type { AnyType, IsAny, IsNotAny, NotAnyType } from './any/any_type.js'
 export type { At } from './array/array.at.js'
-export type { Concat } from './array/array.concat.js'
+export type { FindFirst } from './array/array.find.js'
+export type { FindLast } from './array/array.find_last.js'
+export type { Some } from './array/array.some.js'
+export type { Concat } from './array/array_plus.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 { Filter, KeepMatch } from './array/filter.js'
+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 { PadStart } from './array/pad_start.js'
+export { reduceWhile } from './array/reduce_while.js'
+export type { Reverse } from './array/reverse.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'
 export type { BigintType, IsBigint, IsNotBigint, NotBigintType } from './bigint/bigint_type.js'
 export type { StringToBigint } from './bigint/cast.js'
 export type {
@@ -82,7 +94,11 @@ 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 type { CommonPropKeys } from './tuple/common_prop_keys.js'
 export * from './tuple/create_tuple.js'
+export { drop } from './tuple/drop.js'
+export type { DropFirst, DropLast, DropMatch, DropNull, DropNullable, DropUndefined } from './tuple/drop.js'
+export type { Tail } from './tuple/tail.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'
@@ -100,3 +116,6 @@ export * from './unpartial.js'
 export * from './utils/index.js'
 export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
 
+
+
+

package/ts/math/numeric_struct.ts

@@ -1,4 +1,4 @@
-import type { Tail } from '../array/tail.js'
+import type { Tail } from '../tuple/tail.js'
 import type { PadStart } from '../tuple/tuple_plus.pad_start.js'
 import type { Add as NumericAdd } from './add.js'
 import type { ToNegative } from './math_plus.to_negative.js'
@@ -631,14 +631,14 @@ export namespace Digit {
 	][A][B]
 
 	export type Plus10 = { [k in number]: number } & {
-		'-1': 9
-		'-2': 8
-		'-3': 7
-		'-4': 6
-		'-5': 5
-		'-6': 4
-		'-7': 3
-		'-8': 2
+		'-1': 9,
+		'-2': 8,
+		'-3': 7,
+		'-4': 6,
+		'-5': 5,
+		'-6': 4,
+		'-7': 3,
+		'-8': 2,
 		'-9': 1
 	}
 	export type Multiply<A extends number, B extends number> = [

package/ts/mix_types/any_or_never_type.ts

@@ -1,22 +1,30 @@
-import type { IsNever } from '../never/never_type.js'
-import type { IsAny } from '../any/any_type.js'
+import type { AnyType } from '../any/any_type.js'
+import type { NeverType } from '../never/never_type.js'
 
 /**
- * 🐾 Parse `T` to ensure it is either exactly `any` or exactly `never`.
+ * Parse `T` to ensure it is either exactly `any` or exactly `never`.
+ *
+ * 🌪️ *filter*
+ * 🩳 *shortcut*
  *
  * @example
  * ```ts
- * type R = AnyType<any> // any
+ * type R = AnyOrNeverType<any> // any
+ * type R = AnyOrNeverType<never> // never
+ * type R = AnyOrNeverType<never, 1, 2> // 1
  *
- * type R = AnyType<never> // never
- * type R = AnyType<unknown> // never
- * type R = AnyType<string | boolean> // never
+ * type R = AnyOrNeverType<unknown> // never
+ * type R = AnyOrNeverType<unknown, 1, 2> // 2
+ * type R = AnyOrNeverType<string | boolean> // never
  * ```
  */
-export type AnyOrNeverType<T, Then = T, Else = never> = IsNever<T, Then, IsAny<T, Then, Else>>
+export type AnyOrNeverType<T, Then = T, Else = never> = NeverType<T, Then, AnyType<T, Then, Else>>
 
 /**
- * 🎭 Validate if `T` is either exactly `any` or exactly `never`.
+ * Validate if `T` is either exactly `any` or exactly `never`.
+ *
+ * 🎭 *validate*
+ * 🩳 *shortcut*
  *
  * @example
  * ```ts
@@ -27,4 +35,4 @@ export type AnyOrNeverType<T, Then = T, Else = never> = IsNever<T, Then, IsAny<T
  * type R = IsAnyOrNever<unknown> // false
  * ```
  */
-export type IsAnyOrNever<T, Then = true, Else = false> = IsNever<T, Then, IsAny<T, Then, Else>>
+export type IsAnyOrNever<T, Then = true, Else = false> = NeverType<T, Then, AnyType<T, Then, Else>>

package/ts/mix_types/readme.md

@@ -0,0 +1,40 @@
+# Mix Types
+
+This folder contains types and utilities that work across multiple types.
+
+## [AnyOrNeverType](./any_or_never_type.ts)
+
+`AnyOrNeverType<T, Then = T, Else = never>` 🎭 🩳
+
+Filter `T` to ensure it is either exactly `any` or exactly `never`.
+
+🌪️ *filter*
+🩳 *shortcut*
+
+```ts
+import type { AnyOrNeverType } from 'type-plus'
+
+type R = AnyOrNeverType<any> // any
+type R = AnyOrNeverType<never> // never
+type R = AnyOrNeverType<never, 1, 2> // 1
+
+type R = AnyOrNeverType<unknown, 1, 2> // 2
+```
+
+## [IsAnyOrNever](./any_or_never_type.ts)
+
+`IsAnyOrNever<T, Then = true, Else = false>` 🎭 🩳
+
+Validate if `T` is either exactly `any` or exactly `never`.
+
+🎭 *validate*
+🩳 *shortcut*
+
+```ts
+import type { IsAnyOrNever } from 'type-plus'
+
+type R = IsAnyOrNever<any> // true
+type R = IsAnyOrNever<never> // true
+
+type R = IsAnyOrNever<unknown> // false
+```

package/ts/nodejs/isNodeError.ts

@@ -1,17 +1,17 @@
 export type SystemErrors = {
-	EACCES: Error & { code: 'EACCES' }
-	EADDRINUSE: Error & { code: 'EADDRINUSE' }
-	ECONNREFUSED: Error
-	ECONNRESET: Error
-	EEXIST: Error
-	EISDIR: Error
-	EMFILE: Error
-	ENOENT: Error & { code: 'ENOENT'; path: string }
-	ENOTDIR: Error
-	ENOTEMPTY: Error
-	ENOTFOUND: Error
-	EPERM: Error
-	EPIPE: Error
+	EACCES: Error & { code: 'EACCES' },
+	EADDRINUSE: Error & { code: 'EADDRINUSE' },
+	ECONNREFUSED: Error,
+	ECONNRESET: Error,
+	EEXIST: Error,
+	EISDIR: Error,
+	EMFILE: Error,
+	ENOENT: Error & { code: 'ENOENT', path: string },
+	ENOTDIR: Error,
+	ENOTEMPTY: Error,
+	ENOTFOUND: Error,
+	EPERM: Error,
+	EPIPE: Error,
 	ETIMEDOUT: Error
 }
 

package/ts/nominal/brand.ts

@@ -17,7 +17,7 @@ export type Brand<B extends string, T = never> = [T] extends [null] | [undefined
  * A branded type of `B` with value of `T`.
  */
 export interface Branded<B extends string, T> {
-	[typeSym]: B
+	[typeSym]: B,
 	[valueSym]: T
 }
 

package/ts/nominal/flavor.ts

@@ -26,7 +26,7 @@ export interface Flavored<F extends string> {
  * A special flavored type for special types.
  */
 export interface FlavoredUnit<F extends string, T> {
-	[typeSym]?: F
+	[typeSym]?: F,
 	[valueSym]: T
 }
 

package/ts/testing/readme.md

@@ -16,4 +16,34 @@ import { testType } from 'type-plus'
 testType.any<T>(true) // T is `any`
 testType.equal<A, B>(true) // A is equal to B
 testType.never<T>(false) // T is not `never`
+
+const t = testType.equal<SomeComplexType, SomeCompositeType>(true)
+type T = typeof t // type resolution
+```
+
+## [testType.inspect](./test_type.ts)
+
+`testType.inspect<T>(fn)`
+
+A quick way to inspect a type.
+
+```ts
+import { testType } from 'type-plus'
+
+testType.inspect<SomeType>(t => {
+  type T = typeof t.type // type resolution
+})
+```
+
+It also provides additional methods and predefined inspections so that you can quickly check how the type behaves in specific cases.
+
+```ts
+import { testType } from 'type-plus'
+
+testType.inspect<SomeType>(t => {
+  t.extends<AnotherType>() // true or false
+  t.union<number>() // SomeType | number`
+  t.intersect<string>() // `SomeType & string`
+  t.extends_boolean // true or false
+})
 ```

package/ts/testing/test_type.ts

@@ -29,13 +29,13 @@ interface TestType {
 	 *
 	 * @return `expected` as `A` for type inspection.
 	 */
-	equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A
+	equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A,
 	/**
 	 * Check if type `A` is equal to type `B`.
 	 *
 	 * @return `expected` as `A` for type inspection.
 	 */
-	equal<A, B>(expected: IsEqual<A, B>): A
+	equal<A, B>(expected: IsEqual<A, B>): A,
 	/**
 	 * Check if `A` can assign to `B`.
 	 *
@@ -57,7 +57,7 @@ interface TestType {
 	 *
 	 * @return `expected` as `A` for type inspection.
 	 */
-	canAssign<A, B>(expected: CanAssign<A, B>): A
+	canAssign<A, B>(expected: CanAssign<A, B>): A,
 	/**
 	 * Check if `A` can fully assign to `B`.
 	 *
@@ -72,91 +72,91 @@ interface TestType {
 	 *
 	 * @return `expected` as `A` for type inspection.
 	 */
-	strictCanAssign<A, B>(expected: StrictCanAssign<A, B>): A
+	strictCanAssign<A, B>(expected: StrictCanAssign<A, B>): A,
 	/**
 	 * Check if type `T` is exactly `any`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	any<T>(expected: IsAny<T>): T
+	any<T>(expected: IsAny<T>): T,
 	/**
 	 * Check if type `T` is exactly `array`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	array<T>(expected: IsArray<T>): T
+	array<T>(expected: IsArray<T>): T,
 	/**
 	 * Check if type `T` is exactly `bigint`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	strictBigint<T>(expected: IsStrictBigint<T>): T
+	strictBigint<T>(expected: IsStrictBigint<T>): T,
 	/**
 	 * Check if type `T` is `bigint` or bigint literals.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	bigint<T>(expected: IsBigint<T>): T
+	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>): 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>): 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>): 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>): 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
+	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
+	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
+	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
+	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>): 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>): T
+	number<T>(expected: IsNumber<T>): T,
 	/**
 	 * Check if type `T` is `object`.
 	 *
@@ -164,50 +164,50 @@ interface TestType {
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	object<T>(expected: IsObject<T>): T
+	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>): 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>): T
+	string<T>(expected: IsString<T>): T,
 	/**
 	 * Check if type `T` is a `symbol`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	symbol<T>(expected: IsSymbol<T>): T
+	symbol<T>(expected: IsSymbol<T>): T,
 	/**
 	 * Check if type `T` is a *tuple*.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	tuple<T>(expected: IsTuple<T>): 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>): T
+	undefined<T>(expected: IsUndefined<T>): T,
 	// hasUndefined<T>(expected: CanAssign<T, undefined>): T
 	/**
 	 * Check if type `T` is exactly `unknown`.
 	 *
 	 * @return `expected` as `T` for type inspection.
 	 */
-	unknown<T>(expected: IsUnknown<T>): 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
+	void<T>(expected: IsVoid<T>): T,
 	/**
 	 * A quick way to inspect a type.
 	 *
@@ -248,25 +248,68 @@ export const testType = new Proxy({} as TestType, {
 })
 
 export type InspectedType<T> = {
-	value: T
-	extends_any: T extends any ? true : false
-	extends_unknown: T extends unknown ? true : false
-	extends_void: T extends void ? true : false
-	extends_never: T extends never ? true : false
-	extends_undefined: T extends undefined ? true : false
-	extends_null: T extends null ? true : false
-	extends_boolean: T extends boolean ? true : false
-	extends_true: T extends true ? true : false
-	extends_false: T extends false ? true : false
-	extends_number: T extends number ? true : false
-	extends_1: T extends 1 ? true : false
-	extends_bigint: T extends bigint ? true : false
-	extends_1n: T extends 1n ? true : false
-	extends_string: T extends string ? true : false
-	extends_a: T extends 'a' ? true : false
-	extends_symbol: T extends symbol ? true : false
-	extends_object: T extends object ? true : false
-	extends_function: T extends Function ? true : false
-	extends_array_unknown: T extends unknown[] ? true : false
-	extends_tuple_empty: T extends [] ? true : false
+	type: T,
+	extends<R>(): T extends R ? true : false,
+	extends_any: T extends any ? true : false,
+	extends_unknown: T extends unknown ? true : false,
+	extends_void: T extends void ? true : false,
+	extends_never: T extends never ? true : false,
+	extends_undefined: T extends undefined ? true : false,
+	extends_null: T extends null ? true : false,
+	extends_boolean: T extends boolean ? true : false,
+	extends_true: T extends true ? true : false,
+	extends_false: T extends false ? true : false,
+	extends_number: T extends number ? true : false,
+	extends_1: T extends 1 ? true : false,
+	extends_bigint: T extends bigint ? true : false,
+	extends_1n: T extends 1n ? true : false,
+	extends_string: T extends string ? true : false,
+	extends_a: T extends 'a' ? true : false,
+	extends_symbol: T extends symbol ? true : false,
+	extends_object: T extends object ? true : false,
+	extends_function: T extends Function ? true : false,
+	extends_array_unknown: T extends unknown[] ? true : false,
+	extends_tuple_empty: T extends [] ? true : false,
+	union<R>(): T | R,
+	union_any: T | any,
+	union_unknown: T | unknown,
+	union_void: T | void,
+	union_never: T | never,
+	union_undefined: T | undefined,
+	union_null: T | null,
+	union_boolean: T | boolean,
+	union_true: T | true,
+	union_false: T | false,
+	union_number: T | number,
+	union_1: T | 1,
+	union_bigint: T | bigint,
+	union_1n: T | 1n,
+	union_string: T | string,
+	union_a: T | 'a',
+	union_symbol: T | symbol,
+	union_object: T | object,
+	union_function: T | Function,
+	union_array_unknown: T | unknown[],
+	union_tuple_empty: T | [],
+	intersect<R>(): T & R,
+	intersect_any: T & any,
+	intersect_unknown: T & unknown,
+	intersect_void: T & void,
+	intersect_never: T & never,
+	intersect_undefined: T & undefined,
+	intersect_null: T & null,
+	intersect_boolean: T & boolean,
+	intersect_true: T & true,
+	intersect_false: T & false,
+	intersect_number: T & number,
+	intersect_1: T & 1,
+	intersect_bigint: T & bigint,
+	intersect_1n: T & 1n,
+	intersect_string: T & string,
+	intersect_a: T & 'a',
+	intersect_symbol: T & symbol,
+	intersect_object: T & object,
+	intersect_function: T & Function,
+	intersect_array_unknown: T & unknown[],
+	intersect_tuple_empty: T & []
 }

package/ts/tuple/common_prop_keys.ts

@@ -0,0 +1,55 @@
+import type { NotNeverType } from '../never/never_type.js'
+import type { KeyTypes } from '../object/KeyTypes.js'
+import type { Tail } from './tail.js'
+
+/**
+ * ⚗️ *transform*
+ *
+ * Gets the common property keys of the elements in tuple `T`.
+ *
+ * ```ts
+ * import { CommonPropKeys } from 'type-plus'
+ *
+ * type R = CommonPropKeys<[{ a: number }, { b: number }]> // never
+ * type R = CommonPropKeys<[{ a: number, c: 1 }, { b: number, c: 2 }]> // 'c'
+ * ```
+ */
+export type CommonPropKeys<
+	T extends Record<KeyTypes, unknown>[],
+	Cases extends {
+		array?: unknown,
+		no_common_keys?: unknown
+	} = {
+		array: T extends Array<infer R extends Record<KeyTypes, unknown>> ? keyof R : never,
+		no_common_keys: never
+	}
+> = number extends T['length']
+	? Cases['array']
+	: (
+		T['length'] extends 0
+		? Cases['no_common_keys']
+		: (
+			T['length'] extends 1
+			? keyof T[0]
+			: (
+				T['length'] extends 2
+				? (
+					keyof T[0] & keyof T[1] extends infer R
+					? NotNeverType<R, R, Cases['no_common_keys']>
+					: never
+				)
+				: (
+					keyof T[0] & keyof T[1] & CommonPropKeys<Tail<Tail<T>>> extends infer R
+					? NotNeverType<R, R, Cases['no_common_keys']>
+					: never
+				)
+			)
+		)
+	)
+
+/**
+ * Gets the common property keys of the elements in `A`.
+ *
+ * @deprecated Please use `CommonPropKeys` instead.
+ */
+export type CommonKeys<A extends Record<KeyTypes, any>[]> = CommonPropKeys<A>

package/ts/tuple/create_tuple.ts

@@ -28,15 +28,15 @@ export type ToTuple<R extends any[], S extends number[], X = any> = S['length']
 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]
+	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]