type-plus 4.9.0 → 4.10.1

package/ts/array/CommonPropKeys.ts

@@ -1,18 +1,18 @@
-import { Tail } from './Tail'
-
-/**
- * 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`.
- * This will be deprecated in 4.0. Please use CommonPropKeys instead.
- */
-export type CommonKeys<A extends Record<string, any>[]> = CommonPropKeys<A>
+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`.
+ * This will be deprecated in 4.0. Please use CommonPropKeys instead.
+ */
+export type CommonKeys<A extends Record<string, any>[]> = CommonPropKeys<A>

package/ts/array/CreateTuple.ts

@@ -1,4 +1,4 @@
-import { DigitArray, IsPositive, IsWhole } from '../math'
+import type { DigitArray, IsPositive, IsWhole } from '../math/index.js'
 
 /**
  * Creates `Tuple<T>` with `L` number of elements.

package/ts/array/IntersectOfProps.ts

@@ -1,20 +1,20 @@
-import { KeyTypes } from '../object'
-import { Tail } from './Tail'
-
-/**
- * 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>
+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/PadLeft.ts

@@ -1,6 +1,6 @@
-import { Equal, IsAny } from '../predicates'
-import { CreateTuple } from './CreateTuple'
-import { UnionOfValues } from './UnionOfValues'
+import { Equal, IsAny } from '../predicates/index.js'
+import { CreateTuple } from './CreateTuple.js'
+import { UnionOfValues } from './UnionOfValues.js'
 
 export type PadLeft<A extends any[], Total extends number, PadWith = any> =
   number extends A['length']

package/ts/array/Some.ts

@@ -1,6 +1,6 @@
-import type { Equal } from '../predicates'
-import type { Tail } from './Tail'
-import type { UnionOfValues } from './UnionOfValues'
+import type { Equal } from '../predicates/index.js'
+import type { Tail } from './Tail.js'
+import type { UnionOfValues } from './UnionOfValues.js'
 
 export type Some<
   A extends any[],

package/ts/array/Tail.ts

@@ -1,4 +1,4 @@
-import { UnionOfValues } from './UnionOfValues'
+import { UnionOfValues } from './UnionOfValues.js'
 
 /**
  * Gets the types of a tuple except the first entry.

package/ts/array/UnionOfProps.ts

@@ -1,18 +1,18 @@
-import { KeyTypes } from '../object'
-import { Tail } from './Tail'
-
-/**
- * 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>
+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/array/drop.ts

@@ -1,5 +1,5 @@
-import { Equal } from '../predicates'
-import { NonNull, NonUndefined } from '../utils'
+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
@@ -68,5 +68,5 @@ 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 any
+  return array.filter(v => v !== value) as DropMatch<A, C>
 }

package/ts/array/index.ts

@@ -1,20 +1,20 @@
-export type { CommonKeys, CommonPropKeys } from './CommonPropKeys'
-export type { Concat } from './Concat'
-export type { CreateTuple } from './CreateTuple'
-export * from './drop'
-export type { Filter, KeepMatch } from './Filter'
-export type { FindFirst, First } from './FindFirst'
-export type { FindLast } from './FindLast'
-export type { Head } from './Head'
-export type { IntersectOfProps, MapToProp } from './IntersectOfProps'
-export type { IsArray } from './IsArray'
-export type { Last } from './Last'
-export * from './literalArray'
-export type { PadLeft } from './PadLeft'
-export * from './reduceWhile'
-export type { Reverse } from './Reverse'
-export type { Some } from './Some'
-export type { Tail } from './Tail'
-export type { PropUnion, UnionOfProps } from './UnionOfProps'
-export type { ArrayValue, UnionOfValues } from './UnionOfValues'
+export type { CommonKeys, CommonPropKeys } from './CommonPropKeys.js'
+export type { Concat } from './Concat.js'
+export type { CreateTuple } from './CreateTuple.js'
+export * from './drop.js'
+export type { Filter, KeepMatch } from './Filter.js'
+export type { FindFirst, First } from './FindFirst.js'
+export type { FindLast } from './FindLast.js'
+export type { Head } from './Head.js'
+export type { IntersectOfProps, MapToProp } from './IntersectOfProps.js'
+export type { IsArray } from './IsArray.js'
+export type { Last } from './Last.js'
+export * from './literalArray.js'
+export type { PadLeft } from './PadLeft.js'
+export * from './reduceWhile.js'
+export type { Reverse } from './Reverse.js'
+export type { Some } from './Some.js'
+export type { Tail } from './Tail.js'
+export type { PropUnion, UnionOfProps } from './UnionOfProps.js'
+export type { ArrayValue, UnionOfValues } from './UnionOfValues.js'
 

package/ts/array/literalArray.ts

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

package/ts/assertion/assertType.ts

@@ -1,105 +1,105 @@
-import { tersify } from 'tersify'
-import { AnyConstructor, isConstructor } from '../class'
-import { AnyFunction } from '../function'
-
-/**
- * assert the subject satisfies the specified type T
- * @type T the type to check against.
- */
-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(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
-}
-
-assertType.isUndefined = function (subject: undefined): asserts subject is 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`)
-}
-
-assertType.isNull = function (subject: null): asserts subject is 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`)
-}
-
-assertType.isNumber = function (subject: number): asserts subject is 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`)
-}
-
-assertType.isBoolean = function (subject: boolean): asserts subject is 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`)
-}
-
-assertType.isTrue = function (subject: true): asserts subject is 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`)
-}
-
-assertType.isFalse = function (subject: false): asserts subject is 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`)
-}
-
-assertType.isString = function (subject: string): asserts subject is 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`)
-}
-
-assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
-  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`)
-}
-
-assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
-  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`)
-}
-assertType.noError = function <S>(subject: Exclude<S, Error>): void {
-  if (subject instanceof Error) throw TypeError(`subject is an Error`)
-}
-
-assertType.isNever = function (subject: never): asserts subject is never {
-}
-
-/**
- * creates a custom assertion function with standard TypeError.
- * Currently this requires explicity type annotation,
- * 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
-  }
-}
+import { tersify } from 'tersify'
+import { AnyConstructor, isConstructor } from '../class/index.js'
+import type { AnyFunction } from '../function/index.js'
+
+/**
+ * assert the subject satisfies the specified type T
+ * @type T the type to check against.
+ */
+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(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
+}
+
+assertType.isUndefined = function (subject: undefined): asserts subject is 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`)
+}
+
+assertType.isNull = function (subject: null): asserts subject is 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`)
+}
+
+assertType.isNumber = function (subject: number): asserts subject is 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`)
+}
+
+assertType.isBoolean = function (subject: boolean): asserts subject is 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`)
+}
+
+assertType.isTrue = function (subject: true): asserts subject is 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`)
+}
+
+assertType.isFalse = function (subject: false): asserts subject is 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`)
+}
+
+assertType.isString = function (subject: string): asserts subject is 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`)
+}
+
+assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
+  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`)
+}
+
+assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
+  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`)
+}
+assertType.noError = function <S>(subject: Exclude<S, Error>): void {
+  if (subject instanceof Error) throw TypeError(`subject is an Error`)
+}
+
+assertType.isNever = function (subject: never): asserts subject is never {
+}
+
+/**
+ * creates a custom assertion function with standard TypeError.
+ * Currently this requires explicity type annotation,
+ * 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
+  }
+}

package/ts/assertion/index.ts

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

package/ts/binary/_binary.ts

@@ -1 +1 @@
-export type { Bit, BitAnd, BitNot, BitOr, BitXor } from './Bit'
+export type { Bit, BitAnd, BitNot, BitOr, BitXor } from './Bit.js'

package/ts/binary/index.ts

@@ -1,2 +1,2 @@
-export * as B from './_binary'
-export * as Bit from './_binary'
+export * as B from './_binary.js'
+export * as Bit from './_binary.js'

package/ts/class/index.ts

@@ -1,2 +1,2 @@
-export type { AnyConstructor } from './AnyConstructor'
-export * from './isConstructor'
+export type { AnyConstructor } from './AnyConstructor.js'
+export * from './isConstructor.js'

package/ts/class/isConstructor.ts

@@ -1,4 +1,4 @@
-import { AnyConstructor } from './AnyConstructor'
+import type { AnyConstructor } from './AnyConstructor.js'
 
 export function isConstructor(subject: unknown): subject is AnyConstructor {
   try {

package/ts/function/index.ts

@@ -1 +1 @@
-export type { AnyFunction } from './AnyFunction'
+export type { AnyFunction } from './AnyFunction.js'

package/ts/functional/Maybe.ts

@@ -1,19 +1,19 @@
-import { Brand } from '../nominal-types'
-import { Equal } from '../predicates'
-import { Widen } from '../utils'
-
-export type Maybe<T> = Just<T> | None<T>
-export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
-export type None<T> = Brand<'maybe', void> & { unwrap(): T }
-
-export function just<T>(value: T):
-  Equal<T, undefined | null> extends true ?
-  None<T> :
-  Just<Widen<NonNullable<T>>> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return { unwrap() { return value } } as any
-}
-
-export function none<T>(): None<T> {
-  return { unwrap() { } } as None<T>
-}
+import type { Brand } from '../nominal-types/index.js'
+import type { Equal } from '../predicates/index.js'
+import type { Widen } from '../utils/index.js'
+
+export type Maybe<T> = Just<T> | None<T>
+export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
+export type None<T> = Brand<'maybe', void> & { unwrap(): T }
+
+export function just<T>(value: T):
+  Equal<T, undefined | null> extends true ?
+  None<T> :
+  Just<Widen<NonNullable<T>>> {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return { unwrap() { return value } } as any
+}
+
+export function none<T>(): None<T> {
+  return { unwrap() { } } as None<T>
+}

package/ts/functional/compose.ts

@@ -1,9 +1,10 @@
-import { Head, Last } from '../array'
-import { AnyFunction } from '../function/AnyFunction'
+import type { Head, Last } from '../array/index.js'
+import type { AnyFunction } from '../function/AnyFunction.js'
 
 /**
  * compose functions
  */
 export function compose<FS extends AnyFunction[]>(...fns: FS): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
-  return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0] as any
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
 }

package/ts/functional/index.ts

@@ -1,3 +1,3 @@
-// export * from './Maybe'
-export type { ChainFn, EndoFn } from './ChainFn'
-export * from './compose'
+// export * from './Maybe.js'
+export type { ChainFn, EndoFn } from './ChainFn.js'
+export * from './compose.js'

package/ts/index.ts

@@ -1,22 +1,22 @@
-// import * as types from './types'
+// import * as types from './types/index.js'
 export { required, requiredDeep } from 'unpartial'
-export * from './array'
-export * from './assertion'
-export * from './class'
-export type { ComposableTypes, NonComposableTypes } from './ComposableTypes'
-export * from './function'
-export * from './functional'
-export * from './JSONTypes'
-export * from './math'
-export * from './nodejs'
-export * from './nominal-types'
-export * from './object'
-export * from './predicates'
-export type { PrimitiveTypes } from './PrimitiveTypes'
-export * from './promise'
-export * from './testing'
-// export * from './types/optional'
-// export * from './types/required'
-export type { UnionKeys } from './UnionKeys'
-export * from './utils'
+export * from './array/index.js'
+export * from './assertion/index.js'
+export * from './class/index.js'
+export type { ComposableTypes, NonComposableTypes } from './ComposableTypes.js'
+export * from './function/index.js'
+export * from './functional/index.js'
+export * from './JSONTypes.js'
+export * from './math/index.js'
+export * from './nodejs/index.js'
+export * from './nominal-types/index.js'
+export * from './object/index.js'
+export * from './predicates/index.js'
+export type { PrimitiveTypes } from './PrimitiveTypes.js'
+export * from './promise/index.js'
+export * from './testing/index.js'
+// export * from './types/optional.js'
+// export * from './types/required.js'
+export type { UnionKeys } from './UnionKeys.js'
+export * from './utils/index.js'
 // export { types, types as T }

package/ts/math/Abs.ts

@@ -1,4 +1,4 @@
-import type { DigitArray } from './Digit'
+import type { DigitArray } from './Digit.js'
 
 export type Abs<N extends number, Fail = never> = number extends N ? Fail :
   `${N}` extends `-${infer P}` ? DigitArray.ToNumber<DigitArray.FromString<P>> : N

package/ts/math/Add.ts

@@ -1,10 +1,10 @@
-import type { PadLeft } from '../array'
-import type { And } from '../predicates'
+import type { PadLeft } from '../array/index.js'
+import type { And } from '../predicates/index.js'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
-import type { Max } from './Max'
+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'
 
 /**
  * Add two number literals.

package/ts/math/Digit.ts

@@ -1,7 +1,7 @@
-import { Tail } from '../array'
-import { And } from '../predicates'
-import { IsPositive } from './IsPositive'
-import { IsWhole } from './IsWhole'
+import type { Tail } from '../array/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> = {

package/ts/math/GreaterThan.ts

@@ -1,9 +1,9 @@
-import type { Head, PadLeft, Tail } from '../array'
-import type { And, Equal, Or, Xor } from '../predicates'
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
-import type { Max } from './Max'
+import type { Head, PadLeft, Tail } from '../array/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 :

package/ts/math/Max.ts

@@ -1,5 +1,5 @@
-import type { Equal } from '../predicates'
-import { GreaterThan } from './GreaterThan'
+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 ?