@planet-matrix/mobius-model 0.4.0 → 0.6.0

package/src/type/is.ts

@@ -1,46 +1,95 @@
 // oxlint-disable no-explicit-any
 
 /**
+ * 表示 JavaScript 与 TypeScript 中的原始类型联合。
+ *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types}
  */
 export type Primitive = string | number | boolean | bigint | symbol | null | undefined
 /**
-  * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type}
-  */
+ * 表示非原始类型。
+ *
+ * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type}
+ */
 export type NonPrimitive = object
 
+/**
+ * 判断目标类型是否为原始类型。
+ */
 export type IsPrimitive<T> =
   T extends string ? true : T extends number ? true : T extends boolean ? true : T extends bigint ? true
   : T extends symbol ? true : T extends null ? true : T extends undefined ? true : false
+/**
+ * 当目标类型是原始类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfPrimitive<T, TRUE = true, FALSE = never> = IsPrimitive<T> extends true ? TRUE : FALSE
 
+/**
+ * 判断联合类型的每个成员是否都属于原始类型集合。
+ */
 export type IsPrimitiveUnion<T> = T extends Primitive ? true : false
+/**
+ * 当联合类型成员都属于原始类型集合时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfPrimitiveUnion<T, TRUE = true, FALSE = never> = IsPrimitiveUnion<T> extends true ? TRUE : FALSE
 
 /**
  * Predicate whether the target is `string`.
  */
 export type IsString<T> = T extends string ? true : false
+/**
+ * 当目标类型是 `string` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfString<T, TRUE = true, FALSE = never> = IsString<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `string`，否则回退到 `string`。
+ */
 export type CastString<T> = T extends string ? T : string
+/**
+ * 判断目标类型是否为字符串字面量类型。
+ */
 export type IsStringLiteral<T> = T extends string ? (string extends T ? false : true) : false
 
 /**
  * Predicate whether the target is `number`.
  */
 export type IsNumber<T> = T extends number ? true : false
+/**
+ * 当目标类型是 `number` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNumber<T, TRUE = true, FALSE = never> = IsNumber<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `number`，否则回退到 `number`。
+ */
 export type CastNumber<T> = T extends number ? T : number
+/**
+ * 判断目标类型是否为数字字面量类型。
+ */
 export type IsNumberLiteral<T> = T extends number ? (number extends T ? false : true) : false
 
 /**
  * Predicate whether the target is `boolean`.
  */
 export type IsBoolean<T> = T extends boolean ? true : false
+/**
+ * 当目标类型是 `boolean` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfBoolean<T, TRUE = true, FALSE = never> = IsBoolean<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `boolean`，否则回退到 `boolean`。
+ */
 export type CastBoolean<T> = T extends boolean ? T : boolean
+/**
+ * 判断目标类型是否为字面量 `true`。
+ */
 export type IsTrue<T> = T extends true ? true : false
+/**
+ * 判断目标类型是否为字面量 `false`。
+ */
 export type IsFalse<T> = T extends false ? true : false
+/**
+ * 判断目标类型是否为布尔字面量类型。
+ */
 export type IsBooleanLiteral<T> =
   [T] extends [boolean] // Check if T is assignable to boolean (true, false, or boolean)
   ? ([boolean] extends [T] // Check if boolean is assignable to T (only true for 'boolean' itself)
@@ -53,86 +102,203 @@ export type IsBooleanLiteral<T> =
  * Predicate whether the target is `bigint`.
  */
 export type IsBigInt<T> = T extends bigint ? true : false
+/**
+ * 当目标类型是 `bigint` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfBigInt<T, TRUE = true, FALSE = never> = IsBigInt<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `bigint`，否则回退到 `bigint`。
+ */
 export type CastBigInt<T> = T extends bigint ? T : bigint
 
 /**
  * Predicate whether the target is `symbol`.
  */
 export type IsSymbol<T> = T extends symbol ? true : false
+/**
+ * 当目标类型是 `symbol` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfSymbol<T, TRUE = true, FALSE = never> = IsSymbol<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `symbol`，否则回退到 `symbol`。
+ */
 export type CastSymbol<T> = T extends symbol ? T : symbol
 
 /**
  * Predicate whether the target is `null`.
  */
 export type IsNull<T> = Exclude<T, null> extends never ? true : false
+/**
+ * 当目标类型是 `null` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNull<T, TRUE = true, FALSE = never> = IsNull<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `null`，否则回退到 `null`。
+ */
 export type CastNull<T> = T extends null ? T : null
+/**
+ * 判断目标类型是否包含 `null`。
+ */
 export type IsNullable<T> = T extends Exclude<T, null> ? false : true
+/**
+ * 当目标类型可空时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNullable<T, TRUE = true, FALSE = never> = IsNullable<T> extends true ? TRUE : FALSE
+/**
+ * 为目标类型附加 `null`。
+ */
 export type Nullable<T> = T | null
+/**
+ * 从目标类型中移除 `null`。
+ */
 export type NonNullable<T> = Exclude<T, null>
 
 /**
  * Predicate whether the target is `undefined`.
  */
 export type IsUndefined<T> = Exclude<T, undefined> extends never ? true : false
+/**
+ * 当目标类型是 `undefined` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfUndefined<T, TRUE = true, FALSE = never> = IsUndefined<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `undefined`，否则回退到 `undefined`。
+ */
 export type CastUndefined<T> = T extends undefined ? T : undefined
+/**
+ * 判断目标类型是否包含 `undefined`。
+ */
 export type IsUndefinedable<T> = T extends Exclude<T, undefined> ? false : true
+/**
+ * 当目标类型可为 `undefined` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfUndefinedable<T, TRUE = true, FALSE = never> = IsUndefinedable<T> extends true ? TRUE : FALSE
+/**
+ * 为目标类型附加 `undefined`。
+ */
 export type Undefinedable<T> = T | undefined
+/**
+ * 从目标类型中移除 `undefined`。
+ */
 export type NonUndefinedable<T> = Exclude<T, undefined>
 
 /**
  * Predicate whether the target is `null | undefined`.
  */
 export type IsNil<T> = Exclude<T, undefined | null> extends never ? true : false
+/**
+ * 当目标类型是 `null | undefined` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNil<T, TRUE = true, FALSE = never> = IsNil<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `null | undefined`，否则回退到该并集。
+ */
 export type CastNil<T> = T extends undefined | null ? T : undefined | null
+/**
+ * 判断目标类型是否包含 `null` 或 `undefined`。
+ */
 export type IsNilable<T> = T extends Exclude<T, null | undefined> ? false : true
+/**
+ * 当目标类型可为 `null` 或 `undefined` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNilable<T, TRUE = true, FALSE = never> = IsNilable<T> extends true ? TRUE : FALSE
+/**
+ * 为目标类型附加 `null | undefined`。
+ */
 export type Nilable<T> = T | null | undefined
+/**
+ * 从目标类型中移除 `null | undefined`。
+ */
 export type NonNilable<T> = Exclude<T, null | undefined>
 
 /**
  * Predicate whether the target is `Record`.
  */
 export type IsRecord<T> = T extends Record<string | number | symbol, unknown> ? true : false
+/**
+ * 当目标类型是记录类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfRecord<T, TRUE = true, FALSE = never> = IsRecord<T> extends true ? TRUE : FALSE
+/**
+ * 判断目标类型是否为字符串键记录类型。
+ */
 export type IsStringRecord<T> = T extends Record<string, unknown> ? true : false
+/**
+ * 当目标类型是字符串键记录类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfStringRecord<T, TRUE = true, FALSE = never> = IsStringRecord<T> extends true ? TRUE : FALSE
+/**
+ * 判断目标类型是否为数字键记录类型。
+ */
 export type IsNumberRecord<T> = T extends Record<number, unknown> ? true : false
+/**
+ * 当目标类型是数字键记录类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNumberRecord<T, TRUE = true, FALSE = never> = IsNumberRecord<T> extends true ? TRUE : FALSE
+/**
+ * 判断目标类型是否为符号键记录类型。
+ */
 export type IsSymbolRecord<T> = T extends Record<symbol, unknown> ? true : false
+/**
+ * 当目标类型是符号键记录类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfSymbolRecord<T, TRUE = true, FALSE = never> = IsSymbolRecord<T> extends true ? TRUE : FALSE
 
+/**
+ * 判断目标类型是否为对象类型。
+*/
 // oxlint-disable-next-line no-wrapper-object-types ban-types
 export type IsObject<Target> = Target extends Object ? true : false
+/**
+ * 当目标类型是对象类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfObject<Target, TRUE = true, FALSE = never> = IsObject<Target> extends true ? TRUE : FALSE
+/**
+ * 表示普通对象结构。
+ */
 export type PlainObject = Record<PropertyKey, unknown>
 /**
  * Predicate whether the target is `EmptyObject`(`{}`).
  */
 export type IsEmptyObject<Target extends Record<PropertyKey, unknown>> = keyof Target extends never ? true : false
+/**
+ * 当目标类型是空对象时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfEmptyObject<Target extends Record<PropertyKey, unknown>, TRUE = true, FALSE = never> = IsEmptyObject<Target> extends true ? TRUE : FALSE
 
 /**
  * Predicate whether the target is `Array`.
  */
 export type IsArray<T> = T extends readonly unknown[] ? (number extends T["length"] ? true : false) : false
+/**
+ * 当目标类型是数组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfArray<T, TRUE = true, FALSE = never> = IsArray<T> extends true ? TRUE : FALSE
 // ReadonlyArray is subset of Array.
+/**
+ * 判断目标类型是否为只读数组。
+ */
 export type IsReadonlyArray<T> = T extends readonly unknown[] ? (T extends unknown[] ? false : true) : false
+/**
+ * 当目标类型是只读数组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfReadonlyArray<T, TRUE = true, FALSE = never> = IsReadonlyArray<T> extends true ? TRUE : FALSE
+/**
+ * 判断目标类型是否为可写数组。
+ */
 export type IsWritableArray<T> = T extends unknown[] ? (number extends T["length"] ? true : false) : false
+/**
+ * 当目标类型是可写数组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfWritableArray<T, TRUE = true, FALSE = never> = IsWritableArray<T> extends true ? TRUE : FALSE
 
 /**
  * Predicate whether the target is `ArrayLike`.
  */
 export type IsArrayLike<T> = T extends ArrayLike<unknown> ? true : false
+/**
+ * 当目标类型满足 `ArrayLike` 结构时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfArrayLike<T, TRUE = true, FALSE = never> = IsArrayLike<T> extends true ? TRUE : FALSE
 
 /**
@@ -141,77 +307,160 @@ export type IfArrayLike<T, TRUE = true, FALSE = never> = IsArrayLike<T> extends
  * @see {@link https://github.com/type-challenges/type-challenges/issues/4491#issuecomment-975808109}
  */
 export type IsTuple<T> = T extends readonly unknown[] ? (number extends T["length"] ? false : true) : false
+/**
+ * 当目标类型是元组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfTuple<T, TRUE = true, FALSE = never> = IsTuple<T> extends true ? TRUE : FALSE
+/**
+ * 判断目标类型是否为只读元组。
+ */
 export type IsReadonlyTuple<T> = T extends readonly unknown[] ? (T extends unknown[] ? false : true) : false
+/**
+ * 当目标类型是只读元组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfReadonlyTuple<T, TRUE = true, FALSE = never> = IsReadonlyTuple<T> extends true ? TRUE : FALSE
+/**
+ * 判断目标类型是否为可写元组。
+ */
 export type IsWritableTuple<T> = T extends unknown[] ? (number extends T["length"] ? false : true) : false
+/**
+ * 当目标类型是可写元组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfWritableTuple<T, TRUE = true, FALSE = never> = IsWritableTuple<T> extends true ? TRUE : FALSE
 
 /**
  * Predicate whether the target is `Array` or `Tuple`.
  */
 export type IsArrayOrTuple<T> = T extends readonly unknown[] ? true : false
+/**
+ * 当目标类型是数组或元组时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfArrayOrTuple<T, TRUE = true, FALSE = never> = IsArrayOrTuple<T> extends true ? TRUE : FALSE
 
 /**
  * Predicate whether the target is of type function.
  */
 export type AnyFunction = (...args: any[]) => any
+/**
+ * 根据输入类型构造对应参数列表的任意函数类型。
+ */
 export type AnyFunctionOfTake<A> = A extends readonly [...infer R] ? ((...args: R) => any) : ((arg: A) => any)
+/**
+ * 表示返回值固定为指定类型的任意函数。
+ */
 export type AnyFunctionOfReturn<T> = (...args: any[]) => T
+/**
+ * 判断目标类型是否为函数类型。
+ */
 export type IsFunction<T> = T extends AnyFunction ? true : false
+/**
+ * 当目标类型是函数类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfFunction<T, TRUE = true, FALSE = never> = IsFunction<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为任意函数类型，否则回退到 `AnyFunction`。
+ */
 export type CastFunction<T> = T extends AnyFunction ? T : AnyFunction
 
+/**
+ * 表示返回非 `Promise` 值的任意同步函数。
+ */
 export type AnySyncFunction = (...args: any[]) => Exclude<unknown, Promise<any>>;
 /**
  * Predicate whether the target is of type sync function.
  */
 export type IsSyncFunction<T> = T extends (...args: any[]) => infer R ? (R extends Promise<any> ? false : true) : false
+/**
+ * 当目标类型是同步函数时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfSyncFunction<T, TRUE = true, FALSE = never> = IsSyncFunction<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为同步函数，否则回退到通用函数类型。
+ */
 export type CastSyncFunction<T> = T extends (...args: unknown[]) => infer R ? (R extends Promise<unknown> ? (...args: Parameters<T>) => Awaited<R> : T) : AnyFunction
 
+/**
+ * 表示返回 `Promise` 的任意异步函数。
+ */
 export type AnyAsyncFunction = (...args: any[]) => Promise<any>
 /**
  * Predicate whether the target is of type async function.
  */
 export type IsAsyncFunction<T> = T extends AnyAsyncFunction ? true : false
+/**
+ * 当目标类型是异步函数时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfAsyncFunction<T, TRUE = true, FALSE = never> = IsAsyncFunction<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为异步函数，否则回退到 `AnyAsyncFunction`。
+ */
 export type CastAsyncFunction<T> = T extends AnyAsyncFunction ? T : AnyAsyncFunction
 
+/**
+ * 表示任意生成器函数。
+ */
 export type AnyGeneratorFunction = (...args: any[]) => Generator<any, any, any>
 /**
  * Predicate whether the target is of type generator function.
  */
 export type IsGeneratorFunction<T> = T extends AnyGeneratorFunction ? true : false
+/**
+ * 当目标类型是生成器函数时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfGeneratorFunction<T, TRUE = true, FALSE = never> = IsGeneratorFunction<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为生成器函数，否则回退到 `AnyGeneratorFunction`。
+ */
 export type CastGeneratorFunction<T> = T extends AnyGeneratorFunction ? T : AnyGeneratorFunction
 
+/**
+ * 表示任意异步生成器函数。
+ */
 export type AnyAsyncGeneratorFunction = (...args: any[]) => AsyncGenerator<any, any, any>
 /**
  * Predicate whether the target is of type async generator function.
  */
 export type IsAsyncGeneratorFunction<T> = T extends AnyAsyncGeneratorFunction ? true : false
+/**
+ * 当目标类型是异步生成器函数时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfAsyncGeneratorFunction<T, TRUE = true, FALSE = never> = IsAsyncGeneratorFunction<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为异步生成器函数，否则回退到 `AnyAsyncGeneratorFunction`。
+ */
 export type CastAsyncGeneratorFunction<T> = T extends AnyAsyncGeneratorFunction ? T : AnyAsyncGeneratorFunction
 
 /**
  * Predicate whether the target is `never`.
  */
 export type IsNever<T> = [T] extends [never] ? true : false
+/**
+ * 当目标类型是 `never` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfNever<T, TRUE = true, FALSE = never> = IsNever<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `never`，否则回退到 `never`。
+ */
 export type CastNever<T> = T extends never ? T : never
 
 /**
  * Predicate whether the target is `any`.
+ *
  * @see {@link https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360}
  */
 export type IsAny<T> = 0 extends (1 & T) ? true : false
+/**
+ * 当目标类型是 `any` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfAny<T, TRUE = true, FALSE = never> = IsAny<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `any`。
+ */
 export type CastAny<T> = T extends any ? T : any
 
 /**
  * Predicate whether the target is `unknown`.
+ *
  * @see {@link https://www.typescriptlang.org/docs/handbook/type-compatibility.html#any-unknown-object-void-undefined-null-and-never-assignability}
  */
 export type IsUnknown<T> = IsNever<T> extends true
@@ -225,7 +474,13 @@ export type IsUnknown<T> = IsNever<T> extends true
     )
     : false
   )
+/**
+ * 当目标类型是 `unknown` 时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfUnknown<T, TRUE = true, FALSE = never> = IsUnknown<T> extends true ? TRUE : FALSE
+/**
+ * 将目标类型收窄为 `unknown`，否则回退到 `unknown`。
+ */
 export type CastUnknown<T> = T extends unknown ? T : unknown
 
 type InternalIsUnion<T, U> =
@@ -239,9 +494,17 @@ type InternalIsUnion<T, U> =
 /**
  * Predicate whether the target is `Union` type.
  *
+ * 判断目标类型是否为联合类型。
+ *
  * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types}
  */
 export type IsUnion<T> = InternalIsUnion<T, T>;
+/**
+ * 当目标类型是联合类型时返回 `TRUE`，否则返回 `FALSE`。
+ */
 export type IfUnion<T, TRUE = true, FALSE = never> = IsUnion<T> extends true ? TRUE : FALSE
 
+/**
+ * 表示一个空接口。
+ */
 export interface EmptyInterface { }

package/src/type/object.ts

@@ -22,23 +22,58 @@ import type { UnionComplement, UnionDifference, UnionIntersection } from "./unio
  */
 export type StrictOmit<T, K extends keyof T> = Omit<T, K>
 
+/**
+ * 表示键为字符串的记录类型。
+ */
 export type StringRecord<T> = Record<string, T>
+/**
+ * 表示键为数字的记录类型。
+ */
 export type NumberRecord<T> = Record<number, T>
+/**
+ * 表示键为符号的记录类型。
+ */
 export type SymbolRecord<T> = Record<symbol, T>
+/**
+ * 表示键可以是字符串、数字或符号的记录类型。
+ */
 export type HybridRecord<T> = Record<string | number | symbol, T>
+/**
+ * 表示值类型为 `any` 的字符串键记录类型。
+ */
 export type AnyStringRecord = StringRecord<any>
+/**
+ * 表示值类型为 `any` 的数字键记录类型。
+ */
 export type AnyNumberRecord = NumberRecord<any>
+/**
+ * 表示值类型为 `any` 的符号键记录类型。
+ */
 export type AnySymbolRecord = SymbolRecord<any>
+/**
+ * 表示值类型为 `any` 的混合键记录类型。
+ */
 export type AnyHybridRecord = Record<string | number | symbol, any>
+/**
+ * 表示任意常见记录类型的联合。
+ */
 export type AnyRecord = AnyStringRecord | AnyNumberRecord | AnySymbolRecord
 
+/**
+ * 为对象类型附加一个依赖其键集合的品牌标记。
+ */
 export type ObjectExact<A extends object> = A & { __brand: keyof A };
 
 /**
+ * 重新映射对象类型，使其在编辑器中以展开后的结构显示。
+ *
  * @see {@link https://stackoverflow.com/questions/78453542/intersection-with-object-in-prettify-helper-type}
  * @see {@link https://github.com/mylesmmurphy/prettify-ts}
  */
 export type ObjectPrettify<Target extends AnyHybridRecord> = Pick<Target, keyof Target>
+/**
+ * 通过条件分发重新构造对象类型，以获得更易读的展开结果。
+ */
 export type ObjectPrettify2<Target extends AnyHybridRecord> = Target extends infer O ? { [K in keyof O]: O[K] } : never
 
 // ============================================================================
@@ -71,6 +106,8 @@ export type ObjectNonEmpty<Target extends AnyStringRecord> = keyof Target extend
 // ============================================================================
 
 /**
+ * Get the keys of an object type.
+ *
  * @example
  * ```
  * interface Props { name: string, age: number, visible: boolean }

package/src/type/string.ts

@@ -4,8 +4,13 @@
 // Primitives
 // ============================================================================
 
+/**
+ * 表示既保留字面量自动补全体验，又允许回退到任意字符串的字符串类型。
+ */
 export type StringAutoCompletable = string & {}
 /**
+ * 为一组选项字符串补充自动补全，同时允许传入其它字符串。
+ *
  * @see {@link https://x.com/mattpocockuk/status/1822917991232569660}
  */
 export type StringWithAutoCompleteOptions<Options extends string> = Options | StringAutoCompletable
@@ -64,9 +69,9 @@ export type AlphanumericCharacter = UppercaseLetter | LowercaseLetter | DigitCha
  * @example
  * ```
  * // Expect: true
- * type Example1 = IsNumber<'123'>
+ * type Example1 = StringIsNumber<'123'>
  * // Expect: false
- * type Example2 = IsNumber<'12a'>
+ * type Example2 = StringIsNumber<'12a'>
  * ```
  */
 export type StringIsNumber<S extends string> =

package/src/type/tuple.ts

@@ -1405,8 +1405,8 @@ export type TuplePartition<T extends readonly unknown[], P, Matches extends read
  * type Example2 = TupleGroupBy<[]>
  * ```
  */
-export type TupleGroupBy<T extends readonly (readonly [PropertyKey, unknown])[], Acc extends Record<PropertyKey, unknown[]> = Record<never, never>> =
-  T extends readonly [infer First extends readonly [PropertyKey, unknown], ...infer Rest extends readonly (readonly [PropertyKey, unknown])[]]
+export type TupleGroupBy<T extends ReadonlyArray<readonly [PropertyKey, unknown]>, Acc extends Record<PropertyKey, unknown[]> = Record<never, never>> =
+  T extends readonly [infer First extends readonly [PropertyKey, unknown], ...infer Rest extends ReadonlyArray<readonly [PropertyKey, unknown]>]
   ? TupleGroupBy<Rest, {
     [K in keyof Acc | First[0]]: K extends First[0]
     ? (K extends keyof Acc ? [...Acc[K], First[1]] : [First[1]])
@@ -2249,7 +2249,7 @@ export type TupleToObject<T extends readonly PropertyKey[]> = {
  * type Example2 = TupleToRecord<[]>
  * ```
  */
-export type TupleToRecord<T extends readonly (readonly [PropertyKey, unknown])[]> = {
+export type TupleToRecord<T extends ReadonlyArray<readonly [PropertyKey, unknown]>> = {
   [K in T[number]as K extends readonly [infer Key extends PropertyKey, unknown] ? Key : never]: K extends readonly [PropertyKey, infer Value] ? Value : never
 }
 
@@ -2264,8 +2264,8 @@ export type TupleToRecord<T extends readonly (readonly [PropertyKey, unknown])[]
  * type Example2 = TupleToString<[], '-'>
  * ```
  */
-export type TupleToString<T extends readonly (string | number | boolean)[], Sep extends string = ''> =
-  T extends readonly [infer First extends string | number | boolean, ...infer Rest extends (string | number | boolean)[]]
+export type TupleToString<T extends ReadonlyArray<string | number | boolean>, Sep extends string = ''> =
+  T extends readonly [infer First extends string | number | boolean, ...infer Rest extends Array<string | number | boolean>]
   ? Rest extends []
   ? `${First}`
   : `${First}${Sep}${TupleToString<Rest, Sep>}`
@@ -2313,7 +2313,7 @@ export type TupleToIntersection<T extends readonly unknown[]> =
  * type Example2 = TupleToMap<[]>
  * ```
  */
-export type TupleToMap<T extends readonly (readonly [PropertyKey, unknown])[]> = Map<
+export type TupleToMap<T extends ReadonlyArray<readonly [PropertyKey, unknown]>> = Map<
   T[number] extends readonly [infer Key extends PropertyKey, unknown] ? Key : never,
   T[number] extends readonly [PropertyKey, infer Value] ? Value : never
 >