Socket
Socket
Sign inDemoInstall

@sindresorhus/is

Package Overview
Dependencies
Maintainers
1
Versions
57
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@sindresorhus/is - npm Package Compare versions

Comparing version 5.6.0 to 6.0.0

439

dist/index.d.ts
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
import type { Buffer } from 'node:buffer';
import type { Class, Falsy, TypedArray, ObservableLike, Primitive, WeakRef } from './types.js';
import type { ArrayLike, Class, Falsy, NodeStream, ObservableLike, Predicate, Primitive, TypedArray, WeakRef } from './types.js';
declare const objectTypeNames: readonly ["Function", "Generator", "AsyncGenerator", "GeneratorFunction", "AsyncGeneratorFunction", "AsyncFunction", "Observable", "Array", "Buffer", "Blob", "Object", "RegExp", "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "WeakRef", "ArrayBuffer", "SharedArrayBuffer", "DataView", "Promise", "URL", "FormData", "URLSearchParams", "HTMLElement", "NaN", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"];

@@ -11,146 +9,196 @@ type ObjectTypeName = typeof objectTypeNames[number];

export type TypeName = ObjectTypeName | PrimitiveTypeName;
declare function is(value: unknown): TypeName;
declare namespace is {
var undefined: (value: unknown) => value is undefined;
var string: (value: unknown) => value is string;
var number: (value: unknown) => value is number;
var positiveNumber: (value: unknown) => value is number;
var negativeNumber: (value: unknown) => value is number;
var bigint: (value: unknown) => value is bigint;
var function_: (value: unknown) => value is Function;
var null_: (value: unknown) => value is null;
var class_: (value: unknown) => value is Class;
var boolean: (value: unknown) => value is boolean;
var symbol: (value: unknown) => value is symbol;
var numericString: (value: unknown) => value is `${number}`;
var array: <T = unknown>(value: unknown, assertion?: ((value: T) => value is T) | undefined) => value is T[];
var buffer: (value: unknown) => value is Buffer;
var blob: (value: unknown) => value is Blob;
var nullOrUndefined: (value: unknown) => value is null | undefined;
var object: (value: unknown) => value is object;
var iterable: <T = unknown>(value: unknown) => value is Iterable<T>;
var asyncIterable: <T = unknown>(value: unknown) => value is AsyncIterable<T>;
var generator: (value: unknown) => value is Generator<unknown, any, unknown>;
var asyncGenerator: (value: unknown) => value is AsyncGenerator<unknown, any, unknown>;
var nativePromise: <T = unknown>(value: unknown) => value is Promise<T>;
var promise: <T = unknown>(value: unknown) => value is Promise<T>;
var generatorFunction: (value: unknown) => value is GeneratorFunction;
var asyncGeneratorFunction: (value: unknown) => value is (...args: any[]) => Promise<unknown>;
var asyncFunction: <T = unknown>(value: unknown) => value is (...args: any[]) => Promise<T>;
var boundFunction: (value: unknown) => value is Function;
var regExp: (value: unknown) => value is RegExp;
var date: (value: unknown) => value is Date;
var error: (value: unknown) => value is Error;
var map: <Key = unknown, Value = unknown>(value: unknown) => value is Map<Key, Value>;
var set: <T = unknown>(value: unknown) => value is Set<T>;
var weakMap: <Key extends object = object, Value = unknown>(value: unknown) => value is WeakMap<Key, Value>;
var weakSet: (value: unknown) => value is WeakSet<object>;
var weakRef: (value: unknown) => value is WeakRef<object>;
var int8Array: (value: unknown) => value is Int8Array;
var uint8Array: (value: unknown) => value is Uint8Array;
var uint8ClampedArray: (value: unknown) => value is Uint8ClampedArray;
var int16Array: (value: unknown) => value is Int16Array;
var uint16Array: (value: unknown) => value is Uint16Array;
var int32Array: (value: unknown) => value is Int32Array;
var uint32Array: (value: unknown) => value is Uint32Array;
var float32Array: (value: unknown) => value is Float32Array;
var float64Array: (value: unknown) => value is Float64Array;
var bigInt64Array: (value: unknown) => value is BigInt64Array;
var bigUint64Array: (value: unknown) => value is BigUint64Array;
var arrayBuffer: (value: unknown) => value is ArrayBuffer;
var sharedArrayBuffer: (value: unknown) => value is SharedArrayBuffer;
var dataView: (value: unknown) => value is DataView;
var enumCase: <T = unknown>(value: unknown, targetEnum: T) => boolean;
var directInstanceOf: <T>(instance: unknown, class_: Class<T>) => instance is T;
var urlInstance: (value: unknown) => value is URL;
var urlString: (value: unknown) => value is string;
var truthy: <T>(value: Falsy | T) => value is T;
var falsy: (value: unknown) => value is Falsy;
var nan: (value: unknown) => boolean;
var primitive: (value: unknown) => value is Primitive;
var integer: (value: unknown) => value is number;
var safeInteger: (value: unknown) => value is number;
var plainObject: <Value = unknown>(value: unknown) => value is Record<PropertyKey, Value>;
var typedArray: (value: unknown) => value is TypedArray;
var arrayLike: <T = unknown>(value: unknown) => value is ArrayLike<T>;
var tupleLike: <T extends TypeGuard<unknown>[]>(value: unknown, guards: [...T]) => value is ResolveTypesOfTypeGuardsTuple<T, []>;
var inRange: (value: number, range: number | number[]) => value is number;
var domElement: (value: unknown) => value is HTMLElement;
var observable: (value: unknown) => value is ObservableLike;
var nodeStream: (value: unknown) => value is NodeStream;
var infinite: (value: unknown) => value is number;
var evenInteger: (value: number) => value is number;
var oddInteger: (value: number) => value is number;
var emptyArray: (value: unknown) => value is never[];
var nonEmptyArray: <T = unknown, Item = unknown>(value: T | Item[]) => value is [Item, ...Item[]];
var emptyString: (value: unknown) => value is "";
var emptyStringOrWhitespace: (value: unknown) => value is string;
var nonEmptyString: (value: unknown) => value is string;
var nonEmptyStringAndNotWhitespace: (value: unknown) => value is string;
var emptyObject: <Key extends string | number | symbol = string>(value: unknown) => value is Record<Key, never>;
var nonEmptyObject: <Key extends string | number | symbol = string, Value = unknown>(value: unknown) => value is Record<Key, Value>;
var emptySet: (value: unknown) => value is Set<never>;
var nonEmptySet: <T = unknown>(value: unknown) => value is Set<T>;
var emptyMap: (value: unknown) => value is Map<never, never>;
var nonEmptyMap: <Key = unknown, Value = unknown>(value: unknown) => value is Map<Key, Value>;
var propertyKey: (value: unknown) => value is PropertyKey;
var formData: (value: unknown) => value is FormData;
var urlSearchParams: (value: unknown) => value is URLSearchParams;
var any: (predicate: Predicate | Predicate[], ...values: unknown[]) => boolean;
var all: (predicate: Predicate, ...values: unknown[]) => boolean;
}
export type ArrayLike<T> = {
readonly [index: number]: T;
readonly length: number;
declare const assertionTypeDescriptions: readonly ["positive number", "negative number", "Class", "string with a number", "null or undefined", "Iterable", "AsyncIterable", "native Promise", "EnumCase", "string with a URL", "truthy", "falsy", "primitive", "integer", "plain object", "TypedArray", "array-like", "tuple-like", "Node.js Stream", "infinite number", "empty array", "non-empty array", "empty string", "empty string or whitespace", "non-empty string", "non-empty string and not whitespace", "empty object", "non-empty object", "empty set", "non-empty set", "empty map", "non-empty map", "PropertyKey", "even integer", "odd integer", "T", "in range", "predicate returns truthy for any value", "predicate returns truthy for all values", "valid length", "whitespace string", "Function", "Generator", "AsyncGenerator", "GeneratorFunction", "AsyncGeneratorFunction", "AsyncFunction", "Observable", "Array", "Buffer", "Blob", "Object", "RegExp", "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "WeakRef", "ArrayBuffer", "SharedArrayBuffer", "DataView", "Promise", "URL", "FormData", "URLSearchParams", "HTMLElement", "NaN", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array", "null", "undefined", "string", "number", "bigint", "boolean", "symbol"];
export type AssertionTypeDescription = typeof assertionTypeDescriptions[number];
declare function detect(value: unknown): TypeName;
declare const is: typeof detect & {
all: typeof isAll;
any: typeof isAny;
array: typeof isArray;
arrayBuffer: typeof isArrayBuffer;
arrayLike: typeof isArrayLike;
asyncFunction: typeof isAsyncFunction;
asyncGenerator: typeof isAsyncGenerator;
asyncGeneratorFunction: typeof isAsyncGeneratorFunction;
asyncIterable: typeof isAsyncIterable;
bigint: typeof isBigint;
bigInt64Array: typeof isBigInt64Array;
bigUint64Array: typeof isBigUint64Array;
blob: typeof isBlob;
boolean: typeof isBoolean;
boundFunction: typeof isBoundFunction;
buffer: typeof isBuffer;
class: typeof isClass;
/** @deprecated Renamed to `class`. */
class_: typeof isClass;
dataView: typeof isDataView;
date: typeof isDate;
detect: typeof detect;
directInstanceOf: typeof isDirectInstanceOf;
/** @deprecated Renamed to `htmlElement` */
domElement: typeof isHtmlElement;
emptyArray: typeof isEmptyArray;
emptyMap: typeof isEmptyMap;
emptyObject: typeof isEmptyObject;
emptySet: typeof isEmptySet;
emptyString: typeof isEmptyString;
emptyStringOrWhitespace: typeof isEmptyStringOrWhitespace;
enumCase: typeof isEnumCase;
error: typeof isError;
evenInteger: typeof isEvenInteger;
falsy: typeof isFalsy;
float32Array: typeof isFloat32Array;
float64Array: typeof isFloat64Array;
formData: typeof isFormData;
function: typeof isFunction;
/** @deprecated Renamed to `function`. */
function_: typeof isFunction;
generator: typeof isGenerator;
generatorFunction: typeof isGeneratorFunction;
htmlElement: typeof isHtmlElement;
infinite: typeof isInfinite;
inRange: typeof isInRange;
int16Array: typeof isInt16Array;
int32Array: typeof isInt32Array;
int8Array: typeof isInt8Array;
integer: typeof isInteger;
iterable: typeof isIterable;
map: typeof isMap;
nan: typeof isNan;
nativePromise: typeof isNativePromise;
negativeNumber: typeof isNegativeNumber;
nodeStream: typeof isNodeStream;
nonEmptyArray: typeof isNonEmptyArray;
nonEmptyMap: typeof isNonEmptyMap;
nonEmptyObject: typeof isNonEmptyObject;
nonEmptySet: typeof isNonEmptySet;
nonEmptyString: typeof isNonEmptyString;
nonEmptyStringAndNotWhitespace: typeof isNonEmptyStringAndNotWhitespace;
null: typeof isNull;
/** @deprecated Renamed to `null`. */
null_: typeof isNull;
nullOrUndefined: typeof isNullOrUndefined;
number: typeof isNumber;
numericString: typeof isNumericString;
object: typeof isObject;
observable: typeof isObservable;
oddInteger: typeof isOddInteger;
plainObject: typeof isPlainObject;
positiveNumber: typeof isPositiveNumber;
primitive: typeof isPrimitive;
promise: typeof isPromise;
propertyKey: typeof isPropertyKey;
regExp: typeof isRegExp;
safeInteger: typeof isSafeInteger;
set: typeof isSet;
sharedArrayBuffer: typeof isSharedArrayBuffer;
string: typeof isString;
symbol: typeof isSymbol;
truthy: typeof isTruthy;
tupleLike: typeof isTupleLike;
typedArray: typeof isTypedArray;
uint16Array: typeof isUint16Array;
uint32Array: typeof isUint32Array;
uint8Array: typeof isUint8Array;
uint8ClampedArray: typeof isUint8ClampedArray;
undefined: typeof isUndefined;
urlInstance: typeof isUrlInstance;
urlSearchParams: typeof isUrlSearchParams;
urlString: typeof isUrlString;
validLength: typeof isValidLength;
weakMap: typeof isWeakMap;
weakRef: typeof isWeakRef;
weakSet: typeof isWeakSet;
whitespaceString: typeof isWhitespaceString;
};
export declare function isAll(predicate: Predicate, ...values: unknown[]): boolean;
export declare function isAny(predicate: Predicate | Predicate[], ...values: unknown[]): boolean;
export declare function isArray<T = unknown>(value: unknown, assertion?: (value: T) => value is T): value is T[];
export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
export declare function isArrayLike<T = unknown>(value: unknown): value is ArrayLike<T>;
export declare function isAsyncFunction<T = unknown>(value: unknown): value is ((...args: any[]) => Promise<T>);
export declare function isAsyncGenerator(value: unknown): value is AsyncGenerator;
export declare function isAsyncGeneratorFunction(value: unknown): value is ((...args: any[]) => Promise<unknown>);
export declare function isAsyncIterable<T = unknown>(value: unknown): value is AsyncIterable<T>;
export declare function isBigint(value: unknown): value is bigint;
export declare function isBigInt64Array(value: unknown): value is BigInt64Array;
export declare function isBigUint64Array(value: unknown): value is BigUint64Array;
export declare function isBlob(value: unknown): value is Blob;
export declare function isBoolean(value: unknown): value is boolean;
export declare function isBoundFunction(value: unknown): value is Function;
export declare function isBuffer(value: unknown): value is Buffer;
export declare function isClass(value: unknown): value is Class;
export declare function isDataView(value: unknown): value is DataView;
export declare function isDate(value: unknown): value is Date;
export declare function isDirectInstanceOf<T>(instance: unknown, class_: Class<T>): instance is T;
export declare function isEmptyArray(value: unknown): value is never[];
export declare function isEmptyMap(value: unknown): value is Map<never, never>;
export declare function isEmptyObject<Key extends keyof any = string>(value: unknown): value is Record<Key, never>;
export declare function isEmptySet(value: unknown): value is Set<never>;
export declare function isEmptyString(value: unknown): value is '';
export declare function isEmptyStringOrWhitespace(value: unknown): value is string;
export declare function isEnumCase<T = unknown>(value: unknown, targetEnum: T): boolean;
export declare function isError(value: unknown): value is Error;
export declare function isEvenInteger(value: unknown): value is number;
export declare function isFalsy(value: unknown): value is Falsy;
export declare function isFloat32Array(value: unknown): value is Float32Array;
export declare function isFloat64Array(value: unknown): value is Float64Array;
export declare function isFormData(value: unknown): value is FormData;
export declare function isFunction(value: unknown): value is Function;
export declare function isGenerator(value: unknown): value is Generator;
export declare function isGeneratorFunction(value: unknown): value is GeneratorFunction;
export declare function isHtmlElement(value: unknown): value is HTMLElement;
export declare function isInfinite(value: unknown): value is number;
export declare function isInRange(value: number, range: number | [number, number]): value is number;
export declare function isInt16Array(value: unknown): value is Int16Array;
export declare function isInt32Array(value: unknown): value is Int32Array;
export declare function isInt8Array(value: unknown): value is Int8Array;
export declare function isInteger(value: unknown): value is number;
export declare function isIterable<T = unknown>(value: unknown): value is Iterable<T>;
export declare function isMap<Key = unknown, Value = unknown>(value: unknown): value is Map<Key, Value>;
export declare function isNan(value: unknown): boolean;
export declare function isNativePromise<T = unknown>(value: unknown): value is Promise<T>;
export declare function isNegativeNumber(value: unknown): value is number;
export declare function isNodeStream(value: unknown): value is NodeStream;
export declare function isNonEmptyArray<T = unknown, Item = unknown>(value: T | Item[]): value is [Item, ...Item[]];
export declare function isNonEmptyMap<Key = unknown, Value = unknown>(value: unknown): value is Map<Key, Value>;
export declare function isNonEmptyObject<Key extends keyof any = string, Value = unknown>(value: unknown): value is Record<Key, Value>;
export declare function isNonEmptySet<T = unknown>(value: unknown): value is Set<T>;
export declare function isNonEmptyString(value: unknown): value is string;
export declare function isNonEmptyStringAndNotWhitespace(value: unknown): value is string;
export declare function isNull(value: unknown): value is null;
export declare function isNullOrUndefined(value: unknown): value is null | undefined;
export declare function isNumber(value: unknown): value is number;
export declare function isNumericString(value: unknown): value is `${number}`;
export declare function isObject(value: unknown): value is object;
export declare function isObservable(value: unknown): value is ObservableLike;
export declare function isOddInteger(value: unknown): value is number;
export declare function isPlainObject<Value = unknown>(value: unknown): value is Record<PropertyKey, Value>;
export declare function isPositiveNumber(value: unknown): value is number;
export declare function isPrimitive(value: unknown): value is Primitive;
export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
export declare function isPropertyKey(value: unknown): value is PropertyKey;
export declare function isRegExp(value: unknown): value is RegExp;
export declare function isSafeInteger(value: unknown): value is number;
export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
export declare function isSharedArrayBuffer(value: unknown): value is SharedArrayBuffer;
export declare function isString(value: unknown): value is string;
export declare function isSymbol(value: unknown): value is symbol;
export declare function isTruthy<T>(value: T | Falsy): value is T;
type TypeGuard<T> = (value: unknown) => value is T;
type ResolveTypesOfTypeGuardsTuple<TypeGuardsOfT, ResultOfT extends unknown[] = []> = TypeGuardsOfT extends [TypeGuard<infer U>, ...infer TOthers] ? ResolveTypesOfTypeGuardsTuple<TOthers, [...ResultOfT, U]> : TypeGuardsOfT extends undefined[] ? ResultOfT : never;
export type NodeStream = {
pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
end?: boolean;
}): T;
} & NodeJS.EventEmitter;
export type Predicate = (value: unknown) => boolean;
export declare const enum AssertionTypeDescription {
class_ = "Class",
numericString = "string with a number",
nullOrUndefined = "null or undefined",
iterable = "Iterable",
asyncIterable = "AsyncIterable",
nativePromise = "native Promise",
urlString = "string with a URL",
truthy = "truthy",
falsy = "falsy",
nan = "NaN",
primitive = "primitive",
integer = "integer",
safeInteger = "integer",
plainObject = "plain object",
arrayLike = "array-like",
tupleLike = "tuple-like",
typedArray = "TypedArray",
domElement = "HTMLElement",
nodeStream = "Node.js Stream",
infinite = "infinite number",
emptyArray = "empty array",
nonEmptyArray = "non-empty array",
emptyString = "empty string",
emptyStringOrWhitespace = "empty string or whitespace",
nonEmptyString = "non-empty string",
nonEmptyStringAndNotWhitespace = "non-empty string and not whitespace",
emptyObject = "empty object",
nonEmptyObject = "non-empty object",
emptySet = "empty set",
nonEmptySet = "non-empty set",
emptyMap = "empty map",
nonEmptyMap = "non-empty map",
evenInteger = "even integer",
oddInteger = "odd integer",
positiveNumber = "positive number",
negativeNumber = "negative number",
directInstanceOf = "T",
inRange = "in range",
any = "predicate returns truthy for any value",
all = "predicate returns truthy for all values"
}
export declare function isTupleLike<T extends Array<TypeGuard<unknown>>>(value: unknown, guards: [...T]): value is ResolveTypesOfTypeGuardsTuple<T>;
export declare function isTypedArray(value: unknown): value is TypedArray;
export declare function isUint16Array(value: unknown): value is Uint16Array;
export declare function isUint32Array(value: unknown): value is Uint32Array;
export declare function isUint8Array(value: unknown): value is Uint8Array;
export declare function isUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
export declare function isUndefined(value: unknown): value is undefined;
export declare function isUrlInstance(value: unknown): value is URL;
export declare function isUrlSearchParams(value: unknown): value is URLSearchParams;
export declare function isUrlString(value: unknown): value is string;
export declare function isValidLength(value: unknown): value is number;
export declare function isWeakMap<Key extends object = object, Value = unknown>(value: unknown): value is WeakMap<Key, Value>;
export declare function isWeakRef(value: unknown): value is WeakRef<object>;
export declare function isWeakSet(value: unknown): value is WeakSet<object>;
export declare function isWhitespaceString(value: unknown): value is string;
type Assert = {

@@ -163,4 +211,10 @@ undefined: (value: unknown) => asserts value is undefined;

bigint: (value: unknown) => asserts value is bigint;
function: (value: unknown) => asserts value is Function;
/** @deprecated Renamed to `function`. */
function_: (value: unknown) => asserts value is Function;
null: (value: unknown) => asserts value is null;
/** @deprecated Renamed to `null`. */
null_: (value: unknown) => asserts value is null;
class: (value: unknown) => asserts value is Class;
/** @deprecated Renamed to `class`. */
class_: (value: unknown) => asserts value is Class;

@@ -220,3 +274,5 @@ boolean: (value: unknown) => asserts value is boolean;

tupleLike: <T extends Array<TypeGuard<unknown>>>(value: unknown, guards: [...T]) => asserts value is ResolveTypesOfTypeGuardsTuple<T>;
/** @deprecated Renamed to `htmlElement` */
domElement: (value: unknown) => asserts value is HTMLElement;
htmlElement: (value: unknown) => asserts value is HTMLElement;
observable: (value: unknown) => asserts value is ObservableLike;

@@ -240,6 +296,8 @@ nodeStream: (value: unknown) => asserts value is NodeStream;

urlSearchParams: (value: unknown) => asserts value is URLSearchParams;
validLength: (value: unknown) => asserts value is number;
whitespaceString: (value: unknown) => asserts value is string;
evenInteger: (value: number) => asserts value is number;
oddInteger: (value: number) => asserts value is number;
directInstanceOf: <T>(instance: unknown, class_: Class<T>) => asserts instance is T;
inRange: (value: number, range: number | number[]) => asserts value is number;
inRange: (value: number, range: number | [number, number]) => asserts value is number;
any: (predicate: Predicate | Predicate[], ...values: unknown[]) => void | never;

@@ -249,3 +307,92 @@ all: (predicate: Predicate, ...values: unknown[]) => void | never;

export declare const assert: Assert;
export declare function assertAll(predicate: Predicate, ...values: unknown[]): void | never;
export declare function assertAny(predicate: Predicate | Predicate[], ...values: unknown[]): void | never;
export declare function assertArray<T = unknown>(value: unknown, assertion?: (element: unknown) => asserts element is T): asserts value is T[];
export declare function assertArrayBuffer(value: unknown): asserts value is ArrayBuffer;
export declare function assertArrayLike<T = unknown>(value: unknown): asserts value is ArrayLike<T>;
export declare function assertAsyncFunction(value: unknown): asserts value is Function;
export declare function assertAsyncGenerator(value: unknown): asserts value is AsyncGenerator;
export declare function assertAsyncGeneratorFunction(value: unknown): asserts value is AsyncGeneratorFunction;
export declare function assertAsyncIterable<T = unknown>(value: unknown): asserts value is AsyncIterable<T>;
export declare function assertBigint(value: unknown): asserts value is bigint;
export declare function assertBigInt64Array(value: unknown): asserts value is BigInt64Array;
export declare function assertBigUint64Array(value: unknown): asserts value is BigUint64Array;
export declare function assertBlob(value: unknown): asserts value is Blob;
export declare function assertBoolean(value: unknown): asserts value is boolean;
export declare function assertBoundFunction(value: unknown): asserts value is Function;
export declare function assertBuffer(value: unknown): asserts value is Buffer;
export declare function assertClass(value: unknown): asserts value is Class;
export declare function assertDataView(value: unknown): asserts value is DataView;
export declare function assertDate(value: unknown): asserts value is Date;
export declare function assertDirectInstanceOf<T>(instance: unknown, class_: Class<T>): asserts instance is T;
export declare function assertEmptyArray(value: unknown): asserts value is never[];
export declare function assertEmptyMap(value: unknown): asserts value is Map<never, never>;
export declare function assertEmptyObject<Key extends keyof any = string>(value: unknown): asserts value is Record<Key, never>;
export declare function assertEmptySet(value: unknown): asserts value is Set<never>;
export declare function assertEmptyString(value: unknown): asserts value is '';
export declare function assertEmptyStringOrWhitespace(value: unknown): asserts value is string;
export declare function assertEnumCase<T = unknown>(value: unknown, targetEnum: T): asserts value is T[keyof T];
export declare function assertError(value: unknown): asserts value is Error;
export declare function assertEvenInteger(value: number): asserts value is number;
export declare function assertFalsy(value: unknown): asserts value is Falsy;
export declare function assertFloat32Array(value: unknown): asserts value is Float32Array;
export declare function assertFloat64Array(value: unknown): asserts value is Float64Array;
export declare function assertFormData(value: unknown): asserts value is FormData;
export declare function assertFunction(value: unknown): asserts value is Function;
export declare function assertGenerator(value: unknown): asserts value is Generator;
export declare function assertGeneratorFunction(value: unknown): asserts value is GeneratorFunction;
export declare function assertHtmlElement(value: unknown): asserts value is HTMLElement;
export declare function assertInfinite(value: unknown): asserts value is number;
export declare function assertInRange(value: number, range: number | [number, number]): asserts value is number;
export declare function assertInt16Array(value: unknown): asserts value is Int16Array;
export declare function assertInt32Array(value: unknown): asserts value is Int32Array;
export declare function assertInt8Array(value: unknown): asserts value is Int8Array;
export declare function assertInteger(value: unknown): asserts value is number;
export declare function assertIterable<T = unknown>(value: unknown): asserts value is Iterable<T>;
export declare function assertMap<Key = unknown, Value = unknown>(value: unknown): asserts value is Map<Key, Value>;
export declare function assertNan(value: unknown): asserts value is number;
export declare function assertNativePromise<T = unknown>(value: unknown): asserts value is Promise<T>;
export declare function assertNegativeNumber(value: unknown): asserts value is number;
export declare function assertNodeStream(value: unknown): asserts value is NodeStream;
export declare function assertNonEmptyArray<T = unknown, Item = unknown>(value: T | Item[]): asserts value is [Item, ...Item[]];
export declare function assertNonEmptyMap<Key = unknown, Value = unknown>(value: unknown): asserts value is Map<Key, Value>;
export declare function assertNonEmptyObject<Key extends keyof any = string, Value = unknown>(value: unknown): asserts value is Record<Key, Value>;
export declare function assertNonEmptySet<T = unknown>(value: unknown): asserts value is Set<T>;
export declare function assertNonEmptyString(value: unknown): asserts value is string;
export declare function assertNonEmptyStringAndNotWhitespace(value: unknown): asserts value is string;
export declare function assertNull(value: unknown): asserts value is null;
export declare function assertNullOrUndefined(value: unknown): asserts value is null | undefined;
export declare function assertNumber(value: unknown): asserts value is number;
export declare function assertNumericString(value: unknown): asserts value is `${number}`;
export declare function assertObject(value: unknown): asserts value is object;
export declare function assertObservable(value: unknown): asserts value is ObservableLike;
export declare function assertOddInteger(value: number): asserts value is number;
export declare function assertPlainObject<Value = unknown>(value: unknown): asserts value is Record<PropertyKey, Value>;
export declare function assertPositiveNumber(value: unknown): asserts value is number;
export declare function assertPrimitive(value: unknown): asserts value is Primitive;
export declare function assertPromise<T = unknown>(value: unknown): asserts value is Promise<T>;
export declare function assertPropertyKey(value: unknown): asserts value is number;
export declare function assertRegExp(value: unknown): asserts value is RegExp;
export declare function assertSafeInteger(value: unknown): asserts value is number;
export declare function assertSet<T = unknown>(value: unknown): asserts value is Set<T>;
export declare function assertSharedArrayBuffer(value: unknown): asserts value is SharedArrayBuffer;
export declare function assertString(value: unknown): asserts value is string;
export declare function assertSymbol(value: unknown): asserts value is symbol;
export declare function assertTruthy<T>(value: T | Falsy): asserts value is T;
export declare function assertTupleLike<T extends Array<TypeGuard<unknown>>>(value: unknown, guards: [...T]): asserts value is ResolveTypesOfTypeGuardsTuple<T>;
export declare function assertTypedArray(value: unknown): asserts value is TypedArray;
export declare function assertUint16Array(value: unknown): asserts value is Uint16Array;
export declare function assertUint32Array(value: unknown): asserts value is Uint32Array;
export declare function assertUint8Array(value: unknown): asserts value is Uint8Array;
export declare function assertUint8ClampedArray(value: unknown): asserts value is Uint8ClampedArray;
export declare function assertUndefined(value: unknown): asserts value is undefined;
export declare function assertUrlInstance(value: unknown): asserts value is URL;
export declare function assertUrlSearchParams(value: unknown): asserts value is URLSearchParams;
export declare function assertUrlString(value: unknown): asserts value is string;
export declare function assertValidLength(value: unknown): asserts value is number;
export declare function assertWeakMap<Key extends object = object, Value = unknown>(value: unknown): asserts value is WeakMap<Key, Value>;
export declare function assertWeakRef<T extends object = object>(value: unknown): asserts value is WeakRef<T>;
export declare function assertWeakSet<T extends object = object>(value: unknown): asserts value is WeakSet<T>;
export declare function assertWhitespaceString(value: unknown): asserts value is string;
export default is;
export type { Class, TypedArray, ObservableLike, Primitive } from './types.js';
export type { ArrayLike, Class, NodeStream, ObservableLike, Predicate, Primitive, TypedArray, } from './types.js';

1439

dist/index.js

@@ -63,10 +63,50 @@ const typedArrayTypeNames = [

}
// eslint-disable-next-line @typescript-eslint/ban-types
function isOfType(type) {
return (value) => typeof value === type;
}
const { toString } = Object.prototype;
const assertionTypeDescriptions = [
'positive number',
'negative number',
'Class',
'string with a number',
'null or undefined',
'Iterable',
'AsyncIterable',
'native Promise',
'EnumCase',
'string with a URL',
'truthy',
'falsy',
'primitive',
'integer',
'plain object',
'TypedArray',
'array-like',
'tuple-like',
'Node.js Stream',
'infinite number',
'empty array',
'non-empty array',
'empty string',
'empty string or whitespace',
'non-empty string',
'non-empty string and not whitespace',
'empty object',
'non-empty object',
'empty set',
'non-empty set',
'empty map',
'non-empty map',
'PropertyKey',
'even integer',
'odd integer',
'T',
'in range',
'predicate returns truthy for any value',
'predicate returns truthy for all values',
'valid length',
'whitespace string',
...objectTypeNames,
...primitiveTypeNames,
];
const getObjectType = (value) => {
const objectTypeName = toString.call(value).slice(8, -1);
if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
if (/HTML\w+Element/.test(objectTypeName) && isHtmlElement(value)) {
return 'HTMLElement';

@@ -79,4 +119,3 @@ }

};
const isObjectOfType = (type) => (value) => getObjectType(value) === type;
function is(value) {
function detect(value) {
if (value === null) {

@@ -109,9 +148,9 @@ return 'null';

}
if (is.observable(value)) {
if (isObservable(value)) {
return 'Observable';
}
if (is.array(value)) {
if (isArray(value)) {
return 'Array';
}
if (is.buffer(value)) {
if (isBuffer(value)) {
return 'Buffer';

@@ -128,22 +167,120 @@ }

}
is.undefined = isOfType('undefined');
is.string = isOfType('string');
const isNumberType = isOfType('number');
is.number = (value) => isNumberType(value) && !is.nan(value);
is.positiveNumber = (value) => is.number(value) && value > 0;
is.negativeNumber = (value) => is.number(value) && value < 0;
is.bigint = isOfType('bigint');
// eslint-disable-next-line @typescript-eslint/ban-types
is.function_ = isOfType('function');
// eslint-disable-next-line @typescript-eslint/ban-types
is.null_ = (value) => value === null;
is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
is.boolean = (value) => value === true || value === false;
is.symbol = isOfType('symbol');
is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
is.array = (value, assertion) => {
function hasPromiseApi(value) {
return isFunction(value?.then) && isFunction(value?.catch);
}
const is = Object.assign(detect, {
all: isAll,
any: isAny,
array: isArray,
arrayBuffer: isArrayBuffer,
arrayLike: isArrayLike,
asyncFunction: isAsyncFunction,
asyncGenerator: isAsyncGenerator,
asyncGeneratorFunction: isAsyncGeneratorFunction,
asyncIterable: isAsyncIterable,
bigint: isBigint,
bigInt64Array: isBigInt64Array,
bigUint64Array: isBigUint64Array,
blob: isBlob,
boolean: isBoolean,
boundFunction: isBoundFunction,
buffer: isBuffer,
class: isClass,
/** @deprecated Renamed to `class`. */
class_: isClass,
dataView: isDataView,
date: isDate,
detect,
directInstanceOf: isDirectInstanceOf,
/** @deprecated Renamed to `htmlElement` */
domElement: isHtmlElement,
emptyArray: isEmptyArray,
emptyMap: isEmptyMap,
emptyObject: isEmptyObject,
emptySet: isEmptySet,
emptyString: isEmptyString,
emptyStringOrWhitespace: isEmptyStringOrWhitespace,
enumCase: isEnumCase,
error: isError,
evenInteger: isEvenInteger,
falsy: isFalsy,
float32Array: isFloat32Array,
float64Array: isFloat64Array,
formData: isFormData,
function: isFunction,
/** @deprecated Renamed to `function`. */
function_: isFunction,
generator: isGenerator,
generatorFunction: isGeneratorFunction,
htmlElement: isHtmlElement,
infinite: isInfinite,
inRange: isInRange,
int16Array: isInt16Array,
int32Array: isInt32Array,
int8Array: isInt8Array,
integer: isInteger,
iterable: isIterable,
map: isMap,
nan: isNan,
nativePromise: isNativePromise,
negativeNumber: isNegativeNumber,
nodeStream: isNodeStream,
nonEmptyArray: isNonEmptyArray,
nonEmptyMap: isNonEmptyMap,
nonEmptyObject: isNonEmptyObject,
nonEmptySet: isNonEmptySet,
nonEmptyString: isNonEmptyString,
nonEmptyStringAndNotWhitespace: isNonEmptyStringAndNotWhitespace,
null: isNull,
/** @deprecated Renamed to `null`. */
null_: isNull,
nullOrUndefined: isNullOrUndefined,
number: isNumber,
numericString: isNumericString,
object: isObject,
observable: isObservable,
oddInteger: isOddInteger,
plainObject: isPlainObject,
positiveNumber: isPositiveNumber,
primitive: isPrimitive,
promise: isPromise,
propertyKey: isPropertyKey,
regExp: isRegExp,
safeInteger: isSafeInteger,
set: isSet,
sharedArrayBuffer: isSharedArrayBuffer,
string: isString,
symbol: isSymbol,
truthy: isTruthy,
tupleLike: isTupleLike,
typedArray: isTypedArray,
uint16Array: isUint16Array,
uint32Array: isUint32Array,
uint8Array: isUint8Array,
uint8ClampedArray: isUint8ClampedArray,
undefined: isUndefined,
urlInstance: isUrlInstance,
urlSearchParams: isUrlSearchParams,
urlString: isUrlString,
validLength: isValidLength,
weakMap: isWeakMap,
weakRef: isWeakRef,
weakSet: isWeakSet,
whitespaceString: isWhitespaceString,
});
function isAbsoluteMod2(remainder) {
return (value) => isInteger(value) && Math.abs(value % 2) === remainder;
}
export function isAll(predicate, ...values) {
return predicateOnArray(Array.prototype.every, predicate, values);
}
export function isAny(predicate, ...values) {
const predicates = isArray(predicate) ? predicate : [predicate];
return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
}
export function isArray(value, assertion) {
if (!Array.isArray(value)) {
return false;
}
if (!is.function_(assertion)) {
if (!isFunction(assertion)) {
return true;

@@ -153,94 +290,107 @@ }

return value.every(element => assertion(element));
};
// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
is.buffer = (value) => value?.constructor?.isBuffer?.(value) ?? false;
is.blob = (value) => isObjectOfType('Blob')(value);
is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value); // eslint-disable-line @typescript-eslint/ban-types
is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value)); // eslint-disable-line @typescript-eslint/ban-types
is.iterable = (value) => is.function_(value?.[Symbol.iterator]);
is.asyncIterable = (value) => is.function_(value?.[Symbol.asyncIterator]);
is.generator = (value) => is.iterable(value) && is.function_(value?.next) && is.function_(value?.throw);
is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
is.nativePromise = (value) => isObjectOfType('Promise')(value);
const hasPromiseApi = (value) => is.function_(value?.then)
&& is.function_(value?.catch);
is.promise = (value) => is.nativePromise(value) || hasPromiseApi(value);
is.generatorFunction = isObjectOfType('GeneratorFunction');
is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
is.regExp = isObjectOfType('RegExp');
is.date = isObjectOfType('Date');
is.error = isObjectOfType('Error');
is.map = (value) => isObjectOfType('Map')(value);
is.set = (value) => isObjectOfType('Set')(value);
is.weakMap = (value) => isObjectOfType('WeakMap')(value); // eslint-disable-line @typescript-eslint/ban-types
is.weakSet = (value) => isObjectOfType('WeakSet')(value); // eslint-disable-line @typescript-eslint/ban-types
is.weakRef = (value) => isObjectOfType('WeakRef')(value); // eslint-disable-line @typescript-eslint/ban-types
is.int8Array = isObjectOfType('Int8Array');
is.uint8Array = isObjectOfType('Uint8Array');
is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
is.int16Array = isObjectOfType('Int16Array');
is.uint16Array = isObjectOfType('Uint16Array');
is.int32Array = isObjectOfType('Int32Array');
is.uint32Array = isObjectOfType('Uint32Array');
is.float32Array = isObjectOfType('Float32Array');
is.float64Array = isObjectOfType('Float64Array');
is.bigInt64Array = isObjectOfType('BigInt64Array');
is.bigUint64Array = isObjectOfType('BigUint64Array');
is.arrayBuffer = isObjectOfType('ArrayBuffer');
is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
is.dataView = isObjectOfType('DataView');
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
is.enumCase = (value, targetEnum) => Object.values(targetEnum).includes(value);
is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
is.urlInstance = (value) => isObjectOfType('URL')(value);
is.urlString = (value) => {
if (!is.string(value)) {
return false;
}
try {
new URL(value); // eslint-disable-line no-new
return true;
}
catch {
return false;
}
};
// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
is.truthy = (value) => Boolean(value); // eslint-disable-line unicorn/prefer-native-coercion-functions
}
export function isArrayBuffer(value) {
return getObjectType(value) === 'ArrayBuffer';
}
export function isArrayLike(value) {
return !isNullOrUndefined(value) && !isFunction(value) && isValidLength(value.length);
}
export function isAsyncFunction(value) {
return getObjectType(value) === 'AsyncFunction';
}
export function isAsyncGenerator(value) {
return isAsyncIterable(value) && isFunction(value.next) && isFunction(value.throw);
}
export function isAsyncGeneratorFunction(value) {
return getObjectType(value) === 'AsyncGeneratorFunction';
}
export function isAsyncIterable(value) {
return isFunction(value?.[Symbol.asyncIterator]);
}
export function isBigint(value) {
return typeof value === 'bigint';
}
export function isBigInt64Array(value) {
return getObjectType(value) === 'BigInt64Array';
}
export function isBigUint64Array(value) {
return getObjectType(value) === 'BigUint64Array';
}
export function isBlob(value) {
return getObjectType(value) === 'Blob';
}
export function isBoolean(value) {
return value === true || value === false;
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isBoundFunction(value) {
return isFunction(value) && !Object.prototype.hasOwnProperty.call(value, 'prototype');
}
export function isBuffer(value) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
return value?.constructor?.isBuffer?.(value) ?? false;
}
export function isClass(value) {
return isFunction(value) && value.toString().startsWith('class ');
}
export function isDataView(value) {
return getObjectType(value) === 'DataView';
}
export function isDate(value) {
return getObjectType(value) === 'Date';
}
export function isDirectInstanceOf(instance, class_) {
return Object.getPrototypeOf(instance) === class_.prototype;
}
export function isEmptyArray(value) {
return isArray(value) && value.length === 0;
}
export function isEmptyMap(value) {
return isMap(value) && value.size === 0;
}
export function isEmptyObject(value) {
return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
}
export function isEmptySet(value) {
return isSet(value) && value.size === 0;
}
export function isEmptyString(value) {
return isString(value) && value.length === 0;
}
export function isEmptyStringOrWhitespace(value) {
return isEmptyString(value) || isWhitespaceString(value);
}
export function isEnumCase(value, targetEnum) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
return Object.values(targetEnum).includes(value);
}
export function isError(value) {
return getObjectType(value) === 'Error';
}
export function isEvenInteger(value) {
return isAbsoluteMod2(0)(value);
}
// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);`
is.falsy = (value) => !value;
is.nan = (value) => Number.isNaN(value);
is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
is.integer = (value) => Number.isInteger(value);
is.safeInteger = (value) => Number.isSafeInteger(value);
is.plainObject = (value) => {
// From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
if (typeof value !== 'object' || value === null) {
return false;
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const prototype = Object.getPrototypeOf(value);
return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
};
is.typedArray = (value) => isTypedArrayName(getObjectType(value));
const isValidLength = (value) => is.safeInteger(value) && value >= 0;
is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
is.tupleLike = (value, guards) => {
if (is.array(guards) && is.array(value) && guards.length === value.length) {
return guards.every((guard, index) => guard(value[index]));
}
return false;
};
is.inRange = (value, range) => {
if (is.number(range)) {
return value >= Math.min(0, range) && value <= Math.max(range, 0);
}
if (is.array(range) && range.length === 2) {
return value >= Math.min(...range) && value <= Math.max(...range);
}
throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
};
export function isFalsy(value) {
return !value;
}
export function isFloat32Array(value) {
return getObjectType(value) === 'Float32Array';
}
export function isFloat64Array(value) {
return getObjectType(value) === 'Float64Array';
}
export function isFormData(value) {
return getObjectType(value) === 'FormData';
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isFunction(value) {
return typeof value === 'function';
}
export function isGenerator(value) {
return isIterable(value) && isFunction(value?.next) && isFunction(value?.throw);
}
export function isGeneratorFunction(value) {
return getObjectType(value) === 'GeneratorFunction';
}
// eslint-disable-next-line @typescript-eslint/naming-convention

@@ -256,8 +406,92 @@ const NODE_TYPE_ELEMENT = 1;

];
is.domElement = (value) => is.object(value)
&& value.nodeType === NODE_TYPE_ELEMENT
&& is.string(value.nodeName)
&& !is.plainObject(value)
&& DOM_PROPERTIES_TO_CHECK.every(property => property in value);
is.observable = (value) => {
export function isHtmlElement(value) {
return isObject(value)
&& value.nodeType === NODE_TYPE_ELEMENT
&& isString(value.nodeName)
&& !isPlainObject(value)
&& DOM_PROPERTIES_TO_CHECK.every(property => property in value);
}
export function isInfinite(value) {
return value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
}
export function isInRange(value, range) {
if (isNumber(range)) {
return value >= Math.min(0, range) && value <= Math.max(range, 0);
}
if (isArray(range) && range.length === 2) {
return value >= Math.min(...range) && value <= Math.max(...range);
}
throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
}
export function isInt16Array(value) {
return getObjectType(value) === 'Int16Array';
}
export function isInt32Array(value) {
return getObjectType(value) === 'Int32Array';
}
export function isInt8Array(value) {
return getObjectType(value) === 'Int8Array';
}
export function isInteger(value) {
return Number.isInteger(value);
}
export function isIterable(value) {
return isFunction(value?.[Symbol.iterator]);
}
export function isMap(value) {
return getObjectType(value) === 'Map';
}
export function isNan(value) {
return Number.isNaN(value);
}
export function isNativePromise(value) {
return getObjectType(value) === 'Promise';
}
export function isNegativeNumber(value) {
return isNumber(value) && value < 0;
}
export function isNodeStream(value) {
return isObject(value) && isFunction(value.pipe) && !isObservable(value);
}
export function isNonEmptyArray(value) {
return isArray(value) && value.length > 0;
}
export function isNonEmptyMap(value) {
return isMap(value) && value.size > 0;
}
// TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
// - https://github.com/Microsoft/TypeScript/pull/29317
export function isNonEmptyObject(value) {
return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length > 0;
}
export function isNonEmptySet(value) {
return isSet(value) && value.size > 0;
}
// TODO: Use `not ''` when the `not` operator is available.
export function isNonEmptyString(value) {
return isString(value) && value.length > 0;
}
// TODO: Use `not ''` when the `not` operator is available.
export function isNonEmptyStringAndNotWhitespace(value) {
return isString(value) && !isEmptyStringOrWhitespace(value);
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isNull(value) {
return value === null;
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isNullOrUndefined(value) {
return isNull(value) || isUndefined(value);
}
export function isNumber(value) {
return typeof value === 'number' && !Number.isNaN(value);
}
export function isNumericString(value) {
return isString(value) && !isEmptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isObject(value) {
return !isNull(value) && (typeof value === 'object' || isFunction(value));
}
export function isObservable(value) {
if (!value) {

@@ -275,35 +509,114 @@ return false;

return false;
};
is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
is.infinite = (value) => value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
is.evenInteger = isAbsoluteMod2(0);
is.oddInteger = isAbsoluteMod2(1);
is.emptyArray = (value) => is.array(value) && value.length === 0;
is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
is.emptyString = (value) => is.string(value) && value.length === 0;
const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
// TODO: Use `not ''` when the `not` operator is available.
is.nonEmptyString = (value) => is.string(value) && value.length > 0;
// TODO: Use `not ''` when the `not` operator is available.
is.nonEmptyStringAndNotWhitespace = (value) => is.string(value) && !is.emptyStringOrWhitespace(value);
// eslint-disable-next-line unicorn/no-array-callback-reference
is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
// TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
// - https://github.com/Microsoft/TypeScript/pull/29317
// eslint-disable-next-line unicorn/no-array-callback-reference
is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
is.emptySet = (value) => is.set(value) && value.size === 0;
is.nonEmptySet = (value) => is.set(value) && value.size > 0;
// eslint-disable-next-line unicorn/no-array-callback-reference
is.emptyMap = (value) => is.map(value) && value.size === 0;
// eslint-disable-next-line unicorn/no-array-callback-reference
is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
}
export function isOddInteger(value) {
return isAbsoluteMod2(1)(value);
}
export function isPlainObject(value) {
// From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
if (typeof value !== 'object' || value === null) {
return false;
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const prototype = Object.getPrototypeOf(value);
return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
}
export function isPositiveNumber(value) {
return isNumber(value) && value > 0;
}
export function isPrimitive(value) {
return isNull(value) || isPrimitiveTypeName(typeof value);
}
export function isPromise(value) {
return isNativePromise(value) || hasPromiseApi(value);
}
// `PropertyKey` is any value that can be used as an object key (string, number, or symbol)
is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value);
is.formData = (value) => isObjectOfType('FormData')(value);
is.urlSearchParams = (value) => isObjectOfType('URLSearchParams')(value);
const predicateOnArray = (method, predicate, values) => {
if (!is.function_(predicate)) {
export function isPropertyKey(value) {
return isAny([isString, isNumber, isSymbol], value);
}
export function isRegExp(value) {
return getObjectType(value) === 'RegExp';
}
export function isSafeInteger(value) {
return Number.isSafeInteger(value);
}
export function isSet(value) {
return getObjectType(value) === 'Set';
}
export function isSharedArrayBuffer(value) {
return getObjectType(value) === 'SharedArrayBuffer';
}
export function isString(value) {
return typeof value === 'string';
}
export function isSymbol(value) {
return typeof value === 'symbol';
}
// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
// eslint-disable-next-line unicorn/prefer-native-coercion-functions
export function isTruthy(value) {
return Boolean(value);
}
export function isTupleLike(value, guards) {
if (isArray(guards) && isArray(value) && guards.length === value.length) {
return guards.every((guard, index) => guard(value[index]));
}
return false;
}
export function isTypedArray(value) {
return isTypedArrayName(getObjectType(value));
}
export function isUint16Array(value) {
return getObjectType(value) === 'Uint16Array';
}
export function isUint32Array(value) {
return getObjectType(value) === 'Uint32Array';
}
export function isUint8Array(value) {
return getObjectType(value) === 'Uint8Array';
}
export function isUint8ClampedArray(value) {
return getObjectType(value) === 'Uint8ClampedArray';
}
export function isUndefined(value) {
return value === undefined;
}
export function isUrlInstance(value) {
return getObjectType(value) === 'URL';
}
// eslint-disable-next-line unicorn/prevent-abbreviations
export function isUrlSearchParams(value) {
return getObjectType(value) === 'URLSearchParams';
}
export function isUrlString(value) {
if (!isString(value)) {
return false;
}
try {
new URL(value); // eslint-disable-line no-new
return true;
}
catch {
return false;
}
}
export function isValidLength(value) {
return isSafeInteger(value) && value >= 0;
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isWeakMap(value) {
return getObjectType(value) === 'WeakMap';
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isWeakRef(value) {
return getObjectType(value) === 'WeakRef';
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function isWeakSet(value) {
return getObjectType(value) === 'WeakSet';
}
export function isWhitespaceString(value) {
return isString(value) && /^\s+$/.test(value);
}
function predicateOnArray(method, predicate, values) {
if (!isFunction(predicate)) {
throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);

@@ -315,148 +628,672 @@ }

return method.call(values, predicate);
}
function typeErrorMessage(description, value) {
return `Expected value which is \`${description}\`, received value of type \`${is(value)}\`.`;
}
function unique(values) {
// eslint-disable-next-line unicorn/prefer-spread
return Array.from(new Set(values));
}
const andFormatter = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' });
const orFormatter = new Intl.ListFormat('en', { style: 'long', type: 'disjunction' });
function typeErrorMessageMultipleValues(expectedType, values) {
const uniqueExpectedTypes = unique((isArray(expectedType) ? expectedType : [expectedType]).map(value => `\`${value}\``));
const uniqueValueTypes = unique(values.map(value => `\`${is(value)}\``));
return `Expected values which are ${orFormatter.format(uniqueExpectedTypes)}. Received values of type${uniqueValueTypes.length > 1 ? 's' : ''} ${andFormatter.format(uniqueValueTypes)}.`;
}
export const assert = {
all: assertAll,
any: assertAny,
array: assertArray,
arrayBuffer: assertArrayBuffer,
arrayLike: assertArrayLike,
asyncFunction: assertAsyncFunction,
asyncGenerator: assertAsyncGenerator,
asyncGeneratorFunction: assertAsyncGeneratorFunction,
asyncIterable: assertAsyncIterable,
bigint: assertBigint,
bigInt64Array: assertBigInt64Array,
bigUint64Array: assertBigUint64Array,
blob: assertBlob,
boolean: assertBoolean,
boundFunction: assertBoundFunction,
buffer: assertBuffer,
class: assertClass,
class_: assertClass,
dataView: assertDataView,
date: assertDate,
directInstanceOf: assertDirectInstanceOf,
domElement: assertHtmlElement,
emptyArray: assertEmptyArray,
emptyMap: assertEmptyMap,
emptyObject: assertEmptyObject,
emptySet: assertEmptySet,
emptyString: assertEmptyString,
emptyStringOrWhitespace: assertEmptyStringOrWhitespace,
enumCase: assertEnumCase,
error: assertError,
evenInteger: assertEvenInteger,
falsy: assertFalsy,
float32Array: assertFloat32Array,
float64Array: assertFloat64Array,
formData: assertFormData,
function: assertFunction,
function_: assertFunction,
generator: assertGenerator,
generatorFunction: assertGeneratorFunction,
htmlElement: assertHtmlElement,
infinite: assertInfinite,
inRange: assertInRange,
int16Array: assertInt16Array,
int32Array: assertInt32Array,
int8Array: assertInt8Array,
integer: assertInteger,
iterable: assertIterable,
map: assertMap,
nan: assertNan,
nativePromise: assertNativePromise,
negativeNumber: assertNegativeNumber,
nodeStream: assertNodeStream,
nonEmptyArray: assertNonEmptyArray,
nonEmptyMap: assertNonEmptyMap,
nonEmptyObject: assertNonEmptyObject,
nonEmptySet: assertNonEmptySet,
nonEmptyString: assertNonEmptyString,
nonEmptyStringAndNotWhitespace: assertNonEmptyStringAndNotWhitespace,
null: assertNull,
null_: assertNull,
nullOrUndefined: assertNullOrUndefined,
number: assertNumber,
numericString: assertNumericString,
object: assertObject,
observable: assertObservable,
oddInteger: assertOddInteger,
plainObject: assertPlainObject,
positiveNumber: assertPositiveNumber,
primitive: assertPrimitive,
promise: assertPromise,
propertyKey: assertPropertyKey,
regExp: assertRegExp,
safeInteger: assertSafeInteger,
set: assertSet,
sharedArrayBuffer: assertSharedArrayBuffer,
string: assertString,
symbol: assertSymbol,
truthy: assertTruthy,
tupleLike: assertTupleLike,
typedArray: assertTypedArray,
uint16Array: assertUint16Array,
uint32Array: assertUint32Array,
uint8Array: assertUint8Array,
uint8ClampedArray: assertUint8ClampedArray,
undefined: assertUndefined,
urlInstance: assertUrlInstance,
urlSearchParams: assertUrlSearchParams,
urlString: assertUrlString,
validLength: assertValidLength,
weakMap: assertWeakMap,
weakRef: assertWeakRef,
weakSet: assertWeakSet,
whitespaceString: assertWhitespaceString,
};
is.any = (predicate, ...values) => {
const predicates = is.array(predicate) ? predicate : [predicate];
return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
const methodTypeMap = {
isArray: 'Array',
isArrayBuffer: 'ArrayBuffer',
isArrayLike: 'array-like',
isAsyncFunction: 'AsyncFunction',
isAsyncGenerator: 'AsyncGenerator',
isAsyncGeneratorFunction: 'AsyncGeneratorFunction',
isAsyncIterable: 'AsyncIterable',
isBigint: 'bigint',
isBigInt64Array: 'BigInt64Array',
isBigUint64Array: 'BigUint64Array',
isBlob: 'Blob',
isBoolean: 'boolean',
isBoundFunction: 'Function',
isBuffer: 'Buffer',
isClass: 'Class',
isDataView: 'DataView',
isDate: 'Date',
isDirectInstanceOf: 'T',
/** @deprecated */
isDomElement: 'HTMLElement',
isEmptyArray: 'empty array',
isEmptyMap: 'empty map',
isEmptyObject: 'empty object',
isEmptySet: 'empty set',
isEmptyString: 'empty string',
isEmptyStringOrWhitespace: 'empty string or whitespace',
isEnumCase: 'EnumCase',
isError: 'Error',
isEvenInteger: 'even integer',
isFalsy: 'falsy',
isFloat32Array: 'Float32Array',
isFloat64Array: 'Float64Array',
isFormData: 'FormData',
isFunction: 'Function',
isGenerator: 'Generator',
isGeneratorFunction: 'GeneratorFunction',
isHtmlElement: 'HTMLElement',
isInfinite: 'infinite number',
isInRange: 'in range',
isInt16Array: 'Int16Array',
isInt32Array: 'Int32Array',
isInt8Array: 'Int8Array',
isInteger: 'integer',
isIterable: 'Iterable',
isMap: 'Map',
isNan: 'NaN',
isNativePromise: 'native Promise',
isNegativeNumber: 'negative number',
isNodeStream: 'Node.js Stream',
isNonEmptyArray: 'non-empty array',
isNonEmptyMap: 'non-empty map',
isNonEmptyObject: 'non-empty object',
isNonEmptySet: 'non-empty set',
isNonEmptyString: 'non-empty string',
isNonEmptyStringAndNotWhitespace: 'non-empty string and not whitespace',
isNull: 'null',
isNullOrUndefined: 'null or undefined',
isNumber: 'number',
isNumericString: 'string with a number',
isObject: 'Object',
isObservable: 'Observable',
isOddInteger: 'odd integer',
isPlainObject: 'plain object',
isPositiveNumber: 'positive number',
isPrimitive: 'primitive',
isPromise: 'Promise',
isPropertyKey: 'PropertyKey',
isRegExp: 'RegExp',
isSafeInteger: 'integer',
isSet: 'Set',
isSharedArrayBuffer: 'SharedArrayBuffer',
isString: 'string',
isSymbol: 'symbol',
isTruthy: 'truthy',
isTupleLike: 'tuple-like',
isTypedArray: 'TypedArray',
isUint16Array: 'Uint16Array',
isUint32Array: 'Uint32Array',
isUint8Array: 'Uint8Array',
isUint8ClampedArray: 'Uint8ClampedArray',
isUndefined: 'undefined',
isUrlInstance: 'URL',
isUrlSearchParams: 'URLSearchParams',
isUrlString: 'string with a URL',
isValidLength: 'valid length',
isWeakMap: 'WeakMap',
isWeakRef: 'WeakRef',
isWeakSet: 'WeakSet',
isWhitespaceString: 'whitespace string',
};
is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
const assertType = (condition, description, value, options = {}) => {
if (!condition) {
const { multipleValues } = options;
const valuesMessage = multipleValues
? `received values of types ${[
...new Set(value.map(singleValue => `\`${is(singleValue)}\``)),
].join(', ')}`
: `received value of type \`${is(value)}\``;
throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
function keysOf(value) {
return Object.keys(value);
}
const isMethodNames = keysOf(methodTypeMap);
function isIsMethodName(value) {
return isMethodNames.includes(value);
}
export function assertAll(predicate, ...values) {
if (!isAll(predicate, ...values)) {
const expectedType = isIsMethodName(predicate.name) ? methodTypeMap[predicate.name] : 'predicate returns truthy for all values';
throw new TypeError(typeErrorMessageMultipleValues(expectedType, values));
}
};
/* eslint-disable @typescript-eslint/no-confusing-void-expression */
export const assert = {
// Unknowns.
undefined: (value) => assertType(is.undefined(value), 'undefined', value),
string: (value) => assertType(is.string(value), 'string', value),
number: (value) => assertType(is.number(value), 'number', value),
positiveNumber: (value) => assertType(is.positiveNumber(value), "positive number" /* AssertionTypeDescription.positiveNumber */, value),
negativeNumber: (value) => assertType(is.negativeNumber(value), "negative number" /* AssertionTypeDescription.negativeNumber */, value),
bigint: (value) => assertType(is.bigint(value), 'bigint', value),
// eslint-disable-next-line @typescript-eslint/ban-types
function_: (value) => assertType(is.function_(value), 'Function', value),
null_: (value) => assertType(is.null_(value), 'null', value),
class_: (value) => assertType(is.class_(value), "Class" /* AssertionTypeDescription.class_ */, value),
boolean: (value) => assertType(is.boolean(value), 'boolean', value),
symbol: (value) => assertType(is.symbol(value), 'symbol', value),
numericString: (value) => assertType(is.numericString(value), "string with a number" /* AssertionTypeDescription.numericString */, value),
array: (value, assertion) => {
const assert = assertType;
assert(is.array(value), 'Array', value);
if (assertion) {
// eslint-disable-next-line unicorn/no-array-for-each, unicorn/no-array-callback-reference
value.forEach(assertion);
}
},
buffer: (value) => assertType(is.buffer(value), 'Buffer', value),
blob: (value) => assertType(is.blob(value), 'Blob', value),
nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* AssertionTypeDescription.nullOrUndefined */, value),
object: (value) => assertType(is.object(value), 'Object', value),
iterable: (value) => assertType(is.iterable(value), "Iterable" /* AssertionTypeDescription.iterable */, value),
asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* AssertionTypeDescription.asyncIterable */, value),
generator: (value) => assertType(is.generator(value), 'Generator', value),
asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* AssertionTypeDescription.nativePromise */, value),
promise: (value) => assertType(is.promise(value), 'Promise', value),
generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
// eslint-disable-next-line @typescript-eslint/ban-types
asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
// eslint-disable-next-line @typescript-eslint/ban-types
boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
date: (value) => assertType(is.date(value), 'Date', value),
error: (value) => assertType(is.error(value), 'Error', value),
map: (value) => assertType(is.map(value), 'Map', value),
set: (value) => assertType(is.set(value), 'Set', value),
weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value),
weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value),
weakRef: (value) => assertType(is.weakRef(value), 'WeakRef', value),
int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value),
uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value),
uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value),
uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value),
int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value),
uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value),
float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value),
float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value),
bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
dataView: (value) => assertType(is.dataView(value), 'DataView', value),
enumCase: (value, targetEnum) => assertType(is.enumCase(value, targetEnum), 'EnumCase', value),
urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value),
urlString: (value) => assertType(is.urlString(value), "string with a URL" /* AssertionTypeDescription.urlString */, value),
truthy: (value) => assertType(is.truthy(value), "truthy" /* AssertionTypeDescription.truthy */, value),
falsy: (value) => assertType(is.falsy(value), "falsy" /* AssertionTypeDescription.falsy */, value),
nan: (value) => assertType(is.nan(value), "NaN" /* AssertionTypeDescription.nan */, value),
primitive: (value) => assertType(is.primitive(value), "primitive" /* AssertionTypeDescription.primitive */, value),
integer: (value) => assertType(is.integer(value), "integer" /* AssertionTypeDescription.integer */, value),
safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* AssertionTypeDescription.safeInteger */, value),
plainObject: (value) => assertType(is.plainObject(value), "plain object" /* AssertionTypeDescription.plainObject */, value),
typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* AssertionTypeDescription.typedArray */, value),
arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* AssertionTypeDescription.arrayLike */, value),
tupleLike: (value, guards) => assertType(is.tupleLike(value, guards), "tuple-like" /* AssertionTypeDescription.tupleLike */, value),
domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* AssertionTypeDescription.domElement */, value),
observable: (value) => assertType(is.observable(value), 'Observable', value),
nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* AssertionTypeDescription.nodeStream */, value),
infinite: (value) => assertType(is.infinite(value), "infinite number" /* AssertionTypeDescription.infinite */, value),
emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* AssertionTypeDescription.emptyArray */, value),
nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* AssertionTypeDescription.nonEmptyArray */, value),
emptyString: (value) => assertType(is.emptyString(value), "empty string" /* AssertionTypeDescription.emptyString */, value),
emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* AssertionTypeDescription.emptyStringOrWhitespace */, value),
nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* AssertionTypeDescription.nonEmptyString */, value),
nonEmptyStringAndNotWhitespace: (value) => assertType(is.nonEmptyStringAndNotWhitespace(value), "non-empty string and not whitespace" /* AssertionTypeDescription.nonEmptyStringAndNotWhitespace */, value),
emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* AssertionTypeDescription.emptyObject */, value),
nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* AssertionTypeDescription.nonEmptyObject */, value),
emptySet: (value) => assertType(is.emptySet(value), "empty set" /* AssertionTypeDescription.emptySet */, value),
nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* AssertionTypeDescription.nonEmptySet */, value),
emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* AssertionTypeDescription.emptyMap */, value),
nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* AssertionTypeDescription.nonEmptyMap */, value),
propertyKey: (value) => assertType(is.propertyKey(value), 'PropertyKey', value),
formData: (value) => assertType(is.formData(value), 'FormData', value),
urlSearchParams: (value) => assertType(is.urlSearchParams(value), 'URLSearchParams', value),
// Numbers.
evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* AssertionTypeDescription.evenInteger */, value),
oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* AssertionTypeDescription.oddInteger */, value),
// Two arguments.
directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* AssertionTypeDescription.directInstanceOf */, instance),
inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* AssertionTypeDescription.inRange */, value),
// Variadic functions.
any: (predicate, ...values) => assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* AssertionTypeDescription.any */, values, { multipleValues: true }),
all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* AssertionTypeDescription.all */, values, { multipleValues: true }),
};
/* eslint-enable @typescript-eslint/no-confusing-void-expression */
// Some few keywords are reserved, but we'll populate them for Node.js users
// See https://github.com/Microsoft/TypeScript/issues/2536
Object.defineProperties(is, {
class: {
value: is.class_,
},
function: {
value: is.function_,
},
null: {
value: is.null_,
},
});
Object.defineProperties(assert, {
class: {
value: assert.class_,
},
function: {
value: assert.function_,
},
null: {
value: assert.null_,
},
});
}
export function assertAny(predicate, ...values) {
if (!isAny(predicate, ...values)) {
const predicates = isArray(predicate) ? predicate : [predicate];
const expectedTypes = predicates.map(predicate => isIsMethodName(predicate.name) ? methodTypeMap[predicate.name] : 'predicate returns truthy for any value');
throw new TypeError(typeErrorMessageMultipleValues(expectedTypes, values));
}
}
export function assertArray(value, assertion) {
if (!isArray(value)) {
throw new TypeError(typeErrorMessage('Array', value));
}
if (assertion) {
// eslint-disable-next-line unicorn/no-array-for-each, unicorn/no-array-callback-reference
value.forEach(assertion);
}
}
export function assertArrayBuffer(value) {
if (!isArrayBuffer(value)) {
throw new TypeError(typeErrorMessage('ArrayBuffer', value));
}
}
export function assertArrayLike(value) {
if (!isArrayLike(value)) {
throw new TypeError(typeErrorMessage('array-like', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertAsyncFunction(value) {
if (!isAsyncFunction(value)) {
throw new TypeError(typeErrorMessage('AsyncFunction', value));
}
}
export function assertAsyncGenerator(value) {
if (!isAsyncGenerator(value)) {
throw new TypeError(typeErrorMessage('AsyncGenerator', value));
}
}
export function assertAsyncGeneratorFunction(value) {
if (!isAsyncGeneratorFunction(value)) {
throw new TypeError(typeErrorMessage('AsyncGeneratorFunction', value));
}
}
export function assertAsyncIterable(value) {
if (!isAsyncIterable(value)) {
throw new TypeError(typeErrorMessage('AsyncIterable', value));
}
}
export function assertBigint(value) {
if (!isBigint(value)) {
throw new TypeError(typeErrorMessage('bigint', value));
}
}
export function assertBigInt64Array(value) {
if (!isBigInt64Array(value)) {
throw new TypeError(typeErrorMessage('BigInt64Array', value));
}
}
export function assertBigUint64Array(value) {
if (!isBigUint64Array(value)) {
throw new TypeError(typeErrorMessage('BigUint64Array', value));
}
}
export function assertBlob(value) {
if (!isBlob(value)) {
throw new TypeError(typeErrorMessage('Blob', value));
}
}
export function assertBoolean(value) {
if (!isBoolean(value)) {
throw new TypeError(typeErrorMessage('boolean', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertBoundFunction(value) {
if (!isBoundFunction(value)) {
throw new TypeError(typeErrorMessage('Function', value));
}
}
export function assertBuffer(value) {
if (!isBuffer(value)) {
throw new TypeError(typeErrorMessage('Buffer', value));
}
}
export function assertClass(value) {
if (!isClass(value)) {
throw new TypeError(typeErrorMessage('Class', value));
}
}
export function assertDataView(value) {
if (!isDataView(value)) {
throw new TypeError(typeErrorMessage('DataView', value));
}
}
export function assertDate(value) {
if (!isDate(value)) {
throw new TypeError(typeErrorMessage('Date', value));
}
}
export function assertDirectInstanceOf(instance, class_) {
if (!isDirectInstanceOf(instance, class_)) {
throw new TypeError(typeErrorMessage('T', instance));
}
}
export function assertEmptyArray(value) {
if (!isEmptyArray(value)) {
throw new TypeError(typeErrorMessage('empty array', value));
}
}
export function assertEmptyMap(value) {
if (!isEmptyMap(value)) {
throw new TypeError(typeErrorMessage('empty map', value));
}
}
export function assertEmptyObject(value) {
if (!isEmptyObject(value)) {
throw new TypeError(typeErrorMessage('empty object', value));
}
}
export function assertEmptySet(value) {
if (!isEmptySet(value)) {
throw new TypeError(typeErrorMessage('empty set', value));
}
}
export function assertEmptyString(value) {
if (!isEmptyString(value)) {
throw new TypeError(typeErrorMessage('empty string', value));
}
}
export function assertEmptyStringOrWhitespace(value) {
if (!isEmptyStringOrWhitespace(value)) {
throw new TypeError(typeErrorMessage('empty string or whitespace', value));
}
}
export function assertEnumCase(value, targetEnum) {
if (!isEnumCase(value, targetEnum)) {
throw new TypeError(typeErrorMessage('EnumCase', value));
}
}
export function assertError(value) {
if (!isError(value)) {
throw new TypeError(typeErrorMessage('Error', value));
}
}
export function assertEvenInteger(value) {
if (!isEvenInteger(value)) {
throw new TypeError(typeErrorMessage('even integer', value));
}
}
export function assertFalsy(value) {
if (!isFalsy(value)) {
throw new TypeError(typeErrorMessage('falsy', value));
}
}
export function assertFloat32Array(value) {
if (!isFloat32Array(value)) {
throw new TypeError(typeErrorMessage('Float32Array', value));
}
}
export function assertFloat64Array(value) {
if (!isFloat64Array(value)) {
throw new TypeError(typeErrorMessage('Float64Array', value));
}
}
export function assertFormData(value) {
if (!isFormData(value)) {
throw new TypeError(typeErrorMessage('FormData', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertFunction(value) {
if (!isFunction(value)) {
throw new TypeError(typeErrorMessage('Function', value));
}
}
export function assertGenerator(value) {
if (!isGenerator(value)) {
throw new TypeError(typeErrorMessage('Generator', value));
}
}
export function assertGeneratorFunction(value) {
if (!isGeneratorFunction(value)) {
throw new TypeError(typeErrorMessage('GeneratorFunction', value));
}
}
export function assertHtmlElement(value) {
if (!isHtmlElement(value)) {
throw new TypeError(typeErrorMessage('HTMLElement', value));
}
}
export function assertInfinite(value) {
if (!isInfinite(value)) {
throw new TypeError(typeErrorMessage('infinite number', value));
}
}
export function assertInRange(value, range) {
if (!isInRange(value, range)) {
throw new TypeError(typeErrorMessage('in range', value));
}
}
export function assertInt16Array(value) {
if (!isInt16Array(value)) {
throw new TypeError(typeErrorMessage('Int16Array', value));
}
}
export function assertInt32Array(value) {
if (!isInt32Array(value)) {
throw new TypeError(typeErrorMessage('Int32Array', value));
}
}
export function assertInt8Array(value) {
if (!isInt8Array(value)) {
throw new TypeError(typeErrorMessage('Int8Array', value));
}
}
export function assertInteger(value) {
if (!isInteger(value)) {
throw new TypeError(typeErrorMessage('integer', value));
}
}
export function assertIterable(value) {
if (!isIterable(value)) {
throw new TypeError(typeErrorMessage('Iterable', value));
}
}
export function assertMap(value) {
if (!isMap(value)) {
throw new TypeError(typeErrorMessage('Map', value));
}
}
export function assertNan(value) {
if (!isNan(value)) {
throw new TypeError(typeErrorMessage('NaN', value));
}
}
export function assertNativePromise(value) {
if (!isNativePromise(value)) {
throw new TypeError(typeErrorMessage('native Promise', value));
}
}
export function assertNegativeNumber(value) {
if (!isNegativeNumber(value)) {
throw new TypeError(typeErrorMessage('negative number', value));
}
}
export function assertNodeStream(value) {
if (!isNodeStream(value)) {
throw new TypeError(typeErrorMessage('Node.js Stream', value));
}
}
export function assertNonEmptyArray(value) {
if (!isNonEmptyArray(value)) {
throw new TypeError(typeErrorMessage('non-empty array', value));
}
}
export function assertNonEmptyMap(value) {
if (!isNonEmptyMap(value)) {
throw new TypeError(typeErrorMessage('non-empty map', value));
}
}
export function assertNonEmptyObject(value) {
if (!isNonEmptyObject(value)) {
throw new TypeError(typeErrorMessage('non-empty object', value));
}
}
export function assertNonEmptySet(value) {
if (!isNonEmptySet(value)) {
throw new TypeError(typeErrorMessage('non-empty set', value));
}
}
export function assertNonEmptyString(value) {
if (!isNonEmptyString(value)) {
throw new TypeError(typeErrorMessage('non-empty string', value));
}
}
export function assertNonEmptyStringAndNotWhitespace(value) {
if (!isNonEmptyStringAndNotWhitespace(value)) {
throw new TypeError(typeErrorMessage('non-empty string and not whitespace', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertNull(value) {
if (!isNull(value)) {
throw new TypeError(typeErrorMessage('null', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertNullOrUndefined(value) {
if (!isNullOrUndefined(value)) {
throw new TypeError(typeErrorMessage('null or undefined', value));
}
}
export function assertNumber(value) {
if (!isNumber(value)) {
throw new TypeError(typeErrorMessage('number', value));
}
}
export function assertNumericString(value) {
if (!isNumericString(value)) {
throw new TypeError(typeErrorMessage('string with a number', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertObject(value) {
if (!isObject(value)) {
throw new TypeError(typeErrorMessage('Object', value));
}
}
export function assertObservable(value) {
if (!isObservable(value)) {
throw new TypeError(typeErrorMessage('Observable', value));
}
}
export function assertOddInteger(value) {
if (!isOddInteger(value)) {
throw new TypeError(typeErrorMessage('odd integer', value));
}
}
export function assertPlainObject(value) {
if (!isPlainObject(value)) {
throw new TypeError(typeErrorMessage('plain object', value));
}
}
export function assertPositiveNumber(value) {
if (!isPositiveNumber(value)) {
throw new TypeError(typeErrorMessage('positive number', value));
}
}
export function assertPrimitive(value) {
if (!isPrimitive(value)) {
throw new TypeError(typeErrorMessage('primitive', value));
}
}
export function assertPromise(value) {
if (!isPromise(value)) {
throw new TypeError(typeErrorMessage('Promise', value));
}
}
export function assertPropertyKey(value) {
if (!isPropertyKey(value)) {
throw new TypeError(typeErrorMessage('PropertyKey', value));
}
}
export function assertRegExp(value) {
if (!isRegExp(value)) {
throw new TypeError(typeErrorMessage('RegExp', value));
}
}
export function assertSafeInteger(value) {
if (!isSafeInteger(value)) {
throw new TypeError(typeErrorMessage('integer', value));
}
}
export function assertSet(value) {
if (!isSet(value)) {
throw new TypeError(typeErrorMessage('Set', value));
}
}
export function assertSharedArrayBuffer(value) {
if (!isSharedArrayBuffer(value)) {
throw new TypeError(typeErrorMessage('SharedArrayBuffer', value));
}
}
export function assertString(value) {
if (!isString(value)) {
throw new TypeError(typeErrorMessage('string', value));
}
}
export function assertSymbol(value) {
if (!isSymbol(value)) {
throw new TypeError(typeErrorMessage('symbol', value));
}
}
export function assertTruthy(value) {
if (!isTruthy(value)) {
throw new TypeError(typeErrorMessage('truthy', value));
}
}
export function assertTupleLike(value, guards) {
if (!isTupleLike(value, guards)) {
throw new TypeError(typeErrorMessage('tuple-like', value));
}
}
export function assertTypedArray(value) {
if (!isTypedArray(value)) {
throw new TypeError(typeErrorMessage('TypedArray', value));
}
}
export function assertUint16Array(value) {
if (!isUint16Array(value)) {
throw new TypeError(typeErrorMessage('Uint16Array', value));
}
}
export function assertUint32Array(value) {
if (!isUint32Array(value)) {
throw new TypeError(typeErrorMessage('Uint32Array', value));
}
}
export function assertUint8Array(value) {
if (!isUint8Array(value)) {
throw new TypeError(typeErrorMessage('Uint8Array', value));
}
}
export function assertUint8ClampedArray(value) {
if (!isUint8ClampedArray(value)) {
throw new TypeError(typeErrorMessage('Uint8ClampedArray', value));
}
}
export function assertUndefined(value) {
if (!isUndefined(value)) {
throw new TypeError(typeErrorMessage('undefined', value));
}
}
export function assertUrlInstance(value) {
if (!isUrlInstance(value)) {
throw new TypeError(typeErrorMessage('URL', value));
}
}
// eslint-disable-next-line unicorn/prevent-abbreviations
export function assertUrlSearchParams(value) {
if (!isUrlSearchParams(value)) {
throw new TypeError(typeErrorMessage('URLSearchParams', value));
}
}
export function assertUrlString(value) {
if (!isUrlString(value)) {
throw new TypeError(typeErrorMessage('string with a URL', value));
}
}
export function assertValidLength(value) {
if (!isValidLength(value)) {
throw new TypeError(typeErrorMessage('valid length', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertWeakMap(value) {
if (!isWeakMap(value)) {
throw new TypeError(typeErrorMessage('WeakMap', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertWeakRef(value) {
if (!isWeakRef(value)) {
throw new TypeError(typeErrorMessage('WeakRef', value));
}
}
// eslint-disable-next-line @typescript-eslint/ban-types
export function assertWeakSet(value) {
if (!isWeakSet(value)) {
throw new TypeError(typeErrorMessage('WeakSet', value));
}
}
export function assertWhitespaceString(value) {
if (!isWhitespaceString(value)) {
throw new TypeError(typeErrorMessage('whitespace string', value));
}
}
export default is;

12

dist/types.d.ts

@@ -0,1 +1,3 @@

/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/**

@@ -33,1 +35,11 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).

};
export type ArrayLike<T> = {
readonly [index: number]: T;
readonly length: number;
};
export type NodeStream = {
pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
end?: boolean;
}): T;
} & NodeJS.EventEmitter;
export type Predicate = (value: unknown) => boolean;

18

package.json
{
"name": "@sindresorhus/is",
"version": "5.6.0",
"version": "6.0.0",
"description": "Type check values",

@@ -17,3 +17,3 @@ "license": "MIT",

"engines": {
"node": ">=14.16"
"node": ">=16"
},

@@ -53,14 +53,14 @@ "scripts": {

"devDependencies": {
"@sindresorhus/tsconfig": "^3.0.1",
"@sindresorhus/tsconfig": "^4.0.0",
"@types/jsdom": "^21.1.1",
"@types/node": "^20.2.5",
"@types/node": "^20.5.0",
"@types/zen-observable": "^0.8.3",
"ava": "^5.3.0",
"ava": "^5.3.1",
"del-cli": "^5.0.0",
"jsdom": "^20.0.1",
"jsdom": "^22.1.0",
"rxjs": "^7.8.1",
"tempy": "^3.0.0",
"tempy": "^3.1.0",
"ts-node": "^10.9.1",
"typescript": "^5.0.4",
"xo": "^0.54.2",
"typescript": "^5.1.6",
"xo": "^0.56.0",
"zen-observable": "^0.10.0",

@@ -67,0 +67,0 @@ "expect-type": "^0.16.0"

52

readme.md

@@ -57,2 +57,14 @@ # is

### Named exports
Named exports allow tooling to perform tree-shaking, potentially reducing bundle size by including only code from the methods that are used.
Every method listed below is available as a named export. Each method is prefixed by either `is` or `assert` depending on usage.
For example:
```js
import {assertNull, isUndefined} from '@sindresorhus/is';
```
## API

@@ -76,2 +88,8 @@

This method is also exported as `detect`. You can import it like this:
```js
import {detect} from '@sindresorhus/is';
```
Note: It will throw an error if you try to feed it object-wrapped primitives, as that's a bad practice. For example `new String('foo')`.

@@ -81,3 +99,3 @@

All the below methods accept a value and returns a boolean for whether the value is of the desired type.
All the below methods accept a value and return a boolean for whether the value is of the desired type.

@@ -89,4 +107,2 @@ #### Primitives

**Note:** TypeScript users must use `.null_()` because of a TypeScript naming limitation.
##### .string(value)

@@ -114,4 +130,2 @@ ##### .number(value)

**Note:** TypeScript users must use `.function_()` because of a TypeScript naming limitation.
##### .buffer(value)

@@ -381,4 +395,12 @@ ##### .blob(value)

JavaScript primitives are as follows: `null`, `undefined`, `string`, `number`, `boolean`, `symbol`.
JavaScript primitives are as follows:
- `null`
- `undefined`
- `string`
- `number`
- `boolean`
- `symbol`
- `bigint`
##### .integer(value)

@@ -398,6 +420,4 @@

Returns `true` for instances created by a class.
Returns `true` if the value is a class constructor.
**Note:** TypeScript users must use `.class_()` because of a TypeScript naming limitation.
##### .typedArray(value)

@@ -466,5 +486,5 @@

##### .domElement(value)
##### .htmlElement(value)
Returns `true` if `value` is a DOM Element.
Returns `true` if `value` is an [HTMLElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement).

@@ -565,2 +585,12 @@ ##### .nodeStream(value)

##### .validLength(value)
Returns `true` if the value is a safe integer that is greater than or equal to zero.
This can be useful to confirm that a value is a valid count of something, ie. 0 or more.
##### .whitespaceString(value)
Returns `true` if the value is a string with only whitespace characters.
## Type guards

@@ -567,0 +597,0 @@

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc