type-plus 5.6.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-plus",
-  "version": "5.6.0",
+  "version": "6.0.0",
   "description": "Provides additional types for TypeScript.",
   "homepage": "https://github.com/unional/type-plus",
   "bugs": {
@@ -22,14 +22,15 @@
     "require": "./cjs/index.js"
   },
   "main": "./cjs/index.js",
-  "typings": "./cjs/index.d.ts",
+  "module": "./esm/index.js",
+  "types": "./cjs/index.d.ts",
   "files": [
     "cjs",
     "esm",
     "ts",
-    "!ts/**/*.spec.ts",
     "!ts/types",
-    "!ts/type-checker"
+    "!ts/type-checker",
+    "!**/*.{spec,test,unit,accept,integrate,system}.*"
   ],
   "dependencies": {
     "tersify": "^3.11.1",
@@ -40,8 +41,9 @@
     "@commitlint/cli": "^17.0.2",
     "@commitlint/config-conventional": "^17.0.2",
     "@jest/globals": "^29.3.1",
-    "@repobuddy/jest": "^2.1.0",
-    "@size-limit/preset-small-lib": "^8.0.0",
+    "@repobuddy/jest": "^3.0.0",
+    "@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",
@@ -51,7 +53,8 @@
     "cross-env": "^7.0.3",
     "depcheck": "^1.4.3",
     "eslint": "^8.17.0",
-    "eslint-plugin-harmony": "^7.1.0",
+    "eslint-config-prettier": "^8.7.0",
+    "eslint-plugin-harmony": "^7.1.2",
     "husky": "^8.0.1",
     "jest": "^29.0.0",
     "jest-watch-suspend": "^1.1.2",
@@ -62,24 +65,27 @@
     "pinst": "^3.0.0",
     "rimraf": "^3.0.2",
     "satisfier": "^5.2.2",
-    "size-limit": "^8.0.0",
+    "size-limit": "^8.2.4",
     "ts-jest": "^29.0.0",
     "tslib": "^2.4.0",
     "typedoc": "^0.23.0",
     "typedoc-plugin-extras": "^2.2.3",
-    "typescript": "^4.9.4"
+    "typescript": "^5.0.0"
   },
-  "packageManager": "pnpm@7.25.1",
+  "packageManager": "pnpm@7.29.3",
   "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"
     }

package/ts/JSONTypes.ts

@@ -9,9 +9,9 @@ export type JSONArray = Array<JSONTypes>
 export const JSONTypes = { get }
 
 function get<T extends JSONTypes>(obj: JSONTypes, ...props: Array<string | number>): T | undefined {
-  if (props.length === 0) return obj as T
-  if (typeof obj !== 'object' || obj === null) return undefined
-  const p = props.shift()!
-  // @ts-ignore
-  return get(obj[p], ...props) as T
+	if (props.length === 0) return obj as T
+	if (typeof obj !== 'object' || obj === null) return undefined
+	const p = props.shift()!
+	// @ts-ignore
+	return get(obj[p], ...props) as T
 }

package/ts/PrimitiveTypes.ts

@@ -1,6 +1,15 @@
 // IsNever from @jack-williams: https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
 
 // eslint-disable-next-line @typescript-eslint/ban-types
-export type PrimitiveTypes = boolean | number | string | object | symbol | bigint | Function | undefined | null
+export type PrimitiveTypes =
+	| boolean
+	| number
+	| string
+	| object
+	| symbol
+	| bigint
+	| Function
+	| undefined
+	| null
 
 export type IsNever<T, Then = true, Else = false> = [T] extends [never] ? Then : Else

package/ts/UnionToIntersection.ts

@@ -1,7 +1,9 @@
-// from jcalz, https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286
-// istanbul ignore file
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
-
-export function toIntersection<U>(union: U): UnionToIntersection<U> {
-  return union as any as UnionToIntersection<U>
-}
+// from jcalz, https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286
+// istanbul ignore file
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+	? I
+	: never
+
+export function toIntersection<U>(union: U): UnionToIntersection<U> {
+	return union as any as UnionToIntersection<U>
+}

package/ts/array_plus/_plus.ts

@@ -0,0 +1 @@
+export type * from './array.js'

package/ts/array_plus/array.ts

@@ -0,0 +1,38 @@
+import type { Abs } from '../math/Abs.js'
+import type { GreaterThan } from '../math/GreaterThan.js'
+import type { Subtract } from '../math/Subtract.js'
+import type { Negative } from '../number_plus/number.js'
+
+/**
+ * Gets the type of the array or tuple at index `N`.
+ *
+ * Like `Array.at()`, this type supports negative numbers.
+ *
+ * @alias ArrayPlus.At
+ *
+ * ```
+ * import type { At } from 'type-plus'
+ *
+ * type R = At<[1, 2, 3], -1> // 3
+ * ```
+ */
+export type At<A extends Array<unknown>, N extends number> = A['length'] extends 0
+	? never
+	: number extends A['length']
+	? A[N]
+	: GreaterThan<Abs<N>, A['length']> extends true
+	? undefined
+	: Negative<N, A[Subtract<A['length'], Abs<N>>], A[N]>
+
+/**
+ * Concats two arrays.
+ *
+ * alias of: `[...A, ...B]`
+ *
+ * ```
+ * 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_plus/common_prop_keys.ts

@@ -0,0 +1,18 @@
+import type { Tail } from './tail.js'
+
+/**
+ * Gets the common property keys of the elements in `A`.
+ */
+export type CommonPropKeys<A extends Record<string, unknown>[]> = A['length'] extends 0
+	? never
+	: A['length'] extends 1
+	? keyof A[0]
+	: A['length'] extends 2
+	? keyof A[0] & keyof A[1]
+	: keyof A[0] & keyof A[1] & CommonPropKeys<Tail<Tail<A>>>
+
+/**
+ * Gets the common property keys of the elements in `A`.
+ * @deprecated Please use CommonPropKeys instead.
+ */
+export type CommonKeys<A extends Record<string, any>[]> = CommonPropKeys<A>

package/ts/array_plus/create_tuple.ts

@@ -0,0 +1,15 @@
+import type { DigitArray, IsPositive, IsWhole } from '../math/index.js'
+
+/**
+ * Creates `Tuple<T>` with `L` number of elements.
+ * @note Other cool implementations by @lazytype, @jcalz:
+ * @see https://github.com/microsoft/TypeScript/issues/26223#issuecomment-674514787
+ * @see https://github.com/microsoft/TypeScript/issues/47874#issuecomment-1039157322
+ */
+export type CreateTuple<L extends number, T = any, Fail = never> = number extends L
+	? T[]
+	: IsPositive<L> extends true
+	? IsWhole<L> extends true
+		? DigitArray.ToTuple<[], DigitArray.FromNumber<L>, T>
+		: Fail
+	: Fail

package/ts/array_plus/drop.ts

@@ -0,0 +1,71 @@
+import type { Equal } from '../predicates/index.js'
+import type { NonNull, NonUndefined } from '../utils/index.js'
+
+export type DropFirst<A extends any[]> = number extends A['length']
+	? A
+	: A['length'] extends 0
+	? never[]
+	: A['length'] extends 1
+	? never[]
+	: A extends [any, ...infer Tail]
+	? Tail
+	: never
+
+export type DropLast<A extends any[]> = number extends A['length']
+	? A
+	: A['length'] extends 0
+	? never[]
+	: A['length'] extends 1
+	? never[]
+	: A extends [...infer Heads, any]
+	? Heads
+	: never
+
+type ExcludeUnionOfEmptyTuple<A> = Equal<A, []> extends true ? A : Exclude<A, []>
+
+/**
+ * drops entries matching `Criteria` in array or tuple `A`.
+ */
+export type DropMatch<A extends Readonly<Array<any>>, Criteria> = number extends A['length']
+	? // array
+	  A[0] extends Criteria
+		? // criteria matches: DropAll<string[], string>
+		  never[]
+		: undefined extends Criteria
+		? null extends Criteria
+			? Array<NonNullable<A[0]>>
+			: Array<NonUndefined<A[0]>>
+		: null extends Criteria
+		? Array<NonNull<A[0]>>
+		: Criteria extends A[0]
+		? Array<Exclude<A[0], Criteria>>
+		: A[0] extends Criteria
+		? A
+		: Array<Exclude<A[0], Criteria>>
+	: DropMatchTuple<A, Criteria>
+
+type DropMatchTuple<A extends Readonly<Array<any>>, Criteria> = A['length'] extends 0
+	? // empty tuple
+	  A
+	: A extends readonly [infer Head, ...infer Tail]
+	? Tail['length'] extends 0
+		? // single element tuple
+		  undefined extends Criteria
+			? ExcludeUnionOfEmptyTuple<Head extends Criteria ? [] : [Head]>
+			: ExcludeUnionOfEmptyTuple<Head extends Criteria ? [] : [Head]>
+		: // multiple elements
+		Exclude<Head, Criteria> extends never
+		? DropMatch<Tail, Criteria>
+		: [Exclude<Head, Criteria>, ...DropMatch<Tail, Criteria>]
+	: never[]
+
+export type DropNull<A extends Array<any>> = DropMatch<A, null>
+export type DropNullable<A extends Array<any>> = DropMatch<A, null | undefined>
+export type DropUndefined<A extends Array<any>> = DropMatch<A, undefined>
+
+/**
+ * drop a particular value from an array
+ */
+export function drop<A extends Readonly<Array<any>>, C>(array: A, value: C): DropMatch<A, C> {
+	return array.filter(v => v !== value) as DropMatch<A, C>
+}

package/ts/array_plus/filter.ts

@@ -0,0 +1,28 @@
+/**
+ * filter the array or tuple `A`, keeping entries satisfying `Criteria`.
+ * @deprecated renaming to `KeepMatch`
+ */
+export type Filter<A extends Array<any>, Criteria> = number extends A['length']
+	? // array
+	  A[0] extends Criteria
+		? A
+		: Criteria extends A[0]
+		? Array<Criteria>
+		: never[]
+	: // tuple
+	A['length'] extends 0
+	? never
+	: A extends [infer Head, ...infer Tail]
+	? Tail['length'] extends 0
+		? Head extends Criteria
+			? [Head]
+			: never[]
+		: Head extends Criteria
+		? [Head, ...Filter<Tail, Criteria>]
+		: Filter<Tail, Criteria>
+	: never
+
+/**
+ * keeps entries satisfying `Criteria` in array or tuple `A`.
+ */
+export type KeepMatch<A extends Array<any>, Criteria> = Filter<A, Criteria>

package/ts/array_plus/find_first.ts

@@ -0,0 +1,16 @@
+export type FindFirst<A extends Array<any>, Criteria> = number extends A['length']
+	? A[0] extends Criteria
+		? A[0]
+		: never
+	: A['length'] extends 0
+	? never
+	: A extends [any, ...infer Tail]
+	? A[0] extends Criteria
+		? A[0]
+		: FindFirst<Tail, Criteria>
+	: never
+
+/**
+ * @deprecated use FindFirst
+ */
+export type First<A extends any[], Criteria> = FindFirst<A, Criteria>

package/ts/array_plus/find_last.ts

@@ -0,0 +1,11 @@
+export type FindLast<A extends Array<any>, Criteria> = number extends A['length']
+	? A[0] extends Criteria
+		? A[0]
+		: never
+	: A['length'] extends 0
+	? never
+	: A extends [...infer Heads, infer Last]
+	? Last extends Criteria
+		? Last
+		: FindLast<Heads, Criteria>
+	: never

package/ts/array_plus/head.ts

@@ -0,0 +1 @@
+export type Head<T extends any[]> = T['length'] extends 0 ? never : T[0]

package/ts/array_plus/index.ts

@@ -0,0 +1,19 @@
+export type * from './array.js'
+export type { CommonKeys, CommonPropKeys } from './common_prop_keys.js'
+export type { CreateTuple } from './create_tuple.js'
+export * from './drop.js'
+export type { Filter, KeepMatch } from './filter.js'
+export type { FindFirst, First } from './find_first.js'
+export type { FindLast } from './find_last.js'
+export type { Head } from './head.js'
+export type { IntersectOfProps, MapToProp } from './intersect_of_props.js'
+export type { IsArray } from './is_array.js'
+export type { Last } from './last.js'
+export * from './literal_array.js'
+export type { PadLeft } from './pad_left.js'
+export * from './reduce_while.js'
+export type { Reverse } from './reverse.js'
+export type { Some } from './some.js'
+export type { Tail } from './tail.js'
+export type { PropUnion, UnionOfProps } from './union_of_props.js'
+export type { ArrayValue, UnionOfValues } from './union_of_values.js'

package/ts/array_plus/intersect_of_props.ts

@@ -0,0 +1,17 @@
+import type { KeyTypes } from '../object/index.js'
+import type { Tail } from './tail.js'
+
+/**
+ * Gets the intersect of properties of the elements in `A`
+ */
+export type IntersectOfProps<A extends Record<any, unknown>[], P extends KeyTypes> = A['length'] extends 0
+	? never
+	: A['length'] extends 1
+	? A[0][P]
+	: A[0][P] & IntersectOfProps<Tail<A>, P>
+
+/**
+ * Gets the intersect of properties of the elements in `A`
+ * This will be deprecated in 4.0. Please use IntersectOfProps instead.
+ */
+export type MapToProp<A extends Record<any, any>[], P extends KeyTypes> = IntersectOfProps<A, P>

package/ts/array_plus/is_array.ts

@@ -0,0 +1 @@
+export type IsArray<T, Then = true, Else = false> = T extends any[] ? Then : Else

package/ts/array_plus/literal_array.ts

@@ -0,0 +1,5 @@
+import type { KeyTypes } from '../object/index.js'
+
+export function literalArray<T extends KeyTypes>(...entries: T[]): T[] {
+	return entries
+}

package/ts/array_plus/pad_left.ts

@@ -0,0 +1,15 @@
+import { Equal, IsAny } from '../predicates/index.js'
+import { CreateTuple } from './create_tuple.js'
+import { UnionOfValues } from './union_of_values.js'
+
+export type PadLeft<A extends any[], Total extends number, PadWith = any> = number extends A['length']
+	? IsAny<UnionOfValues<A>> extends true
+		? A
+		: Equal<UnionOfValues<A>, PadWith> extends true
+		? A
+		: PadLeft<[...CreateTuple<Total, PadWith>, ...A], Total, PadWith>
+	: CreateTuple<Total, any> extends [...infer U, ...A]
+	? number extends U['length']
+		? A
+		: [...CreateTuple<U['length'], PadWith>, ...A]
+	: A

package/ts/array_plus/reduce_while.ts

@@ -0,0 +1,14 @@
+export function reduceWhile<T, R>(
+	predicate: (acc: R, currentValue: T) => boolean,
+	callbackfn: (previousValue: R, currentValue: T, currentIndex: number, array: T[]) => R,
+	initialValue: R,
+	array: T[]
+) {
+	let acc = initialValue
+	for (let i = 0; i < array.length; i++) {
+		const value = array[i]
+		if (!predicate(acc, value)) return acc
+		acc = callbackfn(acc, value, i, array)
+	}
+	return acc
+}

package/ts/array_plus/reverse.ts

@@ -0,0 +1,11 @@
+export type Reverse<A extends unknown[]> = number extends A['length']
+	? A
+	: A['length'] extends 0
+	? A
+	: A['length'] extends 1
+	? A
+	: A extends [any, ...infer T]
+	? T extends any[]
+		? [...Reverse<T>, A[0]]
+		: never
+	: never

package/ts/array_plus/some.ts

@@ -0,0 +1,33 @@
+import type { Equal } from '../predicates/index.js'
+import type { Tail } from './tail.js'
+import type { UnionOfValues } from './union_of_values.js'
+
+export type Some<
+	A extends any[],
+	Criteria,
+	Mode extends 'strict' | 'loose' = 'loose',
+	Then = true,
+	Else = false
+> = Mode extends 'strict'
+	? Some.Strict<A, Criteria, Then, Else>
+	: number extends A['length']
+	? UnionOfValues<A> extends Criteria
+		? Then
+		: Else
+	: A['length'] extends 0
+	? Else
+	: A[0] extends Criteria
+	? Then
+	: Some<Tail<A>, Criteria, 'loose', Then, Else>
+
+export namespace Some {
+	export type Strict<A extends any[], Criteria, Then, Else> = number extends A['length']
+		? Equal<UnionOfValues<A>, Criteria> extends true
+			? Then
+			: Else
+		: A['length'] extends 0
+		? Else
+		: Equal<A[0], Criteria> extends true
+		? Then
+		: Strict<Tail<A>, Criteria, Then, Else>
+}

package/ts/array_plus/tail.ts

@@ -0,0 +1,12 @@
+import { UnionOfValues } from './union_of_values.js'
+
+/**
+ * Gets the types of a tuple except the first entry.
+ */
+export type Tail<T extends any[]> = T['length'] extends 0
+	? never
+	: T extends [any, ...infer Tail]
+	? Tail extends UnionOfValues<T>[]
+		? Tail
+		: never
+	: T

package/ts/array_plus/union_of_props.ts

@@ -0,0 +1,17 @@
+import type { KeyTypes } from '../object/index.js'
+import type { Tail } from './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
+	? never
+	: A['length'] extends 1
+	? A[0][P]
+	: A[0][P] | UnionOfProps<Tail<A>, P>
+
+/**
+ * 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>

package/ts/assertion/assertType.ts

@@ -8,86 +8,88 @@ import type { AnyFunction } from '../function/index.js'
  */
 export function assertType<T>(subject: T): asserts subject is T
 export function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T
-export function assertType<T extends new (...args: any) => any>(subject: unknown, constructor: T): asserts subject is InstanceType<T>
+export function assertType<T extends new (...args: any) => any>(
+	subject: unknown,
+	constructor: T
+): asserts subject is InstanceType<T>
 export function assertType(subject: unknown, validator?: (s: any) => boolean) {
-  if (validator) {
-    if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
-      throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-  }
-  return
+	if (validator) {
+		if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
+			throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+	}
+	return
 }
 
 assertType.isUndefined = function (subject: undefined): asserts subject is undefined {
-  if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
+	if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
 }
 assertType.noUndefined = function <S>(subject: Exclude<S, undefined>): void {
-  if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
+	if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
 }
 
 assertType.isNull = function (subject: null): asserts subject is null {
-  if (subject !== null) throw TypeError(`subject is not null`)
+	if (subject !== null) throw TypeError(`subject is not null`)
 }
 assertType.noNull = function <S>(subject: Exclude<S, null>): void {
-  if (subject === null) throw TypeError(`subject is null`)
+	if (subject === null) throw TypeError(`subject is null`)
 }
 
 assertType.isNumber = function (subject: number): asserts subject is number {
-  if (typeof subject !== 'number') throw TypeError(`subject is not number`)
+	if (typeof subject !== 'number') throw TypeError(`subject is not number`)
 }
 assertType.noNumber = function <S>(subject: Exclude<S, number>): void {
-  if (typeof subject === 'number') throw TypeError(`subject is number`)
+	if (typeof subject === 'number') throw TypeError(`subject is number`)
 }
 
 assertType.isBoolean = function (subject: boolean): asserts subject is boolean {
-  if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
+	if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
 }
 assertType.noBoolean = function <S>(subject: Exclude<S, boolean>): void {
-  if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
+	if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
 }
 
 assertType.isTrue = function (subject: true): asserts subject is true {
-  if (subject !== true) throw TypeError(`subject is not true`)
+	if (subject !== true) throw TypeError(`subject is not true`)
 }
 assertType.noTrue = function <S>(subject: Exclude<S, true>): void {
-  // @ts-ignore
-  if (subject === true) throw TypeError(`subject is true`)
+	// @ts-ignore
+	if (subject === true) throw TypeError(`subject is true`)
 }
 
 assertType.isFalse = function (subject: false): asserts subject is false {
-  if (subject !== false) throw TypeError(`subject is not false`)
+	if (subject !== false) throw TypeError(`subject is not false`)
 }
 assertType.noFalse = function <S>(subject: Exclude<S, false>): void {
-  // @ts-ignore
-  if (subject === false) throw TypeError(`subject is false`)
+	// @ts-ignore
+	if (subject === false) throw TypeError(`subject is false`)
 }
 
 assertType.isString = function (subject: string): asserts subject is string {
-  if (typeof subject !== 'string') throw TypeError(`subject is not string`)
+	if (typeof subject !== 'string') throw TypeError(`subject is not string`)
 }
 assertType.noString = function <S>(subject: Exclude<S, string>): void {
-  if (typeof subject === 'string') throw TypeError(`subject is string`)
+	if (typeof subject === 'string') throw TypeError(`subject is string`)
 }
 
 assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
-  if (typeof subject !== 'function') throw TypeError(`subject is not function`)
+	if (typeof subject !== 'function') throw TypeError(`subject is not function`)
 }
 assertType.noFunction = function <S>(subject: Exclude<S, AnyFunction>): void {
-  if (typeof subject === 'function') throw TypeError(`subject is function`)
+	if (typeof subject === 'function') throw TypeError(`subject is function`)
 }
 
 assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
-  if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
+	if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
 }
 
 assertType.isError = function (subject: Error): asserts subject is Error {
-  if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
+	if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
 }
 assertType.noError = function <S>(subject: Exclude<S, Error>): void {
-  if (subject instanceof Error) throw TypeError(`subject is an Error`)
+	if (subject instanceof Error) throw TypeError(`subject is an Error`)
 }
 
-assertType.isNever = function (subject: never): asserts subject is never {
-}
+assertType.isNever = function (subject: never): asserts subject is never {}
 
 /**
  * creates a custom assertion function with standard TypeError.
@@ -95,13 +97,11 @@ assertType.isNever = function (subject: never): asserts subject is never {
  * thus making it hard to use:
  * https://github.com/microsoft/TypeScript/issues/41047
  */
-assertType.custom = function <T>(
-  validator: (s: T) => boolean
-): (subject: unknown) => asserts subject is T {
-  return function (subject) {
-    if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-    return
-  }
+assertType.custom = function <T>(validator: (s: T) => boolean): (subject: unknown) => asserts subject is T {
+	return function (subject) {
+		if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+		return
+	}
 }
 
 assertType.as = function <T>(subject: unknown): asserts subject is T {}

package/ts/assertion/index.ts

@@ -1 +1 @@
-export * from './assertType.js'
+export * from './assertType.js'

package/ts/binary/Bit.ts

@@ -1,6 +1,6 @@
 export type Bit = 0 | 1
 
 export type BitNot<X extends Bit> = X extends 0 ? 1 : 0
-export type BitAnd<A extends Bit, B extends Bit> = A extends 1 ? B extends 1 ? 1 : 0 : 0
+export type BitAnd<A extends Bit, B extends Bit> = A extends 1 ? (B extends 1 ? 1 : 0) : 0
 export type BitOr<A extends Bit, B extends Bit> = A extends 1 ? 1 : B extends 1 ? 1 : 0
 export type BitXor<A extends Bit, B extends Bit> = A extends 1 ? BitNot<B> : B