Use string literals instead of enums

source/index.ts

@@ -4,49 +4,73 @@
 
 export type Class<T = unknown> = new (...args: any[]) => T;
 
-export const enum TypeName {
+const objectTypeNames = [
-	null = 'null',
+	'Function',
-	boolean = 'boolean',
+	'Generator',
-	undefined = 'undefined',
+	'AsyncGenerator',
-	string = 'string',
+	'GeneratorFunction',
-	number = 'number',
+	'AsyncGeneratorFunction',
-	bigint = 'bigint',
+	'AsyncFunction',
-	symbol = 'symbol',
+	'Observable',
-	Function = 'Function',
+	'Array',
-	Generator = 'Generator',
+	'Buffer',
-	AsyncGenerator = 'AsyncGenerator',
+	'Object',
-	GeneratorFunction = 'GeneratorFunction',
+	'RegExp',
-	AsyncGeneratorFunction = 'AsyncGeneratorFunction',
+	'Date',
-	AsyncFunction = 'AsyncFunction',
+	'Error',
-	Observable = 'Observable',
+	'Map',
-	Array = 'Array',
+	'Set',
-	Buffer = 'Buffer',
+	'WeakMap',
-	Object = 'Object',
+	'WeakSet',
-	RegExp = 'RegExp',
+	'ArrayBuffer',
-	Date = 'Date',
+	'SharedArrayBuffer',
-	Error = 'Error',
+	'DataView',
-	Map = 'Map',
+	'Promise',
-	Set = 'Set',
+	'URL'
-	WeakMap = 'WeakMap',
+] as const;
-	WeakSet = 'WeakSet',
+
-	Int8Array = 'Int8Array',
+type ObjectTypeName = typeof objectTypeNames[number];
-	Uint8Array = 'Uint8Array',
+
-	Uint8ClampedArray = 'Uint8ClampedArray',
+const primitives = {
-	Int16Array = 'Int16Array',
+	null: null,
-	Uint16Array = 'Uint16Array',
+	undefined,
-	Int32Array = 'Int32Array',
+	string: String(),
-	Uint32Array = 'Uint32Array',
+	number: Number(),
-	Float32Array = 'Float32Array',
+	bigint: BigInt(0),
-	Float64Array = 'Float64Array',
+	boolean: Boolean(),
-	BigInt64Array = 'BigInt64Array',
+	symbol: Symbol('')
-	BigUint64Array = 'BigUint64Array',
+} as const;
-	ArrayBuffer = 'ArrayBuffer',
+
-	SharedArrayBuffer = 'SharedArrayBuffer',
+type PrimitiveTypeName = keyof typeof primitives;
-	DataView = 'DataView',
+export type Primitive = typeof primitives[PrimitiveTypeName];
-	Promise = 'Promise',
+
-	URL = 'URL'
+function isPrimitiveTypeName(name: string): name is PrimitiveTypeName {
+	return Object.prototype.hasOwnProperty.call(primitives, name);
 }
 
+const typedArrays = {
+	Int8Array: new Int8Array(),
+	Uint8Array: new Uint8Array(),
+	Uint8ClampedArray: new Uint8ClampedArray(),
+	Int16Array: new Int16Array(),
+	Uint16Array: new Uint16Array(),
+	Int32Array: new Int32Array(),
+	Uint32Array: new Uint32Array(),
+	Float32Array: new Float32Array(),
+	Float64Array: new Float64Array(),
+	BigInt64Array: new BigInt64Array(),
+	BigUint64Array: new BigUint64Array()
+} as const;
+
+type TypedArrayTypeName = keyof typeof typedArrays;
+export type TypedArray = typeof typedArrays[TypedArrayTypeName];
+
+function isTypedArrayName(value: any): value is TypedArrayTypeName {
+	return Object.prototype.hasOwnProperty.call(typedArrays, value);
+}
+
+export type TypeName = ObjectTypeName | PrimitiveTypeName | TypedArrayTypeName;
+
 const {toString} = Object.prototype;
 const isOfType = <T>(type: string) => (value: unknown): value is T => typeof value === type;
 
@@ -64,41 +88,41 @@ const isObjectOfType = <T>(type: TypeName) => (value: unknown): value is T => ge
 function is(value: unknown): TypeName {
 	switch (value) {
 		case null:
-			return TypeName.null;
+			return 'null';
 		case true:
 		case false:
-			return TypeName.boolean;
+			return 'boolean';
 		default:
 	}
 
 	switch (typeof value) {
 		case 'undefined':
-			return TypeName.undefined;
+			return 'undefined';
 		case 'string':
-			return TypeName.string;
+			return 'string';
 		case 'number':
-			return TypeName.number;
+			return 'number';
 		case 'bigint':
-			return TypeName.bigint;
+			return 'bigint';
 		case 'symbol':
-			return TypeName.symbol;
+			return 'symbol';
 		default:
 	}
 
 	if (is.function_(value)) {
-		return TypeName.Function;
+		return 'Function';
 	}
 
 	if (is.observable(value)) {
-		return TypeName.Observable;
+		return 'Observable';
 	}
 
 	if (is.array(value)) {
-		return TypeName.Array;
+		return 'Array';
 	}
 
 	if (is.buffer(value)) {
-		return TypeName.Buffer;
+		return 'Buffer';
 	}
 
 	const tagType = getObjectType(value);
@@ -110,7 +134,7 @@ function is(value: unknown): TypeName {
 		throw new TypeError('Please don\'t use object wrappers for primitive types');
 	}
 
-	return TypeName.Object;
+	return 'Object';
 }
 
 is.undefined = isOfType<undefined>('undefined');
@@ -146,7 +170,7 @@ is.generator = (value: unknown): value is Generator => is.iterable(value) && is.
 is.asyncGenerator = (value: unknown): value is AsyncGenerator => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
 
 is.nativePromise = <T = unknown>(value: unknown): value is Promise<T> =>
-	isObjectOfType<Promise<T>>(TypeName.Promise)(value);
+	isObjectOfType<Promise<T>>('Promise')(value);
 
 const hasPromiseAPI = <T = unknown>(value: unknown): value is Promise<T> =>
 	is.function_((value as Promise<T>)?.then) &&
@@ -154,41 +178,41 @@ const hasPromiseAPI = <T = unknown>(value: unknown): value is Promise<T> =>
 
 is.promise = <T = unknown>(value: unknown): value is Promise<T> => is.nativePromise(value) || hasPromiseAPI(value);
 
-is.generatorFunction = isObjectOfType<GeneratorFunction>(TypeName.GeneratorFunction);
+is.generatorFunction = isObjectOfType<GeneratorFunction>('GeneratorFunction');
 
-is.asyncGeneratorFunction = (value: unknown): value is ((...args: any[]) => Promise<unknown>) => getObjectType(value) === TypeName.AsyncGeneratorFunction;
+is.asyncGeneratorFunction = (value: unknown): value is ((...args: any[]) => Promise<unknown>) => getObjectType(value) === 'AsyncGeneratorFunction';
 
-is.asyncFunction = <T = unknown>(value: unknown): value is ((...args: any[]) => Promise<T>) => getObjectType(value) === TypeName.AsyncFunction;
+is.asyncFunction = <T = unknown>(value: unknown): value is ((...args: any[]) => Promise<T>) => getObjectType(value) === 'AsyncFunction';
 
 // eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
 is.boundFunction = (value: unknown): value is Function => is.function_(value) && !value.hasOwnProperty('prototype');
 
-is.regExp = isObjectOfType<RegExp>(TypeName.RegExp);
+is.regExp = isObjectOfType<RegExp>('RegExp');
-is.date = isObjectOfType<Date>(TypeName.Date);
+is.date = isObjectOfType<Date>('Date');
-is.error = isObjectOfType<Error>(TypeName.Error);
+is.error = isObjectOfType<Error>('Error');
-is.map = <Key = unknown, Value = unknown>(value: unknown): value is Map<Key, Value> => isObjectOfType<Map<Key, Value>>(TypeName.Map)(value);
+is.map = <Key = unknown, Value = unknown>(value: unknown): value is Map<Key, Value> => isObjectOfType<Map<Key, Value>>('Map')(value);
-is.set = <T = unknown>(value: unknown): value is Set<T> => isObjectOfType<Set<T>>(TypeName.Set)(value);
+is.set = <T = unknown>(value: unknown): value is Set<T> => isObjectOfType<Set<T>>('Set')(value);
-is.weakMap = <Key extends object = object, Value = unknown>(value: unknown): value is WeakMap<Key, Value> => isObjectOfType<WeakMap<Key, Value>>(TypeName.WeakMap)(value);
+is.weakMap = <Key extends object = object, Value = unknown>(value: unknown): value is WeakMap<Key, Value> => isObjectOfType<WeakMap<Key, Value>>('WeakMap')(value);
-is.weakSet = (value: unknown): value is WeakSet<object> => isObjectOfType<WeakSet<object>>(TypeName.WeakSet)(value);
+is.weakSet = (value: unknown): value is WeakSet<object> => isObjectOfType<WeakSet<object>>('WeakSet')(value);
 
-is.int8Array = isObjectOfType<Int8Array>(TypeName.Int8Array);
+is.int8Array = isObjectOfType<Int8Array>('Int8Array');
-is.uint8Array = isObjectOfType<Uint8Array>(TypeName.Uint8Array);
+is.uint8Array = isObjectOfType<Uint8Array>('Uint8Array');
-is.uint8ClampedArray = isObjectOfType<Uint8ClampedArray>(TypeName.Uint8ClampedArray);
+is.uint8ClampedArray = isObjectOfType<Uint8ClampedArray>('Uint8ClampedArray');
-is.int16Array = isObjectOfType<Int16Array>(TypeName.Int16Array);
+is.int16Array = isObjectOfType<Int16Array>('Int16Array');
-is.uint16Array = isObjectOfType<Uint16Array>(TypeName.Uint16Array);
+is.uint16Array = isObjectOfType<Uint16Array>('Uint16Array');
-is.int32Array = isObjectOfType<Int32Array>(TypeName.Int32Array);
+is.int32Array = isObjectOfType<Int32Array>('Int32Array');
-is.uint32Array = isObjectOfType<Uint32Array>(TypeName.Uint32Array);
+is.uint32Array = isObjectOfType<Uint32Array>('Uint32Array');
-is.float32Array = isObjectOfType<Float32Array>(TypeName.Float32Array);
+is.float32Array = isObjectOfType<Float32Array>('Float32Array');
-is.float64Array = isObjectOfType<Float64Array>(TypeName.Float64Array);
+is.float64Array = isObjectOfType<Float64Array>('Float64Array');
-is.bigInt64Array = isObjectOfType<BigInt64Array>(TypeName.BigInt64Array);
+is.bigInt64Array = isObjectOfType<BigInt64Array>('BigInt64Array');
-is.bigUint64Array = isObjectOfType<BigUint64Array>(TypeName.BigUint64Array);
+is.bigUint64Array = isObjectOfType<BigUint64Array>('BigUint64Array');
 
-is.arrayBuffer = isObjectOfType<ArrayBuffer>(TypeName.ArrayBuffer);
+is.arrayBuffer = isObjectOfType<ArrayBuffer>('ArrayBuffer');
-is.sharedArrayBuffer = isObjectOfType<SharedArrayBuffer>(TypeName.SharedArrayBuffer);
+is.sharedArrayBuffer = isObjectOfType<SharedArrayBuffer>('SharedArrayBuffer');
-is.dataView = isObjectOfType<DataView>(TypeName.DataView);
+is.dataView = isObjectOfType<DataView>('DataView');
 
 is.directInstanceOf = <T>(instance: unknown, class_: Class<T>): instance is T => Object.getPrototypeOf(instance) === class_.prototype;
-is.urlInstance = (value: unknown): value is URL => isObjectOfType<URL>(TypeName.URL)(value);
+is.urlInstance = (value: unknown): value is URL => isObjectOfType<URL>('URL')(value);
 
 is.urlString = (value: unknown): value is string => {
 	if (!is.string(value)) {
@@ -211,33 +235,14 @@ is.falsy = (value: unknown) => !value;
 
 is.nan = (value: unknown) => Number.isNaN(value as number);
 
-const primitiveTypeOfTypes = new Set([
+is.primitive = (value: unknown): value is Primitive => is.null_(value) || isPrimitiveTypeName(typeof value);
-	'undefined',
-	'string',
-	'number',
-	'bigint',
-	'boolean',
-	'symbol'
-]);
-
-// TODO: This should be able to be `not object` when the `not` operator is out
-export type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| bigint
-	| boolean
-	| symbol;
-
-is.primitive = (value: unknown): value is Primitive => is.null_(value) || primitiveTypeOfTypes.has(typeof value);
 
 is.integer = (value: unknown): value is number => Number.isInteger(value as number);
 is.safeInteger = (value: unknown): value is number => Number.isSafeInteger(value as number);
 
 is.plainObject = <Value = unknown>(value: unknown): value is Record<string, Value> => {
 	// From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
-	if (getObjectType(value) !== TypeName.Object) {
+	if (getObjectType(value) !== 'Object') {
 		return false;
 	}
 
@@ -246,41 +251,7 @@ is.plainObject = <Value = unknown>(value: unknown): value is Record<string, Valu
 	return prototype === null || prototype === Object.getPrototypeOf({});
 };
 
-const typedArrayTypes = new Set([
+is.typedArray = (value: unknown): value is TypedArray => isTypedArrayName(getObjectType(value));
-	TypeName.Int8Array,
-	TypeName.Uint8Array,
-	TypeName.Uint8ClampedArray,
-	TypeName.Int16Array,
-	TypeName.Uint16Array,
-	TypeName.Int32Array,
-	TypeName.Uint32Array,
-	TypeName.Float32Array,
-	TypeName.Float64Array,
-	TypeName.BigInt64Array,
-	TypeName.BigUint64Array
-]);
-
-export type TypedArray =
-	| Int8Array
-	| Uint8Array
-	| Uint8ClampedArray
-	| Int16Array
-	| Uint16Array
-	| Int32Array
-	| Uint32Array
-	| Float32Array
-	| Float64Array
-	| BigInt64Array
-	| BigUint64Array;
-
-is.typedArray = (value: unknown): value is TypedArray => {
-	const objectType = getObjectType(value);
-	if (objectType === undefined) {
-		return false;
-	}
-
-	return typedArrayTypes.has(objectType);
-};
 
 export interface ArrayLike<T> {
 	readonly [index: number]: T;
@@ -537,55 +508,55 @@ interface Assert {
 
 export const assert: Assert = {
 	// Unknowns.
-	undefined: (value: unknown): asserts value is undefined => assertType(is.undefined(value), TypeName.undefined, value),
+	undefined: (value: unknown): asserts value is undefined => assertType(is.undefined(value), 'undefined', value),
-	string: (value: unknown): asserts value is string => assertType(is.string(value), TypeName.string, value),
+	string: (value: unknown): asserts value is string => assertType(is.string(value), 'string', value),
-	number: (value: unknown): asserts value is number => assertType(is.number(value), TypeName.number, value),
+	number: (value: unknown): asserts value is number => assertType(is.number(value), 'number', value),
-	bigint: (value: unknown): asserts value is bigint => assertType(is.bigint(value), TypeName.bigint, value),
+	bigint: (value: unknown): asserts value is bigint => assertType(is.bigint(value), 'bigint', value),
 	// eslint-disable-next-line @typescript-eslint/ban-types
-	function_: (value: unknown): asserts value is Function => assertType(is.function_(value), TypeName.Function, value),
+	function_: (value: unknown): asserts value is Function => assertType(is.function_(value), 'Function', value),
-	null_: (value: unknown): asserts value is null => assertType(is.null_(value), TypeName.null, value),
+	null_: (value: unknown): asserts value is null => assertType(is.null_(value), 'null', value),
 	class_: (value: unknown): asserts value is Class => assertType(is.class_(value), AssertionTypeDescription.class_, value),
-	boolean: (value: unknown): asserts value is boolean => assertType(is.boolean(value), TypeName.boolean, value),
+	boolean: (value: unknown): asserts value is boolean => assertType(is.boolean(value), 'boolean', value),
-	symbol: (value: unknown): asserts value is symbol => assertType(is.symbol(value), TypeName.symbol, value),
+	symbol: (value: unknown): asserts value is symbol => assertType(is.symbol(value), 'symbol', value),
 	numericString: (value: unknown): asserts value is string => assertType(is.numericString(value), AssertionTypeDescription.numericString, value),
-	array: <T = unknown>(value: unknown): asserts value is T[] => assertType(is.array(value), TypeName.Array, value),
+	array: <T = unknown>(value: unknown): asserts value is T[] => assertType(is.array(value), 'Array', value),
-	buffer: (value: unknown): asserts value is Buffer => assertType(is.buffer(value), TypeName.Buffer, value),
+	buffer: (value: unknown): asserts value is Buffer => assertType(is.buffer(value), 'Buffer', value),
 	nullOrUndefined: (value: unknown): asserts value is null | undefined => assertType(is.nullOrUndefined(value), AssertionTypeDescription.nullOrUndefined, value),
-	object: (value: unknown): asserts value is object => assertType(is.object(value), TypeName.Object, value),
+	object: (value: unknown): asserts value is object => assertType(is.object(value), 'Object', value),
 	iterable: <T = unknown>(value: unknown): asserts value is Iterable<T> => assertType(is.iterable(value), AssertionTypeDescription.iterable, value),
 	asyncIterable: <T = unknown>(value: unknown): asserts value is AsyncIterable<T> => assertType(is.asyncIterable(value), AssertionTypeDescription.asyncIterable, value),
-	generator: (value: unknown): asserts value is Generator => assertType(is.generator(value), TypeName.Generator, value),
+	generator: (value: unknown): asserts value is Generator => assertType(is.generator(value), 'Generator', value),
-	asyncGenerator: (value: unknown): asserts value is AsyncGenerator => assertType(is.asyncGenerator(value), TypeName.AsyncGenerator, value),
+	asyncGenerator: (value: unknown): asserts value is AsyncGenerator => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
 	nativePromise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.nativePromise(value), AssertionTypeDescription.nativePromise, value),
-	promise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.promise(value), TypeName.Promise, value),
+	promise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.promise(value), 'Promise', value),
-	generatorFunction: (value: unknown): asserts value is GeneratorFunction => assertType(is.generatorFunction(value), TypeName.GeneratorFunction, value),
+	generatorFunction: (value: unknown): asserts value is GeneratorFunction => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
-	asyncGeneratorFunction: (value: unknown): asserts value is AsyncGeneratorFunction => assertType(is.asyncGeneratorFunction(value), TypeName.AsyncGeneratorFunction, value),
+	asyncGeneratorFunction: (value: unknown): asserts value is AsyncGeneratorFunction => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
 	// eslint-disable-next-line @typescript-eslint/ban-types
-	asyncFunction: (value: unknown): asserts value is Function => assertType(is.asyncFunction(value), TypeName.AsyncFunction, value),
+	asyncFunction: (value: unknown): asserts value is Function => assertType(is.asyncFunction(value), 'AsyncFunction', value),
 	// eslint-disable-next-line @typescript-eslint/ban-types
-	boundFunction: (value: unknown): asserts value is Function => assertType(is.boundFunction(value), TypeName.Function, value),
+	boundFunction: (value: unknown): asserts value is Function => assertType(is.boundFunction(value), 'Function', value),
-	regExp: (value: unknown): asserts value is RegExp => assertType(is.regExp(value), TypeName.RegExp, value),
+	regExp: (value: unknown): asserts value is RegExp => assertType(is.regExp(value), 'RegExp', value),
-	date: (value: unknown): asserts value is Date => assertType(is.date(value), TypeName.Date, value),
+	date: (value: unknown): asserts value is Date => assertType(is.date(value), 'Date', value),
-	error: (value: unknown): asserts value is Error => assertType(is.error(value), TypeName.Error, value),
+	error: (value: unknown): asserts value is Error => assertType(is.error(value), 'Error', value),
-	map: <Key = unknown, Value = unknown>(value: unknown): asserts value is Map<Key, Value> => assertType(is.map(value), TypeName.Map, value),
+	map: <Key = unknown, Value = unknown>(value: unknown): asserts value is Map<Key, Value> => assertType(is.map(value), 'Map', value),
-	set: <T = unknown>(value: unknown): asserts value is Set<T> => assertType(is.set(value), TypeName.Set, value),
+	set: <T = unknown>(value: unknown): asserts value is Set<T> => assertType(is.set(value), 'Set', value),
-	weakMap: <Key extends object = object, Value = unknown>(value: unknown): asserts value is WeakMap<Key, Value> => assertType(is.weakMap(value), TypeName.WeakMap, value),
+	weakMap: <Key extends object = object, Value = unknown>(value: unknown): asserts value is WeakMap<Key, Value> => assertType(is.weakMap(value), 'WeakMap', value),
-	weakSet: <T extends object = object>(value: unknown): asserts value is WeakSet<T> => assertType(is.weakSet(value), TypeName.WeakSet, value),
+	weakSet: <T extends object = object>(value: unknown): asserts value is WeakSet<T> => assertType(is.weakSet(value), 'WeakSet', value),
-	int8Array: (value: unknown): asserts value is Int8Array => assertType(is.int8Array(value), TypeName.Int8Array, value),
+	int8Array: (value: unknown): asserts value is Int8Array => assertType(is.int8Array(value), 'Int8Array', value),
-	uint8Array: (value: unknown): asserts value is Uint8Array => assertType(is.uint8Array(value), TypeName.Uint8Array, value),
+	uint8Array: (value: unknown): asserts value is Uint8Array => assertType(is.uint8Array(value), 'Uint8Array', value),
-	uint8ClampedArray: (value: unknown): asserts value is Uint8ClampedArray => assertType(is.uint8ClampedArray(value), TypeName.Uint8ClampedArray, value),
+	uint8ClampedArray: (value: unknown): asserts value is Uint8ClampedArray => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
-	int16Array: (value: unknown): asserts value is Int16Array => assertType(is.int16Array(value), TypeName.Int16Array, value),
+	int16Array: (value: unknown): asserts value is Int16Array => assertType(is.int16Array(value), 'Int16Array', value),
-	uint16Array: (value: unknown): asserts value is Uint16Array => assertType(is.uint16Array(value), TypeName.Uint16Array, value),
+	uint16Array: (value: unknown): asserts value is Uint16Array => assertType(is.uint16Array(value), 'Uint16Array', value),
-	int32Array: (value: unknown): asserts value is Int32Array => assertType(is.int32Array(value), TypeName.Int32Array, value),
+	int32Array: (value: unknown): asserts value is Int32Array => assertType(is.int32Array(value), 'Int32Array', value),
-	uint32Array: (value: unknown): asserts value is Uint32Array => assertType(is.uint32Array(value), TypeName.Uint32Array, value),
+	uint32Array: (value: unknown): asserts value is Uint32Array => assertType(is.uint32Array(value), 'Uint32Array', value),
-	float32Array: (value: unknown): asserts value is Float32Array => assertType(is.float32Array(value), TypeName.Float32Array, value),
+	float32Array: (value: unknown): asserts value is Float32Array => assertType(is.float32Array(value), 'Float32Array', value),
-	float64Array: (value: unknown): asserts value is Float64Array => assertType(is.float64Array(value), TypeName.Float64Array, value),
+	float64Array: (value: unknown): asserts value is Float64Array => assertType(is.float64Array(value), 'Float64Array', value),
-	bigInt64Array: (value: unknown): asserts value is BigInt64Array => assertType(is.bigInt64Array(value), TypeName.BigInt64Array, value),
+	bigInt64Array: (value: unknown): asserts value is BigInt64Array => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
-	bigUint64Array: (value: unknown): asserts value is BigUint64Array => assertType(is.bigUint64Array(value), TypeName.BigUint64Array, value),
+	bigUint64Array: (value: unknown): asserts value is BigUint64Array => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
-	arrayBuffer: (value: unknown): asserts value is ArrayBuffer => assertType(is.arrayBuffer(value), TypeName.ArrayBuffer, value),
+	arrayBuffer: (value: unknown): asserts value is ArrayBuffer => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
-	sharedArrayBuffer: (value: unknown): asserts value is SharedArrayBuffer => assertType(is.sharedArrayBuffer(value), TypeName.SharedArrayBuffer, value),
+	sharedArrayBuffer: (value: unknown): asserts value is SharedArrayBuffer => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
-	dataView: (value: unknown): asserts value is DataView => assertType(is.dataView(value), TypeName.DataView, value),
+	dataView: (value: unknown): asserts value is DataView => assertType(is.dataView(value), 'DataView', value),
-	urlInstance: (value: unknown): asserts value is URL => assertType(is.urlInstance(value), TypeName.URL, value),
+	urlInstance: (value: unknown): asserts value is URL => assertType(is.urlInstance(value), 'URL', value),
 	urlString: (value: unknown): asserts value is string => assertType(is.urlString(value), AssertionTypeDescription.urlString, value),
 	truthy: (value: unknown): asserts value is unknown => assertType(is.truthy(value), AssertionTypeDescription.truthy, value),
 	falsy: (value: unknown): asserts value is unknown => assertType(is.falsy(value), AssertionTypeDescription.falsy, value),
@@ -597,7 +568,7 @@ export const assert: Assert = {
 	typedArray: (value: unknown): asserts value is TypedArray => assertType(is.typedArray(value), AssertionTypeDescription.typedArray, value),
 	arrayLike: <T = unknown>(value: unknown): asserts value is ArrayLike<T> => assertType(is.arrayLike(value), AssertionTypeDescription.arrayLike, value),
 	domElement: (value: unknown): asserts value is Element => assertType(is.domElement(value), AssertionTypeDescription.domElement, value),
-	observable: (value: unknown): asserts value is ObservableLike => assertType(is.observable(value), TypeName.Observable, value),
+	observable: (value: unknown): asserts value is ObservableLike => assertType(is.observable(value), 'Observable', value),
 	nodeStream: (value: unknown): asserts value is NodeStream => assertType(is.nodeStream(value), AssertionTypeDescription.nodeStream, value),
 	infinite: (value: unknown): asserts value is number => assertType(is.infinite(value), AssertionTypeDescription.infinite, value),
 	emptyArray: (value: unknown): asserts value is never[] => assertType(is.emptyArray(value), AssertionTypeDescription.emptyArray, value),

test/test.ts

@@ -7,7 +7,7 @@ import {JSDOM} from 'jsdom';
 import {Subject, Observable} from 'rxjs';
 import tempy = require('tempy');
 import ZenObservable = require('zen-observable');
-import is, {assert, AssertionTypeDescription, TypeName} from '../source';
+import is, {assert, AssertionTypeDescription, Primitive, TypedArray, TypeName} from '../source';
 
 class PromiseSubclassFixture<T> extends Promise<T> {}
 class ErrorSubclassFixture extends Error {}
@@ -47,7 +47,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			undefined
 		],
-		typename: TypeName.undefined
+		typename: 'undefined'
 	}],
 	['null', {
 		is: is.null_,
@@ -55,7 +55,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			null
 		],
-		typename: TypeName.null
+		typename: 'null'
 	}],
 	['string', {
 		is: is.string,
@@ -65,7 +65,7 @@ const types = new Map<string, Test>([
 			'hello world',
 			''
 		],
-		typename: TypeName.string
+		typename: 'string'
 	}],
 	['emptyString', {
 		is: is.emptyString,
@@ -74,7 +74,7 @@ const types = new Map<string, Test>([
 			'',
 			String()
 		],
-		typename: TypeName.string,
+		typename: 'string',
 		typeDescription: AssertionTypeDescription.emptyString
 	}],
 	['number', {
@@ -88,7 +88,7 @@ const types = new Map<string, Test>([
 			Infinity,
 			-Infinity
 		],
-		typename: TypeName.number
+		typename: 'number'
 	}],
 	['bigint', {
 		is: is.bigint,
@@ -100,7 +100,7 @@ const types = new Map<string, Test>([
 			// -0n,
 			BigInt('1234')
 		],
-		typename: TypeName.bigint
+		typename: 'bigint'
 	}],
 	['boolean', {
 		is: is.boolean,
@@ -108,7 +108,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			true, false
 		],
-		typename: TypeName.boolean
+		typename: 'boolean'
 	}],
 	['symbol', {
 		is: is.symbol,
@@ -116,7 +116,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			Symbol('🦄')
 		],
-		typename: TypeName.symbol
+		typename: 'symbol'
 	}],
 	['numericString', {
 		is: is.numericString,
@@ -127,7 +127,7 @@ const types = new Map<string, Test>([
 			'Infinity',
 			'0x56'
 		],
-		typename: TypeName.string,
+		typename: 'string',
 		typeDescription: AssertionTypeDescription.numericString
 	}],
 	['array', {
@@ -137,7 +137,7 @@ const types = new Map<string, Test>([
 			[1, 2],
 			new Array(2)
 		],
-		typename: TypeName.Array
+		typename: 'Array'
 	}],
 	['emptyArray', {
 		is: is.emptyArray,
@@ -146,7 +146,7 @@ const types = new Map<string, Test>([
 			[],
 			new Array() // eslint-disable-line @typescript-eslint/no-array-constructor
 		],
-		typename: TypeName.Array,
+		typename: 'Array',
 		typeDescription: AssertionTypeDescription.emptyArray
 	}],
 	['function', {
@@ -160,7 +160,7 @@ const types = new Map<string, Test>([
 			function * (): unknown {},
 			async function * (): unknown {}
 		],
-		typename: TypeName.Function
+		typename: 'Function'
 	}],
 	['buffer', {
 		is: is.buffer,
@@ -168,7 +168,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			Buffer.from('🦄')
 		],
-		typename: TypeName.Buffer
+		typename: 'Buffer'
 	}],
 	['object', {
 		is: is.object,
@@ -177,7 +177,7 @@ const types = new Map<string, Test>([
 			{x: 1},
 			Object.create({x: 1})
 		],
-		typename: TypeName.Object
+		typename: 'Object'
 	}],
 	['regExp', {
 		is: is.regExp,
@@ -186,7 +186,7 @@ const types = new Map<string, Test>([
 			/\w/,
 			new RegExp('\\w') // eslint-disable-line prefer-regex-literals
 		],
-		typename: TypeName.RegExp
+		typename: 'RegExp'
 	}],
 	['date', {
 		is: is.date,
@@ -194,7 +194,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Date()
 		],
-		typename: TypeName.Date
+		typename: 'Date'
 	}],
 	['error', {
 		is: is.error,
@@ -203,7 +203,7 @@ const types = new Map<string, Test>([
 			new Error('🦄'),
 			new ErrorSubclassFixture()
 		],
-		typename: TypeName.Error
+		typename: 'Error'
 	}],
 	['nativePromise', {
 		is: is.nativePromise,
@@ -212,7 +212,7 @@ const types = new Map<string, Test>([
 			Promise.resolve(),
 			PromiseSubclassFixture.resolve()
 		],
-		typename: TypeName.Promise,
+		typename: 'Promise',
 		typeDescription: AssertionTypeDescription.nativePromise
 	}],
 	['promise', {
@@ -221,8 +221,8 @@ const types = new Map<string, Test>([
 		fixtures: [
 			{then() {}, catch() {}}
 		],
-		typename: TypeName.Object,
+		typename: 'Object',
-		typeDescription: TypeName.Promise
+		typeDescription: 'Promise'
 	}],
 	['generator', {
 		is: is.generator,
@@ -232,7 +232,7 @@ const types = new Map<string, Test>([
 				yield 4;
 			})()
 		],
-		typename: TypeName.Generator
+		typename: 'Generator'
 	}],
 	['asyncGenerator', {
 		is: is.asyncGenerator,
@@ -242,7 +242,7 @@ const types = new Map<string, Test>([
 				yield 4;
 			})()
 		],
-		typename: TypeName.AsyncGenerator
+		typename: 'AsyncGenerator'
 	}],
 	['generatorFunction', {
 		is: is.generatorFunction,
@@ -252,8 +252,8 @@ const types = new Map<string, Test>([
 				yield 4;
 			}
 		],
-		typename: TypeName.Function,
+		typename: 'Function',
-		typeDescription: TypeName.GeneratorFunction
+		typeDescription: 'GeneratorFunction'
 	}],
 	['asyncGeneratorFunction', {
 		is: is.asyncGeneratorFunction,
@@ -263,8 +263,8 @@ const types = new Map<string, Test>([
 				yield 4;
 			}
 		],
-		typename: TypeName.Function,
+		typename: 'Function',
-		typeDescription: TypeName.AsyncGeneratorFunction
+		typeDescription: 'AsyncGeneratorFunction'
 	}],
 	['asyncFunction', {
 		is: is.asyncFunction,
@@ -273,8 +273,8 @@ const types = new Map<string, Test>([
 			async function () {},
 			async () => {}
 		],
-		typename: TypeName.Function,
+		typename: 'Function',
-		typeDescription: TypeName.AsyncFunction
+		typeDescription: 'AsyncFunction'
 	}],
 	['boundFunction', {
 		is: is.boundFunction,
@@ -283,7 +283,7 @@ const types = new Map<string, Test>([
 			() => {},
 			function () {}.bind(null) // eslint-disable-line no-extra-bind
 		],
-		typename: TypeName.Function
+		typename: 'Function'
 	}],
 	['map', {
 		is: is.map,
@@ -291,7 +291,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Map([['one', '1']])
 		],
-		typename: TypeName.Map
+		typename: 'Map'
 	}],
 	['emptyMap', {
 		is: is.emptyMap,
@@ -299,7 +299,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Map()
 		],
-		typename: TypeName.Map,
+		typename: 'Map',
 		typeDescription: AssertionTypeDescription.emptyMap
 	}],
 	['set', {
@@ -308,7 +308,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Set(['one'])
 		],
-		typename: TypeName.Set
+		typename: 'Set'
 	}],
 	['emptySet', {
 		is: is.emptySet,
@@ -316,7 +316,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Set()
 		],
-		typename: TypeName.Set,
+		typename: 'Set',
 		typeDescription: AssertionTypeDescription.emptySet
 	}],
 	['weakSet', {
@@ -325,7 +325,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new WeakSet()
 		],
-		typename: TypeName.WeakSet
+		typename: 'WeakSet'
 	}],
 	['weakMap', {
 		is: is.weakMap,
@@ -333,7 +333,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new WeakMap()
 		],
-		typename: TypeName.WeakMap
+		typename: 'WeakMap'
 	}],
 	['int8Array', {
 		is: is.int8Array,
@@ -341,7 +341,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Int8Array()
 		],
-		typename: TypeName.Int8Array
+		typename: 'Int8Array'
 	}],
 	['uint8Array', {
 		is: is.uint8Array,
@@ -349,7 +349,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Uint8Array()
 		],
-		typename: TypeName.Uint8Array
+		typename: 'Uint8Array'
 	}],
 	['uint8ClampedArray', {
 		is: is.uint8ClampedArray,
@@ -357,7 +357,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Uint8ClampedArray()
 		],
-		typename: TypeName.Uint8ClampedArray
+		typename: 'Uint8ClampedArray'
 	}],
 	['int16Array', {
 		is: is.int16Array,
@@ -365,7 +365,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Int16Array()
 		],
-		typename: TypeName.Int16Array
+		typename: 'Int16Array'
 	}],
 	['uint16Array', {
 		is: is.uint16Array,
@@ -373,7 +373,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Uint16Array()
 		],
-		typename: TypeName.Uint16Array
+		typename: 'Uint16Array'
 	}],
 	['int32Array', {
 		is: is.int32Array,
@@ -381,7 +381,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Int32Array()
 		],
-		typename: TypeName.Int32Array
+		typename: 'Int32Array'
 	}],
 	['uint32Array', {
 		is: is.uint32Array,
@@ -389,7 +389,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Uint32Array()
 		],
-		typename: TypeName.Uint32Array
+		typename: 'Uint32Array'
 	}],
 	['float32Array', {
 		is: is.float32Array,
@@ -397,7 +397,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Float32Array()
 		],
-		typename: TypeName.Float32Array
+		typename: 'Float32Array'
 	}],
 	['float64Array', {
 		is: is.float64Array,
@@ -405,7 +405,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new Float64Array()
 		],
-		typename: TypeName.Float64Array
+		typename: 'Float64Array'
 	}],
 	['bigInt64Array', {
 		is: is.bigInt64Array,
@@ -413,7 +413,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new BigInt64Array()
 		],
-		typename: TypeName.BigInt64Array
+		typename: 'BigInt64Array'
 	}],
 	['bigUint64Array', {
 		is: is.bigUint64Array,
@@ -421,7 +421,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new BigUint64Array()
 		],
-		typename: TypeName.BigUint64Array
+		typename: 'BigUint64Array'
 	}],
 	['arrayBuffer', {
 		is: is.arrayBuffer,
@@ -429,7 +429,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new ArrayBuffer(10)
 		],
-		typename: TypeName.ArrayBuffer
+		typename: 'ArrayBuffer'
 	}],
 	['dataView', {
 		is: is.dataView,
@@ -437,7 +437,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			new DataView(new ArrayBuffer(10))
 		],
-		typename: TypeName.DataView
+		typename: 'DataView'
 	}],
 	['nan', {
 		is: is.nan,
@@ -446,7 +446,7 @@ const types = new Map<string, Test>([
 			NaN,
 			Number.NaN
 		],
-		typename: TypeName.number,
+		typename: 'number',
 		typeDescription: AssertionTypeDescription.nan
 	}],
 	['nullOrUndefined', {
@@ -466,7 +466,7 @@ const types = new Map<string, Test>([
 			Object.create(null),
 			new Object() // eslint-disable-line no-new-object
 		],
-		typename: TypeName.Object,
+		typename: 'Object',
 		typeDescription: AssertionTypeDescription.plainObject
 	}],
 	['integer', {
@@ -475,7 +475,7 @@ const types = new Map<string, Test>([
 		fixtures: [
 			6
 		],
-		typename: TypeName.number,
+		typename: 'number',
 		typeDescription: AssertionTypeDescription.integer
 	}],
 	['safeInteger', {
@@ -485,7 +485,7 @@ const types = new Map<string, Test>([
 			(2 ** 53) - 1,
 			-(2 ** 53) + 1
 		],
-		typename: TypeName.number,
+		typename: 'number',
 		typeDescription: AssertionTypeDescription.safeInteger
 	}],
 	['domElement', {
@@ -521,7 +521,7 @@ const types = new Map<string, Test>([
 			new Subject(),
 			new ZenObservable(() => {})
 		],
-		typename: TypeName.Observable
+		typename: 'Observable'
 	}],
 	['nodeStream', {
 		is: is.nodeStream,
@@ -537,7 +537,7 @@ const types = new Map<string, Test>([
 			new Stream.Stream(),
 			new Stream.Writable()
 		],
-		typename: TypeName.Object,
+		typename: 'Object',
 		typeDescription: AssertionTypeDescription.nodeStream
 	}],
 	['infinite', {
@@ -547,7 +547,7 @@ const types = new Map<string, Test>([
 			Infinity,
 			-Infinity
 		],
-		typename: TypeName.number,
+		typename: 'number',
 		typeDescription: AssertionTypeDescription.infinite
 	}]
 ]);
@@ -959,7 +959,7 @@ test('is.nullOrUndefined', t => {
 });
 
 test('is.primitive', t => {
-	const primitives = [
+	const primitives: Primitive[] = [
 		undefined,
 		null,
 		'🦄',
@@ -1101,7 +1101,7 @@ test('is.class', t => {
 });
 
 test('is.typedArray', t => {
-	const typedArrays = [
+	const typedArrays: TypedArray[] = [
 		new Int8Array(),
 		new Uint8Array(),
 		new Uint8ClampedArray(),