@superutils/core 1.2.0 → 1.2.1

package/dist/index.d.ts

@@ -4,14 +4,16 @@
 type AsyncFn<TOut = unknown, TArgs extends unknown[] = []> = (...args: TArgs) => Promise<Awaited<TOut>>;
 /**
  * Create a tuple of specific type with given length
- * ---
- * @example Create a new tuple
+ *
+ * @example
+ * #### Create a new tuple
  * ```typescript
  * type CreatedTuple =  CreateTuple<number, 3>
  * // Result: [number, number, number]
  * ```
  *
- * @example Create a new tuple by extending an existing tuple
+ * @example
+ * #### Create a new tuple by extending an existing tuple
  * ```typescript
  * type ExtendedTuple = CreateTuple<string, 6, CreatedTuple>
  * // Result: [number, number, number, string, string, string]
@@ -30,8 +32,8 @@ type CurriedArgs<TArgs extends unknown[], TArgsIsFinite extends boolean, TFunc e
 ], TArity>;
 /**
  * Drop the first item from an array/tuple and keep the rest
- * ---
- * @example usage
+ *
+ * @example
  * ```typescript
  * type MyTuple = [first: string, second: number, third: boolean]
  * type MyTupleWOFirst = DropFirst<MyTuple> // result: [second: number, third: boolean]
@@ -40,8 +42,8 @@ type CurriedArgs<TArgs extends unknown[], TArgsIsFinite extends boolean, TFunc e
 type DropFirst<T extends unknown[]> = T extends [unknown, ...infer Rest] ? Rest : [];
 /**
  * Drop first N items from an array/tuple and keep the rest
- * ---
- * @example usage
+ *
+ * @example
  * ```typescript
  * type MyTuple = [first: string, second: number, third: boolean]
  * type MyTupleWO2 = DropFirstN<MyTuple, 2> // result: [third: boolean]
@@ -50,8 +52,8 @@ type DropFirst<T extends unknown[]> = T extends [unknown, ...infer Rest] ? Rest
 type DropFirstN<T extends unknown[], N extends number, Dropped extends unknown[] = []> = TupleMaxLength<Dropped> extends N ? T : T extends [infer First, ...infer Rest] ? DropFirstN<Rest, N, [...Dropped, First]> : never;
 /**
  * Drop the last item from an array/tuple and keep the rest
- * ---
- * @example usage
+ *
+ * @example
  * ```typescript
  * type MyTuple = [first: string, second: number, third: boolean]
  * type MyTupleWOLast = DropLast<MyTuple> // result: [first: string, second: number]
@@ -69,8 +71,8 @@ type IsFiniteTuple<T extends unknown[]> = number extends T['length'] ? false : t
 type IsOptional<T, K extends keyof T> = {} extends Pick<T, K> ? true : false;
 /**
  * Keep the first item from an array/tuple and drop the rest
- * ---
- * @example usage
+ *
+ * @example
  * ```typescript
  * type MyTuple = [first: string, second: number, third: boolean]
  * type MyTupleWFirst = KeepFirst<MyTuple> // result: [first: string]
@@ -82,8 +84,8 @@ type KeepFirst<T extends unknown[]> = T extends readonly [
 ] ? [First] : never;
 /**
  * Keep first N items from an array/tuple and drop the rest
- * ---
- * @example usage
+ *
+ * @example
  * ```typescript
  * type MyTuple = [first: string, second: number, third: boolean]
  * type MyTupleWith1st2 = KeepFirstN<MyTuple, 2> // result: [first: string, second: number]
@@ -98,7 +100,7 @@ type KeepFirstN<T extends readonly unknown[], N extends number = 1> = TupleMaxLe
  * Defaults to `false`
  * @template TAlt   (optional) Defaults to `undefined`
  *
- * @example usage
+ * @example
  * ```typescript
  * import { KeepOptionals } from '@superutils/core
  * type MyTuple = [first: string, second?: number, third?: boolean]
@@ -126,8 +128,8 @@ type MakeOptional<Tuple extends unknown[], IndexStart extends number, IndexEnd e
 ] ? [...Left, ...Partial<Slice<Tuple, IndexStart>>, ...Right] : never;
 /**
  * Create a new slices tuple from an existing tuple
- * ---
- * @example usage
+ *
+ * @example
  * ```typescript
  * type MyTuple = [a: string, b: boolean, c: number, d: Record<string, unknown>]
  * type FirstHalf = Slice<MyTuple, 0, 2>
@@ -145,8 +147,7 @@ type TimeoutId = Parameters<typeof clearTimeout>[0];
  *
  * This is particularly useful when a tuple (or function paramenters) contains optional members.
  *
- * ---
- * @example usage
+ * @example
  * ```typescript
  * type MyTuple = [string, number?, boolean?]
  * type Lengths = MyTuple['length'] // 1 | 2 | 3 // union because of optional parameters
@@ -157,8 +158,7 @@ type TupleMaxLength<T extends readonly unknown[]> = Required<T>['length'];
 /**
  * Add alt type to all members of a tuple.
  *
- * ---
- * @example usage
+ * @example
  * ```typescript
  * type MyTuple = [first: boolean, second: string]
  * type MyTupleWithUndefined = TupleWithAlt<MyTuple>
@@ -173,9 +173,7 @@ type TupleWithAlt<Tuple extends unknown[], TAlt = undefined> = {
 /**
  * Accept value or a function that returns the value
  *
- * Examples:
- * ---
- * @example usage
+ * @example
  * ```typescript
  * import { isFn, ValueOrFunc } from '@superutils/core'
  * const print = (value: ValueOrFunc<string>) => isFn(value)
@@ -197,21 +195,20 @@ type ValueOrPromise<T> = T | Promise<T>;
  * called with one or more or all arguments at a time. Once all arguments have been
  * supplied, the original function is executed.
  *
- * ---
- *
- * PS:
+ * Note:
  * ---
  * To get around Typescript's limitations, all optional parameters to will be
  * turned required and unioned with `undefined`.
  *
- * ---
- *
  * @param func The function to curry.
  * @returns A new, curried function that is fully type-safe.
 
  *
- * @example Convert any function into a curried function
+ * @example
+ * #### Convert any function into a curried function
  * ```typescript
+ * import { curry } from '@superutils/core'
+ *
  * const func = (
  *     first: string,
  *     second: number,
@@ -231,24 +228,51 @@ type ValueOrPromise<T> = T | Promise<T>;
  * const fnWith3 = fnWith2(false)
  * // All args are now provided, the original function is called and result is returned.
  * const result = fnWith3('last')
+ * console.log({ result })
+ * // Result: 'first-2-false-last'
  * ```
  *
- * @example Flexible curried function arguments
+ * @example
+ * #### Flexible curried function arguments
  * ```typescript
+ * import { curry } from '@superutils/core'
+ *
+ * const func = (
+ *     first: string,
+ *     second: number,
+ *     third?: boolean,
+ *     fourth?: string
+ * ) => `${first}-${second}-${third}-${fourth}`
+ * const curriedFunc = curry(func)
+ *
  * // Provide as many arguments as you wish. Upto the limit of the original function.
  * // Returns a function expecting only the remaining argument(s)
  * const fnWith3 = curriedFunc('first', 2, false)
  * // All args provided, returns the result
  * const result = fnWith3('last')
+ * console.log({ result })
+ * // Result: 'first-2-false-last'
  * ```
  *
- * @example Early invocation using "arity".
+ * @example
+ * #### Early invocation using "arity".
  * Useful when a function has
  *  - non-finite arguments (eg: number[])
  *  - optional arguments and you do not want to avoid one or more optional arguments
+ *
  * ```typescript
+ * import { curry } from '@superutils/core'
+ *
+ * const func = (
+ *     first: string,
+ *     second: number,
+ *     third?: boolean,
+ *     fourth?: string
+ * ) => `${first}-${second}-${third}-${fourth}`
  * const curriedWArity3 = curry(func, 3)
  * const result = curriedWArity3('first', 2, false)
+ * console.log({ result })
+ * // Result: 'first-2-false-undefined'
  * ```
  */
 declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boolean = IsFiniteTuple<TArgs>, TArity extends TArgs['length'] = TArgsIsFinite extends true ? TupleMaxLength<TArgs> : number>(func: (...args: TArgs) => TData, ...[arity]: TArgsIsFinite extends true ? [arity?: TArity] : [
@@ -270,17 +294,16 @@ declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boo
  * function can still be wrapped inside a secondary `fallbackIfFails`. See the "Fallback chaining" example below.
  * - If `target` a promise or async function, `fallback` can be either be  a value, a promise or an async function.
  *
- * @returns if func is a promise the return a promise
+ * @returns A `Promise` is returned if the `target` is a `Promise` or returns one.
+ * Otherwise, the direct value is returned.
  *
- * Examples:
- * ---
- * @example Async functions
- * Working with async functions or functions that returns a promise
+ * @example
+ * #### Async functions: working with async functions or functions that returns a promise
  *
  * ```typescript
  * import { fallbackIfFails } from '@superutils/core'
  *
- * const args = ['some value', true] as const
+ * const args = ['some value', true]
  * const ensureValue = async (value: string, criteria?: boolean) => {
  *     if (criteria !== false && !value.trim()) throw new Error('No value. Should use fallback value')
  *     return value
@@ -288,18 +311,19 @@ declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boo
  * // This makes sure there's always a value without having to manually write try-catch block.
  * const value = await fallbackIfFails(
  *     ensureValue,
- *     () => args,
+ *     () => args as Parameters<typeof ensureValue>,
  *     async () => 'fallback value'
  * )
+ * console.log({ value }) // 'some value'
  * ```
  *
- * @example Non-async functions
- * Working synchronous function that returns value synchronously
+ * @example
+ * #### Non-async functions: working synchronous function that returns value synchronously
  *
  * ```typescript
  * import { fallbackIfFails } from '@superutils/core'
  *
- * const args = ['some value', true] as const
+ * const args = ['some value', true]
  * const ensureValue = (value: string, criteria?: boolean) => {
  *     if (criteria !== false && !value.trim()) throw new Error('No value. Should use fallback value')
  *     return value
@@ -307,13 +331,14 @@ declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boo
  * // this makes sure there's always a value without having to manually write try-catch block.
  * const value = fallbackIfFails(
  *     ensureValue,
- *     () => args,
+ *     () => args as Parameters<typeof ensureValue>,
  *     () => 'fallback value'
  * )
+ * console.log({ value }) // 'some value'
  * ```
  *
- * @example Hybrid functions
- * Working with function that returns value sync/async circumstantially
+ * @example
+ * #### Hybrid functions: working with function that returns value sync/async circumstantially
  *
  * ```typescript
  * import { fallbackIfFails } from '@superutils/core'
@@ -328,14 +353,18 @@ declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boo
  *         })
  * }
  * // First call: no cache, will execute fetch and return a promise
- * const first = await fallbackIfFails(getData, [false], {})
+ * const first = await fallbackIfFails(getData, [false], { fallback: true })
+ * console.log({ first }) // { fallback: true }
+ *
  * // Second call: cache available and will return data synchronously
- * const second = fallbackIfFails(getData, [true], {})
+ * const second = fallbackIfFails(getData, [true], { fallback: true })
+ * console.log({ second }) // { fallback: true }
  * ```
  *
- * @example Fallback-chaining: gracefully handle the fallback function
+ * @example
+ * #### Fallback-chaining: gracefully handle the fallback function
  *
- * ```typescript
+ * ```javascript
  * import { fallbackIfFails } from '@superutils/core'
  *
  * const target = () => {
@@ -348,1087 +377,1300 @@ declare function curry<TData, TArgs extends unknown[], TArgsIsFinite extends boo
  *     target,
  *     [],
  * 	   // this function will only be invoked when
- *     () => fallbackIfFails(fallback, [], undefined)
+ *     () => fallbackIfFails(fallback, [], 'fallback')
  * )
  *
- * console.log({ value }) // undefined
+ * console.log({ value }) // 'fallback'
  * ```
  */
 declare const fallbackIfFails: <T, TArgs extends unknown[] = unknown[], TFB = T, TFBVal = TFB extends (...args: unknown[]) => infer V ? V : TFB, Result = (T extends Promise<unknown> ? true : never) extends never ? T | TFBVal : Promise<Awaited<T | TFBVal>>>(target: T | ((...args: TArgs) => T), args: TArgs | (() => TArgs), fallback: IfPromiseAddValue<TFB> | ((reason: unknown) => IfPromiseAddValue<TFB>)) => Result;
 
-/** Check if value is an array */
-declare const isArr: <Item = unknown>(x: unknown) => x is Item[];
-/**
- * Check if value is an array of objects
- */
-declare const isArrObj: <K extends PropertyKey, V, T extends Record<K, V>[]>(x: unknown, strict?: boolean) => x is T[];
-/** Check if argument is a 2-dimentional array */
-declare const isArr2D: <Item = unknown>(x: unknown) => x is Item[][];
-/** Check if value is convertible to an array by using `Array.from(x)` */
-declare const isArrLike: (x: any) => x is typeof x extends (infer Value)[] ? Value[] : typeof x extends Set<infer Value> ? Set<Value> : typeof x extends Map<infer Key, infer Value> ? Map<Key, Value> : never;
-/**
- * Check if value is convertible to an array by using `Array.from(x)` even if it comes from a different realm
- * (eg: iframe, iframes, worker contexts, node vm contexts, browser extensions).
- *
- * Caution: much slower than {@link isArrLike} due to use of `Object.prototype.toString.call()`
- */
-declare const isArrLikeSafe: <T = unknown, MapKey = unknown>(x: unknown) => x is Set<T> | Map<MapKey, T> | T[];
-/** Check if all values in the array are unique */
-declare const isArrUnique: <T = unknown>(arr: T[]) => boolean;
-/** Check if value is instance of Uint8Array */
-declare const isUint8Arr: (arr: unknown) => arr is Uint8Array<ArrayBufferLike>;
-
-/** Check if value is instance of Date */
-declare const isDate: (x: unknown) => x is Date;
-/**
- * Check if a value is a valid date.
- *
- * @param   date The value to check. Can be a Date object or a string.
- *
- * @returns `true` if the value is a valid date, `false` otherwise.
- */
-declare const isDateValid: (date: unknown) => boolean;
+/** Configuration for finding {@link IterableList} items */
+type FindOptions<K, V, IncludeKey extends boolean = false> = Omit<SearchOptions<K, V>, 'limit' | 'asMap'> & {
+    /**
+     * Whether to include the key in the return type.
+     *
+     * If `true`, return type is `[K, V]` else `V`
+     *
+     * Default: `false`
+     */
+    includeKey?: IncludeKey;
+};
+/** A general type to capture all iterables like Array, Map, Set.... */
+type IterableList<K = unknown, V = unknown> = {
+    entries: () => IterableIterator<[K, V]>;
+    hasOwnProperty: (name: string) => boolean;
+    keys: () => IterableIterator<K>;
+    values: () => IterableIterator<V>;
+} & ({
+    clear: () => void;
+    size: number;
+} | {
+    length: number;
+});
+/** Configuration for sorting iterables */
+type SortOptions = {
+    /** Whether to treat the value as string. Default: `true` */
+    asString?: boolean;
+    /** case-insensitive sort for strings. Default: `true` */
+    ignoreCase?: boolean;
+    /**
+     * Whether to create a new instance of preserve original reference
+     *
+     * Default: `true` for Array, `false` for Map.
+     */
+    newInstance?: boolean;
+    /** Reverse sorted result */
+    reverse?: boolean;
+    /**
+     * Whether to place undefined/null values at the beginning of the sorted array.
+     *
+     * Default: `false`
+     */
+    undefinedFirst?: boolean;
+};
+/** Search criteria for searcheing iterables */
+type SearchOptions<K, V, MatchExact extends boolean = false, AsMap extends boolean = false> = {
+    /** Whethere to return the result as a map (`true`) or array (`false`). Default: `true` */
+    asMap?: AsMap;
+    /** case-insensitive search for strings. Default: `false` */
+    ignoreCase?: boolean;
+    /** limit number of results. Default: `Infinity` */
+    limit?: number;
+    /** partial match for values. Default: `false` */
+    matchExact?: MatchExact;
+    /** match all supplied key-value pairs. Default: `false` */
+    matchAll?: boolean;
+    /** key-value pairs */
+    query: Record<PropertyKey, unknown> | RegExp | string;
+    /** If `true`, the results are sorted by relevance (match index). Default: `false` */
+    ranked?: boolean;
+    /** Map to store results in. Default: `new Map()` */
+    result?: Map<K, V>;
+    /**
+     * Boolean or Callback to prepare item or individual property for search by converting to string.
+     *
+     * - `true`: value will be stringified
+     * - `false`: value will not be stringified when `matchExact = true`
+     * - `function`: transformed value will be used to search
+     *
+     * Returning "empty" (`undefined | null | [] | '' | ...`) value will ignore the item/property.
+     *
+     * Default: `true`
+     */
+    transform?: boolean | ((
+    /** List item */
+    item: V, 
+    /** Item property value or `undefined` for global search across all properties. */
+    value?: V[keyof V], 
+    /** Item property key provided by query or `undefined` for global search across all properties. */
+    key?: keyof V) => MatchExact extends true ? unknown : string | undefined);
+};
 
 /**
- * Check if variable contains empty, null-ish value.
+ * Filter {@link IterableList} (Array, Map, Set) items.
  *
- * Depending on the type certain criteria applies:
- * - `null` | `undefined`: always empty
- * - `String`: empty text or only white-spaces
- * - `Number`: non-finite or NaN
- * - `Array` | `Uint8Array` | `Map` | `Set` | `Object`: contains zero items/properties
- * - `Boolean` | `Function` | `Symbol` | `BigInt`: never empty
+ * @param data
+ * @param predicate callback function to filter values
+ * Parameters:
+ * 1. `item`: current item
+ * 2. `key`: index/key
+ * 3. `data`: value provided in the first argument (`data`)
+ * @param limit	(optional) limit number of results
+ * @param asArray
  *
- * @param x The value to check for emptiness.
- * @param nonNumerable (optional) when `true`, considers non-enumerable properties
- * while checking objects for emptiness. Default: `false`
- * @param fallback (optional) value to return when type is unrecognized.
- * Default: `false`
+ * @returns new Map with filtered items
  *
- * @example Check strings
+ * @example
  * ```typescript
- * import { isEmpty } from '@superutils/core'
- * isEmpty('') // true
- * isEmpty(' ') // true
- * isEmpty(`
- *
- *
- * `) // true
- * isEmpty('    not empty   ') // false
- * isEmpty(`
+ * import { filter } from '@superutils/core'
  *
- *     not empty
+ * const map = new Map<number, { name: string; age: number }>([
+ * 	[1, { name: 'Alice', age: 30 }],
+ * 	[2, { name: 'Bob', age: 25 }],
+ * 	[3, { name: 'Charlie', age: 35 }],
+ * ])
  *
- * `) // false
+ * const filtered = filter(map, item => item.age >= 30)
+ * console.log({ filtered })
+ * // result: Map(2) {
+ * //   1 => { name: 'Alice', age: 30 },
+ * //   3 => { name: 'Charlie', age: 35 }
+ * // }
  * ```
+ */
+declare const filter: <K, V, AsArray extends boolean = false, Result = AsArray extends true ? V[] : Map<K, V>>(data: IterableList<K, V>, predicate: (item: V, key: K, data: IterableList<K, V>) => boolean, limit?: number, asArray?: AsArray, result?: Map<K, V>) => Result;
+
+/**
+ * Finds a first item using predicate in an iterable list (Array, Map or Set).
  *
- * @example check numbers
- * ```typescript
- * import { isEmpty } from '@superutils/core'
- * isEmpty(NaN) // true
- * isEmpty(Infinity) // true
- * isEmpty(0) // false
- * ```
+ * @returns first item matched or `undefined` if not found
  *
+ * @example
+ * #### Find item using predicate callback
  *
- * @example check objects (includes arrays, maps & sets)
  * ```typescript
- * import { isEmpty } from '@superutils/core'
- * isEmpty({}) // true
- * isEmpty([]) // true
- * isEmpty(new Map()) // true
- * isEmpty(new Set()) // true
+ * import { find } from '@superutils/core'
+ *
+ * const map = new Map<number, { name: string; age: number }>([
+ * 	[1, { name: 'Alice', age: 30 }],
+ * 	[2, { name: 'Bob', age: 25 }],
+ * 	[3, { name: 'Charlie', age: 35 }],
+ * ])
+ * const result = find(map, ({ name }) => name === 'Bob')
+ * console.log({ result })
+ * // result: { name: 'Bob', age: 25 }
  * ```
  */
-declare const isEmpty: (x: unknown, nonNumerable?: boolean, fallback?: boolean | 0 | 1) => boolean | 0 | 1;
+declare function find<K, V extends Record<string, unknown>, IncludeKey extends boolean = false, Return = undefined | (IncludeKey extends true ? [K, V] : V)>(data: IterableList<K, V>, predicate: Parameters<typeof filter<K, V>>[1]): Return;
 /**
- * Safe version of {@link isEmpty} with extended type checks and cross-realm handling.
- *
- * CAUTION: much slower than {@link isEmpty} due to use of Object.prototype.toString.call()
+ * Find the first item in an iterable list (Array, Map or Set) using `search()` function
  *
- * Cross-realm means objects created in different JavaScript contexts.
- * Eg: iframe, node vm context, worker context, browser extensions etc.
+ * @param data items to search
+ * @param options filter options. See {@link FindOptions}
  *
+ * @example
+ * #### Find item using search options
  *
- * @param x The value to check for emptiness.
+ * ```typescript
+ * import { find } from '@superutils/core'
  *
- * @returns `true` if the value is considered empty, `false` otherwise.
+ * const map = new Map<number, { name: string; age: number }>([
+ * 	[1, { name: 'Alice', age: 30 }],
+ * 	[2, { name: 'Bob', age: 25 }],
+ * 	[3, { name: 'Charlie', age: 35 }],
+ * ])
+ *	const result = find(map, {
+ *		query: { name: 'Bob' }
+ *	})
+ * console.log({ result })
+ * // result: { name: 'Bob', age: 25 }
+ * ```
  */
-declare const isEmptySafe: (x: unknown, numberableOnly?: boolean) => boolean | 1;
+declare function find<K, V extends Record<string, unknown>, IncludeKey extends boolean = false, Return = undefined | (IncludeKey extends true ? [K, V] : V)>(data: IterableList<K, V>, options: FindOptions<K, V, IncludeKey>): Return;
 
-/** Check if the environment is Browser */
-declare const isEnvBrowser: () => boolean;
-/** Check if the environment is NodeJS */
-declare const isEnvNode: () => boolean;
-/** Check if page is loaded on a touchscreen device */
-declare const isEnvTouchable: () => boolean;
+/** Map entries as array */
+declare const getEntries: <K, V>(map: Map<K, V>) => [K, V][];
 
-/** Check if value is a function */
-declare const isFn: <T extends (...args: any[]) => any>(x: unknown) => x is T;
-/**
- * Check if value is an Async function.
- * Caution: May not work at runtime when Babel/Webpack is used due to code compilation.
- *
- * ---
- * @example usage
- * ```typescript
- * isAsyncFn(async () => {}) // result: true
- * isAsyncFn(() => {}) // result: false
- * ```
- */
-declare const isAsyncFn: <TData = unknown, TArgs extends unknown[] = unknown[]>(x: unknown) => x is AsyncFn<TData, TArgs>;
+/** Get {@link IterableList} keys as array */
+declare const getKeys: <K, V>(data: IterableList<K, V>) => K[];
 
-/** Check if value is instance of Map */
-declare const isMap: <TKey = unknown, TValue = unknown>(x: unknown) => x is Map<TKey, TValue>;
-/** Check if provided is a Map and all values are objects */
-declare const isMapObj: <K extends PropertyKey, V, T extends Record<K, V>>(x: unknown, strict?: boolean) => x is Map<K, V>;
+/** Get size/length of Array/Map/Set */
+declare const getSize: (x: IterableList) => number;
 
-/** Check if value is an integer */
-declare const isInteger: (x: unknown) => x is number;
-/** Check if value is a valid negative integer */
-declare const isNegativeInteger: (x: unknown) => x is number;
-/** Check if value is a valid negative number */
-declare const isNegativeNumber: (x: unknown) => x is number;
-/** Check if value is a valid finite number */
-declare const isNumber: (x: unknown) => x is number;
-/** Check if value is a positive integer */
-declare const isPositiveInteger: (x: unknown) => x is number;
-/** Check if value is a positive number */
-declare const isPositiveNumber: (x: unknown) => x is number;
+/** Get Map values as Array */
+declare const getValues: <K, V>(data: IterableList<K, V>) => V[];
 
 /**
- * Check if value is an object.
+ * Reverse a {@link IterableList} (Array/Map/Set) conditionally
  *
+ * @param   data
+ * @param	reverse	 (optional) condition to reverse the list. Default: `true`
+ * @param	newInstance (optional) whether to return a new instance of the list. Default: `false`
  *
- * @param x value to check
- * @param strict (optional) whether to exclude anything other than plain object. Eg: Array, Map, RegExp, Set etc.
+ * @returns reversed data in original type or empty array for unsupported type
+ */
+declare const reverse: <K, V, T extends IterableList<K, V>>(data: T, reverse?: boolean, newInstance?: boolean) => V[] | [K, V][] | Map<K, V> | Set<V> | (T & Record<"clear", unknown>);
+
+/**
+ * A versatile utility for searching through an iterable list (Array, Map, or Set) of objects.
+ * It supports both a global search (using a string or RegExp) across all properties of an item, and a
+ * detailed, field-specific search using a query object.
  *
- * Default: `true`
+ * @param data The list of objects to search within. Compatible types include:
+ * - `Array`
+ * - `Map`
+ * - `Set`
+ * - `NodeList` (in DOM environments): `options.transform()` required
+ * - `HTMLCollection` (in DOM environments): should accompany `options.transform()`
+ * @param options The search criteria.
+ * @param options.query The search query. Can be a string to search all fields, or an object for field-specific
+ * @param options.ranked (optional) If `true`, the results are sorted by relevance (match index). Default: `false`.
  *
- * Valid objects:
- * - object literals (Prototype: `Object.prototype`)
- * - objects created using `Object.create(null)`
+ * searches (e.g., `{ name: 'John', city: 'New York' }`).
+ * @param options.asMap (optional) If `true`, returns a `Map`. If `false`, returns an `Array`. Default: `true`.
+ * @param options.ignoreCase (optional) If `true`, performs a case-insensitive search for strings. Default: `true`.
+ * @param options.limit (optional) The maximum number of results to return. Default: `Infinity`.
+ * @param options.matchAll (optional) If `true`, an item must match all key-value pairs in the `query` object. If
+ * `false`, it matches if at least one pair is found. Default: `false`.
+ * @param options.matchExact (optional) If `true`, performs an exact match. If `false`, performs a partial match
+ * (i.e., `includes()`). Default: `false`.
+ * @param options.result (optional) An optional `Map` to which the results will be added.
+ * @param options.transform (optional) Callback to transform item/item-property to string
  *
- * Valid when strict mode off (false):
- * - all of above
- * - buit-in objects like Date, Error, Map, Set, Uint8Array etc
- * - custom Class instances
- * - objects created using `Object.create(object)`
+ * @returns A `Map` or an `Array` containing the matched items, based on the `asMap` option.
  *
- * Always invalid:
- * - `null`, `undefined`, `NaN`, `Infinity`
- * - primitive: String, Number, BigInt...
+ * @example
+ * ```javascript
+ * import { search } from '@superutils/core'
  *
- * @example Examples
- * ```typescript
- * import { isObj } from '@superutils/core'
+ * const users = [
+ *   { id: 1, name: 'John Doe', city: 'New York' },
+ *   { id: 2, name: 'Jane Doe', city: 'London' },
+ *   { id: 3, name: 'Peter Jones', city: 'New York' },
+ * ]
  *
- * console.log(isObj(null)) // false
- * console.log(isObj(undefined)) // false
- * console.log(isObj(NaN)) // false
- * console.log(isObj(Infinity)) // false
- * console.log(isObj({})) // true
- * console.log(isObj({ a: 1, b: 2})) // true
- * console.log(isObj(Object.create(null))) // true
- * console.log(isObj(new Map())) // false (strict)
- * console.log(isObj(new Map(), false)) // true (non-strict)
- * console.log(isObj(new Error('error'))) // false (strict)
- * console.log(isObj(new Error('error'), false)) // true (non-strict)
- * class Test { a = 1 }) // a custom class
- * console.log(isObj(new Test())) // false
- * console.log(isObj(new Test(), false)) // true
+ * // Simple string search (case-insensitive, partial match by default)
+ * const doeUsers = search(users, { query: 'doe' })
+ * console.log({ doeUsers })
+ * // Map(2) {
+ * //     0 => { id: 1, name: 'John Doe', city: 'New York' },
+ * //     1 => { id: 2, name: 'Jane Doe', city: 'London' }
+ * //   }
+ * // }
+ *
+ * // Field-specific search, requiring all fields to match
+ * const peterInNY = search(users, {
+ * 	 asMap: false, // return result as array
+ *   query: { name: 'Peter', city: 'New York' },
+ *   matchAll: true,
+ * })
+ * console.log({ peterInNY })
+ * // [ { id: 3, name: 'Peter Jones', city: 'New York' } ]
  * ```
  */
-declare const isObj: <T = Record<PropertyKey, unknown>>(x: unknown, strict?: boolean) => x is T;
-
-/** Check if value is instance of URL */
-declare const isUrl: (x: unknown) => x is URL;
+declare const search: {
+    <K, V, MatchExact extends boolean = false, AsMap extends boolean = true, Result = AsMap extends true ? Map<K, V> : V[]>(data: IterableList<K, V>, options: SearchOptions<K, V, MatchExact, AsMap>): Result;
+    defaults: Pick<Required<SearchOptions<unknown, unknown, false, true>>, "matchAll" | "limit" | "asMap" | "ignoreCase" | "ranked" | "transform">;
+};
 /**
- * Check if a value is a valid URL/string-URL.
- *
- * @param x The value to check.
- * @param strict If true:
- * - requires a domain name with a TLDs etc.
- * - and x is string, catches any auto-correction (eg: trailing spaces being removed, spaces being replaced by `%20`)
- * by `new URL()` to ensure string URL is valid
- * Defaults to `true`.
- * @param tldExceptions when in strict mode, treat these hosts as valid despite no domain name extensions
- * Defaults to `['localhost']`
+ * Internal utility for use with {@link search} function
  *
- * @returns `true` if the value is a valid URL, `false` otherwise.
+ * @returns match index (`-1` means didn't match)
  */
-declare const isUrlValid: (x: unknown, strict?: boolean, tldExceptions?: string[]) => boolean;
+declare function matchObjOrProp<K, V>(// extends Record<string, unknown>
+{ query, ignoreCase, matchExact, transform, }: Pick<SearchOptions<K, V, boolean>, 'transform' | 'query' | 'ignoreCase' | 'matchExact'>, item: V, propertyName?: string): number;
 
-/** Check if value is boolean */
-declare const isBool: (x: unknown) => x is boolean;
-/** Check if value is not undefined or null */
-declare const isDefined: <T = unknown>(x: T | undefined | null) => x is T;
-/** Check if value is instance of Error */
-declare const isError: (x: unknown) => x is Error;
-/** Check if value is a Promise */
-declare const isPromise: <T = unknown>(x: unknown) => x is Promise<T>;
-/** Check if value is a regular expession */
-declare const isRegExp: (x: unknown) => x is RegExp;
-/** Check if value is instance of Set */
-declare const isSet: <T = unknown>(x: unknown) => x is Set<T>;
-/** Check if value is string */
-declare const isStr: (x: unknown) => x is string;
+type SliceMapTransform<Data, Value, Key> = (item: Value, key: Key, data: Data) => Value;
+type SliceMapOptions<Data, Value, Key, AsMap extends boolean = false> = {
+    /** Whether to return the result as a Map (preserving original keys) or an Array */
+    asMap?: AsMap;
+    /** Callback to transform each item from the selected range */
+    transform?: SliceMapTransform<Data, Value, Key>;
+    /** End index (exclusive). Default: `undefined` (end of the list) */
+    end?: number;
+    /** Whether to exclude item if value is `undefined | null` */
+    ignoreEmpty?: boolean;
+    /** Start index. Default: `0` */
+    start?: number;
+};
 /**
- * Check if value is similar to a RxJS subject with .subscribe & .next functions
+ * Slice an iterable list and map the values into an Array/Map.
  *
- * @param x The value to check
- * @param withValue When `true`, also checks if `value` property exists in `x`
+ * @param data		Array, Map, Set...
+ * @param options	One of the following is required to create a new list:
+ * 1. A callback function {@link SliceMapTransform} to transform all items.
+ * 2. Advanced options {@link SliceMapOptions}.
+ * @param options.asMap	(optional) whether return a Map or Array.
+ * @param options.end	(optional) End index (exclusive). Default: `undefined` (end of the list)
+ * @param options.ignoreEmpty (optional) Whether to exclude item if value is `undefined | null`
+ * @param options.start	(optional) Default: `0`
+ * @param options.transform	(optional)
  *
- * @returns `true` if the value is subject-like, `false` otherwise.
- */
-declare const isSubjectLike: <T>(x: unknown, withValue?: boolean) => boolean;
-/** Check if value is a Symbol */
-declare const isSymbol: (x: unknown) => x is symbol;
-/**
- * Compilation of all the compile-time & runtime utilities functions above
- */
-declare const is: {
-    arr: <Item = unknown>(x: unknown) => x is Item[];
-    arr2D: <Item = unknown>(x: unknown) => x is Item[][];
-    arrLike: (x: any) => x is typeof x extends (infer Value)[] ? Value[] : typeof x extends Set<infer Value> ? Set<Value> : typeof x extends Map<infer Key, infer Value> ? Map<Key, Value> : never;
-    arrLikeSafe: <T = unknown, MapKey = unknown>(x: unknown) => x is Set<T> | Map<MapKey, T> | T[];
-    arrObj: <K extends PropertyKey, V, T extends Record<K, V>[]>(x: unknown, strict?: boolean) => x is T[];
-    arrUnique: <T = unknown>(arr: T[]) => boolean;
-    asyncFn: <TData = unknown, TArgs extends unknown[] = unknown[]>(x: unknown) => x is AsyncFn<TData, TArgs>;
-    bool: (x: unknown) => x is boolean;
-    date: (x: unknown) => x is Date;
-    dateValid: (date: unknown) => boolean;
-    defined: <T = unknown>(x: T | undefined | null) => x is T;
-    empty: (x: unknown, nonNumerable?: boolean, fallback?: boolean | 0 | 1) => boolean | 0 | 1;
-    emptySafe: (x: unknown, numberableOnly?: boolean) => boolean | 1;
-    envBrowser: () => boolean;
-    envNode: () => boolean;
-    envTouchable: () => boolean;
-    error: (x: unknown) => x is Error;
-    fn: <T extends (...args: any[]) => any>(x: unknown) => x is T;
-    integer: (x: unknown) => x is number;
-    map: <TKey = unknown, TValue = unknown>(x: unknown) => x is Map<TKey, TValue>;
-    mapObj: <K extends PropertyKey, V, T extends Record<K, V>>(x: unknown, strict?: boolean) => x is Map<K, V>;
-    negativeInteger: (x: unknown) => x is number;
-    negativeNumber: (x: unknown) => x is number;
-    number: (x: unknown) => x is number;
-    obj: <T = Record<PropertyKey, unknown>>(x: unknown, strict?: boolean) => x is T;
-    positiveInteger: (x: unknown) => x is number;
-    positiveNumber: (x: unknown) => x is number;
-    promise: <T = unknown>(x: unknown) => x is Promise<T>;
-    regExp: (x: unknown) => x is RegExp;
-    set: <T = unknown>(x: unknown) => x is Set<T>;
-    str: (x: unknown) => x is string;
-    subjectLike: <T>(x: unknown, withValue?: boolean) => boolean;
-    symbol: (x: unknown) => x is symbol;
-    uint8Arr: (arr: unknown) => arr is Uint8Array<ArrayBufferLike>;
-    url: (x: unknown) => x is URL;
-    urlValid: (x: unknown, strict?: boolean, tldExceptions?: string[]) => boolean;
-};
-
-/** Placeholder function that does nothing */
-declare function noop(): void;
-declare function noopAsync(): Promise<void>;
-
-/**
- * Convert timestamp to `input["datetime-local"]` compatible format.
+ * If callback throws error or returnes `undefined`, the item will be ignored.
  *
- * ---
- * @example Convert ISO datetime string
- * ```typescript
- * toDatetimeLocal('2000-01-01T01:01:01.001Z')
- * // result: "2000-01-01T01:01" // assuming local timezone is UTC+0
- * ```
+ * Callback Params:
+ *   - item: current item
+ *   - key: index/key of the current item
+ *   - data: original list
  *
- * @example Convert Date object
- * ```typescript
- * const date = new Date('2000-01-01T01:01:01.001Z')
- * toDatetimeLocal(date)
- * // result: "2000-01-01T01:01" // assuming local timezone is UTC+0
- * ```
+ * @returns Array/Map depending on `options.asMap`
  *
- * @example Convert Unix Timestamp (epoch time) number
- * ```typescript
- * const epoch = new Date('2000-01-01T01:01:01.001Z').getTime()
- * toDatetimeLocal(epoch)
- * // result: "2000-01-01T01:01" // assuming local timezone is UTC+0
- * ```
- */
-declare const toDatetimeLocal: (dateStr: string | Date | number) => "" | `${number}-${number}-${number}T${number}:${number}`;
-
-/**
- * Constructs a new object with only the supplied property names (keys) and their respective values
+ * @example
+ * #### Slice a list of items and map values into new array
+ * ```javascript
+ * import { sliceMap } from '@superutils/core'
  *
- * @param obj
- * @param keys property names to keep
- * @param ignoreIfNotExist (optional) if truthy, will ignore non-existent `keys`. Default: `true`
+ * const data = new Map([
+ * 	[0, { age: 30, name: 'Alice' }],
+ * 	[1, { age: 25, name: 'Bob' }],
+ * 	[2, undefined],
+ * 	[3, {}],
+ * 	[4, { age: 35, name: 'Charlie' }],
+ * 	[5, { age: 28, name: 'Dave' }],
+ * 	[6, { age: 22, name: 'Eve' }],
+ * ])
+ * const result = sliceMap(data, {
+ * 	asMap: false, // whether to return the result as a Map
+ * 	end: 5, // last index (exclusive)
+ * 	ignoreEmpty: true, // ignore items with no value
+ * 	start: 1, // first index
+ * })
+ * console.log(result)
+ * // [ { age: 25, name: 'Bob' }, { age: 35, name: 'Charlie' } ]
+ * ```
  */
-declare const objClean: <T extends Record<PropertyKey, unknown>, Key extends keyof T = keyof T>(obj: T, keys: Key[], ignoreIfNotExist?: boolean) => Record<Key, T[Key]>;
+declare const sliceMap: <Data extends IterableList, Key = Data extends IterableList<infer Key_1, unknown> ? Key_1 : never, Value = Data extends IterableList<unknown, infer Value_1> ? Value_1 : never, AsMap extends boolean = false, Result = AsMap extends false ? Value[] : Map<Key, Value>>(data: Data, options?: SliceMapOptions<Data, Value, Key, AsMap> | SliceMapTransform<Data, Value, Key>) => Result;
 
+type EntryComparator<K, V> = (a: [K, V], b: [K, V]) => number;
+type ArrayComparator<V> = (a: V, b: V) => number;
 /**
- * Deep-copy an object to another object
- *
- * @param input input object
- * @param output (optional) output object
- * @param ignoreKeys (optional) input peroperties to be ignored. Prevents output's property to be overriden.
- *
- * For child object properties use "." (dot) separated path.
+ * Sort iterable lists (Array/Map/Set).
  *
- * Eg: `"child.grandchild1"` where input is `{ child: { grandchild1: 1, grandchild2: 2 }}`
  *
- * @param override (optional) whether to allow override output properties.
- * This will only be used if `output` object is provided and has own property.
- * Accepted values:
- * - `true`: input property will override output property
- * - `false`: no overriding if output contains the property. Even if the property value is `undefined`.
- * - `"empty"`: only allow overriding output property if it's value is empty by using {@link isEmpty}.
- * - `function`: decide whether to override on a per property basis.
- *
- * Function Arguments:
- *     1. key: current property name/key
- *     2. outputValue: `output` property value
- *     3. inputValue: `input` property value
+ * @param data
+ * @param propertyName Accepted values:
+ * - `string`: value object property name
+ * - `function`: comparator function. Recommended for performance.
+ * - `true`: indicates to sort by Map keys instead of values.
+ * @param options (optional) extra sorting opitons
+ * @param options.asString (optonal) whether to convert values to string for sorting purposes only. Default: `true`
+ * @param options.ignoreCase (optional) case-insensitive sort for strings. Default: `true`
+ * @param options.reverse (optional) True: accending sort. False: descending sort. Default: `false`
+ * @param options.undefinedFirst (optional) Where to place undefined/null values.
+ * Not avaible when `comparator` function is used.
+ * - `true`: at the beginning
+ * - `false`: at the end
  *
  * Default: `false`
  *
- * @param recursive (optional) whether to recursively copy nested objects. Default: `false`
+ * @returns sorted map
  *
+ * @example
+ * #### Sort map of objects
+ * ```javascript
+ * import { sort } from '@superutils/core'
  *
- * @returns copied and/or merged object
+ * const map = new Map([
+ *     [0, { name: 'Charlie' }],
+ *     [1, { name: 'Alice' }],
+ *     [2, { name: 'Bob' }],
+ * ])
+ * console.log(sort(map, 'name'))
+ * // result: Map(3) {
+ * //   1 => { name: 'Alice' },
+ * //   2 => { name: 'Bob' },
+ * //   0 => { name: 'Charlie' }
+ * // }
+ * ```
  */
-declare const objCopy: <Key extends PropertyKey, InValue, OutValue, IgnoredKey extends Key | string>(input: Record<Key, InValue>, output?: Record<PropertyKey, OutValue>, ignoreKeys?: IgnoredKey[] | Set<IgnoredKey>, override?: boolean | "empty" | ((key: Key, outputValue: OutValue, inputValue: InValue) => boolean), recursive?: boolean) => Record<PropertyKey, unknown>;
-
+declare function sort<K, V extends Record<PropertyKey, unknown>, T extends IterableList<K, V>>(data: T, propertyName: keyof V & string, options?: SortOptions): T;
 /**
- * Creates an object from an array of keys and a corresponding array of values.
- * It pairs each key with the value at the same index.
- *
- * @param keys An array of property keys (strings or symbols).
- * @param values (optional) An array of property values. The value at each index corresponds to the key at the same index. If a value is missing for a key, it will be `undefined`.
- * @param result (optional) An existing object to add or overwrite properties on. If not provided, a new object is created.
- * @returns The newly created object, or the `result` object merged with the new properties.
+ * Sort `Map` by map-keys `K`
  *
- * @example Creating a new object from keys and values
- * ```typescript
- * const keys = ['a', 'b', 'c'];
- * const values = [1, 2, 3];
- * const newObj = objCreate(keys, values);
- * // newObj is { a: 1, b: 2, c: 3 }
- * ```
+ * @example
+ * #### Sort map of simple values (string/number/boolean)
+ * ```javascript
+ * import { sort } from '@superutils/core'
  *
- * @example Merging into an existing object
- * ```typescript
- * const existingObj = { a: 0, d: 4 };
- * const keys = ['b', 'c'];
- * const values = [2, 3];
- * objCreate(keys, values, existingObj);
- * // existingObj is now { a: 0, d: 4, b: 2, c: 3 }
+ * const map = new Map([
+ * 	   [1, 1],
+ * 	   [2, 2],
+ *     [0, 0],
+ * ])
+ * console.log(sort(map, false, { asString: false }))
+ * // result: Map(3) { 0 => 0, 1 => 1, 2 => 2 }
  * ```
  */
-declare const objCreate: <V, K extends PropertyKey, RV, RK extends PropertyKey, Result extends Record<K | RK, V | RV>>(keys?: K[], values?: V[], result?: Result) => Result;
+declare function sort<K, V>(data: Map<K, V>, 
+/** Whether to sort by key or Value */
+byKey?: boolean, options?: SortOptions): Map<K, V>;
+/** Sort `Map` with comparator function */
+declare function sort<K, V>(map: Map<K, V>, comparator: EntryComparator<K, V>, options?: SortOptions): Map<K, V>;
+/** Sort `Array` with comparator function */
+declare function sort<V>(array: V[], comparator: ArrayComparator<V>, options?: SortOptions): V[];
+/** Sort `Set` with comparator function */
+declare function sort<V>(set: Set<V>, comparator: ArrayComparator<V>, options?: SortOptions): Set<V>;
+/** Sort Array/Map/Set with `string | boolean | number` values */
+declare function sort<K, V extends string | boolean | number, T extends IterableList<K, V>>(data: T, options?: SortOptions): T;
+declare namespace sort {
+    var defaults: {
+        asString: true;
+        ignoreCase: true;
+        newInstance: false;
+        reverse: false;
+        undefinedFirst: false;
+    };
+}
 
+/** Check if value is an array */
+declare const isArr: <Item = unknown>(x: unknown) => x is Item[];
 /**
- * Checks if all the supplied keys exist in an object
- *
- * @param input
- * @param keys
- * @param requireValue (optional) whether each property should have some value.
+ * Check if value is an array of objects
  */
-declare function objHasKeys(input?: object | unknown[], keys?: PropertyKey[], requireValue?: boolean): boolean;
-
+declare const isArrObj: <K extends PropertyKey, V, T extends Record<K, V>[]>(x: unknown, strict?: boolean) => x is T[];
+/** Check if argument is a 2-dimentional array */
+declare const isArr2D: <T = unknown>(x: unknown) => x is T[][];
+/** Check if value is convertible to an array by using `Array.from(x)` */
+declare const isArrLike: <K = unknown, V = unknown>(x: unknown) => x is IterableList<K, V>;
 /**
- * Get object property names/keys
+ * Check if value is convertible to an array by using `Array.from(x)` even if it comes from a different realm
+ * (eg: iframe, iframes, worker contexts, node vm contexts, browser extensions).
  *
- * @param obj target object
- * @param sorted (optional) Whether to sort the keys. Default: `true`
- * @param includeSymbols (optional) Whether to include `Symbol` object. Default: `false`
+ * Caution: much slower than {@link isArrLike} due to use of `Object.prototype.toString.call()`
  */
-declare const objKeys: <T extends object, Include extends true | false = true>(obj: T, sorted?: boolean, includeSymbols?: Include) => Include extends true ? (keyof T)[] : (keyof T)[] & string[];
-
-type ReadOnlyAllowAddFn<T> = (obj: T, key: string | symbol, valule: unknown) => boolean;
-type ReadOnlyConfig<T, Revocable extends true | false = false> = {
-    /** Whether to allow adding new properties. Default: `false` */
-    add?: boolean | ReadOnlyAllowAddFn<T>;
-    /** Default: `false` */
-    revocable?: Revocable;
-    /** Whether to throw error when a write operation is rejected. Default: `true` */
-    silent?: boolean;
-};
+declare const isArrLikeSafe: <K = unknown, V = unknown>(x: unknown) => x is IterableList<K, V>;
+/** Check if all values in the array are unique */
+declare const isArrUnique: <T = unknown>(x: unknown) => x is T[];
+/** Check if value is instance of Uint8Array */
+declare const isUint8Arr: (x: unknown) => x is Uint8Array;
 
+/** Check if value is instance of Date */
+declare const isDate: (x: unknown) => x is Date;
 /**
- * Constructs a new read-only object where only new properties can be added.
- *
- * Applies only to the top-level properties.
+ * Check if a value is a valid date.
  *
- * @param obj input object
- * @param config (optional) extra configuration
- * @param config.add (optional) Whether to allow adding new properties. Default: `false`
- * @param config.revocable (optional) Whether to create a revokable proxy. Default: `false`
- * @param config.silent (optional) whether to throw error when a write operation is rejected. Default: `false`
+ * @param   date The value to check. Can be a Date object or a string.
  *
- * @returns	Readonly object or object containing readonly object and revoke function
+ * @returns `true` if the value is a valid date, `false` otherwise.
  */
-declare const objReadOnly: <T extends object | unknown[], Revocable extends true | false = false, Result = Revocable extends true ? ReturnType<typeof Proxy.revocable<T>> : T>(obj: T, config?: ReadOnlyConfig<T, Revocable>) => Result;
+declare const isDateValid: (date: unknown) => boolean;
 
 /**
- * Assign value to an object property
+ * Check if variable contains empty, null-ish value.
  *
- * @param obj
- * @param key
- * @param falsyValue (optional) Default: `obj[key]`
- * @param condition	(optional)
- * @param truthyValue (optional) value to use if condition is truthy
- */
-declare const objSetProp: <K extends PropertyKey, V, OutKey extends K | string>(obj: Record<K, V>, key: OutKey, falsyValue?: V, condition?: boolean | ((value: V | undefined, key: OutKey, obj: Record<K, V>) => boolean), truthyValue?: V) => Record<OutKey, V>;
-/** Assign value to an object property only if current value is undefined */
-declare const objSetPropUndefined: (...[obj, key, ...args]: Parameters<typeof objSetProp>) => Record<PropertyKey, unknown>;
-
-/** create a new object with properties sorted by key */
-declare const objSort: <T>(obj: T, recursive?: boolean, _done?: Map<unknown, boolean>) => T;
-
-/**
- * Creates a new object excluding specific properties
+ * Depending on the type certain criteria applies:
+ * - `null` | `undefined`: always empty
+ * - `String`: empty text or only white-spaces
+ * - `Number`: non-finite or NaN
+ * - `Array` | `Uint8Array` | `Map` | `Set` | `Object`: contains zero items/properties
+ * - `Boolean` | `Function` | `Symbol` | `BigInt`: never empty
  *
- * @param	{Object}	input
- * @param	{Array}		keys	property names to exclude
- * @param	{Object}	output	(optional) to delete unwanted props from the original `input` use it here.
- * 								Default: a copy of the `input` object
+ * @param x The value to check for emptiness.
+ * @param nonNumerable (optional) when `true`, considers non-enumerable properties
+ * while checking objects for emptiness. Default: `false`
+ * @param fallback (optional) value to return when type is unrecognized.
+ * Default: `false`
  *
- * @returns {Object}
+ * @example
+ * #### Check strings
+ * ```javascript
+ * import { isEmpty } from '@superutils/core'
+ *
+ * isEmpty('') // true
+ * isEmpty(' ') // true
+ * isEmpty(`
+ *
+ *
+ * `) // true
+ * isEmpty('    not empty   ') // false
+ * isEmpty(`
+ *
+ *     not empty
  *
- * @example Create a new object excluding specific properties
+ * `) // false
+ * ```
  *
+ * @example
+ * #### check numbers
  * ```javascript
- * import { objWithoutKeys } from '@superutils/core'
+ * import { isEmpty } from '@superutils/core'
  *
- * const result = objWithoutKeys({ a: 1, b: '2', c: false }, ['b', 'c'])
- * console.log(result) // { a: 1 }
+ * isEmpty(NaN) // true
+ * isEmpty(Infinity) // true
+ * isEmpty(0) // false
  * ```
  *
- * @example Copy one object's properties to another while ignoring specific properties
- *
+ * @example
+ * #### check objects (includes arrays, maps & sets)
  * ```javascript
- * import { objWithoutKeys } from '@superutils/core'
+ * import { isEmpty } from '@superutils/core'
  *
- * const source = { a: 1, b: '2', c: false }
- * const dest = { d: 4, e: 5 }
- * const result = objWithoutKeys(source, ['b', 'c'], dest)
- * console.log(result) // { d: 4, e: 5, a: 1 }
- * console.log(result === dest) // true
+ * isEmpty({}) // true
+ * isEmpty([]) // true
+ * isEmpty(new Map()) // true
+ * isEmpty(new Set()) // true
  * ```
  */
-declare const objWithoutKeys: (input: unknown, keys: string[], output?: Record<PropertyKey, unknown>) => Record<PropertyKey, unknown>;
-
+declare const isEmpty: (x: unknown, nonNumerable?: boolean, fallback?: boolean | 0 | 1) => boolean | 0 | 1;
 /**
- * Sugar for `objReadOnly()` for an Array
+ * Safe version of {@link isEmpty} with extended type checks and cross-realm handling.
  *
- * @param arr
- * @param config (optional)
- * @param config.add (optional) Whether to allow adding new properties. Default: `false`
- * @param config.revocable (optional) Default: `false`
- * @param config.silent (optional) Whether to throw error when a write operation is rejected. Default: `true`
+ * CAUTION: much slower than {@link isEmpty} due to use of Object.prototype.toString.call()
  *
- * @returns Readonly Array or object containing readonly Array and revoke function
- */
-declare const arrReadOnly: <T>(arr: T[], config?: Omit<ReadOnlyConfig<T[]>, "revoke">) => T[];
-
-/**
- * @ignore exclude from documentation
- * Helper class for creating read-only arrays.
+ * Cross-realm means objects created in different JavaScript contexts.
+ * Eg: iframe, node vm context, worker context, browser extensions etc.
  *
- * Caution: This class can by itself only make the array partially read-only.
- * Use {@link arrReadOnly} instead.
+ *
+ * @param x The value to check for emptiness.
+ *
+ * @returns `true` if the value is considered empty, `false` otherwise.
  */
-declare class ReadOnlyArrayHelper<T> extends Array<T> {
-    readonly config: Omit<ReadOnlyConfig<T[]>, 'revoke'>;
-    constructor(config: Omit<ReadOnlyConfig<T[]>, 'revoke'>, arr: T[]);
-    private ignoreOrThrow;
-    pop: () => T;
-    push: (...items: T[]) => number;
-    reverse: () => this;
-    shift: () => T;
-    splice: (..._ignoredArgs: unknown[]) => never[];
-    unshift: (..._ignoredArgs: T[]) => number;
-}
+declare const isEmptySafe: (x: unknown, numberableOnly?: boolean) => boolean | 1;
+
+/** Check if the environment is Browser */
+declare const isEnvBrowser: () => boolean;
+/** Check if the environment is NodeJS */
+declare const isEnvNode: () => boolean;
+/** Check if page is loaded on a touchscreen device */
+declare const isEnvTouchable: () => boolean;
 
+/** Check if value is a function */
+declare const isFn: <T extends (...args: any[]) => any>(x: unknown) => x is T;
 /**
- * Reverse an array conditionally
+ * Check if value is an Async function.
+ * Caution: May not work at runtime when Babel/Webpack is used due to code compilation.
  *
- * @param   arr
- * @param	reverse	 (optional) condition to reverse the array. Default: `true`
- * @param	newArray (optional) whether to cnstruct new array or use input. Default: `false`
+ * @example
+ * ```javascript
+ * import { isAsyncFn } from '@superutils/core'
  *
- * @returns array
+ * isAsyncFn(async () => {}) // result: true
+ * isAsyncFn(() => {}) // result: false
+ * ```
  */
-declare const arrReverse: <T = unknown>(arr: T[], reverse?: boolean, newArray?: boolean) => T[];
+declare const isAsyncFn: <TData = unknown, TArgs extends unknown[] = unknown[]>(x: unknown) => x is AsyncFn<TData, TArgs>;
+
+/** Check if value is instance of Map */
+declare const isMap: <TKey = unknown, TValue = unknown>(x: unknown) => x is Map<TKey, TValue>;
+/** Check if provided is a Map and all values are objects */
+declare const isMapObj: <K extends PropertyKey, V, T extends Record<K, V>>(x: unknown, strict?: boolean) => x is Map<K, V>;
+
+/** Check if value is an integer */
+declare const isInteger: (x: unknown) => x is number;
+/** Check if value is a valid negative integer */
+declare const isNegativeInteger: (x: unknown) => x is number;
+/** Check if value is a valid negative number */
+declare const isNegativeNumber: (x: unknown) => x is number;
+/** Check if value is a valid finite number */
+declare const isNumber: (x: unknown) => x is number;
+/** Check if value is a positive integer */
+declare const isPositiveInteger: (x: unknown) => x is number;
+/** Check if value is a positive number */
+declare const isPositiveNumber: (x: unknown) => x is number;
 
 /**
- * Generate a Map from one or more arrays
+ * Check if value is an object.
  *
- * @param arr
- * @param key (optional) Array object-item property name or a function to generate keys for each array items.
- * @param flatDepth (optional) maximum recursion depth to flatten the array. Default: `0`
  *
- * @returns Converted Map
+ * @param x value to check
+ * @param strict (optional) whether to exclude anything other than plain object. Eg: Array, Map, RegExp, Set etc.
  *
- * @example Convert Array to Map
- * ```typescript
- * type Item = { a: number }
- * const arr: Item[] = [{ a: 1 }, { a: 2 }, { a: 3 }, [{ a: 4 }]]
- * const map: Map<number, Item> = arrToMap(
- * 	   arr,
- * 	   (_: Item, i: number) => item.a,
- * )
- * ```
+ * Default: `true`
  *
- * @example Flatten and convert Array to Map
- * ```typescript
- * type Item = { key: number; value: string }
- * const arr: (Item | Item[])[] = [
- * 	{ key: 1, value: 'a' },
- * 	{ key: 2, value: 'b' },
- * 	{ key: 3, value: 'c' },
- * 	[{ key: 4, value: 'd' }],
- * ]
- * const map = arrToMap(arr, (item: Item) => item.key, 1) // Map<number, Item>
+ * Valid objects:
+ * - object literals (Prototype: `Object.prototype`)
+ * - objects created using `Object.create(null)`
+ *
+ * Valid when strict mode off (false):
+ * - all of above
+ * - buit-in objects like Date, Error, Map, Set, Uint8Array etc
+ * - custom Class instances
+ * - objects created using `Object.create(object)`
+ *
+ * Always invalid:
+ * - `null`, `undefined`, `NaN`, `Infinity`
+ * - primitive: String, Number, BigInt...
+ *
+ * @example
+ * ```javascript
+ * import { isObj } from '@superutils/core'
+ *
+ * console.log(isObj(null)) // false
+ * console.log(isObj(undefined)) // false
+ * console.log(isObj(NaN)) // false
+ * console.log(isObj(Infinity)) // false
+ * console.log(isObj({})) // true
+ * console.log(isObj({ a: 1, b: 2})) // true
+ * console.log(isObj(Object.create(null))) // true
+ * console.log(isObj(new Map())) // false (strict)
+ * console.log(isObj(new Map(), false)) // true (non-strict)
+ * console.log(isObj(new Error('error'))) // false (strict)
+ * console.log(isObj(new Error('error'), false)) // true (non-strict)
+ * class Test { a = 1 } // a custom class
+ * console.log(isObj(new Test())) // false
+ * console.log(isObj(new Test(), false)) // true
  * ```
  */
-declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, KeyProp extends keyof MapItem = keyof MapItem>(arr: T, key: KeyProp, flatDepth?: FlatDepth): Map<MapItem[KeyProp], MapItem>;
-declare function arrToMap<T extends unknown[], FlatDepth extends number = 0>(arr: T, flatDepth?: FlatDepth): Map<number, FlatArray<T, FlatDepth>>;
-declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, MapKey = unknown>(arr: T, key: (item: MapItem, index: number, flatArr: MapItem[]) => MapKey, flatDepth?: FlatDepth): Map<MapKey, MapItem>;
+declare const isObj: <T = Record<PropertyKey, unknown>>(x: unknown, strict?: boolean) => x is T;
 
+/** Check if value is instance of URL */
+declare const isUrl: (x: unknown) => x is URL;
 /**
- * @function	arrUnique
- * @summary		constructs a new array of unique values
+ * Check if a value is a valid URL/string-URL.
+ *
+ * @param x The value to check.
+ * @param strict If true:
+ * - requires a domain name with a TLDs etc.
+ * - and x is string, catches any auto-correction (eg: trailing spaces being removed, spaces being replaced by `%20`)
+ * by `new URL()` to ensure string URL is valid
+ * Defaults to `true`.
+ * @param tldExceptions when in strict mode, treat these hosts as valid despite no domain name extensions
+ * Defaults to `['localhost']`
+ *
+ * @returns `true` if the value is a valid URL, `false` otherwise.
  */
-declare const arrUnique: <T = unknown>(arr: T[], flatDepth?: number) => FlatArray<T, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -1 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[];
+declare const isUrlValid: (x: unknown, strict?: boolean, tldExceptions?: string[]) => boolean;
 
+/** Check if value is boolean */
+declare const isBool: (x: unknown) => x is boolean;
+/** Check if value is not undefined or null */
+declare const isDefined: <T = unknown>(x: T | undefined | null) => x is T;
+/** Check if value is instance of Error */
+declare const isError: (x: unknown) => x is Error;
+/** Check if value is a Promise */
+declare const isPromise: <T = unknown>(x: unknown) => x is Promise<T>;
+/** Check if value is a regular expession */
+declare const isRegExp: (x: unknown) => x is RegExp;
+/** Check if value is instance of Set */
+declare const isSet: <T = unknown>(x: unknown) => x is Set<T>;
+/** Check if value is string */
+declare const isStr: (x: unknown) => x is string;
 /**
- * Debounce function options
- */
-type DebounceOptions<ThisArg = unknown> = {
-    leading?: boolean | 'global';
-    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
-    thisArg?: ThisArg;
-    tid?: TimeoutId;
-};
-/**
- * Deferred function options
+ * Check if value is similar to a RxJS subject with .subscribe & .next functions
+ *
+ * @param x The value to check
+ * @param withValue When `true`, also checks if `value` property exists in `x`
+ *
+ * @returns `true` if the value is subject-like, `false` otherwise.
  */
-type DeferredOptions<ThisArg = unknown> = ({
-    throttle: true;
-} & ThrottleOptions<ThisArg>) | ({
-    throttle?: false;
-} & DebounceOptions<ThisArg>);
+declare const isSubjectLike: <T>(x: unknown, withValue?: boolean) => boolean;
+/** Check if value is a Symbol */
+declare const isSymbol: (x: unknown) => x is symbol;
 /**
- * Throttle function options
+ * Compilation of all the compile-time & runtime utilities functions above
  */
-type ThrottleOptions<ThisArg = unknown> = {
-    /**
-     *
-     * @param err Error object thrown by the callback function.
-     * @returns
-     */
-    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
-    thisArg?: ThisArg;
-    trailing?: boolean;
-    tid?: TimeoutId;
+declare const is: {
+    arr: <Item = unknown>(x: unknown) => x is Item[];
+    arr2D: <T = unknown>(x: unknown) => x is T[][];
+    arrLike: <K = unknown, V = unknown>(x: unknown) => x is IterableList<K, V>;
+    arrLikeSafe: <K = unknown, V = unknown>(x: unknown) => x is IterableList<K, V>;
+    arrObj: <K extends PropertyKey, V, T extends Record<K, V>[]>(x: unknown, strict?: boolean) => x is T[];
+    arrUnique: <T = unknown>(x: unknown) => x is T[];
+    asyncFn: <TData = unknown, TArgs extends unknown[] = unknown[]>(x: unknown) => x is AsyncFn<TData, TArgs>;
+    bool: (x: unknown) => x is boolean;
+    date: (x: unknown) => x is Date;
+    dateValid: (date: unknown) => boolean;
+    defined: <T = unknown>(x: T | undefined | null) => x is T;
+    empty: (x: unknown, nonNumerable?: boolean, fallback?: boolean | 0 | 1) => boolean | 0 | 1;
+    emptySafe: (x: unknown, numberableOnly?: boolean) => boolean | 1;
+    envBrowser: () => boolean;
+    envNode: () => boolean;
+    envTouchable: () => boolean;
+    error: (x: unknown) => x is Error;
+    fn: <T extends (...args: any[]) => any>(x: unknown) => x is T;
+    integer: (x: unknown) => x is number;
+    map: <TKey = unknown, TValue = unknown>(x: unknown) => x is Map<TKey, TValue>;
+    mapObj: <K extends PropertyKey, V, T extends Record<K, V>>(x: unknown, strict?: boolean) => x is Map<K, V>;
+    negativeInteger: (x: unknown) => x is number;
+    negativeNumber: (x: unknown) => x is number;
+    number: (x: unknown) => x is number;
+    obj: <T = Record<PropertyKey, unknown>>(x: unknown, strict?: boolean) => x is T;
+    positiveInteger: (x: unknown) => x is number;
+    positiveNumber: (x: unknown) => x is number;
+    promise: <T = unknown>(x: unknown) => x is Promise<T>;
+    regExp: (x: unknown) => x is RegExp;
+    set: <T = unknown>(x: unknown) => x is Set<T>;
+    str: (x: unknown) => x is string;
+    subjectLike: <T>(x: unknown, withValue?: boolean) => boolean;
+    symbol: (x: unknown) => x is symbol;
+    uint8Arr: (x: unknown) => x is Uint8Array;
+    url: (x: unknown) => x is URL;
+    urlValid: (x: unknown, strict?: boolean, tldExceptions?: string[]) => boolean;
 };
 
+/** Placeholder function that does nothing */
+declare function noop(): void;
+/** Placeholder async function that does nothing */
+declare function noopAsync(): Promise<void>;
+
 /**
- * Returns a function that invokes the callback function after certain delay/timeout.
- * All errors will be gracefully swallowed.
- *
- * @param	callback 	function to be invoked after timeout
- * @param	delay		(optional) timeout duration in milliseconds. Default: 50
- * @param   config.onError (optional)
- * @param   config.leading (optional) if true, will enable leading-edge debounce mechanism.
- * @param   config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
- * @param	config.tid	   (optional) Timeout Id. If provided, will clear the timeout on first invocation.
+ * Convert timestamp to `input["datetime-local"]` compatible format.
  *
- * @example Debounce function calls
+ * @example
+ * #### Convert ISO datetime string
  * ```javascript
- * import { deferred } from '@superutils/core'
+ * toDatetimeLocal('2000-01-01T01:01:01.001Z')
+ * // result: "2000-01-01T01:01" // assuming local timezone is UTC+0
+ * ```
  *
- * const handleChange = deferred(
- *     event => console.log('Value:', event.target.value),
- *     300 // debounce delay in milliseconds
- * )
+ * @example
+ * #### Convert Date object
+ * ```javascript
+ * const date = new Date('2000-01-01T01:01:01.001Z')
+ * toDatetimeLocal(date)
+ * // result: "2000-01-01T01:01" // assuming local timezone is UTC+0
+ * ```
  *
- * handleChange({ target: { value: 1 } }) // will be ignored
- * handleChange({ target: { value: 2 } }) // will be ingored
- * handleChange({ target: { value: 3 } }) // will be invoked
+ * @example
+ * #### Convert Unix Timestamp (epoch time) number
+ * ```javascript
+ * const epoch = new Date('2000-01-01T01:01:01.001Z').getTime()
+ * toDatetimeLocal(epoch)
+ * // result: "2000-01-01T01:01" // assuming local timezone is UTC+0
  * ```
  */
-declare const debounce: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DebounceOptions<ThisArg>): (...args: TArgs) => void;
-    defaults: {
-        /**
-         * Set the default value of argument `leading` for the `deferred` function.
-         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
-         */
-        leading: false;
-        /**
-         * Set the default value of argument `onError` for the `deferred` function.
-         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
-         */
-        onError: undefined;
-    };
-};
+declare const toDatetimeLocal: (dateStr: string | Date | number) => "" | `${number}-${number}-${number}T${number}:${number}`;
 
 /**
- * Returns a function that can be used to debounce/throttle calls to the provided callback function.
- * All errors will be gracefully swallowed. See {@link debounce} and {@link throttle} for more information.
+ * Constructs a new object with only the supplied property names (keys) and their respective values
  *
- * @param callback function to be invoked after delay
- * @param delay (optional) delay duration in milliseconds. Default: `50`
- * @param config (optional) debounce or throttle configuration options
+ * @param obj
+ * @param keys property names to keep
+ * @param ignoreIfNotExist (optional) if truthy, will ignore non-existent `keys`. Default: `true`
  *
- * @returns Callback function that can be invoked in one of the following 2 methods:
- * - debounced: when `throttle` is `false` or `undefined`
- * - throttled: when `throttle` is `true`
+ * @example
+ * #### Create a new object from an existing object by only extracting specified keys and relevant values
+ *
+ * ```javascript
+ * import { objClean } from '@superutils/core'
+ *
+ * const obj = {
+ * 	a: 1,
+ * 	b: 2,
+ * 	c: 3,
+ * 	d: 4
+ * }
+ * console.log(objClean(obj, [ 'a', 'b']))
+ * // { a: 1, b: 2 }
+ * ```
  */
-declare const deferred: <TArgs extends unknown[], ThisArg, Delay = unknown>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: Delay, config?: DeferredOptions<ThisArg>) => (...args: TArgs) => void;
+declare const objClean: <T extends Record<PropertyKey, unknown>, Key extends keyof T = keyof T>(obj: T, keys: Key[], ignoreIfNotExist?: boolean) => Record<Key, T[Key]>;
 
 /**
- * Returns a throttled function that ensures the callback is invoked at most once in the specified delay interval.
- * All errors will be gracefully swallowed.
+ * Deep-copy an object to another object
  *
- * If the throttled function is called multiple times during the delay interval, only the first call will invoke the callback immediately.
+ * @param input input object
+ * @param output (optional) output object
+ * @param ignoreKeys (optional) input peroperties to be ignored. Prevents output's property to be overriden.
  *
- * If `trailing` is enabled and if returned function is invoked more than once during the delay interval,
- * the callback runs again at the end of the delay with the most recent arguments.
+ * For child object properties use "." (dot) separated path.
  *
- * @param callback function to be invoked after timeout
- * @param delay (optional) interval duration in milliseconds. Default: 50
- * @param config (optional)
- * @param config.onError (optional) callback to be invoked on error
- * @param config.tid (optional)
- * @param config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
- * @param config.trailing (optional) whether to enable trailing edge execution. Default: `true`
+ * Eg: `"child.grandchild1"` where input is `{ child: { grandchild1: 1, grandchild2: 2 }}`
  *
- * @example Throttle function calls
- * ```javascript
- * import { throttle } from '@superutils/core'
+ * @param override (optional) whether to allow override output properties.
+ * This will only be used if `output` object is provided and has own property.
+ * Accepted values:
+ * - `true`: input property will override output property
+ * - `false`: no overriding if output contains the property. Even if the property value is `undefined`.
+ * - `"empty"`: only allow overriding output property if it's value is empty by using {@link isEmpty}.
+ * - `function`: decide whether to override on a per property basis.
  *
- * const handleChange = throttle(
- *     event => console.log('Value:', event.target.value),
- *     300, // throttle duration in milliseconds
- * )
- * handleChange({ target: { value: 1 } }) // will be executed
- * handleChange({ target: { value: 2 } }) // will be ignored
- * handleChange({ target: { value: 3 } }) // will be ignored
+ * Function Arguments:
+ *     1. key: current property name/key
+ *     2. outputValue: `output` property value
+ *     3. inputValue: `input` property value
  *
- * setTimeout(() => {
- *    handleChange({ target: { value: 4 } }) // will be executed (after 300ms)
- *    handleChange({ target: { value: 5 } }) // will be ignored
- * }, 400)
- * ```
+ * Default: `false`
  *
- * @example Throttle with trailing enabled
- * ```javascript
- * import { throttle } from '@superutils/core'
+ * @param recursive (optional) whether to recursively copy nested objects. Default: `false`
  *
- * const handleChange = throttle(
- *     event => console.log('Value:', event.target.value),
- *     300, // throttle duration in milliseconds
- * )
- * handleChange({ target: { value: 1 } }) // will be executed
- * handleChange({ target: { value: 2 } }) // will be ignored
- * handleChange({ target: { value: 3 } }) //  will be executed
  *
- * setTimeout(() => {
- *    handleChange({ target: { value: 4 } }) // will be executed
- *    handleChange({ target: { value: 5 } }) // will be ignored
- * }, 400)
+ * @returns copied and/or merged object
+ *
+ * @example
+ * #### Copy or merge objects
+ *
+ * ```javascript
+ * import { objCopy } from '@superutils/core'
+ *
+ * const source = {
+ * 	a: 1,
+ * 	b: 2,
+ * 	c: 3,
+ * 	x: {
+ * 		a: 1,
+ * 		b: 2,
+ * 	},
+ * }
+ * const dest = {
+ * 	d: 4,
+ * 	e: 5,
+ * }
+ * const copied = objCopy(
+ * 	source,
+ * 	dest,
+ * 	['a', 'x.b'], // exclude source property
+ * 	'empty', // only override if dest doesn't have the property or value is "empty" (check `is.emtpy()`)
+ * 	true, // recursively copies child objects. If false, child objects are copied by reference.
+ * )
+ * console.log({ copied })
+ * // Result:
+ * // {
+ * //     b: 2,
+ * //     c: 33,
+ * //     d: 4,
+ * //     e: 5,
+ * // }
+ * console.log(dest === copied) // true (dest is returned)
  * ```
  */
-declare const throttle: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
-    /**
-     * Set the default values
-     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
-     */
-    defaults: {
-        onError: undefined;
-        trailing: false;
-    };
-};
-/**
- * For legacy compatibility
- * @deprecated use `throttle` instead
- */
-declare const throttled: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
-    /**
-     * Set the default values
-     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
-     */
-    defaults: {
-        onError: undefined;
-        trailing: false;
-    };
-};
+declare const objCopy: <Key extends PropertyKey, InValue, OutValue, IgnoredKey extends Key | string>(input: Record<Key, InValue>, output?: Record<PropertyKey, OutValue>, ignoreKeys?: IgnoredKey[] | Set<IgnoredKey>, override?: boolean | "empty" | ((key: Key, outputValue: OutValue, inputValue: InValue) => boolean), recursive?: boolean) => Record<PropertyKey, unknown>;
 
-/** Configuration for finding {@link IterableList} items */
-type FindOptions<K, V, IncludeKey extends boolean = false> = Omit<SearchOptions<K, V>, 'limit' | 'asMap'> & {
-    /**
-     * Whether to include the key in the return type.
-     *
-     * If `true`, return type is `[K, V]` else `V`
-     *
-     * Default: `false`
-     */
-    includeKey?: IncludeKey;
-};
-/** A general type to capture all iterables like Array, Map, Set.... */
-type IterableList<K = unknown, V = unknown> = {
-    entries: () => IterableIterator<[K, V]>;
-    hasOwnProperty: (name: string) => boolean;
-    keys: () => IterableIterator<K>;
-    values: () => IterableIterator<V>;
-} & ({
-    clear: () => void;
-    size: number;
-} | {
-    length: number;
-});
-/** Configuration for sorting iterables */
-type SortOptions = {
-    ignoreCase?: boolean;
-    /**
-     * Whether to create a new instance of preserve original reference
-     *
-     * Default: `true` for Array, `false` for Map.
-     */
-    newInstance?: boolean;
-    /** Reverse sorted result */
-    reverse?: boolean;
-    /**
-     * Whether to place undefined/null values at the beginning of the sorted array.
-     *
-     * Default: `false`
-     */
-    undefinedFirst?: boolean;
-};
-/** Search criteria for searcheing iterables */
-type SearchOptions<K, V, MatchExact extends boolean = false, AsMap extends boolean = false> = {
-    /** Whethere to return the result as a map (`true`) or array (`false`). Default: `true` */
-    asMap?: AsMap;
-    /** case-insensitive search for strings. Default: `false` */
-    ignoreCase?: boolean;
-    /** limit number of results. Default: `Infinity` */
-    limit?: number;
-    /** partial match for values. Default: `false` */
-    matchExact?: MatchExact;
-    /** match all supplied key-value pairs. Default: `false` */
-    matchAll?: boolean;
-    /** key-value pairs */
-    query: Record<PropertyKey, unknown> | RegExp | string;
-    /** If `true`, the results are sorted by relevance (match index). Default: `false` */
-    ranked?: boolean;
-    /** Map to store results in. Default: `new Map()` */
-    result?: Map<K, V>;
-    /**
-     * Boolean or Callback to prepare item or individual property for search by converting to string.
-     *
-     * - `true`: value will be stringified
-     * - `false`: value will not be stringified when `matchExact = true`
-     * - `function`: transformed value will be used to search
-     *
-     * Returning "empty" (`undefined | null | [] | '' | ...`) value will ignore the item/property.
-     *
-     * Default: `true`
-     */
-    transform?: boolean | ((
-    /** List item */
-    item: V, 
-    /** Item property value or `undefined` for global search across all properties. */
-    value?: V[keyof V], 
-    /** Item property key provided by query or `undefined` for global search across all properties. */
-    key?: keyof V) => MatchExact extends true ? unknown : string | undefined);
+/**
+ * Creates an object from an array of keys and a corresponding array of values.
+ * It pairs each key with the value at the same index.
+ *
+ * @param keys An array of property keys (strings or symbols).
+ * @param values (optional) An array of property values. The value at each index corresponds to the key at the same index. If a value is missing for a key, it will be `undefined`.
+ * @param result (optional) An existing object to add or overwrite properties on. If not provided, a new object is created.
+ * @returns The newly created object, or the `result` object merged with the new properties.
+ *
+ * @example
+ * #### Creating a new object from arrays of keys and values
+ * ```javascript
+ * import { objCreate } from '@superutils/core'
+ *
+ * const keys = ['a', 'b', 'c']
+ * const values = [1, 2, 3]
+ * const newObj = objCreate(keys, values)
+ * console.log(newObj)
+ * // newObj is { a: 1, b: 2, c: 3 }
+ * ```
+ *
+ * @example
+ * #### Merging into an existing object
+ * ```typescript
+ * import { objCreate } from '@superutils/core'
+ *
+ * const existingObj = { a: 0, d: 4 }
+ * const keys = ['b', 'c']
+ * const values = [2, 3]
+ * const newObj = objCreate(keys, values, existingObj)
+ * console.log(newObj)
+ * // existingObj is now { a: 0, d: 4, b: 2, c: 3 }
+ * ```
+ */
+declare const objCreate: <V, K extends PropertyKey, RV, RK extends PropertyKey, Result extends Record<K | RK, V | RV>>(keys?: K[], values?: V[], result?: Result) => Result;
+
+/**
+ * Checks if all the supplied keys exist in an object
+ *
+ * @param input
+ * @param keys
+ * @param requireValue (optional) whether each property should have some value.
+ *
+ * @example
+ * #### Check if object contains specified properties
+ * ```javascript
+ * import { objHasKeys } from '@superutils/core'
+ *
+ * const obj = { a: 1, b: null, c: 0 }
+ * console.log(objHasKeys(obj, ['a', 'b']))
+ * // true
+ *
+ * console.log(
+ * 	objHasKeys(
+ * 		obj,
+ * 		['a', 'b'],
+ * 		true // check if all the respective values of the provided keys are not "empty". Uses `ìsEmpty()`.
+ * 	)
+ * )
+ * // false
+ * ```
+ */
+declare function objHasKeys(input?: object | unknown[], keys?: PropertyKey[], requireValue?: boolean): boolean;
+
+/**
+ * Get object property names/keys
+ *
+ * @param obj target object
+ * @param sorted (optional) Whether to sort the keys. Default: `true`
+ * @param includeSymbols (optional) Whether to include `Symbol` object. Default: `false`
+ */
+declare const objKeys: <T extends object, Include extends true | false = true>(obj: T, sorted?: boolean, includeSymbols?: Include) => Include extends true ? (keyof T)[] : (keyof T)[] & string[];
+
+type ObjReadOnlyAllowAddFn<T> = (obj: T, key: string | symbol, value: unknown) => boolean;
+type ObjReadOnlyConfig<T, Revocable extends true | false = false> = {
+    /** Whether to allow adding new properties. Default: `false` */
+    add?: boolean | ObjReadOnlyAllowAddFn<T>;
+    /** Default: `false` */
+    revocable?: Revocable;
+    /** Whether to throw error when a write operation is rejected. Default: `true` */
+    silent?: boolean;
 };
 
 /**
- * Filter {@link IterableList} (Array, Map, Set) items.
+ * Constructs a read-only proxy of an object.
+ * Prevents modification or deletion of existing properties based on configuration.
  *
- * @param data
- * @param predicate callback function to filter values
- * Parameters:
- * 1. `item`: current item
- * 2. `key`: index/key
- * 3. `data`: value provided in the first argument (`data`)
- * @param limit	(optional) limit number of results
- * @param asArray
+ * Applies only to top-level properties.
  *
- * @returns new Map with filtered items
+ * @param obj input object
+ * @param config (optional) extra configuration
+ * @param config.add (optional) Whether to allow adding new properties. Default: `false`
+ * @param config.revocable (optional) Whether to create a revokable proxy. Default: `false`
+ * @param config.silent (optional) whether to throw error when a write operation is rejected. Default: `true`
+ *
+ * @returns	Readonly object or object containing readonly object and revoke function
  *
  * @example
- * ```typescript
- * import { filter } from '@superutils/core'
+ * Create a readonly object and silently ignore any attempt of property add, update and delete operations
  *
- * const map = new Map<number, { name: string; age: number }>([
- * 	[1, { name: 'Alice', age: 30 }],
- * 	[2, { name: 'Bob', age: 25 }],
- * 	[3, { name: 'Charlie', age: 35 }],
- * ])
+ * ```javascript
+ * import { objReadOnly } from '@superutils/core'
+ *
+ * const obj = objReadOnly({ a: 1, b: 2})
+ * obj.a = 3
+ * delete obj.a
+ * console.log(obj.a) // 1
+ * obj.c = 4
+ * console.log(obj.c) // undefined
+ * ```
  *
- * const filtered = filter(map, item => item.age >= 30)
- * // result: Map(2) {
- * //   1 => { name: 'Alice', age: 30 },
- * //   3 => { name: 'Charlie', age: 35 }
+ * @example
+ * Create a readonly object and throw error on any attempt of property add, update and delete operations
+ *
+ * ```javascript
+ * import { fallbackIfFails, objReadOnly } from '@superutils/core'
+ *
+ * const obj = objReadOnly(
+ * 	{ a: 1, b: 2},
+ *  { silent: false }
+ * )
+ *
+ * try {
+ * 	obj.a = 3
+ * } catch(err) { console.log('update failed:', err.message) }
+ *
+ * try {
+ * 	delete obj.a
+ * } catch(err) { console.log('delete failed:', err.message) }
+ *
+ * try {
+ * 	obj.c = 4
+ * } catch(err) { console.log('add failed:', err.message) }
+ * console.log(obj) // { a: 1, b: 2 }
+ * ```
+ *
+ * @example
+ * Create a readonly object and throw error on any attempt of property update and delete operations
+ * but allow adding new properties
+ *
+ * ```javascript
+ * import { fallbackIfFails, objReadOnly } from '@superutils/core'
+ *
+ * const obj = objReadOnly(
+ * 	{ a: 1, b: 2},
+ *  {
+ * 		add: true,
+ * 		silent: false
+ * 	}
+ * )
+ * 	obj.c = 4
+ *  console.log(obj.c) // 4
+ * ```
+ */
+declare const objReadOnly: <T extends object | unknown[], Revocable extends true | false = false, Result = Revocable extends true ? ReturnType<typeof Proxy.revocable<T>> : T>(obj: T, config?: ObjReadOnlyConfig<T, Revocable>) => Result;
+
+type SetObPropPredicate<K extends PropertyKey, V, OutKey> = (value: V | undefined, key: OutKey, obj: Record<K, V>) => boolean;
+/**
+ * Conditionally assign value to an object's property
+ *
+ * @param obj target object
+ * @param key object property name
+ * @param falsyValue (optional) value to assign when condition is falsy Default: `obj[key]`
+ * @param condition	(optional) condition to determine which value to provide. Default: `false`
+ * @param truthyValue (optional) value to use if condition is truthy
+ */
+declare const objSetProp: <K extends PropertyKey, V, OutKey extends K | string>(obj: Record<K, V>, key: OutKey, falsyValue?: V, condition?: boolean | SetObPropPredicate<K, V, OutKey>, truthyValue?: V) => Record<OutKey, V>;
+/** Assign value to an object property only if current value is undefined */
+declare const objSetPropUndefined: (...[obj, key, ...args]: Parameters<typeof objSetProp>) => Record<PropertyKey, unknown>;
+
+/**
+ * Create a new object with properties sorted by key
+ *
+ * @example
+ * #### Sort an object recursively
+ *
+ * ```javascript
+ * import { objSort } from '@superutils/core'
+ *
+ * const d = Symbol('d')
+ * const obj = { c: 3, a: 1, [d]: 4, b: 2, e: { g: 1, f: 2 } }
+ * console.log(objSort(obj))
+ * // Result:
+ * // {
+ * //     a: 1,
+ * //     b: 2,
+ * //     c: 3,
+ * //     [d]: 4,
+ * //     e: { f: 2, g: 1 },
  * // }
  * ```
  */
-declare const filter: <K, V, AsArray extends boolean = false, Result = AsArray extends true ? V[] : Map<K, V>>(data: IterableList<K, V>, predicate: (item: V, key: K, data: IterableList<K, V>) => boolean, limit?: number, asArray?: AsArray, result?: Map<K, V>) => Result;
+declare const objSort: <T>(obj: T, recursive?: boolean, _done?: Map<unknown, boolean>) => T;
 
 /**
- * Finds a first item matching criteria in an {@link IterableList}.
+ * Creates a new object excluding specific properties
  *
- * @returns first item matched or `undefined` if not found
+ * @param	{Object}	input
+ * @param	{Array}		keys	property names to exclude
+ * @param	{Object}	output	(optional) to delete unwanted props from the original `input` use it here.
+ * 								Default: a copy of the `input` object
  *
- * @example Find item using predicate callback
- * ```typescript
- * import { find } from '@superutils/core'
+ * @returns {Object}
  *
- * const map = new Map<number, { name: string; age: number }>([
- * 	[1, { name: 'Alice', age: 30 }],
- * 	[2, { name: 'Bob', age: 25 }],
- * 	[3, { name: 'Charlie', age: 35 }],
- * ])
- * const result = mapFind(testMap, ({ name }) => name === 'Bob')
- * // result: { name: 'Bob', age: 25 }
+ * @example
+ * #### Create a new object excluding specific properties
+ *
+ * ```javascript
+ * import { objWithoutKeys } from '@superutils/core'
+ *
+ * const result = objWithoutKeys({ a: 1, b: '2', c: false }, ['b', 'c'])
+ * console.log(result) // { a: 1 }
  * ```
  *
- * @example Find item using search options
- * ```typescript
- * import { find } from '@superutils/core'
+ * @example
+ * #### Copy one object's properties to another while ignoring specific properties
  *
- * const map = new Map<number, { name: string; age: number }>([
- * 	[1, { name: 'Alice', age: 30 }],
- * 	[2, { name: 'Bob', age: 25 }],
- * 	[3, { name: 'Charlie', age: 35 }],
- * ])
- *	const result = mapFind(testmap, {
- *		query: 'Bob',
- *		key: 'name',
- *	})
- * // result: { name: 'Bob', age: 25 }
+ * ```javascript
+ * import { objWithoutKeys } from '@superutils/core'
+ *
+ * const source = { a: 1, b: '2', c: false }
+ * const dest = { d: 4, e: 5 }
+ * const result = objWithoutKeys(source, ['b', 'c'], dest)
+ * console.log(result) // { d: 4, e: 5, a: 1 }
+ * console.log(result === dest) // true
  * ```
  */
-declare function find<K, V extends Record<string, unknown>, IncludeKey extends boolean = false, Return = undefined | (IncludeKey extends true ? [K, V] : V)>(data: IterableList<K, V>, callback: Parameters<typeof filter<K, V>>[1]): Return;
-declare function find<K, V extends Record<string, unknown>, IncludeKey extends boolean = false, Return = undefined | (IncludeKey extends true ? [K, V] : V)>(data: IterableList<K, V>, options: FindOptions<K, V, IncludeKey>): Return;
-
-/** Map entries as array */
-declare const getEntries: <K, V>(map: Map<K, V>) => [K, V][];
+declare const objWithoutKeys: (input: unknown, keys: string[], output?: Record<PropertyKey, unknown>) => Record<PropertyKey, unknown>;
 
-/** Get {@link IterableList} keys as array */
-declare const getKeys: <K, V>(data: IterableList<K, V>) => K[];
+/**
+ * Sugar for `objReadOnly()` for an Array
+ *
+ * @param arr
+ * @param config (optional)
+ * @param config.add (optional) Whether to allow adding new properties. Default: `false`
+ * @param config.revocable (optional) Default: `false`
+ * @param config.silent (optional) Whether to throw error when a write operation is rejected. Default: `true`
+ *
+ * @returns Readonly Array or object containing readonly Array and revoke function
+ */
+declare const arrReadOnly: <T>(arr: T[], config?: Omit<ObjReadOnlyConfig<T[]>, "revoke">) => T[];
 
-/** Get size/length of Array/Map/Set */
-declare const getSize: (x: IterableList) => number;
+/**
+ * @ignore exclude from documentation
+ * Helper class for creating read-only arrays.
+ *
+ * Caution: This class can by itself only make the array partially read-only.
+ * Use {@link arrReadOnly} instead.
+ */
+declare class ReadOnlyArrayHelper<T> extends Array<T> {
+    readonly config: Omit<ObjReadOnlyConfig<T[]>, 'revoke'>;
+    constructor(config: Omit<ObjReadOnlyConfig<T[]>, 'revoke'>, arr: T[]);
+    private ignoreOrThrow;
+    pop: () => T;
+    push: (...items: T[]) => number;
+    reverse: () => this;
+    shift: () => T;
+    splice: (..._ignoredArgs: unknown[]) => never[];
+    unshift: (..._ignoredArgs: T[]) => number;
+}
 
-/** Get Map values as Array */
-declare const getValues: <K, V>(data: IterableList<K, V>) => V[];
+/**
+ * Reverse an array conditionally
+ *
+ * @param   arr
+ * @param	reverse	 (optional) condition to reverse the array. Default: `true`
+ * @param	newArray (optional) whether to cnstruct new array or use input. Default: `false`
+ *
+ * @returns array
+ */
+declare const arrReverse: <T = unknown>(arr: T[], reverse?: boolean, newArray?: boolean) => T[];
 
 /**
- * Reverse a {@link IterableList} (Array/Map/Set) conditionally
+ * Generate a Map from one or more arrays
  *
- * @param   data
- * @param	reverse	 (optional) condition to reverse the list. Default: `true`
- * @param	newInstance (optional) whether to return a new instance of the list. Default: `false`
+ * @param arr
+ * @param key (optional) Array object-item property name or a function to generate keys for each array items.
+ * @param flatDepth (optional) maximum recursion depth to flatten the array. Default: `0`
  *
- * @returns reversed data in original type or empty array for unsupported type
+ * @returns Converted Map
+ *
+ * @example
+ * #### Convert Array to Map
+ * ```typescript
+ * type Item = { a: number }
+ * const arr: Item[] = [{ a: 1 }, { a: 2 }, { a: 3 }, [{ a: 4 }]]
+ * const map: Map<number, Item> = arrToMap(
+ * 	   arr,
+ * 	   (_: Item, i: number) => item.a,
+ * )
+ * ```
+ *
+ * @example
+ * #### Flatten and convert Array to Map
+ * ```typescript
+ * type Item = { key: number; value: string }
+ * const arr: (Item | Item[])[] = [
+ * 	{ key: 1, value: 'a' },
+ * 	{ key: 2, value: 'b' },
+ * 	{ key: 3, value: 'c' },
+ * 	[{ key: 4, value: 'd' }],
+ * ]
+ * const map = arrToMap(arr, (item: Item) => item.key, 1) // Map<number, Item>
+ * ```
  */
-declare const reverse: <K, V, T extends IterableList<K, V>>(data: T, reverse?: boolean, newInstance?: boolean) => V[] | [K, V][] | Map<K, V> | Set<V> | (T & Record<"clear", unknown>);
+declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, KeyProp extends keyof MapItem = keyof MapItem>(arr: T, key: KeyProp, flatDepth?: FlatDepth): Map<MapItem[KeyProp], MapItem>;
+declare function arrToMap<T extends unknown[], FlatDepth extends number = 0>(arr: T, flatDepth?: FlatDepth): Map<number, FlatArray<T, FlatDepth>>;
+declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, MapKey = unknown>(arr: T, key: (item: MapItem, index: number, flatArr: MapItem[]) => MapKey, flatDepth?: FlatDepth): Map<MapKey, MapItem>;
+
+/**
+ * @function	arrUnique
+ * @summary		constructs a new array of unique values
+ */
+declare const arrUnique: <T = unknown>(arr: T[], flatDepth?: number) => FlatArray<T, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -1 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[];
+
+/**
+ * Debounce function options
+ */
+type DebounceOptions<ThisArg = unknown> = {
+    leading?: boolean | 'global';
+    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
+    thisArg?: ThisArg;
+    tid?: TimeoutId;
+};
+/**
+ * Deferred function options
+ */
+type DeferredOptions<ThisArg = unknown> = ({
+    throttle: true;
+} & ThrottleOptions<ThisArg>) | ({
+    throttle?: false;
+} & DebounceOptions<ThisArg>);
+/**
+ * Throttle function options
+ */
+type ThrottleOptions<ThisArg = unknown> = {
+    /**
+     *
+     * @param err Error object thrown by the callback function.
+     * @returns
+     */
+    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
+    thisArg?: ThisArg;
+    trailing?: boolean;
+    tid?: TimeoutId;
+};
 
 /**
- * A versatile utility for searching through an iterable list (Array, Map, or Set) of objects.
- * It supports both a global search (using a string or RegExp) across all properties of an item, and a
- * detailed, field-specific search using a query object.
- *
- * @param data The list of objects to search within. Compatible types include:
- * - `Array`
- * - `Map`
- * - `Set`
- * - `NodeList` (in DOM environments): `options.transform()` required
- * - `HTMLCollection` (in DOM environments): should accompany `options.transform()`
- * @param options The search criteria.
- * @param options.query The search query. Can be a string to search all fields, or an object for field-specific
- * @param options.ranked (optional) If `true`, the results are sorted by relevance (match index). Default: `false`.
- *
- * searches (e.g., `{ name: 'John', city: 'New York' }`).
- * @param options.asMap (optional) If `true`, returns a `Map`. If `false`, returns an `Array`. Default: `true`.
- * @param options.ignoreCase (optional) If `true`, performs a case-insensitive search for strings. Default: `true`.
- * @param options.limit (optional) The maximum number of results to return. Default: `Infinity`.
- * @param options.matchAll (optional) If `true`, an item must match all key-value pairs in the `query` object. If
- * `false`, it matches if at least one pair is found. Default: `false`.
- * @param options.matchExact (optional) If `true`, performs an exact match. If `false`, performs a partial match
- * (i.e., `includes()`). Default: `false`.
- * @param options.result (optional) An optional `Map` to which the results will be added.
- * @param options.transform (optional) Callback to transform item/item-property to string
+ * Returns a function that invokes the callback function after certain delay/timeout.
+ * All errors will be gracefully swallowed.
  *
- * @returns A `Map` or an `Array` containing the matched items, based on the `asMap` option.
+ * @param callback 	function to be invoked after timeout
+ * @param delay		(optional) timeout duration in milliseconds. Default: 50
+ * @param config.onError (optional)
+ * @param config.leading (optional) if true, will enable leading-edge debounce mechanism.
+ * @param config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
+ * @param config.tid	   (optional) Timeout Id. If provided, will clear the timeout on first invocation.
  *
  * @example
- * ```typescript
- * const users = [
- *   { id: 1, name: 'John Doe', city: 'New York' },
- *   { id: 2, name: 'Jane Doe', city: 'London' },
- *   { id: 3, name: 'Peter Jones', city: 'New York' },
- * ];
+ * #### Debounce function calls
+ * ```javascript
+ * import { debounce } from '@superutils/core'
  *
- * // Simple string search (case-insensitive, partial match by default)
- * const doeUsers = search(users, { query: 'doe' });
- * // Returns: [{ id: 1, ... }, { id: 2, ... }]
+ * const handleChange = debounce(
+ *     event => console.log('Value:', event.target.value),
+ *     300 // debounce delay in milliseconds
+ * )
  *
- * // Field-specific search, requiring all fields to match
- * const peterInNY = search(users, {
- *   query: { name: 'Peter', city: 'New York' },
- *   matchAll: true,
- * });
- * // Returns: [{ id: 3, ... }]
+ * handleChange({ target: { value: 1 } }) // will be ignored
+ * handleChange({ target: { value: 2 } }) // will be ingored
+ * handleChange({ target: { value: 3 } }) // will be invoked
  * ```
  */
-declare const search: {
-    <K, V, MatchExact extends boolean = false, AsMap extends boolean = true, Result = AsMap extends true ? Map<K, V> : V[]>(data: IterableList<K, V>, options: SearchOptions<K, V, MatchExact, AsMap>): Result;
-    defaults: Pick<Required<SearchOptions<unknown, unknown, false, true>>, "matchAll" | "limit" | "asMap" | "ignoreCase" | "ranked" | "transform">;
+declare const debounce: {
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DebounceOptions<ThisArg>): (...args: TArgs) => void;
+    defaults: {
+        /**
+         * Set the default value of argument `leading` for the `deferred` function.
+         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+         */
+        leading: false;
+        /**
+         * Set the default value of argument `onError` for the `deferred` function.
+         * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+         */
+        onError: undefined;
+    };
 };
+
 /**
- * Utility for use with {@link search} function
+ * Returns a function that can be used to debounce/throttle calls to the provided callback function.
+ * All errors will be gracefully swallowed. See {@link debounce} and {@link throttle} for more information.
  *
- * @returns match index (`-1` means didn't match)
+ * @param callback function to be invoked after delay
+ * @param delay (optional) delay duration in milliseconds. Default: `50`
+ * @param config (optional) debounce or throttle configuration options
+ *
+ * @returns Callback function that can be invoked in one of the following 2 methods:
+ * - debounced: when `throttle` is `false` or `undefined`
+ * - throttled: when `throttle` is `true`
  */
-declare function matchObjOrProp<K, V>(// extends Record<string, unknown>
-{ query, ignoreCase, matchExact, transform, }: Pick<SearchOptions<K, V, boolean>, 'transform' | 'query' | 'ignoreCase' | 'matchExact'>, item: V, propertyName?: string): number;
+declare const deferred: <TArgs extends unknown[], ThisArg, Delay = unknown>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: Delay, config?: DeferredOptions<ThisArg>) => (...args: TArgs) => void;
 
-type SliceMapTransform<Data, Value, Key> = (item: Value, key: Key, data: Data) => Value;
-type SliceMapOptions<Data, Value, Key, AsMap extends boolean = false> = {
-    /** Whether to return the result as a Map (preserving original keys) or an Array */
-    asMap?: AsMap;
-    /** Callback to transform each item from the selected range */
-    transform?: SliceMapTransform<Data, Value, Key>;
-    /** End index (exclusive). Default: `undefined` (end of the list) */
-    end?: number;
-    /** Whether to exclude item if value is `undefined | null` */
-    ignoreEmpty?: boolean;
-    /** Start index. Default: `0` */
-    start?: number;
-};
 /**
- * Slice an iterable list and map the values into an Array/Map.
- *
- * @param data		Array, Map, Set...
- * @param options	One of the following is required to create a new list:
- * 1. A callback function {@link SliceMapTransform} to transform all items.
- * 2. Advanced options {@link SliceMapOptions}.
- * @param options.asMap	(optional) whether return a Map or Array.
- * @param options.end	(optional) End index (exclusive). Default: `undefined` (end of the list)
- * @param options.ignoreEmpty (optional) Whether to exclude item if value is `undefined | null`
- * @param options.start	(optional) Default: `0`
- * @param options.transform	(optional)
+ * Returns a throttled function that ensures the callback is invoked at most once in the specified delay interval.
+ * All errors will be gracefully swallowed.
  *
- * If callback throws error or returnes `undefined`, the item will be ignored.
+ * If the throttled function is called multiple times during the delay interval, only the first call will invoke the callback immediately.
  *
- * Callback Params:
- *   - item: current item
- *   - key: index/key of the current item
- *   - data: original list
+ * If `trailing` is enabled and if returned function is invoked more than once during the delay interval,
+ * the callback runs again at the end of the delay with the most recent arguments.
  *
- * @returns Array/Map
+ * @param callback function to be invoked after timeout
+ * @param delay (optional) interval duration in milliseconds. Default: 50
+ * @param config (optional)
+ * @param config.onError (optional) callback to be invoked on error
+ * @param config.tid (optional)
+ * @param config.thisArg (optional) the special `thisArgs` to be used when invoking the callback.
+ * @param config.trailing (optional) whether to enable trailing edge execution. Default: `true`
  *
  * @example
+ * #### Throttle function calls
  * ```javascript
- * const data = new Map([
- * 	[0, { age: 30, name: 'Alice' }],
- * 	[1, { age: 25, name: 'Bob' }],
- * 	[2, undefined],
- * 	[3, {}],
- * 	[4, { age: 35, name: 'Charlie' }],
- * 	[5, { age: 28, name: 'Dave' }],
- * 	[6, { age: 22, name: 'Eve' }],
- * ])
- * const result = sliceMap(data, {
- * 	asMap: false, // whether to return the result as a Map
- * 	end: 5, // last index (exclusive)
- * 	ignoreEmpty: true, // ignore items with no value
- * 	start: 1, // first index
- * })
- * console.log(result)
- * // [ { age: 25, name: 'Bob' }, { age: 35, name: 'Charlie' } ]
- * ```
- */
-declare const sliceMap: <Data extends IterableList, Key = Data extends IterableList<infer Key_1, unknown> ? Key_1 : never, Value = Data extends IterableList<unknown, infer Value_1> ? Value_1 : never, AsMap extends boolean = false, Result = AsMap extends false ? Value[] : Map<Key, Value>>(data: Data, options?: SliceMapOptions<Data, Value, Key, AsMap> | SliceMapTransform<Data, Value, Key>) => Result;
-
-type EntryComparator<K, V> = (a: [K, V], b: [K, V]) => number;
-type ArrayComparator<V> = (a: V, b: V) => number;
-/**
- * Sort iterable lists (Array/Map/Set).
- *
+ * import { throttle } from '@superutils/core'
  *
- * @param data
- * @param propertyName Accepted values:
- * - `string`: value object property name
- * - `function`: comparator function. Recommended for performance.
- * - `true`: indicates to sort by Map keys instead of values.
- * @param options (optional) extra sorting opitons
- * @param options.ignoreCase	(optional) case-insensitive sort for strings. Default: `true`
- * @param options.reverse (optional) True: accending sort. False: descending sort. Default: `false`
- * @param options.undefinedFirst (optional) Where to place undefined/null values.
- * Not avaible when `comparator` function is used.
- * - `true`: at the beginning
- * - `false`: at the end
+ * const handleChange = throttle(
+ *     event => console.log('Value:', event.target.value),
+ *     300, // throttle duration in milliseconds
+ * )
+ * handleChange({ target: { value: 1 } }) // will be executed
+ * handleChange({ target: { value: 2 } }) // will be ignored
+ * handleChange({ target: { value: 3 } }) // will be ignored
  *
- * Default: `false`
+ * setTimeout(() => {
+ *    handleChange({ target: { value: 4 } }) // will be executed (after 300ms)
+ *    handleChange({ target: { value: 5 } }) // will be ignored
+ * }, 400)
+ * ```
  *
- * @returns sorted map
+ * @example
+ * #### Throttle with trailing enabled
+ * ```javascript
+ * import { throttle } from '@superutils/core'
  *
- * @example sort map of simple values (string/number/boolean)
- * ```typescript
- * import { sort } from '@superutils/core'
- * const map = new Map([
- * 	   [1, 1],
- * 	   [2, 2],
- *     [0, 0],
- * ])
- * sort(map)
- * // result: Map(3) { 0 => 0, 1 => 1, 2 => 2 }
- * ```
+ * const handleChange = throttle(
+ *     event => console.log('Value:', event.target.value),
+ *     300, // throttle duration in milliseconds
+ * )
+ * handleChange({ target: { value: 1 } }) // will be executed
+ * handleChange({ target: { value: 2 } }) // will be ignored
+ * handleChange({ target: { value: 3 } }) //  will be executed
  *
- * @example sort map of objects
- * ```typescript
- * import { sort } from '@superutils/core'
- * const map = new Map([
- *     [0, { name: 'Charlie' }],
- *     [1, { name: 'Alice' }],
- *     [2, { name: 'Bob' }],
- * ])
- * sort(map, 'name')
- * // result: Map(3) {
- * //   1 => { name: 'Alice' },
- * //   2 => { name: 'Bob' },
- * //   0 => { name: 'Charlie' }
- * // }
+ * setTimeout(() => {
+ *    handleChange({ target: { value: 4 } }) // will be executed
+ *    handleChange({ target: { value: 5 } }) // will be ignored
+ * }, 400)
  * ```
  */
-declare function sort<K, V extends Record<PropertyKey, unknown>, T extends IterableList<K, V>>(data: T, propertyName: keyof V & string, options?: SortOptions): T;
-/** Sort `Map` by map-keys `K` */
-declare function sort<K, V>(data: Map<K, V>, byKey: true, options?: SortOptions): Map<K, V>;
-/** Sort `Map` with comparator function */
-declare function sort<K, V>(map: Map<K, V>, comparator: EntryComparator<K, V>, options?: SortOptions): Map<K, V>;
-/** Sort `Array` with comparator function */
-declare function sort<V>(array: V[], comparator: ArrayComparator<V>, options?: SortOptions): V[];
-/** Sort `Set` with comparator function */
-declare function sort<V>(set: Set<V>, comparator: ArrayComparator<V>, options?: SortOptions): Set<V>;
-/** Sort Array/Map/Set with `string | boolean | number` values */
-declare function sort<K, V extends string | boolean | number, T extends IterableList<K, V>>(data: T, options?: SortOptions): T;
-declare namespace sort {
-    var defaults: {
-        ignoreCase: true;
-        newInstance: false;
-        reverse: false;
-        undefinedFirst: false;
+declare const throttle: {
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
+    /**
+     * Set the default values
+     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
+     */
+    defaults: {
+        onError: undefined;
+        trailing: false;
     };
-}
+};
+/**
+ * For legacy compatibility
+ * @deprecated use `throttle` instead
+ */
+declare const throttled: {
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
+    /**
+     * Set the default values
+     * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
+     */
+    defaults: {
+        onError: undefined;
+        trailing: false;
+    };
+};
 
 /**
  * Creates a new Map by combining two or more Maps
@@ -1437,27 +1679,26 @@ declare namespace sort {
  *
  * @returns new combined Map
  *
- * @example Join two Maps
- * ```typescript
+ * @example
+ * #### Join two Maps
+ * ```javascript
  * import { mapJoin } from '@superutils/core'
  *
- * const maps = [
- * 	new Map([['a', 1]]),
- * 	new Map([['b', 2]]),
- * ]
- * const joined = mapJoin(...maps)
+ * const map1 = new Map([['a', 1]])
+ * const map2 = new Map([['b', 2]])
+ * console.log(mapJoin(map1, map2))
  * // Result: Map(2) {'a' => 1, 'b' => 2}
  * ```
  *
- * @example Join entries and Maps into a single Map
- * ```typescript
+ * @example
+ * #### Join entries and Maps into a single Map
+ * ```javascript
  * import { mapJoin } from '@superutils/core'
  *
- * const joined = mapJoin(
- * 	new Map([['a', 1]]),
- * 	[['b', 2]],
- * 	new Map([['c', 3]]),
- * )
+ * const map1 = new Map([['a', 1]])
+ * const entries = [['b', 2], ['c', 2]]
+ * const map2 =	new Map([['c', 3]])
+ * console.log(mapJoin(map1, entries, map2))
  * // Result: Map(2) {'a' => 1, 'b' => 2, 'c' => 3}
  * ```
  */
@@ -1558,4 +1799,4 @@ declare const HASH_REGEX: RegExp;
  */
 declare const strToArr: (value: unknown, seperator?: string) => string[];
 
-export { type ArrayComparator, type AsyncFn, type CreateTuple, type CurriedArgs, type Curry, type DebounceOptions, type DeferredOptions, type DropFirst, type DropFirstN, type DropLast, EMAIL_REGEX, type EntryComparator, type FindOptions, type FiniteNumber, HASH_REGEX, HEX_REGEX, type IfPromiseAddValue, type Integer, type IsFiniteTuple, type IsOptional, type IterableList, type KeepFirst, type KeepFirstN, type KeepOptionals, type KeepRequired, type MakeOptional, type MinLength, type NegativeInteger, type NegativeNumber, type OptionalIf, type PositiveInteger, type PositiveNumber, type ReadOnlyAllowAddFn, ReadOnlyArrayHelper, type ReadOnlyConfig, type SearchOptions, type Slice, type SliceMapOptions, type SliceMapTransform, type SortOptions, type ThrottleOptions, type TimeoutId, type TupleMaxLength, type TupleWithAlt, type ValueOrFunc, type ValueOrPromise, arrReadOnly, arrReverse, arrToMap, arrUnique, clearClutter, copyToClipboard, curry, debounce, deferred, fallbackIfFails, filter, find, getEntries, getKeys, getSize, getUrlParam, getValues, is, isArr, isArr2D, isArrLike, isArrLikeSafe, isArrObj, isArrUnique, isAsyncFn, isBool, isDate, isDateValid, isDefined, isEmpty, isEmptySafe, isEnvBrowser, isEnvNode, isEnvTouchable, isError, isFn, isInteger, isMap, isMapObj, isNegativeInteger, isNegativeNumber, isNumber, isObj, isPositiveInteger, isPositiveNumber, isPromise, isRegExp, isSet, isStr, isSubjectLike, isSymbol, isUint8Arr, isUrl, isUrlValid, mapJoin, matchObjOrProp, noop, noopAsync, objClean, objCopy, objCreate, objHasKeys, objKeys, objReadOnly, objSetProp, objSetPropUndefined, objSort, objWithoutKeys, randomInt, reverse, search, sliceMap, sort, strToArr, throttle, throttled, toDatetimeLocal };
+export { type ArrayComparator, type AsyncFn, type CreateTuple, type CurriedArgs, type Curry, type DebounceOptions, type DeferredOptions, type DropFirst, type DropFirstN, type DropLast, EMAIL_REGEX, type EntryComparator, type FindOptions, type FiniteNumber, HASH_REGEX, HEX_REGEX, type IfPromiseAddValue, type Integer, type IsFiniteTuple, type IsOptional, type IterableList, type KeepFirst, type KeepFirstN, type KeepOptionals, type KeepRequired, type MakeOptional, type MinLength, type NegativeInteger, type NegativeNumber, type ObjReadOnlyAllowAddFn, type ObjReadOnlyConfig, type OptionalIf, type PositiveInteger, type PositiveNumber, ReadOnlyArrayHelper, type SearchOptions, type SetObPropPredicate, type Slice, type SliceMapOptions, type SliceMapTransform, type SortOptions, type ThrottleOptions, type TimeoutId, type TupleMaxLength, type TupleWithAlt, type ValueOrFunc, type ValueOrPromise, arrReadOnly, arrReverse, arrToMap, arrUnique, clearClutter, copyToClipboard, curry, debounce, deferred, fallbackIfFails, filter, find, getEntries, getKeys, getSize, getUrlParam, getValues, is, isArr, isArr2D, isArrLike, isArrLikeSafe, isArrObj, isArrUnique, isAsyncFn, isBool, isDate, isDateValid, isDefined, isEmpty, isEmptySafe, isEnvBrowser, isEnvNode, isEnvTouchable, isError, isFn, isInteger, isMap, isMapObj, isNegativeInteger, isNegativeNumber, isNumber, isObj, isPositiveInteger, isPositiveNumber, isPromise, isRegExp, isSet, isStr, isSubjectLike, isSymbol, isUint8Arr, isUrl, isUrlValid, mapJoin, matchObjOrProp, noop, noopAsync, objClean, objCopy, objCreate, objHasKeys, objKeys, objReadOnly, objSetProp, objSetPropUndefined, objSort, objWithoutKeys, randomInt, reverse, search, sliceMap, sort, strToArr, throttle, throttled, toDatetimeLocal };