diff --git a/index.d.ts b/index.d.ts
index ee07d85a8..9af047a2f 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -39,6 +39,7 @@ export type {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './sour
 export type {UndefinedOnPartialDeep} from './source/undefined-on-partial-deep.d.ts';
 export type {ReadonlyDeep} from './source/readonly-deep.d.ts';
 export type {LiteralUnion} from './source/literal-union.d.ts';
+export type {ExtractLiterals} from './source/extract-literals.js';
 export type {Promisable} from './source/promisable.d.ts';
 export type {Arrayable} from './source/arrayable.d.ts';
 export type {Opaque, UnwrapOpaque, Tagged, GetTagMetadata, UnwrapTagged} from './source/tagged.d.ts';
@@ -122,6 +123,13 @@ export type {
 	IsBooleanLiteral,
 	IsSymbolLiteral,
 } from './source/is-literal.d.ts';
+export type {
+	IsPrimitive,
+	IsStringPrimitive,
+	IsNumericPrimitive,
+	IsBooleanPrimitive,
+	IsSymbolPrimitive,
+} from './source/is-primitive.d.ts';
 export type {IsAny} from './source/is-any.d.ts';
 export type {IfAny} from './source/if-any.d.ts';
 export type {IsNever} from './source/is-never.d.ts';
diff --git a/readme.md b/readme.md
index 3f04fef88..11b21d2fd 100644
--- a/readme.md
+++ b/readme.md
@@ -122,6 +122,7 @@ Click the type names for complete docs.
 - [`UndefinedOnPartialDeep`](source/undefined-on-partial-deep.d.ts) - Create a deep version of another type where all optional keys are set to also accept `undefined`.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
 - [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
+- [`ExtractLiterals`](source/literal-of.d.ts) - Creates a union of the literal members from a given union type, removing wide primitive or infinite types, and optionally specify the Strictness.
 - [`Tagged`](source/tagged.d.ts) - Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf). (This replaces the previous [`Opaque`](source/tagged.d.ts) type, which is now deprecated.)
 - [`UnwrapTagged`](source/tagged.d.ts) - Get the untagged portion of a tagged type created with `Tagged`. (This replaces the previous [`UnwrapOpaque`](source/tagged.d.ts) type, which is now deprecated.)
 - [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
@@ -189,10 +190,15 @@ Click the type names for complete docs.
 
 - [`If`](source/if.d.ts) - An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 - [`IsLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+- [`IsPrimitive`](source/is-primitive.d.ts) - Returns a boolean for whether the given type is strictly a [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
 - [`IsStringLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsNumericLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsBooleanLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsSymbolLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+- [`IsStringPrimitive`](source/is-primitive.d.ts) - Returns a boolean for whether the given type is strictly a `string` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+- [`IsNumericPrimitive`](source/is-primitive.d.ts) - Returns a boolean for whether the given type is strictly a `number` or `bigint` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+- [`IsBooleanPrimitive`](source/is-primitive.d.ts) - Returns a boolean for whether the given type is strictly a `true` or `false` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+- [`IsSymbolPrimitive`](source/is-primitive.d.ts) - Returns a boolean for whether the given type is strictly a `symbol` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
 - [`IsAny`](source/is-any.d.ts) - Returns a boolean for whether the given type is `any`.
 - [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`.
 - [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`.
diff --git a/source/extract-literals.d.ts b/source/extract-literals.d.ts
new file mode 100644
index 000000000..8fb2d5253
--- /dev/null
+++ b/source/extract-literals.d.ts
@@ -0,0 +1,97 @@
+import type {ApplyDefaultOptions} from './internal/object.js';
+import type {UnwrapTagged, TagContainer} from './tagged.js';
+import type {IsPrimitive} from './is-primitive.js';
+import type {IsLiteral} from './is-literal.js';
+import type {Primitive} from './primitive.js';
+import type {Not} from './internal/type.js';
+
+/**
+ExtactLiterals options.
+
+@see {@link ExtactLiterals}
+*/
+export type ExtractLiteralsOptions = {
+	/**
+	Whether to remove infinite signature types (e.g., `abc${string}`).
+
+	@default true
+	*/
+	strict?: boolean;
+};
+
+export type DefaultExtractLiteralsOptions = {
+	strict: true;
+};
+
+/**
+Creates a union of the literal members from a given union type, removing wide primitive or infinite types.
+
+This utility helps you extract only the literal members from a "literal union" type
+(e.g., `'foo' | 'bar' | string` becomes `'foo' | 'bar'`), saving you from defining separate types for literals and unions.
+
+It works with all primitive and tagged types, and supports two strictness modes:
+
+- **Strict mode (`Strict = true`)**: Removes any infinite signature type (e.g., `abc${string}`, `123${number}`).
+- **Non-strict mode (`Strict = false`)**: Removes only wide primitive types (e.g., `string`, `number`).
+
+@default true
+
+@example
+```ts
+import type { ExtractLiterals } from 'type-fest';
+
+// String example:
+type Pet = LiteralUnion<'dog' | 'cat' | `${string}Dog`, string>;
+//    ^? type Pet = 'dog' | 'cat' | `${string}Dog` | (string & {})
+type PetLiteralStrict = ExtractLiterals<Pet>;
+//    ^? type PetLiteralNonStrict = 'dog' | 'cat'
+type PetLiteralNonStrict = ExtractLiterals<Pet, false>;
+//    ^? type PetLiteralStrict = 'dog' | 'cat' | `${string}Dog`
+
+// Number example:
+type Nums = LiteralUnion<0 | 1 | 2, number>;
+//    ^? type Nums = 0 | 1 | 2 | (number & {})
+type NumsLiteral = ExtractLiterals<Nums>;
+//    ^? type NumsLiteral = 0 | 1 | 2
+
+// Symbol example:
+declare const sym1: unique symbol;
+declare const sym2: unique symbol;
+type Symbols = LiteralUnion<typeof sym1 | typeof sym2, symbol>;
+//    ^? type Symbols = typeof sym1 | typeof sym2 | (symbol & {})
+type SymbolsLiteral = ExtractLiterals<Symbols>;
+//    ^? type SymbolsLiteral = typeof sym1 | typeof sym2
+
+// BigInt example:
+type Big = LiteralUnion<1n | 2n, bigint>;
+//    ^? type Big = 1n | 2n | (bigint & {})
+type BigLiteral = ExtractLiterals<Big>;
+//    ^? type BigLiteral = 1n | 2n
+
+```
+
+@author benzaria
+@see LiteralUnion
+@category Type
+*/
+export type ExtractLiterals<
+	LiteralUnion extends Primitive,
+	Options extends ExtractLiteralsOptions = {},
+> = LiteralUnion extends infer Member
+	? ((
+		Member extends TagContainer<any>
+			? UnwrapTagged<Member>
+			: Member
+	) extends infer Type
+		? ApplyDefaultOptions<
+		ExtractLiteralsOptions,
+		DefaultExtractLiteralsOptions,
+		Options
+		>['strict'] extends true
+			? Not<IsLiteral<Type>>
+			: IsPrimitive<Type>
+		: never
+	) extends true
+		? never
+		: Member
+	: never;
diff --git a/source/internal/type.d.ts b/source/internal/type.d.ts
index 4325679f7..889da1596 100644
--- a/source/internal/type.d.ts
+++ b/source/internal/type.d.ts
@@ -1,7 +1,8 @@
-import type {If} from '../if.js';
-import type {IsAny} from '../is-any.d.ts';
-import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {IsAny} from '../is-any.d.ts';
+import type {And} from '../and.js';
+import type {If} from '../if.js';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -13,14 +14,24 @@ Matches non-recursive types.
 */
 export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 
+/**
+Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
+1. If either type is `never`, the result is `true` iff the other type is also `never`.
+2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends<string | number, number>` => `false | true` => `boolean`.
+*/
+export type Extends<Left, Right> = IsNever<Left> extends true ? IsNever<Right> : [Left] extends [Right] ? true : false;
+
 /**
 Returns a boolean for whether the two given types extends the base type.
 */
-export type IsBothExtends<BaseType, FirstType, SecondType> = FirstType extends BaseType
-	? SecondType extends BaseType
-		? true
-		: false
-	: false;
+export type IsBothExtends<BaseType, FirstType, SecondType> = (
+	IsNotFalse<
+	And<
+	Extends<FirstType, BaseType>,
+	Extends<SecondType, BaseType>
+	>
+	>
+);
 
 /**
 Test if the given function has multiple call signatures.
@@ -44,23 +55,6 @@ Returns a boolean for whether the given `boolean` is not `false`.
 */
 export type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
 
-/**
-Returns a boolean for whether the given type is primitive value or primitive type.
-
-@example
-```
-IsPrimitive<'string'>
-//=> true
-
-IsPrimitive<string>
-//=> true
-
-IsPrimitive<Object>
-//=> false
-```
-*/
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-
 /**
 Returns a boolean for whether A is false.
 
diff --git a/source/is-literal.d.ts b/source/is-literal.d.ts
index 1e97bf41b..e0c3c7511 100644
--- a/source/is-literal.d.ts
+++ b/source/is-literal.d.ts
@@ -1,8 +1,10 @@
+import type {Extends, IsNotFalse, Not} from './internal/type.d.ts';
+import type {CollapseLiterals} from './internal/object.d.ts';
+import type {TagContainer, UnwrapTagged} from './tagged.js';
 import type {Primitive} from './primitive.d.ts';
-import type {Numeric} from './numeric.d.ts';
-import type {CollapseLiterals, IfNotAnyOrNever, IsNotFalse, IsPrimitive} from './internal/index.d.ts';
 import type {IsNever} from './is-never.d.ts';
-import type {TagContainer, UnwrapTagged} from './tagged.js';
+import type {Numeric} from './numeric.d.ts';
+import type {And} from './and.js';
 
 /**
 Returns a boolean for whether the given type `T` is the specified `LiteralType`.
@@ -24,11 +26,10 @@ LiteralCheck<1, string>
 type LiteralCheck<T, LiteralType extends Primitive> = (
 	IsNever<T> extends false // Must be wider than `never`
 		? [T] extends [LiteralType & infer U] // Remove any branding
-			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
-				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
-					? false
-					: true
-				: false
+			? And<
+			Extends<U, LiteralType>, // Must be narrower than `LiteralType`
+			Not<Extends<LiteralType, U>> // Cannot be wider than `LiteralType`
+			>
 			: false
 		: false
 );
@@ -52,7 +53,8 @@ type LiteralChecks<T, LiteralUnionType> = (
 	// Conditional type to force union distribution.
 	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
 	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
-	IsNotFalse<LiteralUnionType extends Primitive
+	IsNotFalse<
+	LiteralUnionType extends Primitive
 		? LiteralCheck<T, LiteralUnionType>
 		: never
 	>
@@ -111,22 +113,24 @@ type L2 = Length<`${number}`>;
 //=> number
 ```
 
+@see IsStringPrimitive
 @category Type Guard
 @category Utilities
 */
-export type IsStringLiteral<S> = IfNotAnyOrNever<S,
-_IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>,
-false, false>;
-
-export type _IsStringLiteral<S> =
-// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
-// and since `{}` extends index signatures, the result becomes `false`.
-S extends string
-	? {} extends Record<S, never>
-		? false
-		: true
+export type IsStringLiteral<T> = IsNever<T> extends false
+	? _IsStringLiteral<CollapseLiterals<T extends TagContainer<any> ? UnwrapTagged<T> : T>>
 	: false;
 
+export type _IsStringLiteral<S> = (
+	// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+	// and since `{}` extends index signatures, the result becomes `false`.
+	S extends string
+		? {} extends Record<S, never>
+			? false
+			: true
+		: false
+);
+
 /**
 Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 
@@ -170,10 +174,13 @@ endsWith('abc123', end);
 //=> boolean
 ```
 
+@see IsNumericPrimitive
 @category Type Guard
 @category Utilities
 */
-export type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
+export type IsNumericLiteral<T> = T extends Numeric
+	? LiteralChecks<T, Numeric>
+	: false;
 
 /**
 Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
@@ -210,6 +217,7 @@ const eitherId = getId({asString: runtimeBoolean});
 //=> number | string
 ```
 
+@see IsBooleanPrimitive
 @category Type Guard
 @category Utilities
 */
@@ -245,6 +253,7 @@ get({[symbolValue]: 1} as const, symbolValue);
 //=> number
 ```
 
+@see IsSymbolPrimitive
 @category Type Guard
 @category Utilities
 */
@@ -291,10 +300,12 @@ stripLeading(str, 'abc');
 //=> string
 ```
 
+@see IsPrimitive
 @category Type Guard
 @category Utilities
 */
-export type IsLiteral<T> =
-	IsPrimitive<T> extends true
+export type IsLiteral<T> = (
+	Extends<T, Primitive> extends true
 		? IsNotFalse<IsLiteralUnion<T>>
-		: false;
+		: false
+);
diff --git a/source/is-primitive.d.ts b/source/is-primitive.d.ts
new file mode 100644
index 000000000..db99a3215
--- /dev/null
+++ b/source/is-primitive.d.ts
@@ -0,0 +1,192 @@
+import type {IsNotFalse, Extends} from './internal/type.js';
+import type {Primitive} from './primitive.js';
+import type {Numeric} from './numeric.js';
+import type {IsAny} from './is-any.js';
+import type {And} from './and.js';
+
+/**
+Returns a boolean for whether the given type `T` is the specified `PrimitiveType`.
+
+@example
+```
+type ex = PrimitiveCheck<number, number>
+//   ^? type ex = true
+
+type ex = PrimitiveCheck<1, number>
+//   ^? type ex = false
+
+type ex = PrimitiveCheck<(string & {}), string> // Because (string & {}) does not change the type string it just hide's it. See PrimitiveUnion
+//   ^? type ex = true
+```
+*/
+type PrimitiveCheck<T, PrimitiveType extends Primitive> = (
+	IsAny<T> extends false // Cannot be wider than `any`
+		? And<
+		Extends<T, PrimitiveType>, // Must be narrower than `PrimitiveType`
+		Extends<PrimitiveType, T> // Must be wider than `PrimitiveType`
+		>
+		: false
+);
+
+/**
+Returns a boolean for whether the given type `T` is one of the specified primitive types in `PrimitiveUnionType`.
+
+@example
+```
+type ex = PrimitiveChecks<number, Numeric>
+//   ^? type ex = true
+
+type ex = PrimitiveChecks<bigint, Numeric>
+//   ^? type ex = true
+
+type ex = PrimitiveChecks<string, Numeric>
+//   ^? type ex = false
+```
+*/
+type PrimitiveChecks<T, PrimitiveUnionType extends Primitive> = (
+	// Conditional type to force union distribution.
+	// If `T` is none of the primitive types in the union `PrimitiveUnionType`, then `PrimitiveCheck<T, PrimitiveType>` will evaluate to `false` for the whole union.
+	// If `T` is one of the primitive types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+	IsNotFalse<
+	PrimitiveUnionType extends Primitive
+		? PrimitiveCheck<T, PrimitiveUnionType>
+		: never
+	>
+);
+
+/**
+Returns a boolean for whether the given type is strictly a `string` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+
+@example
+```
+import type {IsStringPrimitive} from 'type-fest';
+
+type ex = IsStringPrimitive<string>
+//   ^? type ex = true
+
+type ex = IsStringPrimitive<(string & {})>
+//   ^? type ex = true
+
+type ex = IsStringPrimitive<`on${string}`>
+//   ^? type ex = false
+
+type ex = IsStringPrimitive<Capitalize<string>>
+//   ^? type ex = false
+
+```
+
+@see IsStringLiteral
+@category Type Guard
+@category Utilities
+*/
+export type IsStringPrimitive<T> = PrimitiveCheck<T, string>;
+
+/**
+Returns a boolean for whether the given type is strictly a `number` or `bigint` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+
+@example
+```
+type ex = IsNumericPrimitive<Numeric>
+//   ^? type ex = true
+
+type ex = IsNumericPrimitive<number>
+//   ^? type ex = true
+
+type ex = IsNumericPrimitive<bigint>
+//   ^? type ex = true
+
+type ex = IsNumericPrimitive<1>
+//   ^? type ex = false
+
+```
+
+@see IsNumericLiteral
+@category Type Guard
+@category Utilities
+*/
+export type IsNumericPrimitive<T> = T extends Numeric
+	? PrimitiveChecks<T, Numeric>
+	: false;
+
+/**
+Returns a boolean for whether the given type is strictly a `boolean` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+
+@example
+```
+import type {IsBooleanPrimitive} from 'type-fest';
+
+type ex = IsBooleanPrimitive<boolean>
+//   ^? type ex = true
+
+type ex = IsBooleanPrimitive<true | false>
+//   ^? type ex = true
+
+type ex = IsBooleanPrimitive<true>
+//   ^? type ex = false
+
+type ex = IsBooleanPrimitive<false>
+//   ^? type ex = false
+
+```
+
+@see IsBooleanLiteral
+@category Type Guard
+@category Utilities
+*/
+export type IsBooleanPrimitive<T> = PrimitiveCheck<T, boolean>;
+
+/**
+Returns a boolean for whether the given type is strictly a `symbol` [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+
+@example
+```
+type ex = IsSymbolPrimitive<symbol>
+//   ^? type ex = true
+
+type ex = IsSymbolPrimitive<typeof Symbol('foo')>
+//   ^? type ex = false
+
+```
+
+@see IsSymbolLiteral
+@category Type Guard
+@category Utilities
+*/
+export type IsSymbolPrimitive<T> = PrimitiveCheck<T, symbol>;
+
+/** Helper type for `IsPrimitive`. */
+type IsPrimitiveUnion<T> =
+	| IsStringPrimitive<T>
+	| IsNumericPrimitive<T>
+	| IsBooleanPrimitive<T>
+	| IsSymbolPrimitive<T>;
+
+/**
+Returns a boolean for whether the given type is strictly a [primitive type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean).
+
+@example
+```
+type ex = IsPrimitive<number>
+//   ^? type ex = true
+
+type ex = IsPrimitive<string>
+//   ^? type ex = true
+
+type ex = IsPrimitive<'string'>
+//   ^? type ex = false
+
+type ex = IsPrimitive<object>
+//   ^? type ex = false
+
+```
+
+@author benzaria
+@see IsLiteral
+@category Type Guard
+@category Utilities
+*/
+export type IsPrimitive<T> = (
+	Extends<T, Primitive> extends true
+		? IsNotFalse<IsPrimitiveUnion<T>>
+		: false
+);
diff --git a/test-d/extract-literals.ts b/test-d/extract-literals.ts
new file mode 100644
index 000000000..b67a7d1f3
--- /dev/null
+++ b/test-d/extract-literals.ts
@@ -0,0 +1,88 @@
+import {expectType} from 'tsd';
+import type {ExtractLiterals, LiteralUnion, IsEqual, Tagged} from '../index.js';
+
+// For Strings:
+
+type Events = 'hover' | 'click' | `click-${number}` | (string & {});
+//   ^?
+type EventsLiteralStrict = ExtractLiterals<Events>;
+//   ^?
+type EventsLiteralNonStrict = ExtractLiterals<Events, {strict: false}>;
+//   ^?
+
+expectType<IsEqual<'hover' | 'click' | `click-${number}`, EventsLiteralNonStrict>>(true);
+expectType<IsEqual<'hover' | 'click', EventsLiteralStrict>>(true);
+
+expectType<IsEqual<'hover' | 'click' | `click-${number}`, EventsLiteralStrict>>(false);
+expectType<IsEqual<'hover' | 'click', EventsLiteralNonStrict>>(false);
+
+// For Numbers:
+
+type Nums = LiteralUnion<0 | 1 | 2, number>;
+//   ^?
+type NumsLiteral = ExtractLiterals<Nums>;
+//   ^?
+
+expectType<IsEqual<0 | 1 | 2, NumsLiteral>>(true);
+expectType<IsEqual<0 | 1 | 2, Nums>>(false);
+
+// For Symbols:
+
+declare const symbol1: unique symbol;
+declare const symbol2: unique symbol;
+
+type Symbol1 = typeof symbol1;
+type Symbol2 = typeof symbol2;
+
+type Symbols = LiteralUnion<Symbol1 | Symbol2, symbol>;
+//   ^?
+type SymbolsLiteral = ExtractLiterals<Symbols>;
+//   ^?
+
+expectType<IsEqual<Symbol1 | Symbol2, SymbolsLiteral>>(true);
+expectType<IsEqual<Symbol1 | Symbol2, Symbols>>(false);
+
+// For Bigints:
+
+type Big = LiteralUnion<1n | 2n, bigint>;
+//   ^?
+type BigLiteral = ExtractLiterals<Big>;
+//   ^?
+
+expectType<IsEqual<1n | 2n, BigLiteral>>(true);
+expectType<IsEqual<1n | 2n, Big>>(false);
+
+// For Tagged types:
+
+type Animals = Tagged<'dog' | 'cat' | `${string}Dog`, 'alimals'>;
+type AnimalsStrict = Exclude<Animals, `${string}Dog`>;
+
+type TaggedUnion = LiteralUnion<Animals, string>;
+//   ^?
+type TaggedStrict = ExtractLiterals<TaggedUnion>;
+//   ^?
+type TaggedNonStrict = ExtractLiterals<TaggedUnion, {strict: false}>;
+//   ^?
+
+expectType<IsEqual<Animals, TaggedNonStrict>>(true);
+expectType<IsEqual<AnimalsStrict, TaggedStrict>>(true);
+
+expectType<IsEqual<Animals, TaggedUnion>>(false);
+expectType<IsEqual<AnimalsStrict, TaggedUnion>>(false);
+
+type _LiteralUnion = 'dog' | 'cat' | `${string}Dog`;
+type _Alimals = Tagged<_LiteralUnion, 'alimals'>;
+type _AlimalsStrict = Exclude<_Alimals, `${string}Dog`>;
+
+type _TaggedUnion = LiteralUnion<_Alimals, string>;
+//   ^?
+type _TaggedStrict = ExtractLiterals<_TaggedUnion>;
+//   ^?
+type _TaggedNonStrict = ExtractLiterals<_TaggedUnion, {strict: false}>;
+//   ^?
+
+expectType<IsEqual<_Alimals, _TaggedNonStrict>>(true);
+expectType<IsEqual<_AlimalsStrict, _TaggedStrict>>(true);
+
+expectType<IsEqual<_Alimals, _TaggedUnion>>(false);
+expectType<IsEqual<_AlimalsStrict, _TaggedUnion>>(false);
diff --git a/test-d/is-literal.ts b/test-d/is-literal.ts
index 9fb176033..b7d527a28 100644
--- a/test-d/is-literal.ts
+++ b/test-d/is-literal.ts
@@ -1,4 +1,5 @@
 import {expectType} from 'tsd';
+import type tag from 'tagged-tag';
 import type {
 	IsLiteral,
 	IsStringLiteral,
@@ -8,33 +9,30 @@ import type {
 	Tagged,
 	LiteralUnion,
 } from '../index.d.ts';
+import type {Numeric} from '../source/numeric.js';
 
-const stringLiteral = '';
-const numberLiteral = 1;
-// Note: tsd warns on direct literal usage so we cast to the literal type
-const bigintLiteral = BigInt(1) as 1n;
-const booleanLiteral = true;
-const symbolLiteral = Symbol('');
+type stringLiteral = 'aA';
+type numberLiteral = 1;
+type bigintLiteral = 1n;
+type booleanLiteral = true;
+type symbolLiteral = typeof tag;
+type numericLiteral = numberLiteral | bigintLiteral;
 
-declare const _string: string;
-declare const _number: number;
-declare const _bigint: bigint;
-declare const _boolean: boolean;
-declare const _symbol: symbol;
+declare const boolean: boolean;
 
 // Literals should be true
-expectType<IsLiteral<typeof stringLiteral>>(true);
-expectType<IsLiteral<typeof numberLiteral>>(true);
-expectType<IsLiteral<typeof bigintLiteral>>(true);
-expectType<IsLiteral<typeof booleanLiteral>>(true);
-expectType<IsLiteral<typeof symbolLiteral>>(true);
+expectType<IsLiteral<stringLiteral>>(true);
+expectType<IsLiteral<numberLiteral>>(true);
+expectType<IsLiteral<bigintLiteral>>(true);
+expectType<IsLiteral<booleanLiteral>>(true);
+expectType<IsLiteral<symbolLiteral>>(true);
 
 // Primitives should be false
-expectType<IsLiteral<typeof _string>>(false);
-expectType<IsLiteral<typeof _number>>(false);
-expectType<IsLiteral<typeof _bigint>>(false);
-expectType<IsLiteral<typeof _boolean>>(false);
-expectType<IsLiteral<typeof _symbol>>(false);
+expectType<IsLiteral<string>>(false);
+expectType<IsLiteral<number>>(false);
+expectType<IsLiteral<bigint>>(false);
+expectType<IsLiteral<boolean>>(false);
+expectType<IsLiteral<symbol>>(false);
 
 // Null, undefined, and non-primitives should fail all literal checks
 expectType<IsLiteral<null>>(false);
@@ -42,8 +40,8 @@ expectType<IsLiteral<undefined>>(false);
 expectType<IsLiteral<any>>(false);
 expectType<IsLiteral<never>>(false);
 
-expectType<IsStringLiteral<typeof stringLiteral>>(true);
-expectType<IsStringLiteral<typeof _string>>(false);
+expectType<IsStringLiteral<stringLiteral>>(true);
+expectType<IsStringLiteral<string>>(false);
 
 // Strings with infinite set of possible values return `false`
 expectType<IsStringLiteral<Uppercase<string>>>(false);
@@ -75,12 +73,20 @@ expectType<IsStringLiteral<`ab${'c' | 'd' | 'e'}`>>(true);
 expectType<IsStringLiteral<Uppercase<'a' | 'b'> | 'C' | 'D'>>(true);
 expectType<IsStringLiteral<Lowercase<'xyz'> | Capitalize<'abc'>>>(true);
 
+// Union of literals and non-literals return `boolean`
+expectType<IsStringLiteral<Uppercase<string> | stringLiteral>>(boolean);
+expectType<IsStringLiteral<Lowercase<string> | stringLiteral>>(boolean);
+
+// Union of diffrent literal types return `boolean`
+expectType<IsNumericLiteral<numericLiteral | stringLiteral>>(boolean);
+expectType<IsStringLiteral<stringLiteral | numberLiteral>>(boolean);
+
 // Strings with union of literals and non-literals return `boolean`
-expectType<IsStringLiteral<Uppercase<string> | 'abc'>>({} as boolean);
-expectType<IsStringLiteral<Lowercase<string> | 'Abc'>>({} as boolean);
-expectType<IsStringLiteral<null | '1' | '2' | '3'>>({} as boolean);
-expectType<IsStringLiteral<1 | 2 | '3'>>({} as boolean);
-expectType<IsStringLiteral<'foo' | 'bar' | number>>({} as boolean);
+expectType<IsStringLiteral<Uppercase<string> | 'abc'>>(boolean);
+expectType<IsStringLiteral<Lowercase<string> | 'Abc'>>(boolean);
+expectType<IsStringLiteral<null | '1' | '2' | '3'>>(boolean);
+expectType<IsStringLiteral<1 | 2 | '3'>>(boolean);
+expectType<IsStringLiteral<'foo' | 'bar' | number>>(boolean);
 
 // Types other than string return `false`
 expectType<IsStringLiteral<bigint>>(false);
@@ -93,16 +99,19 @@ expectType<IsStringLiteral<{}>>(false);
 expectType<IsStringLiteral<any>>(false);
 expectType<IsStringLiteral<never>>(false);
 
-expectType<IsNumericLiteral<typeof numberLiteral>>(true);
-expectType<IsNumericLiteral<typeof bigintLiteral>>(true);
-expectType<IsNumericLiteral<typeof _number>>(false);
-expectType<IsNumericLiteral<typeof _bigint>>(false);
+expectType<IsNumericLiteral<numericLiteral>>(true);
+expectType<IsNumericLiteral<numberLiteral>>(true);
+expectType<IsNumericLiteral<bigintLiteral>>(true);
+expectType<IsNumericLiteral<Numeric>>(false);
+expectType<IsNumericLiteral<number>>(false);
+expectType<IsNumericLiteral<bigint>>(false);
 
-expectType<IsBooleanLiteral<typeof booleanLiteral>>(true);
-expectType<IsBooleanLiteral<typeof _boolean>>(false);
+expectType<IsBooleanLiteral<booleanLiteral>>(true);
+expectType<IsBooleanLiteral<true | false>>(false);
+expectType<IsBooleanLiteral<boolean>>(false);
 
-expectType<IsSymbolLiteral<typeof symbolLiteral>>(true);
-expectType<IsSymbolLiteral<typeof _symbol>>(false);
+expectType<IsSymbolLiteral<symbolLiteral>>(true);
+expectType<IsSymbolLiteral<symbol>>(false);
 
 // Missing generic parameter
 // @ts-expect-error
@@ -118,25 +127,27 @@ type A4 = IsSymbolLiteral;
 
 // Tagged types
 expectType<IsStringLiteral<Tagged<string, 'Tag'>>>(false);
+expectType<IsSymbolLiteral<Tagged<symbol, 'Tag'>>>(false);
+expectType<IsNumericLiteral<Tagged<number, 'Tag'>>>(false);
+expectType<IsNumericLiteral<Tagged<bigint, 'Tag'>>>(false);
+expectType<IsBooleanLiteral<Tagged<boolean, 'Tag'>>>(false);
+
 expectType<IsStringLiteral<Tagged<Uppercase<string>, 'Tag'>>>(false);
 expectType<IsStringLiteral<Tagged<number, 'Tag'>>>(false);
 expectType<IsStringLiteral<Tagged<'foo' | 'bar', 'Tag'>>>(true);
-expectType<IsStringLiteral<Tagged<'foo' | 'bar' | `on${string}`, 'Tag'>>>({} as boolean);
-expectType<IsStringLiteral<Tagged<'1st' | '2nd' | '3rd' | number, 'Tag'>>>({} as boolean);
+expectType<IsStringLiteral<Tagged<'foo' | 'bar' | `on${string}`, 'Tag'>>>(boolean);
+expectType<IsStringLiteral<Tagged<'1st' | '2nd' | '3rd' | number, 'Tag'>>>(boolean);
 
 expectType<IsStringLiteral<Tagged<string, 'Tag'> | Tagged<number, 'Tag'>>>(false);
 expectType<IsStringLiteral<Tagged<'foo', 'Tag'> | Tagged<'bar', 'Tag'>>>(true);
-expectType<IsStringLiteral<Tagged<'foo' | 'bar', 'Tag'> | Tagged<number, 'Tag'>>>({} as boolean);
-expectType<IsStringLiteral<Tagged<'foo' | 'bar', 'Tag'> | number>>({} as boolean);
+expectType<IsStringLiteral<Tagged<'foo' | 'bar', 'Tag'> | Tagged<number, 'Tag'>>>(boolean);
+expectType<IsStringLiteral<Tagged<'foo' | 'bar', 'Tag'> | number>>(boolean);
 
 // Uncollapsed unions (e.g., `'foo' | 'bar' | (string & {})`)
 expectType<IsStringLiteral<'foo' | 'bar' | (string & {})>>(false);
 expectType<IsStringLiteral<LiteralUnion<'foo' | 'bar', string>>>(false);
 expectType<IsStringLiteral<LiteralUnion<'onClick' | 'onMouseDown', `on${string}`>>>(false);
-expectType<IsStringLiteral<LiteralUnion<'press' | 'onClick' | 'onMouseDown', `on${string}`>>>({} as boolean);
-expectType<IsStringLiteral<LiteralUnion<'foo' | 'bar', number>>>({} as boolean);
+expectType<IsStringLiteral<LiteralUnion<'press' | 'onClick' | 'onMouseDown', `on${string}`>>>(boolean);
+expectType<IsStringLiteral<LiteralUnion<'foo' | 'bar', number>>>(boolean);
 expectType<IsStringLiteral<Tagged<LiteralUnion<'foo' | 'bar', string>, 'Tag'>>>(false);
-expectType<IsStringLiteral<Tagged<LiteralUnion<'click' | 'onMouseDown', `on${string}`>, 'Tag'>>>({} as boolean);
-
-expectType<IsNumericLiteral<Tagged<number, 'Tag'>>>(false);
-expectType<IsBooleanLiteral<Tagged<boolean, 'Tag'>>>(false);
+expectType<IsStringLiteral<Tagged<LiteralUnion<'click' | 'onMouseDown', `on${string}`>, 'Tag'>>>(boolean);
diff --git a/test-d/is-primitive.ts b/test-d/is-primitive.ts
new file mode 100644
index 000000000..99dc2aaaf
--- /dev/null
+++ b/test-d/is-primitive.ts
@@ -0,0 +1,115 @@
+import {expectType} from 'tsd';
+import type tag from 'tagged-tag';
+import type {
+	IsPrimitive,
+	IsBooleanPrimitive,
+	IsNumericPrimitive,
+	IsStringPrimitive,
+	IsSymbolPrimitive,
+	Tagged,
+} from '../index.d.ts';
+import type {Numeric} from '../source/numeric.js';
+
+type stringLiteral = 'aA';
+type numberLiteral = 1;
+type bigintLiteral = 1n;
+type booleanLiteral = true;
+type symbolLiteral = typeof tag;
+type numericLiteral = numberLiteral | bigintLiteral;
+
+declare const boolean: boolean;
+
+// Primitives should be true
+expectType<IsPrimitive<string>>(true);
+expectType<IsPrimitive<number>>(true);
+expectType<IsPrimitive<bigint>>(true);
+expectType<IsPrimitive<symbol>>(true);
+expectType<IsPrimitive<boolean>>(true);
+
+// Literals should be false
+expectType<IsPrimitive<stringLiteral>>(false);
+expectType<IsPrimitive<numberLiteral>>(false);
+expectType<IsPrimitive<bigintLiteral>>(false);
+expectType<IsPrimitive<symbolLiteral>>(false);
+expectType<IsPrimitive<booleanLiteral>>(false);
+
+// Null, undefined, and non-primitives should fail all literal checks
+expectType<IsPrimitive<null>>(false);
+expectType<IsPrimitive<undefined>>(false);
+expectType<IsPrimitive<any>>(false);
+expectType<IsPrimitive<never>>(false);
+
+expectType<IsStringPrimitive<stringLiteral>>(false);
+expectType<IsStringPrimitive<string>>(true);
+
+// Strings with infinite set of possible values return `false`
+expectType<IsStringPrimitive<Uppercase<string>>>(false);
+expectType<IsStringPrimitive<Lowercase<string>>>(false);
+expectType<IsStringPrimitive<Capitalize<string>>>(false);
+expectType<IsStringPrimitive<Uncapitalize<string>>>(false);
+expectType<IsStringPrimitive<Capitalize<Lowercase<string>>>>(false);
+expectType<IsStringPrimitive<Uncapitalize<Uppercase<string>>>>(false);
+expectType<IsStringPrimitive<`abc${string}`>>(false);
+expectType<IsStringPrimitive<`${string}abc`>>(false);
+expectType<IsStringPrimitive<`${number}:${string}`>>(false);
+expectType<IsStringPrimitive<`abc${Uppercase<string>}`>>(false);
+expectType<IsStringPrimitive<`${Lowercase<string>}abc`>>(false);
+expectType<IsStringPrimitive<`${number}`>>(false);
+expectType<IsStringPrimitive<`${number}${string}`>>(false);
+expectType<IsStringPrimitive<`${number}` | Uppercase<string>>>(false);
+expectType<IsStringPrimitive<Capitalize<string> | Uppercase<string>>>(false);
+expectType<IsStringPrimitive<`abc${string}` | `${string}abc`>>(false);
+
+// Strings with finite set of possible values return `false`
+expectType<IsStringPrimitive<'a' | 'b'>>(false);
+expectType<IsStringPrimitive<Uppercase<'a'>>>(false);
+expectType<IsStringPrimitive<Lowercase<'a'>>>(false);
+expectType<IsStringPrimitive<Uppercase<'a' | 'b'>>>(false);
+expectType<IsStringPrimitive<Lowercase<'a' | 'b'>>>(false);
+expectType<IsStringPrimitive<Capitalize<'abc' | 'xyz'>>>(false);
+expectType<IsStringPrimitive<Uncapitalize<'Abc' | 'Xyz'>>>(false);
+expectType<IsStringPrimitive<`ab${'c' | 'd' | 'e'}`>>(false);
+expectType<IsStringPrimitive<Uppercase<'a' | 'b'> | 'C' | 'D'>>(false);
+expectType<IsStringPrimitive<Lowercase<'xyz'> | Capitalize<'abc'>>>(false);
+
+// Union of literals and non-literals return `true`
+expectType<IsStringPrimitive<Uppercase<string> | (string & {})>>(true);
+expectType<IsStringPrimitive<Lowercase<string> | (string & {})>>(true);
+
+// Boundary types
+expectType<IsStringPrimitive<{}>>(false);
+expectType<IsStringPrimitive<any>>(false);
+expectType<IsStringPrimitive<never>>(false);
+
+expectType<IsNumericPrimitive<numericLiteral>>(false);
+expectType<IsNumericPrimitive<numberLiteral>>(false);
+expectType<IsNumericPrimitive<bigintLiteral>>(false);
+expectType<IsNumericPrimitive<Numeric>>(true);
+expectType<IsNumericPrimitive<number>>(true);
+expectType<IsNumericPrimitive<bigint>>(true);
+
+expectType<IsBooleanPrimitive<booleanLiteral>>(false);
+expectType<IsBooleanPrimitive<true | false>>(true);
+expectType<IsBooleanPrimitive<boolean>>(true);
+
+expectType<IsSymbolPrimitive<symbolLiteral>>(false);
+expectType<IsSymbolPrimitive<symbol>>(true);
+
+// Missing generic parameter
+// @ts-expect-error
+type A0 = IsPrimitive;
+// @ts-expect-error
+type A1 = IsStringPrimitive;
+// @ts-expect-error
+type A2 = IsNumericPrimitive;
+// @ts-expect-error
+type A3 = IsBooleanPrimitive;
+// @ts-expect-error
+type A4 = IsSymbolPrimitive;
+
+// Tagged types should be false
+expectType<IsStringPrimitive<Tagged<string, 'Tag'>>>(false);
+expectType<IsSymbolPrimitive<Tagged<symbol, 'Tag'>>>(false);
+expectType<IsNumericPrimitive<Tagged<number, 'Tag'>>>(false);
+expectType<IsNumericPrimitive<Tagged<bigint, 'Tag'>>>(false);
+expectType<IsBooleanPrimitive<Tagged<boolean, 'Tag'>>>(false);