Upload folder using huggingface_hub (part 15)

node_modules/es-toolkit/dist/fp/array/head.js

@@ -0,0 +1,9 @@
+const require_head = require("../../array/head.js");
+//#region src/fp/array/head.ts
+function head() {
+	return function(array) {
+		return require_head.head(array);
+	};
+}
+//#endregion
+exports.head = head;

node_modules/es-toolkit/dist/fp/array/head.mjs

@@ -0,0 +1,9 @@
+import { head as head$1 } from "../../array/head.mjs";
+//#region src/fp/array/head.ts
+function head() {
+	return function(array) {
+		return head$1(array);
+	};
+}
+//#endregion
+export { head };

node_modules/es-toolkit/dist/fp/array/index.d.mts

@@ -0,0 +1,69 @@
+import { WindowedOptions } from "../../array/windowed.mjs";
+import { at } from "./at.mjs";
+import { cartesianProduct } from "./cartesianProduct.mjs";
+import { chunk } from "./chunk.mjs";
+import { chunkBy } from "./chunkBy.mjs";
+import { combinations } from "./combinations.mjs";
+import { compact } from "./compact.mjs";
+import { countBy } from "./countBy.mjs";
+import { difference } from "./difference.mjs";
+import { differenceBy } from "./differenceBy.mjs";
+import { differenceWith } from "./differenceWith.mjs";
+import { drop } from "./drop.mjs";
+import { dropRight } from "./dropRight.mjs";
+import { dropRightWhile } from "./dropRightWhile.mjs";
+import { dropWhile } from "./dropWhile.mjs";
+import { filter } from "./filter.mjs";
+import { find } from "./find.mjs";
+import { findIndex } from "./findIndex.mjs";
+import { findLast } from "./findLast.mjs";
+import { findLastIndex } from "./findLastIndex.mjs";
+import { flatMap } from "./flatMap.mjs";
+import { flatMapDeep } from "./flatMapDeep.mjs";
+import { flatten } from "./flatten.mjs";
+import { flattenDeep } from "./flattenDeep.mjs";
+import { forEach } from "./forEach.mjs";
+import { groupBy } from "./groupBy.mjs";
+import { head } from "./head.mjs";
+import { initial } from "./initial.mjs";
+import { intersection } from "./intersection.mjs";
+import { intersectionBy } from "./intersectionBy.mjs";
+import { intersectionWith } from "./intersectionWith.mjs";
+import { isSubset } from "./isSubset.mjs";
+import { isSubsetWith } from "./isSubsetWith.mjs";
+import { join } from "./join.mjs";
+import { keyBy } from "./keyBy.mjs";
+import { last } from "./last.mjs";
+import { length } from "./length.mjs";
+import { map } from "./map.mjs";
+import { maxBy } from "./maxBy.mjs";
+import { minBy } from "./minBy.mjs";
+import { orderBy } from "./orderBy.mjs";
+import { partition } from "./partition.mjs";
+import { reverse } from "./reverse.mjs";
+import { sample } from "./sample.mjs";
+import { sampleSize } from "./sampleSize.mjs";
+import { shuffle } from "./shuffle.mjs";
+import { sortBy } from "./sortBy.mjs";
+import { tail } from "./tail.mjs";
+import { take } from "./take.mjs";
+import { takeRight } from "./takeRight.mjs";
+import { takeRightWhile } from "./takeRightWhile.mjs";
+import { takeWhile } from "./takeWhile.mjs";
+import { toFilled } from "./toFilled.mjs";
+import { union } from "./union.mjs";
+import { unionBy } from "./unionBy.mjs";
+import { unionWith } from "./unionWith.mjs";
+import { uniq } from "./uniq.mjs";
+import { uniqBy } from "./uniqBy.mjs";
+import { uniqWith } from "./uniqWith.mjs";
+import { unzip } from "./unzip.mjs";
+import { unzipWith } from "./unzipWith.mjs";
+import { windowed } from "./windowed.mjs";
+import { without } from "./without.mjs";
+import { xor } from "./xor.mjs";
+import { xorBy } from "./xorBy.mjs";
+import { xorWith } from "./xorWith.mjs";
+import { zip } from "./zip.mjs";
+import { zipObject } from "./zipObject.mjs";
+import { zipWith } from "./zipWith.mjs";

node_modules/es-toolkit/dist/fp/array/index.d.ts

@@ -0,0 +1,69 @@
+import { WindowedOptions } from "../../array/windowed.js";
+import { at } from "./at.js";
+import { cartesianProduct } from "./cartesianProduct.js";
+import { chunk } from "./chunk.js";
+import { chunkBy } from "./chunkBy.js";
+import { combinations } from "./combinations.js";
+import { compact } from "./compact.js";
+import { countBy } from "./countBy.js";
+import { difference } from "./difference.js";
+import { differenceBy } from "./differenceBy.js";
+import { differenceWith } from "./differenceWith.js";
+import { drop } from "./drop.js";
+import { dropRight } from "./dropRight.js";
+import { dropRightWhile } from "./dropRightWhile.js";
+import { dropWhile } from "./dropWhile.js";
+import { filter } from "./filter.js";
+import { find } from "./find.js";
+import { findIndex } from "./findIndex.js";
+import { findLast } from "./findLast.js";
+import { findLastIndex } from "./findLastIndex.js";
+import { flatMap } from "./flatMap.js";
+import { flatMapDeep } from "./flatMapDeep.js";
+import { flatten } from "./flatten.js";
+import { flattenDeep } from "./flattenDeep.js";
+import { forEach } from "./forEach.js";
+import { groupBy } from "./groupBy.js";
+import { head } from "./head.js";
+import { initial } from "./initial.js";
+import { intersection } from "./intersection.js";
+import { intersectionBy } from "./intersectionBy.js";
+import { intersectionWith } from "./intersectionWith.js";
+import { isSubset } from "./isSubset.js";
+import { isSubsetWith } from "./isSubsetWith.js";
+import { join } from "./join.js";
+import { keyBy } from "./keyBy.js";
+import { last } from "./last.js";
+import { length } from "./length.js";
+import { map } from "./map.js";
+import { maxBy } from "./maxBy.js";
+import { minBy } from "./minBy.js";
+import { orderBy } from "./orderBy.js";
+import { partition } from "./partition.js";
+import { reverse } from "./reverse.js";
+import { sample } from "./sample.js";
+import { sampleSize } from "./sampleSize.js";
+import { shuffle } from "./shuffle.js";
+import { sortBy } from "./sortBy.js";
+import { tail } from "./tail.js";
+import { take } from "./take.js";
+import { takeRight } from "./takeRight.js";
+import { takeRightWhile } from "./takeRightWhile.js";
+import { takeWhile } from "./takeWhile.js";
+import { toFilled } from "./toFilled.js";
+import { union } from "./union.js";
+import { unionBy } from "./unionBy.js";
+import { unionWith } from "./unionWith.js";
+import { uniq } from "./uniq.js";
+import { uniqBy } from "./uniqBy.js";
+import { uniqWith } from "./uniqWith.js";
+import { unzip } from "./unzip.js";
+import { unzipWith } from "./unzipWith.js";
+import { windowed } from "./windowed.js";
+import { without } from "./without.js";
+import { xor } from "./xor.js";
+import { xorBy } from "./xorBy.js";
+import { xorWith } from "./xorWith.js";
+import { zip } from "./zip.js";
+import { zipObject } from "./zipObject.js";
+import { zipWith } from "./zipWith.js";

node_modules/es-toolkit/dist/fp/array/index.js

@@ -0,0 +1,68 @@
+require("./at.js");
+require("./cartesianProduct.js");
+require("./chunk.js");
+require("./chunkBy.js");
+require("./combinations.js");
+require("./compact.js");
+require("./countBy.js");
+require("./difference.js");
+require("./differenceBy.js");
+require("./differenceWith.js");
+require("./drop.js");
+require("./dropRight.js");
+require("./dropRightWhile.js");
+require("./dropWhile.js");
+require("./filter.js");
+require("./find.js");
+require("./findIndex.js");
+require("./findLast.js");
+require("./findLastIndex.js");
+require("./flatMap.js");
+require("./flatMapDeep.js");
+require("./flatten.js");
+require("./flattenDeep.js");
+require("./forEach.js");
+require("./groupBy.js");
+require("./head.js");
+require("./initial.js");
+require("./intersection.js");
+require("./intersectionBy.js");
+require("./intersectionWith.js");
+require("./isSubset.js");
+require("./isSubsetWith.js");
+require("./join.js");
+require("./keyBy.js");
+require("./last.js");
+require("./length.js");
+require("./map.js");
+require("./maxBy.js");
+require("./minBy.js");
+require("./orderBy.js");
+require("./partition.js");
+require("./reverse.js");
+require("./sample.js");
+require("./sampleSize.js");
+require("./shuffle.js");
+require("./sortBy.js");
+require("./tail.js");
+require("./take.js");
+require("./takeRight.js");
+require("./takeRightWhile.js");
+require("./takeWhile.js");
+require("./toFilled.js");
+require("./union.js");
+require("./unionBy.js");
+require("./unionWith.js");
+require("./uniq.js");
+require("./uniqBy.js");
+require("./uniqWith.js");
+require("./unzip.js");
+require("./unzipWith.js");
+require("./windowed.js");
+require("./without.js");
+require("./xor.js");
+require("./xorBy.js");
+require("./xorWith.js");
+require("./zip.js");
+require("./zipObject.js");
+require("./zipWith.js");

node_modules/es-toolkit/dist/fp/array/index.mjs

@@ -0,0 +1,68 @@
+import "./at.mjs";
+import "./cartesianProduct.mjs";
+import "./chunk.mjs";
+import "./chunkBy.mjs";
+import "./combinations.mjs";
+import "./compact.mjs";
+import "./countBy.mjs";
+import "./difference.mjs";
+import "./differenceBy.mjs";
+import "./differenceWith.mjs";
+import "./drop.mjs";
+import "./dropRight.mjs";
+import "./dropRightWhile.mjs";
+import "./dropWhile.mjs";
+import "./filter.mjs";
+import "./find.mjs";
+import "./findIndex.mjs";
+import "./findLast.mjs";
+import "./findLastIndex.mjs";
+import "./flatMap.mjs";
+import "./flatMapDeep.mjs";
+import "./flatten.mjs";
+import "./flattenDeep.mjs";
+import "./forEach.mjs";
+import "./groupBy.mjs";
+import "./head.mjs";
+import "./initial.mjs";
+import "./intersection.mjs";
+import "./intersectionBy.mjs";
+import "./intersectionWith.mjs";
+import "./isSubset.mjs";
+import "./isSubsetWith.mjs";
+import "./join.mjs";
+import "./keyBy.mjs";
+import "./last.mjs";
+import "./length.mjs";
+import "./map.mjs";
+import "./maxBy.mjs";
+import "./minBy.mjs";
+import "./orderBy.mjs";
+import "./partition.mjs";
+import "./reverse.mjs";
+import "./sample.mjs";
+import "./sampleSize.mjs";
+import "./shuffle.mjs";
+import "./sortBy.mjs";
+import "./tail.mjs";
+import "./take.mjs";
+import "./takeRight.mjs";
+import "./takeRightWhile.mjs";
+import "./takeWhile.mjs";
+import "./toFilled.mjs";
+import "./union.mjs";
+import "./unionBy.mjs";
+import "./unionWith.mjs";
+import "./uniq.mjs";
+import "./uniqBy.mjs";
+import "./uniqWith.mjs";
+import "./unzip.mjs";
+import "./unzipWith.mjs";
+import "./windowed.mjs";
+import "./without.mjs";
+import "./xor.mjs";
+import "./xorBy.mjs";
+import "./xorWith.mjs";
+import "./zip.mjs";
+import "./zipObject.mjs";
+import "./zipWith.mjs";

node_modules/es-toolkit/dist/fp/array/initial.d.mts

@@ -0,0 +1,19 @@
+//#region src/fp/array/initial.d.ts
+/**
+ * Creates a function that returns every element except the last one.
+ *
+ * The returned function follows the main {@link initial} behavior and always returns a new array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its initial elements.
+ *
+ * @example
+ * import { initial, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], initial());
+ * // => [1, 2]
+ */
+declare function initial<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { initial };

node_modules/es-toolkit/dist/fp/array/initial.d.ts

@@ -0,0 +1,19 @@
+//#region src/fp/array/initial.d.ts
+/**
+ * Creates a function that returns every element except the last one.
+ *
+ * The returned function follows the main {@link initial} behavior and always returns a new array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its initial elements.
+ *
+ * @example
+ * import { initial, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], initial());
+ * // => [1, 2]
+ */
+declare function initial<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { initial };

node_modules/es-toolkit/dist/fp/array/initial.js

@@ -0,0 +1,24 @@
+const require_initial = require("../../array/initial.js");
+//#region src/fp/array/initial.ts
+/**
+* Creates a function that returns every element except the last one.
+*
+* The returned function follows the main {@link initial} behavior and always returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its initial elements.
+*
+* @example
+* import { initial, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], initial());
+* // => [1, 2]
+*/
+function initial() {
+	return function(array) {
+		return require_initial.initial(array);
+	};
+}
+//#endregion
+exports.initial = initial;

node_modules/es-toolkit/dist/fp/array/initial.mjs

@@ -0,0 +1,24 @@
+import { initial as initial$1 } from "../../array/initial.mjs";
+//#region src/fp/array/initial.ts
+/**
+* Creates a function that returns every element except the last one.
+*
+* The returned function follows the main {@link initial} behavior and always returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its initial elements.
+*
+* @example
+* import { initial, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], initial());
+* // => [1, 2]
+*/
+function initial() {
+	return function(array) {
+		return initial$1(array);
+	};
+}
+//#endregion
+export { initial };

node_modules/es-toolkit/dist/fp/array/intersection.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/intersection.d.ts
+/**
+ * Creates a function that keeps values from the piped array that are also present in another array.
+ *
+ * Equality follows SameValueZero through Set membership, matching the main
+ * {@link intersection} implementation. The returned function is lazy-capable
+ * inside {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to intersect with the piped array.
+ * @returns A function that maps the piped array to its intersection.
+ *
+ * @example
+ * import { intersection, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], intersection([2, 4]));
+ * // => [2]
+ */
+declare function intersection<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { intersection };

node_modules/es-toolkit/dist/fp/array/intersection.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/intersection.d.ts
+/**
+ * Creates a function that keeps values from the piped array that are also present in another array.
+ *
+ * Equality follows SameValueZero through Set membership, matching the main
+ * {@link intersection} implementation. The returned function is lazy-capable
+ * inside {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to intersect with the piped array.
+ * @returns A function that maps the piped array to its intersection.
+ *
+ * @example
+ * import { intersection, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], intersection([2, 4]));
+ * // => [2]
+ */
+declare function intersection<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { intersection };

node_modules/es-toolkit/dist/fp/array/intersection.js

@@ -0,0 +1,32 @@
+const require_intersection = require("../../array/intersection.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/intersection.ts
+/**
+* Creates a function that keeps values from the piped array that are also present in another array.
+*
+* Equality follows SameValueZero through Set membership, matching the main
+* {@link intersection} implementation. The returned function is lazy-capable
+* inside {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to intersect with the piped array.
+* @returns A function that maps the piped array to its intersection.
+*
+* @example
+* import { intersection, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], intersection([2, 4]));
+* // => [2]
+*/
+function intersection(secondArray) {
+	const secondSet = new Set(secondArray);
+	function intersectionEager(array) {
+		return require_intersection.intersection(array, secondArray);
+	}
+	const intersectionLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (secondSet.has(value)) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(intersectionEager, intersectionLazy);
+}
+//#endregion
+exports.intersection = intersection;

node_modules/es-toolkit/dist/fp/array/intersection.mjs

@@ -0,0 +1,31 @@
+import { intersection as intersection$1 } from "../../array/intersection.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/intersection.ts
+/**
+* Creates a function that keeps values from the piped array that are also present in another array.
+*
+* Equality follows SameValueZero through Set membership, matching the main
+* {@link intersection} implementation. The returned function is lazy-capable
+* inside {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to intersect with the piped array.
+* @returns A function that maps the piped array to its intersection.
+*
+* @example
+* import { intersection, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], intersection([2, 4]));
+* // => [2]
+*/
+function intersection(secondArray) {
+	const secondSet = new Set(secondArray);
+	function intersectionEager(array) {
+		return intersection$1(array, secondArray);
+	}
+	return combineEagerAndLazyFunctions(intersectionEager, createLazyFunction((value, _index, emit) => {
+		if (secondSet.has(value)) emit(value);
+	}));
+}
+//#endregion
+export { intersection };

node_modules/es-toolkit/dist/fp/array/intersectionBy.d.mts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionBy.d.ts
+/**
+ * Creates a function that keeps values whose mapped identity appears in another array.
+ *
+ * The mapper is applied to values from both arrays. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to intersect with the piped array after mapping.
+ * @param mapper - Maps values from both arrays to comparison keys.
+ * @returns A function that maps the piped array to its mapped intersection.
+ *
+ * @example
+ * import { intersectionBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionBy<T, U>(secondArray: readonly U[], mapper: (value: T | U) => unknown): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionBy };

node_modules/es-toolkit/dist/fp/array/intersectionBy.d.ts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionBy.d.ts
+/**
+ * Creates a function that keeps values whose mapped identity appears in another array.
+ *
+ * The mapper is applied to values from both arrays. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to intersect with the piped array after mapping.
+ * @param mapper - Maps values from both arrays to comparison keys.
+ * @returns A function that maps the piped array to its mapped intersection.
+ *
+ * @example
+ * import { intersectionBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionBy<T, U>(secondArray: readonly U[], mapper: (value: T | U) => unknown): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionBy };

node_modules/es-toolkit/dist/fp/array/intersectionBy.js

@@ -0,0 +1,33 @@
+const require_intersectionBy = require("../../array/intersectionBy.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/intersectionBy.ts
+/**
+* Creates a function that keeps values whose mapped identity appears in another array.
+*
+* The mapper is applied to values from both arrays. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to intersect with the piped array after mapping.
+* @param mapper - Maps values from both arrays to comparison keys.
+* @returns A function that maps the piped array to its mapped intersection.
+*
+* @example
+* import { intersectionBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+* // => [{ id: 2 }]
+*/
+function intersectionBy(secondArray, mapper) {
+	const mappedSecondSet = new Set(secondArray.map((item) => mapper(item)));
+	function intersectionByEager(array) {
+		return require_intersectionBy.intersectionBy(array, secondArray, mapper);
+	}
+	const intersectionByLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (mappedSecondSet.has(mapper(value))) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(intersectionByEager, intersectionByLazy);
+}
+//#endregion
+exports.intersectionBy = intersectionBy;

node_modules/es-toolkit/dist/fp/array/intersectionBy.mjs

@@ -0,0 +1,32 @@
+import { intersectionBy as intersectionBy$1 } from "../../array/intersectionBy.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/intersectionBy.ts
+/**
+* Creates a function that keeps values whose mapped identity appears in another array.
+*
+* The mapper is applied to values from both arrays. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to intersect with the piped array after mapping.
+* @param mapper - Maps values from both arrays to comparison keys.
+* @returns A function that maps the piped array to its mapped intersection.
+*
+* @example
+* import { intersectionBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+* // => [{ id: 2 }]
+*/
+function intersectionBy(secondArray, mapper) {
+	const mappedSecondSet = new Set(secondArray.map((item) => mapper(item)));
+	function intersectionByEager(array) {
+		return intersectionBy$1(array, secondArray, mapper);
+	}
+	return combineEagerAndLazyFunctions(intersectionByEager, createLazyFunction((value, _index, emit) => {
+		if (mappedSecondSet.has(mapper(value))) emit(value);
+	}));
+}
+//#endregion
+export { intersectionBy };

node_modules/es-toolkit/dist/fp/array/intersectionWith.d.mts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionWith.d.ts
+/**
+ * Creates a function that keeps values equal to at least one configured value.
+ *
+ * Equality is decided by the provided comparator. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to compare against the piped array.
+ * @param areItemsEqual - Returns true when a piped value equals a configured value.
+ * @returns A function that maps the piped array to its custom intersection.
+ *
+ * @example
+ * import { intersectionWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionWith<T, U>(secondArray: readonly U[], areItemsEqual: (item: T, other: U) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionWith };

node_modules/es-toolkit/dist/fp/array/intersectionWith.d.ts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionWith.d.ts
+/**
+ * Creates a function that keeps values equal to at least one configured value.
+ *
+ * Equality is decided by the provided comparator. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to compare against the piped array.
+ * @param areItemsEqual - Returns true when a piped value equals a configured value.
+ * @returns A function that maps the piped array to its custom intersection.
+ *
+ * @example
+ * import { intersectionWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionWith<T, U>(secondArray: readonly U[], areItemsEqual: (item: T, other: U) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionWith };

node_modules/es-toolkit/dist/fp/array/intersectionWith.js

@@ -0,0 +1,32 @@
+const require_intersectionWith = require("../../array/intersectionWith.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/intersectionWith.ts
+/**
+* Creates a function that keeps values equal to at least one configured value.
+*
+* Equality is decided by the provided comparator. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to compare against the piped array.
+* @param areItemsEqual - Returns true when a piped value equals a configured value.
+* @returns A function that maps the piped array to its custom intersection.
+*
+* @example
+* import { intersectionWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+* // => [{ id: 2 }]
+*/
+function intersectionWith(secondArray, areItemsEqual) {
+	function intersectionWithEager(array) {
+		return require_intersectionWith.intersectionWith(array, secondArray, areItemsEqual);
+	}
+	const intersectionWithLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (secondArray.some((other) => areItemsEqual(value, other))) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(intersectionWithEager, intersectionWithLazy);
+}
+//#endregion
+exports.intersectionWith = intersectionWith;

node_modules/es-toolkit/dist/fp/array/intersectionWith.mjs

@@ -0,0 +1,31 @@
+import { intersectionWith as intersectionWith$1 } from "../../array/intersectionWith.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/intersectionWith.ts
+/**
+* Creates a function that keeps values equal to at least one configured value.
+*
+* Equality is decided by the provided comparator. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to compare against the piped array.
+* @param areItemsEqual - Returns true when a piped value equals a configured value.
+* @returns A function that maps the piped array to its custom intersection.
+*
+* @example
+* import { intersectionWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+* // => [{ id: 2 }]
+*/
+function intersectionWith(secondArray, areItemsEqual) {
+	function intersectionWithEager(array) {
+		return intersectionWith$1(array, secondArray, areItemsEqual);
+	}
+	return combineEagerAndLazyFunctions(intersectionWithEager, createLazyFunction((value, _index, emit) => {
+		if (secondArray.some((other) => areItemsEqual(value, other))) emit(value);
+	}));
+}
+//#endregion
+export { intersectionWith };

node_modules/es-toolkit/dist/fp/array/isSubset.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/array/isSubset.d.ts
+/**
+ * Creates a predicate that checks whether the piped array is a subset of superset.
+ *
+ * Every value in the piped array must be present in superset, using the main
+ * {@link isSubset} equality behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubset, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], isSubset([1, 2, 3]));
+ * // => true
+ */
+declare function isSubset<T>(superset: readonly T[]): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubset };

node_modules/es-toolkit/dist/fp/array/isSubset.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/isSubset.d.ts
+/**
+ * Creates a predicate that checks whether the piped array is a subset of superset.
+ *
+ * Every value in the piped array must be present in superset, using the main
+ * {@link isSubset} equality behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubset, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], isSubset([1, 2, 3]));
+ * // => true
+ */
+declare function isSubset<T>(superset: readonly T[]): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubset };

node_modules/es-toolkit/dist/fp/array/isSubset.js

@@ -0,0 +1,25 @@
+const require_isSubset = require("../../array/isSubset.js");
+//#region src/fp/array/isSubset.ts
+/**
+* Creates a predicate that checks whether the piped array is a subset of superset.
+*
+* Every value in the piped array must be present in superset, using the main
+* {@link isSubset} equality behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubset, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2], isSubset([1, 2, 3]));
+* // => true
+*/
+function isSubset(superset) {
+	return function(array) {
+		return require_isSubset.isSubset(superset, array);
+	};
+}
+//#endregion
+exports.isSubset = isSubset;

node_modules/es-toolkit/dist/fp/array/isSubset.mjs

@@ -0,0 +1,25 @@
+import { isSubset as isSubset$1 } from "../../array/isSubset.mjs";
+//#region src/fp/array/isSubset.ts
+/**
+* Creates a predicate that checks whether the piped array is a subset of superset.
+*
+* Every value in the piped array must be present in superset, using the main
+* {@link isSubset} equality behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubset, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2], isSubset([1, 2, 3]));
+* // => true
+*/
+function isSubset(superset) {
+	return function(array) {
+		return isSubset$1(superset, array);
+	};
+}
+//#endregion
+export { isSubset };

node_modules/es-toolkit/dist/fp/array/isSubsetWith.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/isSubsetWith.d.ts
+/**
+ * Creates a predicate that checks subset membership with a custom equality function.
+ *
+ * Every value in the piped array must match at least one value in superset according
+ * to areItemsEqual.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubsetWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+ * // => true
+ */
+declare function isSubsetWith<T>(superset: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubsetWith };

node_modules/es-toolkit/dist/fp/array/isSubsetWith.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/isSubsetWith.d.ts
+/**
+ * Creates a predicate that checks subset membership with a custom equality function.
+ *
+ * Every value in the piped array must match at least one value in superset according
+ * to areItemsEqual.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubsetWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+ * // => true
+ */
+declare function isSubsetWith<T>(superset: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubsetWith };

node_modules/es-toolkit/dist/fp/array/isSubsetWith.js

@@ -0,0 +1,26 @@
+const require_isSubsetWith = require("../../array/isSubsetWith.js");
+//#region src/fp/array/isSubsetWith.ts
+/**
+* Creates a predicate that checks subset membership with a custom equality function.
+*
+* Every value in the piped array must match at least one value in superset according
+* to areItemsEqual.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubsetWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+* // => true
+*/
+function isSubsetWith(superset, areItemsEqual) {
+	return function(array) {
+		return require_isSubsetWith.isSubsetWith(superset, array, areItemsEqual);
+	};
+}
+//#endregion
+exports.isSubsetWith = isSubsetWith;

node_modules/es-toolkit/dist/fp/array/isSubsetWith.mjs

@@ -0,0 +1,26 @@
+import { isSubsetWith as isSubsetWith$1 } from "../../array/isSubsetWith.mjs";
+//#region src/fp/array/isSubsetWith.ts
+/**
+* Creates a predicate that checks subset membership with a custom equality function.
+*
+* Every value in the piped array must match at least one value in superset according
+* to areItemsEqual.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubsetWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+* // => true
+*/
+function isSubsetWith(superset, areItemsEqual) {
+	return function(array) {
+		return isSubsetWith$1(superset, array, areItemsEqual);
+	};
+}
+//#endregion
+export { isSubsetWith };

node_modules/es-toolkit/dist/fp/array/join.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/array/join.d.ts
+/**
+ * Creates a function that joins array values into a string.
+ *
+ * The separator is passed to Array.prototype.join, so undefined uses a comma.
+ * Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param separator - The separator placed between values.
+ * @returns A function that maps a readonly array to a joined string.
+ *
+ * @example
+ * import { join, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], join('-'));
+ * // => 'a-b-c'
+ */
+declare function join<T>(separator?: string): (array: readonly T[]) => string;
+//#endregion
+export { join };

node_modules/es-toolkit/dist/fp/array/join.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/join.d.ts
+/**
+ * Creates a function that joins array values into a string.
+ *
+ * The separator is passed to Array.prototype.join, so undefined uses a comma.
+ * Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param separator - The separator placed between values.
+ * @returns A function that maps a readonly array to a joined string.
+ *
+ * @example
+ * import { join, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], join('-'));
+ * // => 'a-b-c'
+ */
+declare function join<T>(separator?: string): (array: readonly T[]) => string;
+//#endregion
+export { join };

node_modules/es-toolkit/dist/fp/array/join.js

@@ -0,0 +1,24 @@
+//#region src/fp/array/join.ts
+/**
+* Creates a function that joins array values into a string.
+*
+* The separator is passed to Array.prototype.join, so undefined uses a comma.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param separator - The separator placed between values.
+* @returns A function that maps a readonly array to a joined string.
+*
+* @example
+* import { join, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], join('-'));
+* // => 'a-b-c'
+*/
+function join(separator) {
+	return function(array) {
+		return array.join(separator);
+	};
+}
+//#endregion
+exports.join = join;

node_modules/es-toolkit/dist/fp/array/join.mjs

@@ -0,0 +1,24 @@
+//#region src/fp/array/join.ts
+/**
+* Creates a function that joins array values into a string.
+*
+* The separator is passed to Array.prototype.join, so undefined uses a comma.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param separator - The separator placed between values.
+* @returns A function that maps a readonly array to a joined string.
+*
+* @example
+* import { join, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], join('-'));
+* // => 'a-b-c'
+*/
+function join(separator) {
+	return function(array) {
+		return array.join(separator);
+	};
+}
+//#endregion
+export { join };

node_modules/es-toolkit/dist/fp/array/keyBy.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/keyBy.d.ts
+/**
+ * Creates a function that indexes values by a derived key.
+ *
+ * The key selector receives each value, index, and full input array. When multiple values
+ * produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The property-key type produced by the selector.
+ * @param getKey - Called with each value, index, and array to produce an object key.
+ * @returns A function that maps a readonly array to an object keyed by the derived keys.
+ *
+ * @example
+ * import { keyBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+ * // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+ */
+declare function keyBy<T, K extends PropertyKey>(getKey: (item: T, index: number, array: readonly T[]) => K): (array: readonly T[]) => Record<K, T>;
+//#endregion
+export { keyBy };

node_modules/es-toolkit/dist/fp/array/keyBy.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/keyBy.d.ts
+/**
+ * Creates a function that indexes values by a derived key.
+ *
+ * The key selector receives each value, index, and full input array. When multiple values
+ * produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The property-key type produced by the selector.
+ * @param getKey - Called with each value, index, and array to produce an object key.
+ * @returns A function that maps a readonly array to an object keyed by the derived keys.
+ *
+ * @example
+ * import { keyBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+ * // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+ */
+declare function keyBy<T, K extends PropertyKey>(getKey: (item: T, index: number, array: readonly T[]) => K): (array: readonly T[]) => Record<K, T>;
+//#endregion
+export { keyBy };

node_modules/es-toolkit/dist/fp/array/keyBy.js

@@ -0,0 +1,26 @@
+const require_keyBy = require("../../array/keyBy.js");
+//#region src/fp/array/keyBy.ts
+/**
+* Creates a function that indexes values by a derived key.
+*
+* The key selector receives each value, index, and full input array. When multiple values
+* produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+*
+* @template T - The type of elements in the array.
+* @template K - The property-key type produced by the selector.
+* @param getKey - Called with each value, index, and array to produce an object key.
+* @returns A function that maps a readonly array to an object keyed by the derived keys.
+*
+* @example
+* import { keyBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+* // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+*/
+function keyBy(getKey) {
+	return function(array) {
+		return require_keyBy.keyBy(array, getKey);
+	};
+}
+//#endregion
+exports.keyBy = keyBy;

node_modules/es-toolkit/dist/fp/array/keyBy.mjs

@@ -0,0 +1,26 @@
+import { keyBy as keyBy$1 } from "../../array/keyBy.mjs";
+//#region src/fp/array/keyBy.ts
+/**
+* Creates a function that indexes values by a derived key.
+*
+* The key selector receives each value, index, and full input array. When multiple values
+* produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+*
+* @template T - The type of elements in the array.
+* @template K - The property-key type produced by the selector.
+* @param getKey - Called with each value, index, and array to produce an object key.
+* @returns A function that maps a readonly array to an object keyed by the derived keys.
+*
+* @example
+* import { keyBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+* // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+*/
+function keyBy(getKey) {
+	return function(array) {
+		return keyBy$1(array, getKey);
+	};
+}
+//#endregion
+export { keyBy };

node_modules/es-toolkit/dist/fp/array/last.d.mts

@@ -0,0 +1,35 @@
+//#region src/fp/array/last.d.ts
+/**
+ * Creates a function that returns the last element of a non-empty array.
+ *
+ * This overload preserves the non-empty tuple guarantee: the returned function
+ * always returns T when the piped array has at least one element.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a non-empty readonly array to its last element.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3] as const, last());
+ * // => 3
+ */
+declare function last<T>(): (array: readonly [...T[], T]) => T;
+/**
+ * Creates a function that returns the last element of an array, or undefined.
+ *
+ * Empty arrays return undefined, matching the main {@link last} behavior. Use
+ * the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its last element, or undefined.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as number[], last());
+ * // => undefined
+ */
+declare function last<T>(): (array: readonly T[]) => T | undefined;
+//#endregion
+export { last };

node_modules/es-toolkit/dist/fp/array/last.d.ts

@@ -0,0 +1,35 @@
+//#region src/fp/array/last.d.ts
+/**
+ * Creates a function that returns the last element of a non-empty array.
+ *
+ * This overload preserves the non-empty tuple guarantee: the returned function
+ * always returns T when the piped array has at least one element.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a non-empty readonly array to its last element.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3] as const, last());
+ * // => 3
+ */
+declare function last<T>(): (array: readonly [...T[], T]) => T;
+/**
+ * Creates a function that returns the last element of an array, or undefined.
+ *
+ * Empty arrays return undefined, matching the main {@link last} behavior. Use
+ * the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its last element, or undefined.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as number[], last());
+ * // => undefined
+ */
+declare function last<T>(): (array: readonly T[]) => T | undefined;
+//#endregion
+export { last };

node_modules/es-toolkit/dist/fp/array/last.js

@@ -0,0 +1,9 @@
+const require_last = require("../../array/last.js");
+//#region src/fp/array/last.ts
+function last() {
+	return function(array) {
+		return require_last.last(array);
+	};
+}
+//#endregion
+exports.last = last;

node_modules/es-toolkit/dist/fp/array/last.mjs

@@ -0,0 +1,9 @@
+import { last as last$1 } from "../../array/last.mjs";
+//#region src/fp/array/last.ts
+function last() {
+	return function(array) {
+		return last$1(array);
+	};
+}
+//#endregion
+export { last };

node_modules/es-toolkit/dist/fp/array/length.d.mts

@@ -0,0 +1,18 @@
+//#region src/fp/array/length.d.ts
+/**
+ * Creates a function that returns the length of an array.
+ *
+ * Use it with {@link pipe} when a pipeline should end with the number of input values.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its length.
+ *
+ * @example
+ * import { length, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], length());
+ * // => 3
+ */
+declare function length<T>(): (array: readonly T[]) => number;
+//#endregion
+export { length };

node_modules/es-toolkit/dist/fp/array/length.d.ts

@@ -0,0 +1,18 @@
+//#region src/fp/array/length.d.ts
+/**
+ * Creates a function that returns the length of an array.
+ *
+ * Use it with {@link pipe} when a pipeline should end with the number of input values.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its length.
+ *
+ * @example
+ * import { length, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], length());
+ * // => 3
+ */
+declare function length<T>(): (array: readonly T[]) => number;
+//#endregion
+export { length };

node_modules/es-toolkit/dist/fp/array/length.js

@@ -0,0 +1,22 @@
+//#region src/fp/array/length.ts
+/**
+* Creates a function that returns the length of an array.
+*
+* Use it with {@link pipe} when a pipeline should end with the number of input values.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its length.
+*
+* @example
+* import { length, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], length());
+* // => 3
+*/
+function length() {
+	return function(array) {
+		return array.length;
+	};
+}
+//#endregion
+exports.length = length;

node_modules/es-toolkit/dist/fp/array/length.mjs

@@ -0,0 +1,22 @@
+//#region src/fp/array/length.ts
+/**
+* Creates a function that returns the length of an array.
+*
+* Use it with {@link pipe} when a pipeline should end with the number of input values.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its length.
+*
+* @example
+* import { length, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], length());
+* // => 3
+*/
+function length() {
+	return function(array) {
+		return array.length;
+	};
+}
+//#endregion
+export { length };

node_modules/es-toolkit/dist/fp/array/map.d.mts

@@ -0,0 +1,27 @@
+//#region src/fp/array/map.d.ts
+/**
+ * Creates a function that builds a new array by calling `callback` on every
+ * element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element, so a trailing
+ * `take` can terminate the walk early without mapping the rest of the input.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param callback - Called with `(value, index)` for each element; its return
+ *   value becomes the corresponding element of the output array.
+ * @returns A function that maps a `readonly T[]` to a new `U[]`.
+ *
+ * @example
+ * import { pipe, map } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+ *
+ * @example
+ * // The index is available as the second argument.
+ * pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+ */
+declare function map<T, U>(callback: (value: T, index: number) => U): (array: readonly T[]) => U[];
+//#endregion
+export { map };

node_modules/es-toolkit/dist/fp/array/map.d.ts

@@ -0,0 +1,27 @@
+//#region src/fp/array/map.d.ts
+/**
+ * Creates a function that builds a new array by calling `callback` on every
+ * element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element, so a trailing
+ * `take` can terminate the walk early without mapping the rest of the input.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param callback - Called with `(value, index)` for each element; its return
+ *   value becomes the corresponding element of the output array.
+ * @returns A function that maps a `readonly T[]` to a new `U[]`.
+ *
+ * @example
+ * import { pipe, map } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+ *
+ * @example
+ * // The index is available as the second argument.
+ * pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+ */
+declare function map<T, U>(callback: (value: T, index: number) => U): (array: readonly T[]) => U[];
+//#endregion
+export { map };

node_modules/es-toolkit/dist/fp/array/map.js

@@ -0,0 +1,36 @@
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/map.ts
+/**
+* Creates a function that builds a new array by calling `callback` on every
+* element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+*
+* The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+* with adjacent lazy functions and runs element-by-element, so a trailing
+* `take` can terminate the walk early without mapping the rest of the input.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param callback - Called with `(value, index)` for each element; its return
+*   value becomes the corresponding element of the output array.
+* @returns A function that maps a `readonly T[]` to a new `U[]`.
+*
+* @example
+* import { pipe, map } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+*
+* @example
+* // The index is available as the second argument.
+* pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+*/
+function map(callback) {
+	function mapEager(array) {
+		return array.map(callback);
+	}
+	const mapLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		emit(callback(value, index));
+	});
+	return require_lazy.combineEagerAndLazyFunctions(mapEager, mapLazy);
+}
+//#endregion
+exports.map = map;

node_modules/es-toolkit/dist/fp/array/map.mjs

@@ -0,0 +1,35 @@
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/map.ts
+/**
+* Creates a function that builds a new array by calling `callback` on every
+* element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+*
+* The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+* with adjacent lazy functions and runs element-by-element, so a trailing
+* `take` can terminate the walk early without mapping the rest of the input.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param callback - Called with `(value, index)` for each element; its return
+*   value becomes the corresponding element of the output array.
+* @returns A function that maps a `readonly T[]` to a new `U[]`.
+*
+* @example
+* import { pipe, map } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+*
+* @example
+* // The index is available as the second argument.
+* pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+*/
+function map(callback) {
+	function mapEager(array) {
+		return array.map(callback);
+	}
+	return combineEagerAndLazyFunctions(mapEager, createLazyFunction((value, index, emit) => {
+		emit(callback(value, index));
+	}));
+}
+//#endregion
+export { map };