diff --git a/type-plus/ts/index.ts b/type-plus/ts/index.ts
index f8a9fcf480..f6f269da80 100644
--- a/type-plus/ts/index.ts
+++ b/type-plus/ts/index.ts
@@ -83,8 +83,11 @@ export * from './predicates/index.js'
 export type * from './predicates/not_assignable.js'
 export type { PrimitiveTypes } from './primitive.js'
 export * from './promise/index.js'
+export type * from './string/$extract_processed_string.js'
 export type * from './string/is_not_string.js'
 export type * from './string/is_string.js'
+export type * from './string/is_string_literal.js'
+export type * from './string/is_template_literal.js'
 export type { StringIncludes, StringSplit } from './string/string.js'
 export type { StringPlus } from './string/string_plus.js'
 export type * from './symbol/is_not_symbol.js'
diff --git a/type-plus/ts/mix_types/merge.spec.ts b/type-plus/ts/mix_types/merge.spec.ts
index b3dd91c801..14414b262b 100644
--- a/type-plus/ts/mix_types/merge.spec.ts
+++ b/type-plus/ts/mix_types/merge.spec.ts
@@ -171,3 +171,4 @@ describe(`${merge.name}()`, () => {
 })
 
 // TODO: array merge check
+testType.equal<Merge<{toString: 1}, string>, string>(true)
diff --git a/type-plus/ts/number/is_number.spec.ts b/type-plus/ts/number/is_number.spec.ts
index 668fa04e69..a97887d5ea 100644
--- a/type-plus/ts/number/is_number.spec.ts
+++ b/type-plus/ts/number/is_number.spec.ts
@@ -142,6 +142,7 @@ describe('exact', () => {
 
 	it('can disable union distribution', () => {
 		testType.equal<IsNumber<number | string, { distributive: false }>, false>(true)
+		testType.equal<IsNumber<1 | 2, { distributive: false }>, true>(true)
 	})
 
 	it('returns true for intersection type', () => {
diff --git a/type-plus/ts/object/merge.spec.ts b/type-plus/ts/object/merge.spec.ts
index 51a34fce9c..fa28d55ba6 100644
--- a/type-plus/ts/object/merge.spec.ts
+++ b/type-plus/ts/object/merge.spec.ts
@@ -129,4 +129,3 @@ it('spread across unions', () => {
 	// 	{ a: number } | { a: number, b: 2 }
 	// >(true)
 })
-
diff --git a/type-plus/ts/string/$extract_processed_string.spec.ts b/type-plus/ts/string/$extract_processed_string.spec.ts
new file mode 100644
index 0000000000..9d5c3bc83b
--- /dev/null
+++ b/type-plus/ts/string/$extract_processed_string.spec.ts
@@ -0,0 +1,234 @@
+import { it } from '@jest/globals'
+import { testType } from '../index.js'
+import { type $ExtractProcessedString } from './$extract_processed_string.js'
+
+it('returns T if T is a string', () => {
+	testType.equal<$ExtractProcessedString<string>, string>(true)
+})
+
+it(`returns T if T is a string literal`, () => {
+	testType.equal<$ExtractProcessedString<''>, ''>(true)
+	testType.equal<$ExtractProcessedString<'a'>, 'a'>(true)
+})
+
+it('returns T if T can be reduced to a string literal', () => {
+	testType.equal<$ExtractProcessedString<`${''}`>, ''>(true)
+	testType.equal<$ExtractProcessedString<`${'b'}`>, 'b'>(true)
+	testType.equal<$ExtractProcessedString<`${boolean}`>, `true` | `false`>(true)
+	testType.equal<$ExtractProcessedString<`${true}`>, `true`>(true)
+	testType.equal<$ExtractProcessedString<`${false}`>, `false`>(true)
+	testType.equal<$ExtractProcessedString<`${1}`>, `1`>(true)
+	testType.equal<$ExtractProcessedString<`${1.1}`>, `1.1`>(true)
+	testType.equal<$ExtractProcessedString<`${1e99}`>, `1e+99`>(true)
+	testType.equal<$ExtractProcessedString<`${-1}`>, `-1`>(true)
+	testType.equal<$ExtractProcessedString<`${1n}`>, `1`>(true)
+	testType.equal<$ExtractProcessedString<`${null}`>, `null`>(true)
+	testType.equal<$ExtractProcessedString<`${undefined}`>, `undefined`>(true)
+})
+
+
+it('returns T for template literal', () => {
+	testType.equal<$ExtractProcessedString<`${number}`>, `${number}`>(true)
+	testType.equal<$ExtractProcessedString<`${string}`>, string>(true)
+	testType.equal<$ExtractProcessedString<`${bigint}`>, `${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<`a${number}`>, `a${number}`>(true)
+	testType.equal<$ExtractProcessedString<`a${string}`>, `a${string}`>(true)
+	testType.equal<$ExtractProcessedString<`a${bigint}`>, `a${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<`${number}c`>, `${number}c`>(true)
+	testType.equal<$ExtractProcessedString<`${string}c`>, `${string}c`>(true)
+	testType.equal<$ExtractProcessedString<`${bigint}c`>, `${bigint}c`>(true)
+
+	testType.equal<$ExtractProcessedString<`a${number}c`>, `a${number}c`>(true)
+	testType.equal<$ExtractProcessedString<`a${string}c`>, `a${string}c`>(true)
+	testType.equal<$ExtractProcessedString<`a${bigint}c`>, `a${bigint}c`>(true)
+
+	testType.equal<`${number | string | bigint}`, string>(true)
+	testType.equal<$ExtractProcessedString<`${number | string | bigint}`>, string>(true)
+	testType.equal<$ExtractProcessedString<`${number | bigint}`>, `${number | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<`a${number | string | bigint}`>, `a${number | string | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<`${number | string | bigint}c`>, `${number | string | bigint}c`>(true)
+	testType.equal<$ExtractProcessedString<`a${number | string | bigint}c`>, `a${number | string | bigint}c`>(true)
+})
+
+it('unwraps T in Uppercase', () => {
+	testType.equal<$ExtractProcessedString<Uppercase<string>>, string>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<''>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<'a'>>, 'A'>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<`${''}`>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${'b'}`>>, 'B'>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${boolean}`>>, `TRUE` | `FALSE`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${true}`>>, `TRUE`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${false}`>>, `FALSE`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${1}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${1.1}`>>, `1.1`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${1e99}`>>, `1E+99`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${-1}`>>, `-1`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${1n}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${null}`>>, `NULL`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${undefined}`>>, `UNDEFINED`>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<`${number}`>>, `${number}`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${string}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${bigint}`>>, `${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<`a${number}`>>, `A${Uppercase<`${number}`>}`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`a${string}`>>, `A${Uppercase<`${string}`>}`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`a${bigint}`>>, `A${Uppercase<`${bigint}`>}`>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<`${number}c`>>, `${Uppercase<`${number}`>}C`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${string}c`>>, `${Uppercase<`${string}`>}C`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${bigint}c`>>, `${Uppercase<`${bigint}`>}C`>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<`a${number}c`>>, `A${Uppercase<`${number}`>}C`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`a${string}c`>>, `A${Uppercase<`${string}`>}C`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`a${bigint}c`>>, `A${Uppercase<`${bigint}`>}C`>(true)
+
+	testType.equal<`${number | string | bigint}`, string>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${number | string | bigint}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${number | bigint}`>>, `${number | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`a${number | string | bigint}`>>, `A${Uppercase<`${number | string | bigint}`>}`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`${number | string | bigint}c`>>, `${Uppercase<`${number | string | bigint}`>}C`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<`a${number | string | bigint}c`>>, `A${Uppercase<`${number | string | bigint}`>}C`>(true)
+})
+
+it('unwraps T in Lowercase', () => {
+	testType.equal<$ExtractProcessedString<Lowercase<string>>, string>(true)
+
+	testType.equal<$ExtractProcessedString<Lowercase<''>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<'a'>>, 'a'>(true)
+
+	testType.equal<$ExtractProcessedString<Lowercase<`${''}`>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${'b'}`>>, 'b'>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${boolean}`>>, `true` | `false`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${true}`>>, `true`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${false}`>>, `false`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${1}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${1.1}`>>, `1.1`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${1e99}`>>, `1e+99`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${-1}`>>, `-1`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${1n}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${null}`>>, `null`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${undefined}`>>, `undefined`>(true)
+
+	testType.equal<$ExtractProcessedString<Lowercase<`${number}`>>, `${number}`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${string}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${bigint}`>>, `${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<Lowercase<`a${number}`>>, `a${Lowercase<`${number}`>}`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`a${string}`>>, `a${Lowercase<`${string}`>}`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`a${bigint}`>>, `a${Lowercase<`${bigint}`>}`>(true)
+
+	testType.equal<$ExtractProcessedString<Lowercase<`${number}c`>>, `${Lowercase<`${number}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${string}c`>>, `${Lowercase<`${string}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${bigint}c`>>, `${Lowercase<`${bigint}`>}c`>(true)
+
+	testType.equal<$ExtractProcessedString<Lowercase<`a${number}c`>>, `a${Lowercase<`${number}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`a${string}c`>>, `a${Lowercase<`${string}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`a${bigint}c`>>, `a${Lowercase<`${bigint}`>}c`>(true)
+
+	testType.equal<`${number | string | bigint}`, string>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${number | string | bigint}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${number | bigint}`>>, `${number | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`a${number | string | bigint}`>>, `a${Lowercase<`${number | string | bigint}`>}`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`${number | string | bigint}c`>>, `${Lowercase<`${number | string | bigint}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Lowercase<`a${number | string | bigint}c`>>, `a${Lowercase<`${number | string | bigint}`>}c`>(true)
+})
+
+it('unwraps T in Capitalize', () => {
+	testType.equal<$ExtractProcessedString<Capitalize<string>>, string>(true)
+
+	testType.equal<$ExtractProcessedString<Capitalize<''>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<'a'>>, 'A'>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<'hello world'>>, 'Hello world'>(true)
+
+	testType.equal<$ExtractProcessedString<Capitalize<`${''}`>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${'b'}`>>, 'B'>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${boolean}`>>, `True` | `False`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${true}`>>, `True`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${false}`>>, `False`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${1}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${1.1}`>>, `1.1`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${1e99}`>>, `1e+99`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${-1}`>>, `-1`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${1n}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${null}`>>, `Null`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${undefined}`>>, `Undefined`>(true)
+
+	testType.equal<$ExtractProcessedString<Capitalize<`${number}`>>, `${number}`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${string}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${bigint}`>>, `${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<Capitalize<`a${number}`>>, `A${number}`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`a${string}`>>, `A${string}`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`a${bigint}`>>, `A${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<Capitalize<`${number}c`>>, `${Capitalize<`${number}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${string}c`>>, `${Capitalize<`${string}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${bigint}c`>>, `${Capitalize<`${bigint}`>}c`>(true)
+
+	testType.equal<$ExtractProcessedString<Capitalize<`a${number}c`>>, `A${number}c`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`a${string}c`>>, `A${string}c`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`a${bigint}c`>>, `A${bigint}c`>(true)
+
+	testType.equal<`${number | string | bigint}`, string>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${number | string | bigint}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${number | bigint}`>>, `${number | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`a${number | string | bigint}`>>, `A${number | string | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`${number | string | bigint}c`>>, `${Capitalize<`${number | string | bigint}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Capitalize<`a${number | string | bigint}c`>>, `A${number | string | bigint}c`>(true)
+})
+
+it('unwraps T in Uncapitalize', () => {
+	testType.equal<$ExtractProcessedString<Uncapitalize<string>>, string>(true)
+
+	testType.equal<$ExtractProcessedString<Uncapitalize<''>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<'ABC'>>, 'aBC'>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<'HELLO WORLD'>>, 'hELLO WORLD'>(true)
+
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${''}`>>, ''>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${'b'}`>>, 'b'>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${boolean}`>>, `true` | `false`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${true}`>>, `true`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${false}`>>, `false`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${1}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${1.1}`>>, `1.1`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${1e99}`>>, `1e+99`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${-1}`>>, `-1`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${1n}`>>, `1`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${null}`>>, `null`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${undefined}`>>, `undefined`>(true)
+
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${number}`>>, `${number}`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${string}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${bigint}`>>, `${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${number}`>>, `a${number}`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${string}`>>, `a${string}`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${bigint}`>>, `a${bigint}`>(true)
+
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${number}c`>>, `${Uncapitalize<`${number}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${string}c`>>, `${Uncapitalize<`${string}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${bigint}c`>>, `${Uncapitalize<`${bigint}`>}c`>(true)
+
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${number}c`>>, `a${number}c`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${string}c`>>, `a${string}c`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${bigint}c`>>, `a${bigint}c`>(true)
+
+	testType.equal<`${number | string | bigint}`, string>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${number | string | bigint}`>>, string>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${number | bigint}`>>, `${number | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${number | string | bigint}`>>, `a${number | string | bigint}`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`${number | string | bigint}c`>>, `${Uncapitalize<`${number | string | bigint}`>}c`>(true)
+	testType.equal<$ExtractProcessedString<Uncapitalize<`a${number | string | bigint}c`>>, `a${number | string | bigint}c`>(true)
+})
+
+it('unwraps nested T', () => {
+	testType.equal<$ExtractProcessedString<Uppercase<Lowercase<Capitalize<Uncapitalize<'ABC'>>>>>, 'ABC'>(true)
+
+	testType.equal<$ExtractProcessedString<Uppercase<Lowercase<Capitalize<Uncapitalize<`${number}`>>>>>, `${number}`>(true)
+	testType.equal<$ExtractProcessedString<Uppercase<Lowercase<Capitalize<Uncapitalize<`a${number}`>>>>>, `A${Uppercase<Lowercase<`${number}`>>}`>(true)
+})
diff --git a/type-plus/ts/string/$extract_processed_string.ts b/type-plus/ts/string/$extract_processed_string.ts
new file mode 100644
index 0000000000..1fe7f0c4f3
--- /dev/null
+++ b/type-plus/ts/string/$extract_processed_string.ts
@@ -0,0 +1,45 @@
+/**
+ * 🧰 *type util*
+ *
+ * Extract the processed string from any of the intrinsic string manipulation types:
+ *
+ * - `Uppercase`
+ * - `Lowercase`
+ * - `Capitalize`
+ * - `Uncapitalize`
+ */
+export type $ExtractProcessedString<T extends string> =
+	([T, unknown] extends [unknown, T]
+		? T
+		: $ExtractProcessedString._UpperOrElse<T,
+			$ExtractProcessedString._LowerOrElse<T,
+				$ExtractProcessedString._CapOrElse<T,
+					$ExtractProcessedString._UncapOrElse<T, T>>>>
+	)
+
+export namespace $ExtractProcessedString {
+	export type _UpperOrElse<N, Else> = N extends Uppercase<infer Y>
+		? (string extends Y
+			? Uppercase<any> extends N ? Y : N
+			: $ExtractProcessedString<Y>
+		)
+		: Else
+	export type _LowerOrElse<N, Else> = N extends Lowercase<infer Y>
+		? (string extends Y
+			? Lowercase<any> extends N ? Y : N
+			: $ExtractProcessedString<Y>
+		)
+		: Else
+	export type _CapOrElse<N, Else> = N extends Capitalize<infer Y>
+		? (string extends Y
+			? Capitalize<any> extends N ? Y : N
+			: $ExtractProcessedString<Y>
+		)
+		: Else
+	export type _UncapOrElse<N, Else> = N extends Uncapitalize<infer Y>
+		? (string extends Y
+			? Uncapitalize<any> extends N ? Y : N
+			: $ExtractProcessedString<Y>
+		)
+		: Else
+}
diff --git a/type-plus/ts/string/is_string.ts b/type-plus/ts/string/is_string.ts
index c424ae06ab..ae679cce06 100644
--- a/type-plus/ts/string/is_string.ts
+++ b/type-plus/ts/string/is_string.ts
@@ -7,7 +7,6 @@ import type { $Exact } from '../type_plus/branch/$exact.js'
 import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
 import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
 import type { $Else, $Then } from '../type_plus/branch/$selection.js'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
 
 /**
  * 🎭 *predicate*
@@ -86,7 +85,7 @@ export namespace IsString {
 
 	export type $UtilOptions = Assignable.$UtilOptions & $Exact.$Options
 
-	export type _D<T, $O extends $SelectionOptions> =
+	export type _D<T, $O extends $UtilOptions> =
 		T extends string & infer U
 		? (
 			U extends string
@@ -94,7 +93,7 @@ export namespace IsString {
 			: $ResolveBranch<T, $O, [$Then]>
 		)
 		: $ResolveBranch<T, $O, [$Else]>
-	export type _N<T, $O extends $SelectionOptions> =
+	export type _N<T, $O extends $UtilOptions> =
 		[T] extends [string & infer U] ?
 		U extends string ? $ResolveBranch<T, $O, [$Else]>
 		: $ResolveBranch<T, $O, [$Then]>
diff --git a/type-plus/ts/string/is_string_literal.spec.ts b/type-plus/ts/string/is_string_literal.spec.ts
new file mode 100644
index 0000000000..dd0d6cfdb5
--- /dev/null
+++ b/type-plus/ts/string/is_string_literal.spec.ts
@@ -0,0 +1,896 @@
+import { describe, it } from '@jest/globals'
+
+import { testType, type $Else, type $Then, type IsStringLiteral } from '../index.js'
+
+it('returns false for string', () => {
+	testType.false<IsStringLiteral<string>>(true)
+	testType.equal<`${string}`, string>(true)
+	testType.false<IsStringLiteral<`${string}`>>(true)
+})
+
+it('returns true if T is a string literal', () => {
+	testType.true<IsStringLiteral<''>>(true)
+	testType.true<IsStringLiteral<'a'>>(true)
+})
+
+it('returns true if T is a template string literal', () => {
+	testType.true<IsStringLiteral<`${''}`>>(true)
+	testType.true<IsStringLiteral<`${'b'}`>>(true)
+	testType.true<IsStringLiteral<`${boolean}`>>(true)
+	testType.true<IsStringLiteral<`${true}`>>(true)
+	testType.true<IsStringLiteral<`${false}`>>(true)
+	testType.true<IsStringLiteral<`${number}`>>(true)
+	testType.true<IsStringLiteral<`${1}`>>(true)
+	testType.true<IsStringLiteral<`${1.1}`>>(true)
+	testType.true<IsStringLiteral<`${-1}`>>(true)
+	testType.true<IsStringLiteral<`${bigint}`>>(true)
+	testType.true<IsStringLiteral<`${1n}`>>(true)
+	testType.true<IsStringLiteral<`${null}`>>(true)
+	testType.true<IsStringLiteral<`${undefined}`>>(true)
+
+	testType.true<IsStringLiteral<`a${'b'}`>>(true)
+	testType.true<IsStringLiteral<`a${boolean}`>>(true)
+	testType.true<IsStringLiteral<`a${true}`>>(true)
+	testType.true<IsStringLiteral<`a${false}`>>(true)
+	testType.true<IsStringLiteral<`a${number}`>>(true)
+	testType.true<IsStringLiteral<`a${1}`>>(true)
+	testType.true<IsStringLiteral<`a${1.1}`>>(true)
+	testType.true<IsStringLiteral<`a${-1}`>>(true)
+	testType.true<IsStringLiteral<`a${string}`>>(true)
+	testType.true<IsStringLiteral<`a${bigint}`>>(true)
+	testType.true<IsStringLiteral<`a${1n}`>>(true)
+	testType.true<IsStringLiteral<`a${null}`>>(true)
+	testType.true<IsStringLiteral<`a${undefined}`>>(true)
+
+	testType.true<IsStringLiteral<`${'b'}c`>>(true)
+	testType.true<IsStringLiteral<`${boolean}c`>>(true)
+	testType.true<IsStringLiteral<`${true}c`>>(true)
+	testType.true<IsStringLiteral<`${false}c`>>(true)
+	testType.true<IsStringLiteral<`${number}c`>>(true)
+	testType.true<IsStringLiteral<`${1}c`>>(true)
+	testType.true<IsStringLiteral<`${1.1}c`>>(true)
+	testType.true<IsStringLiteral<`${-1}c`>>(true)
+	testType.true<IsStringLiteral<`${string}c`>>(true)
+	testType.true<IsStringLiteral<`${bigint}c`>>(true)
+	testType.true<IsStringLiteral<`${1n}c`>>(true)
+	testType.true<IsStringLiteral<`${null}c`>>(true)
+	testType.true<IsStringLiteral<`${undefined}c`>>(true)
+
+	testType.true<IsStringLiteral<`a${'b'}c`>>(true)
+	testType.true<IsStringLiteral<`a${boolean}c`>>(true)
+	testType.true<IsStringLiteral<`a${true}c`>>(true)
+	testType.true<IsStringLiteral<`a${false}c`>>(true)
+	testType.true<IsStringLiteral<`a${number}c`>>(true)
+	testType.true<IsStringLiteral<`a${1}c`>>(true)
+	testType.true<IsStringLiteral<`a${1.1}c`>>(true)
+	testType.true<IsStringLiteral<`a${-1}c`>>(true)
+	testType.true<IsStringLiteral<`a${string}c`>>(true)
+	testType.true<IsStringLiteral<`a${bigint}c`>>(true)
+	testType.true<IsStringLiteral<`a${1n}c`>>(true)
+	testType.true<IsStringLiteral<`a${null}c`>>(true)
+	testType.true<IsStringLiteral<`a${undefined}c`>>(true)
+})
+
+it('returns true for Uppercase string literal', () => {
+	testType.true<IsStringLiteral<Uppercase<'abc'>>>(true)
+	testType.true<IsStringLiteral<Uppercase<'foo'>>>(true)
+})
+
+it('returns true for Uppercase template string literal', () => {
+	testType.true<IsStringLiteral<Uppercase<`${''}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${'b'}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${boolean}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${true}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${false}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${number}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${1}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${1.1}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${-1}`>>>(true)
+	testType.false<IsStringLiteral<Uppercase<`${string}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${bigint}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${1n}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${null}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${undefined}`>>>(true)
+
+	testType.true<IsStringLiteral<Uppercase<`a${'b'}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${boolean}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${true}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${false}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${number}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${1}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${1.1}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${-1}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${string}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${bigint}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${1n}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${null}`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`a${undefined}`>>>(true)
+
+	testType.true<IsStringLiteral<Uppercase<`${'b'}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${boolean}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${true}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${false}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${number}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${1}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${1.1}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${-1}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${string}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${bigint}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${1n}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${null}c`>>>(true)
+	testType.true<IsStringLiteral<Uppercase<`${undefined}c`>>>(true)
+})
+
+it('returns false for Uppercase string', () => {
+	testType.false<IsStringLiteral<Uppercase<string>>>(true)
+	testType.false<IsStringLiteral<Uppercase<Uppercase<string>>>>(true)
+	testType.false<IsStringLiteral<Uppercase<Lowercase<string>>>>(true)
+	testType.false<IsStringLiteral<Uppercase<Uppercase<Lowercase<string>>>>>(true)
+	testType.false<IsStringLiteral<Uppercase<Lowercase<Uppercase<string>>>>>(true)
+})
+
+it('returns true for Lowercase string literal', () => {
+	testType.true<IsStringLiteral<Lowercase<'abc'>>>(true)
+	testType.true<IsStringLiteral<Lowercase<'foo'>>>(true)
+})
+
+it('returns true for Lowercase template string literal', () => {
+	testType.true<IsStringLiteral<Lowercase<`${''}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${'b'}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${boolean}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${true}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${false}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${number}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${1}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${1.1}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${-1}`>>>(true)
+	testType.false<IsStringLiteral<Lowercase<`${string}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${bigint}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${1n}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${null}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${undefined}`>>>(true)
+
+	testType.true<IsStringLiteral<Lowercase<`a${'b'}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${boolean}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${true}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${false}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${number}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${1}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${1.1}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${-1}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${string}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${bigint}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${1n}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${null}`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`a${undefined}`>>>(true)
+
+	testType.true<IsStringLiteral<Lowercase<`${'b'}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${boolean}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${true}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${false}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${number}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${1}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${1.1}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${-1}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${string}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${bigint}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${1n}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${null}c`>>>(true)
+	testType.true<IsStringLiteral<Lowercase<`${undefined}c`>>>(true)
+})
+
+it('returns false for Lowercase string', () => {
+	testType.false<IsStringLiteral<Lowercase<string>>>(true)
+	testType.false<IsStringLiteral<Lowercase<Lowercase<string>>>>(true)
+	testType.false<IsStringLiteral<Lowercase<Uppercase<string>>>>(true)
+	testType.false<IsStringLiteral<Lowercase<Lowercase<Uppercase<string>>>>>(true)
+	testType.false<IsStringLiteral<Lowercase<Uppercase<Lowercase<string>>>>>(true)
+})
+
+it('returns false for special types', () => {
+	testType.false<IsStringLiteral<void>>(true)
+	testType.false<IsStringLiteral<unknown>>(true)
+	testType.false<IsStringLiteral<any>>(true)
+	testType.false<IsStringLiteral<never>>(true)
+})
+
+it('returns false for all other types', () => {
+	testType.false<IsStringLiteral<undefined>>(true)
+	testType.false<IsStringLiteral<null>>(true)
+	testType.false<IsStringLiteral<boolean>>(true)
+	testType.false<IsStringLiteral<true>>(true)
+	testType.false<IsStringLiteral<false>>(true)
+	testType.false<IsStringLiteral<number>>(true)
+	testType.false<IsStringLiteral<-1>>(true)
+	testType.false<IsStringLiteral<0>>(true)
+	testType.false<IsStringLiteral<1>>(true)
+	testType.false<IsStringLiteral<1.1>>(true)
+	testType.false<IsStringLiteral<string>>(true)
+	testType.false<IsStringLiteral<bigint>>(true)
+	testType.false<IsStringLiteral<-1n>>(true)
+	testType.false<IsStringLiteral<0n>>(true)
+	testType.false<IsStringLiteral<1n>>(true)
+	testType.false<IsStringLiteral<symbol>>(true)
+	testType.false<IsStringLiteral<{}>>(true)
+	testType.false<IsStringLiteral<string[]>>(true)
+	testType.false<IsStringLiteral<[]>>(true)
+	testType.false<IsStringLiteral<Function>>(true)
+	testType.false<IsStringLiteral<() => void>>(true)
+})
+
+it('distributes over union type', () => {
+	testType.equal<IsStringLiteral<string | number>, false>(true)
+	testType.equal<IsStringLiteral<'a' | number>, boolean>(true)
+})
+
+it('works with intersection type', () => {
+	testType.equal<IsStringLiteral<string & { a: 1 }>, false>(true)
+	testType.equal<IsStringLiteral<string & { a: 1 }, { distributive: false }>, false>(true)
+	testType.equal<IsStringLiteral<'' & { a: 1 }>, true>(true)
+	testType.equal<IsStringLiteral<'' & { a: 1 }, { distributive: false }>, true>(true)
+})
+
+describe('disable distribution', () => {
+	it('returns false for string', () => {
+		testType.false<IsStringLiteral<string, { distributive: false }>>(true)
+	})
+
+	it('returns true if T is a string literal', () => {
+		testType.true<IsStringLiteral<'', { distributive: false }>>(true)
+		testType.true<IsStringLiteral<'a', { distributive: false }>>(true)
+	})
+
+	it('returns true if T is a template string literal', () => {
+		testType.true<IsStringLiteral<`${''}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${'b'}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${boolean}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${true}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${false}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${number}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${1}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${1.1}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${-1}`, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<`${string}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${bigint}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${1n}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${null}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${undefined}`, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<`a${'b'}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${boolean}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${true}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${false}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${number}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${1}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${1.1}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${-1}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${string}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${bigint}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${1n}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${null}`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${undefined}`, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<`${'b'}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${boolean}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${true}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${false}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${number}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${1}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${1.1}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${-1}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${string}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${bigint}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${1n}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${null}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`${undefined}c`, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<`a${'b'}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${boolean}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${true}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${false}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${number}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${1}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${1.1}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${-1}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${string}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${bigint}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${1n}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${null}c`, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<`a${undefined}c`, { distributive: false }>>(true)
+	})
+
+	it('returns true for Uppercase string literal', () => {
+		testType.true<IsStringLiteral<Uppercase<'abc'>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<'foo'>, { distributive: false }>>(true)
+	})
+
+	it('returns true for Uppercase template string literal', () => {
+		testType.true<IsStringLiteral<Uppercase<`${''}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${'b'}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${boolean}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${true}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${false}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${number}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${1.1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${-1}`>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Uppercase<`${string}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${bigint}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${1n}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${null}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${undefined}`>, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<Uppercase<`a${'b'}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${boolean}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${true}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${false}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${number}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${1.1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${-1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${string}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${bigint}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${1n}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${null}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${undefined}`>, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<Uppercase<`${'b'}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${boolean}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${true}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${false}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${number}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${1.1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${-1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${string}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${bigint}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${1n}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${null}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`${undefined}c`>, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<Uppercase<`a${'b'}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${boolean}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${true}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${false}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${number}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${1.1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${-1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${string}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${bigint}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${1n}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${null}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Uppercase<`a${undefined}c`>, { distributive: false }>>(true)
+	})
+
+	it('returns false for Uppercase string', () => {
+		testType.false<IsStringLiteral<Uppercase<string>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Uppercase<string>>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Lowercase<string>>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Uppercase<Lowercase<string>>>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Lowercase<Uppercase<string>>>, { distributive: false }>>(true)
+	})
+
+	it('returns true for Lowercase string literal', () => {
+		testType.true<IsStringLiteral<Lowercase<'abc'>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<'foo'>, { distributive: false }>>(true)
+	})
+
+	it('returns true for Lowercase template string literal', () => {
+		testType.true<IsStringLiteral<Lowercase<`${'b'}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${boolean}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${true}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${false}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${number}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${1.1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${-1}`>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Lowercase<`${string}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${bigint}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${1n}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${null}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${undefined}`>, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<Lowercase<`a${'b'}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${boolean}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${true}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${false}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${number}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${1.1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${-1}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${string}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${bigint}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${1n}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${null}`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${undefined}`>, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<Lowercase<`${'b'}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${boolean}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${true}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${false}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${number}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${1.1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${-1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${string}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${bigint}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${1n}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${null}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${undefined}c`>, { distributive: false }>>(true)
+
+		testType.true<IsStringLiteral<Lowercase<`a${'b'}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${boolean}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${true}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${false}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${number}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${1.1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${-1}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${string}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${bigint}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${1n}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${null}c`>, { distributive: false }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`a${undefined}c`>, { distributive: false }>>(true)
+	})
+
+	it('returns false for Lowercase string', () => {
+		testType.false<IsStringLiteral<Lowercase<string>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Lowercase<string>>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Uppercase<string>>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Lowercase<Uppercase<string>>>, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Uppercase<Lowercase<string>>>, { distributive: false }>>(true)
+	})
+
+	it('returns false for special types', () => {
+		testType.false<IsStringLiteral<void, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<unknown, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<any, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<never, { distributive: false }>>(true)
+	})
+
+	it('returns false for all other types', () => {
+		testType.false<IsStringLiteral<undefined, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<null, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<boolean, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<true, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<false, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<number, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<-1, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<0, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<1, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<1.1, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<string, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<bigint, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<-1n, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<0n, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<1n, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<symbol, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<{}, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<string[], { distributive: false }>>(true)
+		testType.false<IsStringLiteral<[], { distributive: false }>>(true)
+		testType.false<IsStringLiteral<Function, { distributive: false }>>(true)
+		testType.false<IsStringLiteral<() => void, { distributive: false }>>(true)
+	})
+
+	it('over union', () => {
+		testType.equal<IsStringLiteral<'a' | number, { distributive: false }>, false>(true)
+	})
+})
+
+it('works as filter', () => {
+	testType.equal<IsStringLiteral<string, { selection: 'filter' }>, never>(true)
+	testType.equal<IsStringLiteral<'', { selection: 'filter' }>, ''>(true)
+
+	testType.equal<IsStringLiteral<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsStringLiteral<unknown, { selection: 'filter' }>, never>(true)
+	testType.equal<IsStringLiteral<string | number, { selection: 'filter' }>, never>(true)
+
+	testType.equal<IsStringLiteral<'' | 1, { selection: 'filter' }>, ''>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsStringLiteral<string, IsStringLiteral.$Branch>, $Else>(true)
+	testType.equal<IsStringLiteral<'a', IsStringLiteral.$Branch>, $Then>(true)
+	testType.equal<IsStringLiteral<'a', { $then: String, $else: never }>, String>(true)
+
+	testType.equal<IsStringLiteral<any, IsStringLiteral.$Branch>, $Else>(true)
+	testType.equal<IsStringLiteral<unknown, IsStringLiteral.$Branch>, $Else>(true)
+	testType.equal<IsStringLiteral<never, IsStringLiteral.$Branch>, $Else>(true)
+	testType.equal<IsStringLiteral<void, IsStringLiteral.$Branch>, $Else>(true)
+})
+
+it('can override $any branch', () => {
+	testType.equal<IsStringLiteral<any>, false>(true)
+	testType.equal<IsStringLiteral<any, { $any: unknown }>, unknown>(true)
+})
+
+it('can override $unknown branch', () => {
+	testType.equal<IsStringLiteral<unknown>, false>(true)
+	testType.equal<IsStringLiteral<unknown, { $unknown: unknown }>, unknown>(true)
+})
+
+it('can override $never branch', () => {
+	testType.equal<IsStringLiteral<never>, false>(true)
+	testType.equal<IsStringLiteral<never, { $never: unknown }>, unknown>(true)
+})
+
+describe('exact', () => {
+	it('returns false for string', () => {
+		testType.false<IsStringLiteral<string, { exact: true }>>(true)
+	})
+
+	it('returns true if T is a string literal', () => {
+		testType.true<IsStringLiteral<'', { exact: true }>>(true)
+		testType.true<IsStringLiteral<'a', { exact: true }>>(true)
+	})
+
+	it('returns true if T is a template string literal reducible to simple string literal', () => {
+		testType.true<IsStringLiteral<`${''}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${'b'}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${boolean}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${true}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${false}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${1}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${1.1}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${-1}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${1n}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${null}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${undefined}`, { exact: true }>>(true)
+
+		testType.true<IsStringLiteral<`a${'b'}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${boolean}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${true}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${false}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${1}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${1.1}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${-1}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${1n}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${null}`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${undefined}`, { exact: true }>>(true)
+
+		testType.true<IsStringLiteral<`${'b'}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${boolean}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${true}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${false}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${1}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${1.1}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${-1}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${1n}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${null}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`${undefined}c`, { exact: true }>>(true)
+
+		testType.true<IsStringLiteral<`a${'b'}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${boolean}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${true}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${false}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${1}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${1.1}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${-1}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${1n}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${null}c`, { exact: true }>>(true)
+		testType.true<IsStringLiteral<`a${undefined}c`, { exact: true }>>(true)
+	})
+
+	it('returns false if T is a non-reducible template string literal', () => {
+		testType.false<IsStringLiteral<`${number}`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`${string}`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`${bigint}`, { exact: true }>>(true)
+
+		testType.false<IsStringLiteral<`a${number}`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`a${string}`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`a${bigint}`, { exact: true }>>(true)
+
+		testType.false<IsStringLiteral<`${number}c`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`${string}c`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`${bigint}c`, { exact: true }>>(true)
+
+		testType.false<IsStringLiteral<`a${number}c`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`a${string}c`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`a${bigint}c`, { exact: true }>>(true)
+
+		testType.false<IsStringLiteral<`a${number | string | bigint}`, { exact: true }>>(true)
+		testType.false<IsStringLiteral<`${number | string | bigint}c`, { exact: true }>>(true)
+	})
+
+	it('returns true for Uppercase string literal', () => {
+		testType.true<IsStringLiteral<Uppercase<'abc'>, { exact: true }>>(true)
+		testType.true<IsStringLiteral<Lowercase<'abc'>, { exact: true }>>(true)
+	})
+
+	it('returns false for Uppercase or Lowercase string', () => {
+		testType.false<IsStringLiteral<Uppercase<string>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Uppercase<string>>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Lowercase<string>>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Uppercase<Lowercase<string>>>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Uppercase<Lowercase<Uppercase<string>>>, { exact: true }>>(true)
+
+		testType.false<IsStringLiteral<Lowercase<string>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Lowercase<string>>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Uppercase<string>>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Lowercase<Uppercase<string>>>, { exact: true }>>(true)
+		testType.false<IsStringLiteral<Lowercase<Uppercase<Lowercase<string>>>, { exact: true }>>(true)
+		})
+
+	it('returns true for intrinsic manipulative types with template string literal reducible to simple string literal', () => {
+		testType.true<IsStringLiteral<Uppercase<`${''}`>, { exact: true }>>(true)
+		testType.true<IsStringLiteral<Lowercase<`${'b'}`>, { exact: true }>>(true)
+		testType.true<IsStringLiteral<Capitalize<`${boolean}`>, { exact: true }>>(true)
+		testType.true<IsStringLiteral<Uncapitalize<`${true}`>, { exact: true }>>(true)
+	})
+
+	it('returns false for special types', () => {
+		testType.false<IsStringLiteral<void>>(true)
+		testType.false<IsStringLiteral<unknown>>(true)
+		testType.false<IsStringLiteral<any>>(true)
+		testType.false<IsStringLiteral<never>>(true)
+	})
+
+	it('returns false for all other types', () => {
+		testType.false<IsStringLiteral<undefined>>(true)
+		testType.false<IsStringLiteral<null>>(true)
+		testType.false<IsStringLiteral<boolean>>(true)
+		testType.false<IsStringLiteral<true>>(true)
+		testType.false<IsStringLiteral<false>>(true)
+		testType.false<IsStringLiteral<number>>(true)
+		testType.false<IsStringLiteral<-1>>(true)
+		testType.false<IsStringLiteral<0>>(true)
+		testType.false<IsStringLiteral<1>>(true)
+		testType.false<IsStringLiteral<1.1>>(true)
+		testType.false<IsStringLiteral<string>>(true)
+		testType.false<IsStringLiteral<bigint>>(true)
+		testType.false<IsStringLiteral<-1n>>(true)
+		testType.false<IsStringLiteral<0n>>(true)
+		testType.false<IsStringLiteral<1n>>(true)
+		testType.false<IsStringLiteral<symbol>>(true)
+		testType.false<IsStringLiteral<{}>>(true)
+		testType.false<IsStringLiteral<string[]>>(true)
+		testType.false<IsStringLiteral<[]>>(true)
+		testType.false<IsStringLiteral<Function>>(true)
+		testType.false<IsStringLiteral<() => void>>(true)
+	})
+
+	it('distributes over union type', () => {
+		testType.equal<IsStringLiteral<string | number>, false>(true)
+		testType.equal<IsStringLiteral<'a' | number>, boolean>(true)
+	})
+
+	it('works with intersection type', () => {
+		testType.equal<IsStringLiteral<string & { a: 1 }>, false>(true)
+		testType.equal<IsStringLiteral<string & { a: 1 }, { distributive: false }>, false>(true)
+		testType.equal<IsStringLiteral<'' & { a: 1 }>, true>(true)
+		testType.equal<IsStringLiteral<'' & { a: 1 }, { distributive: false }>, true>(true)
+	})
+
+	describe('disable distribution', () => {
+		it('returns false for string', () => {
+			testType.false<IsStringLiteral<string, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns true if T is a string literal', () => {
+			testType.true<IsStringLiteral<'', { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<'a', { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns true if T is a template string literal', () => {
+			testType.true<IsStringLiteral<`${''}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${'b'}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${boolean}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${true}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${false}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${number}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${1}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${1.1}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${-1}`, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<`${string}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${bigint}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${1n}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${null}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${undefined}`, { distributive: false, exact: true }>>(true)
+
+			testType.true<IsStringLiteral<`a${'b'}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${boolean}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${true}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${false}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${number}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${1}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${1.1}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${-1}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${string}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${bigint}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${1n}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${null}`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${undefined}`, { distributive: false, exact: true }>>(true)
+
+			testType.true<IsStringLiteral<`${'b'}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${boolean}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${true}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${false}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${number}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${1}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${1.1}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${-1}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${string}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${bigint}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${1n}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${null}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`${undefined}c`, { distributive: false, exact: true }>>(true)
+
+			testType.true<IsStringLiteral<`a${'b'}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${boolean}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${true}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${false}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${number}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${1}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${1.1}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${-1}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${string}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${bigint}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${1n}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${null}c`, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<`a${undefined}c`, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns true for Uppercase string literal', () => {
+			testType.true<IsStringLiteral<Uppercase<'abc'>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<'foo'>, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns true for Uppercase template string literal', () => {
+			testType.true<IsStringLiteral<Uppercase<`${''}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${'b'}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${boolean}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${true}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${false}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${number}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${1}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${1.1}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${-1}`>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Uppercase<`${string}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${bigint}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${1n}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${null}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${undefined}`>, { distributive: false, exact: true }>>(true)
+
+			testType.true<IsStringLiteral<Uppercase<`a${'b'}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${boolean}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${true}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${false}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${number}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${1}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${1.1}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${-1}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${string}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${bigint}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${1n}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${null}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${undefined}`>, { distributive: false, exact: true }>>(true)
+
+			testType.true<IsStringLiteral<Uppercase<`${'b'}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${boolean}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${true}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${false}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${number}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${1}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${1.1}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${-1}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${string}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${bigint}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${1n}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${null}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`${undefined}c`>, { distributive: false, exact: true }>>(true)
+
+			testType.true<IsStringLiteral<Uppercase<`a${'b'}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${boolean}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${true}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${false}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${number}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${1}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${1.1}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${-1}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${string}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${bigint}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${1n}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${null}c`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Uppercase<`a${undefined}c`>, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns false for Uppercase string', () => {
+			testType.false<IsStringLiteral<Uppercase<string>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Uppercase<Uppercase<string>>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Uppercase<Lowercase<string>>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Uppercase<Uppercase<Lowercase<string>>>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Uppercase<Lowercase<Uppercase<string>>>, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns true for Lowercase string literal', () => {
+			testType.true<IsStringLiteral<Lowercase<'abc'>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Lowercase<'foo'>, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns true for Lowercase template string literal', () => {
+			testType.true<IsStringLiteral<Lowercase<`${number}`>, { distributive: false, exact: true }>>(true)
+			testType.true<IsStringLiteral<Lowercase<`a${boolean}c`>, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns false for Lowercase string', () => {
+			testType.false<IsStringLiteral<Lowercase<string>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Lowercase<Lowercase<string>>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Lowercase<Uppercase<string>>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Lowercase<Lowercase<Uppercase<string>>>, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Lowercase<Uppercase<Lowercase<string>>>, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns false for special types', () => {
+			testType.false<IsStringLiteral<void, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<unknown, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<any, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<never, { distributive: false, exact: true }>>(true)
+		})
+
+		it('returns false for all other types', () => {
+			testType.false<IsStringLiteral<undefined, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<null, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<boolean, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<true, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<false, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<number, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<-1, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<0, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<1, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<1.1, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<string, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<bigint, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<-1n, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<0n, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<1n, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<symbol, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<{}, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<string[], { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<[], { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<Function, { distributive: false, exact: true }>>(true)
+			testType.false<IsStringLiteral<() => void, { distributive: false, exact: true }>>(true)
+		})
+
+		it('over union', () => {
+			testType.equal<IsStringLiteral<'a' | number, { distributive: false, exact: true }>, false>(true)
+		})
+	})
+
+	it('works as filter', () => {
+		testType.equal<IsStringLiteral<string, { selection: 'filter' }>, never>(true)
+		testType.equal<IsStringLiteral<'', { selection: 'filter' }>, ''>(true)
+
+		testType.equal<IsStringLiteral<never, { selection: 'filter' }>, never>(true)
+		testType.equal<IsStringLiteral<unknown, { selection: 'filter' }>, never>(true)
+		testType.equal<IsStringLiteral<string | number, { selection: 'filter' }>, never>(true)
+
+		testType.equal<IsStringLiteral<'' | 1, { selection: 'filter' }>, ''>(true)
+	})
+
+	it('works with unique branches', () => {
+		testType.equal<IsStringLiteral<string, IsStringLiteral.$Branch>, $Else>(true)
+		testType.equal<IsStringLiteral<'a', IsStringLiteral.$Branch>, $Then>(true)
+		testType.equal<IsStringLiteral<'a', { $then: String, $else: never }>, String>(true)
+
+		testType.equal<IsStringLiteral<any, IsStringLiteral.$Branch>, $Else>(true)
+		testType.equal<IsStringLiteral<unknown, IsStringLiteral.$Branch>, $Else>(true)
+		testType.equal<IsStringLiteral<never, IsStringLiteral.$Branch>, $Else>(true)
+		testType.equal<IsStringLiteral<void, IsStringLiteral.$Branch>, $Else>(true)
+	})
+
+	it('can override $any branch', () => {
+		testType.equal<IsStringLiteral<any>, false>(true)
+		testType.equal<IsStringLiteral<any, { $any: unknown }>, unknown>(true)
+	})
+
+	it('can override $unknown branch', () => {
+		testType.equal<IsStringLiteral<unknown>, false>(true)
+		testType.equal<IsStringLiteral<unknown, { $unknown: unknown }>, unknown>(true)
+	})
+
+	it('can override $never branch', () => {
+		testType.equal<IsStringLiteral<never>, false>(true)
+		testType.equal<IsStringLiteral<never, { $never: unknown }>, unknown>(true)
+	})
+})
diff --git a/type-plus/ts/string/is_string_literal.ts b/type-plus/ts/string/is_string_literal.ts
new file mode 100644
index 0000000000..715a5b80fb
--- /dev/null
+++ b/type-plus/ts/string/is_string_literal.ts
@@ -0,0 +1,128 @@
+import type { Assignable } from '../predicates/assignable.js'
+import type { $Equality } from '../type_plus/$equality.js'
+import type { $MergeOptions } from '../type_plus/$merge_options.js'
+import type { $ResolveOptions } from '../type_plus/$resolve_options.js'
+import type { $SpecialType } from '../type_plus/$special_type.js'
+import type { $Exact } from '../type_plus/branch/$exact.js'
+import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../type_plus/branch/$selection.js'
+import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
+import type { $ExtractProcessedString } from './$extract_processed_string.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is string literals.
+ *
+ * @example
+ * ```ts
+ * type R = IsStringLiteral<string> // false
+ * type R = IsStringLiteral<'a'> // true
+ *
+ * type R = IsStringLiteral<never> // false
+ * type R = IsStringLiteral<unknown> // false
+ * type R = IsStringLiteral<string | boolean> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is string literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsStringLiteral<string, { selection: 'filter' }> // never
+ * type R = IsStringLiteral<'a', { selection: 'filter' }> // 'a'
+ *
+ * type R = IsStringLiteral<never, { selection: 'filter' }> // never
+ * type R = IsStringLiteral<unknown, { selection: 'filter' }> // never
+ * type R = IsStringLiteral<string | boolean, { selection: 'filter' }> // string
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsStringLiteral<string | 1> // boolean
+ * type R = IsStringLiteral<string | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsStringLiteral<string, $IsStringLiteral.$Branch> // $Then
+ * type R = IsStringLiteral<bigint, $IsStringLiteral.$Branch> // $Else
+ * ```
+ */
+export type IsStringLiteral<T, $O extends IsStringLiteral.$Options = {}> =
+	$SpecialType<T,
+		$MergeOptions<$O,
+			{
+				$then: $ResolveBranch<T, $O, [$Else]>,
+				$else: IsStringLiteral.$<T, $O>
+			}
+		>
+	>
+
+export namespace IsStringLiteral {
+	export type $Options = $Equality.$Options & $Exact.$Options
+	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is string literals.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends $UtilOptions> =
+		$ResolveOptions<[$O['exact'], $Exact.$Default]> extends true
+		? $IsDistributive<$O, { $then: _ED<T, $O>, $else: _EN<T, $O> }>
+		: $IsDistributive<$O, { $then: _D<T, $O>, $else: _N<T, $O> }>
+
+	export type $UtilOptions = Assignable.$UtilOptions & $Exact.$Options
+
+	export type _ED<T, $O extends $SelectionOptions> =
+		T extends string
+		? ($ExtractProcessedString<`${T}`> extends infer K
+			? (string extends K
+				? $ResolveBranch<T, $O, [$Else]>
+				: (K extends string
+					? (Uppercase<K> extends Uppercase<Lowercase<K>>
+						? (Lowercase<K> extends Lowercase<Uppercase<K>>
+							? $ResolveBranch<T, $O, [$Then]>
+							: $ResolveBranch<T, $O, [$Else]>)
+						: $ResolveBranch<T, $O, [$Else]>)
+					: $ResolveBranch<T, $O, [$Else]>))
+			: never)
+		: $ResolveBranch<T, $O, [$Else]>
+	export type _EN<T, $O extends $SelectionOptions> =
+		_D<T, { $then: $Then, $else: $Else }> extends infer R
+		? $Then | $Else extends R
+		? $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<T, $O, [R]>
+		: never
+
+	export type _D<T, $O extends $SelectionOptions> =
+		T extends string & infer U ? _U<T, U, $O> : $ResolveBranch<T, $O, [$Else]>
+
+	export type _N<T, $O extends $SelectionOptions> =
+		[T] extends [string & infer U] ? _U<T, U, $O> : $ResolveBranch<T, $O, [$Else]>
+
+	export type _U<T, U, $O extends $SelectionOptions> =
+		U extends `${any}`
+		? $ResolveBranch<T, $O, [$Then]>
+		: (
+			U extends Uppercase<infer N>
+			? _D<N, $O>
+			: U extends Lowercase<infer N>
+			? _D<N, $O>
+			: $ResolveBranch<T, $O, [$Else]>
+		)
+
+}
diff --git a/type-plus/ts/string/is_template_literal.spec.ts b/type-plus/ts/string/is_template_literal.spec.ts
new file mode 100644
index 0000000000..1dce84a75c
--- /dev/null
+++ b/type-plus/ts/string/is_template_literal.spec.ts
@@ -0,0 +1,467 @@
+import { describe, it } from '@jest/globals'
+import { testType, type $Else, type IsTemplateLiteral } from '../index.js'
+
+it('returns false for string', () => {
+	testType.false<IsTemplateLiteral<string>>(true)
+})
+
+it('returns false if T is a string literal', () => {
+	testType.false<IsTemplateLiteral<''>>(true)
+	testType.false<IsTemplateLiteral<'a'>>(true)
+})
+
+it('returns true for template literal', () => {
+	testType.true<IsTemplateLiteral<`${number}`>>(true)
+	testType.false<IsTemplateLiteral<`${string}`>>(true)
+	testType.true<IsTemplateLiteral<`${bigint}`>>(true)
+
+	testType.true<IsTemplateLiteral<`a${number}`>>(true)
+	testType.true<IsTemplateLiteral<`a${string}`>>(true)
+	testType.true<IsTemplateLiteral<`a${bigint}`>>(true)
+
+	testType.true<IsTemplateLiteral<`${number}c`>>(true)
+	testType.true<IsTemplateLiteral<`${string}c`>>(true)
+	testType.true<IsTemplateLiteral<`${bigint}c`>>(true)
+
+	testType.true<IsTemplateLiteral<`a${number}c`>>(true)
+	testType.true<IsTemplateLiteral<`a${string}c`>>(true)
+	testType.true<IsTemplateLiteral<`a${bigint}c`>>(true)
+
+	testType.equal<`${number | string | bigint}`, string>(true)
+	testType.false<IsTemplateLiteral<`${number | string | bigint}`>>(true)
+	testType.true<IsTemplateLiteral<`a${number | string | bigint}`>>(true)
+	testType.true<IsTemplateLiteral<`${number | string | bigint}c`>>(true)
+})
+
+it('returns false if T can be reduced to a string literal', () => {
+	testType.false<IsTemplateLiteral<`${''}`>>(true)
+	testType.false<IsTemplateLiteral<`${'b'}`>>(true)
+	testType.false<IsTemplateLiteral<`${boolean}`>>(true)
+	testType.false<IsTemplateLiteral<`${true}`>>(true)
+	testType.false<IsTemplateLiteral<`${false}`>>(true)
+	testType.false<IsTemplateLiteral<`${1}`>>(true)
+	testType.false<IsTemplateLiteral<`${1.1}`>>(true)
+	testType.false<IsTemplateLiteral<`${-1}`>>(true)
+	testType.false<IsTemplateLiteral<`${1n}`>>(true)
+	testType.false<IsTemplateLiteral<`${null}`>>(true)
+	testType.false<IsTemplateLiteral<`${undefined}`>>(true)
+
+	testType.false<IsTemplateLiteral<`a${'b'}`>>(true)
+	testType.false<IsTemplateLiteral<`a${boolean}`>>(true)
+	testType.false<IsTemplateLiteral<`a${true}`>>(true)
+	testType.false<IsTemplateLiteral<`a${false}`>>(true)
+	testType.false<IsTemplateLiteral<`a${1}`>>(true)
+	testType.false<IsTemplateLiteral<`a${1.1}`>>(true)
+	testType.false<IsTemplateLiteral<`a${-1}`>>(true)
+	testType.false<IsTemplateLiteral<`a${1n}`>>(true)
+	testType.false<IsTemplateLiteral<`a${null}`>>(true)
+	testType.false<IsTemplateLiteral<`a${undefined}`>>(true)
+
+	testType.false<IsTemplateLiteral<`${'b'}c`>>(true)
+	testType.false<IsTemplateLiteral<`${boolean}c`>>(true)
+	testType.false<IsTemplateLiteral<`${true}c`>>(true)
+	testType.false<IsTemplateLiteral<`${false}c`>>(true)
+	testType.false<IsTemplateLiteral<`${1}c`>>(true)
+	testType.false<IsTemplateLiteral<`${1.1}c`>>(true)
+	testType.false<IsTemplateLiteral<`${-1}c`>>(true)
+	testType.false<IsTemplateLiteral<`${1n}c`>>(true)
+	testType.false<IsTemplateLiteral<`${null}c`>>(true)
+	testType.false<IsTemplateLiteral<`${undefined}c`>>(true)
+
+	testType.false<IsTemplateLiteral<`a${'b'}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${boolean}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${true}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${false}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${1}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${1.1}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${-1}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${1n}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${null}c`>>(true)
+	testType.false<IsTemplateLiteral<`a${undefined}c`>>(true)
+})
+
+it('returns false for Uppercase or Lowercase string', () => {
+	testType.false<IsTemplateLiteral<Uppercase<string>>>(true)
+	testType.false<IsTemplateLiteral<Uppercase<Uppercase<string>>>>(true)
+	testType.false<IsTemplateLiteral<Uppercase<Lowercase<string>>>>(true)
+	testType.false<IsTemplateLiteral<Uppercase<Uppercase<Lowercase<string>>>>>(true)
+	testType.false<IsTemplateLiteral<Uppercase<Lowercase<Uppercase<string>>>>>(true)
+
+	testType.false<IsTemplateLiteral<Lowercase<string>>>(true)
+	testType.false<IsTemplateLiteral<Lowercase<Lowercase<string>>>>(true)
+	testType.false<IsTemplateLiteral<Lowercase<Uppercase<string>>>>(true)
+	testType.false<IsTemplateLiteral<Lowercase<Lowercase<Uppercase<string>>>>>(true)
+	testType.false<IsTemplateLiteral<Lowercase<Uppercase<Lowercase<string>>>>>(true)
+})
+
+it('returns false for Uppercase or Lowercase string literal', () => {
+	testType.false<IsTemplateLiteral<Uppercase<'abc'>>>(true)
+	testType.false<IsTemplateLiteral<Uppercase<'foo'>>>(true)
+
+	testType.false<IsTemplateLiteral<Lowercase<'abc'>>>(true)
+	testType.false<IsTemplateLiteral<Lowercase<'foo'>>>(true)
+})
+
+it('returns true for intrinsic manipulative types with template literal', () => {
+	testType.true<IsTemplateLiteral<Uppercase<`${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Uppercase<`a${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`a${string}`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`a${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Uppercase<`${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Uppercase<`a${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`a${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<`a${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Lowercase<`${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Lowercase<`a${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`a${string}`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`a${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Lowercase<`${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Lowercase<`a${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`a${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Lowercase<`a${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Capitalize<`${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Capitalize<`a${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`a${string}`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`a${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Capitalize<`${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Capitalize<`.${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`a${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`a${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Capitalize<`a${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Uncapitalize<`a${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`a${string}`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`a${bigint}`>>>(true)
+
+	testType.true<IsTemplateLiteral<Uncapitalize<`${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`${bigint}c`>>>(true)
+
+	testType.true<IsTemplateLiteral<Uncapitalize<`.${number}`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`a${number}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`a${string}c`>>>(true)
+	testType.true<IsTemplateLiteral<Uncapitalize<`a${bigint}c`>>>(true)
+
+
+	testType.true<IsTemplateLiteral<Uppercase<Uppercase<`a${number}c`>>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<Lowercase<`a${number}c`>>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<Uppercase<Lowercase<`a${number}c`>>>>>(true)
+	testType.true<IsTemplateLiteral<Uppercase<Lowercase<Uppercase<`a${number}c`>>>>>(true)
+})
+
+it('returns false for special types', () => {
+	testType.false<IsTemplateLiteral<any>>(true)
+	testType.false<IsTemplateLiteral<unknown>>(true)
+	testType.false<IsTemplateLiteral<void>>(true)
+	testType.false<IsTemplateLiteral<never>>(true)
+})
+
+it('returns false for other types', () => {
+	testType.false<IsTemplateLiteral<undefined>>(true)
+	testType.false<IsTemplateLiteral<null>>(true)
+	testType.false<IsTemplateLiteral<boolean>>(true)
+	testType.false<IsTemplateLiteral<true>>(true)
+	testType.false<IsTemplateLiteral<false>>(true)
+	testType.false<IsTemplateLiteral<number>>(true)
+	testType.false<IsTemplateLiteral<1>>(true)
+	testType.false<IsTemplateLiteral<string>>(true)
+	testType.false<IsTemplateLiteral<symbol>>(true)
+	testType.false<IsTemplateLiteral<bigint>>(true)
+	testType.false<IsTemplateLiteral<1n>>(true)
+	testType.false<IsTemplateLiteral<{}>>(true)
+	testType.false<IsTemplateLiteral<string[]>>(true)
+	testType.false<IsTemplateLiteral<[]>>(true)
+	testType.false<IsTemplateLiteral<Function>>(true)
+	testType.false<IsTemplateLiteral<() => void>>(true)
+})
+
+it('distributes over union type', () => {
+	testType.equal<`${number}` | string, string>(true)
+	testType.equal<IsTemplateLiteral<`${number}` | string>, false>(true)
+	testType.equal<IsTemplateLiteral<`${number}` | number>, boolean>(true)
+	testType.equal<IsTemplateLiteral<`${number}` | 'abc'>, boolean>(true)
+	testType.equal<IsTemplateLiteral<`a${number}` | `${bigint}c`>, true>(true)
+	testType.equal<IsTemplateLiteral<`${boolean}` | `${null}`>, false>(true)
+
+	testType.equal<IsTemplateLiteral<Uppercase<`${number}`> | number>, boolean>(true)
+	testType.equal<IsTemplateLiteral<Lowercase<`${number}`> | 'abc'>, boolean>(true)
+	testType.equal<IsTemplateLiteral<Capitalize<`a${number}` | `${bigint}c`>>, true>(true)
+	testType.equal<IsTemplateLiteral<Uncapitalize<`${boolean}` | `${null}`>>, false>(true)
+})
+
+it('works with intersection type', () => {
+	testType.equal<IsTemplateLiteral<string & { a: 1 }>, false>(true)
+
+	testType.equal<IsTemplateLiteral<'' & { a: 1 }>, false>(true)
+	testType.equal<IsTemplateLiteral<'abc' & { a: 1 }>, false>(true)
+
+	testType.equal<IsTemplateLiteral<`${number}` & { a: 1 }>, true>(true)
+	testType.equal<IsTemplateLiteral<`${string}` & { a: 1 }>, false>(true)
+	testType.equal<IsTemplateLiteral<`${bigint}` & { a: 1 }>, true>(true)
+	testType.equal<IsTemplateLiteral<`a${number}` & { a: 1 }>, true>(true)
+	testType.equal<IsTemplateLiteral<`a${string}` & { a: 1 }>, true>(true)
+	testType.equal<IsTemplateLiteral<`a${bigint}` & { a: 1 }>, true>(true)
+
+	testType.equal<IsTemplateLiteral<Uppercase<``> & { a: 1 }>, false>(true)
+	testType.equal<IsTemplateLiteral<Uppercase<`${number}`> & { a: 1 }>, true>(true)
+
+	testType.equal<IsTemplateLiteral<Uppercase<`` & { a: 1 }>>, false>(true)
+	testType.equal<IsTemplateLiteral<Uppercase<`${number}` & { a: 1 }>>, true>(true)
+})
+
+describe('disable distribution', () => {
+	it('returns false for string', () => {
+		testType.false<IsTemplateLiteral<string, { distributive: false }>>(true)
+	})
+
+	it('returns false if T is a string literal', () => {
+		testType.false<IsTemplateLiteral<'', { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<'a', { distributive: false }>>(true)
+	})
+
+	it('returns true for template literal', () => {
+		testType.true<IsTemplateLiteral<`${number}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${string}`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`${bigint}`, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<`a${number}`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`a${string}`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`a${bigint}`, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<`${number}c`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`${string}c`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`${bigint}c`, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<`a${number}c`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`a${string}c`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`a${bigint}c`, { distributive: false }>>(true)
+
+		testType.equal<`${number | string | bigint}`, string>(true)
+		testType.false<IsTemplateLiteral<`${number | string | bigint}`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`a${number | string | bigint}`, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<`${number | string | bigint}c`, { distributive: false }>>(true)
+	})
+
+	it('returns false if T can be reduced to a string literal', () => {
+		testType.false<IsTemplateLiteral<`${''}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${'b'}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${boolean}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${true}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${false}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${1}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${1.1}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${-1}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${1n}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${null}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${undefined}`, { distributive: false }>>(true)
+
+		testType.false<IsTemplateLiteral<`a${'b'}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${boolean}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${true}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${false}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${1}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${1.1}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${-1}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${1n}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${null}`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${undefined}`, { distributive: false }>>(true)
+
+		testType.false<IsTemplateLiteral<`${'b'}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${boolean}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${true}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${false}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${1}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${1.1}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${-1}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${1n}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${null}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`${undefined}c`, { distributive: false }>>(true)
+
+		testType.false<IsTemplateLiteral<`a${'b'}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${boolean}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${true}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${false}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${1}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${1.1}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${-1}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${1n}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${null}c`, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<`a${undefined}c`, { distributive: false }>>(true)
+	})
+
+	it('returns false for Uppercase or Lowercase string', () => {
+		testType.false<IsTemplateLiteral<Uppercase<string>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Uppercase<Uppercase<string>>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Uppercase<Lowercase<string>>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Uppercase<Uppercase<Lowercase<string>>>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Uppercase<Lowercase<Uppercase<string>>>, { distributive: false }>>(true)
+
+		testType.false<IsTemplateLiteral<Lowercase<string>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Lowercase<Lowercase<string>>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Lowercase<Uppercase<string>>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Lowercase<Lowercase<Uppercase<string>>>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Lowercase<Uppercase<Lowercase<string>>>, { distributive: false }>>(true)
+	})
+
+	it('returns false for Uppercase or Lowercase string literal', () => {
+		testType.false<IsTemplateLiteral<Uppercase<'abc'>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Uppercase<'foo'>, { distributive: false }>>(true)
+
+		testType.false<IsTemplateLiteral<Lowercase<'abc'>, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Lowercase<'foo'>, { distributive: false }>>(true)
+	})
+
+	it('returns true for Uppercase or Lowercase template literal', () => {
+		testType.true<IsTemplateLiteral<Uppercase<`${number}`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`${bigint}`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Uppercase<`a${number}`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`a${string}`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`a${bigint}`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Uppercase<`${number}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`${string}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`${bigint}c`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Uppercase<`a${number}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`a${string}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<`a${bigint}c`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Lowercase<`${number}`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`${bigint}`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Lowercase<`a${number}`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`a${string}`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`a${bigint}`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Lowercase<`${number}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`${string}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`${bigint}c`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Lowercase<`a${number}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`a${string}c`>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Lowercase<`a${bigint}c`>, { distributive: false }>>(true)
+
+		testType.true<IsTemplateLiteral<Uppercase<Uppercase<`a${number}c`>>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<Lowercase<`a${number}c`>>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<Uppercase<Lowercase<`a${number}c`>>>, { distributive: false }>>(true)
+		testType.true<IsTemplateLiteral<Uppercase<Lowercase<Uppercase<`a${number}c`>>>, { distributive: false }>>(true)
+	})
+
+	it('returns false for special types', () => {
+		testType.false<IsTemplateLiteral<any, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<unknown, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<void, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<never, { distributive: false }>>(true)
+	})
+
+	it('returns false for other types', () => {
+		testType.false<IsTemplateLiteral<undefined, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<null, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<boolean, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<true, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<false, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<number, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<1, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<string, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<symbol, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<bigint, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<1n, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<{}, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<string[], { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<[], { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<Function, { distributive: false }>>(true)
+		testType.false<IsTemplateLiteral<() => void, { distributive: false }>>(true)
+	})
+
+	it('distribute is disabled', () => {
+		testType.equal<`${number}` | string, string>(true)
+		testType.equal<IsTemplateLiteral<`${number}` | string, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<`${number}` | number, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<`${number}` | 'abc', { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<`a${number}` | `${bigint}c`, { distributive: false }>, true>(true)
+		testType.equal<IsTemplateLiteral<`${boolean}` | `${null}`, { distributive: false }>, false>(true)
+
+		testType.equal<IsTemplateLiteral<Uppercase<`${number}`> | number, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<Lowercase<`${number}`> | 'abc', { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<Capitalize<`a${number}` | `${bigint}c`>, { distributive: false }>, true>(true)
+		testType.equal<IsTemplateLiteral<Uncapitalize<`${boolean}` | `${null}`>, { distributive: false }>, false>(true)
+	})
+
+	it('works with intersection type', () => {
+		testType.equal<IsTemplateLiteral<string & { a: 1 }, { distributive: false }>, false>(true)
+
+		testType.equal<IsTemplateLiteral<'' & { a: 1 }, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<'abc' & { a: 1 }, { distributive: false }>, false>(true)
+
+		testType.equal<IsTemplateLiteral<`${number}` & { a: 1 }, { distributive: false }>, true>(true)
+		testType.equal<IsTemplateLiteral<`${string}` & { a: 1 }, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<`${bigint}` & { a: 1 }, { distributive: false }>, true>(true)
+		testType.equal<IsTemplateLiteral<`a${number}` & { a: 1 }, { distributive: false }>, true>(true)
+		testType.equal<IsTemplateLiteral<`a${string}` & { a: 1 }, { distributive: false }>, true>(true)
+		testType.equal<IsTemplateLiteral<`a${bigint}` & { a: 1 }, { distributive: false }>, true>(true)
+
+		testType.equal<IsTemplateLiteral<Uppercase<``> & { a: 1 }, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<Uppercase<`${number}`> & { a: 1 }, { distributive: false }>, true>(true)
+
+		testType.equal<IsTemplateLiteral<Uppercase<`` & { a: 1 }>, { distributive: false }>, false>(true)
+		testType.equal<IsTemplateLiteral<Uppercase<`${number}` & { a: 1 }>, { distributive: false }>, true>(true)
+	})
+})
+
+it('works as filter', () => {
+	testType.equal<IsTemplateLiteral<string, { selection: 'filter' }>, never>(true)
+	testType.equal<IsTemplateLiteral<'', { selection: 'filter' }>, never>(true)
+	testType.equal<IsTemplateLiteral<`${number}`, { selection: 'filter' }>, `${number}`>(true)
+
+	testType.equal<IsTemplateLiteral<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsTemplateLiteral<unknown, { selection: 'filter' }>, never>(true)
+	testType.equal<IsTemplateLiteral<string | number, { selection: 'filter' }>, never>(true)
+	testType.equal<IsTemplateLiteral<`${number}` | number, { selection: 'filter' }>, `${number}`>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsTemplateLiteral<string, IsTemplateLiteral.$Branch>, $Else>(true)
+	testType.equal<IsTemplateLiteral<'a', IsTemplateLiteral.$Branch>, $Else>(true)
+	testType.equal<IsTemplateLiteral<`${number}`, { $then: String, $else: never }>, String>(true)
+
+	testType.equal<IsTemplateLiteral<any, IsTemplateLiteral.$Branch>, $Else>(true)
+	testType.equal<IsTemplateLiteral<unknown, IsTemplateLiteral.$Branch>, $Else>(true)
+	testType.equal<IsTemplateLiteral<never, IsTemplateLiteral.$Branch>, $Else>(true)
+	testType.equal<IsTemplateLiteral<void, IsTemplateLiteral.$Branch>, $Else>(true)
+})
+
+it('can override $any branch', () => {
+	testType.equal<IsTemplateLiteral<any>, false>(true)
+	testType.equal<IsTemplateLiteral<any, { $any: unknown }>, unknown>(true)
+})
+
+it('can override $unknown branch', () => {
+	testType.equal<IsTemplateLiteral<unknown>, false>(true)
+	testType.equal<IsTemplateLiteral<unknown, { $unknown: unknown }>, unknown>(true)
+})
+
+it('can override $never branch', () => {
+	testType.equal<IsTemplateLiteral<never>, false>(true)
+	testType.equal<IsTemplateLiteral<never, { $never: unknown }>, unknown>(true)
+})
diff --git a/type-plus/ts/string/is_template_literal.ts b/type-plus/ts/string/is_template_literal.ts
new file mode 100644
index 0000000000..4631e4050b
--- /dev/null
+++ b/type-plus/ts/string/is_template_literal.ts
@@ -0,0 +1,67 @@
+import type { Assignable } from '../predicates/assignable.js'
+import type { $Equality } from '../type_plus/$equality.js'
+import type { $MergeOptions } from '../type_plus/$merge_options.js'
+import type { $SpecialType } from '../type_plus/$special_type.js'
+import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
+import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../type_plus/branch/$selection.js'
+import type { $ExtractProcessedString } from './$extract_processed_string.js'
+
+export type IsTemplateLiteral<T, $O extends IsTemplateLiteral.$Options = {}> =
+	$SpecialType<T,
+		$MergeOptions<$O,
+			{
+				$then: $ResolveBranch<T, $O, [$Else]>,
+				$else: IsTemplateLiteral.$<T, $O>
+			}
+		>
+	>
+
+export namespace IsTemplateLiteral {
+	export type $Options = $Equality.$Options
+	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+
+	export type $UtilOptions = Assignable.$UtilOptions
+
+	export type $<T, $O extends $UtilOptions> =
+		$IsDistributive<$O, { $then: _D<T, $O>, $else: _N<T, $O> }>
+
+	type _D<T, $O extends $UtilOptions> =
+		T extends string
+		? ($ExtractProcessedString<`${T}`> extends infer K
+			? (string extends K
+				? $ResolveBranch<T, $O, [$Else]>
+				: (K extends string
+					? (Uppercase<K> extends Uppercase<Lowercase<K>>
+						? (Lowercase<K> extends Lowercase<Uppercase<K>>
+							? $ResolveBranch<T, $O, [$Else]>
+							: $ResolveBranch<T, $O, [$Then]>)
+						: $ResolveBranch<T, $O, [$Then]>)
+					: $ResolveBranch<T, $O, [$Else]>))
+			: never)
+		: $ResolveBranch<T, $O, [$Else]>
+
+	type _N<T, $O extends $UtilOptions> =
+		_D<T, { $then: $Then, $else: $Else }> extends infer R
+		? $Then | $Else extends R
+		? $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<T, $O, [R]>
+		: never
+	// [T] extends [string]
+	// ? ($ExtractProcessedString<`${T}`> extends infer K
+	// 	? ([string] extends [K]
+	// 		? $ResolveBranch<T, $O, [$Else]>
+	// 		: ([K] extends [string] //? Uppercase<Lowercase<K>>
+	// 			? (Uppercase<K> extends Uppercase<Lowercase<K>>
+	// 				? (Lowercase<K> extends Lowercase<Uppercase<K>>
+	// 					? $ResolveBranch<T, $O, [$Else]>
+	// 					: $ResolveBranch<T, $O, [$Then]>
+	// 					)
+	// 				: $ResolveBranch<T, $O, [$Then]>
+	// 				)
+	// 			: $ResolveBranch<T, $O, [$Else]>
+	// 		)
+	// 	)
+	// 	: never)
+	// : $ResolveBranch<T, $O, [$Else]>
+}
diff --git a/type-plus/ts/string/string_plus.ts b/type-plus/ts/string/string_plus.ts
index ed3e4bd9ef..d40334ca5b 100644
--- a/type-plus/ts/string/string_plus.ts
+++ b/type-plus/ts/string/string_plus.ts
@@ -30,4 +30,5 @@ export namespace StringPlus {
 	 * ```
 	 */
 	export type Split<Subject extends string, Seperator extends string> = StringSplit<Subject, Seperator>
+
 }