es-toolkit 1.48.1-dev.1889 → 1.48.1-dev.1894

package/dist/fp/pipe.js

@@ -0,0 +1,116 @@
+//#region src/fp/pipe.ts
+/**
+* Performs left-to-right function composition, threading `value` through each
+* function in sequence. Every function receives the output of the previous
+* one, so the data flows top-to-bottom in the same order it is read. This
+* turns deeply nested calls into clear, sequential steps without temporary
+* variables.
+*
+* This is the entry point of `es-toolkit/fp`. Each `es-toolkit/fp` function is
+* called with its configuration (e.g. `map(fn)`, `take(2)`) and returns a
+* function that takes the data, which `pipe` then supplies.
+*
+* When consecutive **lazy-capable** functions (`map`, `filter`, `take`, ...)
+* appear together, `pipe` fuses them and processes the input element-by-element
+* instead of building an intermediate array after every step. This allows
+* early termination: a trailing `take(n)` stops the walk as soon as `n`
+* results exist, so the remaining input is never visited.
+*
+* @param value - The initial value fed into the pipe.
+* @param functions - Data-last operators (or any unary functions) applied in order.
+* @returns The result of applying every function, left to right.
+*
+* @example
+* import { pipe, map, filter, take } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], map(x => x * 3)); // => [3, 6, 9]
+*
+* @example
+* // Lazy evaluation with early termination: only the first two even squares
+* // are ever computed, the rest of the array is never touched.
+* pipe(
+*   [1, 2, 3, 4, 5, 6, 7, 8],
+*   map(x => x * x),
+*   filter(x => x % 2 === 0),
+*   take(2)
+* ); // => [4, 16]
+*
+* @example
+* // Any unary function works inside a pipe, not just es-toolkit operators.
+* pipe(
+*   '  Hello  ',
+*   s => s.trim(),
+*   s => s.toLowerCase()
+* ); // => 'hello'
+*/
+function pipe(value, ...functions) {
+	let output = value;
+	const groups = chunkFunctions(functions);
+	for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+		const group = groups[groupIndex];
+		if (group.lazy && isIterable(output) && (group.shortCircuit || !Array.isArray(output))) output = lazyPipe(output, group);
+		else for (let index = 0; index < group.length; index++) output = group[index](output);
+	}
+	return output;
+}
+function chunkFunctions(functions) {
+	if (functions.length === 0) return [];
+	let currentGroup = [functions[0]];
+	const result = [currentGroup];
+	let previousIsLazy = currentGroup[0].lazy != null;
+	if (previousIsLazy) currentGroup.lazy = true;
+	if (currentGroup[0].shortCircuit) currentGroup.shortCircuit = true;
+	for (let index = 1; index < functions.length; index++) {
+		const func = functions[index];
+		const isLazy = func.lazy != null;
+		if (isLazy !== previousIsLazy) {
+			currentGroup = [func];
+			result.push(currentGroup);
+		} else currentGroup.push(func);
+		if (isLazy) currentGroup.lazy = true;
+		if (func.shortCircuit) currentGroup.shortCircuit = true;
+		previousIsLazy = isLazy;
+	}
+	return result;
+}
+/**
+* Fuses a run of lazy functions into a single pass over `data`. The functions'
+* push transforms are composed (last function first) into one sink, then `data`
+* is driven through it element-by-element. A short-circuiting function (e.g.
+* `take`) returns `false`, which stops the drive loop at once, so the functions
+* before it never run on the rest of the input — no intermediate arrays.
+*
+* @param data - The iterable fed into the run (an array, `Set`, generator, ...).
+* @param lazyFunctions - The consecutive lazy functions to fuse, in order.
+* @returns The collected results.
+*/
+function lazyPipe(data, lazyFunctions) {
+	const result = [];
+	let sink = (value) => {
+		result.push(value);
+		return true;
+	};
+	for (let index = lazyFunctions.length - 1; index >= 0; index--) sink = lazyFunctions[index].lazy(sink);
+	if (Array.isArray(data)) {
+		for (let index = 0; index < data.length; index++) if (sink(data[index]) === false) break;
+	} else {
+		const iterator = data[Symbol.iterator]();
+		let step = iterator.next();
+		while (!step.done) {
+			if (sink(step.value) === false) break;
+			step = iterator.next();
+		}
+	}
+	return result;
+}
+/**
+* Whether `value` can be fed through the lazy path. A non-array iterable (a
+* `Set`, a generator, ...) can only go through `lazyPipe`, since the eager path
+* relies on array methods. Primitives and plain objects (no `Symbol.iterator`)
+* fall through to the eager branch.
+*/
+function isIterable(value) {
+	return typeof value === "object" && value !== null && Symbol.iterator in value;
+}
+//#endregion
+exports.pipe = pipe;

package/dist/fp/pipe.mjs

@@ -0,0 +1,116 @@
+//#region src/fp/pipe.ts
+/**
+* Performs left-to-right function composition, threading `value` through each
+* function in sequence. Every function receives the output of the previous
+* one, so the data flows top-to-bottom in the same order it is read. This
+* turns deeply nested calls into clear, sequential steps without temporary
+* variables.
+*
+* This is the entry point of `es-toolkit/fp`. Each `es-toolkit/fp` function is
+* called with its configuration (e.g. `map(fn)`, `take(2)`) and returns a
+* function that takes the data, which `pipe` then supplies.
+*
+* When consecutive **lazy-capable** functions (`map`, `filter`, `take`, ...)
+* appear together, `pipe` fuses them and processes the input element-by-element
+* instead of building an intermediate array after every step. This allows
+* early termination: a trailing `take(n)` stops the walk as soon as `n`
+* results exist, so the remaining input is never visited.
+*
+* @param value - The initial value fed into the pipe.
+* @param functions - Data-last operators (or any unary functions) applied in order.
+* @returns The result of applying every function, left to right.
+*
+* @example
+* import { pipe, map, filter, take } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], map(x => x * 3)); // => [3, 6, 9]
+*
+* @example
+* // Lazy evaluation with early termination: only the first two even squares
+* // are ever computed, the rest of the array is never touched.
+* pipe(
+*   [1, 2, 3, 4, 5, 6, 7, 8],
+*   map(x => x * x),
+*   filter(x => x % 2 === 0),
+*   take(2)
+* ); // => [4, 16]
+*
+* @example
+* // Any unary function works inside a pipe, not just es-toolkit operators.
+* pipe(
+*   '  Hello  ',
+*   s => s.trim(),
+*   s => s.toLowerCase()
+* ); // => 'hello'
+*/
+function pipe(value, ...functions) {
+	let output = value;
+	const groups = chunkFunctions(functions);
+	for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+		const group = groups[groupIndex];
+		if (group.lazy && isIterable(output) && (group.shortCircuit || !Array.isArray(output))) output = lazyPipe(output, group);
+		else for (let index = 0; index < group.length; index++) output = group[index](output);
+	}
+	return output;
+}
+function chunkFunctions(functions) {
+	if (functions.length === 0) return [];
+	let currentGroup = [functions[0]];
+	const result = [currentGroup];
+	let previousIsLazy = currentGroup[0].lazy != null;
+	if (previousIsLazy) currentGroup.lazy = true;
+	if (currentGroup[0].shortCircuit) currentGroup.shortCircuit = true;
+	for (let index = 1; index < functions.length; index++) {
+		const func = functions[index];
+		const isLazy = func.lazy != null;
+		if (isLazy !== previousIsLazy) {
+			currentGroup = [func];
+			result.push(currentGroup);
+		} else currentGroup.push(func);
+		if (isLazy) currentGroup.lazy = true;
+		if (func.shortCircuit) currentGroup.shortCircuit = true;
+		previousIsLazy = isLazy;
+	}
+	return result;
+}
+/**
+* Fuses a run of lazy functions into a single pass over `data`. The functions'
+* push transforms are composed (last function first) into one sink, then `data`
+* is driven through it element-by-element. A short-circuiting function (e.g.
+* `take`) returns `false`, which stops the drive loop at once, so the functions
+* before it never run on the rest of the input — no intermediate arrays.
+*
+* @param data - The iterable fed into the run (an array, `Set`, generator, ...).
+* @param lazyFunctions - The consecutive lazy functions to fuse, in order.
+* @returns The collected results.
+*/
+function lazyPipe(data, lazyFunctions) {
+	const result = [];
+	let sink = (value) => {
+		result.push(value);
+		return true;
+	};
+	for (let index = lazyFunctions.length - 1; index >= 0; index--) sink = lazyFunctions[index].lazy(sink);
+	if (Array.isArray(data)) {
+		for (let index = 0; index < data.length; index++) if (sink(data[index]) === false) break;
+	} else {
+		const iterator = data[Symbol.iterator]();
+		let step = iterator.next();
+		while (!step.done) {
+			if (sink(step.value) === false) break;
+			step = iterator.next();
+		}
+	}
+	return result;
+}
+/**
+* Whether `value` can be fed through the lazy path. A non-array iterable (a
+* `Set`, a generator, ...) can only go through `lazyPipe`, since the eager path
+* relies on array methods. Primitives and plain objects (no `Symbol.iterator`)
+* fall through to the eager branch.
+*/
+function isIterable(value) {
+	return typeof value === "object" && value !== null && Symbol.iterator in value;
+}
+//#endregion
+export { pipe };

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import { at } from "./array/at.mjs";
 import { cartesianProduct } from "./array/cartesianProduct.mjs";
 import { chunk } from "./array/chunk.mjs";
+import { chunkBy } from "./array/chunkBy.mjs";
 import { combinations } from "./array/combinations.mjs";
 import { compact } from "./array/compact.mjs";
 import { countBy } from "./array/countBy.mjs";
@@ -133,6 +134,7 @@ import { isEqualWith } from "./predicate/isEqualWith.mjs";
 import { isError } from "./predicate/isError.mjs";
 import { isFile } from "./predicate/isFile.mjs";
 import { isFunction } from "./predicate/isFunction.mjs";
+import { isIterable } from "./predicate/isIterable.mjs";
 import { isJSON } from "./predicate/isJSON.mjs";
 import { isJSONArray, isJSONObject, isJSONValue } from "./predicate/isJSONValue.mjs";
 import { isLength } from "./predicate/isLength.mjs";
@@ -183,4 +185,4 @@ import { words } from "./string/words.mjs";
 import { attempt } from "./util/attempt.mjs";
 import { attemptAsync } from "./util/attemptAsync.mjs";
 import { invariant } from "./util/invariant.mjs";
-export { AbortError, DebounceOptions, DebouncedFunction, MemoizeCache, Mutex, Semaphore, ThrottleOptions, ThrottledFunction, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { AbortError, DebounceOptions, DebouncedFunction, MemoizeCache, Mutex, Semaphore, ThrottleOptions, ThrottledFunction, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { at } from "./array/at.js";
 import { cartesianProduct } from "./array/cartesianProduct.js";
 import { chunk } from "./array/chunk.js";
+import { chunkBy } from "./array/chunkBy.js";
 import { combinations } from "./array/combinations.js";
 import { compact } from "./array/compact.js";
 import { countBy } from "./array/countBy.js";
@@ -133,6 +134,7 @@ import { isEqualWith } from "./predicate/isEqualWith.js";
 import { isError } from "./predicate/isError.js";
 import { isFile } from "./predicate/isFile.js";
 import { isFunction } from "./predicate/isFunction.js";
+import { isIterable } from "./predicate/isIterable.js";
 import { isJSON } from "./predicate/isJSON.js";
 import { isJSONArray, isJSONObject, isJSONValue } from "./predicate/isJSONValue.js";
 import { isLength } from "./predicate/isLength.js";
@@ -183,4 +185,4 @@ import { words } from "./string/words.js";
 import { attempt } from "./util/attempt.js";
 import { attemptAsync } from "./util/attemptAsync.js";
 import { invariant } from "./util/invariant.js";
-export { AbortError, DebounceOptions, DebouncedFunction, MemoizeCache, Mutex, Semaphore, ThrottleOptions, ThrottledFunction, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { AbortError, DebounceOptions, DebouncedFunction, MemoizeCache, Mutex, Semaphore, ThrottleOptions, ThrottledFunction, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/index.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_at = require("./array/at.js");
 const require_cartesianProduct = require("./array/cartesianProduct.js");
 const require_chunk = require("./array/chunk.js");
+const require_chunkBy = require("./array/chunkBy.js");
 const require_combinations = require("./array/combinations.js");
 const require_compact = require("./array/compact.js");
 const require_countBy = require("./array/countBy.js");
@@ -148,6 +149,7 @@ const require_isEqual = require("./predicate/isEqual.js");
 const require_isError = require("./predicate/isError.js");
 const require_isFile = require("./predicate/isFile.js");
 const require_isFunction = require("./predicate/isFunction.js");
+const require_isIterable = require("./predicate/isIterable.js");
 const require_isJSON = require("./predicate/isJSON.js");
 const require_isJSONValue = require("./predicate/isJSONValue.js");
 const require_isLength = require("./predicate/isLength.js");
@@ -210,6 +212,7 @@ exports.camelCase = require_camelCase.camelCase;
 exports.capitalize = require_capitalize.capitalize;
 exports.cartesianProduct = require_cartesianProduct.cartesianProduct;
 exports.chunk = require_chunk.chunk;
+exports.chunkBy = require_chunkBy.chunkBy;
 exports.clamp = require_clamp.clamp;
 exports.clone = require_clone.clone;
 exports.cloneDeep = require_cloneDeep.cloneDeep;
@@ -267,6 +270,7 @@ exports.isEqualWith = require_isEqualWith.isEqualWith;
 exports.isError = require_isError.isError;
 exports.isFile = require_isFile.isFile;
 exports.isFunction = require_isFunction.isFunction;
+exports.isIterable = require_isIterable.isIterable;
 exports.isJSON = require_isJSON.isJSON;
 exports.isJSONArray = require_isJSONValue.isJSONArray;
 exports.isJSONObject = require_isJSONValue.isJSONObject;

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { at } from "./array/at.mjs";
 import { cartesianProduct } from "./array/cartesianProduct.mjs";
 import { chunk } from "./array/chunk.mjs";
+import { chunkBy } from "./array/chunkBy.mjs";
 import { combinations } from "./array/combinations.mjs";
 import { compact } from "./array/compact.mjs";
 import { countBy } from "./array/countBy.mjs";
@@ -147,6 +148,7 @@ import { isEqual } from "./predicate/isEqual.mjs";
 import { isError } from "./predicate/isError.mjs";
 import { isFile } from "./predicate/isFile.mjs";
 import { isFunction } from "./predicate/isFunction.mjs";
+import { isIterable } from "./predicate/isIterable.mjs";
 import { isJSON } from "./predicate/isJSON.mjs";
 import { isJSONArray, isJSONObject, isJSONValue } from "./predicate/isJSONValue.mjs";
 import { isLength } from "./predicate/isLength.mjs";
@@ -192,4 +194,4 @@ import { attempt } from "./util/attempt.mjs";
 import { attemptAsync } from "./util/attemptAsync.mjs";
 import { invariant } from "./util/invariant.mjs";
 import "./util/index.mjs";
-export { AbortError, Mutex, Semaphore, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { AbortError, Mutex, Semaphore, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/predicate/index.d.mts

@@ -10,6 +10,7 @@ import { isEqualWith } from "./isEqualWith.mjs";
 import { isError } from "./isError.mjs";
 import { isFile } from "./isFile.mjs";
 import { isFunction } from "./isFunction.mjs";
+import { isIterable } from "./isIterable.mjs";
 import { isJSON } from "./isJSON.mjs";
 import { isJSONArray, isJSONObject, isJSONValue } from "./isJSONValue.mjs";
 import { isLength } from "./isLength.mjs";
@@ -30,4 +31,4 @@ import { isTypedArray } from "./isTypedArray.mjs";
 import { isUndefined } from "./isUndefined.mjs";
 import { isWeakMap } from "./isWeakMap.mjs";
 import { isWeakSet } from "./isWeakSet.mjs";
-export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };
+export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/predicate/index.d.ts

@@ -10,6 +10,7 @@ import { isEqualWith } from "./isEqualWith.js";
 import { isError } from "./isError.js";
 import { isFile } from "./isFile.js";
 import { isFunction } from "./isFunction.js";
+import { isIterable } from "./isIterable.js";
 import { isJSON } from "./isJSON.js";
 import { isJSONArray, isJSONObject, isJSONValue } from "./isJSONValue.js";
 import { isLength } from "./isLength.js";
@@ -30,4 +31,4 @@ import { isTypedArray } from "./isTypedArray.js";
 import { isUndefined } from "./isUndefined.js";
 import { isWeakMap } from "./isWeakMap.js";
 import { isWeakSet } from "./isWeakSet.js";
-export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };
+export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/predicate/index.js

@@ -14,6 +14,7 @@ const require_isEqual = require("./isEqual.js");
 const require_isError = require("./isError.js");
 const require_isFile = require("./isFile.js");
 const require_isFunction = require("./isFunction.js");
+const require_isIterable = require("./isIterable.js");
 const require_isJSON = require("./isJSON.js");
 const require_isJSONValue = require("./isJSONValue.js");
 const require_isLength = require("./isLength.js");
@@ -43,6 +44,7 @@ exports.isEqualWith = require_isEqualWith.isEqualWith;
 exports.isError = require_isError.isError;
 exports.isFile = require_isFile.isFile;
 exports.isFunction = require_isFunction.isFunction;
+exports.isIterable = require_isIterable.isIterable;
 exports.isJSON = require_isJSON.isJSON;
 exports.isJSONArray = require_isJSONValue.isJSONArray;
 exports.isJSONObject = require_isJSONValue.isJSONObject;

package/dist/predicate/index.mjs

@@ -13,6 +13,7 @@ import { isEqual } from "./isEqual.mjs";
 import { isError } from "./isError.mjs";
 import { isFile } from "./isFile.mjs";
 import { isFunction } from "./isFunction.mjs";
+import { isIterable } from "./isIterable.mjs";
 import { isJSON } from "./isJSON.mjs";
 import { isJSONArray, isJSONObject, isJSONValue } from "./isJSONValue.mjs";
 import { isLength } from "./isLength.mjs";
@@ -30,4 +31,4 @@ import { isSymbol } from "./isSymbol.mjs";
 import { isUndefined } from "./isUndefined.mjs";
 import { isWeakMap } from "./isWeakMap.mjs";
 import { isWeakSet } from "./isWeakSet.mjs";
-export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };
+export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/predicate/isIterable.d.mts

@@ -0,0 +1,26 @@
+//#region src/predicate/isIterable.d.ts
+/**
+ * Checks if a value is iterable, i.e. it implements the iterable protocol by
+ * providing a `Symbol.iterator` method.
+ *
+ * Arrays, strings, `Set`, `Map`, typed arrays, and generators are iterable;
+ * plain objects, `null`, and `undefined` are not.
+ *
+ * This function can be used as a TypeScript type predicate to narrow the type of
+ * `value` to `Iterable<unknown>`.
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is iterable, `false` otherwise.
+ *
+ * @example
+ * isIterable([1, 2, 3]); // true
+ * isIterable('abc'); // true
+ * isIterable(new Set([1, 2, 3])); // true
+ * isIterable(new Map()); // true
+ * isIterable({ a: 1 }); // false
+ * isIterable(123); // false
+ * isIterable(null); // false
+ */
+declare function isIterable(value: unknown): value is Iterable<unknown>;
+//#endregion
+export { isIterable };

package/dist/predicate/isIterable.d.ts

@@ -0,0 +1,26 @@
+//#region src/predicate/isIterable.d.ts
+/**
+ * Checks if a value is iterable, i.e. it implements the iterable protocol by
+ * providing a `Symbol.iterator` method.
+ *
+ * Arrays, strings, `Set`, `Map`, typed arrays, and generators are iterable;
+ * plain objects, `null`, and `undefined` are not.
+ *
+ * This function can be used as a TypeScript type predicate to narrow the type of
+ * `value` to `Iterable<unknown>`.
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is iterable, `false` otherwise.
+ *
+ * @example
+ * isIterable([1, 2, 3]); // true
+ * isIterable('abc'); // true
+ * isIterable(new Set([1, 2, 3])); // true
+ * isIterable(new Map()); // true
+ * isIterable({ a: 1 }); // false
+ * isIterable(123); // false
+ * isIterable(null); // false
+ */
+declare function isIterable(value: unknown): value is Iterable<unknown>;
+//#endregion
+export { isIterable };

package/dist/predicate/isIterable.js

@@ -0,0 +1,28 @@
+//#region src/predicate/isIterable.ts
+/**
+* Checks if a value is iterable, i.e. it implements the iterable protocol by
+* providing a `Symbol.iterator` method.
+*
+* Arrays, strings, `Set`, `Map`, typed arrays, and generators are iterable;
+* plain objects, `null`, and `undefined` are not.
+*
+* This function can be used as a TypeScript type predicate to narrow the type of
+* `value` to `Iterable<unknown>`.
+*
+* @param value - The value to check.
+* @returns `true` if `value` is iterable, `false` otherwise.
+*
+* @example
+* isIterable([1, 2, 3]); // true
+* isIterable('abc'); // true
+* isIterable(new Set([1, 2, 3])); // true
+* isIterable(new Map()); // true
+* isIterable({ a: 1 }); // false
+* isIterable(123); // false
+* isIterable(null); // false
+*/
+function isIterable(value) {
+	return value != null && typeof value[Symbol.iterator] === "function";
+}
+//#endregion
+exports.isIterable = isIterable;

package/dist/predicate/isIterable.mjs

@@ -0,0 +1,28 @@
+//#region src/predicate/isIterable.ts
+/**
+* Checks if a value is iterable, i.e. it implements the iterable protocol by
+* providing a `Symbol.iterator` method.
+*
+* Arrays, strings, `Set`, `Map`, typed arrays, and generators are iterable;
+* plain objects, `null`, and `undefined` are not.
+*
+* This function can be used as a TypeScript type predicate to narrow the type of
+* `value` to `Iterable<unknown>`.
+*
+* @param value - The value to check.
+* @returns `true` if `value` is iterable, `false` otherwise.
+*
+* @example
+* isIterable([1, 2, 3]); // true
+* isIterable('abc'); // true
+* isIterable(new Set([1, 2, 3])); // true
+* isIterable(new Map()); // true
+* isIterable({ a: 1 }); // false
+* isIterable(123); // false
+* isIterable(null); // false
+*/
+function isIterable(value) {
+	return value != null && typeof value[Symbol.iterator] === "function";
+}
+//#endregion
+export { isIterable };

package/fp.d.ts

@@ -0,0 +1 @@
+export * from './dist/fp';

package/fp.js

@@ -0,0 +1 @@
+module.exports = require('./dist/fp');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.48.1-dev.1889+0aaf0e6e",
+  "version": "1.48.1-dev.1894+6b75d8a8",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",
@@ -74,6 +74,16 @@
         "default": "./dist/error/index.js"
       }
     },
+    "./fp": {
+      "import": {
+        "types": "./dist/fp/index.d.mts",
+        "default": "./dist/fp/index.mjs"
+      },
+      "require": {
+        "types": "./dist/fp/index.d.ts",
+        "default": "./dist/fp/index.js"
+      }
+    },
     "./function": {
       "import": {
         "types": "./dist/function/index.d.mts",
@@ -173,6 +183,7 @@
     "array.js",
     "compat.js",
     "error.js",
+    "fp.js",
     "function.js",
     "map.js",
     "math.js",
@@ -304,6 +315,16 @@
           "default": "./dist/error/index.js"
         }
       },
+      "./fp": {
+        "import": {
+          "types": "./dist/fp/index.d.mts",
+          "default": "./dist/fp/index.mjs"
+        },
+        "require": {
+          "types": "./dist/fp/index.d.ts",
+          "default": "./dist/fp/index.js"
+        }
+      },
       "./function": {
         "import": {
           "types": "./dist/function/index.d.mts",