@sindresorhus/is - npm Package Compare versions

Comparing version 6.2.0 to 6.3.0

dist/index.d.ts

@@ -206,98 +206,98 @@ /// <reference types="node" resolution-mode="require"/>
 type Assert = {
-    undefined: (value: unknown) => asserts value is undefined;
-    string: (value: unknown) => asserts value is string;
-    number: (value: unknown) => asserts value is number;
-    positiveNumber: (value: unknown) => asserts value is number;
-    negativeNumber: (value: unknown) => asserts value is number;
-    bigint: (value: unknown) => asserts value is bigint;
-    function: (value: unknown) => asserts value is Function;
+    undefined: (value: unknown, message?: string) => asserts value is undefined;
+    string: (value: unknown, message?: string) => asserts value is string;
+    number: (value: unknown, message?: string) => asserts value is number;
+    positiveNumber: (value: unknown, message?: string) => asserts value is number;
+    negativeNumber: (value: unknown, message?: string) => asserts value is number;
+    bigint: (value: unknown, message?: string) => asserts value is bigint;
+    function: (value: unknown, message?: string) => asserts value is Function;
     /** @deprecated Renamed to `function`. */
-    function_: (value: unknown) => asserts value is Function;
-    null: (value: unknown) => asserts value is null;
+    function_: (value: unknown, message?: string) => asserts value is Function;
+    null: (value: unknown, message?: string) => asserts value is null;
     /** @deprecated Renamed to `null`. */
-    null_: (value: unknown) => asserts value is null;
-    class: (value: unknown) => asserts value is Class;
+    null_: (value: unknown, message?: string) => asserts value is null;
+    class: (value: unknown, message?: string) => asserts value is Class;
     /** @deprecated Renamed to `class`. */
-    class_: (value: unknown) => asserts value is Class;
-    boolean: (value: unknown) => asserts value is boolean;
-    symbol: (value: unknown) => asserts value is symbol;
-    numericString: (value: unknown) => asserts value is `${number}`;
-    array: <T = unknown>(value: unknown, assertion?: (element: unknown) => asserts element is T) => asserts value is T[];
-    buffer: (value: unknown) => asserts value is Buffer;
-    blob: (value: unknown) => asserts value is Blob;
-    nullOrUndefined: (value: unknown) => asserts value is null | undefined;
-    object: <Key extends keyof any = string, Value = unknown>(value: unknown) => asserts value is Record<Key, Value>;
-    iterable: <T = unknown>(value: unknown) => asserts value is Iterable<T>;
-    asyncIterable: <T = unknown>(value: unknown) => asserts value is AsyncIterable<T>;
-    generator: (value: unknown) => asserts value is Generator;
-    asyncGenerator: (value: unknown) => asserts value is AsyncGenerator;
-    nativePromise: <T = unknown>(value: unknown) => asserts value is Promise<T>;
-    promise: <T = unknown>(value: unknown) => asserts value is Promise<T>;
-    generatorFunction: (value: unknown) => asserts value is GeneratorFunction;
-    asyncGeneratorFunction: (value: unknown) => asserts value is AsyncGeneratorFunction;
-    asyncFunction: (value: unknown) => asserts value is Function;
-    boundFunction: (value: unknown) => asserts value is Function;
-    regExp: (value: unknown) => asserts value is RegExp;
-    date: (value: unknown) => asserts value is Date;
-    error: (value: unknown) => asserts value is Error;
-    map: <Key = unknown, Value = unknown>(value: unknown) => asserts value is Map<Key, Value>;
-    set: <T = unknown>(value: unknown) => asserts value is Set<T>;
-    weakMap: <Key extends object = object, Value = unknown>(value: unknown) => asserts value is WeakMap<Key, Value>;
-    weakSet: <T extends object = object>(value: unknown) => asserts value is WeakSet<T>;
-    weakRef: <T extends object = object>(value: unknown) => asserts value is WeakRef<T>;
-    int8Array: (value: unknown) => asserts value is Int8Array;
-    uint8Array: (value: unknown) => asserts value is Uint8Array;
-    uint8ClampedArray: (value: unknown) => asserts value is Uint8ClampedArray;
-    int16Array: (value: unknown) => asserts value is Int16Array;
-    uint16Array: (value: unknown) => asserts value is Uint16Array;
-    int32Array: (value: unknown) => asserts value is Int32Array;
-    uint32Array: (value: unknown) => asserts value is Uint32Array;
-    float32Array: (value: unknown) => asserts value is Float32Array;
-    float64Array: (value: unknown) => asserts value is Float64Array;
-    bigInt64Array: (value: unknown) => asserts value is BigInt64Array;
-    bigUint64Array: (value: unknown) => asserts value is BigUint64Array;
-    arrayBuffer: (value: unknown) => asserts value is ArrayBuffer;
-    sharedArrayBuffer: (value: unknown) => asserts value is SharedArrayBuffer;
-    dataView: (value: unknown) => asserts value is DataView;
-    enumCase: <T = unknown>(value: unknown, targetEnum: T) => asserts value is T[keyof T];
-    urlInstance: (value: unknown) => asserts value is URL;
-    urlString: (value: unknown) => asserts value is string;
-    truthy: <T>(value: T | Falsy) => asserts value is T;
-    falsy: (value: unknown) => asserts value is Falsy;
-    nan: (value: unknown) => asserts value is number;
-    primitive: (value: unknown) => asserts value is Primitive;
-    integer: (value: unknown) => asserts value is number;
-    safeInteger: (value: unknown) => asserts value is number;
-    plainObject: <Value = unknown>(value: unknown) => asserts value is Record<PropertyKey, Value>;
-    typedArray: (value: unknown) => asserts value is TypedArray;
-    arrayLike: <T = unknown>(value: unknown) => asserts value is ArrayLike<T>;
-    tupleLike: <T extends Array<TypeGuard<unknown>>>(value: unknown, guards: [...T]) => asserts value is ResolveTypesOfTypeGuardsTuple<T>;
+    class_: (value: unknown, message?: string) => asserts value is Class;
+    boolean: (value: unknown, message?: string) => asserts value is boolean;
+    symbol: (value: unknown, message?: string) => asserts value is symbol;
+    numericString: (value: unknown, message?: string) => asserts value is `${number}`;
+    array: <T = unknown>(value: unknown, assertion?: (element: unknown) => asserts element is T, message?: string) => asserts value is T[];
+    buffer: (value: unknown, message?: string) => asserts value is Buffer;
+    blob: (value: unknown, message?: string) => asserts value is Blob;
+    nullOrUndefined: (value: unknown, message?: string) => asserts value is null | undefined;
+    object: <Key extends keyof any = string, Value = unknown>(value: unknown, message?: string) => asserts value is Record<Key, Value>;
+    iterable: <T = unknown>(value: unknown, message?: string) => asserts value is Iterable<T>;
+    asyncIterable: <T = unknown>(value: unknown, message?: string) => asserts value is AsyncIterable<T>;
+    generator: (value: unknown, message?: string) => asserts value is Generator;
+    asyncGenerator: (value: unknown, message?: string) => asserts value is AsyncGenerator;
+    nativePromise: <T = unknown>(value: unknown, message?: string) => asserts value is Promise<T>;
+    promise: <T = unknown>(value: unknown, message?: string) => asserts value is Promise<T>;
+    generatorFunction: (value: unknown, message?: string) => asserts value is GeneratorFunction;
+    asyncGeneratorFunction: (value: unknown, message?: string) => asserts value is AsyncGeneratorFunction;
+    asyncFunction: (value: unknown, message?: string) => asserts value is Function;
+    boundFunction: (value: unknown, message?: string) => asserts value is Function;
+    regExp: (value: unknown, message?: string) => asserts value is RegExp;
+    date: (value: unknown, message?: string) => asserts value is Date;
+    error: (value: unknown, message?: string) => asserts value is Error;
+    map: <Key = unknown, Value = unknown>(value: unknown, message?: string) => asserts value is Map<Key, Value>;
+    set: <T = unknown>(value: unknown, message?: string) => asserts value is Set<T>;
+    weakMap: <Key extends object = object, Value = unknown>(value: unknown, message?: string) => asserts value is WeakMap<Key, Value>;
+    weakSet: <T extends object = object>(value: unknown, message?: string) => asserts value is WeakSet<T>;
+    weakRef: <T extends object = object>(value: unknown, message?: string) => asserts value is WeakRef<T>;
+    int8Array: (value: unknown, message?: string) => asserts value is Int8Array;
+    uint8Array: (value: unknown, message?: string) => asserts value is Uint8Array;
+    uint8ClampedArray: (value: unknown, message?: string) => asserts value is Uint8ClampedArray;
+    int16Array: (value: unknown, message?: string) => asserts value is Int16Array;
+    uint16Array: (value: unknown, message?: string) => asserts value is Uint16Array;
+    int32Array: (value: unknown, message?: string) => asserts value is Int32Array;
+    uint32Array: (value: unknown, message?: string) => asserts value is Uint32Array;
+    float32Array: (value: unknown, message?: string) => asserts value is Float32Array;
+    float64Array: (value: unknown, message?: string) => asserts value is Float64Array;
+    bigInt64Array: (value: unknown, message?: string) => asserts value is BigInt64Array;
+    bigUint64Array: (value: unknown, message?: string) => asserts value is BigUint64Array;
+    arrayBuffer: (value: unknown, message?: string) => asserts value is ArrayBuffer;
+    sharedArrayBuffer: (value: unknown, message?: string) => asserts value is SharedArrayBuffer;
+    dataView: (value: unknown, message?: string) => asserts value is DataView;
+    enumCase: <T = unknown>(value: unknown, targetEnum: T, message?: string) => asserts value is T[keyof T];
+    urlInstance: (value: unknown, message?: string) => asserts value is URL;
+    urlString: (value: unknown, message?: string) => asserts value is string;
+    truthy: <T>(value: T | Falsy, message?: string) => asserts value is T;
+    falsy: (value: unknown, message?: string) => asserts value is Falsy;
+    nan: (value: unknown, message?: string) => asserts value is number;
+    primitive: (value: unknown, message?: string) => asserts value is Primitive;
+    integer: (value: unknown, message?: string) => asserts value is number;
+    safeInteger: (value: unknown, message?: string) => asserts value is number;
+    plainObject: <Value = unknown>(value: unknown, message?: string) => asserts value is Record<PropertyKey, Value>;
+    typedArray: (value: unknown, message?: string) => asserts value is TypedArray;
+    arrayLike: <T = unknown>(value: unknown, message?: string) => asserts value is ArrayLike<T>;
+    tupleLike: <T extends Array<TypeGuard<unknown>>>(value: unknown, guards: [...T], message?: string) => 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;
-    nodeStream: (value: unknown) => asserts value is NodeStream;
-    infinite: (value: unknown) => asserts value is number;
-    emptyArray: (value: unknown) => asserts value is never[];
-    nonEmptyArray: <T = unknown, Item = unknown>(value: T | Item[]) => asserts value is [Item, ...Item[]];
-    emptyString: (value: unknown) => asserts value is '';
-    emptyStringOrWhitespace: (value: unknown) => asserts value is string;
-    nonEmptyString: (value: unknown) => asserts value is string;
-    nonEmptyStringAndNotWhitespace: (value: unknown) => asserts value is string;
-    emptyObject: <Key extends keyof any = string>(value: unknown) => asserts value is Record<Key, never>;
-    nonEmptyObject: <Key extends keyof any = string, Value = unknown>(value: unknown) => asserts value is Record<Key, Value>;
-    emptySet: (value: unknown) => asserts value is Set<never>;
-    nonEmptySet: <T = unknown>(value: unknown) => asserts value is Set<T>;
-    emptyMap: (value: unknown) => asserts value is Map<never, never>;
-    nonEmptyMap: <Key = unknown, Value = unknown>(value: unknown) => asserts value is Map<Key, Value>;
-    propertyKey: (value: unknown) => asserts value is PropertyKey;
-    formData: (value: unknown) => asserts value is FormData;
-    urlSearchParams: (value: unknown) => asserts value is URLSearchParams;
-    validDate: (value: unknown) => asserts value is Date;
-    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, number]) => asserts value is number;
+    domElement: (value: unknown, message?: string) => asserts value is HTMLElement;
+    htmlElement: (value: unknown, message?: string) => asserts value is HTMLElement;
+    observable: (value: unknown, message?: string) => asserts value is ObservableLike;
+    nodeStream: (value: unknown, message?: string) => asserts value is NodeStream;
+    infinite: (value: unknown, message?: string) => asserts value is number;
+    emptyArray: (value: unknown, message?: string) => asserts value is never[];
+    nonEmptyArray: <T = unknown, Item = unknown>(value: T | Item[], message?: string) => asserts value is [Item, ...Item[]];
+    emptyString: (value: unknown, message?: string) => asserts value is '';
+    emptyStringOrWhitespace: (value: unknown, message?: string) => asserts value is string;
+    nonEmptyString: (value: unknown, message?: string) => asserts value is string;
+    nonEmptyStringAndNotWhitespace: (value: unknown, message?: string) => asserts value is string;
+    emptyObject: <Key extends keyof any = string>(value: unknown, message?: string) => asserts value is Record<Key, never>;
+    nonEmptyObject: <Key extends keyof any = string, Value = unknown>(value: unknown, message?: string) => asserts value is Record<Key, Value>;
+    emptySet: (value: unknown, message?: string) => asserts value is Set<never>;
+    nonEmptySet: <T = unknown>(value: unknown, message?: string) => asserts value is Set<T>;
+    emptyMap: (value: unknown, message?: string) => asserts value is Map<never, never>;
+    nonEmptyMap: <Key = unknown, Value = unknown>(value: unknown, message?: string) => asserts value is Map<Key, Value>;
+    propertyKey: (value: unknown, message?: string) => asserts value is PropertyKey;
+    formData: (value: unknown, message?: string) => asserts value is FormData;
+    urlSearchParams: (value: unknown, message?: string) => asserts value is URLSearchParams;
+    validDate: (value: unknown, message?: string) => asserts value is Date;
+    validLength: (value: unknown, message?: string) => asserts value is number;
+    whitespaceString: (value: unknown, message?: string) => asserts value is string;
+    evenInteger: (value: number, message?: string) => asserts value is number;
+    oddInteger: (value: number, message?: string) => asserts value is number;
+    directInstanceOf: <T>(instance: unknown, class_: Class<T>, message?: string) => asserts instance is T;
+    inRange: (value: number, range: number | [number, number], message?: string) => asserts value is number;
     any: (predicate: Predicate | Predicate[], ...values: unknown[]) => void | never;
@@ -309,91 +309,91 @@ all: (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 assertValidDate(value: unknown): asserts value is Date;
-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 declare function assertArray<T = unknown>(value: unknown, assertion?: (element: unknown) => asserts element is T, message?: string): asserts value is T[];
+export declare function assertArrayBuffer(value: unknown, message?: string): asserts value is ArrayBuffer;
+export declare function assertArrayLike<T = unknown>(value: unknown, message?: string): asserts value is ArrayLike<T>;
+export declare function assertAsyncFunction(value: unknown, message?: string): asserts value is Function;
+export declare function assertAsyncGenerator(value: unknown, message?: string): asserts value is AsyncGenerator;
+export declare function assertAsyncGeneratorFunction(value: unknown, message?: string): asserts value is AsyncGeneratorFunction;
+export declare function assertAsyncIterable<T = unknown>(value: unknown, message?: string): asserts value is AsyncIterable<T>;
+export declare function assertBigint(value: unknown, message?: string): asserts value is bigint;
+export declare function assertBigInt64Array(value: unknown, message?: string): asserts value is BigInt64Array;
+export declare function assertBigUint64Array(value: unknown, message?: string): asserts value is BigUint64Array;
+export declare function assertBlob(value: unknown, message?: string): asserts value is Blob;
+export declare function assertBoolean(value: unknown, message?: string): asserts value is boolean;
+export declare function assertBoundFunction(value: unknown, message?: string): asserts value is Function;
+export declare function assertBuffer(value: unknown, message?: string): asserts value is Buffer;
+export declare function assertClass(value: unknown, message?: string): asserts value is Class;
+export declare function assertDataView(value: unknown, message?: string): asserts value is DataView;
+export declare function assertDate(value: unknown, message?: string): asserts value is Date;
+export declare function assertDirectInstanceOf<T>(instance: unknown, class_: Class<T>, message?: string): asserts instance is T;
+export declare function assertEmptyArray(value: unknown, message?: string): asserts value is never[];
+export declare function assertEmptyMap(value: unknown, message?: string): asserts value is Map<never, never>;
+export declare function assertEmptyObject<Key extends keyof any = string>(value: unknown, message?: string): asserts value is Record<Key, never>;
+export declare function assertEmptySet(value: unknown, message?: string): asserts value is Set<never>;
+export declare function assertEmptyString(value: unknown, message?: string): asserts value is '';
+export declare function assertEmptyStringOrWhitespace(value: unknown, message?: string): asserts value is string;
+export declare function assertEnumCase<T = unknown>(value: unknown, targetEnum: T, message?: string): asserts value is T[keyof T];
+export declare function assertError(value: unknown, message?: string): asserts value is Error;
+export declare function assertEvenInteger(value: number, message?: string): asserts value is number;
+export declare function assertFalsy(value: unknown, message?: string): asserts value is Falsy;
+export declare function assertFloat32Array(value: unknown, message?: string): asserts value is Float32Array;
+export declare function assertFloat64Array(value: unknown, message?: string): asserts value is Float64Array;
+export declare function assertFormData(value: unknown, message?: string): asserts value is FormData;
+export declare function assertFunction(value: unknown, message?: string): asserts value is Function;
+export declare function assertGenerator(value: unknown, message?: string): asserts value is Generator;
+export declare function assertGeneratorFunction(value: unknown, message?: string): asserts value is GeneratorFunction;
+export declare function assertHtmlElement(value: unknown, message?: string): asserts value is HTMLElement;
+export declare function assertInfinite(value: unknown, message?: string): asserts value is number;
+export declare function assertInRange(value: number, range: number | [number, number], message?: string): asserts value is number;
+export declare function assertInt16Array(value: unknown, message?: string): asserts value is Int16Array;
+export declare function assertInt32Array(value: unknown, message?: string): asserts value is Int32Array;
+export declare function assertInt8Array(value: unknown, message?: string): asserts value is Int8Array;
+export declare function assertInteger(value: unknown, message?: string): asserts value is number;
+export declare function assertIterable<T = unknown>(value: unknown, message?: string): asserts value is Iterable<T>;
+export declare function assertMap<Key = unknown, Value = unknown>(value: unknown, message?: string): asserts value is Map<Key, Value>;
+export declare function assertNan(value: unknown, message?: string): asserts value is number;
+export declare function assertNativePromise<T = unknown>(value: unknown, message?: string): asserts value is Promise<T>;
+export declare function assertNegativeNumber(value: unknown, message?: string): asserts value is number;
+export declare function assertNodeStream(value: unknown, message?: string): asserts value is NodeStream;
+export declare function assertNonEmptyArray<T = unknown, Item = unknown>(value: T | Item[], message?: string): asserts value is [Item, ...Item[]];
+export declare function assertNonEmptyMap<Key = unknown, Value = unknown>(value: unknown, message?: string): asserts value is Map<Key, Value>;
+export declare function assertNonEmptyObject<Key extends keyof any = string, Value = unknown>(value: unknown, message?: string): asserts value is Record<Key, Value>;
+export declare function assertNonEmptySet<T = unknown>(value: unknown, message?: string): asserts value is Set<T>;
+export declare function assertNonEmptyString(value: unknown, message?: string): asserts value is string;
+export declare function assertNonEmptyStringAndNotWhitespace(value: unknown, message?: string): asserts value is string;
+export declare function assertNull(value: unknown, message?: string): asserts value is null;
+export declare function assertNullOrUndefined(value: unknown, message?: string): asserts value is null | undefined;
+export declare function assertNumber(value: unknown, message?: string): asserts value is number;
+export declare function assertNumericString(value: unknown, message?: string): asserts value is `${number}`;
+export declare function assertObject(value: unknown, message?: string): asserts value is object;
+export declare function assertObservable(value: unknown, message?: string): asserts value is ObservableLike;
+export declare function assertOddInteger(value: number, message?: string): asserts value is number;
+export declare function assertPlainObject<Value = unknown>(value: unknown, message?: string): asserts value is Record<PropertyKey, Value>;
+export declare function assertPositiveNumber(value: unknown, message?: string): asserts value is number;
+export declare function assertPrimitive(value: unknown, message?: string): asserts value is Primitive;
+export declare function assertPromise<T = unknown>(value: unknown, message?: string): asserts value is Promise<T>;
+export declare function assertPropertyKey(value: unknown, message?: string): asserts value is number;
+export declare function assertRegExp(value: unknown, message?: string): asserts value is RegExp;
+export declare function assertSafeInteger(value: unknown, message?: string): asserts value is number;
+export declare function assertSet<T = unknown>(value: unknown, message?: string): asserts value is Set<T>;
+export declare function assertSharedArrayBuffer(value: unknown, message?: string): asserts value is SharedArrayBuffer;
+export declare function assertString(value: unknown, message?: string): asserts value is string;
+export declare function assertSymbol(value: unknown, message?: string): asserts value is symbol;
+export declare function assertTruthy<T>(value: T | Falsy, message?: string): asserts value is T;
+export declare function assertTupleLike<T extends Array<TypeGuard<unknown>>>(value: unknown, guards: [...T], message?: string): asserts value is ResolveTypesOfTypeGuardsTuple<T>;
+export declare function assertTypedArray(value: unknown, message?: string): asserts value is TypedArray;
+export declare function assertUint16Array(value: unknown, message?: string): asserts value is Uint16Array;
+export declare function assertUint32Array(value: unknown, message?: string): asserts value is Uint32Array;
+export declare function assertUint8Array(value: unknown, message?: string): asserts value is Uint8Array;
+export declare function assertUint8ClampedArray(value: unknown, message?: string): asserts value is Uint8ClampedArray;
+export declare function assertUndefined(value: unknown, message?: string): asserts value is undefined;
+export declare function assertUrlInstance(value: unknown, message?: string): asserts value is URL;
+export declare function assertUrlSearchParams(value: unknown, message?: string): asserts value is URLSearchParams;
+export declare function assertUrlString(value: unknown, message?: string): asserts value is string;
+export declare function assertValidDate(value: unknown, message?: string): asserts value is Date;
+export declare function assertValidLength(value: unknown, message?: string): asserts value is number;
+export declare function assertWeakMap<Key extends object = object, Value = unknown>(value: unknown, message?: string): asserts value is WeakMap<Key, Value>;
+export declare function assertWeakRef<T extends object = object>(value: unknown, message?: string): asserts value is WeakRef<T>;
+export declare function assertWeakSet<T extends object = object>(value: unknown, message?: string): asserts value is WeakSet<T>;
+export declare function assertWhitespaceString(value: unknown, message?: string): asserts value is string;
 export default is;
 export type { ArrayLike, Class, NodeStream, ObservableLike, Predicate, Primitive, TypedArray, } from './types.js';

dist/index.js

@@ -852,5 +852,5 @@ const typedArrayTypeNames = [
 }
-export function assertArray(value, assertion) {
+export function assertArray(value, assertion, message) {
     if (!isArray(value)) {
-        throw new TypeError(typeErrorMessage('Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Array', value));
     }
@@ -862,447 +862,447 @@ if (assertion) {
 }
-export function assertArrayBuffer(value) {
+export function assertArrayBuffer(value, message) {
     if (!isArrayBuffer(value)) {
-        throw new TypeError(typeErrorMessage('ArrayBuffer', value));
+        throw new TypeError(message ?? typeErrorMessage('ArrayBuffer', value));
     }
 }
-export function assertArrayLike(value) {
+export function assertArrayLike(value, message) {
     if (!isArrayLike(value)) {
-        throw new TypeError(typeErrorMessage('array-like', value));
+        throw new TypeError(message ?? typeErrorMessage('array-like', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertAsyncFunction(value) {
+export function assertAsyncFunction(value, message) {
     if (!isAsyncFunction(value)) {
-        throw new TypeError(typeErrorMessage('AsyncFunction', value));
+        throw new TypeError(message ?? typeErrorMessage('AsyncFunction', value));
     }
 }
-export function assertAsyncGenerator(value) {
+export function assertAsyncGenerator(value, message) {
     if (!isAsyncGenerator(value)) {
-        throw new TypeError(typeErrorMessage('AsyncGenerator', value));
+        throw new TypeError(message ?? typeErrorMessage('AsyncGenerator', value));
     }
 }
-export function assertAsyncGeneratorFunction(value) {
+export function assertAsyncGeneratorFunction(value, message) {
     if (!isAsyncGeneratorFunction(value)) {
-        throw new TypeError(typeErrorMessage('AsyncGeneratorFunction', value));
+        throw new TypeError(message ?? typeErrorMessage('AsyncGeneratorFunction', value));
     }
 }
-export function assertAsyncIterable(value) {
+export function assertAsyncIterable(value, message) {
     if (!isAsyncIterable(value)) {
-        throw new TypeError(typeErrorMessage('AsyncIterable', value));
+        throw new TypeError(message ?? typeErrorMessage('AsyncIterable', value));
     }
 }
-export function assertBigint(value) {
+export function assertBigint(value, message) {
     if (!isBigint(value)) {
-        throw new TypeError(typeErrorMessage('bigint', value));
+        throw new TypeError(message ?? typeErrorMessage('bigint', value));
     }
 }
-export function assertBigInt64Array(value) {
+export function assertBigInt64Array(value, message) {
     if (!isBigInt64Array(value)) {
-        throw new TypeError(typeErrorMessage('BigInt64Array', value));
+        throw new TypeError(message ?? typeErrorMessage('BigInt64Array', value));
     }
 }
-export function assertBigUint64Array(value) {
+export function assertBigUint64Array(value, message) {
     if (!isBigUint64Array(value)) {
-        throw new TypeError(typeErrorMessage('BigUint64Array', value));
+        throw new TypeError(message ?? typeErrorMessage('BigUint64Array', value));
     }
 }
-export function assertBlob(value) {
+export function assertBlob(value, message) {
     if (!isBlob(value)) {
-        throw new TypeError(typeErrorMessage('Blob', value));
+        throw new TypeError(message ?? typeErrorMessage('Blob', value));
     }
 }
-export function assertBoolean(value) {
+export function assertBoolean(value, message) {
     if (!isBoolean(value)) {
-        throw new TypeError(typeErrorMessage('boolean', value));
+        throw new TypeError(message ?? typeErrorMessage('boolean', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertBoundFunction(value) {
+export function assertBoundFunction(value, message) {
     if (!isBoundFunction(value)) {
-        throw new TypeError(typeErrorMessage('Function', value));
+        throw new TypeError(message ?? typeErrorMessage('Function', value));
     }
 }
-export function assertBuffer(value) {
+export function assertBuffer(value, message) {
     if (!isBuffer(value)) {
-        throw new TypeError(typeErrorMessage('Buffer', value));
+        throw new TypeError(message ?? typeErrorMessage('Buffer', value));
     }
 }
-export function assertClass(value) {
+export function assertClass(value, message) {
     if (!isClass(value)) {
-        throw new TypeError(typeErrorMessage('Class', value));
+        throw new TypeError(message ?? typeErrorMessage('Class', value));
     }
 }
-export function assertDataView(value) {
+export function assertDataView(value, message) {
     if (!isDataView(value)) {
-        throw new TypeError(typeErrorMessage('DataView', value));
+        throw new TypeError(message ?? typeErrorMessage('DataView', value));
     }
 }
-export function assertDate(value) {
+export function assertDate(value, message) {
     if (!isDate(value)) {
-        throw new TypeError(typeErrorMessage('Date', value));
+        throw new TypeError(message ?? typeErrorMessage('Date', value));
     }
 }
-export function assertDirectInstanceOf(instance, class_) {
+export function assertDirectInstanceOf(instance, class_, message) {
     if (!isDirectInstanceOf(instance, class_)) {
-        throw new TypeError(typeErrorMessage('T', instance));
+        throw new TypeError(message ?? typeErrorMessage('T', instance));
     }
 }
-export function assertEmptyArray(value) {
+export function assertEmptyArray(value, message) {
     if (!isEmptyArray(value)) {
-        throw new TypeError(typeErrorMessage('empty array', value));
+        throw new TypeError(message ?? typeErrorMessage('empty array', value));
     }
 }
-export function assertEmptyMap(value) {
+export function assertEmptyMap(value, message) {
     if (!isEmptyMap(value)) {
-        throw new TypeError(typeErrorMessage('empty map', value));
+        throw new TypeError(message ?? typeErrorMessage('empty map', value));
     }
 }
-export function assertEmptyObject(value) {
+export function assertEmptyObject(value, message) {
     if (!isEmptyObject(value)) {
-        throw new TypeError(typeErrorMessage('empty object', value));
+        throw new TypeError(message ?? typeErrorMessage('empty object', value));
     }
 }
-export function assertEmptySet(value) {
+export function assertEmptySet(value, message) {
     if (!isEmptySet(value)) {
-        throw new TypeError(typeErrorMessage('empty set', value));
+        throw new TypeError(message ?? typeErrorMessage('empty set', value));
     }
 }
-export function assertEmptyString(value) {
+export function assertEmptyString(value, message) {
     if (!isEmptyString(value)) {
-        throw new TypeError(typeErrorMessage('empty string', value));
+        throw new TypeError(message ?? typeErrorMessage('empty string', value));
     }
 }
-export function assertEmptyStringOrWhitespace(value) {
+export function assertEmptyStringOrWhitespace(value, message) {
     if (!isEmptyStringOrWhitespace(value)) {
-        throw new TypeError(typeErrorMessage('empty string or whitespace', value));
+        throw new TypeError(message ?? typeErrorMessage('empty string or whitespace', value));
     }
 }
-export function assertEnumCase(value, targetEnum) {
+export function assertEnumCase(value, targetEnum, message) {
     if (!isEnumCase(value, targetEnum)) {
-        throw new TypeError(typeErrorMessage('EnumCase', value));
+        throw new TypeError(message ?? typeErrorMessage('EnumCase', value));
     }
 }
-export function assertError(value) {
+export function assertError(value, message) {
     if (!isError(value)) {
-        throw new TypeError(typeErrorMessage('Error', value));
+        throw new TypeError(message ?? typeErrorMessage('Error', value));
     }
 }
-export function assertEvenInteger(value) {
+export function assertEvenInteger(value, message) {
     if (!isEvenInteger(value)) {
-        throw new TypeError(typeErrorMessage('even integer', value));
+        throw new TypeError(message ?? typeErrorMessage('even integer', value));
     }
 }
-export function assertFalsy(value) {
+export function assertFalsy(value, message) {
     if (!isFalsy(value)) {
-        throw new TypeError(typeErrorMessage('falsy', value));
+        throw new TypeError(message ?? typeErrorMessage('falsy', value));
     }
 }
-export function assertFloat32Array(value) {
+export function assertFloat32Array(value, message) {
     if (!isFloat32Array(value)) {
-        throw new TypeError(typeErrorMessage('Float32Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Float32Array', value));
     }
 }
-export function assertFloat64Array(value) {
+export function assertFloat64Array(value, message) {
     if (!isFloat64Array(value)) {
-        throw new TypeError(typeErrorMessage('Float64Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Float64Array', value));
     }
 }
-export function assertFormData(value) {
+export function assertFormData(value, message) {
     if (!isFormData(value)) {
-        throw new TypeError(typeErrorMessage('FormData', value));
+        throw new TypeError(message ?? typeErrorMessage('FormData', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertFunction(value) {
+export function assertFunction(value, message) {
     if (!isFunction(value)) {
-        throw new TypeError(typeErrorMessage('Function', value));
+        throw new TypeError(message ?? typeErrorMessage('Function', value));
     }
 }
-export function assertGenerator(value) {
+export function assertGenerator(value, message) {
     if (!isGenerator(value)) {
-        throw new TypeError(typeErrorMessage('Generator', value));
+        throw new TypeError(message ?? typeErrorMessage('Generator', value));
     }
 }
-export function assertGeneratorFunction(value) {
+export function assertGeneratorFunction(value, message) {
     if (!isGeneratorFunction(value)) {
-        throw new TypeError(typeErrorMessage('GeneratorFunction', value));
+        throw new TypeError(message ?? typeErrorMessage('GeneratorFunction', value));
     }
 }
-export function assertHtmlElement(value) {
+export function assertHtmlElement(value, message) {
     if (!isHtmlElement(value)) {
-        throw new TypeError(typeErrorMessage('HTMLElement', value));
+        throw new TypeError(message ?? typeErrorMessage('HTMLElement', value));
     }
 }
-export function assertInfinite(value) {
+export function assertInfinite(value, message) {
     if (!isInfinite(value)) {
-        throw new TypeError(typeErrorMessage('infinite number', value));
+        throw new TypeError(message ?? typeErrorMessage('infinite number', value));
     }
 }
-export function assertInRange(value, range) {
+export function assertInRange(value, range, message) {
     if (!isInRange(value, range)) {
-        throw new TypeError(typeErrorMessage('in range', value));
+        throw new TypeError(message ?? typeErrorMessage('in range', value));
     }
 }
-export function assertInt16Array(value) {
+export function assertInt16Array(value, message) {
     if (!isInt16Array(value)) {
-        throw new TypeError(typeErrorMessage('Int16Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Int16Array', value));
     }
 }
-export function assertInt32Array(value) {
+export function assertInt32Array(value, message) {
     if (!isInt32Array(value)) {
-        throw new TypeError(typeErrorMessage('Int32Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Int32Array', value));
     }
 }
-export function assertInt8Array(value) {
+export function assertInt8Array(value, message) {
     if (!isInt8Array(value)) {
-        throw new TypeError(typeErrorMessage('Int8Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Int8Array', value));
     }
 }
-export function assertInteger(value) {
+export function assertInteger(value, message) {
     if (!isInteger(value)) {
-        throw new TypeError(typeErrorMessage('integer', value));
+        throw new TypeError(message ?? typeErrorMessage('integer', value));
     }
 }
-export function assertIterable(value) {
+export function assertIterable(value, message) {
     if (!isIterable(value)) {
-        throw new TypeError(typeErrorMessage('Iterable', value));
+        throw new TypeError(message ?? typeErrorMessage('Iterable', value));
     }
 }
-export function assertMap(value) {
+export function assertMap(value, message) {
     if (!isMap(value)) {
-        throw new TypeError(typeErrorMessage('Map', value));
+        throw new TypeError(message ?? typeErrorMessage('Map', value));
     }
 }
-export function assertNan(value) {
+export function assertNan(value, message) {
     if (!isNan(value)) {
-        throw new TypeError(typeErrorMessage('NaN', value));
+        throw new TypeError(message ?? typeErrorMessage('NaN', value));
     }
 }
-export function assertNativePromise(value) {
+export function assertNativePromise(value, message) {
     if (!isNativePromise(value)) {
-        throw new TypeError(typeErrorMessage('native Promise', value));
+        throw new TypeError(message ?? typeErrorMessage('native Promise', value));
     }
 }
-export function assertNegativeNumber(value) {
+export function assertNegativeNumber(value, message) {
     if (!isNegativeNumber(value)) {
-        throw new TypeError(typeErrorMessage('negative number', value));
+        throw new TypeError(message ?? typeErrorMessage('negative number', value));
     }
 }
-export function assertNodeStream(value) {
+export function assertNodeStream(value, message) {
     if (!isNodeStream(value)) {
-        throw new TypeError(typeErrorMessage('Node.js Stream', value));
+        throw new TypeError(message ?? typeErrorMessage('Node.js Stream', value));
     }
 }
-export function assertNonEmptyArray(value) {
+export function assertNonEmptyArray(value, message) {
     if (!isNonEmptyArray(value)) {
-        throw new TypeError(typeErrorMessage('non-empty array', value));
+        throw new TypeError(message ?? typeErrorMessage('non-empty array', value));
     }
 }
-export function assertNonEmptyMap(value) {
+export function assertNonEmptyMap(value, message) {
     if (!isNonEmptyMap(value)) {
-        throw new TypeError(typeErrorMessage('non-empty map', value));
+        throw new TypeError(message ?? typeErrorMessage('non-empty map', value));
     }
 }
-export function assertNonEmptyObject(value) {
+export function assertNonEmptyObject(value, message) {
     if (!isNonEmptyObject(value)) {
-        throw new TypeError(typeErrorMessage('non-empty object', value));
+        throw new TypeError(message ?? typeErrorMessage('non-empty object', value));
     }
 }
-export function assertNonEmptySet(value) {
+export function assertNonEmptySet(value, message) {
     if (!isNonEmptySet(value)) {
-        throw new TypeError(typeErrorMessage('non-empty set', value));
+        throw new TypeError(message ?? typeErrorMessage('non-empty set', value));
     }
 }
-export function assertNonEmptyString(value) {
+export function assertNonEmptyString(value, message) {
     if (!isNonEmptyString(value)) {
-        throw new TypeError(typeErrorMessage('non-empty string', value));
+        throw new TypeError(message ?? typeErrorMessage('non-empty string', value));
     }
 }
-export function assertNonEmptyStringAndNotWhitespace(value) {
+export function assertNonEmptyStringAndNotWhitespace(value, message) {
     if (!isNonEmptyStringAndNotWhitespace(value)) {
-        throw new TypeError(typeErrorMessage('non-empty string and not whitespace', value));
+        throw new TypeError(message ?? typeErrorMessage('non-empty string and not whitespace', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertNull(value) {
+export function assertNull(value, message) {
     if (!isNull(value)) {
-        throw new TypeError(typeErrorMessage('null', value));
+        throw new TypeError(message ?? typeErrorMessage('null', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertNullOrUndefined(value) {
+export function assertNullOrUndefined(value, message) {
     if (!isNullOrUndefined(value)) {
-        throw new TypeError(typeErrorMessage('null or undefined', value));
+        throw new TypeError(message ?? typeErrorMessage('null or undefined', value));
     }
 }
-export function assertNumber(value) {
+export function assertNumber(value, message) {
     if (!isNumber(value)) {
-        throw new TypeError(typeErrorMessage('number', value));
+        throw new TypeError(message ?? typeErrorMessage('number', value));
     }
 }
-export function assertNumericString(value) {
+export function assertNumericString(value, message) {
     if (!isNumericString(value)) {
-        throw new TypeError(typeErrorMessage('string with a number', value));
+        throw new TypeError(message ?? typeErrorMessage('string with a number', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertObject(value) {
+export function assertObject(value, message) {
     if (!isObject(value)) {
-        throw new TypeError(typeErrorMessage('Object', value));
+        throw new TypeError(message ?? typeErrorMessage('Object', value));
     }
 }
-export function assertObservable(value) {
+export function assertObservable(value, message) {
     if (!isObservable(value)) {
-        throw new TypeError(typeErrorMessage('Observable', value));
+        throw new TypeError(message ?? typeErrorMessage('Observable', value));
     }
 }
-export function assertOddInteger(value) {
+export function assertOddInteger(value, message) {
     if (!isOddInteger(value)) {
-        throw new TypeError(typeErrorMessage('odd integer', value));
+        throw new TypeError(message ?? typeErrorMessage('odd integer', value));
     }
 }
-export function assertPlainObject(value) {
+export function assertPlainObject(value, message) {
     if (!isPlainObject(value)) {
-        throw new TypeError(typeErrorMessage('plain object', value));
+        throw new TypeError(message ?? typeErrorMessage('plain object', value));
     }
 }
-export function assertPositiveNumber(value) {
+export function assertPositiveNumber(value, message) {
     if (!isPositiveNumber(value)) {
-        throw new TypeError(typeErrorMessage('positive number', value));
+        throw new TypeError(message ?? typeErrorMessage('positive number', value));
     }
 }
-export function assertPrimitive(value) {
+export function assertPrimitive(value, message) {
     if (!isPrimitive(value)) {
-        throw new TypeError(typeErrorMessage('primitive', value));
+        throw new TypeError(message ?? typeErrorMessage('primitive', value));
     }
 }
-export function assertPromise(value) {
+export function assertPromise(value, message) {
     if (!isPromise(value)) {
-        throw new TypeError(typeErrorMessage('Promise', value));
+        throw new TypeError(message ?? typeErrorMessage('Promise', value));
     }
 }
-export function assertPropertyKey(value) {
+export function assertPropertyKey(value, message) {
     if (!isPropertyKey(value)) {
-        throw new TypeError(typeErrorMessage('PropertyKey', value));
+        throw new TypeError(message ?? typeErrorMessage('PropertyKey', value));
     }
 }
-export function assertRegExp(value) {
+export function assertRegExp(value, message) {
     if (!isRegExp(value)) {
-        throw new TypeError(typeErrorMessage('RegExp', value));
+        throw new TypeError(message ?? typeErrorMessage('RegExp', value));
     }
 }
-export function assertSafeInteger(value) {
+export function assertSafeInteger(value, message) {
     if (!isSafeInteger(value)) {
-        throw new TypeError(typeErrorMessage('integer', value));
+        throw new TypeError(message ?? typeErrorMessage('integer', value));
     }
 }
-export function assertSet(value) {
+export function assertSet(value, message) {
     if (!isSet(value)) {
-        throw new TypeError(typeErrorMessage('Set', value));
+        throw new TypeError(message ?? typeErrorMessage('Set', value));
     }
 }
-export function assertSharedArrayBuffer(value) {
+export function assertSharedArrayBuffer(value, message) {
     if (!isSharedArrayBuffer(value)) {
-        throw new TypeError(typeErrorMessage('SharedArrayBuffer', value));
+        throw new TypeError(message ?? typeErrorMessage('SharedArrayBuffer', value));
     }
 }
-export function assertString(value) {
+export function assertString(value, message) {
     if (!isString(value)) {
-        throw new TypeError(typeErrorMessage('string', value));
+        throw new TypeError(message ?? typeErrorMessage('string', value));
     }
 }
-export function assertSymbol(value) {
+export function assertSymbol(value, message) {
     if (!isSymbol(value)) {
-        throw new TypeError(typeErrorMessage('symbol', value));
+        throw new TypeError(message ?? typeErrorMessage('symbol', value));
     }
 }
-export function assertTruthy(value) {
+export function assertTruthy(value, message) {
     if (!isTruthy(value)) {
-        throw new TypeError(typeErrorMessage('truthy', value));
+        throw new TypeError(message ?? typeErrorMessage('truthy', value));
     }
 }
-export function assertTupleLike(value, guards) {
+export function assertTupleLike(value, guards, message) {
     if (!isTupleLike(value, guards)) {
-        throw new TypeError(typeErrorMessage('tuple-like', value));
+        throw new TypeError(message ?? typeErrorMessage('tuple-like', value));
     }
 }
-export function assertTypedArray(value) {
+export function assertTypedArray(value, message) {
     if (!isTypedArray(value)) {
-        throw new TypeError(typeErrorMessage('TypedArray', value));
+        throw new TypeError(message ?? typeErrorMessage('TypedArray', value));
     }
 }
-export function assertUint16Array(value) {
+export function assertUint16Array(value, message) {
     if (!isUint16Array(value)) {
-        throw new TypeError(typeErrorMessage('Uint16Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Uint16Array', value));
     }
 }
-export function assertUint32Array(value) {
+export function assertUint32Array(value, message) {
     if (!isUint32Array(value)) {
-        throw new TypeError(typeErrorMessage('Uint32Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Uint32Array', value));
     }
 }
-export function assertUint8Array(value) {
+export function assertUint8Array(value, message) {
     if (!isUint8Array(value)) {
-        throw new TypeError(typeErrorMessage('Uint8Array', value));
+        throw new TypeError(message ?? typeErrorMessage('Uint8Array', value));
     }
 }
-export function assertUint8ClampedArray(value) {
+export function assertUint8ClampedArray(value, message) {
     if (!isUint8ClampedArray(value)) {
-        throw new TypeError(typeErrorMessage('Uint8ClampedArray', value));
+        throw new TypeError(message ?? typeErrorMessage('Uint8ClampedArray', value));
     }
 }
-export function assertUndefined(value) {
+export function assertUndefined(value, message) {
     if (!isUndefined(value)) {
-        throw new TypeError(typeErrorMessage('undefined', value));
+        throw new TypeError(message ?? typeErrorMessage('undefined', value));
     }
 }
-export function assertUrlInstance(value) {
+export function assertUrlInstance(value, message) {
     if (!isUrlInstance(value)) {
-        throw new TypeError(typeErrorMessage('URL', value));
+        throw new TypeError(message ?? typeErrorMessage('URL', value));
     }
 }
 // eslint-disable-next-line unicorn/prevent-abbreviations
-export function assertUrlSearchParams(value) {
+export function assertUrlSearchParams(value, message) {
     if (!isUrlSearchParams(value)) {
-        throw new TypeError(typeErrorMessage('URLSearchParams', value));
+        throw new TypeError(message ?? typeErrorMessage('URLSearchParams', value));
     }
 }
-export function assertUrlString(value) {
+export function assertUrlString(value, message) {
     if (!isUrlString(value)) {
-        throw new TypeError(typeErrorMessage('string with a URL', value));
+        throw new TypeError(message ?? typeErrorMessage('string with a URL', value));
     }
 }
-export function assertValidDate(value) {
+export function assertValidDate(value, message) {
     if (!isValidDate(value)) {
-        throw new TypeError(typeErrorMessage('valid Date', value));
+        throw new TypeError(message ?? typeErrorMessage('valid Date', value));
     }
 }
-export function assertValidLength(value) {
+export function assertValidLength(value, message) {
     if (!isValidLength(value)) {
-        throw new TypeError(typeErrorMessage('valid length', value));
+        throw new TypeError(message ?? typeErrorMessage('valid length', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertWeakMap(value) {
+export function assertWeakMap(value, message) {
     if (!isWeakMap(value)) {
-        throw new TypeError(typeErrorMessage('WeakMap', value));
+        throw new TypeError(message ?? typeErrorMessage('WeakMap', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertWeakRef(value) {
+export function assertWeakRef(value, message) {
     if (!isWeakRef(value)) {
-        throw new TypeError(typeErrorMessage('WeakRef', value));
+        throw new TypeError(message ?? typeErrorMessage('WeakRef', value));
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function assertWeakSet(value) {
+export function assertWeakSet(value, message) {
     if (!isWeakSet(value)) {
-        throw new TypeError(typeErrorMessage('WeakSet', value));
+        throw new TypeError(message ?? typeErrorMessage('WeakSet', value));
     }
 }
-export function assertWhitespaceString(value) {
+export function assertWhitespaceString(value, message) {
     if (!isWhitespaceString(value)) {
-        throw new TypeError(typeErrorMessage('whitespace string', value));
+        throw new TypeError(message ?? typeErrorMessage('whitespace string', value));
     }
 }
 export default is;

package.json

 {
 	"name": "@sindresorhus/is",
-	"version": "6.2.0",
+	"version": "6.3.0",
 	"description": "Type check values",
@@ -5,0 +5,0 @@ "license": "MIT",

readme.md

@@ -48,2 +48,11 @@ # is
 
+Assertions (except `assertAll` and `assertAny`) also support an optional custom error message.
+
+```js
+import {assert} from '@sindresorhus/is';
+
+assert.nonEmptyString(process.env.API_URL, 'The API_URL environment variable is required.');
+//=> Error: The API_URL environment variable is required.
+```
+
 And with TypeScript:
@@ -50,0 +59,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

99507

increased by5.63%

Number of lines in readme file

762

increased by1.2%

No dependency changes