es-toolkit 1.22.0-dev.696 → 1.22.0-dev.698

package/dist/compat/index.d.mts

@@ -56,6 +56,7 @@ export { MemoizeCache, memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
+export { curryRight } from '../function/curryRight.mjs';
 export { flow } from '../function/flow.mjs';
 export { flowRight } from '../function/flowRight.mjs';
 export { mean } from '../math/mean.mjs';
@@ -79,6 +80,9 @@ export { isUndefined } from '../predicate/isUndefined.mjs';
 export { isLength } from '../predicate/isLength.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
 export { isPrimitive } from '../predicate/isPrimitive.mjs';
+export { isJSONObject } from '../predicate/isJSONObject.mjs';
+export { isJSONValue } from '../predicate/isJSONValue.mjs';
+export { isJSONArray } from '../predicate/isJSONArray.mjs';
 export { isSet } from '../predicate/isSet.mjs';
 export { delay } from '../promise/delay.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';

package/dist/compat/index.d.ts

@@ -56,6 +56,7 @@ export { MemoizeCache, memoize } from '../function/memoize.js';
 export { unary } from '../function/unary.js';
 export { partial } from '../function/partial.js';
 export { partialRight } from '../function/partialRight.js';
+export { curryRight } from '../function/curryRight.js';
 export { flow } from '../function/flow.js';
 export { flowRight } from '../function/flowRight.js';
 export { mean } from '../math/mean.js';
@@ -79,6 +80,9 @@ export { isUndefined } from '../predicate/isUndefined.js';
 export { isLength } from '../predicate/isLength.js';
 export { isFunction } from '../predicate/isFunction.js';
 export { isPrimitive } from '../predicate/isPrimitive.js';
+export { isJSONObject } from '../predicate/isJSONObject.js';
+export { isJSONValue } from '../predicate/isJSONValue.js';
+export { isJSONArray } from '../predicate/isJSONArray.js';
 export { isSet } from '../predicate/isSet.js';
 export { delay } from '../promise/delay.js';
 export { withTimeout } from '../promise/withTimeout.js';

package/dist/compat/index.js

@@ -4,12 +4,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const zipWith = require('../_chunk/zipWith-EOU_KZ.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
-const flowRight = require('../_chunk/flowRight-BzdOZX.js');
+const flowRight = require('../_chunk/flowRight-DD5Qyk.js');
 const range = require('../_chunk/range-BXlMmn.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-BEa9JI.js');
-const isPlainObject$1 = require('../_chunk/isPlainObject-BIekvL.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-CkNwsM.js');
+const toMerged = require('../_chunk/toMerged-DD-s3X.js');
+const isPlainObject$1 = require('../_chunk/isPlainObject-DKBeLp.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-DDVaWr.js');
 const pad$1 = require('../_chunk/pad-Cw2pvt.js');
 
 function castArray(value) {
@@ -1847,6 +1847,7 @@ exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
 exports.after = flowRight.after;
 exports.before = flowRight.before;
+exports.curryRight = flowRight.curryRight;
 exports.flow = flowRight.flow;
 exports.flowRight = flowRight.flowRight;
 exports.memoize = flowRight.memoize;
@@ -1873,6 +1874,9 @@ exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.isDate = isWeakSet$1.isDate;
 exports.isEqual = isWeakSet$1.isEqual;
 exports.isFunction = isWeakSet$1.isFunction;
+exports.isJSONArray = isWeakSet$1.isJSONArray;
+exports.isJSONObject = isWeakSet$1.isJSONObject;
+exports.isJSONValue = isWeakSet$1.isJSONValue;
 exports.isLength = isWeakSet$1.isLength;
 exports.isMap = isWeakSet$1.isMap;
 exports.isNotNil = isWeakSet$1.isNotNil;

package/dist/compat/index.mjs

@@ -56,6 +56,7 @@ export { memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
+export { curryRight } from '../function/curryRight.mjs';
 export { flow } from '../function/flow.mjs';
 export { flowRight } from '../function/flowRight.mjs';
 export { mean } from '../math/mean.mjs';
@@ -80,6 +81,9 @@ export { isNull } from '../predicate/isNull.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
 export { isLength } from '../predicate/isLength.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
+export { isJSONObject } from '../predicate/isJSONObject.mjs';
+export { isJSONValue } from '../predicate/isJSONValue.mjs';
+export { isJSONArray } from '../predicate/isJSONArray.mjs';
 export { isSet } from '../predicate/isSet.mjs';
 export { delay } from '../promise/delay.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';

package/dist/function/curryRight.d.mts

@@ -0,0 +1,140 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ * const curriedNoArgFunc = curryRight(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curryRight<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curryRight(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curryRight<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P2) => (p2: P1) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *  return [a, b];
+ * }
+ * const curriedTwoArgFunc = curryRight(twoArgFunc);
+ * const func = curriedTwoArgFunc(1);
+ * console.log(func(2)); // [2, 1]
+ */
+declare function curryRight<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P2) => (p2: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p1: P3) => (p2: P2) => (p3: P1) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return [a, b, c];
+ * }
+ * const curriedThreeArgFunc = curryRight(threeArgFunc);
+ * const func = curriedThreeArgFunc(1);
+ * const func2 = func(2);
+ * console.log(func2(3)); // [3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P3) => (p2: P2) => (p3: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P4) => (p2: P3) => (p3: P2) => (p4: P1) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *  return [a, b, c, d];
+ * }
+ * const curriedFourArgFunc = curryRight(fourArgFunc);
+ * const func = curriedFourArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * console.log(func3(4)); // [4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P4) => (p2: P3) => (p3: P2) => (p4: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P5) => (p2: P4) => (p3: P3) => (p4: P2) => (p5: P1) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return [a, b, c, d, e];
+ * }
+ * const curriedFiveArgFunc = curryRight(fiveArgFunc);
+ * const func = curriedFiveArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * const func4 = func3(4);
+ * console.log(func4(5)); // [5, 4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P5) => (p2: P4) => (p3: P3) => (p4: P2) => (p5: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curryRight(sum);
+ *
+ * // The parameter `c` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5);
+ */
+declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any;
+
+export { curryRight };

package/dist/function/curryRight.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ * const curriedNoArgFunc = curryRight(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curryRight<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curryRight(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curryRight<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P2) => (p2: P1) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *  return [a, b];
+ * }
+ * const curriedTwoArgFunc = curryRight(twoArgFunc);
+ * const func = curriedTwoArgFunc(1);
+ * console.log(func(2)); // [2, 1]
+ */
+declare function curryRight<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P2) => (p2: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p1: P3) => (p2: P2) => (p3: P1) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return [a, b, c];
+ * }
+ * const curriedThreeArgFunc = curryRight(threeArgFunc);
+ * const func = curriedThreeArgFunc(1);
+ * const func2 = func(2);
+ * console.log(func2(3)); // [3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P3) => (p2: P2) => (p3: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P4) => (p2: P3) => (p3: P2) => (p4: P1) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *  return [a, b, c, d];
+ * }
+ * const curriedFourArgFunc = curryRight(fourArgFunc);
+ * const func = curriedFourArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * console.log(func3(4)); // [4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P4) => (p2: P3) => (p3: P2) => (p4: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P5) => (p2: P4) => (p3: P3) => (p4: P2) => (p5: P1) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return [a, b, c, d, e];
+ * }
+ * const curriedFiveArgFunc = curryRight(fiveArgFunc);
+ * const func = curriedFiveArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * const func4 = func3(4);
+ * console.log(func4(5)); // [5, 4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P5) => (p2: P4) => (p3: P3) => (p4: P2) => (p5: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curryRight(sum);
+ *
+ * // The parameter `c` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5);
+ */
+declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any;
+
+export { curryRight };

package/dist/function/curryRight.mjs

@@ -0,0 +1,21 @@
+function curryRight(func) {
+    if (func.length === 0 || func.length === 1) {
+        return func;
+    }
+    return function (arg) {
+        return makeCurryRight(func, func.length, [arg]);
+    };
+}
+function makeCurryRight(origin, argsLength, args) {
+    if (args.length === argsLength) {
+        return origin(...args);
+    }
+    else {
+        const next = function (arg) {
+            return makeCurryRight(origin, argsLength, [arg, ...args]);
+        };
+        return next;
+    }
+}
+
+export { curryRight };

package/dist/function/index.d.mts

@@ -12,6 +12,7 @@ export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
 export { curry } from './curry.mjs';
+export { curryRight } from './curryRight.mjs';
 export { spread } from './spread.mjs';
 export { flow } from './flow.mjs';
 export { flowRight } from './flowRight.mjs';

package/dist/function/index.d.ts

@@ -12,6 +12,7 @@ export { partial } from './partial.js';
 export { partialRight } from './partialRight.js';
 export { rest } from './rest.js';
 export { curry } from './curry.js';
+export { curryRight } from './curryRight.js';
 export { spread } from './spread.js';
 export { flow } from './flow.js';
 export { flowRight } from './flowRight.js';

package/dist/function/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const flowRight = require('../_chunk/flowRight-BzdOZX.js');
+const flowRight = require('../_chunk/flowRight-DD5Qyk.js');
 
 function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) {
     let pendingAt = null;
@@ -54,6 +54,7 @@ function spread(func) {
 exports.after = flowRight.after;
 exports.ary = flowRight.ary;
 exports.before = flowRight.before;
+exports.curryRight = flowRight.curryRight;
 exports.debounce = flowRight.debounce;
 exports.flow = flowRight.flow;
 exports.flowRight = flowRight.flowRight;

package/dist/function/index.mjs

@@ -12,6 +12,7 @@ export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
 export { curry } from './curry.mjs';
+export { curryRight } from './curryRight.mjs';
 export { spread } from './spread.mjs';
 export { flow } from './flow.mjs';
 export { flowRight } from './flowRight.mjs';

package/dist/index.d.mts

@@ -70,6 +70,7 @@ export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
 export { curry } from './function/curry.mjs';
+export { curryRight } from './function/curryRight.mjs';
 export { spread } from './function/spread.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
@@ -113,6 +114,9 @@ export { isRegExp } from './predicate/isRegExp.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
 export { isSymbol } from './predicate/isSymbol.mjs';
 export { isString } from './predicate/isString.mjs';
+export { isJSONObject } from './predicate/isJSONObject.mjs';
+export { isJSONValue } from './predicate/isJSONValue.mjs';
+export { isJSONArray } from './predicate/isJSONArray.mjs';
 export { isSet } from './predicate/isSet.mjs';
 export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';

package/dist/index.d.ts

@@ -70,6 +70,7 @@ export { partial } from './function/partial.js';
 export { partialRight } from './function/partialRight.js';
 export { rest } from './function/rest.js';
 export { curry } from './function/curry.js';
+export { curryRight } from './function/curryRight.js';
 export { spread } from './function/spread.js';
 export { flow } from './function/flow.js';
 export { flowRight } from './function/flowRight.js';
@@ -113,6 +114,9 @@ export { isRegExp } from './predicate/isRegExp.js';
 export { isBoolean } from './predicate/isBoolean.js';
 export { isSymbol } from './predicate/isSymbol.js';
 export { isString } from './predicate/isString.js';
+export { isJSONObject } from './predicate/isJSONObject.js';
+export { isJSONValue } from './predicate/isJSONValue.js';
+export { isJSONArray } from './predicate/isJSONArray.js';
 export { isSet } from './predicate/isSet.js';
 export { isWeakMap } from './predicate/isWeakMap.js';
 export { isWeakSet } from './predicate/isWeakSet.js';

package/dist/index.js

@@ -5,16 +5,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const zipWith = require('./_chunk/zipWith-EOU_KZ.js');
 const array_index = require('./array/index.js');
 const promise_index = require('./_chunk/index-BGZDR9.js');
-const flowRight = require('./_chunk/flowRight-BzdOZX.js');
+const flowRight = require('./_chunk/flowRight-DD5Qyk.js');
 const function_index = require('./function/index.js');
 const range = require('./_chunk/range-BXlMmn.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
 const math_index = require('./math/index.js');
 const object_index = require('./object/index.js');
-const toMerged = require('./_chunk/toMerged-BEa9JI.js');
-const isWeakSet = require('./_chunk/isWeakSet-CkNwsM.js');
+const toMerged = require('./_chunk/toMerged-DD-s3X.js');
+const isWeakSet = require('./_chunk/isWeakSet-DDVaWr.js');
 const predicate_index = require('./predicate/index.js');
-const isPlainObject = require('./_chunk/isPlainObject-BIekvL.js');
+const isPlainObject = require('./_chunk/isPlainObject-DKBeLp.js');
 const pad = require('./_chunk/pad-Cw2pvt.js');
 const string_index = require('./string/index.js');
 
@@ -84,6 +84,7 @@ exports.withTimeout = promise_index.withTimeout;
 exports.after = flowRight.after;
 exports.ary = flowRight.ary;
 exports.before = flowRight.before;
+exports.curryRight = flowRight.curryRight;
 exports.debounce = flowRight.debounce;
 exports.flow = flowRight.flow;
 exports.flowRight = flowRight.flowRight;
@@ -124,6 +125,9 @@ exports.toMerged = toMerged.toMerged;
 exports.isDate = isWeakSet.isDate;
 exports.isEqual = isWeakSet.isEqual;
 exports.isFunction = isWeakSet.isFunction;
+exports.isJSONArray = isWeakSet.isJSONArray;
+exports.isJSONObject = isWeakSet.isJSONObject;
+exports.isJSONValue = isWeakSet.isJSONValue;
 exports.isLength = isWeakSet.isLength;
 exports.isMap = isWeakSet.isMap;
 exports.isNil = isWeakSet.isNil;

package/dist/index.mjs

@@ -70,6 +70,7 @@ export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
 export { curry } from './function/curry.mjs';
+export { curryRight } from './function/curryRight.mjs';
 export { spread } from './function/spread.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
@@ -113,6 +114,9 @@ export { isRegExp } from './predicate/isRegExp.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
 export { isSymbol } from './predicate/isSymbol.mjs';
 export { isString } from './predicate/isString.mjs';
+export { isJSONObject } from './predicate/isJSONObject.mjs';
+export { isJSONValue } from './predicate/isJSONValue.mjs';
+export { isJSONArray } from './predicate/isJSONArray.mjs';
 export { isSet } from './predicate/isSet.mjs';
 export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';

package/dist/object/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const toMerged = require('../_chunk/toMerged-BEa9JI.js');
+const toMerged = require('../_chunk/toMerged-DD-s3X.js');
 
 function omit(obj, keys) {
     const result = { ...obj };

package/dist/predicate/index.d.mts

@@ -15,6 +15,9 @@ export { isRegExp } from './isRegExp.mjs';
 export { isBoolean } from './isBoolean.mjs';
 export { isSymbol } from './isSymbol.mjs';
 export { isString } from './isString.mjs';
+export { isJSONObject } from './isJSONObject.mjs';
+export { isJSONValue } from './isJSONValue.mjs';
+export { isJSONArray } from './isJSONArray.mjs';
 export { isSet } from './isSet.mjs';
 export { isWeakMap } from './isWeakMap.mjs';
 export { isWeakSet } from './isWeakSet.mjs';

package/dist/predicate/index.d.ts

@@ -15,6 +15,9 @@ export { isRegExp } from './isRegExp.js';
 export { isBoolean } from './isBoolean.js';
 export { isSymbol } from './isSymbol.js';
 export { isString } from './isString.js';
+export { isJSONObject } from './isJSONObject.js';
+export { isJSONValue } from './isJSONValue.js';
+export { isJSONArray } from './isJSONArray.js';
 export { isSet } from './isSet.js';
 export { isWeakMap } from './isWeakMap.js';
 export { isWeakSet } from './isWeakSet.js';

package/dist/predicate/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const isWeakSet = require('../_chunk/isWeakSet-CkNwsM.js');
-const isPlainObject = require('../_chunk/isPlainObject-BIekvL.js');
+const isWeakSet = require('../_chunk/isWeakSet-DDVaWr.js');
+const isPlainObject = require('../_chunk/isPlainObject-DKBeLp.js');
 
 function isError(value) {
     return value instanceof Error;
@@ -24,6 +24,9 @@ function isString(value) {
 exports.isDate = isWeakSet.isDate;
 exports.isEqual = isWeakSet.isEqual;
 exports.isFunction = isWeakSet.isFunction;
+exports.isJSONArray = isWeakSet.isJSONArray;
+exports.isJSONObject = isWeakSet.isJSONObject;
+exports.isJSONValue = isWeakSet.isJSONValue;
 exports.isLength = isWeakSet.isLength;
 exports.isMap = isWeakSet.isMap;
 exports.isNil = isWeakSet.isNil;

package/dist/predicate/index.mjs

@@ -15,6 +15,9 @@ export { isRegExp } from './isRegExp.mjs';
 export { isBoolean } from './isBoolean.mjs';
 export { isSymbol } from './isSymbol.mjs';
 export { isString } from './isString.mjs';
+export { isJSONObject } from './isJSONObject.mjs';
+export { isJSONValue } from './isJSONValue.mjs';
+export { isJSONArray } from './isJSONArray.mjs';
 export { isSet } from './isSet.mjs';
 export { isWeakMap } from './isWeakMap.mjs';
 export { isWeakSet } from './isWeakSet.mjs';

package/dist/predicate/isJSONArray.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Checks if a given value is a valid JSON array.
+ *
+ * A valid JSON array is defined as an array where all items are valid JSON values.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is any[]} - True if the value is a valid JSON array, otherwise false.
+ *
+ * @example
+ * console.log(isJSONArray([1, 2, 3])); // true
+ * console.log(isJSONArray(["string", null, true])); // true
+ * console.log(isJSONArray([1, 2, () => {}])); // false
+ * console.log(isJSONArray("not an array")); // false
+ */
+declare function isJSONArray(value: unknown): value is any[];
+
+export { isJSONArray };

package/dist/predicate/isJSONArray.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if a given value is a valid JSON array.
+ *
+ * A valid JSON array is defined as an array where all items are valid JSON values.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is any[]} - True if the value is a valid JSON array, otherwise false.
+ *
+ * @example
+ * console.log(isJSONArray([1, 2, 3])); // true
+ * console.log(isJSONArray(["string", null, true])); // true
+ * console.log(isJSONArray([1, 2, () => {}])); // false
+ * console.log(isJSONArray("not an array")); // false
+ */
+declare function isJSONArray(value: unknown): value is any[];
+
+export { isJSONArray };

package/dist/predicate/isJSONArray.mjs

@@ -0,0 +1,10 @@
+import { isJSONValue } from './isJSONValue.mjs';
+
+function isJSONArray(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every(item => isJSONValue(item));
+}
+
+export { isJSONArray };