type-plus 6.3.0 → 6.4.0

package/esm/testing/test_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_type.js","sourceRoot":"","sources":["../../ts/testing/test_type.ts"],"names":[],"mappings":"AAyBA,SAAS,KAAK,CAAC,QAAiB;IAC/B,OAAO,QAAQ,CAAA;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACvB;;;;OAIG;IACH,GAAG,CAAI,QAAkB;QACxB,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,OAAO,CAAI,QAAsB;QAChC,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,KAAK,CAAI,QAAoB;QAC5B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,IAAI,CAAI,QAAmB;QAC1B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD,KAAK;IACL;;;;OAIG;IACH,SAAS,CAAO,QAAyB;QACxC,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,aAAa,CAAI,QAA4B;QAC5C,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,OAAO,CAAI,QAAsB;QAChC,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,IAAI,CAAI,QAAmB;QAC1B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,KAAK,CAAI,QAAoB;QAC5B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,YAAY,CAAI,QAA2B;QAC1C,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,MAAM,CAAI,QAAqB;QAC9B,OAAO,QAAa,CAAA;IACrB,CAAC;CACD,CAAA"}

package/esm/tuple/tuple_type.d.ts

@@ -0,0 +1,67 @@
+import type { IsNever } from '../never/never_type.js';
+/**
+ * Check if `T` is a tuple and not an array.
+ *
+ * ```ts
+ * import type { TupleType } from 'type-plus'
+ *
+ * type R = TupleType<[]>       // []
+ * type R = TupleType<[1]>      // [1]
+ *
+ * type R = TupleType<number[]> // never
+ * type R = TupleType<string>   // never
+ * type R = TupleType<never>    // never
+ * type R = TupleType<unknown>  // never
+ * ```
+ */
+export type TupleType<T, Then = T, Else = never> = IsNever<T, Else, [
+    T
+] extends [any[]] ? (number extends T['length'] ? Else : Then) : Else>;
+/**
+ * Check if `T` is not a tuple.
+ *
+ * ```ts
+ * import type { NotTupleType } from 'type-plus'
+ *
+ * type R = NotTupleType<[]>       // never
+ * type R = NotTupleType<[1]>      // never
+ *
+ * type R = NotTupleType<number[]> // number[]
+ * type R = NotTupleType<string>   // string
+ * type R = NotTupleType<never>    // never
+ * type R = NotTupleType<unknown>  // unknown
+ * ```
+ */
+export type NotTupleType<T, Then = T, Else = never> = TupleType<T, Else, Then>;
+/**
+ * Is `T` a tuple and not an array.
+ *
+ * ```ts
+ * import type { IsTuple } from 'type-plus'
+ *
+ * type R = IsTuple<[]>       // true
+ *
+ * type R = IsTuple<number[]> // false
+ * type R = IsTuple<string>   // false
+ * type R = IsTuple<never>    // false
+ * type R = IsTuple<unknown>  // false
+ * ```
+ */
+export type IsTuple<T, Then = true, Else = false> = TupleType<T, Then, Else>;
+/**
+ * Is `T` not a tuple.
+ *
+ * ```ts
+ * import type { IsNotTuple } from 'type-plus'
+ *
+ * type R = IsNotTuple<[]>       // false
+ * type R = IsNotTuple<[1]>      // false
+ *
+ * type R = IsNotTuple<number[]> // false
+ * type R = IsNotTuple<string>   // false
+ * type R = IsNotTuple<never>    // false
+ * type R = IsNotTuple<unknown>  // false
+ * ```
+ */
+export type IsNotTuple<T, Then = true, Else = false> = TupleType<T, Else, Then>;
+//# sourceMappingURL=tuple_type.d.ts.map

package/esm/tuple/tuple_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple_type.d.ts","sourceRoot":"","sources":["../../ts/tuple/tuple_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CACzD,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,CACvE,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/tuple/tuple_type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tuple_type.js.map

package/esm/tuple/tuple_type.js.map

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

package/esm/undefined/undefined_type.d.ts

@@ -0,0 +1,61 @@
+import type { IsAny } from '../any/any_type.js';
+/**
+ * Check if the type `T` is exactly `undefined`.
+ *
+ * ```
+ * import type { UndefinedType } from 'type-plus'
+ *
+ * type R = UndefinedType<undefined> // undefined
+ *
+ * type R = UndefinedType<never> // never
+ * type R = UndefinedType<unknown> // never
+ * type R = UndefinedType<string | boolean> // never
+ * ```
+ */
+export type UndefinedType<T, Then = T, Else = never> = IsAny<T, Else, [
+    T,
+    undefined
+] extends [undefined, T] ? Then : Else>;
+/**
+ * Is the type `T` exactly `undefined`.
+ *
+ * ```
+ * import type { IsUndefined } from 'type-plus'
+ *
+ * type R = IsUndefined<undefined> // true
+ *
+ * type R = IsUndefined<never> // false
+ * type R = IsUndefined<unknown> // false
+ * type R = IsUndefined<string | boolean> // false
+ * ```
+ */
+export type IsUndefined<T, Then = true, Else = false> = UndefinedType<T, Then, Else>;
+/**
+ * Check if the type `T` is not `undefined`.
+ *
+ * ```
+ * import type { NotUndefinedType } from 'type-plus'
+ *
+ * type R = NotUndefinedType<undefined> // never
+ *
+ * type R = NotUndefinedType<never> // never
+ * type R = NotUndefinedType<unknown> // unknown
+ * type R = NotUndefinedType<string | boolean> // string | boolean
+ * ```
+ */
+export type NotUndefinedType<T, Then = T, Else = never> = UndefinedType<T, Else, Then>;
+/**
+ * Is the type `T` not `undefined`.
+ *
+ * ```
+ * import type { IsNotUndefined } from 'type-plus'
+ *
+ * type R = IsNotUndefined<undefined> // false
+ *
+ * type R = IsNotUndefined<never> // true
+ * type R = IsNotUndefined<unknown> // true
+ * type R = IsNotUndefined<string | boolean> // true
+ * ```
+ */
+export type IsNotUndefined<T, Then = true, Else = false> = UndefinedType<T, Else, Then>;
+//# sourceMappingURL=undefined_type.d.ts.map

package/esm/undefined/undefined_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undefined_type.d.ts","sourceRoot":"","sources":["../../ts/undefined/undefined_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CAC3D,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,SAAS;CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CACnD,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEpF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEtF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/undefined/undefined_type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=undefined_type.js.map

package/esm/undefined/undefined_type.js.map

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

package/esm/union_keys.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `UnionKeys<T>` will distribute keys of an union to individual types.
+ * This should be used in conjuncture with distributive types.
+ */
+export type UnionKeys<T> = keyof T | (T extends unknown ? keyof T : never);
+//# sourceMappingURL=union_keys.d.ts.map

package/esm/union_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_keys.d.ts","sourceRoot":"","sources":["../ts/union_keys.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,OAAO,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC,CAAA"}

package/esm/union_keys.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=union_keys.js.map

package/esm/union_keys.js.map

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

package/esm/union_to_intersection.d.ts

@@ -0,0 +1,3 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export declare function toIntersection<U>(union: U): UnionToIntersection<U>;
+//# sourceMappingURL=union_to_intersection.d.ts.map

package/esm/union_to_intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_to_intersection.d.ts","sourceRoot":"","sources":["../ts/union_to_intersection.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,IAAI,GACvG,CAAC,GACD,KAAK,CAAA;AAER,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAElE"}

package/esm/union_to_intersection.js

@@ -0,0 +1,4 @@
+export function toIntersection(union) {
+    return union;
+}
+//# sourceMappingURL=union_to_intersection.js.map

package/esm/union_to_intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_to_intersection.js","sourceRoot":"","sources":["../ts/union_to_intersection.ts"],"names":[],"mappings":"AAMA,MAAM,UAAU,cAAc,CAAI,KAAQ;IACzC,OAAO,KAAsC,CAAA;AAC9C,CAAC"}

package/esm/unknown/unknown_type.d.ts

@@ -0,0 +1,59 @@
+import type { IsAny } from '../any/any_type.js';
+/**
+ * Check if the type `T` is exactly `unknown`.
+ *
+ * ```
+ * import type { UnknownType } from 'type-plus'
+ *
+ * type R = UnknownType<unknown> // unknown
+ *
+ * type R = UnknownType<number> // never
+ * type R = UnknownType<never> // never
+ * ```
+ */
+export type UnknownType<T, Then = T, Else = never> = IsAny<T, Else, [
+    T,
+    unknown
+] extends [unknown, T] ? Then : Else>;
+/**
+ * Is the type `T` exactly `unknown`.
+ *
+ * ```
+ * import type { IsUnknown } from 'type-plus'
+ *
+ * type R = IsUnknown<unknown> // true
+ *
+ * type R = IsUnknown<number> // false
+ * type R = IsUnknown<never> // false
+ * ```
+ */
+export type IsUnknown<T, Then = true, Else = false> = UnknownType<T, Then, Else>;
+/**
+ * Check if the type `T` is not `unknown`.
+ *
+ * ```
+ * import type { NotUnknownType } from 'type-plus'
+ *
+ * type R = NotUnknownType<unknown> // never
+ *
+ * type R = NotUnknownType<never> // never
+ * type R = NotUnknownType<number> // number
+ * type R = NotUnknownType<string | boolean> // string | boolean
+ * ```
+ */
+export type NotUnknownType<T, Then = T, Else = never> = UnknownType<T, Else, Then>;
+/**
+ * Is the type `T` not exactly `unknown`.
+ *
+ * ```
+ * import type { IsNotUnknown } from 'type-plus'
+ *
+ * type R = IsNotUnknown<unknown> // false
+ *
+ * type R = IsNotUnknown<never> // true
+ * type R = IsNotUnknown<number> // true
+ * type R = IsNotUnknown<string | boolean> // true
+ * ```
+ */
+export type IsNotUnknown<T, Then = true, Else = false> = UnknownType<T, Else, Then>;
+//# sourceMappingURL=unknown_type.d.ts.map

package/esm/unknown/unknown_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown_type.d.ts","sourceRoot":"","sources":["../../ts/unknown/unknown_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CACzD,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,OAAO;CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAC/C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAElF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/unknown/unknown_type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unknown_type.js.map

package/esm/unknown/unknown_type.js.map

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

package/esm/void/void_type.d.ts

@@ -0,0 +1,51 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js';
+import type { IsUndefined } from '../undefined/undefined_type.js';
+/**
+ * Check if `T` is `void`.
+ *
+ * ```ts
+ * import type { VoidType } from 'type-plus'
+ *
+ * type R = VoidType<void> // void
+ *
+ * type R = VoidType<1> // never
+ * ```
+ */
+export type VoidType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, IsUndefined<T, Else, [T] extends [void] ? Then : Else>>;
+/**
+ * Check if `T` is not `void`.
+ *
+ * ```ts
+ * import type { VoidType } from 'type-plus'
+ *
+ * type R = VoidType<void> // never
+ *
+ * type R = VoidType<1> // 1
+ * ```
+ */
+export type NotVoidType<T, Then = T, Else = never> = VoidType<T, Else, Then>;
+/**
+ * Is `T` `void`.
+ *
+ * ```ts
+ * import type { IsVoid } from 'type-plus'
+ *
+ * type R = IsVoid<void> // true
+ *
+ * type R = IsVoid<1> // false
+ * ```
+ */
+export type IsVoid<T, Then = true, Else = false> = VoidType<T, Then, Else>;
+/**
+ * Is `T` not `void`.
+ *
+ * ```ts
+ * import type { IsNotVoid } from 'type-plus'
+ *
+ * type R = IsNotVoid<void> // false
+ *
+ * type R = IsNotVoid<1> // true
+ * ```
+ */
+export type IsNotVoid<T, Then = true, Else = false> = VoidType<T, Else, Then>;
+//# sourceMappingURL=void_type.d.ts.map

package/esm/void/void_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"void_type.d.ts","sourceRoot":"","sources":["../../ts/void/void_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAC7D,CAAC,EACD,IAAI,EACJ,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CACtD,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/void/void_type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=void_type.js.map

package/esm/void/void_type.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-plus",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "Provides additional types for TypeScript.",
   "homepage": "https://github.com/unional/type-plus",
   "bugs": {
@@ -40,11 +40,10 @@
     "@changesets/cli": "^2.25.2",
     "@commitlint/cli": "^17.0.2",
     "@commitlint/config-conventional": "^17.0.2",
-    "@jest/globals": "^29.3.1",
-    "@repobuddy/jest": "^3.0.0",
+    "@jest/globals": "^29.5.0",
+    "@repobuddy/jest": "^3.1.5",
     "@size-limit/esbuild-why": "^8.2.4",
     "@size-limit/preset-small-lib": "^8.2.4",
-    "@types/jest": "^29.0.0",
     "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.28.0",
     "@typescript-eslint/parser": "^5.48.0",
@@ -56,40 +55,23 @@
     "eslint-config-prettier": "^8.7.0",
     "eslint-plugin-harmony": "^7.1.2",
     "husky": "^8.0.1",
-    "jest": "^29.0.0",
+    "jest": "^29.5.0",
     "jest-watch-suspend": "^1.1.2",
     "jest-watch-toggle-config-2": "^2.1.0",
-    "jest-watch-typeahead": "^2.0.0",
+    "jest-watch-typeahead": "^2.2.2",
     "ncp": "^2.0.0",
     "npm-run-all": "^4.1.5",
     "pinst": "^3.0.0",
     "rimraf": "^3.0.2",
     "satisfier": "^5.2.2",
     "size-limit": "^8.2.4",
-    "ts-jest": "^29.0.0",
+    "ts-jest": "^29.1.0",
     "tslib": "^2.4.0",
     "typedoc": "^0.23.0",
     "typedoc-plugin-extras": "^2.2.3",
     "typescript": "^5.0.2"
   },
-  "packageManager": "pnpm@7.30.0",
-  "size-limit": [
-    {
-      "name": "cjs",
-      "path": "./cjs/index.js",
-      "limit": "15 kb"
-    },
-    {
-      "name": "esm",
-      "path": "./esm/index.js",
-      "limit": "15 kb"
-    },
-    {
-      "name": "tslib",
-      "path": "./tslib/index.js",
-      "limit": "15 kb"
-    }
-  ],
+  "packageManager": "pnpm@8.1.0",
   "scripts": {
     "build": "run-p build:cjs build:esm build:tslib",
     "build:cjs": "tsc -p tsconfig.cjs.json && ncp package.cjs.json cjs/package.json",

package/ts/any/any_or_never.ts

@@ -0,0 +1,17 @@
+import type { IsNever } from '../never/never_type.js'
+import type { IsAny } from './any_type.js'
+
+/**
+ * Is `T` type `any` or `never`.
+ *
+ * ```ts
+ * import type { IsAnyOrNever } from 'type-plus'
+ *
+ * type R = IsAnyOrNever<any> // true
+ * type R = IsAnyOrNever<never> // true
+ *
+ * type R = IsAnyOrNever<1> // false
+ * type R = IsAnyOrNever<unknown> // false
+ * ```
+ */
+export type IsAnyOrNever<T, Then = true, Else = false> = IsNever<T, Then, IsAny<T, Then, Else>>

package/ts/any/any_type.ts

@@ -0,0 +1,60 @@
+
+/**
+ * Check if the type `T` is exactly `any`.
+ *
+ * ```
+ * import type { AnyType } from 'type-plus'
+ *
+ * type R = AnyType<any> // any
+ *
+ * type R = AnyType<never> // never
+ * type R = AnyType<unknown> // never
+ * type R = AnyType<string | boolean> // never
+ * ```
+ */
+export type AnyType<T, Then = T, Else = never> = 0 extends 1 & T ? Then : Else
+
+/**
+ * Is the type `T` exactly `any`.
+ *
+ * ```
+ * import type { IsAny } from 'type-plus'
+ *
+ * type R = IsAny<any> // true
+ *
+ * type R = IsAny<never> // false
+ * type R = IsAny<unknown> // false
+ * type R = IsAny<string | boolean> // false
+ * ```
+ */
+export type IsAny<T, Then = true, Else = false> = AnyType<T, Then, Else>
+
+/**
+ * Check if the type `T` is not `any`.
+ *
+ * ```
+ * import type { NotAnyType } from 'type-plus'
+ *
+ * type R = NotAnyType<any> // never
+ *
+ * type R = NotAnyType<never> // never
+ * type R = NotAnyType<unknown> // unknown
+ * type R = NotAnyType<string | boolean> // string | boolean
+ * ```
+ */
+export type NotAnyType<T, Then = T, Else = never> = AnyType<T, Else, Then>
+
+/**
+ * Is the type `T` not `any`.
+ *
+ * ```
+ * import type { IsNotAny } from 'type-plus'
+ *
+ * type R = IsNotAny<any> // false
+ *
+ * type R = IsNotAny<never> // true
+ * type R = IsNotAny<unknown> // true
+ * type R = IsNotAny<string | boolean> // true
+ * ```
+ */
+export type IsNotAny<T, Then = true, Else = false> = AnyType<T, Else, Then>

package/ts/any/readme.md

@@ -0,0 +1,26 @@
+# Any
+
+`any` is one of the two top type in TypeScript. It is the supertype of all types. It is a way to opt-out of type checking and let the values pass through compile-time checks.
+
+## Type Checking
+
+The `AnyType<T>` and friends are used to check if a type is `any` or not.
+
+They are strict type checks, meaning they match only the type `any`.
+Union and intersections are not a factor here they are resolved to `any`,
+except `any & never` which is `never`.
+
+- [`AnyType<T, Then = T, Else = never>`](any_type.ts#L15): check if `T` is exactly `any`.
+- [`IsAny<T, Then = true, Else = false`](any_type.ts#L30): is `T` exactly `any`.
+- [`NotAnyType<T, Then = T, Else = never>`](any_type.ts#L45): check if `T` is not exactly `any`.
+- [`IsNotAny<T, Then = true, Else = false>`](any_type.ts#L60): is `T` not exactly `any`.
+
+## Type Utilities
+
+- [`IsAnyOrNever<T, Then = true, Else = false>`](any_or_never.ts#L17)]: is `T` type `any` or `never`.
+
+## References
+
+- [handbook]
+
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#any

package/ts/array/array.ts

@@ -0,0 +1,37 @@
+import type { IndexAt } from './array_index.js'
+
+/**
+ * Gets the type of the array or tuple at index `N`.
+ *
+ * Like `Array.at()`, this type supports negative numbers.
+ *
+ * @alias ArrayPlus.At
+ * @see https://github.com/microsoft/TypeScript/issues/53345#issuecomment-1477138167
+ *
+ * ```ts
+ * import type { At } from 'type-plus'
+ *
+ * type R = At<[1, 2, 3], 2> // 3
+ * type R = At<[1, 2, 3], -1> // 3
+ * ```
+ */
+export type At<A extends unknown[], N extends number, Fail = never> = IndexAt<A, N, Fail> extends infer I
+	? I extends number
+		? A[I]
+		: Fail
+	: never
+
+/**
+ * Concats two arrays.
+ *
+ * alias of: `[...A, ...B]`
+ *
+ * @alias ArrayPlus.Concat
+ *
+ * ```ts
+ * import type { Concat } form 'type-plus'
+ *
+ * type R = Concat<[1], [2, 3]> // [1, 2, 3]
+ * ```
+ */
+export type Concat<A extends unknown[], B extends unknown[]> = [...A, ...B]

package/ts/array/array_index.ts

@@ -0,0 +1,70 @@
+import type { IsAny } from '../any/any_type.js'
+import type { Equal } from '../equal/equal.js'
+import type { Abs } from '../math/Abs.js'
+import type { GreaterThan } from '../math/GreaterThan.js'
+import type { Subtract } from '../math/Subtract.js'
+import type { IsNever } from '../never/never_type.js'
+import type { Integer } from '../number/integer.js'
+import type { Negative } from '../number/negative.js'
+import type { StrictNumberType } from '../number/strict_number_type.js'
+
+/**
+ * Gets the normalized index to access the element of an array or tuple.
+ *
+ * ```
+ * import type { ArrayPlus } from 'type-plus'
+ *
+ * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], 2> // 2
+ * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], -2> // 1
+ *
+ * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], 3> // never
+ * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], -4> // never
+ * ```
+ */
+export type IndexAt<A extends Array<unknown>, N extends number, Fail = never> = Equal<
+	A['length'],
+	0,
+	Fail,
+	Integer<
+		N,
+		StrictNumberType<
+			A['length'],
+			// A: array
+			N,
+			// A: tuple
+			Negative<
+				N,
+				GreaterThan<Abs<N>, A['length']> extends true ? Fail : Subtract<A['length'], Abs<N>>,
+				GreaterThan<A['length'], N> extends true ? N : Fail
+			>
+		>,
+		// N: number or float
+		IsAny<
+			N,
+			number,
+			StrictNumberType<
+				N,
+				// TODO: handle tuple to union of indexes
+				N
+			>
+		>
+	>
+>
+
+/**
+ * Is N an out of bound index of A.
+ *
+ * ```
+ * import { IsIndexOutOfBound } from 'type-plus'
+ *
+ * type R = IsIndexOutOfBound<[1], 0> // false
+ * type R = IsIndexOutOfBound<[1], -1> // false
+
+ * type R = IsIndexOutOfBound<[1], 1> // true
+ * type R = IsIndexOutOfBound<[1], -2> // true
+ */
+export type IsIndexOutOfBound<A extends unknown[], N extends number, Then = true, Else = false> = IsNever<
+	IndexAt<A, N>,
+	Then,
+	Else
+>

package/ts/array/array_plus.ts

@@ -0,0 +1,2 @@
+export type { At, Concat } from './array.js'
+export type { IndexAt, IsIndexOutOfBound } from './array_index.js'