inferred-types 0.19.0 → 0.22.0

package/tests/string-literals/CamelCase.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { CamelCase } from "~/types";
+import { CamelCase } from "src/types";
 
 const target = "twoThreeFour";
 type TARGET = typeof target;
 
 describe("CamelCase<T> type utility", () => {
-
   it("CamelCase<T> provides an identity to a CamelCased string", () => {
     type T1 = CamelCase<"TwoThreeFour">;
     type T2 = CamelCase<"\n TwoThreeFour ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("CamelCase<T> type utility", () => {
   it("CamelCase<T> transform snake_case type", () => {
     type T1 = CamelCase<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -32,10 +28,7 @@ describe("CamelCase<T> type utility", () => {
     type T1 = CamelCase<"twoThreeFour">;
     type T2 = CamelCase<"  twoThreeFour \t">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -54,7 +47,7 @@ describe("CamelCase<T> type utility", () => {
       Expect<Equal<T3, "twoThreeFourFiveSix">>,
       Expect<Equal<T4, "twoThreeFourFiveSixSeven">>,
       Expect<Equal<T5, "twoThreeFourFiveSixSevenEight">>,
-      Expect<Equal<T6, "twoThreeFourFiveSixSevenEightNineTenEleven">>,
+      Expect<Equal<T6, "twoThreeFourFiveSixSevenEightNineTenEleven">>
     ];
     const c: cases = [true, true, true, true, true, true];
     expect(c).toBe(c);
@@ -63,9 +56,7 @@ describe("CamelCase<T> type utility", () => {
   it("CamelCase<T> transforms interior space to CamelCased type", () => {
     type T1 = CamelCase<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -75,11 +66,7 @@ describe("CamelCase<T> type utility", () => {
     type T2 = CamelCase<"\n TWO_THREE_FOUR ">;
     type T3 = CamelCase<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -88,10 +75,7 @@ describe("CamelCase<T> type utility", () => {
     type T1 = CamelCase<"  one two three ">;
     type T2 = CamelCase<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "oneTwoThree">>,
-      Expect<Equal<T2, "oneTwoThree">>,
-    ];
+    type cases = [Expect<Equal<T1, "oneTwoThree">>, Expect<Equal<T2, "oneTwoThree">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -99,9 +83,7 @@ describe("CamelCase<T> type utility", () => {
   it("CamelCase<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = CamelCase<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -119,10 +101,9 @@ describe("CamelCase<T> type utility", () => {
       Expect<Equal<T2, "oneTwoThreeFourFiveSixSevenEightNine">>,
       Expect<Equal<T3, "oneTwoThreeFourFiveSixSevenEightNine">>,
       Expect<Equal<T4, "oneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T5, "oneTwoThreeFourFiveSixSevenEightNine">>,
+      Expect<Equal<T5, "oneTwoThreeFourFiveSixSevenEightNine">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/Dasherize.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { Dasherize } from "~/types";
+import { Dasherize } from "src/types";
 
 const target = "two-three-four";
 type TARGET = typeof target;
 
 describe("Dasherize<T> type utility", () => {
-
   it("Dasherize<T> provides an identity to a dasherized string", () => {
     type T1 = Dasherize<"two-three-four">;
     type T2 = Dasherize<"\n two-three-four ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> transform snake_case type", () => {
     type T1 = Dasherize<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -31,9 +27,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> transforms PascalCase type", () => {
     type T1 = Dasherize<"TwoThreeFour">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -51,7 +45,7 @@ describe("Dasherize<T> type utility", () => {
       Expect<Equal<T2, "two-three-four-five">>,
       Expect<Equal<T3, "two-three-four-five-six">>,
       Expect<Equal<T4, "two-three-four-five-six-seven">>,
-      Expect<Equal<T5, "two-three-four-five-six-seven-eight">>,
+      Expect<Equal<T5, "two-three-four-five-six-seven-eight">>
       // Expect<Equal<T6, "two-three-four-five-six-seven-eight-nine">>,
     ];
     const c: cases = [true, true, true, true, true];
@@ -61,9 +55,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> transforms interior space to dasherized type", () => {
     type T1 = Dasherize<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -73,11 +65,7 @@ describe("Dasherize<T> type utility", () => {
     type T2 = Dasherize<"\n TWO_THREE_FOUR ">;
     type T3 = Dasherize<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -86,10 +74,7 @@ describe("Dasherize<T> type utility", () => {
     type T1 = Dasherize<"  one two three ">;
     type T2 = Dasherize<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "one-two-three">>,
-      Expect<Equal<T2, "one-two-three">>,
-    ];
+    type cases = [Expect<Equal<T1, "one-two-three">>, Expect<Equal<T2, "one-two-three">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -97,9 +82,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = Dasherize<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -116,10 +99,9 @@ describe("Dasherize<T> type utility", () => {
       Expect<Equal<T2, "one-two-three-four-five-six-seven-eight-nine-ten">>,
       Expect<Equal<T3, "one-two-three-four-five-six-seven-eight-nine-ten">>,
       Expect<Equal<T4, "one-two-three-four-five-six-seven-eight-nine-ten">>,
-      Expect<Equal<T5, "one-two-three-four-five-six-seven-eight-nine-ten">>,
+      Expect<Equal<T5, "one-two-three-four-five-six-seven-eight-nine-ten">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/HasUppercase.spec.ts

@@ -1,18 +1,15 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { HasUppercase } from "~/types";
+import { HasUppercase } from "src/types";
 
 describe("HasUppercase<T> type utility", () => {
-
   it("finds capitals where they exist", () => {
     type T1 = HasUppercase<"Yup">;
     type T2 = HasUppercase<"yUp">;
     type T3 = HasUppercase<"YUP">;
 
-    type cases = [
-      Expect<Equal<T1, true>>,
-      Expect<Equal<T2, true>>,
-      Expect<Equal<T3, true>>,
-    ];
+    type cases = [Expect<Equal<T1, true>>, Expect<Equal<T2, true>>, Expect<Equal<T3, true>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -21,10 +18,7 @@ describe("HasUppercase<T> type utility", () => {
     type T1 = HasUppercase<"nope">;
     type T2 = HasUppercase<"  noo nooo noooooooooooooo">;
 
-    type cases = [
-      Expect<Equal<T1, false>>,
-      Expect<Equal<T2, false>>,
-    ];
+    type cases = [Expect<Equal<T1, false>>, Expect<Equal<T2, false>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -32,11 +26,8 @@ describe("HasUppercase<T> type utility", () => {
   it("when passed a non literal string, returns 'unknown'", () => {
     type T1 = HasUppercase<string>;
 
-    type cases = [
-      Expect<Equal<T1, "unknown">>,
-    ];
+    type cases = [Expect<Equal<T1, "unknown">>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });

package/tests/string-literals/PascalCase.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { PascalCase } from "~/types";
+import { PascalCase } from "src/types";
 
 const target = "TwoThreeFour";
 type TARGET = typeof target;
 
 describe("PascalCase<T> type utility", () => {
-
   it("PascalCase<T> provides an identity to a PascalCased string", () => {
     type T1 = PascalCase<"TwoThreeFour">;
     type T2 = PascalCase<"\n TwoThreeFour ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("PascalCase<T> type utility", () => {
   it("PascalCase<T> transform snake_case type", () => {
     type T1 = PascalCase<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -32,10 +28,7 @@ describe("PascalCase<T> type utility", () => {
     type T1 = PascalCase<"twoThreeFour">;
     type T2 = PascalCase<"  twoThreeFour \t">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -54,7 +47,7 @@ describe("PascalCase<T> type utility", () => {
       Expect<Equal<T3, "TwoThreeFourFiveSix">>,
       Expect<Equal<T4, "TwoThreeFourFiveSixSeven">>,
       Expect<Equal<T5, "TwoThreeFourFiveSixSevenEight">>,
-      Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>,
+      Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>
     ];
     const c: cases = [true, true, true, true, true, true];
     expect(c).toBe(c);
@@ -63,9 +56,7 @@ describe("PascalCase<T> type utility", () => {
   it("PascalCase<T> transforms interior space to PascalCased type", () => {
     type T1 = PascalCase<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -75,11 +66,7 @@ describe("PascalCase<T> type utility", () => {
     type T2 = PascalCase<"\n TWO_THREE_FOUR ">;
     type T3 = PascalCase<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -88,10 +75,7 @@ describe("PascalCase<T> type utility", () => {
     type T1 = PascalCase<"  one two three ">;
     type T2 = PascalCase<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "OneTwoThree">>,
-      Expect<Equal<T2, "OneTwoThree">>,
-    ];
+    type cases = [Expect<Equal<T1, "OneTwoThree">>, Expect<Equal<T2, "OneTwoThree">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -99,9 +83,7 @@ describe("PascalCase<T> type utility", () => {
   it("PascalCase<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = PascalCase<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -119,10 +101,9 @@ describe("PascalCase<T> type utility", () => {
       Expect<Equal<T2, "OneTwoThreeFourFiveSixSevenEightNine">>,
       Expect<Equal<T3, "OneTwoThreeFourFiveSixSevenEightNine">>,
       Expect<Equal<T4, "OneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T5, "OneTwoThreeFourFiveSixSevenEightNine">>,
+      Expect<Equal<T5, "OneTwoThreeFourFiveSixSevenEightNine">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/SnakeCase.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { SnakeCase } from "~/types";
+import { SnakeCase } from "src/types";
 
 const target = "two_three_four";
 type TARGET = typeof target;
 
 describe("SnakeCase<T> type utility", () => {
-
   it("SnakeCase<T> provides an identity to a SnakeCased string", () => {
     type T1 = SnakeCase<"TwoThreeFour">;
     type T2 = SnakeCase<"\n TwoThreeFour ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("SnakeCase<T> type utility", () => {
   it("SnakeCase<T> transform snake_case type", () => {
     type T1 = SnakeCase<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -32,10 +28,7 @@ describe("SnakeCase<T> type utility", () => {
     type T1 = SnakeCase<"twoThreeFour">;
     type T2 = SnakeCase<"  twoThreeFour \t">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -53,7 +46,7 @@ describe("SnakeCase<T> type utility", () => {
       Expect<Equal<T2, "two_three_four_five">>,
       Expect<Equal<T3, "two_three_four_five_six">>,
       Expect<Equal<T4, "two_three_four_five_six_seven">>,
-      Expect<Equal<T5, "two_three_four_five_six_seven_eight">>,
+      Expect<Equal<T5, "two_three_four_five_six_seven_eight">>
       // Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>,
     ];
     const c: cases = [true, true, true, true, true];
@@ -63,9 +56,7 @@ describe("SnakeCase<T> type utility", () => {
   it("SnakeCase<T> transforms interior space to SnakeCased type", () => {
     type T1 = SnakeCase<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -75,11 +66,7 @@ describe("SnakeCase<T> type utility", () => {
     type T2 = SnakeCase<"\n TWO_THREE_FOUR ">;
     type T3 = SnakeCase<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -88,10 +75,7 @@ describe("SnakeCase<T> type utility", () => {
     type T1 = SnakeCase<"  one two three ">;
     type T2 = SnakeCase<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "one_two_three">>,
-      Expect<Equal<T2, "one_two_three">>,
-    ];
+    type cases = [Expect<Equal<T1, "one_two_three">>, Expect<Equal<T2, "one_two_three">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -99,9 +83,7 @@ describe("SnakeCase<T> type utility", () => {
   it("SnakeCase<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = SnakeCase<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -119,10 +101,9 @@ describe("SnakeCase<T> type utility", () => {
       Expect<Equal<T2, "one_two_three_four_five_six_seven_eight_nine">>,
       Expect<Equal<T3, "one_two_three_four_five_six_seven_eight_nine">>,
       Expect<Equal<T4, "one_two_three_four_five_six_seven_eight_nine">>,
-      Expect<Equal<T5, "one_two_three_four_five_six_seven_eight_nine">>,
+      Expect<Equal<T5, "one_two_three_four_five_six_seven_eight_nine">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/whitespace-capture.spec.ts

@@ -1,16 +1,14 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { LeftWhitespace, RightWhitespace } from "~/types";
+import { LeftWhitespace, RightWhitespace } from "src/types";
 
 describe("LeftWhitespace<T> utility", () => {
-
   it("no whitespace results in empty string literal", () => {
     type T1 = LeftWhitespace<"foobar">;
     type T2 = LeftWhitespace<"foobar \n">;
 
-    type cases = [
-      Expect<Equal<T1, "">>,
-      Expect<Equal<T2, "">>,
-    ];
+    type cases = [Expect<Equal<T1, "">>, Expect<Equal<T2, "">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -19,10 +17,7 @@ describe("LeftWhitespace<T> utility", () => {
     type T1 = LeftWhitespace<" foobar">;
     type T2 = LeftWhitespace<"\n\t foobar \n">;
 
-    type cases = [
-      Expect<Equal<T1, " ">>,
-      Expect<Equal<T2, "\n\t ">>,
-    ];
+    type cases = [Expect<Equal<T1, " ">>, Expect<Equal<T2, "\n\t ">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -30,25 +25,18 @@ describe("LeftWhitespace<T> utility", () => {
   it("a 'string' type passed in returns a string", () => {
     type T1 = LeftWhitespace<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });
 
 describe("RightWhitespace<T> utility", () => {
-
   it("no whitespace results in empty string literal", () => {
     type T1 = RightWhitespace<"foobar">;
     type T2 = RightWhitespace<"\n\tfoobar">;
 
-    type cases = [
-      Expect<Equal<T1, "">>,
-      Expect<Equal<T2, "">>,
-    ];
+    type cases = [Expect<Equal<T1, "">>, Expect<Equal<T2, "">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -57,10 +45,7 @@ describe("RightWhitespace<T> utility", () => {
     type T1 = RightWhitespace<"foobar ">;
     type T2 = RightWhitespace<"\n\t foobar \n">;
 
-    type cases = [
-      Expect<Equal<T1, " ">>,
-      Expect<Equal<T2, " \n">>,
-    ];
+    type cases = [Expect<Equal<T1, " ">>, Expect<Equal<T2, " \n">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -68,11 +53,8 @@ describe("RightWhitespace<T> utility", () => {
   it("a 'string' type passed in returns a string", () => {
     type T1 = RightWhitespace<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/tuples/TupleToUnion.spec.ts

@@ -1,4 +1,6 @@
-import { TupleToUnion } from "~/types";
+import { describe, it, expect } from "vitest";
+
+import { TupleToUnion } from "src/types";
 import { Expect, Equal } from "@type-challenges/utils";
 
 describe("TupleToUnion<T> type utility", () => {

package/tests/withValue.spec.ts

@@ -1,7 +1,8 @@
-import { createFnWithProps, type, withValue } from "~/utility";
+import { describe, it, expect } from "vitest";
 import type { Expect, Equal } from "@type-challenges/utils";
-import { WithValue } from "~/types/props";
-import { FunctionType } from "~/types";
+
+import { createFnWithProps, type, withValue } from "../src/utility";
+import { FunctionType, WithValue } from "../src";
 
 describe("withValue()() utility", () => {
   it("type reduction with WithValue<T> works as expected", () => {

package/tsconfig.json

@@ -3,37 +3,26 @@
     "module": "ESNEXT",
     "target": "ESNEXT",
     "moduleResolution": "node",
-
     "sourceMap": true,
     "noEmit": true,
     "incremental": true,
     "resolveJsonModule": true,
-
     "strict": true,
     "skipLibCheck": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noImplicitReturns": true,
     "allowSyntheticDefaultImports": true,
-
-    "lib": ["ES2020"],
-
+    "lib": [
+      "ES2020"
+    ],
     "baseUrl": ".",
     "declaration": true,
     "outDir": "dist",
     "tsBuildInfoFile": ".tsbuildinfo",
-
-    "paths": {
-      "~/*": ["src/*"],
-      "/~/*": ["src/*"]
-    },
-    "plugins": [
-      // Transform paths in output .js files
-      { "transform": "typescript-transform-paths" },
-
-      // Transform paths in output .d.ts files (Include this line if you output declarations files)
-      { "transform": "typescript-transform-paths", "afterDeclarations": true }
-    ]
   },
-  "include": ["src", "tests"]
-}
+  "include": [
+    "src",
+    "tests"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+/// <reference types="vitest" />
+import { defineConfig } from "vite";
+
+// used for testing, library code uses TSUP to build exports
+export default defineConfig({
+  test: {
+    dir: "tests",
+    api: {
+      host: "0.0.0.0",
+    },
+  },
+  plugins: [],
+});