@pivanov/utils 0.0.3 → 1.0.1

package/dist/types/cache/storage.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `JSON.stringify` replacer that converts `BigInt` values to strings.
+ *
+ * @example
+ * ```ts
+ * JSON.stringify({ id: 9007199254740993n }, stringifyBigIntValues);
+ * ```
+ */
+export declare const stringifyBigIntValues: (_key: string, value: unknown) => unknown;
+/**
+ * Stores a JSON-serializable value in the browser Cache API.
+ *
+ * Note: values are serialized via `JSON.stringify`. `Date`, `Map`, `Set`,
+ * `undefined`, and `Symbol` values are lossy. `BigInt` is auto-stringified.
+ */
+export declare const storageSetItem: (cacheName: string, key: string, value: unknown) => Promise<void>;
+/**
+ * Retrieves a value from the Cache API. Returns `null` if not found.
+ */
+export declare const storageGetItem: <T>(cacheName: string, key: string) => Promise<T | null>;
+/**
+ * Stores a value with a TTL (time-to-live in milliseconds). After the TTL
+ * elapses, reads via `storageGetItemWithTTL` will return `null` and delete
+ * the expired entry.
+ *
+ * Wire format is a self-describing envelope: `{ __ttl: true, v, exp }`.
+ * Entries stored this way are only correctly read via the `WithTTL` variants.
+ *
+ * @example
+ * ```ts
+ * await storageSetItemWithTTL('my-cache', 'token', 'abc123', 60_000);
+ * const token = await storageGetItemWithTTL<string>('my-cache', 'token');
+ * ```
+ */
+export declare const storageSetItemWithTTL: (cacheName: string, key: string, value: unknown, ttlMs: number) => Promise<void>;
+/**
+ * Reads a value previously stored with `storageSetItemWithTTL`. Returns
+ * `null` if absent or expired; expired entries are deleted.
+ */
+export declare const storageGetItemWithTTL: <T>(cacheName: string, key: string) => Promise<T | null>;
+/**
+ * Removes a single key. Returns `true` if the key existed and was deleted.
+ */
+export declare const storageRemoveItem: (cacheName: string, key: string) => Promise<boolean>;
+/**
+ * Clears every entry in the named cache.
+ */
+export declare const storageClear: (cacheName: string) => Promise<void>;
+/**
+ * Clears every cache entry whose key matches `str` as prefix or suffix.
+ *
+ * @deprecated Prefer `storageClearByPrefix` / `storageClearBySuffix` for
+ *   readability. This function will remain through v1.x.
+ */
+export declare const storageClearByPrefixOrSuffix: (cacheName: string, str: string, isPrefix?: boolean) => Promise<void>;
+/**
+ * Clears every cache entry whose key starts with `prefix`.
+ */
+export declare const storageClearByPrefix: (cacheName: string, prefix: string) => Promise<void>;
+/**
+ * Clears every cache entry whose key ends with `suffix`.
+ */
+export declare const storageClearBySuffix: (cacheName: string, suffix: string) => Promise<void>;
+/**
+ * Checks whether a key exists in the cache.
+ */
+export declare const storageExists: (cacheName: string, key: string) => Promise<boolean>;
+/**
+ * Returns every key currently stored in the cache.
+ */
+export declare const storageGetAllKeys: (cacheName: string) => Promise<string[]>;
+/**
+ * Calculates the size in bytes of the cache, or of a single entry.
+ */
+export declare const storageCalculateSize: (cacheName: string, cacheKey?: string) => Promise<number>;

package/dist/types/cache/support.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reports whether the Cache Storage API is reachable in the current realm.
+ *
+ * Use it to guard cache access during SSR, in Node, or in any runtime that does
+ * not expose `caches`.
+ *
+ * @example
+ * ```ts
+ * if (isCacheStorageSupported()) {
+ *   await cacheClear('assets-v1');
+ * }
+ * ```
+ */
+export declare const isCacheStorageSupported: () => boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./assertion";
+export * from "./object";
+export * from "./promise";
+export * from "./string";
+export * from "./tools";
+export * from "./types";

package/dist/types/object/index.d.ts

@@ -0,0 +1,118 @@
+import type { TDict } from "../types";
+/**
+ * Creates a new object with the specified keys removed.
+ *
+ * @example
+ * ```ts
+ * omit({ name: 'John', age: 30 }, ['age']); // { name: 'John' }
+ * ```
+ */
+export declare const omit: <T extends TDict, K extends keyof T>(object: T, keys: K[]) => Omit<T, K>;
+/**
+ * Creates a new object with only the specified keys.
+ *
+ * @example
+ * ```ts
+ * pick({ name: 'John', age: 30 }, ['name']); // { name: 'John' }
+ * ```
+ */
+export declare const pick: <T extends TDict, K extends keyof T>(object: T, keys: K[]) => Pick<T, K>;
+/**
+ * Returns a new object keeping entries where the predicate returns true.
+ *
+ * @example
+ * ```ts
+ * pickBy({ a: 1, b: 2, c: 3 }, (v) => v > 1); // { b: 2, c: 3 }
+ * ```
+ */
+export declare const pickBy: <T extends TDict>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean) => Partial<T>;
+/**
+ * Returns a new object dropping entries where the predicate returns true.
+ *
+ * @example
+ * ```ts
+ * omitBy({ a: 1, b: null, c: 3 }, (v) => v === null); // { a: 1, c: 3 }
+ * ```
+ */
+export declare const omitBy: <T extends TDict>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean) => Partial<T>;
+/**
+ * Returns a new object with values mapped via the transform function.
+ *
+ * @example
+ * ```ts
+ * mapValues({ a: 1, b: 2 }, (v) => v * 2); // { a: 2, b: 4 }
+ * ```
+ */
+export declare const mapValues: <T extends TDict, R>(object: T, mapper: (value: T[keyof T], key: keyof T) => R) => Record<keyof T, R>;
+/**
+ * Returns a new object with keys mapped via the transform function.
+ *
+ * @example
+ * ```ts
+ * mapKeys({ a: 1, b: 2 }, (_, k) => k.toUpperCase()); // { A: 1, B: 2 }
+ * ```
+ */
+export declare const mapKeys: <T extends TDict>(object: T, mapper: (value: T[keyof T], key: keyof T) => string) => Record<string, T[keyof T]>;
+/**
+ * Groups items by the key returned by the iteratee.
+ *
+ * @example
+ * ```ts
+ * groupBy(['apple', 'banana', 'cherry'], (s) => s[0]);
+ * // { a: ['apple'], b: ['banana'], c: ['cherry'] }
+ * ```
+ */
+export declare const groupBy: <T, K extends string | number>(items: readonly T[], iteratee: (item: T, index: number) => K) => Record<K, T[]>;
+/**
+ * Swaps keys with values. Values must be valid object keys.
+ *
+ * @example
+ * ```ts
+ * invert({ a: 'x', b: 'y' }); // { x: 'a', y: 'b' }
+ * ```
+ */
+export declare const invert: <K extends string, V extends string | number | symbol>(object: Record<K, V>) => Record<V, K>;
+/**
+ * Typed `Object.hasOwn`. Narrows the key into the object's own keys.
+ *
+ * @example
+ * ```ts
+ * if (hasOwn(obj, 'name')) obj.name; // narrowed
+ * ```
+ */
+export declare const hasOwn: <T extends object, K extends PropertyKey>(object: T, key: K) => object is T & Record<K, unknown>;
+/**
+ * Typed `Object.keys`. Returns `(keyof T)[]` instead of `string[]`.
+ *
+ * Note: like `Object.keys`, the runtime keys are just the own enumerable
+ * string keys, so this typing can be unsound if the object has extra runtime
+ * properties not in its compile-time type.
+ */
+export declare const keysOf: <T extends object>(object: T) => (keyof T)[];
+/**
+ * Typed `Object.entries`. Returns `[keyof T, T[keyof T]][]`.
+ */
+export declare const entriesOf: <T extends object>(object: T) => [keyof T, T[keyof T]][];
+/**
+ * Typed `Object.fromEntries` for tuple arrays with literal key types.
+ */
+export declare const fromEntries: <K extends PropertyKey, V>(entries: readonly (readonly [K, V])[]) => Record<K, V>;
+/**
+ * Shallow-merges multiple objects into a new object. Does not mutate inputs.
+ *
+ * @example
+ * ```ts
+ * merge({ a: 1 }, { b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * ```
+ */
+export declare const merge: <T extends object>(target: T, ...sources: Partial<T>[]) => T;
+/**
+ * Recursively merges multiple objects into a new object. Does not mutate
+ * inputs. Nested plain objects are merged; arrays and other values replace.
+ *
+ * @example
+ * ```ts
+ * deepMerge({ a: { b: 1 } }, { a: { c: 2 } }); // { a: { b: 1, c: 2 } }
+ * ```
+ */
+export declare const deepMerge: <T extends object>(target: T, ...sources: Partial<T>[]) => T;

package/dist/types/promise/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Asynchronously waits for the specified number of milliseconds.
+ *
+ * Accepts an optional `AbortSignal` - when the signal aborts, the returned
+ * promise rejects with the signal's `reason` and the pending timer is cleared.
+ *
+ * @example
+ * ```ts
+ * await sleep(1000);
+ *
+ * const ctrl = new AbortController();
+ * setTimeout(() => ctrl.abort(), 50);
+ * await sleep(1000, ctrl.signal); // rejects after 50ms
+ * ```
+ */
+export declare const sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
+/**
+ * Races a promise against a timeout. Rejects with the given reason (or a
+ * default `TimeoutError`) if the promise doesn't settle in time.
+ *
+ * @example
+ * ```ts
+ * await timeout(fetch('/slow'), 3000);
+ * await timeout(work(), 5000, new Error('took too long'));
+ * ```
+ */
+export declare const timeout: <T>(promise: Promise<T>, ms: number, reason?: unknown) => Promise<T>;
+interface IRetryOptions {
+    /** Maximum number of attempts (including the first). Default: 3. */
+    attempts?: number;
+    /** Milliseconds to wait between attempts. Can be a fixed number or a function
+     *  `(attempt) => ms` where attempt is 1-indexed. Default: 0 (no delay). */
+    backoff?: number | ((attempt: number) => number);
+    /** Cancels in-flight retries. */
+    signal?: AbortSignal;
+    /** Optional predicate - return false to abort retrying for a given error. */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+}
+/**
+ * Runs `fn` and retries on rejection up to `attempts` times with optional
+ * backoff. Re-throws the last error if all attempts fail.
+ *
+ * @example
+ * ```ts
+ * await retry(() => fetch('/api'), { attempts: 3, backoff: 500 });
+ * await retry(work, {
+ *   attempts: 5,
+ *   backoff: (n) => 100 * 2 ** n, // exponential
+ * });
+ * ```
+ */
+export declare const retry: <T>(fn: (attempt: number) => Promise<T> | T, options?: IRetryOptions) => Promise<T>;
+interface IDeferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+}
+/**
+ * Creates an externally-resolvable promise. Equivalent to `Promise.withResolvers`
+ * (ES2024) but works in older runtimes.
+ *
+ * @example
+ * ```ts
+ * const { promise, resolve } = defer<string>();
+ * setTimeout(() => resolve('hi'), 100);
+ * const value = await promise;
+ * ```
+ */
+export declare const defer: <T>() => IDeferred<T>;
+/**
+ * Maps `items` through `fn` with bounded concurrency. Results preserve input
+ * order. If any task rejects, the returned promise rejects as soon as that
+ * error surfaces (but already-started tasks continue running).
+ *
+ * @example
+ * ```ts
+ * const bodies = await parallelLimit(urls, 4, (url) => fetch(url));
+ * ```
+ */
+export declare const parallelLimit: <T, R>(items: readonly T[], concurrency: number, fn: (item: T, index: number) => Promise<R> | R) => Promise<R[]>;
+export {};

package/dist/types/string/index.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Converts a string to camelCase.
+ *
+ * @example
+ * ```ts
+ * camelCase('foo-bar');  // 'fooBar'
+ * camelCase('FOO_BAR');  // 'fooBar'
+ * ```
+ */
+export declare const camelCase: (str: string) => string;
+/**
+ * Converts a string to PascalCase.
+ *
+ * @example
+ * ```ts
+ * pascalCase('foo-bar');      // 'FooBar'
+ * pascalCase('foo123bar');    // 'Foo123Bar'
+ * ```
+ */
+export declare const pascalCase: (str: string) => string;
+/**
+ * Capitalizes the first character of a string (runtime).
+ * For TypeScript literal-type preservation, use `capitalize` instead.
+ */
+export declare const capitalizeFirstLetter: (string: string) => string;
+/**
+ * Converts a string to kebab-case.
+ *
+ * @example
+ * ```ts
+ * kebabCase('fooBar');         // 'foo-bar'
+ * kebabCase('XMLHttpRequest'); // 'xml-http-request'
+ * ```
+ */
+export declare const kebabCase: (str: string) => string;
+/**
+ * Converts a string to snake_case.
+ *
+ * @example
+ * ```ts
+ * snakeCase('fooBar');         // 'foo_bar'
+ * snakeCase('XMLHttpRequest'); // 'xml_http_request'
+ * ```
+ */
+export declare const snakeCase: (str: string) => string;
+/**
+ * Converts a string to Title Case - each word capitalized, separators
+ * normalized to single spaces.
+ *
+ * @example
+ * ```ts
+ * titleCase('hello world');       // 'Hello World'
+ * titleCase('foo-bar_baz');       // 'Foo Bar Baz'
+ * ```
+ */
+export declare const titleCase: (str: string) => string;
+/**
+ * Converts a string into a URL-friendly slug. More aggressive than
+ * `kebabCase` - strips all non-ASCII-word characters.
+ *
+ * @example
+ * ```ts
+ * slugify('Hello World!');     // 'hello-world'
+ * slugify('Über Café');         // 'uber-cafe'
+ * ```
+ */
+export declare const slugify: (str: string) => string;
+/**
+ * Capitalizes the first character; preserves TypeScript literal types.
+ */
+export declare const capitalize: <S extends string>(str: S) => Capitalize<S>;
+/**
+ * Lower-cases the first character; preserves TypeScript literal types.
+ */
+export declare const uncapitalize: <S extends string>(str: S) => Uncapitalize<S>;
+/**
+ * Truncates a string to `maxLength` characters, appending an ellipsis
+ * (default `…`) if truncation happened. The ellipsis is included in
+ * the final length.
+ *
+ * @example
+ * ```ts
+ * truncate('Hello, world!', 8);        // 'Hello, …'
+ * truncate('Hello, world!', 8, '...'); // 'Hello...'
+ * truncate('Short', 20);               // 'Short'
+ * ```
+ */
+export declare const truncate: (str: string, maxLength: number, ellipsis?: string) => string;
+/**
+ * Escapes HTML special characters for safe interpolation into markup.
+ *
+ * @example
+ * ```ts
+ * escapeHtml('<script>alert(1)</script>');
+ * // '&lt;script&gt;alert(1)&lt;/script&gt;'
+ * ```
+ */
+export declare const escapeHtml: (str: string) => string;
+/**
+ * Escapes characters that have special meaning in a regular expression so the
+ * string can be safely embedded as a literal match.
+ *
+ * @example
+ * ```ts
+ * new RegExp(escapeRegExp('a.b*c')); // matches the literal "a.b*c"
+ * ```
+ */
+export declare const escapeRegExp: (str: string) => string;
+/**
+ * Splits a string into words by whitespace, dashes, and underscores.
+ * Preserves case; filters out empty segments.
+ *
+ * @example
+ * ```ts
+ * words('hello_world-foo bar'); // ['hello', 'world', 'foo', 'bar']
+ * ```
+ */
+export declare const words: (str: string) => string[];
+/**
+ * Splits a string by line breaks (`\r\n`, `\n`, or `\r`).
+ *
+ * @example
+ * ```ts
+ * lines('a\nb\r\nc'); // ['a', 'b', 'c']
+ * ```
+ */
+export declare const lines: (str: string) => string[];

package/dist/types/tools/deepClone.d.ts

@@ -0,0 +1,2 @@
+export type TCloneable = object | number | string | boolean | symbol | bigint | null | undefined;
+export declare const deepClone: <T extends TCloneable>(obj: T) => T;

package/dist/types/tools/dom.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Returns true when running in a browser-like environment.
+ *
+ * Checks for both `window` and `document` so service-worker and
+ * partially-mocked contexts are correctly reported as non-browser.
+ *
+ * @example
+ * ```ts
+ * if (isBrowser()) window.addEventListener('resize', onResize);
+ * ```
+ */
+export declare const isBrowser: () => boolean;
+/**
+ * Sets CSS custom properties on an element. Safely no-ops when element is null.
+ *
+ * @example
+ * ```ts
+ * setStyleProperties(el, { '--primary': '#3b82f6', '--gap': '1rem' });
+ * ```
+ */
+export declare const setStyleProperties: (el: HTMLElement | null, cssVars: Record<string, string>) => void;
+interface CheckVisibilityOptions {
+    /** Require the element to intersect the viewport. Default: true. */
+    checkViewport?: boolean;
+    /** Require computed `display` to be non-"none". Default: true. */
+    checkDisplay?: boolean;
+    /** Require computed `visibility` to be "visible". Default: true. */
+    checkVisibility?: boolean;
+    /** Require computed `opacity` to be > 0. Default: true. */
+    checkOpacity?: boolean;
+}
+/**
+ * Checks whether an element is visible to the user.
+ *
+ * By default verifies: attached to DOM, `display` not `none`,
+ * `visibility` is `visible`, `opacity > 0`, and intersects the viewport
+ * on both axes. Each check can be toggled via options.
+ *
+ * @example
+ * ```ts
+ * if (checkVisibility(el)) el.classList.add('seen');
+ * checkVisibility(el, { checkViewport: false }); // visible per CSS only
+ * ```
+ */
+export declare const checkVisibility: (element: HTMLElement, options?: CheckVisibilityOptions) => boolean;
+/**
+ * @internal Resets the cached canvas - for tests only.
+ */
+export declare const __resetTextMeasurementCache: () => void;
+interface IViewportOptions {
+    /** Require vertical intersection. Default: true. */
+    vertical?: boolean;
+    /** Require horizontal intersection. Default: true. */
+    horizontal?: boolean;
+}
+/**
+ * Returns true when the element's bounding rect intersects the viewport.
+ * Pure geometry - ignores CSS visibility. Use `checkVisibility` for a full
+ * visibility check.
+ *
+ * Zero-sized rects (no layout yet) return true - we can't clip against
+ * nothing, and failing them would produce false negatives in test environments.
+ *
+ * @example
+ * ```ts
+ * if (isInViewport(el)) track();
+ * isInViewport(el, { horizontal: false }); // vertical only
+ * ```
+ */
+export declare const isInViewport: (element: HTMLElement, options?: IViewportOptions) => boolean;
+/**
+ * Measures the rendered width of text in pixels using a cached off-screen
+ * canvas. Returns `0` when 2D context is unavailable.
+ *
+ * @example
+ * ```ts
+ * calculateRenderedTextWidth('Hello World', 16);
+ * calculateRenderedTextWidth('Hi', 14, true, 'Arial');
+ * ```
+ */
+export declare const calculateRenderedTextWidth: (text: string, fontSize: number, isUppercase?: boolean, fontFamily?: string) => number;
+export {};

package/dist/types/tools/eventBus/eventBus.d.ts

@@ -0,0 +1,37 @@
+import type { IEventBus, IEventBusSubscribeOptions, TEventBusListener, TEventBusUnsubscribe } from "./types";
+/**
+ * Dispatches a message to every subscriber on `topic`.
+ *
+ * @example
+ * ```ts
+ * busDispatch('user-updated', { id: 1, name: 'John' });
+ * ```
+ */
+export declare const busDispatch: <T extends IEventBus>(topic: T["topic"], message: T["message"]) => void;
+/**
+ * Subscribes to messages on a specific topic. Returns an unsubscribe function.
+ *
+ * Pass `options.onError` to handle listener exceptions (default: `console.error`).
+ *
+ * @example
+ * ```ts
+ * const unsubscribe = busSubscribe('user-updated', (msg) => {
+ *   console.log(msg);
+ * });
+ * unsubscribe();
+ *
+ * // Custom error handler
+ * busSubscribe('x', handler, { onError: (e) => reportBug(e) });
+ * ```
+ */
+export declare const busSubscribe: <T extends IEventBus>(topic: T["topic"], listener: TEventBusListener<T["message"]>, options?: IEventBusSubscribeOptions) => TEventBusUnsubscribe;
+/**
+ * Subscribes to a topic and automatically unsubscribes after the first
+ * matching dispatch.
+ *
+ * @example
+ * ```ts
+ * busOnce('ready', () => startApp());
+ * ```
+ */
+export declare const busOnce: <T extends IEventBus>(topic: T["topic"], listener: TEventBusListener<T["message"]>, options?: IEventBusSubscribeOptions) => TEventBusUnsubscribe;

package/dist/types/tools/eventBus/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./eventBus";
+export type { IEventBus, IEventBusSubscribeOptions, TEventBusListener, TEventBusUnsubscribe, TEventMessage, TEventTopic, } from "./types";
+export * from "./useEventBus";

package/dist/types/tools/eventBus/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Generic event-bus shape. Extend this interface for typed dispatch/subscribe.
+ *
+ * @example
+ * ```ts
+ * interface UserLoggedIn extends IEventBus<{ id: number; name: string }> {
+ *   topic: 'user:logged-in';
+ * }
+ * busDispatch<UserLoggedIn>('user:logged-in', { id: 1, name: 'John' });
+ * ```
+ */
+export interface IEventBus<T = unknown> {
+    topic: string;
+    message: T;
+}
+/**
+ * Listener callback shape.
+ */
+export type TEventBusListener<T = unknown> = (message: T) => void;
+/**
+ * Function returned by `busSubscribe` that removes the subscription.
+ */
+export type TEventBusUnsubscribe = () => void;
+/**
+ * Optional behavior for a subscription.
+ */
+export interface IEventBusSubscribeOptions {
+    /** Called with the error when the listener throws. Defaults to `console.error`. */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Type helper: given an event map, extract the set of valid topic names.
+ *
+ * @example
+ * ```ts
+ * type Events = {
+ *   'user:login': { id: number };
+ *   'user:logout': void;
+ * };
+ * type Topic = TEventTopic<Events>; // 'user:login' | 'user:logout'
+ * ```
+ */
+export type TEventTopic<Map> = keyof Map & string;
+/**
+ * Type helper: given an event map and a topic, extract the message payload.
+ */
+export type TEventMessage<Map, Topic extends TEventTopic<Map>> = Map[Topic];

package/dist/types/tools/eventBus/useEventBus.d.ts

@@ -0,0 +1,3 @@
+import { type DependencyList } from "react";
+import type { IEventBus, TEventBusListener } from "./types";
+export declare const useEventBus: <T extends IEventBus>(topic: T["topic"], listener: TEventBusListener<T["message"]>, deps?: DependencyList) => void;

package/dist/types/tools/index.d.ts

@@ -0,0 +1,5 @@
+export * from "../cache";
+export * from "./deepClone";
+export * from "./dom";
+export * from "./eventBus";
+export * from "./isEqual";

package/dist/types/tools/isEqual.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Deeply compares two values for structural equality.
+ *
+ * Supports: primitives (with NaN-equals-NaN), Arrays, Sets, Maps, Dates,
+ * RegExp (source + flags), Errors (name + message), TypedArrays,
+ * ArrayBuffer/DataView (byte-wise), and plain objects. Handles circular
+ * references via cycle tracking.
+ *
+ * Sets with non-primitive members use order-independent deep comparison
+ * (O(n²) worst case).
+ *
+ * @example
+ * ```ts
+ * isEqual({ a: 1, b: 2 }, { b: 2, a: 1 }); // true
+ * isEqual([1, 2, 3], [1, 2, 3]); // true
+ * isEqual(new Set([{ id: 1 }]), new Set([{ id: 1 }])); // true
+ * isEqual(/foo/gi, /foo/gi); // true
+ * isEqual(new Uint8Array([1, 2]), new Uint8Array([1, 2])); // true
+ * ```
+ */
+export declare const isEqual: <T, K>(obj: T | T[], objToCompare: K | K[]) => boolean;