@sindresorhus/is

@sindresorhus/is

Version 6.1.0
Published 1 month ago
93.1 kB
No dependencies
MIT license

Install

npm i @sindresorhus/is

yarn add @sindresorhus/is

pnpm add @sindresorhus/is

Overview

Type check values

Index

Variables

variable assert

const assert: Assert;

variable assertionTypeDescriptions

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'
];

variable is

const is: ((value: unknown) => TypeName) & {
    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;
    class_: typeof isClass;
    dataView: typeof isDataView;
    date: typeof isDate;
    detect: typeof detect;
    directInstanceOf: typeof isDirectInstanceOf;
    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;
    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;
    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;
};

variable objectTypeNames

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'
];

variable primitiveTypeNames

const primitiveTypeNames: readonly [
    'null',
    'undefined',
    'string',
    'number',
    'bigint',
    'boolean',
    'symbol'
];

Functions

function assertAll

assertAll: (predicate: Predicate, ...values: unknown[]) => void | never;

function assertAny

assertAny: (
    predicate: Predicate | Predicate[],
    ...values: unknown[]
) => void | never;

function assertArray

assertArray: <T = unknown>(
    value: unknown,
    assertion?: (element: unknown) => asserts element is T
) => asserts value is T[];

function assertArrayBuffer

assertArrayBuffer: (value: unknown) => asserts value is ArrayBuffer;

function assertArrayLike

assertArrayLike: <T = unknown>(value: unknown) => asserts value is ArrayLike<T>;

function assertAsyncFunction

assertAsyncFunction: (value: unknown) => asserts value is Function;

function assertAsyncGenerator

assertAsyncGenerator: (
    value: unknown
) => asserts value is AsyncGenerator<unknown, any, unknown>;

function assertAsyncGeneratorFunction

assertAsyncGeneratorFunction: (
    value: unknown
) => asserts value is AsyncGeneratorFunction;

function assertAsyncIterable

assertAsyncIterable: <T = unknown>(
    value: unknown
) => asserts value is AsyncIterable<T>;

function assertBigint

assertBigint: (value: unknown) => asserts value is bigint;

function assertBigInt64Array

assertBigInt64Array: (value: unknown) => asserts value is BigInt64Array;

function assertBigUint64Array

assertBigUint64Array: (value: unknown) => asserts value is BigUint64Array;

function assertBlob

assertBlob: (value: unknown) => asserts value is Blob;

function assertBoolean

assertBoolean: (value: unknown) => asserts value is boolean;

function assertBoundFunction

assertBoundFunction: (value: unknown) => asserts value is Function;

function assertBuffer

assertBuffer: (value: unknown) => asserts value is Buffer;

function assertClass

assertClass: (value: unknown) => asserts value is Class<unknown, any[]>;

function assertDataView

assertDataView: (value: unknown) => asserts value is DataView;

function assertDate

assertDate: (value: unknown) => asserts value is Date;

function assertDirectInstanceOf

assertDirectInstanceOf: <T>(
    instance: unknown,
    class_: Class<T>
) => asserts instance is T;

function assertEmptyArray

assertEmptyArray: (value: unknown) => asserts value is never[];

function assertEmptyMap

assertEmptyMap: (value: unknown) => asserts value is Map<never, never>;

function assertEmptyObject

assertEmptyObject: <Key extends string | number | symbol = string>(
    value: unknown
) => asserts value is Record<Key, never>;

function assertEmptySet

assertEmptySet: (value: unknown) => asserts value is Set<never>;

function assertEmptyString

assertEmptyString: (value: unknown) => asserts value is '';

function assertEmptyStringOrWhitespace

assertEmptyStringOrWhitespace: (value: unknown) => asserts value is string;

function assertEnumCase

assertEnumCase: <T = unknown>(
    value: unknown,
    targetEnum: T
) => asserts value is T[keyof T];

function assertError

assertError: (value: unknown) => asserts value is Error;

function assertEvenInteger

assertEvenInteger: (value: number) => asserts value is number;

function assertFalsy

assertFalsy: (value: unknown) => asserts value is Falsy;

function assertFloat32Array

assertFloat32Array: (value: unknown) => asserts value is Float32Array;

function assertFloat64Array

assertFloat64Array: (value: unknown) => asserts value is Float64Array;

function assertFormData

assertFormData: (value: unknown) => asserts value is FormData;

function assertFunction

assertFunction: (value: unknown) => asserts value is Function;

function assertGenerator

assertGenerator: (
    value: unknown
) => asserts value is Generator<unknown, any, unknown>;

function assertGeneratorFunction

assertGeneratorFunction: (value: unknown) => asserts value is GeneratorFunction;

function assertHtmlElement

assertHtmlElement: (value: unknown) => asserts value is HTMLElement;

function assertInfinite

assertInfinite: (value: unknown) => asserts value is number;

function assertInRange

assertInRange: (
    value: number,
    range: number | [number, number]
) => asserts value is number;

function assertInt16Array

assertInt16Array: (value: unknown) => asserts value is Int16Array;

function assertInt32Array

assertInt32Array: (value: unknown) => asserts value is Int32Array;

function assertInt8Array

assertInt8Array: (value: unknown) => asserts value is Int8Array;

function assertInteger

assertInteger: (value: unknown) => asserts value is number;

function assertIterable

assertIterable: <T = unknown>(value: unknown) => asserts value is Iterable<T>;

function assertMap

assertMap: <Key = unknown, Value = unknown>(
    value: unknown
) => asserts value is Map<Key, Value>;

function assertNan

assertNan: (value: unknown) => asserts value is number;

function assertNativePromise

assertNativePromise: <T = unknown>(
    value: unknown
) => asserts value is Promise<T>;

function assertNegativeNumber

assertNegativeNumber: (value: unknown) => asserts value is number;

function assertNodeStream

assertNodeStream: (value: unknown) => asserts value is any;

function assertNonEmptyArray

assertNonEmptyArray: <T = unknown, Item = unknown>(
    value: T | Item[]
) => asserts value is [Item, ...Item[]];

function assertNonEmptyMap

assertNonEmptyMap: <Key = unknown, Value = unknown>(
    value: unknown
) => asserts value is Map<Key, Value>;

function assertNonEmptyObject

assertNonEmptyObject: <
    Key extends string | number | symbol = string,
    Value = unknown
>(
    value: unknown
) => asserts value is Record<Key, Value>;

function assertNonEmptySet

assertNonEmptySet: <T = unknown>(value: unknown) => asserts value is Set<T>;

function assertNonEmptyString

assertNonEmptyString: (value: unknown) => asserts value is string;

function assertNonEmptyStringAndNotWhitespace

assertNonEmptyStringAndNotWhitespace: (
    value: unknown
) => asserts value is string;

function assertNull

assertNull: (value: unknown) => asserts value is null;

function assertNullOrUndefined

assertNullOrUndefined: (value: unknown) => asserts value is null;

function assertNumber

assertNumber: (value: unknown) => asserts value is number;

function assertNumericString

assertNumericString: (value: unknown) => asserts value is `${number}`;

function assertObject

assertObject: (value: unknown) => asserts value is object;

function assertObservable

assertObservable: (value: unknown) => asserts value is ObservableLike;

function assertOddInteger

assertOddInteger: (value: number) => asserts value is number;

function assertPlainObject

assertPlainObject: <Value = unknown>(
    value: unknown
) => asserts value is Record<PropertyKey, Value>;

function assertPositiveNumber

assertPositiveNumber: (value: unknown) => asserts value is number;

function assertPrimitive

assertPrimitive: (value: unknown) => asserts value is Primitive;

function assertPromise

assertPromise: <T = unknown>(value: unknown) => asserts value is Promise<T>;

function assertPropertyKey

assertPropertyKey: (value: unknown) => asserts value is number;

function assertRegExp

assertRegExp: (value: unknown) => asserts value is RegExp;

function assertSafeInteger

assertSafeInteger: (value: unknown) => asserts value is number;

function assertSet

assertSet: <T = unknown>(value: unknown) => asserts value is Set<T>;

function assertSharedArrayBuffer

assertSharedArrayBuffer: (value: unknown) => asserts value is SharedArrayBuffer;

function assertString

assertString: (value: unknown) => asserts value is string;

function assertSymbol

assertSymbol: (value: unknown) => asserts value is symbol;

function assertTruthy

assertTruthy: <T>(value: T | Falsy) => asserts value is T;

function assertTupleLike

assertTupleLike: <T extends TypeGuard<unknown>[]>(
    value: unknown,
    guards: [...T]
) => asserts value is ResolveTypesOfTypeGuardsTuple<T, []>;

function assertTypedArray

assertTypedArray: (value: unknown) => asserts value is TypedArray;

function assertUint16Array

assertUint16Array: (value: unknown) => asserts value is Uint16Array;

function assertUint32Array

assertUint32Array: (value: unknown) => asserts value is Uint32Array;

function assertUint8Array

assertUint8Array: (value: unknown) => asserts value is Uint8Array;

function assertUint8ClampedArray

assertUint8ClampedArray: (value: unknown) => asserts value is Uint8ClampedArray;

function assertUndefined

assertUndefined: (value: unknown) => asserts value is undefined;

function assertUrlInstance

assertUrlInstance: (value: unknown) => asserts value is URL;

function assertUrlSearchParams

assertUrlSearchParams: (value: unknown) => asserts value is URLSearchParams;

function assertUrlString

assertUrlString: (value: unknown) => asserts value is string;

function assertValidLength

assertValidLength: (value: unknown) => asserts value is number;

function assertWeakMap

assertWeakMap: <Key extends object = object, Value = unknown>(
    value: unknown
) => asserts value is WeakMap<Key, Value>;

function assertWeakRef

assertWeakRef: <T extends object = object>(
    value: unknown
) => asserts value is WeakRef<T>;

function assertWeakSet

assertWeakSet: <T extends object = object>(
    value: unknown
) => asserts value is WeakSet<T>;

function assertWhitespaceString

assertWhitespaceString: (value: unknown) => asserts value is string;

function detect

detect: (value: unknown) => TypeName;

function isAll

isAll: (predicate: Predicate, ...values: unknown[]) => boolean;

function isAny

isAny: (predicate: Predicate | Predicate[], ...values: unknown[]) => boolean;

function isArray

isArray: <T = unknown>(
    value: unknown,
    assertion?: (value: T) => value is T
) => value is T[];

function isArrayBuffer

isArrayBuffer: (value: unknown) => value is ArrayBuffer;

function isArrayLike

isArrayLike: <T = unknown>(value: unknown) => value is ArrayLike<T>;

function isAsyncFunction

isAsyncFunction: <T = unknown>(
    value: unknown
) => value is (...args: any[]) => Promise<T>;

function isAsyncGenerator

isAsyncGenerator: (
    value: unknown
) => value is AsyncGenerator<unknown, any, unknown>;

function isAsyncGeneratorFunction

isAsyncGeneratorFunction: (
    value: unknown
) => value is (...args: any[]) => Promise<unknown>;

function isAsyncIterable

isAsyncIterable: <T = unknown>(value: unknown) => value is AsyncIterable<T>;

function isBigint

isBigint: (value: unknown) => value is bigint;

function isBigInt64Array

isBigInt64Array: (value: unknown) => value is BigInt64Array;

function isBigUint64Array

isBigUint64Array: (value: unknown) => value is BigUint64Array;

function isBlob

isBlob: (value: unknown) => value is Blob;

function isBoolean

isBoolean: (value: unknown) => value is boolean;

function isBoundFunction

isBoundFunction: (value: unknown) => value is Function;

function isBuffer

isBuffer: (value: unknown) => value is Buffer;

function isClass

isClass: (value: unknown) => value is Class<unknown, any[]>;

function isDataView

isDataView: (value: unknown) => value is DataView;

function isDate

isDate: (value: unknown) => value is Date;

function isDirectInstanceOf

isDirectInstanceOf: <T>(instance: unknown, class_: Class<T>) => instance is T;

function isEmptyArray

isEmptyArray: (value: unknown) => value is never[];

function isEmptyMap

isEmptyMap: (value: unknown) => value is Map<never, never>;

function isEmptyObject

isEmptyObject: <Key extends string | number | symbol = string>(
    value: unknown
) => value is Record<Key, never>;

function isEmptySet

isEmptySet: (value: unknown) => value is Set<never>;

function isEmptyString

isEmptyString: (value: unknown) => value is '';

function isEmptyStringOrWhitespace

isEmptyStringOrWhitespace: (value: unknown) => value is string;

function isEnumCase

isEnumCase: <T = unknown>(value: unknown, targetEnum: T) => boolean;

function isError

isError: (value: unknown) => value is Error;

function isEvenInteger

isEvenInteger: (value: unknown) => value is number;

function isFalsy

isFalsy: (value: unknown) => value is Falsy;

function isFloat32Array

isFloat32Array: (value: unknown) => value is Float32Array;

function isFloat64Array

isFloat64Array: (value: unknown) => value is Float64Array;

function isFormData

isFormData: (value: unknown) => value is FormData;

function isFunction

isFunction: (value: unknown) => value is Function;

function isGenerator

isGenerator: (value: unknown) => value is Generator<unknown, any, unknown>;

function isGeneratorFunction

isGeneratorFunction: (value: unknown) => value is GeneratorFunction;

function isHtmlElement

isHtmlElement: (value: unknown) => value is HTMLElement;

function isInfinite

isInfinite: (value: unknown) => value is number;

function isInRange

isInRange: (value: number, range: number | [number, number]) => value is number;

function isInt16Array

isInt16Array: (value: unknown) => value is Int16Array;

function isInt32Array

isInt32Array: (value: unknown) => value is Int32Array;

function isInt8Array

isInt8Array: (value: unknown) => value is Int8Array;

function isInteger

isInteger: (value: unknown) => value is number;

function isIterable

isIterable: <T = unknown>(value: unknown) => value is Iterable<T>;

function isMap

isMap: <Key = unknown, Value = unknown>(
    value: unknown
) => value is Map<Key, Value>;

function isNan

isNan: (value: unknown) => boolean;

function isNativePromise

isNativePromise: <T = unknown>(value: unknown) => value is Promise<T>;

function isNegativeNumber

isNegativeNumber: (value: unknown) => value is number;

function isNodeStream

isNodeStream: (value: unknown) => value is any;

function isNonEmptyArray

isNonEmptyArray: <T = unknown, Item = unknown>(
    value: T | Item[]
) => value is [Item, ...Item[]];

function isNonEmptyMap

isNonEmptyMap: <Key = unknown, Value = unknown>(
    value: unknown
) => value is Map<Key, Value>;

function isNonEmptyObject

isNonEmptyObject: <
    Key extends string | number | symbol = string,
    Value = unknown
>(
    value: unknown
) => value is Record<Key, Value>;

function isNonEmptySet

isNonEmptySet: <T = unknown>(value: unknown) => value is Set<T>;

function isNonEmptyString

isNonEmptyString: (value: unknown) => value is NonEmptyString;

function isNonEmptyStringAndNotWhitespace

isNonEmptyStringAndNotWhitespace: (value: unknown) => value is NonEmptyString;

function isNull

isNull: (value: unknown) => value is null;

function isNullOrUndefined

isNullOrUndefined: (value: unknown) => value is null;

function isNumber

isNumber: (value: unknown) => value is number;

function isNumericString

isNumericString: (value: unknown) => value is `${number}`;

function isObject

isObject: (value: unknown) => value is object;

function isObservable

isObservable: (value: unknown) => value is ObservableLike;

function isOddInteger

isOddInteger: (value: unknown) => value is number;

function isPlainObject

isPlainObject: <Value = unknown>(
    value: unknown
) => value is Record<PropertyKey, Value>;

function isPositiveNumber

isPositiveNumber: (value: unknown) => value is number;

function isPrimitive

isPrimitive: (value: unknown) => value is Primitive;

function isPromise

isPromise: <T = unknown>(value: unknown) => value is Promise<T>;

function isPropertyKey

isPropertyKey: (value: unknown) => value is PropertyKey;

function isRegExp

isRegExp: (value: unknown) => value is RegExp;

function isSafeInteger

isSafeInteger: (value: unknown) => value is number;

function isSet

isSet: <T = unknown>(value: unknown) => value is Set<T>;

function isSharedArrayBuffer

isSharedArrayBuffer: (value: unknown) => value is SharedArrayBuffer;

function isString

isString: (value: unknown) => value is string;

function isSymbol

isSymbol: (value: unknown) => value is symbol;

function isTruthy

isTruthy: <T>(value: T | Falsy) => value is T;

function isTupleLike

isTupleLike: <T extends TypeGuard<unknown>[]>(
    value: unknown,
    guards: [...T]
) => value is ResolveTypesOfTypeGuardsTuple<T, []>;

function isTypedArray

isTypedArray: (value: unknown) => value is TypedArray;

function isUint16Array

isUint16Array: (value: unknown) => value is Uint16Array;

function isUint32Array

isUint32Array: (value: unknown) => value is Uint32Array;

function isUint8Array

isUint8Array: (value: unknown) => value is Uint8Array;

function isUint8ClampedArray

isUint8ClampedArray: (value: unknown) => value is Uint8ClampedArray;

function isUndefined

isUndefined: (value: unknown) => value is undefined;

function isUrlInstance

isUrlInstance: (value: unknown) => value is URL;

function isUrlSearchParams

isUrlSearchParams: (value: unknown) => value is URLSearchParams;

function isUrlString

isUrlString: (value: unknown) => value is string;

function isValidLength

isValidLength: (value: unknown) => value is number;

function isWeakMap

isWeakMap: <Key extends object = object, Value = unknown>(
    value: unknown
) => value is WeakMap<Key, Value>;

function isWeakRef

isWeakRef: (value: unknown) => value is WeakRef<object>;

function isWeakSet

isWeakSet: (value: unknown) => value is WeakSet<object>;

function isWhitespaceString

isWhitespaceString: (value: unknown) => value is string;

Type Aliases

type ArrayLike

type ArrayLike<T> = {
    readonly [index: number]: T;
    readonly length: number;
};

type AssertionTypeDescription

type AssertionTypeDescription = (typeof assertionTypeDescriptions)[number];

type Class

type Class<T = unknown, Arguments extends any[] = any[]> = new (
    ...arguments_: Arguments
) => T;

Matches a [class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).

type NodeStream

type NodeStream = {
    pipe<T extends NodeJS.WritableStream>(
        destination: T,
        options?: {
            end?: boolean;
        }
    ): T;
} & NodeJS.EventEmitter;

type ObservableLike

type ObservableLike = {
    subscribe(observer: (value: unknown) => void): void;
    [Symbol.observable](): ObservableLike;
};

Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).

type Predicate

type Predicate = (value: unknown) => boolean;

type Primitive

type Primitive = null | undefined | string | number | boolean | symbol | bigint;

Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).

type TypedArray

type TypedArray =
    | Int8Array
    | Uint8Array
    | Uint8ClampedArray
    | Int16Array
    | Uint16Array
    | Int32Array
    | Uint32Array
    | Float32Array
    | Float64Array
    | BigInt64Array
    | BigUint64Array;

Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like Uint8Array or Float64Array.

type TypeName

type TypeName = ObjectTypeName | PrimitiveTypeName;

Package Files (2)

Dependencies (0)

No dependencies.

Dev Dependencies (14)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@sindresorhus/is.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@sindresorhus/is)

HTML

<a href="https://www.jsdocs.io/package/@sindresorhus/is"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 26 days ago.
Package analyzed in 6181 ms.
Missing or incorrect documentation? Open an issue for this package.