type-plus 5.5.2 → 6.0.0

package/ts/math/Digit.ts

@@ -1,117 +1,152 @@
-import type { Tail } from '../array/index.js'
+import type { Tail } from '../array_plus/index.js'
 import type { And } from '../predicates/index.js'
 import type { IsPositive } from './IsPositive.js'
 import type { IsWhole } from './IsWhole.js'
 
 export namespace Digit {
-  export type ToTuple<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],
-    9: [T, T, T, T, T, T, T, T, T],
-    10: [T, T, T, T, T, T, T, T, T, T],
-    11: [T, T, T, T, T, T, T, T, T, T, T],
-    12: [T, T, T, T, T, T, T, T, T, T, T, T],
-    13: [T, T, T, T, T, T, T, T, T, T, T, T, T],
-    14: [T, T, T, T, T, T, T, T, T, T, T, T, T, T],
-    15: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T],
-    16: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T],
-    17: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T],
-    18: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T],
-    19: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T],
-  }
+	export type ToTuple<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]
+		9: [T, T, T, T, T, T, T, T, T]
+		10: [T, T, T, T, T, T, T, T, T, T]
+		11: [T, T, T, T, T, T, T, T, T, T, T]
+		12: [T, T, T, T, T, T, T, T, T, T, T, T]
+		13: [T, T, T, T, T, T, T, T, T, T, T, T, T]
+		14: [T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+		15: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+		16: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+		17: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+		18: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+		19: [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+	}
 
-  /**
-   * A > B for [1-9]
-   */
-  export type GreaterThan<A extends number, B extends number> = B extends GreaterThanMap[A] ? true : false
+	/**
+	 * A > B for [1-9]
+	 */
+	export type GreaterThan<A extends number, B extends number> = B extends GreaterThanMap[A] ? true : false
 
-  export type GreaterThanMap = { [k in number]: number } & {
-    0: never,
-    1: 0,
-    2: 0 | 1,
-    3: 0 | 1 | 2,
-    4: 0 | 1 | 2 | 3,
-    5: 0 | 1 | 2 | 3 | 4,
-    6: 0 | 1 | 2 | 3 | 4 | 5,
-    7: 0 | 1 | 2 | 3 | 4 | 5 | 6,
-    8: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
-    9: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8,
-  }
+	export type GreaterThanMap = { [k in number]: number } & {
+		0: never
+		1: 0
+		2: 0 | 1
+		3: 0 | 1 | 2
+		4: 0 | 1 | 2 | 3
+		5: 0 | 1 | 2 | 3 | 4
+		6: 0 | 1 | 2 | 3 | 4 | 5
+		7: 0 | 1 | 2 | 3 | 4 | 5 | 6
+		8: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
+		9: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
+	}
 }
 
 export namespace DigitArray {
-  export type ToNumber<C extends number[]> = ToTuple<[], C>['length']
+	export type ToNumber<C extends number[]> = ToTuple<[], C>['length']
 
-  export type ToTuple<R extends any[], S extends number[], X = any> =
-    S['length'] extends 0
-    ? R
-    : (S['length'] extends 1
-      ? [...R, ...Digit.ToTuple<X>[S[0]]]
-      : (S extends [any, ...infer T]
-        ? (T extends any[]
-          ? ToTuple<Multi10<[...R, ...Digit.ToTuple<X>[S[0]]]>, T>
-          : never)
-        : never))
+	export type ToTuple<R extends any[], S extends number[], X = any> = S['length'] extends 0
+		? R
+		: S['length'] extends 1
+		? [...R, ...Digit.ToTuple<X>[S[0]]]
+		: S extends [any, ...infer T]
+		? T extends any[]
+			? ToTuple<Multi10<[...R, ...Digit.ToTuple<X>[S[0]]]>, T>
+			: never
+		: never
 
-  export type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C]
+	export type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C]
 
+	export type FromNumber<N extends number> = FromString<NumberToString<N>>
+	export type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>
+	export type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N
 
-  export type FromNumber<N extends number> = FromString<NumberToString<N>>
-  export type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>
-  export type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N
+	export type NumberToString<N extends number> = And<IsPositive<N>, IsWhole<N>> extends true ? `${N}` : never
 
-  export type NumberToString<N extends number> = (And<IsPositive<N>, IsWhole<N>>) extends true ? `${N}` : never
+	export type FromString<S extends string> = S extends `1${infer L}`
+		? [1, ...FromString<L>]
+		: S extends `2${infer L}`
+		? [2, ...FromString<L>]
+		: S extends `3${infer L}`
+		? [3, ...FromString<L>]
+		: S extends `4${infer L}`
+		? [4, ...FromString<L>]
+		: S extends `5${infer L}`
+		? [5, ...FromString<L>]
+		: S extends `6${infer L}`
+		? [6, ...FromString<L>]
+		: S extends `7${infer L}`
+		? [7, ...FromString<L>]
+		: S extends `8${infer L}`
+		? [8, ...FromString<L>]
+		: S extends `9${infer L}`
+		? [9, ...FromString<L>]
+		: S extends `0${infer L}`
+		? [0, ...FromString<L>]
+		: []
 
-  export type FromString<S extends string> = S extends `1${infer L}` ? [1, ...FromString<L>]
-    : S extends `2${infer L}` ? [2, ...FromString<L>]
-    : S extends `3${infer L}` ? [3, ...FromString<L>]
-    : S extends `4${infer L}` ? [4, ...FromString<L>]
-    : S extends `5${infer L}` ? [5, ...FromString<L>]
-    : S extends `6${infer L}` ? [6, ...FromString<L>]
-    : S extends `7${infer L}` ? [7, ...FromString<L>]
-    : S extends `8${infer L}` ? [8, ...FromString<L>]
-    : S extends `9${infer L}` ? [9, ...FromString<L>]
-    : S extends `0${infer L}` ? [0, ...FromString<L>]
-    : []
+	export type Shift10<DA extends number[]> = TrimLeadingZero<Shift10State<[], DA>>
+	export type Shift10State<R extends number[], DA extends number[]> = DA['length'] extends 0
+		? R
+		: DA['length'] extends 1
+		? [...R, ...DA]
+		: DA extends [any, ...infer T]
+		? T extends number[]
+			? DA[0] extends 0
+				? Shift10State<[...R, DA[0]], T>
+				: T extends [any, ...infer Y]
+				? Y extends number[]
+					? Shift10State<[...R, MinusOne[DA[0]]], [Plus10[T[0]], ...Y]>
+					: []
+				: []
+			: []
+		: []
 
-  export type Shift10<DA extends number[]> = TrimLeadingZero<Shift10State<[], DA>>
-  export type Shift10State<R extends number[], DA extends number[]> =
-    DA['length'] extends 0
-    ? R
-    : (DA['length'] extends 1
-      ? [...R, ...DA]
-      : (DA extends [any, ...infer T]
-        ? (T extends number[]
-          ? (DA[0] extends 0
-            ? Shift10State<[...R, DA[0]], T>
-            : (T extends [any, ...infer Y]
-              ? (Y extends number[]
-                ? Shift10State<[...R, MinusOne[DA[0]]], [Plus10[T[0]], ...Y]>
-                : [])
-              : []))
-          : [])
-        : [])
-    )
+	export type TrimLeadingZero<A extends number[]> = A['length'] extends 0
+		? A
+		: A[0] extends 0
+		? TrimLeadingZero<Tail<A>>
+		: A
 
-  export type TrimLeadingZero<A extends number[]> =
-    A['length'] extends 0
-    ? A
-    : A[0] extends 0 ? TrimLeadingZero<Tail<A>> : A
+	export type MinusOne = { [k in number]: number } & {
+		0: 0
+		1: 0
+		2: 1
+		3: 2
+		4: 3
+		5: 4
+		6: 5
+		7: 6
+		8: 7
+		9: 8
+		10: 9
+		11: 10
+		12: 11
+		13: 12
+		14: 13
+		15: 14
+		16: 15
+		17: 16
+		18: 17
+		19: 18
+	}
 
-  export type MinusOne = { [k in number]: number } & {
-    0: 0, 1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8,
-    10: 9, 11: 10, 12: 11, 13: 12, 14: 13, 15: 14, 16: 15, 17: 16, 18: 17, 19: 18
-  }
-
-  export type Plus10 = { [k in number]: number } &
-  { 0: 10, 1: 11, 2: 12, 3: 13, 4: 14, 5: 15, 6: 16, 7: 17, 8: 18, 9: 19 }
+	export type Plus10 = { [k in number]: number } & {
+		0: 10
+		1: 11
+		2: 12
+		3: 13
+		4: 14
+		5: 15
+		6: 16
+		7: 17
+		8: 18
+		9: 19
+	}
 }

package/ts/math/GreaterThan.ts

@@ -1,37 +1,54 @@
-import type { Head, PadLeft, Tail } from '../array/index.js'
+import type { Head, PadLeft, Tail } from '../array_plus/index.js'
 import type { And, Equal, Or, Xor } from '../predicates/index.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { IsPositive } from './IsPositive.js'
 import type { IsWhole } from './IsWhole.js'
 import type { Max } from './Max.js'
 
-export type GreaterThan<A extends number, B extends number, Fail = never> =
-  And<IsWhole<A>, IsWhole<B>> extends false ? Fail :
-  number extends A ? Fail :
-  number extends B ? Fail :
-  Equal<A, B> extends true ? false :
-  Xor<IsPositive<A>, IsPositive<B>> extends true ? IsPositive<A> :
-  Or<IsPositive<A>, IsPositive<B>> extends false ? GreaterThan.ForWholeNumber<B, A> :
-  GreaterThan.ForWholeNumber<A, B>
+export type GreaterThan<A extends number, B extends number, Fail = never> = And<
+	IsWhole<A>,
+	IsWhole<B>
+> extends false
+	? Fail
+	: number extends A
+	? Fail
+	: number extends B
+	? Fail
+	: Equal<A, B> extends true
+	? false
+	: Xor<IsPositive<A>, IsPositive<B>> extends true
+	? IsPositive<A>
+	: Or<IsPositive<A>, IsPositive<B>> extends false
+	? GreaterThan.ForWholeNumber<B, A>
+	: GreaterThan.ForWholeNumber<A, B>
 
 export namespace GreaterThan {
-  export type ForWholeNumber<A extends number, B extends number> = (
-    DigitArray.FromNumberAbs<A> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumberAbs<B> extends infer DB ? DB extends number[] ?
-    Max<DA['length'], DB['length']> extends infer M ? M extends number ?
-    PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
-    PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    ForDigitArray<PDA, PDB>
-    : never : never
-    : never : never
-    : never : never
-    : never : never
-    : never : never
-  )
+	export type ForWholeNumber<
+		A extends number,
+		B extends number
+	> = DigitArray.FromNumberAbs<A> extends infer DA
+		? DA extends number[]
+			? DigitArray.FromNumberAbs<B> extends infer DB
+				? DB extends number[]
+					? Max<DA['length'], DB['length']> extends infer M
+						? M extends number
+							? PadLeft<DA, M, 0> extends infer PDA
+								? PDA extends number[]
+									? PadLeft<DB, M, 0> extends infer PDB
+										? PDB extends number[]
+											? ForDigitArray<PDA, PDB>
+											: never
+										: never
+									: never
+								: never
+							: never
+						: never
+					: never
+				: never
+			: never
+		: never
 
-  export type ForDigitArray<DA extends number[], DB extends number[]> = (
-    Equal<Head<DA>, Head<DB>> extends true
-    ? ForDigitArray<Tail<DA>, Tail<DB>>
-    : Digit.GreaterThan<Head<DA>, Head<DB>>
-  )
+	export type ForDigitArray<DA extends number[], DB extends number[]> = Equal<Head<DA>, Head<DB>> extends true
+		? ForDigitArray<Tail<DA>, Tail<DB>>
+		: Digit.GreaterThan<Head<DA>, Head<DB>>
 }

package/ts/math/IsPositive.ts

@@ -1,9 +1,10 @@
-/**
- * Check if type of positive number literal
- * `number` type is false as it can be negative.
- * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
- */
-export type IsPositive<N extends number, Then = true, Else = false> =
-  number extends N
-  ? Else
-  : `${N}` extends `-${number}` ? Else : Then
+/**
+ * Check if type of positive number literal
+ * `number` type is false as it can be negative.
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ */
+export type IsPositive<N extends number, Then = true, Else = false> = number extends N
+	? Else
+	: `${N}` extends `-${number}`
+	? Else
+	: Then

package/ts/math/IsWhole.ts

@@ -1,9 +1,10 @@
-/**
- * Check if type is whole number literal.
- * `number` type is false as it can be fractional.
- * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
- */
-export type IsWhole<N extends number, Then = true, Else = false> =
-  number extends N
-  ? Else
-  : `${N}` extends `${number}.${number}` ? Else : Then
+/**
+ * Check if type is whole number literal.
+ * `number` type is false as it can be fractional.
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ */
+export type IsWhole<N extends number, Then = true, Else = false> = number extends N
+	? Else
+	: `${N}` extends `${number}.${number}`
+	? Else
+	: Then

package/ts/math/Max.ts

@@ -1,8 +1,10 @@
 import type { Equal } from '../predicates/index.js'
 import { GreaterThan } from './GreaterThan.js'
 
-export type Max<A extends number, B extends number, Fail = never> =
-  GreaterThan<A, B> extends infer Result ?
-  Equal<Result, never> extends true ? Fail :
-  Result extends true ? A : B
-  : never
+export type Max<A extends number, B extends number, Fail = never> = GreaterThan<A, B> extends infer Result
+	? Equal<Result, never> extends true
+		? Fail
+		: Result extends true
+		? A
+		: B
+	: never

package/ts/math/Subtract.ts

@@ -1,4 +1,4 @@
-import type { PadLeft, Some, Tail } from '../array/index.js'
+import type { PadLeft, Some, Tail } from '../array_plus/index.js'
 import type { And } from '../predicates/index.js'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { Digit, DigitArray } from './Digit.js'
@@ -6,35 +6,50 @@ import type { IsPositive } from './IsPositive.js'
 import type { IsWhole } from './IsWhole.js'
 import type { Max } from './Max.js'
 
-export type Subtract<A extends number, B extends number, Fail = never> =
-  And<
-    And<IsPositive<A>, IsWhole<A>>,
-    And<IsPositive<B>, IsWhole<B>>
-  > extends true
-  ? (DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-    Max<DA['length'], DB['length']> extends infer M ? M extends number ?
-    PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
-    PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    Subtract.DigitArray<[], PDA, PDB> extends infer Result ? Result extends number[] ?
-    Some<Result, never, 'strict'> extends true ? Fail :
-    DigitArray.ToNumber<Result>
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail)
-  : Fail
+export type Subtract<A extends number, B extends number, Fail = never> = And<
+	And<IsPositive<A>, IsWhole<A>>,
+	And<IsPositive<B>, IsWhole<B>>
+> extends true
+	? DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA
+		? DA extends number[]
+			? DigitArray.FromNumber<B> extends infer DB
+				? DB extends number[]
+					? Max<DA['length'], DB['length']> extends infer M
+						? M extends number
+							? PadLeft<DA, M, 0> extends infer PDA
+								? PDA extends number[]
+									? PadLeft<DB, M, 0> extends infer PDB
+										? PDB extends number[]
+											? Subtract.DigitArray<[], PDA, PDB> extends infer Result
+												? Result extends number[]
+													? Some<Result, never, 'strict'> extends true
+														? Fail
+														: DigitArray.ToNumber<Result>
+													: Fail
+												: Fail
+											: Fail
+										: Fail
+									: Fail
+								: Fail
+							: Fail
+						: Fail
+					: Fail
+				: Fail
+			: Fail
+		: Fail
+	: Fail
 
 export namespace Subtract {
-  export type DigitArray<R extends number[], A extends number[], B extends number[]> =
-    A['length'] extends 0 ? R :
-    DigitArray<[...R, Digit<A[0], B[0]>], Tail<A>, Tail<B>>
+	export type DigitArray<R extends number[], A extends number[], B extends number[]> = A['length'] extends 0
+		? R
+		: DigitArray<[...R, Digit<A[0], B[0]>], Tail<A>, Tail<B>>
 
-
-  export type Digit<A extends number, B extends number> =
-    Digit.ToTuple[A] extends [...(infer U), ...Digit.ToTuple[B]] ? U['length'] : never
+	export type Digit<A extends number, B extends number> = Digit.ToTuple[A] extends [
+		...infer U,
+		...Digit.ToTuple[B]
+	]
+		? U['length']
+		: never
 }
 
 /**

package/ts/nodejs/isNodeError.ts

@@ -1,18 +1,18 @@
 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,
-  'ETIMEDOUT': 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
 }
 
 export type SystemErrorCodes = keyof SystemErrors
@@ -23,5 +23,5 @@ export type SystemErrorCodes = keyof SystemErrors
  * Feel free to contribute.
  */
 export function isSystemError<C extends SystemErrorCodes>(code: C, err: unknown): err is SystemErrors[C] {
-  return !!err && (err as any).code === code
+	return !!err && (err as any).code === code
 }

package/ts/nominal-types/Brand.ts

@@ -8,10 +8,9 @@ import { typeSym, valueSym } from './types.js'
  * Create a "branded" version of a type.
  * TypeScript won't allow implicit conversion to this type
  */
-export type Brand<B extends string, T> =
-  T extends object
-  ? T & { [typeSym]: B }
-  : { [typeSym]: B, [valueSym]: T }
+export type Brand<B extends string, T> = T extends object
+	? T & { [typeSym]: B }
+	: { [typeSym]: B; [valueSym]: T }
 
 /**
  * Creates a brand creator with the specified type.
@@ -22,11 +21,14 @@ export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Wi
  */
 export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
 export function brand(type: string, subject?: unknown) {
-  if (subject === undefined) return function <T>(subject: T) { return brand(type, subject) }
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return brand(type, subject)
+		}
 
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as { [typeSym]: string })[typeSym] = type
-  }
-  return subject
+	if (typeof subject === 'object' && subject !== null) {
+		// if subject is not an object, the branding will exist only in type-level.
+		;(subject as { [typeSym]: string })[typeSym] = type
+	}
+	return subject
 }

package/ts/nominal-types/Flavor.ts

@@ -11,7 +11,7 @@ import { typeSym } from './types.js'
  * This is a less restrictive form of branding.
  */
 export type Flavor<F extends string, T> = T & {
-  [typeSym]?: F
+	[typeSym]?: F
 }
 
 /**
@@ -23,10 +23,13 @@ export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F,
  */
 export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
 export function flavor(type: string, subject?: unknown) {
-  if (subject === undefined) return function <T>(subject: T) { return flavor(type, subject) }
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as { [typeSym]: string })[typeSym] = type
-  }
-  return subject
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return flavor(type, subject)
+		}
+	if (typeof subject === 'object' && subject !== null) {
+		// if subject is not an object, the branding will exist only in type-level.
+		;(subject as { [typeSym]: string })[typeSym] = type
+	}
+	return subject
 }

package/ts/nominal-types/nominalMatch.ts

@@ -2,12 +2,21 @@ import type { Brand } from './Brand.js'
 import type { Flavor } from './Flavor.js'
 import { typeSym } from './types.js'
 
-export function nominalMatch<A extends string, B extends A>(a: Brand<A, unknown>, b: Brand<B, unknown>): boolean
-export function nominalMatch<A extends string, B extends A>(a: Flavor<A, unknown>, b: Flavor<B, unknown>): boolean
-export function nominalMatch<A extends string, B extends A>(a: Brand<A, unknown> | Flavor<A, unknown>, b: Brand<B, unknown> | Flavor<B, unknown>) {
-  if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
-    return a[typeSym] === b[typeSym]
-  else {
-    return true
-  }
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown>,
+	b: Brand<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Flavor<A, unknown>,
+	b: Flavor<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown> | Flavor<A, unknown>,
+	b: Brand<B, unknown> | Flavor<B, unknown>
+) {
+	if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
+		return a[typeSym] === b[typeSym]
+	else {
+		return true
+	}
 }

package/ts/number_plus/_plus.ts

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

package/ts/number_plus/index.ts

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