inferred-types 0.37.0 → 0.37.1

package/tests/literals/CamelCase.spec.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-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>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> transform snake_case type", () => {
-    type T1 = CamelCase<"two_three_four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> transforms camelCase type", () => {
-    type T1 = CamelCase<"twoThreeFour">;
-    type T2 = CamelCase<"  twoThreeFour \t">;
-
-    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> transforms camelCase type up to any length", () => {
-    type T1 = CamelCase<"twoThreeFour">;
-    type T2 = CamelCase<"twoThreeFourFive">;
-    type T3 = CamelCase<"twoThreeFourFiveSix">;
-    type T4 = CamelCase<"twoThreeFourFiveSixSeven">;
-    type T5 = CamelCase<"twoThreeFourFiveSixSevenEight">;
-    type T6 = CamelCase<"twoThreeFourFiveSixSevenEightNineTenEleven">;
-
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, "twoThreeFourFive">>,
-      Expect<Equal<T3, "twoThreeFourFiveSix">>,
-      Expect<Equal<T4, "twoThreeFourFiveSixSeven">>,
-      Expect<Equal<T5, "twoThreeFourFiveSixSevenEight">>,
-      Expect<Equal<T6, "twoThreeFourFiveSixSevenEightNineTenEleven">>
-    ];
-    const c: cases = [true, true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> transforms interior space to CamelCased type", () => {
-    type T1 = CamelCase<"two three four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> transforms ALL CAPS to CamelCased type", () => {
-    type T1 = CamelCase<"TWO THREE FOUR">;
-    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>>];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> removes leading and trailing whitespace and still converts", () => {
-    type T1 = CamelCase<"  one two three ">;
-    type T2 = CamelCase<"\n  one two three ">;
-
-    type cases = [Expect<Equal<T1, "oneTwoThree">>, Expect<Equal<T2, "oneTwoThree">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> returns 'string' type when passed a non-literal string", () => {
-    type T1 = CamelCase<string>;
-
-    type cases = [Expect<Equal<T1, string>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("CamelCase<T> can handle long strings which do not have caps (unless they're ALL CAPS)", () => {
-    type T1 = CamelCase<"one two three four five six seven eight nine">;
-    type T2 = CamelCase<"one_two_three_four_five_six_seven_eight_nine">;
-    type T3 = CamelCase<"ONE_TWO_THREE_FOUR_FIVE_SIX_SEVEN_EIGHT_NINE">;
-    // also works for multiple delimiters
-    type T4 = CamelCase<"one-two-three-four_five_six_seven_eight_nine">;
-    type T5 = CamelCase<"\n one-two-three-four_five_six_seven eight_nine \t">;
-
-    type cases = [
-      Expect<Equal<T1, "oneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T2, "oneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T3, "oneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T4, "oneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T5, "oneTwoThreeFourFiveSixSevenEightNine">>
-    ];
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-});

package/tests/literals/Dasherize.spec.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-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>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> transform snake_case type", () => {
-    type T1 = Dasherize<"two_three_four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> transforms PascalCase type", () => {
-    type T1 = Dasherize<"TwoThreeFour">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> transforms camelCase type up to a pretty long length", () => {
-    type T1 = Dasherize<"twoThreeFour">;
-    type T2 = Dasherize<"twoThreeFourFive">;
-    type T3 = Dasherize<"twoThreeFourFiveSix">;
-    type T4 = Dasherize<"twoThreeFourFiveSixSeven">;
-    type T5 = Dasherize<"twoThreeFourFiveSixSevenEight">;
-    // type T6 = Dasherize<"twoThreeFourFiveSixSevenEightNine">;
-
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      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<T6, "two-three-four-five-six-seven-eight-nine">>,
-    ];
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> transforms interior space to dasherized type", () => {
-    type T1 = Dasherize<"two three four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> transforms ALL CAPS to dasherized type", () => {
-    type T1 = Dasherize<"TWO THREE FOUR">;
-    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>>];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> removes leading and trailing whitespace and still converts", () => {
-    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">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> returns 'string' type when passed a non-literal string", () => {
-    type T1 = Dasherize<string>;
-
-    type cases = [Expect<Equal<T1, string>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("Dasherize<T> can handle long strings which do not have caps (unless they're ALL CAPS)", () => {
-    type T1 = Dasherize<"one two three four five six seven eight nine ten">;
-    type T2 = Dasherize<"one_two_three_four_five_six_seven_eight_nine_ten">;
-    type T3 = Dasherize<"ONE_TWO_THREE_FOUR_FIVE_SIX_SEVEN_EIGHT_NINE_TEN">;
-    type T4 = Dasherize<"one-two-three-four_five_six_seven_eight_nine_ten">;
-    type T5 = Dasherize<"\n one-two-three-four_five_six_seven_eight_nine_ten \t">;
-
-    type cases = [
-      Expect<Equal<T1, "one-two-three-four-five-six-seven-eight-nine-ten">>,
-      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">>
-    ];
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-});

package/tests/literals/EnsureStripLeadingTrailing.test.ts

@@ -1,79 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { ensureLeading } from "src/runtime/literals/ensureLeading";
-import { ensureTrailing } from "src/runtime/literals/ensureTrailing";
-import { stripLeading } from "src/runtime/literals/stripLeading";
-import { stripTrailing } from "src/runtime/literals/stripTrailing";
-import { EnsureLeading, EnsureTrailing, StripLeading, StripTrailing } from "src/types/alphabetic";
-import { describe, expect, it } from "vitest";
-
-// Note: while type tests clearly fail visible inspection, they pass from Vitest
-// standpoint so always be sure to run `tsc --noEmit` over your test files to
-// gain validation that no new type vulnerabilities have cropped up.
-
-describe("EnsureLeading", () => {
-  it("EnsureLeading<T,U>", () => {
-    type T1 = EnsureLeading<"bar", "foo">;
-    type T2 = EnsureLeading<"foobar", "foo">;
-
-    type cases = [Expect<Equal<T1, "foobar">>, Expect<Equal<T2, "foobar">>];
-    const cases: cases = [true, true];
-  });
-
-  it("ensureLeading()", () => {
-    const t1 = ensureLeading("bar", "foo");
-    const t2 = ensureLeading("foobar", "foo");
-    expect(t1).toBe("foobar");
-    expect(t2).toBe("foobar");
-  });
-});
-
-describe("EnsureTrailing", () => {
-  it("EnsureTrailing<T,U>", () => {
-    type T1 = EnsureTrailing<"foo", "bar">;
-    type T2 = EnsureTrailing<"foobar", "bar">;
-
-    type cases = [Expect<Equal<T1, "foobar">>, Expect<Equal<T2, "foobar">>];
-    const cases: cases = [true, true];
-  });
-
-  it("ensureTrailing()", () => {
-    const t1 = ensureTrailing("foo", "bar");
-    const t2 = ensureTrailing("foobar", "bar");
-    expect(t1).toBe("foobar");
-    expect(t2).toBe("foobar");
-  });
-});
-
-describe("StripLeading", () => {
-  it("StripLeading<T,U>", () => {
-    type T1 = StripLeading<"foobar", "foo">;
-    type T2 = StripLeading<"bar", "foo">;
-
-    type cases = [Expect<Equal<T1, "bar">>, Expect<Equal<T2, "bar">>];
-    const cases: cases = [true, true];
-  });
-
-  it("stripLeading()", () => {
-    const t1 = stripLeading("foobar", "foo");
-    const t2 = stripLeading("bar", "foo");
-    expect(t1).toBe("bar");
-    expect(t2).toBe("bar");
-  });
-});
-
-describe("StripTrailing", () => {
-  it("StripTrailing<T,U>", () => {
-    type T1 = StripTrailing<"foobar", "bar">;
-    type T2 = StripTrailing<"foo", "bar">;
-
-    type cases = [Expect<Equal<T1, "foo">>, Expect<Equal<T2, "foo">>];
-    const cases: cases = [true, true];
-  });
-
-  it("stripTrailing()", () => {
-    const t1 = stripTrailing("foobar", "bar");
-    const t2 = stripTrailing("foo", "bar");
-    expect(t1).toBe("foo");
-    expect(t2).toBe("foo");
-  });
-});

package/tests/literals/HasUppercase.spec.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-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>>];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("correctly identifies the absence of capitals", () => {
-    type T1 = HasUppercase<"nope">;
-    type T2 = HasUppercase<"  noo nooo noooooooooooooo">;
-
-    type cases = [Expect<Equal<T1, false>>, Expect<Equal<T2, false>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("when passed a non literal string, returns 'unknown'", () => {
-    type T1 = HasUppercase<string>;
-
-    type cases = [Expect<Equal<T1, "unknown">>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});

package/tests/literals/PascalCase.spec.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-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>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> transform snake_case type", () => {
-    type T1 = PascalCase<"two_three_four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> transforms camelCase type", () => {
-    type T1 = PascalCase<"twoThreeFour">;
-    type T2 = PascalCase<"  twoThreeFour \t">;
-
-    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> transforms camelCase type up to any length", () => {
-    type T1 = PascalCase<"twoThreeFour">;
-    type T2 = PascalCase<"twoThreeFourFive">;
-    type T3 = PascalCase<"twoThreeFourFiveSix">;
-    type T4 = PascalCase<"twoThreeFourFiveSixSeven">;
-    type T5 = PascalCase<"twoThreeFourFiveSixSevenEight">;
-    type T6 = PascalCase<"twoThreeFourFiveSixSevenEightNineTenEleven">;
-
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, "TwoThreeFourFive">>,
-      Expect<Equal<T3, "TwoThreeFourFiveSix">>,
-      Expect<Equal<T4, "TwoThreeFourFiveSixSeven">>,
-      Expect<Equal<T5, "TwoThreeFourFiveSixSevenEight">>,
-      Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>
-    ];
-    const c: cases = [true, true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> transforms interior space to PascalCased type", () => {
-    type T1 = PascalCase<"two three four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> transforms ALL CAPS to PascalCased type", () => {
-    type T1 = PascalCase<"TWO THREE FOUR">;
-    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>>];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> removes leading and trailing whitespace and still converts", () => {
-    type T1 = PascalCase<"  one two three ">;
-    type T2 = PascalCase<"\n  one two three ">;
-
-    type cases = [Expect<Equal<T1, "OneTwoThree">>, Expect<Equal<T2, "OneTwoThree">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> returns 'string' type when passed a non-literal string", () => {
-    type T1 = PascalCase<string>;
-
-    type cases = [Expect<Equal<T1, string>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("PascalCase<T> can handle long strings which do not have caps (unless they're ALL CAPS)", () => {
-    type T1 = PascalCase<"one two three four five six seven eight nine">;
-    type T2 = PascalCase<"one_two_three_four_five_six_seven_eight_nine">;
-    type T3 = PascalCase<"ONE_TWO_THREE_FOUR_FIVE_SIX_SEVEN_EIGHT_NINE">;
-    // also works for multiple delimiters
-    type T4 = PascalCase<"one-two-three-four_five_six_seven_eight_nine">;
-    type T5 = PascalCase<"\n one-two-three-four_five_six_seven eight_nine \t">;
-
-    type cases = [
-      Expect<Equal<T1, "OneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T2, "OneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T3, "OneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T4, "OneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T5, "OneTwoThreeFourFiveSixSevenEightNine">>
-    ];
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-});

package/tests/literals/PathJoin.test.ts

@@ -1,111 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { pathJoin } from "src/runtime/literals/pathJoin";
-import { PathJoin } from "src/types/alphabetic/PathJoin";
-import { describe, expect, it } from "vitest";
-
-// Note: type tests fail visible inspection but pass from Vitest
-// standpoint so always be sure to run `tsc --noEmit` over your test files to
-// gain validation that no new type vulnerabilities have cropped up.
-
-describe("PathJoin<T,U>", () => {
-  it("only literals / happy path", () => {
-    type T1 = PathJoin<"foo", "bar">;
-    type T2 = PathJoin<"foo/", "bar">;
-    type T3 = PathJoin<"foo", "/bar">;
-    type T4 = PathJoin<"foo/", "/bar">;
-    type T5 = PathJoin<"/foo/", "/bar">;
-    type T6 = PathJoin<"foo/", "/bar/">;
-
-    type cases = [
-      // neither have divider
-      Expect<Equal<T1, "foo/bar">>,
-      // one has, one does not
-      Expect<Equal<T2, "foo/bar">>,
-      Expect<Equal<T3, "foo/bar">>,
-      // both have
-      Expect<Equal<T4, "foo/bar">>,
-      // leading slash
-      Expect<Equal<T5, "/foo/bar">>,
-      // trailing slash
-      Expect<Equal<T6, "foo/bar/">>
-    ];
-    const cases: cases = [true, true, true, true, true, true];
-  });
-
-  it("PathJoin<T,U> with U as array", () => {
-    type T1 = PathJoin<"foo", ["bar", "baz"]>;
-    type T2 = PathJoin<"/foo/", ["/bar/", "/baz/"]>;
-    type T3 = PathJoin<"/foo/", ["bar", "/baz"]>;
-
-    type cases = [
-      //
-      Expect<Equal<T1, "foo/bar/baz">>,
-      Expect<Equal<T2, "/foo/bar/baz/">>,
-      Expect<Equal<T3, "/foo/bar/baz">>
-    ];
-    const cases: cases = [true, true, true];
-  });
-
-  it("wide types mixed in", () => {
-    type T1 = PathJoin<"foo", string>;
-    type T2 = PathJoin<"foo/", string>;
-    type T3 = PathJoin<string, "/bar">;
-    type T4 = PathJoin<string, "bar">;
-
-    type cases = [
-      Expect<Equal<T1, `foo/${string}`>>,
-      Expect<Equal<T2, `foo/${string}`>>,
-      Expect<Equal<T3, `${string}/bar`>>,
-      Expect<Equal<T4, `${string}bar`>>
-    ];
-    const cases: cases = [true, true, true, true];
-  });
-});
-
-describe("pathJoin() runtime util", () => {
-  it("no leading or trailing slashes", () => {
-    const t1 = pathJoin("foo", "bar");
-    const t2 = pathJoin("foo/", "bar");
-    const t3 = pathJoin("foo", "/bar");
-    const t4 = pathJoin("foo/", "/bar");
-    // multi
-    const t5 = pathJoin("foo/", "bar", "/baz");
-    const t6 = pathJoin("foo/", "bar/", "/baz");
-
-    [t1, t2, t3, t4].forEach((test) =>
-      expect(test, "no leading or trailing slash").toBe("foo/bar")
-    );
-    [t5, t6].forEach((test) =>
-      expect(test, "no leading or trailing slash (with multi U)").toBe("foo/bar/baz")
-    );
-  });
-
-  it("leading and trailing slashes", () => {
-    const t1 = pathJoin("/foo", "bar");
-    const t2 = pathJoin("foo/", "bar/");
-    const t3 = pathJoin("/foo", "bar", "/baz");
-    const t4 = pathJoin("foo/", "/bar/", "/baz/");
-    // runtime tests
-    expect(t1).toBe("/foo/bar");
-    expect(t2).toBe("foo/bar/");
-    expect(t3).toBe("/foo/bar/baz");
-    expect(t4).toBe("foo/bar/baz/");
-  });
-
-  it("singular value", () => {
-    const t1 = pathJoin("foo");
-    const t2 = pathJoin("foo/");
-
-    // runtime
-    expect(t1).toBe("foo");
-    expect(t2).toBe("foo/");
-
-    // design time
-    type cases = [
-      //
-      Expect<Equal<typeof t1, "foo">>,
-      Expect<Equal<typeof t2, "foo/">>
-    ];
-    const cases: cases = [true, true];
-  });
-});

package/tests/literals/SnakeCase.spec.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-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>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> transform snake_case type", () => {
-    type T1 = SnakeCase<"two_three_four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> transforms camelCase type", () => {
-    type T1 = SnakeCase<"twoThreeFour">;
-    type T2 = SnakeCase<"  twoThreeFour \t">;
-
-    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> transforms camelCase type up to a reasonable length", () => {
-    type T1 = SnakeCase<"twoThreeFour">;
-    type T2 = SnakeCase<"twoThreeFourFive">;
-    type T3 = SnakeCase<"twoThreeFourFiveSix">;
-    type T4 = SnakeCase<"twoThreeFourFiveSixSeven">;
-    type T5 = SnakeCase<"twoThreeFourFiveSixSevenEight">;
-    // type T6 = SnakeCase<"twoThreeFourFiveSixSevenEightNineTenEleven">;
-
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      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<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>,
-    ];
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> transforms interior space to SnakeCased type", () => {
-    type T1 = SnakeCase<"two three four">;
-
-    type cases = [Expect<Equal<T1, TARGET>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> transforms ALL CAPS to SnakeCased type", () => {
-    type T1 = SnakeCase<"TWO THREE FOUR">;
-    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>>];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> removes leading and trailing whitespace and still converts", () => {
-    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">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> returns 'string' type when passed a non-literal string", () => {
-    type T1 = SnakeCase<string>;
-
-    type cases = [Expect<Equal<T1, string>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("SnakeCase<T> can handle long strings which do not have caps (unless they're ALL CAPS)", () => {
-    type T1 = SnakeCase<"one two three four five six seven eight nine">;
-    type T2 = SnakeCase<"one_two_three_four_five_six_seven_eight_nine">;
-    type T3 = SnakeCase<"ONE_TWO_THREE_FOUR_FIVE_SIX_SEVEN_EIGHT_NINE">;
-    // also works for multiple delimiters
-    type T4 = SnakeCase<"one-two-three-four_five_six_seven_eight_nine">;
-    type T5 = SnakeCase<"\n one-two-three-four_five_six_seven eight_nine \t">;
-
-    type cases = [
-      Expect<Equal<T1, "one_two_three_four_five_six_seven_eight_nine">>,
-      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">>
-    ];
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-});