@budsbox/lib-es 2.3.0 → 3.0.0

package/dist/array.d.ts

@@ -1,53 +1,75 @@
-import type { TupleN } from '@budsbox/lib-types';
-import type { FValue } from './types.js';
 /**
- * Ensures that the provided value is returned as an array. If the value is already an array,
- * it is returned as-is. If the value is not an array, it is wrapped in a new array.
+ * This module provides array utility functions for common operations like deduplication, union, intersection, difference, etc.
  *
- * @param value - The value to be checked and converted into an array if necessary.
- * @returns An array containing the original value or the original array if it was already an array.
+ * @module
+ * @importTarget ./array
+ */
+import type { FValue, TupleN } from '@budsbox/lib-types';
+/**
+ * @module
+ *
+ * Array utility functions for common operations like deduplication, union, intersection, and difference.
+ */
+/**
+ * {@label MUTABLE} Returns the value as an array. If already an array, returns it as-is; otherwise wraps it.
+ *
+ * @param value - The value to convert.
+ * @returns An array containing the value.
+ * @typeParam T - The element type.
  */
 export declare function ensureArray<T>(value: T | T[]): T[];
+/**
+ * {@label READONLY} Returns the value as an array. If already an array, returns it as-is; otherwise wraps it.
+ *
+ * @param value - The value to convert.
+ * @returns An array containing the value.
+ * @typeParam T - The element type.
+ */
 export declare function ensureArray<T>(value: readonly T[] | T): readonly T[];
 /**
- * Creates an array of a fixed length with all elements initialized to the specified value.
+ * Creates a fixed-length array filled with a value or computed by a function.
  *
- * @param n - The length of the array to create.
- * @param value - The value to fill the array with. Defaults to `null`.
- * @returns A tuple of the specified length with all elements set to the given value.
+ * @param n - The desired array length.
+ * @param value - The fill value or a function that receives the index and returns the element value. Defaults to `null`.
+ * @returns A tuple of length N with all elements set to the value or computed result.
+ * @throws {@link !TypeError} if `n` is not a non-negative integer.
+ * @typeParam N - The array length.
+ * @typeParam T - The element type.
  */
 export declare function nArray<N extends number, T = null>(n: N, value?: FValue<number, T>): TupleN<N, T>;
 /**
- * Removes duplicate elements from the provided array while preserving the order of the first occurrence of each element.
+ * Removes duplicate elements from an array, preserving the order of the first occurrence.
  *
- * @param items - The array of items from which duplicates should be removed.
- *                The array is expected to be read-only and can contain elements of any type.
- * @returns A new array containing only the unique elements from the input array, in the order of their first occurrence.
+ * @param items - The array to deduplicate.
+ * @returns A new array with unique elements in their original order.
+ * @throws {@link !TypeError} if `items` is not an array.
+ * @typeParam T - The element type.
  */
 export declare const dedupe: <T>(items: readonly T[]) => T[];
 /**
- * Creates an array of unique values from the combined elements of the input arrays.
+ * Creates an array of unique values from multiple input arrays.
  *
- * @param arrays - The arrays to be merged and deduplicated.
- * @returns An array containing unique elements from all input arrays.
+ * @param arrays - Arrays or individual elements to merge.
+ * @returns A new array containing unique elements from all inputs.
+ * @typeParam T - The element type.
  */
 export declare function union<T>(...arrays: ReadonlyArray<readonly T[] | T>): T[];
 /**
- * Computes the intersection of multiple arrays, returning an array that contains
- * all elements that are present in every input array.
+ * Returns elements present in all input arrays.
  *
- * @param arrays - A variadic parameter allowing multiple arrays or single elements.
- * Each array or element will be checked for intersection.
- * @returns An array containing elements that are present in all input arrays.
+ * @param arrays - Arrays or individual elements to intersect.
+ * @returns A new array containing elements common to all inputs.
+ * @typeParam T - The element type.
  */
 export declare function intersection<T>(...arrays: ReadonlyArray<readonly T[] | T>): T[];
 /**
- * Computes the difference between a source array and one or more arrays of exclusions.
- * Returns a new array containing elements from the source array that are not present in any of the exclusion arrays.
+ * Returns elements from the source array that are not in any exclusion arrays.
  *
- * @param source - The source array to compare against.
- * @param excludes - Arrays containing elements to be excluded from the source array.
- * @returns A new array containing elements from the source array that are not in the exclusion arrays.
+ * @param source - The source array.
+ * @param excludes - Arrays of elements to exclude.
+ * @returns A new array with excluded elements removed.
+ * @throws {@link !TypeError} if `source` is not an array or `excludes` contains non-array elements.
+ * @typeParam T - The element type.
  */
 export declare function diff<T>(source: readonly T[], ...excludes: ReadonlyArray<readonly T[]>): T[];
 //# sourceMappingURL=array.d.ts.map

package/dist/array.js

@@ -1,9 +1,15 @@
-import { isFunction } from '#guards';
+/**
+ * This module provides array utility functions for common operations like deduplication, union, intersection, difference, etc.
+ *
+ * @module
+ * @importTarget ./array
+ */
+import { assertArray, assertEvery, isArray, isFunction, isInteger, isNonNegative, isNumber, } from '#guards';
 export function ensureArray(value) {
     return Array.isArray(value) ? value : [value];
 }
 export function nArray(n, value = null) {
-    // eslint-disable-next-line jsdoc/require-jsdoc
+    assertEvery(n, 'n', isNumber, isNonNegative, isInteger);
     if (isFunction(value)) {
         const newArray = new Array(n);
         for (let i = 0; i < newArray.length; i++) {
@@ -14,29 +20,33 @@ export function nArray(n, value = null) {
     return new Array(n).fill(value);
 }
 /**
- * Removes duplicate elements from the provided array while preserving the order of the first occurrence of each element.
+ * Removes duplicate elements from an array, preserving the order of the first occurrence.
  *
- * @param items - The array of items from which duplicates should be removed.
- *                The array is expected to be read-only and can contain elements of any type.
- * @returns A new array containing only the unique elements from the input array, in the order of their first occurrence.
+ * @param items - The array to deduplicate.
+ * @returns A new array with unique elements in their original order.
+ * @throws {@link !TypeError} if `items` is not an array.
+ * @typeParam T - The element type.
  */
-export const dedupe = (items) => Array.from(new Set(items));
+export const dedupe = (items) => {
+    assertArray(items, 'items');
+    return Array.from(new Set(items));
+};
 /**
- * Creates an array of unique values from the combined elements of the input arrays.
+ * Creates an array of unique values from multiple input arrays.
  *
- * @param arrays - The arrays to be merged and deduplicated.
- * @returns An array containing unique elements from all input arrays.
+ * @param arrays - Arrays or individual elements to merge.
+ * @returns A new array containing unique elements from all inputs.
+ * @typeParam T - The element type.
  */
 export function union(...arrays) {
     return dedupe(arrays.flatMap((v) => v));
 }
 /**
- * Computes the intersection of multiple arrays, returning an array that contains
- * all elements that are present in every input array.
+ * Returns elements present in all input arrays.
  *
- * @param arrays - A variadic parameter allowing multiple arrays or single elements.
- * Each array or element will be checked for intersection.
- * @returns An array containing elements that are present in all input arrays.
+ * @param arrays - Arrays or individual elements to intersect.
+ * @returns A new array containing elements common to all inputs.
+ * @typeParam T - The element type.
  */
 export function intersection(...arrays) {
     const { length } = arrays;
@@ -52,14 +62,16 @@ export function intersection(...arrays) {
         .map(([item]) => item);
 }
 /**
- * Computes the difference between a source array and one or more arrays of exclusions.
- * Returns a new array containing elements from the source array that are not present in any of the exclusion arrays.
+ * Returns elements from the source array that are not in any exclusion arrays.
  *
- * @param source - The source array to compare against.
- * @param excludes - Arrays containing elements to be excluded from the source array.
- * @returns A new array containing elements from the source array that are not in the exclusion arrays.
+ * @param source - The source array.
+ * @param excludes - Arrays of elements to exclude.
+ * @returns A new array with excluded elements removed.
+ * @throws {@link !TypeError} if `source` is not an array or `excludes` contains non-array elements.
+ * @typeParam T - The element type.
  */
 export function diff(source, ...excludes) {
+    assertArray(excludes, isArray, 'excludes');
     const set = new Set(excludes.flatMap((v) => v));
     return source.filter((v) => !set.has(v));
 }

package/dist/function.d.ts

@@ -1,5 +1,12 @@
+/**
+ * This module provides utility functions for working with functions, including caching and memoization.
+ *
+ * @module
+ * @importTarget ./function
+ */
 import type { UnknownArray } from 'type-fest';
-import type { AnyFunction } from '@budsbox/lib-types';
+import type { AnyFunction, Predicate } from '@budsbox/lib-types';
+import { type NormalizedOptionalRest } from '#guards';
 /**
  * A function that does nothing.
  */
@@ -13,16 +20,17 @@ export declare const noop: () => void;
 export declare const pass: <T>(value: T) => T;
 type CacheableFn<TFn extends AnyFunction> = Parameters<TFn> extends [unknown, ...UnknownArray] ? TFn : never;
 type DefaultCacheKey<TFn extends AnyFunction> = Parameters<TFn> extends [infer TArg0, ...UnknownArray] ? TArg0 : never;
-type CachedFn<TFn extends AnyFunction, TKey = DefaultCacheKey<TFn>> = TFn extends (...args: infer TArgs) => infer TReturn ? (cacheMap: Map<TKey, TReturn>, ...args: TArgs) => TReturn : never;
+type CachedFn<TFn extends AnyFunction, TKey = DefaultCacheKey<TFn>> = TFn extends (...args: infer TArgs) => infer TReturn ? (cacheMap: (TKey extends WeakKey ? WeakMap<TKey, TReturn> : never) | Map<TKey, TReturn>, ...args: TArgs) => TReturn : never;
 /**
  * Creates a cached version of a given function.
  * The returned function stores the results of previous calls in a provided cache map
  * and returns the cached result when called with the same arguments,
  * reducing redundant calculations or operations.
  *
- * @remarks A provided function has to accept at least one argument, or it fails typechecking.
- * @param fn - The function to be cached. It must conform to the `CacheableFn` type.
+ * @param fn - The function to be cached.
  * @returns A new function that accepts the cache map as the first argument and the original function's arguments as the rest.
+ * @remarks A provided function has to accept at least one argument, or it fails typechecking.
+ * @typeParam TFn - The type of function to be cache. It extends `AnyFunction` type.
  */
 export declare function createCachedFn<TFn extends AnyFunction>(fn: CacheableFn<TFn>): CachedFn<TFn>;
 /**
@@ -34,11 +42,60 @@ export declare function createCachedFn<TFn extends AnyFunction>(fn: CacheableFn<
  * key for each set of arguments. If the same key is generated for later
  * calls, the cached result is returned instead of invoking the original function.
  *
- * @remarks A provided function has to accept at least one argument, or it fails typechecking.
- * @param fn - The function to be cached. It must conform to the `CacheableFn` type.
+ * @param fn - The function to be cached.
  * @param keyFn - A function that generates a unique key based on the arguments passed to `fn`.
  * @returns A new function that accepts the cache map as the first argument and the original function's arguments as the rest.
+ * @remarks A provided function has to accept at least one argument, or it fails typechecking.
+ * @typeParam TFn - The type of function to be cache. It extends the ` AnyFunction ` type.
+ * @typeParam TKey - The type of key generated by the key function.
  */
 export declare function createCachedFn<TFn extends AnyFunction, TKey>(fn: CacheableFn<TFn>, keyFn: (...args: Parameters<TFn>) => TKey): CachedFn<TFn, TKey>;
+/**
+ * Normalizes a sequence of optional rest arguments by matching them against a series of type predicates.
+ *
+ * This function takes an array of arguments and attempts to match each argument against the corresponding
+ * predicate in the sequence. Arguments that match their predicates are placed at their respective positions
+ * in the output array, while unmatched positions are filled with `undefined`. This enables flexible function
+ * signatures where arguments can be provided with gaps as long as they're in the right order.
+ *
+ * The function validates that:
+ * - No more arguments are provided than there are predicates
+ * - Each argument matches its corresponding predicate in sequence
+ * - Any remaining arguments after a successful match also satisfy the subsequent predicates
+ *
+ * @param predicateSequence - An ordered array of type predicates that define the expected types for each position.
+ * @param args - The actual arguments to normalize against the predicate sequence.
+ * @param restShift - An optional offset added to argument indices in error messages, useful when these
+ *                   arguments are part of a larger parameter list. Defaults to 0.
+ * @returns A tuple where each element is either the matched argument value or `undefined` if no match was found
+ *         at that position. The length matches the predicate sequence length.
+ * @throws {@link !TypeError} If more arguments are provided than predicates in the sequence.
+ * @throws {@link !TypeError} If an argument doesn't match any of the remaining predicates in the sequence.
+ * @typeParam TPredicateSequence - a tuple of predicate types.
+ * @remarks For this function to work, a predicate sequence has to be tuple. Use `as const` to convert array to tuple.
+ * @example
+ * ```typescript
+ * normalizeOptionalRest([isString, isBoolean, isNumber], ['foo'])
+ * // Returns: ['foo', undefined, undefined]
+ *
+ * normalizeOptionalRest([isString, isBoolean, isNumber], [true])
+ * // Returns: [undefined, true, undefined]
+ *
+ * normalizeOptionalRest([isString, isBoolean, isNumber], ['foo', true, 1])
+ * // Returns: ['foo', true, 1]
+ *
+ * normalizeOptionalRest([isString, isBoolean, isNumber] as const, ['foo', 1])
+ * // Returns: ['foo', undefined, 1]
+ *
+ * // Using restShift for better error messages in nested contexts
+ * normalizeOptionalRest([isString, isBoolean] as const, ['foo', 'bar'], 2)
+ * // Throws: TypeError with message referencing rest[3] instead of rest[1]
+ *
+ * // Trailing undefined values are ignored
+ * normalizeOptionalRest([isString, isBoolean, isNumber] as const, ['foo', true, undefined])
+ * // Returns: ['foo', true, undefined]
+ * ```
+ */
+export declare function normalizeOptionalRest<TPredicateSequence extends ReadonlyArray<Predicate<unknown>>>(predicateSequence: TPredicateSequence, args: readonly unknown[], restShift?: number): NormalizedOptionalRest<TPredicateSequence>;
 export {};
 //# sourceMappingURL=function.d.ts.map

package/dist/function.js

@@ -1,3 +1,11 @@
+/**
+ * This module provides utility functions for working with functions, including caching and memoization.
+ *
+ * @module
+ * @importTarget ./function
+ */
+import { assertArray, assertEvery, assertFunction, isFunction, isInteger, isPositive, } from '#guards';
+import { normalizeOptionalRest as _normalizeOptionalRest } from '#guards/assert';
 /**
  * A function that does nothing.
  */
@@ -10,6 +18,8 @@ export const noop = () => { };
  */
 export const pass = (value) => value;
 export function createCachedFn(fn, keyFn = pass) {
+    assertFunction(fn, 'fn');
+    assertFunction(keyFn, 'keyFn');
     return (map, ...args) => {
         const key = keyFn(...args);
         if (map.has(key))
@@ -19,4 +29,10 @@ export function createCachedFn(fn, keyFn = pass) {
         return result;
     };
 }
+export function normalizeOptionalRest(predicateSequence, args, restShift = 0) {
+    assertArray(predicateSequence, isFunction);
+    assertArray(args);
+    assertEvery(restShift, 'restShift', isInteger, isPositive);
+    return _normalizeOptionalRest(predicateSequence, args, restShift);
+}
 //# sourceMappingURL=function.js.map

package/dist/guards/assert.d.ts

@@ -0,0 +1,213 @@
+/**
+ * @module
+ * Provides assertion functions for runtime type checking and validation.
+ * @categoryDescription Assertions
+ * Assertion functions for runtime type checking and validation.
+ */
+import type { Primitive } from 'type-fest';
+import type { AnyFunction, NarrowedType, NonNil, Predicate, TypePredicate, UnknownFunction, WithFallback } from '@budsbox/lib-types';
+import type { InvariantFn, InvariantPredicateFn, NormalizedOptionalRest } from './types.js';
+/**
+ * {@link InvariantFn} implementation.
+ *
+ * @inheritDoc {@link InvariantFn}
+ */
+export declare const invariant: InvariantFn;
+/**
+ * {@link InvariantPredicateFn} implementation.
+ *
+ * @inheritDoc {@link InvariantPredicateFn}
+ */
+export declare const invariantPredicate: InvariantPredicateFn;
+/**
+ * Evaluates a given predicate function with the specified value and an optional predicate name.
+ * Narrows the type of the value if the predicate is a type guard.
+ *
+ * @param predicate - A function that takes a value of type `TValue` and returns a boolean.
+ * @param value - The value to be passed to the predicate function.
+ * @param predicateName - An optional name for the predicate, used for identification or debugging purposes.
+ * @returns Returns `true` if the predicate function evaluates the value as valid, otherwise `false`.
+ * @throws {@link !TypeError} in the following cases:
+ * - If the provided `predicate` is not a function.
+ * - If the predicate function does not return a boolean.
+ * @typeParam TValue - The type of the value to be tested by the predicate.
+ * @typeParam TGuardInput - The type of the input to the predicate in case it's a type guard.
+ * @typeParam TNarrowed - The narrowed type of the value if the predicate is a type guard.
+ * @category Other
+ */
+export declare function callPredicate<TNarrowed>(predicate: TypePredicate<unknown, TNarrowed>, value: unknown, predicateName?: string): value is TNarrowed;
+export declare function callPredicate<TValue extends TGuardInput, TGuardInput, TNarrowed extends TGuardInput>(predicate: TypePredicate<TGuardInput, TNarrowed>, value: TValue, predicateName?: string): value is WithFallback<Extract<TValue, TNarrowed>, TValue & TNarrowed>;
+export declare function callPredicate<TValue>(predicate: Predicate<TValue>, value: TValue, predicateName?: string): boolean;
+export declare function normalizeOptionalRest<TPredicateSequence extends ReadonlyArray<Predicate<unknown>>>(predicateSequence: TPredicateSequence, args: readonly unknown[], restShift?: number): NormalizedOptionalRest<TPredicateSequence>;
+/**
+ * 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 declare function assertDef<T>(value: T, name?: string): asserts value is NonNil<T> | (null & T);
+/**
+ * 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 declare function assertNotNil(value: unknown, name?: string): asserts value is NonNil;
+/**
+ * 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 declare function assertString(value: unknown, name?: string): asserts value is string;
+/**
+ * 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 declare function assertNumber(value: unknown, name?: string): asserts value is number;
+/**
+ * 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 declare function assertSymbol(value: unknown, name?: string): asserts value is symbol;
+/**
+ * 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 declare function assertPropKey(value: unknown, name?: string): asserts value is PropertyKey;
+/**
+ * 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 declare function assertBoolean(value: unknown, name?: string): asserts value is boolean;
+/**
+ * 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 declare function assertPrimitive(value: unknown, name?: string): asserts value is Primitive;
+/**
+ * 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 declare function assertObject(value: unknown, name?: string): asserts value is object;
+/**
+ * Asserts that the provided value is an array.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @returns void
+ * @throws {@link !TypeError} If the value is not an array.
+ * @typeParam T - The type of elements in the array.
+ * @category Assertions
+ */
+export declare function assertArray<T>(value: T, name?: string): asserts value is WithFallback<Extract<T, readonly unknown[]>, T & unknown[]>;
+export declare function assertArray<TValue, TGuard extends TypePredicate<WithFallback<TValue extends ReadonlyArray<infer TItem> ? TItem : never>>>(value: TValue, typeGuard: TGuard, name?: string): asserts value is WithFallback<Extract<TValue, Array<NarrowedType<TGuard>>>, TValue & Array<NarrowedType<TGuard>>>;
+export declare function assertArray<TValue>(value: TValue, predicate: Predicate<WithFallback<TValue extends ReadonlyArray<infer TItem> ? TItem : never>>, name?: string): asserts value is WithFallback<Extract<TValue, readonly unknown[]>, TValue & unknown[]>;
+/**
+ * Asserts that the provided value is a function.
+ *
+ * @param value - The value to check.
+ * @param name - The name of the value for the error message.
+ * @returns void
+ * @throws {@link !TypeError} If the value is not a function.
+ * @typeParam T - The type being checked.
+ * @category Assertions
+ */
+export declare function assertFunction<T>(value: T, name?: string): asserts value is WithFallback<Extract<T, AnyFunction>, UnknownFunction & T>;
+export declare function assertFunction<TFn extends AnyFunction = UnknownFunction>(value: unknown, name?: string): asserts value is TFn;
+/**
+ * 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 declare function assertDate(value: unknown, name?: string): asserts value is Date;
+/**
+ * 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 declare function assertRegExp(value: unknown, name?: string): asserts value is RegExp;
+/**
+ * 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 declare function assertError(value: unknown, name?: string): asserts value is Error;
+/**
+ * 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 declare function assertMap(value: unknown, name?: string): asserts value is Map<unknown, unknown>;
+/**
+ * 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 declare function assertSet(value: unknown, name?: string): asserts value is Set<unknown>;
+/**
+ * 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 declare function assertWeakMapLike(value: unknown, name?: string): asserts value is WeakMap<WeakKey, unknown>;
+/**
+ * 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 declare function assertWeakSetLike(value: unknown, name?: string): asserts value is WeakSet<WeakKey>;
+//# sourceMappingURL=assert.d.ts.map