es-toolkit 1.17.0 → 1.18.0-dev.573

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # es-toolkit Changelog
 
+## Version v1.18.0
+
+Released on September 12th, 2024.
+
+- Added support for [isObject](https://es-toolkit.slash.page/reference/compat/predicate/isObject.html), [findLastIndex](https://es-toolkit.slash.page/reference/compat/array/findLastIndex.html), [parseInt](https://es-toolkit.slash.page/reference/compat/math/parseInt.html), [rearg](https://es-toolkit.slash.page/reference/compat/function/rearg.html), [conforms](https://es-toolkit.slash.page/reference/compat/predicate/conforms.html), [conformsTo](https://es-toolkit.slash.page/reference/compat/predicate/conformsTo.html), [bindKey](https://es-toolkit.slash.page/reference/compat/function/bindKey.html), [some](https://es-toolkit.slash.page/reference/compat/array/some.html), [fromPairs](https://es-toolkit.slash.page/reference/compat/object/fromPairs.html), [isArrayLikeObject](https://es-toolkit.slash.page/reference/compat/predicate/isArrayLikeObject.html), [escapeRegExp](https://es-toolkit.slash.page/reference/string/escapeRegExp.html), [sortBy](https://es-toolkit.slash.page/reference/array/sortBy.html), [isWeakSet](https://es-toolkit.slash.page/reference/predicate/isWeakSet.html), [isWeakMap](https://es-toolkit.slash.page/reference/predicate/isWeakMap.html), [flatMapDeep](https://es-toolkit.slash.page/reference/array/flatMapDeep.html), [escape](https://es-toolkit.slash.page/reference/string/escape.html), [unescape](https://es-toolkit.slash.page/reference/string/unescape.html), [repeat](https://es-toolkit.slash.page/reference/compat/string/repeat.html), [pad](https://es-toolkit.slash.page/reference/compat/string/pad.html), [join](https://es-toolkit.slash.page/reference/compat/array/join.html), and [spread](https://es-toolkit.slash.page/reference/compat/function/spread.html).
+- Improved performance for [deburr](https://es-toolkit.slash.page/reference/string/deburr.html).
+
 ## Version v1.17.0
 
 Released on August 31st, 2024.

package/README.md

@@ -1,6 +1,6 @@
 ![](./docs/public/og.png)
 
-# es-toolkit · [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/es-toolkit/graph/badge.svg?token=8N5S3AR3C7)](https://codecov.io/gh/toss/es-toolkit) [![NPM badge](https://img.shields.io/npm/v/es-toolkit?logo=npm)](https://www.npmjs.com/package/es-toolkit) [![JSR badge](https://jsr.io/badges/@es-toolkit/es-toolkit)](https://jsr.io/@es-toolkit/es-toolkit)
+# es-toolkit · [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/es-toolkit/graph/badge.svg?token=8N5S3AR3C7)](https://codecov.io/gh/toss/es-toolkit) [![NPM badge](https://img.shields.io/npm/v/es-toolkit?logo=npm)](https://www.npmjs.com/package/es-toolkit) [![JSR badge](https://jsr.io/badges/@es-toolkit/es-toolkit)](https://jsr.io/@es-toolkit/es-toolkit) [![Discord Badge](https://discord.com/api/guilds/1281071127052943361/widget.png?style=shield)](https://discord.gg/vGXbVjP2nY)
 
 English | [한국어](https://github.com/toss/es-toolkit/blob/main/README-ko_kr.md) | [简体中文](https://github.com/toss/es-toolkit/blob/main/README-zh_hans.md) | [日本語](https://github.com/toss/es-toolkit/blob/main/README-ja_jp.md)
 

package/dist/_chunk/{index-CoqN5B.js → index-BGZDR9.js}

@@ -26,7 +26,10 @@ function delay(ms, { signal } = {}) {
         if (signal?.aborted) {
             return abortError();
         }
-        const timeoutId = setTimeout(resolve, ms);
+        const timeoutId = setTimeout(() => {
+            signal?.removeEventListener('abort', abortHandler);
+            resolve();
+        }, ms);
         signal?.addEventListener('abort', abortHandler, { once: true });
     });
 }

package/dist/_chunk/{isTypedArray-BBEkFl.js → isTypedArray-Dsrnb1.js}

@@ -25,17 +25,7 @@ function isPrimitive(value) {
 }
 
 function isTypedArray(x) {
-    return (x instanceof Uint8Array ||
-        x instanceof Uint8ClampedArray ||
-        x instanceof Uint16Array ||
-        x instanceof Uint32Array ||
-        x instanceof BigUint64Array ||
-        x instanceof Int8Array ||
-        x instanceof Int16Array ||
-        x instanceof Int32Array ||
-        x instanceof BigInt64Array ||
-        x instanceof Float32Array ||
-        x instanceof Float64Array);
+    return ArrayBuffer.isView(x) && !(x instanceof DataView);
 }
 
 exports.isPlainObject = isPlainObject;

package/dist/_chunk/{isFunction-aCEz9d.js → isWeakSet-BerD1A.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const isTypedArray = require('./isTypedArray-BBEkFl.js');
+const isTypedArray = require('./isTypedArray-Dsrnb1.js');
 
 const regexpTag = '[object RegExp]';
 const stringTag = '[object String]';
@@ -215,7 +215,7 @@ function isNil(x) {
 }
 
 function isNotNil(x) {
-    return x !== null && x !== undefined;
+    return x != null;
 }
 
 function isNull(x) {
@@ -234,6 +234,14 @@ function isFunction(value) {
     return typeof value === 'function';
 }
 
+function isWeakMap(value) {
+    return value instanceof WeakMap;
+}
+
+function isWeakSet(value) {
+    return value instanceof WeakSet;
+}
+
 exports.argumentsTag = argumentsTag;
 exports.booleanTag = booleanTag;
 exports.getTag = getTag;
@@ -244,5 +252,7 @@ exports.isNil = isNil;
 exports.isNotNil = isNotNil;
 exports.isNull = isNull;
 exports.isUndefined = isUndefined;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;
 exports.numberTag = numberTag;
 exports.stringTag = stringTag;

package/dist/_chunk/rest-CXt9w3.js

@@ -0,0 +1,182 @@
+'use strict';
+
+function before(n, func) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error('n must be a non-negative integer.');
+    }
+    let counter = 0;
+    return ((...args) => {
+        if (++counter < n) {
+            return func(...args);
+        }
+        return undefined;
+    });
+}
+
+function after(n, func) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`n must be a non-negative integer.`);
+    }
+    let counter = 0;
+    return ((...args) => {
+        if (++counter >= n) {
+            return func(...args);
+        }
+        return undefined;
+    });
+}
+
+function debounce(func, debounceMs, { signal } = {}) {
+    let timeoutId = null;
+    const debounced = function (...args) {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        if (signal?.aborted) {
+            return;
+        }
+        timeoutId = setTimeout(() => {
+            func(...args);
+            timeoutId = null;
+        }, debounceMs);
+    };
+    const onAbort = function () {
+        debounced.cancel();
+    };
+    debounced.cancel = function () {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    return debounced;
+}
+
+function noop() { }
+
+function once(func) {
+    let called = false;
+    let cache;
+    return function () {
+        if (called) {
+            return cache;
+        }
+        const result = func();
+        called = true;
+        cache = result;
+        return result;
+    };
+}
+
+function throttle(func, throttleMs) {
+    let lastCallTime;
+    const throttledFunction = function (...args) {
+        const now = Date.now();
+        if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+            lastCallTime = now;
+            func(...args);
+        }
+    };
+    return throttledFunction;
+}
+
+function negate(func) {
+    return ((...args) => !func(...args));
+}
+
+function memoize(fn, options = {}) {
+    const { cache = new Map(), getCacheKey } = options;
+    const memoizedFn = function (arg) {
+        const key = getCacheKey ? getCacheKey(arg) : arg;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn.call(this, arg);
+        cache.set(key, result);
+        return result;
+    };
+    memoizedFn.cache = cache;
+    return memoizedFn;
+}
+
+function ary(func, n) {
+    return function (...args) {
+        return func.apply(this, args.slice(0, n));
+    };
+}
+
+function unary(func) {
+    return ary(func, 1);
+}
+
+function partial(func, ...partialArgs) {
+    return function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === partial.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        return func.apply(this, args);
+    };
+}
+const partialPlaceholder = Symbol('partial.placeholder');
+partial.placeholder = partialPlaceholder;
+
+function partialRight(func, ...partialArgs) {
+    return function (...providedArgs) {
+        const placeholderLength = partialArgs.filter(arg => arg === partialRightPlaceholder).length;
+        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+        const args = [];
+        let providedIndex = 0;
+        for (let i = 0; i < rangeLength; i++) {
+            args.push(providedArgs[providedIndex++]);
+        }
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === partialRight.placeholder) {
+                args.push(providedArgs[providedIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        return func.apply(this, args);
+    };
+}
+const partialRightPlaceholder = Symbol('partialRight.placeholder');
+partialRight.placeholder = partialRightPlaceholder;
+
+function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}
+
+exports.after = after;
+exports.ary = ary;
+exports.before = before;
+exports.debounce = debounce;
+exports.memoize = memoize;
+exports.negate = negate;
+exports.noop = noop;
+exports.once = once;
+exports.partial = partial;
+exports.partialRight = partialRight;
+exports.rest = rest;
+exports.throttle = throttle;
+exports.unary = unary;

package/dist/_chunk/{toMerged-BGwYW5.js → toMerged-DN1PPP.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const isTypedArray = require('./isTypedArray-BBEkFl.js');
+const isTypedArray = require('./isTypedArray-Dsrnb1.js');
 
 function omit(obj, keys) {
     const result = { ...obj };

package/dist/_chunk/{initial-Ci2bn_.js → zipWith-CYaH1Y.js}

@@ -125,6 +125,14 @@ function flatMap(arr, iteratee, depth = 1) {
     return flatten(arr.map(item => iteratee(item)), depth);
 }
 
+function flattenDeep(arr) {
+    return flatten(arr, Infinity);
+}
+
+function flatMapDeep(arr, iteratee) {
+    return flattenDeep(arr.map((item) => iteratee(item)));
+}
+
 function forEachRight(arr, callback) {
     for (let i = arr.length - 1; i >= 0; i--) {
         const element = arr[i];
@@ -144,6 +152,14 @@ function groupBy(arr, getKeyFromItem) {
     return result;
 }
 
+function head(arr) {
+    return arr[0];
+}
+
+function initial(arr) {
+    return arr.slice(0, -1);
+}
+
 function intersection(firstArr, secondArr) {
     const secondSet = new Set(secondArr);
     return firstArr.filter(item => {
@@ -164,6 +180,10 @@ function intersectionWith(firstArr, secondArr, areItemsEqual) {
     });
 }
 
+function isSubset(superset, subset) {
+    return difference(subset, superset).length === 0;
+}
+
 function keyBy(arr, getKeyFromItem) {
     const result = {};
     for (const item of arr) {
@@ -173,6 +193,10 @@ function keyBy(arr, getKeyFromItem) {
     return result;
 }
 
+function last(arr) {
+    return arr[arr.length - 1];
+}
+
 function maxBy(items, getValue) {
     let maxElement = items[0];
     let max = -Infinity;
@@ -199,34 +223,6 @@ function minBy(items, getValue) {
     return minElement;
 }
 
-function compareValues(a, b, order) {
-    if (a < b) {
-        return order === 'asc' ? -1 : 1;
-    }
-    if (a > b) {
-        return order === 'asc' ? 1 : -1;
-    }
-    return 0;
-}
-
-function orderBy(arr, criteria, orders) {
-    return arr.slice().sort((a, b) => {
-        const ordersLength = orders.length;
-        for (let i = 0; i < criteria.length; i++) {
-            const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
-            const criterion = criteria[i];
-            const criterionIsFunction = typeof criterion === 'function';
-            const valueA = criterionIsFunction ? criterion(a) : a[criterion];
-            const valueB = criterionIsFunction ? criterion(b) : b[criterion];
-            const result = compareValues(valueA, valueB, order);
-            if (result !== 0) {
-                return result;
-            }
-        }
-        return 0;
-    });
-}
-
 function partition(arr, isInTruthy) {
     const truthy = [];
     const falsy = [];
@@ -250,10 +246,6 @@ function pullAt(arr, indicesToRemove) {
     return removed;
 }
 
-function sortBy(arr, criteria) {
-    return orderBy(arr, criteria, ['asc']);
-}
-
 function sample(arr) {
     const randomIndex = Math.floor(Math.random() * arr.length);
     return arr[randomIndex];
@@ -285,6 +277,10 @@ function shuffle(arr) {
     return result;
 }
 
+function tail(arr) {
+    return arr.slice(1);
+}
+
 function take(arr, count) {
     return arr.slice(0, count);
 }
@@ -316,6 +312,17 @@ function takeWhile(arr, shouldContinueTaking) {
     return result;
 }
 
+function toFilled(arr, value, start = 0, end = arr.length) {
+    const length = arr.length;
+    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+    const newArr = arr.slice();
+    for (let i = finalStart; i < finalEnd; i++) {
+        newArr[i] = value;
+    }
+    return newArr;
+}
+
 function uniq(arr) {
     return Array.from(new Set(arr));
 }
@@ -391,6 +398,11 @@ function unzipWith(target, iteratee) {
     return result;
 }
 
+function without(array, ...values) {
+    const valuesSet = new Set(values);
+    return array.filter(item => !valuesSet.has(item));
+}
+
 function xor(arr1, arr2) {
     return difference(union(arr1, arr2), intersection(arr1, arr2));
 }
@@ -440,42 +452,6 @@ function zipWith(arr1, ...rest) {
     return result;
 }
 
-function without(array, ...values) {
-    const valuesSet = new Set(values);
-    return array.filter(item => !valuesSet.has(item));
-}
-
-function head(arr) {
-    return arr[0];
-}
-
-function isSubset(superset, subset) {
-    return difference(subset, superset).length === 0;
-}
-
-function tail(arr) {
-    return arr.slice(1);
-}
-
-function toFilled(arr, value, start = 0, end = arr.length) {
-    const length = arr.length;
-    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
-    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
-    const newArr = arr.slice();
-    for (let i = finalStart; i < finalEnd; i++) {
-        newArr[i] = value;
-    }
-    return newArr;
-}
-
-function last(arr) {
-    return arr[arr.length - 1];
-}
-
-function initial(arr) {
-    return arr.slice(0, -1);
-}
-
 exports.at = at;
 exports.chunk = chunk;
 exports.compact = compact;
@@ -489,7 +465,9 @@ exports.dropRightWhile = dropRightWhile;
 exports.dropWhile = dropWhile;
 exports.fill = fill;
 exports.flatMap = flatMap;
+exports.flatMapDeep = flatMapDeep;
 exports.flatten = flatten;
+exports.flattenDeep = flattenDeep;
 exports.forEachRight = forEachRight;
 exports.groupBy = groupBy;
 exports.head = head;
@@ -502,13 +480,11 @@ exports.keyBy = keyBy;
 exports.last = last;
 exports.maxBy = maxBy;
 exports.minBy = minBy;
-exports.orderBy = orderBy;
 exports.partition = partition;
 exports.pullAt = pullAt;
 exports.sample = sample;
 exports.sampleSize = sampleSize;
 exports.shuffle = shuffle;
-exports.sortBy = sortBy;
 exports.tail = tail;
 exports.take = take;
 exports.takeRight = takeRight;

package/dist/array/countBy.d.mts

@@ -14,6 +14,16 @@
  * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
  * @returns {Record<K, number>} An object containing the transformed items as keys and the
  * counts as values.
+ *
+ * @example
+ * const array = ['a', 'b', 'c', 'a', 'b', 'a'];
+ * const result = countBy(array, x => x);
+ * // result will be { a: 3, b: 2, c: 1 }
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
+ * // result will be { odd: 3, even: 2 }
  */
 declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T) => K): Record<K, number>;
 

package/dist/array/countBy.d.ts

@@ -14,6 +14,16 @@
  * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
  * @returns {Record<K, number>} An object containing the transformed items as keys and the
  * counts as values.
+ *
+ * @example
+ * const array = ['a', 'b', 'c', 'a', 'b', 'a'];
+ * const result = countBy(array, x => x);
+ * // result will be { a: 3, b: 2, c: 1 }
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
+ * // result will be { odd: 3, even: 2 }
  */
 declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T) => K): Record<K, number>;
 

package/dist/array/fill.d.mts

@@ -1,3 +1,58 @@
+/**
+ * Fills the whole array with a specified value.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T>(array: unknown[], value: T): T[];
+/**
+ * Fills elements of an array with a specified value from the start position up to the end of the array.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @param {number} [start=0] - The start position. Defaults to 0.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;
 /**
  * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
  *
@@ -26,8 +81,6 @@
  * const result = fill(array, '*', -2, -1);
  * // => [1, '*', 3]
  */
-declare function fill<T>(array: unknown[], value: T): T[];
-declare function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;
 declare function fill<T, U>(array: Array<T | U>, value: U, start: number, end: number): Array<T | U>;
 
 export { fill };

package/dist/array/fill.d.ts

@@ -1,3 +1,58 @@
+/**
+ * Fills the whole array with a specified value.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T>(array: unknown[], value: T): T[];
+/**
+ * Fills elements of an array with a specified value from the start position up to the end of the array.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @param {number} [start=0] - The start position. Defaults to 0.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;
 /**
  * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
  *
@@ -26,8 +81,6 @@
  * const result = fill(array, '*', -2, -1);
  * // => [1, '*', 3]
  */
-declare function fill<T>(array: unknown[], value: T): T[];
-declare function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;
 declare function fill<T, U>(array: Array<T | U>, value: U, start: number, end: number): Array<T | U>;
 
 export { fill };

package/dist/array/flatMapDeep.d.mts

@@ -0,0 +1,18 @@
+import { ExtractNestedArrayType } from './flattenDeep.mjs';
+
+/**
+ * Recursively maps each element in an array using a provided iteratee function and then deeply flattens the resulting array.
+ *
+ * @template T - The type of elements within the array.
+ * @template U - The type of elements within the returned array from the iteratee function.
+ * @param {T[]} arr - The array to flatten.
+ * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @returns {Array<ExtractNestedArrayType<U>>} A new array that has been flattened.
+ *
+ * @example
+ * const result = flatMapDeep([1, 2, 3], n => [[n, n]]);
+ * // [1, 1, 2, 2, 3, 3]
+ */
+declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T) => U): Array<ExtractNestedArrayType<U>>;
+
+export { flatMapDeep };