jsfunx 1.1.2 → 1.2.1

package/README.md

@@ -9,13 +9,13 @@ The main reason why this library was created is to:
 ### use
 
 ```js
-import { isType, number } from "jsfunx"; // ESM
+import { isType, number, useStrict } from "jsfunx"; // ESM
 
 // or
 
 // "use strict"; // CJS
 
-// const { isType, number } = require("jsfunx"); // CJS
+// const { isType, number, useStrict } = require("jsfunx"); // CJS
 
 /**
  * Adds two numbers together and returns the result.
@@ -27,8 +27,9 @@ import { isType, number } from "jsfunx"; // ESM
  */
 
 function add(num1, num2) {
-  // 35 char
+  useStrict(add, arguments);
 
+  // 35 char
   if (isType([num1, num2], number)) {
     return num1 + num2;
   }
@@ -59,7 +60,6 @@ console.log(add(Number(1), Number(3)));
 
 function add(num1, num2) {
   // 59 char
-
   if (typeof num1 === "number" && typeof num2 === "number") {
     return num1 + num2;
   }
@@ -77,13 +77,13 @@ console.log(add(Number(1), Number(3)));
 ### and
 
 ```js
-import { isType, number, string } from "jsfunx"; // ESM
+import { isType, number, string, useStrict } from "jsfunx"; // ESM
 
 // or
 
 // "use strict"; // CJS
 
-// const { isType, number, string } = require("jsfunx"); // CJS
+// const { isType, number, string, useStrict } = require("jsfunx"); // CJS
 
 /**
  * Prints a message with the given name and age.
@@ -95,8 +95,9 @@ import { isType, number, string } from "jsfunx"; // ESM
  */
 
 function fun(name, age) {
-  // 44 char
+  useStrict(fun, arguments);
 
+  // 44 char
   if (isType([name, age], [string, number])) {
     console.log(`your name is ${name} and your age is ${age}`);
     return;
@@ -128,7 +129,6 @@ fun(String("mohamed"), Number(23));
 
 function fun(name, age) {
   // 58 char
-
   if (typeof name === "string" && typeof age === "number") {
     console.log(`your name is ${name} and your age is ${age}`);
     return;
@@ -147,13 +147,13 @@ fun(String("mohamed"), Number(23));
 ### and
 
 ```js
-import { instancesof } from "jsfunx"; // ESM
+import { instancesof, useStrict } from "jsfunx"; // ESM
 
 // or
 
 // "use strict"; // CJS
 
-// const { instancesof } = require("jsfunx"); // CJS
+// const { instancesof, useStrict } = require("jsfunx"); // CJS
 
 /**
  * Adds two numbers together and returns the result.
@@ -165,8 +165,9 @@ import { instancesof } from "jsfunx"; // ESM
  */
 
 function add(num1, num2) {
-  // 40 char
+  useStrict(add, arguments);
 
+  // 40 char
   if (instancesof([num1, num2], Number)) {
     return new Number(num1 + num2);
   }
@@ -193,7 +194,6 @@ console.log(add(new Number(1), new Number(3)));
 
 function add(num1, num2) {
   // 55 char
-
   if (num1 instanceof Number && num2 instanceof Number) {
     return new Number(num1 + num2);
   }
@@ -207,13 +207,13 @@ console.log(add(new Number(1), new Number(3)));
 ### and
 
 ```js
-import { instancesof } from "jsfunx"; // ESM
+import { instancesof, useStrict } from "jsfunx"; // ESM
 
 // or
 
 // "use strict"; // CJS
 
-// const { instancesof } = require("jsfunx"); // CJS
+// const { instancesof, useStrict } = require("jsfunx"); // CJS
 
 /**
  * Prints a message with the given name and age.
@@ -225,8 +225,9 @@ import { instancesof } from "jsfunx"; // ESM
  */
 
 function fun(name, age) {
-  // 49 char
+  useStrict(fun, arguments);
 
+  // 49 char
   if (instancesof([name, age], [String, Number])) {
     console.log(`your name is ${name} and your age is ${age}`);
     return;
@@ -254,7 +255,6 @@ fun(new String("mohamed"), new Number(23));
 
 function fun(name, age) {
   // 54 char
-
   if (name instanceof String && age instanceof Number) {
     console.log(`your name is ${name} and your age is ${age}`);
     return;
@@ -268,6 +268,10 @@ fun(new String("mohamed"), new Number(23));
 
 but not just this there is other funcs you can see the source code and check all the tests in the main fun.
 
+## Note:
+
+useStrict() was used to enforce strict argument passing in functions.
+
 ## Installation
 
 You can install `jsfunx` via npm:

package/jsfunx.cjs

@@ -153,9 +153,9 @@ const undef = "undefined";
  *
  * @param {* | Array<*>} data - The value or array of values to check.
  * @param {* | Array<*>} dataType - The expected type or array of expected types.
- * @param {"and" | "or"} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match - Whether to compare type names strictly or loosely.
- * @param {boolean} strict - If `true`, enforces strict comparison rules.
+ * @param {("and" | "or") | String} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match - Whether to compare type names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enforces strict comparison rules.
  * @returns {boolean} `true` if the data matches the expected type(s) according to the given logic, otherwise `false`.
  */
 
@@ -783,9 +783,9 @@ function checkType(data, dataType, logic, match, strict) {
  * @template T - The instance type returned by the constructor(s).
  * @param {* | Array<*>} objs - The object or array of objects to test.
  * @param {(new (...args: any[]) => T) | Array<new (...args: any[]) => T>} type - The constructor or list of constructors to test against.
- * @param {"and" | "or"} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match - Whether to compare classes names strictly or loosely.
- * @param {boolean} strict - If `true`, enables strict comparison behavior.
+ * @param {("and" | "or") | String} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match - Whether to compare classes names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enables strict comparison behavior.
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
@@ -1292,9 +1292,9 @@ function echo(data) {
  * @template T - The instance type returned by the constructor(s).
  * @param {*|Array<*>} objs - The object or array of objects to test.
  * @param {(new (...args: any[]) => T) | Array<new (...args: any[]) => T>} type - The constructor or list of constructors to test against.
- * @param {"and" | "or" | boolean} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match_or_strict - Whether to compare classes names strictly or loosely.
- * @param {boolean} strict - If `true`, enables strict comparison behavior.
+ * @param {("and" | "or") | String | (boolean | Boolean)} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match_or_strict - Whether to compare classes names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enables strict comparison behavior.
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
@@ -1333,20 +1333,9 @@ function instancesof(
 
   // ================================================================
 
-  if (len === 3)
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
-      return isinstancesof(objs, type, and, logic_or_match, strict);
-
-  if (len === 4) {
-    if (
-      not(checkType(arguments[3], boolean)) &&
-      not(arguments[3] instanceof Boolean)
-    )
-      throw new TypeError("forth argument must be true or false");
-
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
+  if (len > 2 && len < 5)
+    if (checkType(logic_or_match, boolean) || logic_or_match instanceof Boolean)
       return isinstancesof(objs, type, and, logic_or_match, match_or_strict);
-  }
 
   return isinstancesof(objs, type, logic_or_match, match_or_strict, strict);
 }
@@ -1380,9 +1369,9 @@ function isinstance(obj, cls) {
  * @template T - The instance type returned by the constructor(s).
  * @param {*|Array<*>} objs - The object or array of objects to test.
  * @param {(new (...args: any[]) => T) | Array<new (...args: any[]) => T>} type - The constructor or list of constructors to test against.
- * @param {"and" | "or" | boolean} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match_or_strict - Whether to compare classes names strictly or loosely.
- * @param {boolean} strict - If `true`, enables strict comparison behavior.
+ * @param {("and" | "or") | String | (boolean | Boolean)} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match_or_strict - Whether to compare classes names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enables strict comparison behavior.
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
@@ -1405,9 +1394,9 @@ function isinstances(
  *
  * @param {* | Array<*>} data - The value or array of values to check.
  * @param {* | Array<*>} dataType - The expected type or array of expected types.
- * @param {"and" | "or" | boolean} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match_or_strict - Whether to compare type names strictly or loosely.
- * @param {boolean} strict - If `true`, enforces strict comparison rules.
+ * @param {("and" | "or") | String | (boolean | Boolean)} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match_or_strict - Whether to compare type names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enforces strict comparison rules.
  * @returns {boolean} `true` if the data matches the expected type(s) according to the given logic, otherwise `false`.
  */
 
@@ -1446,20 +1435,9 @@ function isType(
 
   // ================================================================
 
-  if (len === 3)
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
-      return checkType(data, dataType, and, logic_or_match, strict);
-
-  if (len === 4) {
-    if (
-      not(checkType(arguments[3], boolean)) &&
-      not(arguments[3] instanceof Boolean)
-    )
-      throw new TypeError("forth argument must be true or false");
-
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
+  if (len > 2 && len < 5)
+    if (checkType(logic_or_match, boolean) || logic_or_match instanceof Boolean)
       return checkType(data, dataType, and, logic_or_match, match_or_strict);
-  }
 
   return checkType(data, dataType, logic_or_match, match_or_strict, strict);
 }
@@ -1566,12 +1544,20 @@ function log(...data) {
  */
 
 function not(obj) {
-  if (arguments.length === 0)
-    throw new TypeError("not() takes exactly one argument (0 given)");
+  /** @type {number} */
+
+  let len = arguments.length;
+
+  if (len !== 1)
+    throw new TypeError(`not() takes exactly one argument (${len} given)`);
+
+  /** @type {*} */
+
+  let val = obj?.valueOf();
 
-  if (obj instanceof Boolean) return obj == false;
+  if (!(val instanceof Object) || val instanceof Function) return !val;
 
-  return obj?.length === 0 || !obj; // handling the object case
+  return val.length === 0 || !val; // handling the true object case
 }
 
 /**
@@ -1624,6 +1610,89 @@ function puts(...data) {
   console.log(...data);
 }
 
+/**
+ * Validates function arguments strictly at runtime.
+ *
+ * Ensures that:
+ * 1. `useStrict` is called with exactly three arguments:
+ *    - `func`: the function to validate against
+ *    - `args`: an array or array-like object of arguments intended for `func`
+ *    - `optional`: optional arguments number in the function
+ * 2. `func` is a function.
+ * 3. `args` is array-like.
+ * 4. `optional` is a number.
+ * 5. The number of elements in `args` greater than or equal the number of parameters `func` expects.
+ * 6. The number of elements in `args` less than or equal the number of parameters `func` + `optional` expects.
+ *
+ * @param {Function} func - The function whose arguments are being validated.
+ * @param {Array|IArguments} args - The array-like object of arguments to check against the function's parameter count.
+ * @param {number | Number} optional - default arguments number in the function.
+ * @param {boolean | Boolean} postArgs - extra argument(s) after positional and optional ones `...args: any[]`.
+ * @throws {TypeError} If called with a number of arguments less than 2.
+ * @throws {TypeError} If called with a number of arguments greater than 3.
+ * @throws {TypeError} If `func` is not a function.
+ * @throws {TypeError} If `args` is not array-like.
+ * @throws {TypeError} If `optional` is a negative number or not a number at all.
+ * @throws {TypeError} If the length of `args` is less than the parameters number of `func`.
+ * @throws {TypeError} If the length of `args` is greater than the parameters number of `func` + `optional`.
+ * @returns {void} This function does not return a value.
+ */
+
+function strict(func, args, optional, postArgs) {
+  if (!(func instanceof Function))
+    throw new TypeError("first argument must be a function");
+
+  if (typeof args !== "object" || typeof args.length !== "number")
+    throw new TypeError("second argument must be array-like");
+
+  if (
+    (typeof optional !== "number" && !(optional instanceof Number)) ||
+    optional < 0
+  )
+    throw new TypeError("third argument must be a positive number");
+
+  /** @type {string} */
+
+  const funcName = func.name;
+
+  /** @type {number} */
+
+  const paramsNumber = func.length;
+
+  /** @type {number} */
+
+  const argsNumber = args.length;
+
+  if (argsNumber < paramsNumber)
+    throw new TypeError(
+      `${funcName}() takes ${paramsNumber} positional argument(s) but ${argsNumber} were given`
+    );
+
+  if (not(postArgs))
+    if (argsNumber > paramsNumber + optional) {
+      if (paramsNumber > 0 && optional > 0)
+        throw new TypeError(
+          `${funcName}() takes ${
+            paramsNumber + optional
+          } arguments in total but ${argsNumber} were given`
+        );
+
+      if (paramsNumber > 0)
+        throw new TypeError(
+          `${funcName}() takes ${paramsNumber} positional argument(s) in total but ${argsNumber} were given`
+        );
+
+      if (optional > 0)
+        throw new TypeError(
+          `${funcName}() takes ${optional} optional argument(s) in total but ${argsNumber} were given`
+        );
+
+      throw new TypeError(
+        `${funcName}() takes no argument(s) but ${argsNumber} were given`
+      );
+    }
+}
+
 /**
  * Returns the JavaScript type of a value using the `typeof` operator.
  *
@@ -1704,31 +1773,14 @@ function typesof(...objs) {
 /**
  * Validates function arguments strictly at runtime.
  *
- * Ensures that:
- * 1. `useStrict` is called with exactly three arguments:
- *    - `func`: the function to validate against
- *    - `args`: an array or array-like object of arguments intended for `func`
- *    - `optional`: optional arguments number in the function
- * 2. `func` is a function.
- * 3. `args` is array-like.
- * 4. `optional` is a number.
- * 5. The number of elements in `args` greater than or equal the number of parameters `func` expects.
- * 6. The number of elements in `args` less than or equal the number of parameters `func` + `optional` expects.
- *
  * @param {Function} func - The function whose arguments are being validated.
  * @param {Array|IArguments} args - The array-like object of arguments to check against the function's parameter count.
- * @param {number} optional - default arguments number in the function.
- * @throws {TypeError} If called with a number of arguments less than 2.
- * @throws {TypeError} If called with a number of arguments greater than 3.
- * @throws {TypeError} If `func` is not a function.
- * @throws {TypeError} If `args` is not array-like.
- * @throws {TypeError} If `optional` is a negative number or not a number at all.
- * @throws {TypeError} If the length of `args` is less than the parameters number of `func`.
- * @throws {TypeError} If the length of `args` is greater than the parameters number of `func` + `optional`.
+ * @param {number | Number} optional_or_postArgs - default arguments number in the function.
+ * @param {boolean | Boolean} postArgs - extra argument(s) after positional and optional ones `...args: any[]`.
  * @returns {void} This function does not return a value.
  */
 
-function useStrict(func, args, optional = 0) {
+function useStrict(func, args, optional_or_postArgs = 0, postArgs = false) {
   /** @type {number} */
 
   const len = arguments.length;
@@ -1740,59 +1792,22 @@ function useStrict(func, args, optional = 0) {
         : "useStrict() missing 2 required arguments: 'func' and 'args'"
     );
 
-  if (len > 3)
-    throw TypeError(
-      `useStrict() takes 3 arguments in total but ${len} were given`
-    );
-
-  if (!(func instanceof Function))
-    throw TypeError("first argument must be a function");
-
-  if (typeof args !== "object" || typeof args.length !== "number")
-    throw TypeError("second argument must be array-like");
-
-  if (typeof optional !== "number" || optional < 0)
-    throw TypeError("third argument must be a positive number");
-
-  /** @type {string} */
-
-  const funcName = func.name;
-
-  /** @type {number} */
-
-  const paramsNumber = func.length;
-
-  /** @type {number} */
-
-  const argsNumber = args.length;
-
-  if (argsNumber < paramsNumber)
-    throw TypeError(
-      `${funcName}() takes ${paramsNumber} positional argument(s) but ${argsNumber} were given`
+  if (len > 4)
+    throw new TypeError(
+      `useStrict() takes 4 arguments in total but ${len} were given`
     );
 
-  if (argsNumber > paramsNumber + optional) {
-    if (paramsNumber > 0 && optional > 0)
-      throw TypeError(
-        `${funcName}() takes ${
-          paramsNumber + optional
-        } arguments in total but ${argsNumber} were given`
-      );
-
-    if (paramsNumber > 0)
-      throw TypeError(
-        `${funcName}() takes ${paramsNumber} positional argument(s) in total but ${argsNumber} were given`
-      );
-
-    if (optional > 0)
-      throw TypeError(
-        `${funcName}() takes ${optional} optional argument(s) in total but ${argsNumber} were given`
-      );
+  if (len === 3) {
+    if (
+      typeof optional_or_postArgs === "boolean" ||
+      optional_or_postArgs instanceof Boolean
+    )
+      strict(func, args, 0, optional_or_postArgs);
 
-    throw TypeError(
-      `${funcName}() takes no argument(s) but ${argsNumber} were given`
-    );
+    return;
   }
+
+  strict(func, args, optional_or_postArgs, postArgs);
 }
 
 /**

package/jsfunx.mjs

@@ -157,9 +157,9 @@ export const undef = "undefined";
  *
  * @param {* | Array<*>} data - The value or array of values to check.
  * @param {* | Array<*>} dataType - The expected type or array of expected types.
- * @param {"and" | "or"} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match - Whether to compare type names strictly or loosely.
- * @param {boolean} strict - If `true`, enforces strict comparison rules.
+ * @param {("and" | "or") | String} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match - Whether to compare type names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enforces strict comparison rules.
  * @returns {boolean} `true` if the data matches the expected type(s) according to the given logic, otherwise `false`.
  */
 
@@ -787,9 +787,9 @@ function checkType(data, dataType, logic, match, strict) {
  * @template T - The instance type returned by the constructor(s).
  * @param {* | Array<*>} objs - The object or array of objects to test.
  * @param {(new (...args: any[]) => T) | Array<new (...args: any[]) => T>} type - The constructor or list of constructors to test against.
- * @param {"and" | "or"} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match - Whether to compare classes names strictly or loosely.
- * @param {boolean} strict - If `true`, enables strict comparison behavior.
+ * @param {("and" | "or") | String} logic - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match - Whether to compare classes names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enables strict comparison behavior.
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
@@ -1296,9 +1296,9 @@ export function echo(data) {
  * @template T - The instance type returned by the constructor(s).
  * @param {*|Array<*>} objs - The object or array of objects to test.
  * @param {(new (...args: any[]) => T) | Array<new (...args: any[]) => T>} type - The constructor or list of constructors to test against.
- * @param {"and" | "or" | boolean} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match_or_strict - Whether to compare classes names strictly or loosely.
- * @param {boolean} strict - If `true`, enables strict comparison behavior.
+ * @param {("and" | "or") | String | (boolean | Boolean)} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match_or_strict - Whether to compare classes names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enables strict comparison behavior.
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
@@ -1337,20 +1337,9 @@ export function instancesof(
 
   // ================================================================
 
-  if (len === 3)
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
-      return isinstancesof(objs, type, and, logic_or_match, strict);
-
-  if (len === 4) {
-    if (
-      not(checkType(arguments[3], boolean)) &&
-      not(arguments[3] instanceof Boolean)
-    )
-      throw new TypeError("forth argument must be true or false");
-
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
+  if (len > 2 && len < 5)
+    if (checkType(logic_or_match, boolean) || logic_or_match instanceof Boolean)
       return isinstancesof(objs, type, and, logic_or_match, match_or_strict);
-  }
 
   return isinstancesof(objs, type, logic_or_match, match_or_strict, strict);
 }
@@ -1384,9 +1373,9 @@ export function isinstance(obj, cls) {
  * @template T - The instance type returned by the constructor(s).
  * @param {*|Array<*>} objs - The object or array of objects to test.
  * @param {(new (...args: any[]) => T) | Array<new (...args: any[]) => T>} type - The constructor or list of constructors to test against.
- * @param {"and" | "or" | boolean} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match_or_strict - Whether to compare classes names strictly or loosely.
- * @param {boolean} strict - If `true`, enables strict comparison behavior.
+ * @param {("and" | "or") | String | (boolean | Boolean)} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match_or_strict - Whether to compare classes names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enables strict comparison behavior.
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
@@ -1409,9 +1398,9 @@ export function isinstances(
  *
  * @param {* | Array<*>} data - The value or array of values to check.
  * @param {* | Array<*>} dataType - The expected type or array of expected types.
- * @param {"and" | "or" | boolean} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
- * @param {boolean} match_or_strict - Whether to compare type names strictly or loosely.
- * @param {boolean} strict - If `true`, enforces strict comparison rules.
+ * @param {("and" | "or") | String | (boolean | Boolean)} logic_or_match - Logic mode: `"and"` requires all matches, `"or"` allows any match.
+ * @param {boolean | Boolean} match_or_strict - Whether to compare type names strictly or loosely.
+ * @param {boolean | Boolean} strict - If `true`, enforces strict comparison rules.
  * @returns {boolean} `true` if the data matches the expected type(s) according to the given logic, otherwise `false`.
  */
 
@@ -1450,20 +1439,9 @@ export function isType(
 
   // ================================================================
 
-  if (len === 3)
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
-      return checkType(data, dataType, and, logic_or_match, strict);
-
-  if (len === 4) {
-    if (
-      not(checkType(arguments[3], boolean)) &&
-      not(arguments[3] instanceof Boolean)
-    )
-      throw new TypeError("forth argument must be true or false");
-
-    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean)
+  if (len > 2 && len < 5)
+    if (checkType(logic_or_match, boolean) || logic_or_match instanceof Boolean)
       return checkType(data, dataType, and, logic_or_match, match_or_strict);
-  }
 
   return checkType(data, dataType, logic_or_match, match_or_strict, strict);
 }
@@ -1570,12 +1548,20 @@ export function log(...data) {
  */
 
 export function not(obj) {
-  if (arguments.length === 0)
-    throw new TypeError("not() takes exactly one argument (0 given)");
+  /** @type {number} */
+
+  let len = arguments.length;
+
+  if (len !== 1)
+    throw new TypeError(`not() takes exactly one argument (${len} given)`);
+
+  /** @type {*} */
+
+  let val = obj?.valueOf();
 
-  if (obj instanceof Boolean) return obj == false;
+  if (!(val instanceof Object) || val instanceof Function) return !val;
 
-  return obj?.length === 0 || !obj; // handling the object case
+  return val.length === 0 || !val; // handling the true object case
 }
 
 /**
@@ -1628,6 +1614,89 @@ export function puts(...data) {
   console.log(...data);
 }
 
+/**
+ * Validates function arguments strictly at runtime.
+ *
+ * Ensures that:
+ * 1. `useStrict` is called with exactly three arguments:
+ *    - `func`: the function to validate against
+ *    - `args`: an array or array-like object of arguments intended for `func`
+ *    - `optional`: optional arguments number in the function
+ * 2. `func` is a function.
+ * 3. `args` is array-like.
+ * 4. `optional` is a number.
+ * 5. The number of elements in `args` greater than or equal the number of parameters `func` expects.
+ * 6. The number of elements in `args` less than or equal the number of parameters `func` + `optional` expects.
+ *
+ * @param {Function} func - The function whose arguments are being validated.
+ * @param {Array|IArguments} args - The array-like object of arguments to check against the function's parameter count.
+ * @param {number | Number} optional - default arguments number in the function.
+ * @param {boolean | Boolean} postArgs - extra argument(s) after positional and optional ones `...args: any[]`.
+ * @throws {TypeError} If called with a number of arguments less than 2.
+ * @throws {TypeError} If called with a number of arguments greater than 3.
+ * @throws {TypeError} If `func` is not a function.
+ * @throws {TypeError} If `args` is not array-like.
+ * @throws {TypeError} If `optional` is a negative number or not a number at all.
+ * @throws {TypeError} If the length of `args` is less than the parameters number of `func`.
+ * @throws {TypeError} If the length of `args` is greater than the parameters number of `func` + `optional`.
+ * @returns {void} This function does not return a value.
+ */
+
+function strict(func, args, optional, postArgs) {
+  if (!(func instanceof Function))
+    throw new TypeError("first argument must be a function");
+
+  if (typeof args !== "object" || typeof args.length !== "number")
+    throw new TypeError("second argument must be array-like");
+
+  if (
+    (typeof optional !== "number" && !(optional instanceof Number)) ||
+    optional < 0
+  )
+    throw new TypeError("third argument must be a positive number");
+
+  /** @type {string} */
+
+  const funcName = func.name;
+
+  /** @type {number} */
+
+  const paramsNumber = func.length;
+
+  /** @type {number} */
+
+  const argsNumber = args.length;
+
+  if (argsNumber < paramsNumber)
+    throw new TypeError(
+      `${funcName}() takes ${paramsNumber} positional argument(s) but ${argsNumber} were given`
+    );
+
+  if (not(postArgs))
+    if (argsNumber > paramsNumber + optional) {
+      if (paramsNumber > 0 && optional > 0)
+        throw new TypeError(
+          `${funcName}() takes ${
+            paramsNumber + optional
+          } arguments in total but ${argsNumber} were given`
+        );
+
+      if (paramsNumber > 0)
+        throw new TypeError(
+          `${funcName}() takes ${paramsNumber} positional argument(s) in total but ${argsNumber} were given`
+        );
+
+      if (optional > 0)
+        throw new TypeError(
+          `${funcName}() takes ${optional} optional argument(s) in total but ${argsNumber} were given`
+        );
+
+      throw new TypeError(
+        `${funcName}() takes no argument(s) but ${argsNumber} were given`
+      );
+    }
+}
+
 /**
  * Returns the JavaScript type of a value using the `typeof` operator.
  *
@@ -1708,31 +1777,19 @@ export function typesof(...objs) {
 /**
  * Validates function arguments strictly at runtime.
  *
- * Ensures that:
- * 1. `useStrict` is called with exactly three arguments:
- *    - `func`: the function to validate against
- *    - `args`: an array or array-like object of arguments intended for `func`
- *    - `optional`: optional arguments number in the function
- * 2. `func` is a function.
- * 3. `args` is array-like.
- * 4. `optional` is a number.
- * 5. The number of elements in `args` greater than or equal the number of parameters `func` expects.
- * 6. The number of elements in `args` less than or equal the number of parameters `func` + `optional` expects.
- *
  * @param {Function} func - The function whose arguments are being validated.
  * @param {Array|IArguments} args - The array-like object of arguments to check against the function's parameter count.
- * @param {number} optional - default arguments number in the function.
- * @throws {TypeError} If called with a number of arguments less than 2.
- * @throws {TypeError} If called with a number of arguments greater than 3.
- * @throws {TypeError} If `func` is not a function.
- * @throws {TypeError} If `args` is not array-like.
- * @throws {TypeError} If `optional` is a negative number or not a number at all.
- * @throws {TypeError} If the length of `args` is less than the parameters number of `func`.
- * @throws {TypeError} If the length of `args` is greater than the parameters number of `func` + `optional`.
+ * @param {number | Number} optional_or_postArgs - default arguments number in the function.
+ * @param {boolean | Boolean} postArgs - extra argument(s) after positional and optional ones `...args: any[]`.
  * @returns {void} This function does not return a value.
  */
 
-export function useStrict(func, args, optional = 0) {
+export function useStrict(
+  func,
+  args,
+  optional_or_postArgs = 0,
+  postArgs = false
+) {
   /** @type {number} */
 
   const len = arguments.length;
@@ -1744,59 +1801,22 @@ export function useStrict(func, args, optional = 0) {
         : "useStrict() missing 2 required arguments: 'func' and 'args'"
     );
 
-  if (len > 3)
-    throw TypeError(
-      `useStrict() takes 3 arguments in total but ${len} were given`
-    );
-
-  if (!(func instanceof Function))
-    throw TypeError("first argument must be a function");
-
-  if (typeof args !== "object" || typeof args.length !== "number")
-    throw TypeError("second argument must be array-like");
-
-  if (typeof optional !== "number" || optional < 0)
-    throw TypeError("third argument must be a positive number");
-
-  /** @type {string} */
-
-  const funcName = func.name;
-
-  /** @type {number} */
-
-  const paramsNumber = func.length;
-
-  /** @type {number} */
-
-  const argsNumber = args.length;
-
-  if (argsNumber < paramsNumber)
-    throw TypeError(
-      `${funcName}() takes ${paramsNumber} positional argument(s) but ${argsNumber} were given`
+  if (len > 4)
+    throw new TypeError(
+      `useStrict() takes 4 arguments in total but ${len} were given`
     );
 
-  if (argsNumber > paramsNumber + optional) {
-    if (paramsNumber > 0 && optional > 0)
-      throw TypeError(
-        `${funcName}() takes ${
-          paramsNumber + optional
-        } arguments in total but ${argsNumber} were given`
-      );
-
-    if (paramsNumber > 0)
-      throw TypeError(
-        `${funcName}() takes ${paramsNumber} positional argument(s) in total but ${argsNumber} were given`
-      );
-
-    if (optional > 0)
-      throw TypeError(
-        `${funcName}() takes ${optional} optional argument(s) in total but ${argsNumber} were given`
-      );
+  if (len === 3) {
+    if (
+      typeof optional_or_postArgs === "boolean" ||
+      optional_or_postArgs instanceof Boolean
+    )
+      strict(func, args, 0, optional_or_postArgs);
 
-    throw TypeError(
-      `${funcName}() takes no argument(s) but ${argsNumber} were given`
-    );
+    return;
   }
+
+  strict(func, args, optional_or_postArgs, postArgs);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsfunx",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "JavaScript utility functions for cleaner, more readable code",
   "main": "./jsfunx.cjs",
   "module": "./jsfunx.mjs",