umt 2.2.1 → 2.4.0

package/module/Validate/index.d.ts

@@ -15,4 +15,5 @@ export * from "./isNotEmpty";
 export * from "./isNumber";
 export * from "./isPerfectSquare";
 export * from "./isPrimeNumber";
+export * from "./isString";
 export * from "./isValueNaN";

package/module/Validate/index.js

@@ -17,5 +17,6 @@ export * from "./isNotEmpty";
 export * from "./isNumber";
 export * from "./isPerfectSquare";
 export * from "./isPrimeNumber";
+export * from "./isString";
 export * from "./isValueNaN";
 //# sourceMappingURL=index.js.map

package/module/Validate/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Validate/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AAEzB,iBAAiB;AACjB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Validate/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AAEzB,iBAAiB;AACjB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/module/Validate/isString.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Determines if the value is a string
+ * @param  {unknown} value - Value to check
+ * @returns boolean - True if the value is a string, false otherwise
+ * @example isString("test"); // true
+ * isString(123); // false
+ */
+declare const isString: (value: unknown) => value is string;
+export { isString };

package/module/Validate/isString.js

@@ -0,0 +1,12 @@
+/**
+ * Determines if the value is a string
+ * @param  {unknown} value - Value to check
+ * @returns boolean - True if the value is a string, false otherwise
+ * @example isString("test"); // true
+ * isString(123); // false
+ */
+const isString = (value) => {
+    return typeof value === "string";
+};
+export { isString };
+//# sourceMappingURL=isString.js.map

package/module/Validate/isString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.js","sourceRoot":"","sources":["../../src/Validate/isString.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAmB,EAAE;IACnD,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACnC,CAAC,CAAC;AAEF,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/module/Validate/object/core.d.ts

@@ -2,7 +2,7 @@
  * Object validation core module
  * Provides validation functionality for objects with type-specific validation rules for each property
  */
-import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+import type { Types, ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 /**
  * Creates an object validator with property-specific validation rules
  * @template T - Object type containing validation functions for each property
@@ -12,8 +12,4 @@ import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
  */
 export declare const object: <T extends {
     [key: string]: (value: any) => ValidateCoreReturnType<any>;
-}>(option?: T, message?: string) => (value: { [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }) => {
-    validate: boolean;
-    message: string;
-    type: { [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; };
-};
+}>(option?: T, message?: string) => (value: Types<{ [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }>) => ValidateCoreReturnType<{ [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }>;

package/module/Validate/object/core.js.map

@@ -1 +1 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/object/core.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAGnE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAMpB,SAAY,EAAO,EACnB,OAAgB,EAChB,EAAE;IACF,OAAO,CACL,KAEC,EAKD,EAAE;QACF,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,KAAK;aACZ,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,QAAQ,IAAI,MAAM,EAAE,CAAC;YAC9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAChD,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO;oBACxC,IAAI,EAAE,KAAK;iBACZ,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/object/core.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAOnE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAMpB,SAAY,EAAO,EACnB,OAAgB,EAChB,EAAE;IACF,OAAO,CACL,KAEE,EAGD,EAAE;QACH,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,KAAK;aACZ,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,QAAQ,IAAI,MAAM,EAAE,CAAC;YAC9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAChD,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO;oBACxC,IAAI,EAAE,KAAK;iBACZ,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/module/Validate/type.d.ts

@@ -33,3 +33,4 @@ export type ValidateFunctionType<T> = (value: T) => boolean;
  * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
  */
 export type ValidateType<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T;
+export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ReturnType<T>["type"];

package/module/es5/Array/chunk.js

@@ -12,9 +12,11 @@ exports.chunk = void 0;
 * @example chunk([1, 2, 3, 4, 5, 6, 7, 8, 9], 3); // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 */
 var chunk = exports.chunk = function chunk(array, n) {
-  var result = [];
-  for (var index = 0; index < array.length; index += n) {
-    result.push(array.slice(index, index + n));
+  var length = array.length;
+  // eslint-disable-next-line unicorn/no-new-array
+  var result = new Array(Math.ceil(length / n));
+  for (var index = 0, k = 0; index < length; index += n, k++) {
+    result[k] = array.slice(index, index + n);
   }
   return result;
 };

package/module/es5/Array/dualPivotQuickSort.d.ts

@@ -1,4 +1,4 @@
-type CompareFunction<T> = (a: T, b: T) => number;
+import type { CompareFunction } from "$/array/compareFunction";
 /**
  * Sort array using dual-pivot quicksort algorithm
  * More efficient than traditional quicksort for arrays with many duplicate values
@@ -13,4 +13,3 @@ type CompareFunction<T> = (a: T, b: T) => number;
  * dualPivotQuickSort(['banana', 'apple', 'orange']); // ['apple', 'banana', 'orange']
  */
 export declare const dualPivotQuickSort: <T>(array: T[], compareFunction?: CompareFunction<T>, startIndex?: number, endIndex?: number, insertionSortThreshold?: number) => T[];
-export {};

package/module/es5/Array/dualPivotQuickSort.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.dualPivotQuickSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+var _applyInsertionSortIfNeeded = require("./sortingHelpers/applyInsertionSortIfNeeded");
+var _rangeValidator = require("./sortingHelpers/rangeValidator");
 /**
  * Get the median of three elements in the array
  * @param array - The input array
@@ -120,25 +122,6 @@ var partition = function partition(array, low, high, compareFunction) {
   };
 };
 
-/**
- * Sort small arrays using selection sort
- * @param array - Array to be sorted
- * @param start - Starting index
- * @param end - Ending index
- * @param compareFunction - Comparison function
- */
-var insertionSort = function insertionSort(array, start, end, compareFunction) {
-  for (var index = start + 1; index <= end; index++) {
-    var current = array[index];
-    var index_ = index - 1;
-    while (index_ >= start && compareFunction(array[index_], current) > 0) {
-      array[index_ + 1] = array[index_];
-      index_--;
-    }
-    array[index_ + 1] = current;
-  }
-};
-
 /**
  * Internal implementation of dual-pivot quicksort
  * @param array - Array to be sorted
@@ -148,9 +131,7 @@ var insertionSort = function insertionSort(array, start, end, compareFunction) {
  * @param insertionSortThreshold - Threshold for switching to insertion sort
  */
 var _sortRange = function sortRange(array, start, end, compareFunction, insertionSortThreshold) {
-  // Use insertion sort for small arrays
-  if (end - start + 1 <= insertionSortThreshold) {
-    insertionSort(array, start, end, compareFunction);
+  if ((0, _applyInsertionSortIfNeeded.applyInsertionSortIfNeeded)(array, start, end, compareFunction, insertionSortThreshold)) {
     return;
   }
 
@@ -189,12 +170,11 @@ var dualPivotQuickSort = exports.dualPivotQuickSort = function dualPivotQuickSor
   var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
   var insertionSortThreshold = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
-  // Validate and adjust indices
-  var validStartIndex = Math.max(0, Math.min(startIndex, array.length - 1));
-  var validEndIndex = Math.max(validStartIndex, Math.min(endIndex, array.length - 1));
-
-  // Sort array if valid range exists
-  if (validEndIndex >= validStartIndex) {
+  var _validateRange = (0, _rangeValidator.validateRange)(array, startIndex, endIndex),
+    validStartIndex = _validateRange.startIndex,
+    validEndIndex = _validateRange.endIndex,
+    shouldSort = _validateRange.shouldSort;
+  if (shouldSort) {
     _sortRange(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
   }
   return array;

package/module/es5/Array/quickSort.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.quickSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+var _applyInsertionSortIfNeeded = require("./sortingHelpers/applyInsertionSortIfNeeded");
+var _rangeValidator = require("./sortingHelpers/rangeValidator");
 /**
  * Finds the median value among three elements in the array
  * @param array The array containing the elements
@@ -64,25 +66,6 @@ var partition = function partition(array, low, high, compareFunction) {
   }
 };
 
-/**
- * Sorts a portion of the array using insertion sort algorithm
- * @param array Array to sort
- * @param low Starting index of the range to sort
- * @param high Ending index of the range to sort
- * @param compareFunction Function to compare elements
- */
-var insertionSort = function insertionSort(array, low, high, compareFunction) {
-  for (var index = low + 1; index <= high; index++) {
-    var key = array[index];
-    var currentIndex = index - 1;
-    while (currentIndex >= low && compareFunction(array[currentIndex], key) > 0) {
-      array[currentIndex + 1] = array[currentIndex];
-      currentIndex--;
-    }
-    array[currentIndex + 1] = key;
-  }
-};
-
 /**
  * Internal implementation of the quicksort algorithm with tail-call optimization
  * @param array Array to sort
@@ -95,8 +78,7 @@ var _sortImpl = function sortImpl(array, lowInit, highInit, compareFunction, ins
   var low = lowInit;
   var high = highInit;
   while (low < high) {
-    if (high - low < insertionSortThreshold) {
-      insertionSort(array, low, high, compareFunction);
+    if ((0, _applyInsertionSortIfNeeded.applyInsertionSortIfNeeded)(array, low, high, compareFunction, insertionSortThreshold)) {
       return;
     }
     var pivotIndex = partition(array, low, high, compareFunction);
@@ -128,9 +110,12 @@ var quickSort = exports.quickSort = function quickSort(array) {
   var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
   var insertionSortThreshold = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
-  // Only sort within valid range
-  var validStartIndex = Math.max(0, Math.min(startIndex, array.length - 1));
-  var validEndIndex = Math.max(validStartIndex, Math.min(endIndex, array.length - 1));
-  _sortImpl(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+  var _validateRange = (0, _rangeValidator.validateRange)(array, startIndex, endIndex),
+    validStartIndex = _validateRange.startIndex,
+    validEndIndex = _validateRange.endIndex,
+    shouldSort = _validateRange.shouldSort;
+  if (shouldSort) {
+    _sortImpl(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+  }
   return array;
 };

package/module/es5/Array/sortingHelpers/applyInsertionSortIfNeeded.d.ts

@@ -0,0 +1,13 @@
+import type { CompareFunction } from "$/array/compareFunction";
+/**
+ * Checks if a partition is small enough to apply insertion sort and applies it if so.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array containing the partition.
+ * @param {number} low The starting index of the partition.
+ * @param {number} high The ending index of the partition.
+ * @param {CompareFunction<T>} compareFunction The function to compare elements.
+ * @param {number} insertionSortThreshold The size threshold for switching to insertion sort.
+ * @returns {boolean} True if insertion sort was applied, false otherwise.
+ */
+export declare const applyInsertionSortIfNeeded: <T>(array: T[], low: number, high: number, compareFunction: CompareFunction<T>, insertionSortThreshold: number) => boolean;

package/module/es5/Array/sortingHelpers/applyInsertionSortIfNeeded.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyInsertionSortIfNeeded = void 0;
+var _insertionSort = require("@/Array/insertionSort");
+/**
+ * Checks if a partition is small enough to apply insertion sort and applies it if so.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array containing the partition.
+ * @param {number} low The starting index of the partition.
+ * @param {number} high The ending index of the partition.
+ * @param {CompareFunction<T>} compareFunction The function to compare elements.
+ * @param {number} insertionSortThreshold The size threshold for switching to insertion sort.
+ * @returns {boolean} True if insertion sort was applied, false otherwise.
+ */
+var applyInsertionSortIfNeeded = exports.applyInsertionSortIfNeeded = function applyInsertionSortIfNeeded(array, low, high, compareFunction, insertionSortThreshold) {
+  if (high - low + 1 <= insertionSortThreshold) {
+    (0, _insertionSort.insertionSort)(array, compareFunction, low, high);
+    return true;
+  }
+  return false;
+};

package/module/es5/Array/sortingHelpers/rangeValidator.d.ts

@@ -0,0 +1,17 @@
+export interface ValidatedSortRange {
+    startIndex: number;
+    endIndex: number;
+    shouldSort: boolean;
+}
+/**
+ * Validates and adjusts the start and end indices for an operation on an array.
+ * Ensures indices are within the bounds of the array.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array.
+ * @param {number} startIndex The desired starting index.
+ * @param {number} endIndex The desired ending index.
+ * @returns {ValidatedSortRange} An object containing the validated start index, end index,
+ *                               and a boolean indicating if the operation should proceed on the range.
+ */
+export declare const validateRange: <T>(array: T[], startIndex: number, endIndex: number) => ValidatedSortRange;

package/module/es5/Array/sortingHelpers/rangeValidator.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateRange = void 0;
+/**
+ * Validates and adjusts the start and end indices for an operation on an array.
+ * Ensures indices are within the bounds of the array.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array.
+ * @param {number} startIndex The desired starting index.
+ * @param {number} endIndex The desired ending index.
+ * @returns {ValidatedSortRange} An object containing the validated start index, end index,
+ *                               and a boolean indicating if the operation should proceed on the range.
+ */
+var validateRange = exports.validateRange = function validateRange(array, startIndex, endIndex) {
+  var length = array.length;
+  // Handle empty arrays early
+  if (length === 0) {
+    return {
+      startIndex: 0,
+      endIndex: -1,
+      shouldSort: false
+    };
+  }
+  var validatedStartIndex = Math.max(0, Math.min(startIndex, length - 1));
+  var validatedEndIndex = Math.max(validatedStartIndex, Math.min(endIndex, length - 1));
+  return {
+    startIndex: validatedStartIndex,
+    endIndex: validatedEndIndex,
+    shouldSort: validatedEndIndex >= validatedStartIndex
+  };
+};

package/module/es5/Function/curry.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Curries a function.
+ *
+ * @param func - The function to curry.
+ * @returns The curried function.
+ *
+ * @example
+ * // Example with a function that adds three numbers
+ * const add = (a: number, b: number, c: number) => a + b + c;
+ * const curriedAdd = curry(add);
+ *
+ * console.log(curriedAdd(1)(2)(3)); // Output: 6
+ * console.log(curriedAdd(1, 2)(3)); // Output: 6
+ * console.log(curriedAdd(1, 2, 3)); // Output: 6
+ */
+export declare function curry<Result>(function_: () => Result): () => Result;
+export declare function curry<Argument1, Result>(function_: (argument1: Argument1) => Result): (argument1: Argument1) => Result;
+export declare function curry<Argument1, Argument2, Result>(function_: (argument1: Argument1, argument2: Argument2) => Result): {
+    (argument1: Argument1): (argument2: Argument2) => Result;
+    (argument1: Argument1, argument2: Argument2): Result;
+};
+export declare function curry<Argument1, Argument2, Argument3, Result>(function_: (argument1: Argument1, argument2: Argument2, argument3: Argument3) => Result): {
+    (argument1: Argument1): {
+        (argument2: Argument2): (argument3: Argument3) => Result;
+        (argument2: Argument2, argument3: Argument3): Result;
+    };
+    (argument1: Argument1, argument2: Argument2): (argument3: Argument3) => Result;
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3): Result;
+};
+export declare function curry<Argument1, Argument2, Argument3, Argument4, Result>(function_: (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4) => Result): {
+    (argument1: Argument1): {
+        (argument2: Argument2): {
+            (argument3: Argument3): (argument4: Argument4) => Result;
+            (argument3: Argument3, argument4: Argument4): Result;
+        };
+        (argument2: Argument2, argument3: Argument3): (argument4: Argument4) => Result;
+        (argument2: Argument2, argument3: Argument3, argument4: Argument4): Result;
+    };
+    (argument1: Argument1, argument2: Argument2): {
+        (argument3: Argument3): (argument4: Argument4) => Result;
+        (argument3: Argument3, argument4: Argument4): Result;
+    };
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3): (argument4: Argument4) => Result;
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4): Result;
+};
+export declare function curry<Argument1, Argument2, Argument3, Argument4, Argument5, Result>(function_: (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5) => Result): {
+    (argument1: Argument1): {
+        (argument2: Argument2): {
+            (argument3: Argument3): {
+                (argument4: Argument4): (argument5: Argument5) => Result;
+                (argument4: Argument4, argument5: Argument5): Result;
+            };
+            (argument3: Argument3, argument4: Argument4): (argument5: Argument5) => Result;
+            (argument3: Argument3, argument4: Argument4, argument5: Argument5): Result;
+        };
+        (argument2: Argument2, argument3: Argument3): {
+            (argument4: Argument4): (argument5: Argument5) => Result;
+            (argument4: Argument4, argument5: Argument5): Result;
+        };
+        (argument2: Argument2, argument3: Argument3, argument4: Argument4): (argument5: Argument5) => Result;
+        (argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5): Result;
+    };
+    (argument1: Argument1, argument2: Argument2): {
+        (argument3: Argument3): {
+            (argument4: Argument4): (argument5: Argument5) => Result;
+            (argument4: Argument4, argument5: Argument5): Result;
+        };
+        (argument3: Argument3, argument4: Argument4): (argument5: Argument5) => Result;
+        (argument3: Argument3, argument4: Argument4, argument5: Argument5): Result;
+    };
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3): {
+        (argument4: Argument4): (argument5: Argument5) => Result;
+        (argument4: Argument4, argument5: Argument5): Result;
+    };
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4): (argument5: Argument5) => Result;
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5): Result;
+};
+export declare function curry<Argument1, Argument2, Argument3, Argument4, Argument5, Argument6, Result>(function_: (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5, argument6: Argument6) => Result): {
+    (argument1: Argument1): {
+        (argument2: Argument2): {
+            (argument3: Argument3): {
+                (argument4: Argument4): {
+                    (argument5: Argument5): (argument6: Argument6) => Result;
+                    (argument5: Argument5, argument6: Argument6): Result;
+                };
+                (argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+                (argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+            };
+            (argument3: Argument3, argument4: Argument4): {
+                (argument5: Argument5): (argument6: Argument6) => Result;
+                (argument5: Argument5, argument6: Argument6): Result;
+            };
+            (argument3: Argument3, argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+            (argument3: Argument3, argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+        };
+        (argument2: Argument2, argument3: Argument3): {
+            (argument4: Argument4): {
+                (argument5: Argument5): (argument6: Argument6) => Result;
+                (argument5: Argument5, argument6: Argument6): Result;
+            };
+            (argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+            (argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+        };
+        (argument2: Argument2, argument3: Argument3, argument4: Argument4): {
+            (argument5: Argument5): (argument6: Argument6) => Result;
+            (argument5: Argument5, argument6: Argument6): Result;
+        };
+        (argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+        (argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+    };
+    (argument1: Argument1, argument2: Argument2): {
+        (argument3: Argument3): {
+            (argument4: Argument4): {
+                (argument5: Argument5): (argument6: Argument6) => Result;
+                (argument5: Argument5, argument6: Argument6): Result;
+            };
+            (argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+            (argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+        };
+        (argument3: Argument3, argument4: Argument4): {
+            (argument5: Argument5): (argument6: Argument6) => Result;
+            (argument5: Argument5, argument6: Argument6): Result;
+        };
+        (argument3: Argument3, argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+        (argument3: Argument3, argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+    };
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3): {
+        (argument4: Argument4): {
+            (argument5: Argument5): (argument6: Argument6) => Result;
+            (argument5: Argument5, argument6: Argument6): Result;
+        };
+        (argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+        (argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+    };
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4): {
+        (argument5: Argument5): (argument6: Argument6) => Result;
+        (argument5: Argument5, argument6: Argument6): Result;
+    };
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5): (argument6: Argument6) => Result;
+    (argument1: Argument1, argument2: Argument2, argument3: Argument3, argument4: Argument4, argument5: Argument5, argument6: Argument6): Result;
+};

package/module/es5/Function/curry.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.curry = curry;
+/**
+ * Curries a function.
+ *
+ * @param func - The function to curry.
+ * @returns The curried function.
+ *
+ * @example
+ * // Example with a function that adds three numbers
+ * const add = (a: number, b: number, c: number) => a + b + c;
+ * const curriedAdd = curry(add);
+ *
+ * console.log(curriedAdd(1)(2)(3)); // Output: 6
+ * console.log(curriedAdd(1, 2)(3)); // Output: 6
+ * console.log(curriedAdd(1, 2, 3)); // Output: 6
+ */
+
+function curry(function_) {
+  return function curried() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    if (arguments_.length >= function_.length) {
+      return function_.apply(this, arguments_);
+    }
+    return function () {
+      for (var _len2 = arguments.length, moreArguments = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        moreArguments[_key2] = arguments[_key2];
+      }
+      return Reflect.apply(curried, this, [].concat(arguments_, moreArguments));
+    };
+  };
+}

package/module/es5/Function/index.d.ts

@@ -0,0 +1 @@
+export * from "./curry";

package/module/es5/Function/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _curry = require("./curry");
+Object.keys(_curry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _curry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _curry[key];
+    }
+  });
+});

package/module/es5/Tool/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./createPipeline";
 export * from "./parseJson";
+export * from "./pipe";

package/module/es5/Tool/index.js

@@ -24,4 +24,15 @@ Object.keys(_parseJson).forEach(function (key) {
       return _parseJson[key];
     }
   });
+});
+var _pipe = require("./pipe");
+Object.keys(_pipe).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pipe[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _pipe[key];
+    }
+  });
 });

package/module/es5/Tool/pipe.d.ts

@@ -0,0 +1,66 @@
+import { type Result } from "@/Error/safeExecute";
+/**
+ * A class to handle pipeline processing
+ * Allows chaining transformations in a fluent interface
+ * @template T Type of the current value
+ */
+export declare class Pipe<T> {
+    private readonly value;
+    /**
+     * @param value Current value in the pipe
+     */
+    constructor(value: T);
+    /**
+     * Applies a transformation function and returns a new Pipe instance
+     * @param fn Transformation function to apply
+     * @returns New Pipe instance with transformed value
+     */
+    map<U>(function_: (input: T) => U): Pipe<U>;
+    /**
+     * Applies a transformation function only if the condition is met
+     * @param predicate Condition function
+     * @param fn Transformation function to apply if condition is met
+     * @returns New Pipe instance with conditionally transformed value
+     */
+    when<U>(predicate: (input: T) => boolean, function_: (input: T) => U): Pipe<U | T>;
+    /**
+     * Executes a side effect without changing the value
+     * @param fn Function to execute as a side effect
+     * @returns Same Pipe instance
+     */
+    tap(function_: (input: T) => void): Pipe<T>;
+    /**
+     * Strictly filters the value based on a predicate function
+     * Throws an error if the predicate returns false
+     * @param predicate Condition function that determines if value should be filtered
+     * @returns New Pipe instance with filtered value and narrowed type
+     * @throws Error if the predicate returns false
+     */
+    filterStrict<U extends T>(predicate: (input: T) => input is U): Pipe<U>;
+    /**
+     * Filters the value based on a predicate function
+     * Returns a default value if the predicate returns false
+     * @param predicate Condition function that determines if value should be filtered
+     * @param defaultValue Default value to use if predicate returns false
+     * @returns New Pipe instance with filtered value or default value
+     */
+    filterWithDefault<U extends T>(predicate: (input: T) => input is U, defaultValue: U): Pipe<U>;
+    /**
+     * Filters the value based on a predicate function
+     * Returns a Result type containing either the filtered value or an error
+     * @param predicate Condition function that determines if value should be filtered
+     * @returns New Pipe instance with Result containing filtered value or error
+     */
+    filterResult<U extends T>(predicate: (input: T) => input is U): Pipe<Result<U, Error>>;
+    /**
+     * Terminates the pipeline and returns the final value
+     * @returns Final result of the pipeline processing
+     */
+    end(): T;
+}
+/**
+ * Creates a new Pipe instance with an initial value
+ * @param initialValue Initial value for the pipeline
+ * @returns New Pipe instance
+ */
+export declare function pipe<T>(initialValue: T): Pipe<T>;