Apply linter fixes

src/digit-list/compare.ts

@@ -78,16 +78,16 @@ type _$compare3<
   RESULT extends 1 | 0 | -1 = IS_SAME_LENGTH extends false
     ? _$compare3<A_LENGTH, B_LENGTH>
     : A extends []
-    ? B extends []
-      ? 0
-      : -1
-    : B extends []
-    ? 1
-    : BOTH_SINGLE_DIGIT extends true
-    ? COMP
-    : COMP extends 0
-    ? _$compare3<A_NEXT, B_NEXT>
-    : COMP
+      ? B extends []
+        ? 0
+        : -1
+      : B extends []
+        ? 1
+        : BOTH_SINGLE_DIGIT extends true
+          ? COMP
+          : COMP extends 0
+            ? _$compare3<A_NEXT, B_NEXT>
+            : COMP
 > = RESULT
 
 type _$compare2<

src/digit-list/decrement.ts

@@ -78,8 +78,8 @@ type _$decrement2<
 > = A extends '0'[]
   ? FINAL_RESULT
   : CARRY extends '0'
-  ? SHORT_CIRCUIT
-  : _$decrement2<NEXT_A, NEXT_CARRY, NEXT_OUTPUT>
+    ? SHORT_CIRCUIT
+    : _$decrement2<NEXT_A, NEXT_CARRY, NEXT_OUTPUT>
 
 /**
  * `_$decrement` is a type-level function that takes in a digit list `A` and

src/digit-list/divide-by-subtraction.ts

@@ -116,10 +116,10 @@ export type _$divideBySubtraction<
 > = B extends [Digit.Zero]
   ? [Digit.Zero]
   : B extends ['1']
-  ? OPERATION extends 'DIVIDE'
-    ? A
-    : [Digit.Zero]
-  : _$divideBySubtraction2<A, B, OPERATION>
+    ? OPERATION extends 'DIVIDE'
+      ? A
+      : [Digit.Zero]
+    : _$divideBySubtraction2<A, B, OPERATION>
 
 interface DivideBySubtraction_T<A extends DigitList.DigitList>
   extends Kind.Kind {

src/digit-list/divide.ts

@@ -121,10 +121,10 @@ export type _$divide<
 > = B extends [Digit.Zero]
   ? [Digit.Zero]
   : B extends ['1']
-  ? OPERATION extends 'DIVIDE'
-    ? A
-    : [Digit.Zero]
-  : _$divide2<A, B, OPERATION>
+    ? OPERATION extends 'DIVIDE'
+      ? A
+      : [Digit.Zero]
+    : _$divide2<A, B, OPERATION>
 
 interface Divide_T<A extends DigitList.DigitList> extends Kind.Kind {
   f(x: Type._$cast<this[Kind._], DigitList.DigitList>): _$divide<A, typeof x>

src/digit-list/first.ts

@@ -16,8 +16,8 @@ import { Digit, DigitList, Kind, Type } from '../'
 export type _$first<T extends DigitList.DigitList> = T extends []
   ? Digit.Zero
   : T extends [infer X, ...unknown[]]
-  ? X
-  : Digit.Zero
+    ? X
+    : Digit.Zero
 
 /**
  * `First` is a type-level function that returns the first digit of a digit list.

src/digit-list/increment.ts

@@ -56,8 +56,8 @@ export type _$increment<
 > = A extends []
   ? FINAL_RESULT
   : CARRY extends '0'
-  ? SHORT_CIRCUIT
-  : _$increment<NEXT_A, NEXT_CARRY, NEXT_OUTPUT>
+    ? SHORT_CIRCUIT
+    : _$increment<NEXT_A, NEXT_CARRY, NEXT_OUTPUT>
 
 /**
  * `Increment` is a type-level function that increments a digit list.

src/digit-list/last.ts

@@ -16,8 +16,8 @@ import { Type, Kind, Digit, DigitList } from '..'
 export type _$last<T extends DigitList.DigitList> = T extends []
   ? Digit.Zero
   : T extends [...unknown[], infer X]
-  ? X
-  : Digit.Zero
+    ? X
+    : Digit.Zero
 
 /**
  * `Last` is a type-level function that gets the last digit of a digit list.

src/digit-list/pop.ts

@@ -24,8 +24,8 @@ import { Type, Kind, DigitList } from '..'
 export type _$pop<T extends DigitList.DigitList> = T extends []
   ? []
   : T extends [...infer X, unknown]
-  ? X
-  : []
+    ? X
+    : []
 
 /**
  * `Pop` is a type-level function that removes the last digit from a digit list.

src/digit-list/shift.ts

@@ -21,8 +21,8 @@ import { Type, Kind, DigitList } from '..'
 export type _$shift<T extends DigitList.DigitList> = T extends []
   ? []
   : T extends [unknown, ...infer X]
-  ? X
-  : []
+    ? X
+    : []
 
 /**
  * `Shift` is a type-level function that removes the first digit from a digit list.

src/list/accumulate.ts

@@ -32,8 +32,8 @@ export type _$accumulate<
   RESULT extends Kind._$inputOf<F>[] = X extends []
     ? M
     : ACC extends Kind._$inputOf<F>
-    ? _$accumulate<F, REST, ACC, List._$push<ACC, M>>
-    : never
+      ? _$accumulate<F, REST, ACC, List._$push<ACC, M>>
+      : never
 > = 0 extends 1 ? never : RESULT
 
 interface Accumulate_T2<

src/list/at.ts

@@ -40,8 +40,8 @@ export type _$at<
       ? POS_ABS
       : never
     : DigitList._$compare<T_LENGTH, POS_ABS> extends -1
-    ? never
-    : DigitList._$subtract<T_LENGTH, POS_ABS>,
+      ? never
+      : DigitList._$subtract<T_LENGTH, POS_ABS>,
   INDEX extends number = DigitList._$toNumber<POS_NORM>
 > = POS_NORM extends never ? never : T[INDEX]
 

src/list/iterate.ts

@@ -23,15 +23,15 @@ export type _$iterate<
   RESULT extends Kind._$inputOf<F>[] = COUNT extends 0
     ? M
     : ACC extends Kind._$inputOf<F>
-    ? _$iterate<
-        F,
-        O,
-        N,
-        NaturalNumber._$decrement<COUNT>,
-        List._$push<ACC, M>,
-        ACC
-      >
-    : never
+      ? _$iterate<
+          F,
+          O,
+          N,
+          NaturalNumber._$decrement<COUNT>,
+          List._$push<ACC, M>,
+          ACC
+        >
+      : never
 > = 0 extends 1 ? never : RESULT
 
 interface Iterate_T2<F extends Kind.Kind, N extends Number.Number>

src/list/last.ts

@@ -17,10 +17,10 @@ import { Type, Kind } from '..'
 export type _$last<T extends readonly unknown[]> = T extends [infer X]
   ? X
   : T extends [unknown, ...infer Tail]
-  ? _$last<Tail>
-  : T extends [...unknown[], infer X]
-  ? X
-  : T[number]
+    ? _$last<Tail>
+    : T extends [...unknown[], infer X]
+      ? X
+      : T[number]
 
 /**
  * `Last` is a type-level function that returns the last element of a tuple.

src/list/pair.ts

@@ -19,8 +19,8 @@ export type _$pair<
 > = T extends [infer X1, infer X2, ...infer Rest]
   ? _$pair<[X2, ...Rest], [...O, [X1, X2]]>
   : number extends T['length']
-  ? [T[number], T[number]][]
-  : O
+    ? [T[number], T[number]][]
+    : O
 
 /**
  * `Pair` is a type-level function that generates a tuple of pairs from a tuple,

src/list/range.ts

@@ -23,18 +23,18 @@ type _$range2<
       ? true
       : false
     : NaturalNumber._$compare<START, STOP> extends -1 | 0
-    ? true
-    : false,
+      ? true
+      : false,
   RESULT extends Number.Number[] = START extends Kind._$inputOf<F>
     ? List._$iterate<F, START, COUNT>
     : never
 > = 0 extends 1
   ? never
   : VALIDATE extends true
-  ? COUNT extends 0
-    ? []
-    : RESULT
-  : never
+    ? COUNT extends 0
+      ? []
+      : RESULT
+    : never
 
 /**
  * `_$range` is a type-level function that generates a range of numbers.

src/list/reduce.ts

@@ -28,20 +28,22 @@ export type _$reduce<
 > = 0 extends 1
   ? never
   : X extends [infer H, ...infer T]
-  ? $<
-      $<F, Type._$cast<O, Kind._$inputOf<F>>>,
-      Type._$cast<
-        H,
-        Kind._$inputOf<
-          Function._$returnType<
-            (F & { readonly [Kind._]: Type._$cast<O, Kind._$inputOf<F>> })['f']
+    ? $<
+        $<F, Type._$cast<O, Kind._$inputOf<F>>>,
+        Type._$cast<
+          H,
+          Kind._$inputOf<
+            Function._$returnType<
+              (F & {
+                readonly [Kind._]: Type._$cast<O, Kind._$inputOf<F>>
+              })['f']
+            >
           >
         >
-      >
-    > extends infer R
-    ? _$reduce<F, T, R>
-    : never
-  : O
+      > extends infer R
+      ? _$reduce<F, T, R>
+      : never
+    : O
 
 interface Reduce_T2<F extends Kind.Kind<(x: never) => Kind.Kind>, X>
   extends Kind.Kind {

src/list/reverse.ts

@@ -8,8 +8,8 @@ type _$reverse2<T extends unknown[], O extends unknown[] = []> = T extends [
     ? [...O, Last]
     : _$reverse2<Init, [...O, Last]>
   : T extends [infer Head, ...unknown[]]
-  ? Head
-  : [...O, ...T]
+    ? Head
+    : [...O, ...T]
 
 /**
  * `_$reverse` is a type-level function that reverses a tuple.
@@ -26,8 +26,8 @@ export type _$reverse<
 > = T extends [infer Head, ...infer Tail]
   ? _$reverse<Tail, [Head, ...O]>
   : T extends []
-  ? O
-  : [..._$reverse2<T>, ...O]
+    ? O
+    : [..._$reverse2<T>, ...O]
 
 /**
  * `Reverse` is a type-level function that reverses a tuple.

src/list/slice.ts

@@ -51,8 +51,8 @@ export type _$slice<
     DigitList.DigitList = Number._$isNatural<START> extends true
     ? START_ABS
     : DigitList._$compare<T_LENGTH, START_ABS> extends -1
-    ? [Digit.Zero]
-    : DigitList._$subtract<T_LENGTH, START_ABS>,
+      ? [Digit.Zero]
+      : DigitList._$subtract<T_LENGTH, START_ABS>,
   POP_NORM extends DigitList.DigitList = Number._$isNatural<END> extends true
     ? DigitList._$compare<T_LENGTH, END_ABS> extends -1
       ? [Digit.Zero]

src/list/some.ts

@@ -18,8 +18,12 @@ export type _$some<
 > = 0 extends 1
   ? never
   : T extends [infer Head, ...infer Rest]
-  ? _$some<F, Rest, Boolean._$or<O, $<F, Type._$cast<Head, Kind._$inputOf<F>>>>>
-  : O
+    ? _$some<
+        F,
+        Rest,
+        Boolean._$or<O, $<F, Type._$cast<Head, Kind._$inputOf<F>>>>
+      >
+    : O
 
 interface Some_T<T extends Kind.Kind<(x: never) => boolean>> extends Kind.Kind {
   f(x: Type._$cast<this[Kind._], Kind._$inputOf<T>[]>): _$some<T, typeof x>

src/list/splice.ts

@@ -24,38 +24,38 @@ type _$splice2<
     DigitList.DigitList = Number._$isNatural<START> extends true
     ? START_ABS
     : DigitList._$compare<T_LENGTH, START_ABS> extends -1
-    ? [Digit.Zero]
-    : DigitList._$subtract<T_LENGTH, START_ABS>,
+      ? [Digit.Zero]
+      : DigitList._$subtract<T_LENGTH, START_ABS>,
   RESULT extends List.List = DigitList._$compare<
     START_NORM,
     NaturalNumber._$toList<T['length']>
   > extends 1 | 0
     ? List._$concat<INSERTS, T>
     : DEL_COUNT extends [Digit.Zero]
-    ? START_NORM extends [Digit.Zero]
-      ? [...PRE, ...INSERTS, ...POST]
-      : _$splice2<
-          T,
-          DigitList._$toNumber<DigitList._$decrement<START_NORM>>,
-          [Digit.Zero],
-          INSERTS,
-          List._$push<POST[0], PRE>,
-          List._$shift<POST>
-        >
-    : START_NORM extends [Digit.Zero]
-    ? [
-        ...PRE,
-        ...INSERTS,
-        ...List._$shiftN<POST, DigitList._$toNumber<DEL_COUNT>>
-      ]
-    : _$splice2<
-        T,
-        DigitList._$toNumber<DigitList._$decrement<START_NORM>>,
-        DEL_COUNT,
-        INSERTS,
-        List._$push<POST[0], PRE>,
-        List._$shift<POST>
-      >
+      ? START_NORM extends [Digit.Zero]
+        ? [...PRE, ...INSERTS, ...POST]
+        : _$splice2<
+            T,
+            DigitList._$toNumber<DigitList._$decrement<START_NORM>>,
+            [Digit.Zero],
+            INSERTS,
+            List._$push<POST[0], PRE>,
+            List._$shift<POST>
+          >
+      : START_NORM extends [Digit.Zero]
+        ? [
+            ...PRE,
+            ...INSERTS,
+            ...List._$shiftN<POST, DigitList._$toNumber<DEL_COUNT>>
+          ]
+        : _$splice2<
+            T,
+            DigitList._$toNumber<DigitList._$decrement<START_NORM>>,
+            DEL_COUNT,
+            INSERTS,
+            List._$push<POST[0], PRE>,
+            List._$shift<POST>
+          >
 > = RESULT
 
 /**

src/list/times.ts

@@ -9,8 +9,8 @@ type _$times2<
 > = 0 extends 1
   ? never
   : COUNTER extends ['0']
-  ? STATE
-  : _$times2<DEC, [DEC_NUM, ...STATE]>
+    ? STATE
+    : _$times2<DEC, [DEC_NUM, ...STATE]>
 
 /**
  * `_$times` is a type-level function that generates a list of numbers from 0 to N-1.

src/list/zip.ts

@@ -40,8 +40,8 @@ export type _$zip<
   RESULT extends List.List = MIN_LENGTH extends Number.MAX_SAFE_INTEGER
     ? []
     : IDX extends MIN_LENGTH
-    ? ACC
-    : _$zip<T, NaturalNumber._$increment<IDX>, List._$push<CURR, ACC>>
+      ? ACC
+      : _$zip<T, NaturalNumber._$increment<IDX>, List._$push<CURR, ACC>>
 > = RESULT
 
 /**