jsfunx 1.0.0 → 1.0.1

package/README.md

@@ -30,7 +30,7 @@ function add(num1, num2) {
     return num1 + num2;
   }
 
-  throw TypeError("invalid arguments");
+  throw new TypeError("invalid arguments");
 }
 
 console.log(add(1, 3));
@@ -156,7 +156,7 @@ function add(num1, num2) {
     return num1 + num2;
   }
 
-  throw TypeError("invalid arguments");
+  throw new TypeError("invalid arguments");
 }
 
 console.log(add(new Number(1), new Number(3)));

package/jsfunx.cjs

@@ -44,18 +44,42 @@ const func = "function";
 
 /** @type {string} */
 
+const fun = "function";
+
+/** @type {string} */
+
+const fn = "function";
+
+/** @type {string} */
+
 const number = "number";
 
 /** @type {string} */
 
+const num = "number";
+
+/** @type {string} */
+
 const object = "object";
 
 /** @type {string} */
 
+const obj = "object";
+
+/** @type {string} */
+
+const nil = "object"; // don't use this with objects, use it only with the null primitive.
+
+/** @type {string} */
+
 const string = "string";
 
 /** @type {string} */
 
+const str = "string";
+
+/** @type {string} */
+
 const symbol = "symbol";
 
 /** @type {string} */
@@ -64,6 +88,10 @@ const boolean = "boolean";
 
 /** @type {string} */
 
+const bool = "boolean";
+
+/** @type {string} */
+
 const undef = "undefined";
 
 /**
@@ -82,14 +110,35 @@ const undef = "undefined";
  */
 
 function checkType(data, dataType, logic, match, strict) {
-  // if data or dataType is Array must be nested Array
+  /** @type {Set<string>} */
+
+  let setOfTypes = new Set([
+    and,
+    or,
+    bigint,
+    func,
+    number,
+    object,
+    string,
+    symbol,
+    boolean,
+    undef,
+  ]);
 
   if (!(dataType instanceof Array)) {
+    if (!setOfTypes.has(dataType)) {
+      throw new TypeError("type undefined !");
+    }
+
     if (!(data instanceof Array)) {
       return typeof data === dataType;
     }
 
-    if (logic === and) {
+    if (data.length === 0) {
+      data[0] = [];
+    }
+
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let dt of data) {
         // 1 step directly in all cases
 
@@ -108,7 +157,7 @@ function checkType(data, dataType, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let dt of data) {
         // 1 step directly in all cases
 
@@ -134,6 +183,10 @@ function checkType(data, dataType, logic, match, strict) {
     for (let dtype of dataType) {
       // 1 step directly in all cases
 
+      if (!setOfTypes.has(dtype)) {
+        throw new TypeError(`type ${dtype} undefined !`);
+      }
+
       if (typeof data === dtype) {
         return true;
       }
@@ -149,10 +202,18 @@ function checkType(data, dataType, logic, match, strict) {
     return false;
   }
 
-  if (!match) {
-    if (logic === and) {
+  if (data.length === 0) {
+    data[0] = [];
+  }
+
+  if (not(match)) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       outerLoop: for (let dt of data) {
         for (let dtype of dataType) {
+          if (!setOfTypes.has(dtype)) {
+            throw new TypeError(`type ${dtype} undefined !`);
+          }
+
           if (typeof dt === dtype) {
             continue outerLoop;
           }
@@ -190,6 +251,10 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
+      //   //   // if (!setOfTypes.has(dtype)) {
+      //   //   //   throw new TypeError(`type ${dtype} undefined !`);
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -222,6 +287,10 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
+      //   //   // if (!setOfTypes.has(dataType[0])) {
+      //   //   //   throw new TypeError("type undefined !");
+      //   //   // }
+
       //   //   // if (!(typeof dt === dataType[0])) {
       //   //   //   return false;
       //   //   // }
@@ -277,9 +346,13 @@ function checkType(data, dataType, logic, match, strict) {
       // return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let dt of data) {
         for (let dtype of dataType) {
+          if (!setOfTypes.has(dtype)) {
+            throw new TypeError(`type ${dtype} undefined !`);
+          }
+
           if (typeof dt === dtype) {
             return true;
           }
@@ -313,6 +386,10 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
+      //   //   // if (!setOfTypes.has(dtype)) {
+      //   //   //   throw new TypeError(`type ${dtype} undefined !`);
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -347,9 +424,13 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
-      //   //   if (typeof dt === dataType[0]) {
-      //   //     return true;
-      //   //   }
+      //   //   // if (!setOfTypes.has(dataType[0])) {
+      //   //   //   throw new TypeError("type undefined !");
+      //   //   // }
+
+      //   //   // if (typeof dt === dataType[0]) {
+      //   //   //   return true;
+      //   //   // }
       //   // }
 
       //   // shared return
@@ -458,10 +539,14 @@ function checkType(data, dataType, logic, match, strict) {
       min = dataType.length;
     }
 
-    if (logic === and) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
+        if (!setOfTypes.has(dataType[i])) {
+          throw new TypeError(`type ${dataType[i]} undefined !`);
+        }
+
         if (!(typeof data[i] === dataType[i])) {
           return false;
         }
@@ -479,10 +564,14 @@ function checkType(data, dataType, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
+        if (!setOfTypes.has(dataType[i])) {
+          throw new TypeError(`type ${dataType[i]} undefined !`);
+        }
+
         if (typeof data[i] === dataType[i]) {
           return true;
         }
@@ -503,10 +592,14 @@ function checkType(data, dataType, logic, match, strict) {
     throw new TypeError("logic type undefined !");
   }
 
-  if (logic === and) {
+  if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
     for (let i = 0; i < data.length; ++i) {
       // 1 step directly in all cases
 
+      if (!setOfTypes.has(dataType[i])) {
+        throw new TypeError(`type ${dataType[i]} undefined !`);
+      }
+
       if (!(typeof data[i] === dataType[i])) {
         return false;
       }
@@ -524,10 +617,14 @@ function checkType(data, dataType, logic, match, strict) {
     return true;
   }
 
-  if (logic === or) {
+  if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
     for (let i = 0; i < data.length; ++i) {
       // 1 step directly in all cases
 
+      if (!setOfTypes.has(dataType[i])) {
+        throw new TypeError(`type ${dataType[i]} undefined !`);
+      }
+
       if (typeof data[i] === dataType[i]) {
         return true;
       }
@@ -586,7 +683,7 @@ function isinstances(objs, type, logic, match, strict) {
       );
     }
 
-    if (logic === and) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let obj of objs) {
         // 1 step directly in all cases
 
@@ -611,7 +708,7 @@ function isinstances(objs, type, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let obj of objs) {
         // 1 step directly in all cases
 
@@ -680,8 +777,12 @@ function isinstances(objs, type, logic, match, strict) {
     );
   }
 
-  if (!match) {
-    if (logic === and) {
+  if (not(match)) {
+    if (objs.length === 0) {
+      objs[0] = [];
+    }
+
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       outerLoop: for (let obj of objs) {
         for (let dt of type) {
           try {
@@ -814,7 +915,7 @@ function isinstances(objs, type, logic, match, strict) {
       // return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let obj of objs) {
         for (let dt of type) {
           try {
@@ -1001,7 +1102,7 @@ function isinstances(objs, type, logic, match, strict) {
       min = type.length;
     }
 
-    if (logic === and) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
@@ -1028,7 +1129,7 @@ function isinstances(objs, type, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
@@ -1058,7 +1159,7 @@ function isinstances(objs, type, logic, match, strict) {
     throw new TypeError("logic type undefined !");
   }
 
-  if (logic === and) {
+  if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
     for (let i = 0; i < objs.length; ++i) {
       // 1 step directly in all cases
 
@@ -1085,7 +1186,7 @@ function isinstances(objs, type, logic, match, strict) {
     return true;
   }
 
-  if (logic === or) {
+  if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
     for (let i = 0; i < objs.length; ++i) {
       // 1 step directly in all cases
 
@@ -1145,7 +1246,7 @@ function instancesof(
 
   if (len < 2) {
     throw new TypeError(
-      len == 1
+      len === 1
         ? "instancesof() missing 1 required arguments: 'type'"
         : "instancesof() missing 2 required arguments: 'objs' and 'type'"
     );
@@ -1158,26 +1259,21 @@ function instancesof(
   }
 
   if (len === 3) {
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return isinstances(objs, type, and, logic_or_match, strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return isinstances(objs, type, and, logic_or_match, strict);
     }
   }
 
   if (len === 4) {
-    switch (arguments[3]) {
-      case true:
-      case false:
-        break;
-      default:
-        throw new TypeError("forth argument must be true or false");
+    if (
+      not(checkType(arguments[3], boolean)) &&
+      not(arguments[3] instanceof Boolean)
+    ) {
+      throw new TypeError("forth argument must be true or false");
     }
 
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return isinstances(objs, type, and, logic_or_match, match_or_strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return isinstances(objs, type, and, logic_or_match, match_or_strict);
     }
   }
 
@@ -1212,7 +1308,7 @@ function isType(
 
   if (len < 2) {
     throw new TypeError(
-      len == 1
+      len === 1
         ? "isType() missing 1 required arguments: 'dataType'"
         : "isType() missing 2 required arguments: 'data' and 'dataType'"
     );
@@ -1225,26 +1321,21 @@ function isType(
   }
 
   if (len === 3) {
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return checkType(data, dataType, and, logic_or_match, strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return checkType(data, dataType, and, logic_or_match, strict);
     }
   }
 
   if (len === 4) {
-    switch (arguments[3]) {
-      case true:
-      case false:
-        break;
-      default:
-        throw new TypeError("forth argument must be true or false");
+    if (
+      not(checkType(arguments[3], boolean)) &&
+      not(arguments[3] instanceof Boolean)
+    ) {
+      throw new TypeError("forth argument must be true or false");
     }
 
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return checkType(data, dataType, and, logic_or_match, match_or_strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return checkType(data, dataType, and, logic_or_match, match_or_strict);
     }
   }
 
@@ -1626,11 +1717,18 @@ module.exports = {
   or,
   bigint,
   func,
+  fun,
+  fn,
   number,
+  num,
   object,
+  obj,
+  nil,
   string,
+  str,
   symbol,
   boolean,
+  bool,
   undef,
   instancesof,
   isType,

package/jsfunx.mjs

@@ -50,18 +50,42 @@ export const func = "function";
 
 /** @type {string} */
 
+export const fun = "function";
+
+/** @type {string} */
+
+export const fn = "function";
+
+/** @type {string} */
+
 export const number = "number";
 
 /** @type {string} */
 
+export const num = "number";
+
+/** @type {string} */
+
 export const object = "object";
 
 /** @type {string} */
 
+export const obj = "object";
+
+/** @type {string} */
+
+export const nil = "object"; // don't use this with objects, use it only with the null primitive.
+
+/** @type {string} */
+
 export const string = "string";
 
 /** @type {string} */
 
+export const str = "string";
+
+/** @type {string} */
+
 export const symbol = "symbol";
 
 /** @type {string} */
@@ -70,6 +94,10 @@ export const boolean = "boolean";
 
 /** @type {string} */
 
+export const bool = "boolean";
+
+/** @type {string} */
+
 export const undef = "undefined";
 
 /**
@@ -88,14 +116,35 @@ export const undef = "undefined";
  */
 
 function checkType(data, dataType, logic, match, strict) {
-  // if data or dataType is Array must be nested Array
+  /** @type {Set<string>} */
+
+  let setOfTypes = new Set([
+    and,
+    or,
+    bigint,
+    func,
+    number,
+    object,
+    string,
+    symbol,
+    boolean,
+    undef,
+  ]);
 
   if (!(dataType instanceof Array)) {
+    if (!setOfTypes.has(dataType)) {
+      throw new TypeError("type undefined !");
+    }
+
     if (!(data instanceof Array)) {
       return typeof data === dataType;
     }
 
-    if (logic === and) {
+    if (data.length === 0) {
+      data[0] = [];
+    }
+
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let dt of data) {
         // 1 step directly in all cases
 
@@ -114,7 +163,7 @@ function checkType(data, dataType, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let dt of data) {
         // 1 step directly in all cases
 
@@ -140,6 +189,10 @@ function checkType(data, dataType, logic, match, strict) {
     for (let dtype of dataType) {
       // 1 step directly in all cases
 
+      if (!setOfTypes.has(dtype)) {
+        throw new TypeError(`type ${dtype} undefined !`);
+      }
+
       if (typeof data === dtype) {
         return true;
       }
@@ -155,10 +208,18 @@ function checkType(data, dataType, logic, match, strict) {
     return false;
   }
 
-  if (!match) {
-    if (logic === and) {
+  if (data.length === 0) {
+    data[0] = [];
+  }
+
+  if (not(match)) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       outerLoop: for (let dt of data) {
         for (let dtype of dataType) {
+          if (!setOfTypes.has(dtype)) {
+            throw new TypeError(`type ${dtype} undefined !`);
+          }
+
           if (typeof dt === dtype) {
             continue outerLoop;
           }
@@ -196,6 +257,10 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
+      //   //   // if (!setOfTypes.has(dtype)) {
+      //   //   //   throw new TypeError(`type ${dtype} undefined !`);
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -228,6 +293,10 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
+      //   //   // if (!setOfTypes.has(dataType[0])) {
+      //   //   //   throw new TypeError("type undefined !");
+      //   //   // }
+
       //   //   // if (!(typeof dt === dataType[0])) {
       //   //   //   return false;
       //   //   // }
@@ -283,9 +352,13 @@ function checkType(data, dataType, logic, match, strict) {
       // return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let dt of data) {
         for (let dtype of dataType) {
+          if (!setOfTypes.has(dtype)) {
+            throw new TypeError(`type ${dtype} undefined !`);
+          }
+
           if (typeof dt === dtype) {
             return true;
           }
@@ -319,6 +392,10 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
+      //   //   // if (!setOfTypes.has(dtype)) {
+      //   //   //   throw new TypeError(`type ${dtype} undefined !`);
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -353,9 +430,13 @@ function checkType(data, dataType, logic, match, strict) {
 
       //   //   // the same as this
 
-      //   //   if (typeof dt === dataType[0]) {
-      //   //     return true;
-      //   //   }
+      //   //   // if (!setOfTypes.has(dataType[0])) {
+      //   //   //   throw new TypeError("type undefined !");
+      //   //   // }
+
+      //   //   // if (typeof dt === dataType[0]) {
+      //   //   //   return true;
+      //   //   // }
       //   // }
 
       //   // shared return
@@ -464,10 +545,14 @@ function checkType(data, dataType, logic, match, strict) {
       min = dataType.length;
     }
 
-    if (logic === and) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
+        if (!setOfTypes.has(dataType[i])) {
+          throw new TypeError(`type ${dataType[i]} undefined !`);
+        }
+
         if (!(typeof data[i] === dataType[i])) {
           return false;
         }
@@ -485,10 +570,14 @@ function checkType(data, dataType, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
+        if (!setOfTypes.has(dataType[i])) {
+          throw new TypeError(`type ${dataType[i]} undefined !`);
+        }
+
         if (typeof data[i] === dataType[i]) {
           return true;
         }
@@ -509,10 +598,14 @@ function checkType(data, dataType, logic, match, strict) {
     throw new TypeError("logic type undefined !");
   }
 
-  if (logic === and) {
+  if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
     for (let i = 0; i < data.length; ++i) {
       // 1 step directly in all cases
 
+      if (!setOfTypes.has(dataType[i])) {
+        throw new TypeError(`type ${dataType[i]} undefined !`);
+      }
+
       if (!(typeof data[i] === dataType[i])) {
         return false;
       }
@@ -530,10 +623,14 @@ function checkType(data, dataType, logic, match, strict) {
     return true;
   }
 
-  if (logic === or) {
+  if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
     for (let i = 0; i < data.length; ++i) {
       // 1 step directly in all cases
 
+      if (!setOfTypes.has(dataType[i])) {
+        throw new TypeError(`type ${dataType[i]} undefined !`);
+      }
+
       if (typeof data[i] === dataType[i]) {
         return true;
       }
@@ -592,7 +689,7 @@ function isinstances(objs, type, logic, match, strict) {
       );
     }
 
-    if (logic === and) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let obj of objs) {
         // 1 step directly in all cases
 
@@ -617,7 +714,7 @@ function isinstances(objs, type, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let obj of objs) {
         // 1 step directly in all cases
 
@@ -686,8 +783,12 @@ function isinstances(objs, type, logic, match, strict) {
     );
   }
 
-  if (!match) {
-    if (logic === and) {
+  if (not(match)) {
+    if (objs.length === 0) {
+      objs[0] = [];
+    }
+
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       outerLoop: for (let obj of objs) {
         for (let dt of type) {
           try {
@@ -820,7 +921,7 @@ function isinstances(objs, type, logic, match, strict) {
       // return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let obj of objs) {
         for (let dt of type) {
           try {
@@ -1007,7 +1108,7 @@ function isinstances(objs, type, logic, match, strict) {
       min = type.length;
     }
 
-    if (logic === and) {
+    if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
@@ -1034,7 +1135,7 @@ function isinstances(objs, type, logic, match, strict) {
       return true;
     }
 
-    if (logic === or) {
+    if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
       for (let i = 0; i < min; ++i) {
         // 1 step directly in all cases
 
@@ -1064,7 +1165,7 @@ function isinstances(objs, type, logic, match, strict) {
     throw new TypeError("logic type undefined !");
   }
 
-  if (logic === and) {
+  if (logic === and || (logic instanceof String && logic.valueOf() === and)) {
     for (let i = 0; i < objs.length; ++i) {
       // 1 step directly in all cases
 
@@ -1091,7 +1192,7 @@ function isinstances(objs, type, logic, match, strict) {
     return true;
   }
 
-  if (logic === or) {
+  if (logic === or || (logic instanceof String && logic.valueOf() === or)) {
     for (let i = 0; i < objs.length; ++i) {
       // 1 step directly in all cases
 
@@ -1151,7 +1252,7 @@ export function instancesof(
 
   if (len < 2) {
     throw new TypeError(
-      len == 1
+      len === 1
         ? "instancesof() missing 1 required arguments: 'type'"
         : "instancesof() missing 2 required arguments: 'objs' and 'type'"
     );
@@ -1164,26 +1265,21 @@ export function instancesof(
   }
 
   if (len === 3) {
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return isinstances(objs, type, and, logic_or_match, strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return isinstances(objs, type, and, logic_or_match, strict);
     }
   }
 
   if (len === 4) {
-    switch (arguments[3]) {
-      case true:
-      case false:
-        break;
-      default:
-        throw new TypeError("forth argument must be true or false");
+    if (
+      not(checkType(arguments[3], boolean)) &&
+      not(arguments[3] instanceof Boolean)
+    ) {
+      throw new TypeError("forth argument must be true or false");
     }
 
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return isinstances(objs, type, and, logic_or_match, match_or_strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return isinstances(objs, type, and, logic_or_match, match_or_strict);
     }
   }
 
@@ -1218,7 +1314,7 @@ export function isType(
 
   if (len < 2) {
     throw new TypeError(
-      len == 1
+      len === 1
         ? "isType() missing 1 required arguments: 'dataType'"
         : "isType() missing 2 required arguments: 'data' and 'dataType'"
     );
@@ -1231,26 +1327,21 @@ export function isType(
   }
 
   if (len === 3) {
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return checkType(data, dataType, and, logic_or_match, strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return checkType(data, dataType, and, logic_or_match, strict);
     }
   }
 
   if (len === 4) {
-    switch (arguments[3]) {
-      case true:
-      case false:
-        break;
-      default:
-        throw new TypeError("forth argument must be true or false");
+    if (
+      not(checkType(arguments[3], boolean)) &&
+      not(arguments[3] instanceof Boolean)
+    ) {
+      throw new TypeError("forth argument must be true or false");
     }
 
-    switch (arguments[2]) {
-      case true:
-      case false:
-        return checkType(data, dataType, and, logic_or_match, match_or_strict);
+    if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
+      return checkType(data, dataType, and, logic_or_match, match_or_strict);
     }
   }
 

package/package.json

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