@budsbox/lib-es 2.2.0 → 3.0.0

package/dist/guards/assert.js

@@ -0,0 +1,245 @@
+/**
+ * @module
+ * Provides assertion functions for runtime type checking and validation.
+ * @categoryDescription Assertions
+ * Assertion functions for runtime type checking and validation.
+ */
+import { isArray, isBoolean, isDate, isDef, isError, isFunction, isMap, isNotNil, isNumber, isObject, isPrimitive, isPropKey, isRegExp, isSet, isString, isSymbol, isTrue, isWeakMapLike, isWeakSetLike, } from './check.js';
+import { describeComplexPredicate } from './describe.js';
+import { formatAccessString, formatPredicateExpectedMessage, } from './format.js';
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GENERAL ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+/**
+ * {@link InvariantFn} implementation.
+ *
+ * @inheritDoc {@link InvariantFn}
+ */
+export const invariant = (condition, message = formatPredicateExpectedMessage(isTrue, false, 'condition')) => {
+    if (!isTrue(condition))
+        throw new TypeError(isFunction(message) ? message() : message);
+};
+/**
+ * {@link InvariantPredicateFn} implementation.
+ *
+ * @inheritDoc {@link InvariantPredicateFn}
+ */
+export const invariantPredicate = (predicate, value, valueName = 'value') => {
+    invariant(callPredicate(predicate, value), () => formatPredicateExpectedMessage(predicate, value, valueName));
+};
+export function callPredicate(predicate, value, predicateName = 'predicate') {
+    if (!isFunction(predicate))
+        throw new TypeError(formatPredicateExpectedMessage(isFunction, predicate, predicateName));
+    const result = predicate(value);
+    if (!isBoolean(result))
+        throw new TypeError(formatPredicateExpectedMessage(isBoolean, result, 'predicate result'));
+    return result;
+}
+export function normalizeOptionalRest(predicateSequence, args, restShift = 0) {
+    if (args.length > predicateSequence.length)
+        throw new TypeError(
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `Too many arguments provided. Expected at most ${predicateSequence.length + restShift}, got ${args.length + restShift}`);
+    const output = new Array(predicateSequence.length).fill(undefined);
+    let predicateSuccessIndex = -1, argIndex = 0;
+    for (let i = 0; i < predicateSequence.length; i++) {
+        const predicate = predicateSequence[i];
+        if (callPredicate(predicate, args[argIndex])) {
+            predicateSuccessIndex = i;
+            output[i] = args[argIndex++];
+        }
+    }
+    if (argIndex < args.length &&
+        !args.slice(argIndex).every((v) => v === undefined)) {
+        invariantPredicate(describeComplexPredicate(() => false, // dummy
+        false, ...predicateSequence.slice(predicateSuccessIndex + 1)), args[argIndex], formatAccessString('args', argIndex + restShift));
+    }
+    return output;
+}
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ASSERTIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+/**
+ * Asserts that the given value is defined (not undefined).
+ *
+ * @param value - The value to be checked for being defined.
+ * @param name - An optional name or description of the value included in the error message if the assertion fails.
+ * @throws {@link !TypeError} If the value is undefined.
+ * @typeParam T - The type of the value being asserted.
+ * @category Assertions
+ */
+export function assertDef(value, name) {
+    invariantPredicate(isDef, value, name);
+}
+/**
+ * Asserts that the provided value is neither null nor undefined.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is null or undefined.
+ * @category Assertions
+ */
+export function assertNotNil(value, name) {
+    invariantPredicate(isNotNil, value, name);
+}
+/**
+ * Asserts that the provided value is a string.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a string.
+ * @category Assertions
+ */
+export function assertString(value, name) {
+    invariantPredicate(isString, value, name);
+}
+/**
+ * Asserts that the provided value is a number and not NaN.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a number or NaN.
+ * @remarks Throws a {@link !TypeError} if the value is NaN.
+ * @category Assertions
+ */
+export function assertNumber(value, name) {
+    invariantPredicate(isNumber, value, name);
+}
+/**
+ * Asserts that the provided value is a symbol.
+ *
+ * @param value - The value to be checked.
+ * @param name - An optional name for the value, used in the error message if the assertion fails. Defaults to 'value'.
+ * @throws {@link !TypeError} If the value is not a symbol.
+ * @category Assertions
+ */
+export function assertSymbol(value, name) {
+    invariantPredicate(isSymbol, value, name);
+}
+/**
+ * Asserts that the provided value is a valid property key (string, number, or symbol).
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a valid property key.
+ * @category Assertions
+ */
+export function assertPropKey(value, name) {
+    invariantPredicate(isPropKey, value, name);
+}
+/**
+ * Asserts that the provided value is a boolean.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a boolean.
+ * @category Assertions
+ */
+export function assertBoolean(value, name) {
+    invariantPredicate(isBoolean, value, name);
+}
+/**
+ * Asserts that the provided value is a primitive type (string, number, boolean, bigint, symbol, null, or undefined).
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a primitive type.
+ * @category Assertions
+ */
+export function assertPrimitive(value, name) {
+    invariantPredicate(isPrimitive, value, name);
+}
+/**
+ * Asserts that the provided value is an object.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not an object.
+ * @category Assertions
+ */
+export function assertObject(value, name) {
+    invariantPredicate(isObject, value, name);
+}
+export function assertArray(value, ...rest) {
+    const [predicate, name = 'valueName'] = normalizeOptionalRest([isFunction, isString], rest, 1);
+    invariantPredicate(isArray, value, name);
+    if (isFunction(predicate))
+        value.forEach((el, i) => void invariantPredicate(predicate, el, `${name}[${String(i)}]`));
+}
+export function assertFunction(value, name) {
+    invariantPredicate(isFunction, value, name);
+}
+/**
+ * Asserts that the provided value is a Date object.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a Date object.
+ * @category Assertions
+ */
+export function assertDate(value, name) {
+    invariantPredicate(isDate, value, name);
+}
+/**
+ * Asserts that the provided value is a RegExp object.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a RegExp object.
+ * @category Assertions
+ */
+export function assertRegExp(value, name) {
+    invariantPredicate(isRegExp, value, name);
+}
+/**
+ * Asserts that the provided value is an Error object.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not an Error object.
+ * @category Assertions
+ */
+export function assertError(value, name) {
+    invariantPredicate(isError, value, name);
+}
+/**
+ * Asserts that the provided value is a Map object.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a Map object.
+ * @category Assertions
+ */
+export function assertMap(value, name) {
+    invariantPredicate(isMap, value, name);
+}
+/**
+ * Asserts that the provided value is a Set object.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a Set object.
+ * @category Assertions
+ */
+export function assertSet(value, name) {
+    invariantPredicate(isSet, value, name);
+}
+/**
+ * Asserts that the provided value is WeakMap-like (a WeakMap object).
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a WeakMap object.
+ * @category Assertions
+ */
+export function assertWeakMapLike(value, name) {
+    invariantPredicate(isWeakMapLike, value, name);
+}
+/**
+ * Asserts that the provided value is WeakSet-like (a WeakSet object).
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @throws {@link !TypeError} If the value is not a WeakSet object.
+ * @category Assertions
+ */
+export function assertWeakSetLike(value, name) {
+    invariantPredicate(isWeakSetLike, value, name);
+}
+//# sourceMappingURL=assert.js.map

package/dist/guards/check.d.ts

@@ -0,0 +1,470 @@
+/**
+ * @module
+ * This module provides type guards for various JavaScript types.
+ * @categoryDescription Checks
+ * Type guards for JavaScript primitives and common types.
+ */
+import type { Primitive } from 'type-fest';
+import type { AnyFunction, Nil, NonNil, Undef, UnknownFunction, WithFallback } from '@budsbox/lib-types';
+export type { Primitive };
+/**
+ * Checks if the provided value is `undefined`.
+ *
+ * @param value - The value to check for `undefined`.
+ * @returns `true` if the value is `undefined`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isUndef(undefined); // true
+ * isUndef(null); // false
+ * isUndef(0); // false
+ * ```
+ * @category Checks
+ */
+export declare function isUndef(value: unknown): value is Undef;
+/**
+ * {@label OVERLOAD_T}
+ *
+ * Checks if a given value is defined (not `undefined`).
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is defined, otherwise `false`.
+ * @typeParam T - Type of the input value.
+ * @example
+ * ```typescript
+ * isDef(undefined); // false
+ * isDef(null); // true
+ * isDef(42); // true
+ * ```
+ * @category Checks
+ */
+export declare function isDef<T>(value: T): value is NonNil<T> | (null & T);
+/**
+ * Checks if the provided value is `null` or `undefined`.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is `null` or `undefined`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isNil(null); // true
+ * isNil(undefined); // true
+ * isNil(false); // false
+ * isNil(''); // false
+ * ```
+ * @category Checks
+ */
+export declare function isNil(value: unknown): value is Nil;
+/**
+ * {@label OVERLOAD_VALUE}
+ *
+ * Checks if the provided value is not `null` or `undefined`.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is not `null` or `undefined`; otherwise, `false`.
+ * @example
+ * ```typescript
+ * isNotNil(null); // false
+ * isNotNil(undefined); // false
+ * isNotNil(0); // true
+ * isNotNil(''); // true
+ * ```
+ * @category Checks
+ */
+export declare function isNotNil(value: unknown): value is NonNil;
+/**
+ * Checks if the given value is of type ``boolean``.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `boolean`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isBoolean(true); // true
+ * isBoolean(false); // true
+ * isBoolean(1); // false
+ * isBoolean('true'); // false
+ * ```
+ * @category Checks
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if the provided value is strictly equal to `true`.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is strictly `true`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isTrue(true); // true
+ * isTrue(1); // false
+ * isTrue('true'); // false
+ * isTrue(false); // false
+ * ```
+ * @category Checks
+ */
+export declare function isTrue(value: unknown): value is true;
+/**
+ * Determines if the provided value is strictly `false`.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is `false`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isFalse(false); // true
+ * isFalse(0); // false
+ * isFalse(''); // false
+ * isFalse(true); // false
+ * ```
+ * @category Checks
+ */
+export declare function isFalse(value: unknown): value is false;
+/**
+ * Determines if the given value is truthy, i.e., converts to `true` when used in a `boolean` context.
+ *
+ * @param value - The value to be tested for truthiness.
+ * @returns `true` if the value is truthy, `false` otherwise.
+ * @example
+ * ```typescript
+ * isTruly(true); // true
+ * isTruly(1); // true
+ * isTruly('hello'); // true
+ * isTruly(0); // false
+ * isTruly(''); // false
+ * isTruly(null); // false
+ * ```
+ * @category Checks
+ */
+export declare function isTruly(value: unknown): boolean;
+/**
+ * Determines if a given value is falsy.
+ * A value is considered falsy if it evaluates to `false` when coerced to a `boolean`.
+ *
+ * @param value - The value to be tested.
+ * @returns `true` if the value is falsy, otherwise `false`.
+ * @example
+ * ```typescript
+ * isFalsy(false); // true
+ * isFalsy(0); // true
+ * isFalsy(''); // true
+ * isFalsy(null); // true
+ * isFalsy(undefined); // true
+ * isFalsy('hello'); // false
+ * ```
+ * @category Checks
+ */
+export declare function isFalsy(value: unknown): boolean;
+/**
+ * Checks if the provided value is a `number` and not {@link NaN}.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is a `number` and not {@link NaN}, otherwise `false`.
+ * @example
+ * ```typescript
+ * isNumber(42); // true
+ * isNumber(3.14); // true
+ * isNumber(NaN); // false
+ * isNumber('42'); // false
+ * isNumber(null); // false
+ * ```
+ * @category Checks
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a given value is of type `bigint`.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is a `bigint`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isBigint(42n); // true
+ * isBigint(42); // false
+ * isBigint('42'); // false
+ * isBigint(BigInt(42)); // true
+ * ```
+ * @category Checks
+ */
+export declare function isBigint(value: unknown): value is bigint;
+/**
+ * Determines whether a given number is positive.
+ *
+ * @param num - The `number` or `bigint` to check.
+ * @returns `true` if the input is greater than zero, otherwise `false`.
+ * @example
+ * ```typescript
+ * isPositive(42); // true
+ * isPositive(0); // false
+ * isPositive(-5); // false
+ * isPositive(100n); // true
+ * ```
+ * @category Checks
+ */
+export declare function isPositive(num: bigint | number): boolean;
+/**
+ * Determines whether a given number is non-negative.
+ *
+ * @param num - The number to check. It can be a `bigint` or a `number`.
+ * @returns `true` if the provided number is greater than or equal to zero, otherwise `false`.
+ * @example
+ * ```typescript
+ * isNonNegative(42); // true
+ * isNonNegative(0); // true
+ * isNonNegative(-1); // false
+ * isNonNegative(0n); // true
+ * ```
+ * @category Checks
+ */
+export declare function isNonNegative(num: bigint | number): boolean;
+/**
+ * Checks if the provided value is an integer.
+ *
+ * @param value - The value to check, which can be a `bigint` or `number`.
+ * @returns `true` if the value is an integer, otherwise `false`.
+ * @example
+ * ```typescript
+ * isInteger(42); // true
+ * isInteger(3.14); // false
+ * isInteger(42n); // true
+ * ```
+ * @category Checks
+ */
+export declare function isInteger(value: unknown): value is bigint | number;
+/**
+ * Determines if the provided value is a `string`.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `string`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isString('hello'); // true
+ * isString(42); // false
+ * ```
+ * @category Checks
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Checks if the provided value is of type ``symbol``.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `symbol`, otherwise `false`.
+ * @example
+ * ```typescript
+ * isSymbol(Symbol('foo')); // true
+ * isSymbol('foo'); // false
+ * ```
+ * @category Checks
+ */
+export declare const isSymbol: (value: unknown) => value is symbol;
+/**
+ * Determines whether the given value is a valid JavaScript property key.
+ *
+ * A property key in JavaScript can be a `string`, `symbol`, or `number`, as these are
+ * the types allowed for indexing object properties.
+ *
+ * @param value - The value to be checked as a potential property key.
+ * @returns `true` if the value is a valid property key, otherwise `false`.
+ * @example
+ * ```typescript
+ * isPropKey('foo'); // true
+ * isPropKey(123); // true
+ * isPropKey(Symbol('bar')); // true
+ * isPropKey({}); // false
+ * ```
+ * @category Checks
+ */
+export declare const isPropKey: (value: unknown) => value is PropertyKey;
+/**
+ * Checks if a given value is a {@link Primitive} type (`null`, `undefined`, `boolean`, `string`, `number`, `symbol`, or `bigint`).
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link Primitive} type, otherwise `false`.
+ * @example
+ * ```typescript
+ * isPrimitive(42); // true
+ * isPrimitive('foo'); // true
+ * isPrimitive(null); // true
+ * isPrimitive({}); // false
+ * ```
+ * @category Checks
+ */
+export declare const isPrimitive: (value: unknown) => value is Primitive;
+/**
+ * Checks if the given value is an {@link object}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is an {@link object}, `false` otherwise.
+ * @example
+ * ```typescript
+ * isObject({}); // true
+ * isObject([]); // true
+ * isObject(null); // false
+ * ```
+ * @category Checks
+ */
+export declare function isObject(value: unknown): value is object;
+/**
+ * Checks if the given value is an {@link Array}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is an {@link Array}, otherwise `false`.
+ * @typeParam T - Type of the value to be checked.
+ * @example
+ * ```typescript
+ * isArray([1, 2, 3]); // true
+ * isArray('foo'); // false
+ * ```
+ * @category Checks
+ */
+export declare function isArray<T>(value: T): value is WithFallback<Extract<T, readonly unknown[]>, T & unknown[]>;
+/**
+ * {@label OVERLOAD_T}
+ *
+ * Determines if the provided value is a function.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a function, otherwise `false`.
+ * @typeParam T - The type of the value being checked.
+ * @example
+ * ```typescript
+ * isFunction(() => {}); // true
+ * isFunction(42); // false
+ * ```
+ * @category Checks
+ */
+export declare function isFunction<T>(value: T): value is WithFallback<Extract<T, AnyFunction>, UnknownFunction & T>;
+/**
+ * {@label OVERLOAD_TFN}
+ *
+ * Determines if the provided value is of type {@link Function}.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is a function, otherwise `false`.
+ * @typeParam TFn - Function type to narrow to when the check passes.
+ * @example
+ * ```typescript
+ * isFunction<() => void>(() => {}); // true
+ * ```
+ * @category Checks
+ */
+export declare function isFunction<TFn extends AnyFunction = UnknownFunction>(value: unknown): value is TFn;
+/**
+ * {@label OVERLOAD_UNKNOWN}
+ *
+ * Determines if the provided value is a function.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a function, otherwise `false`.
+ * @category Checks
+ */
+export declare function isFunction(value: unknown): value is AnyFunction;
+/**
+ * Checks if the given value is a {@link Date} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link Date} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isDate(new Date()); // true
+ * isDate('2023-01-01'); // false
+ * ```
+ * @category Checks
+ */
+export declare function isDate(value: unknown): value is Date;
+/**
+ * Checks if the given value is a {@link RegExp} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link RegExp} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isRegExp(/foo/); // true
+ * isRegExp('foo'); // false
+ * ```
+ * @category Checks
+ */
+export declare function isRegExp(value: unknown): value is RegExp;
+/**
+ * Checks if the given value is an {@link Error} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is an {@link Error} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isError(new Error('foo')); // true
+ * isError({ message: 'foo' }); // false
+ * ```
+ * @category Checks
+ */
+export declare function isError(value: unknown): value is Error;
+/**
+ * Checks if the given value is a {@link Map} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link Map} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isMap(new Map()); // true
+ * isMap({}); // false
+ * ```
+ * @category Checks
+ */
+export declare function isMap(value: unknown): value is Map<unknown, unknown>;
+/**
+ * Checks if the given value is a {@link Set} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link Set} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isSet(new Set()); // true
+ * isSet([]); // false
+ * ```
+ * @category Checks
+ */
+export declare function isSet(value: unknown): value is Set<unknown>;
+/**
+ * Checks if the given value is a {@link WeakMap} or {@link Map} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link WeakMap} or {@link Map} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isWeakMapLike(new WeakMap()); // true
+ * isWeakMapLike(new Map()); // true
+ * isWeakMapLike({}); // false
+ * ```
+ * @category Checks
+ */
+export declare function isWeakMapLike(value: unknown): value is Map<unknown, unknown> | WeakMap<WeakKey, unknown>;
+/**
+ * Checks if the given value is a {@link WeakSet} or {@link Set} instance.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link WeakSet} or {@link Set} instance, otherwise `false`.
+ * @example
+ * ```typescript
+ * isWeakSetLike(new WeakSet()); // true
+ * isWeakSetLike(new Set()); // true
+ * isWeakSetLike([]); // false
+ * ```
+ * @category Checks
+ */
+export declare function isWeakSetLike(value: unknown): value is Set<unknown> | WeakSet<WeakKey>;
+/**
+ * Determines whether two values are the same value using the
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness#same-value-zero_equality "SameValueZero" comparison algorithm}.
+ *
+ * @param x - The first value to be compared.
+ * @param y - The second value to be compared.
+ * @returns `true` if `x` and `y` are the same value according to the "SameValueZero" comparison, otherwise `false`.
+ * @remarks
+ * - It differs from strict equality (`===`) in that {@link NaN} is considered equal to itself.
+ * - It differs from {@link Object.is} in that it considers `-0` and `+0` equal.
+ * - It's the same algorithm used by {@link Set} and {@link Map} to compare elements.
+ * @typeParam TValue - The type of the first value being compared.
+ * @example
+ * ```typescript
+ * sameValueZero(0, -0); // true
+ * sameValueZero(NaN, NaN); // true
+ * sameValueZero(1, '1'); // false
+ * ```
+ * @category Checks
+ */
+export declare const sameValueZero: <TValue>(x: TValue, y: unknown) => y is TValue;
+//# sourceMappingURL=check.d.ts.map