jsfunx 1.0.1 → 1.0.2

package/jsfunx.cjs

@@ -32,7 +32,11 @@ const and = "and";
 
 /** @type {string} */
 
-const or = "or";
+const bi = "bigint";
+
+/** @type {BigIntConstructor} */
+
+const BI = BigInt;
 
 /** @type {string} */
 
@@ -40,55 +44,95 @@ const bigint = "bigint";
 
 /** @type {string} */
 
-const func = "function";
+const bool = "boolean";
+
+/** @type {BooleanConstructor} */
+
+const Bool = Boolean;
 
 /** @type {string} */
 
-const fun = "function";
+const boolean = "boolean";
 
 /** @type {string} */
 
 const fn = "function";
 
+/** @type {FunctionConstructor} */
+
+const Fn = Function;
+
 /** @type {string} */
 
-const number = "number";
+const fun = "function";
+
+/** @type {FunctionConstructor} */
+
+const Fun = Function;
+
+/** @type {string} */
+
+const func = "function";
+
+/** @type {FunctionConstructor} */
+
+const Func = Function;
+
+/** @type {null} */
+
+const nil = null;
 
 /** @type {string} */
 
 const num = "number";
 
+/** @type {NumberConstructor} */
+
+const Num = Number;
+
 /** @type {string} */
 
-const object = "object";
+const number = "number";
 
 /** @type {string} */
 
 const obj = "object";
 
+/** @type {ObjectConstructor} */
+
+const Obj = Object;
+
 /** @type {string} */
 
-const nil = "object"; // don't use this with objects, use it only with the null primitive.
+const object = "object";
 
 /** @type {string} */
 
-const string = "string";
+const or = "or";
 
 /** @type {string} */
 
 const str = "string";
 
+/** @type {StringConstructor} */
+
+const Str = String;
+
 /** @type {string} */
 
-const symbol = "symbol";
+const string = "string";
 
 /** @type {string} */
 
-const boolean = "boolean";
+const sym = "symbol";
+
+/** @type {SymbolConstructor} */
+
+const Sym = Symbol;
 
 /** @type {string} */
 
-const bool = "boolean";
+const symbol = "symbol";
 
 /** @type {string} */
 
@@ -110,19 +154,21 @@ const undef = "undefined";
  */
 
 function checkType(data, dataType, logic, match, strict) {
-  /** @type {Set<string>} */
+  /** @type {Set<string | null | undefined>} */
 
   let setOfTypes = new Set([
     and,
+    bi,
+    bool,
+    fn,
+    null,
+    num,
+    obj,
     or,
-    bigint,
-    func,
-    number,
-    object,
-    string,
-    symbol,
-    boolean,
+    str,
+    sym,
     undef,
+    undefined,
   ]);
 
   if (!(dataType instanceof Array)) {
@@ -131,6 +177,14 @@ function checkType(data, dataType, logic, match, strict) {
     }
 
     if (!(data instanceof Array)) {
+      if (data === null) {
+        return dataType === null;
+      }
+
+      if (dataType === undefined) {
+        return data === undefined;
+      }
+
       return typeof data === dataType;
     }
 
@@ -142,6 +196,20 @@ function checkType(data, dataType, logic, match, strict) {
       for (let dt of data) {
         // 1 step directly in all cases
 
+        if (dt === null) {
+          if (dataType !== null) {
+            return false;
+          }
+          continue;
+        }
+
+        if (dataType === undefined) {
+          if (dt !== undefined) {
+            return false;
+          }
+          continue;
+        }
+
         if (!(typeof dt === dataType)) {
           return false;
         }
@@ -161,6 +229,20 @@ function checkType(data, dataType, logic, match, strict) {
       for (let dt of data) {
         // 1 step directly in all cases
 
+        if (dt === null) {
+          if (dataType === null) {
+            return true;
+          }
+          continue;
+        }
+
+        if (dataType === undefined) {
+          if (dt === undefined) {
+            return true;
+          }
+          continue;
+        }
+
         if (typeof dt === dataType) {
           return true;
         }
@@ -187,6 +269,20 @@ function checkType(data, dataType, logic, match, strict) {
         throw new TypeError(`type ${dtype} undefined !`);
       }
 
+      if (data === null) {
+        if (dtype === null) {
+          return true;
+        }
+        continue;
+      }
+
+      if (dtype === undefined) {
+        if (data === undefined) {
+          return true;
+        }
+        continue;
+      }
+
       if (typeof data === dtype) {
         return true;
       }
@@ -214,6 +310,20 @@ function checkType(data, dataType, logic, match, strict) {
             throw new TypeError(`type ${dtype} undefined !`);
           }
 
+          if (dt === null) {
+            if (dtype === null) {
+              continue outerLoop;
+            }
+            continue;
+          }
+
+          if (dtype === undefined) {
+            if (dt === undefined) {
+              continue outerLoop;
+            }
+            continue;
+          }
+
           if (typeof dt === dtype) {
             continue outerLoop;
           }
@@ -255,6 +365,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError(`type ${dtype} undefined !`);
       //   //   // }
 
+      //   //   // if (data[0] === null) {
+      //   //   //   if (dtype === null) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dtype === undefined) {
+      //   //   //   if (data[0] === undefined) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -291,6 +415,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError("type undefined !");
       //   //   // }
 
+      //   //   // if (dt === null) {
+      //   //   //   if (dataType[0] !== null) {
+      //   //   //     return false;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dataType[0] === undefined) {
+      //   //   //   if (dt !== undefined) {
+      //   //   //     return false;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (!(typeof dt === dataType[0])) {
       //   //   //   return false;
       //   //   // }
@@ -353,6 +491,20 @@ function checkType(data, dataType, logic, match, strict) {
             throw new TypeError(`type ${dtype} undefined !`);
           }
 
+          if (dt === null) {
+            if (dtype === null) {
+              return true;
+            }
+            continue;
+          }
+
+          if (dtype === undefined) {
+            if (dt === undefined) {
+              return true;
+            }
+            continue;
+          }
+
           if (typeof dt === dtype) {
             return true;
           }
@@ -390,6 +542,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError(`type ${dtype} undefined !`);
       //   //   // }
 
+      //   //   // if (data[0] === null) {
+      //   //   //   if (dtype === null) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dtype === undefined) {
+      //   //   //   if (data[0] === undefined) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -428,6 +594,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError("type undefined !");
       //   //   // }
 
+      //   //   // if (dt === null) {
+      //   //   //   if (dataType[0] === null) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dataType[0] === undefined) {
+      //   //   //   if (dt === undefined) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (typeof dt === dataType[0]) {
       //   //   //   return true;
       //   //   // }
@@ -547,6 +727,20 @@ function checkType(data, dataType, logic, match, strict) {
           throw new TypeError(`type ${dataType[i]} undefined !`);
         }
 
+        if (data[i] === null) {
+          if (dataType[i] !== null) {
+            return false;
+          }
+          continue;
+        }
+
+        if (dataType[i] === undefined) {
+          if (data[i] !== undefined) {
+            return false;
+          }
+          continue;
+        }
+
         if (!(typeof data[i] === dataType[i])) {
           return false;
         }
@@ -572,6 +766,20 @@ function checkType(data, dataType, logic, match, strict) {
           throw new TypeError(`type ${dataType[i]} undefined !`);
         }
 
+        if (data[i] === null) {
+          if (dataType[i] === null) {
+            return true;
+          }
+          continue;
+        }
+
+        if (dataType[i] === undefined) {
+          if (data[i] === undefined) {
+            return true;
+          }
+          continue;
+        }
+
         if (typeof data[i] === dataType[i]) {
           return true;
         }
@@ -600,6 +808,20 @@ function checkType(data, dataType, logic, match, strict) {
         throw new TypeError(`type ${dataType[i]} undefined !`);
       }
 
+      if (data[i] === null) {
+        if (dataType[i] !== null) {
+          return false;
+        }
+        continue;
+      }
+
+      if (dataType[i] === undefined) {
+        if (data[i] !== undefined) {
+          return false;
+        }
+        continue;
+      }
+
       if (!(typeof data[i] === dataType[i])) {
         return false;
       }
@@ -625,6 +847,20 @@ function checkType(data, dataType, logic, match, strict) {
         throw new TypeError(`type ${dataType[i]} undefined !`);
       }
 
+      if (data[i] === null) {
+        if (dataType[i] === null) {
+          return true;
+        }
+        continue;
+      }
+
+      if (dataType[i] === undefined) {
+        if (data[i] === undefined) {
+          return true;
+        }
+        continue;
+      }
+
       if (typeof data[i] === dataType[i]) {
         return true;
       }
@@ -662,7 +898,7 @@ function checkType(data, dataType, logic, match, strict) {
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
-function isinstances(objs, type, logic, match, strict) {
+function isinstancesof(objs, type, logic, match, strict) {
   if (!(type instanceof Array)) {
     // uncomment (return objs instanceof type)
     // to enable the 1/4 of (one to one)
@@ -1216,6 +1452,21 @@ function isinstances(objs, type, logic, match, strict) {
   throw new TypeError("logic type undefined !");
 }
 
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+function echo(data) {
+  if (arguments.length > 1) {
+    throw new TypeError('unexpected token ","');
+  }
+  process.stdout.write(data);
+}
+
 /**
  * Checks whether one or more objects are instances of a given class (or classes),
  * similar to using the `instanceof` operator — but extended to handle arrays
@@ -1260,7 +1511,7 @@ function instancesof(
 
   if (len === 3) {
     if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
-      return isinstances(objs, type, and, logic_or_match, strict);
+      return isinstancesof(objs, type, and, logic_or_match, strict);
     }
   }
 
@@ -1273,11 +1524,56 @@ function instancesof(
     }
 
     if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
-      return isinstances(objs, type, and, logic_or_match, match_or_strict);
+      return isinstancesof(objs, type, and, logic_or_match, match_or_strict);
     }
   }
 
-  return isinstances(objs, type, logic_or_match, match_or_strict, strict);
+  return isinstancesof(objs, type, logic_or_match, match_or_strict, strict);
+}
+
+/**
+ * Checks whether an object is an instance of a given class or constructor.
+ *
+ * @function
+ * @param {any} obj - The object to check.
+ * @param {Function} cls - The class or constructor to check against.
+ * @returns {boolean} True if `obj` is an instance of `cls`, otherwise false.
+ * @throws {TypeError} If `cls` is not a valid constructor.
+ */
+
+function isinstance(obj, cls) {
+  try {
+    return obj instanceof cls;
+  } catch (error) {
+    throw new TypeError("Right-hand side of 'isinstance' is not callable");
+  }
+}
+
+/**
+ * Checks whether one or more objects are instances of a given class (or classes),
+ * similar to using the `instanceof` operator — but extended to handle arrays
+ * and multiple constructors with logical control.
+ *
+ * Works like a plural form of `instanceof`, allowing you to check several objects
+ * against one or more classes, using `"and"` or `"or"` logic.
+ *
+ * @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.
+ * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
+ */
+
+function isinstances(
+  objs,
+  type,
+  logic_or_match = and,
+  match_or_strict = true,
+  strict = true
+) {
+  return instancesof(objs, type, logic_or_match, match_or_strict, strict);
 }
 
 /**
@@ -1342,6 +1638,22 @@ function isType(
   return checkType(data, dataType, logic_or_match, match_or_strict, strict);
 }
 
+/**
+ * Returns the length of an iterable or object that has a `length` property.
+ *
+ * @function
+ * @param {any} iter - The value to measure. Must have a `length` property.
+ * @returns {number} The length of the given value.
+ * @throws {TypeError} If the value does not have a `length` property.
+ */
+
+function len(iter) {
+  if (iter.length === undefined) {
+    throw new TypeError(`type '${typeof iter}' has no len()`);
+  }
+  return iter.length;
+}
+
 /**
  * Checks whether all provided values have the same length.
  * Each value must have a numeric `length` property (e.g., arrays, strings, typed arrays, etc.).
@@ -1397,6 +1709,35 @@ function lengths(...objs) {
   return [lens, equal];
 }
 
+/**
+ * Checks whether all provided values have the same length.
+ * Each value must have a numeric `length` property (e.g., arrays, strings, typed arrays, etc.).
+ *
+ * If all lengths are equal, returns a tuple containing that length and `true`.
+ * Otherwise, returns a tuple containing an array of all detected lengths and `false`.
+ *
+ * @param {...{length: number}} objs - The values to compare by their length property.
+ * @returns {[number | number[], boolean]} A tuple:
+ *   - `[length, true]` if all values have the same length.
+ *   - `[lengths, false]` if the lengths differ.
+ */
+
+function lens(...objs) {
+  return lengths(...objs);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+function log(...data) {
+  console.log(...data);
+}
+
 /**
  * Evaluates the truthiness of a given value.
  * Works like the logical NOT operator (`!`), returning `true` if the value is falsy and `false` if it is truthy.
@@ -1417,6 +1758,86 @@ function not(obj) {
   return obj?.length === 0 || !obj; // handling the object case
 }
 
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+function print(...data) {
+  console.log(...data);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+function printf(data) {
+  if (arguments.length > 1) {
+    throw new TypeError('unexpected token ","');
+  }
+  process.stdout.write(...data);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+function println(...data) {
+  console.log(...data);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+function puts(...data) {
+  console.log(...data);
+}
+
+/**
+ * Returns the JavaScript type of a value using the `typeof` operator.
+ *
+ * @function
+ * @param {any} data - The value whose type will be determined.
+ * @returns {string} The type of the value (e.g., "string", "number", "object", "undefined").
+ */
+
+function type(data) {
+  return typeof data;
+}
+
+/**
+ * Checks whether all provided values are of the same type.
+ * Similar to the `typeof` operator but supports multiple inputs.
+ *
+ * If all values share the same type, returns a tuple containing that type as a string and `true`.
+ * Otherwise, returns a tuple containing an array of the detected types and `false`.
+ *
+ * @param {...*} objs - The values to check.
+ * @returns {[string | string[], boolean]} A tuple:
+ *   - `[type, true]` if all values are of the same type.
+ *   - `[types, false]` if values have mixed types.
+ */
+
+function types(...objs) {
+  return typesof(...objs);
+}
+
 /**
  * Checks whether all provided values are of the same type.
  * Similar to the `typeof` operator but supports multiple inputs.
@@ -1714,26 +2135,50 @@ if (require.main === module) {
 
 module.exports = {
   and,
-  or,
+  bi,
+  BI,
   bigint,
-  func,
-  fun,
+  bool,
+  Bool,
+  boolean,
   fn,
-  number,
+  Fn,
+  fun,
+  Fun,
+  func,
+  Func,
+  nil,
   num,
-  object,
+  Num,
+  number,
   obj,
-  nil,
-  string,
+  Obj,
+  object,
+  or,
   str,
+  Str,
+  string,
+  sym,
+  Sym,
   symbol,
-  boolean,
-  bool,
   undef,
+
+  echo,
   instancesof,
+  isinstance,
+  isinstances,
   isType,
+  len,
   lengths,
+  lens,
+  log,
   not,
+  print,
+  printf,
+  println,
+  puts,
+  type,
+  types,
   typesof,
   $,
 };

package/jsfunx.mjs

@@ -38,7 +38,11 @@ export const and = "and";
 
 /** @type {string} */
 
-export const or = "or";
+export const bi = "bigint";
+
+/** @type {BigIntConstructor} */
+
+export const BI = BigInt;
 
 /** @type {string} */
 
@@ -46,55 +50,95 @@ export const bigint = "bigint";
 
 /** @type {string} */
 
-export const func = "function";
+export const bool = "boolean";
+
+/** @type {BooleanConstructor} */
+
+export const Bool = Boolean;
 
 /** @type {string} */
 
-export const fun = "function";
+export const boolean = "boolean";
 
 /** @type {string} */
 
 export const fn = "function";
 
+/** @type {FunctionConstructor} */
+
+export const Fn = Function;
+
 /** @type {string} */
 
-export const number = "number";
+export const fun = "function";
+
+/** @type {FunctionConstructor} */
+
+export const Fun = Function;
+
+/** @type {string} */
+
+export const func = "function";
+
+/** @type {FunctionConstructor} */
+
+export const Func = Function;
+
+/** @type {null} */
+
+export const nil = null;
 
 /** @type {string} */
 
 export const num = "number";
 
+/** @type {NumberConstructor} */
+
+export const Num = Number;
+
 /** @type {string} */
 
-export const object = "object";
+export const number = "number";
 
 /** @type {string} */
 
 export const obj = "object";
 
+/** @type {ObjectConstructor} */
+
+export const Obj = Object;
+
 /** @type {string} */
 
-export const nil = "object"; // don't use this with objects, use it only with the null primitive.
+export const object = "object";
 
 /** @type {string} */
 
-export const string = "string";
+export const or = "or";
 
 /** @type {string} */
 
 export const str = "string";
 
+/** @type {StringConstructor} */
+
+export const Str = String;
+
 /** @type {string} */
 
-export const symbol = "symbol";
+export const string = "string";
 
 /** @type {string} */
 
-export const boolean = "boolean";
+export const sym = "symbol";
+
+/** @type {SymbolConstructor} */
+
+export const Sym = Symbol;
 
 /** @type {string} */
 
-export const bool = "boolean";
+export const symbol = "symbol";
 
 /** @type {string} */
 
@@ -116,19 +160,21 @@ export const undef = "undefined";
  */
 
 function checkType(data, dataType, logic, match, strict) {
-  /** @type {Set<string>} */
+  /** @type {Set<string | null | undefined>} */
 
   let setOfTypes = new Set([
     and,
+    bi,
+    bool,
+    fn,
+    null,
+    num,
+    obj,
     or,
-    bigint,
-    func,
-    number,
-    object,
-    string,
-    symbol,
-    boolean,
+    str,
+    sym,
     undef,
+    undefined,
   ]);
 
   if (!(dataType instanceof Array)) {
@@ -137,6 +183,14 @@ function checkType(data, dataType, logic, match, strict) {
     }
 
     if (!(data instanceof Array)) {
+      if (data === null) {
+        return dataType === null;
+      }
+
+      if (dataType === undefined) {
+        return data === undefined;
+      }
+
       return typeof data === dataType;
     }
 
@@ -148,6 +202,20 @@ function checkType(data, dataType, logic, match, strict) {
       for (let dt of data) {
         // 1 step directly in all cases
 
+        if (dt === null) {
+          if (dataType !== null) {
+            return false;
+          }
+          continue;
+        }
+
+        if (dataType === undefined) {
+          if (dt !== undefined) {
+            return false;
+          }
+          continue;
+        }
+
         if (!(typeof dt === dataType)) {
           return false;
         }
@@ -167,6 +235,20 @@ function checkType(data, dataType, logic, match, strict) {
       for (let dt of data) {
         // 1 step directly in all cases
 
+        if (dt === null) {
+          if (dataType === null) {
+            return true;
+          }
+          continue;
+        }
+
+        if (dataType === undefined) {
+          if (dt === undefined) {
+            return true;
+          }
+          continue;
+        }
+
         if (typeof dt === dataType) {
           return true;
         }
@@ -193,6 +275,20 @@ function checkType(data, dataType, logic, match, strict) {
         throw new TypeError(`type ${dtype} undefined !`);
       }
 
+      if (data === null) {
+        if (dtype === null) {
+          return true;
+        }
+        continue;
+      }
+
+      if (dtype === undefined) {
+        if (data === undefined) {
+          return true;
+        }
+        continue;
+      }
+
       if (typeof data === dtype) {
         return true;
       }
@@ -220,6 +316,20 @@ function checkType(data, dataType, logic, match, strict) {
             throw new TypeError(`type ${dtype} undefined !`);
           }
 
+          if (dt === null) {
+            if (dtype === null) {
+              continue outerLoop;
+            }
+            continue;
+          }
+
+          if (dtype === undefined) {
+            if (dt === undefined) {
+              continue outerLoop;
+            }
+            continue;
+          }
+
           if (typeof dt === dtype) {
             continue outerLoop;
           }
@@ -261,6 +371,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError(`type ${dtype} undefined !`);
       //   //   // }
 
+      //   //   // if (data[0] === null) {
+      //   //   //   if (dtype === null) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dtype === undefined) {
+      //   //   //   if (data[0] === undefined) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -297,6 +421,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError("type undefined !");
       //   //   // }
 
+      //   //   // if (dt === null) {
+      //   //   //   if (dataType[0] !== null) {
+      //   //   //     return false;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dataType[0] === undefined) {
+      //   //   //   if (dt !== undefined) {
+      //   //   //     return false;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (!(typeof dt === dataType[0])) {
       //   //   //   return false;
       //   //   // }
@@ -359,6 +497,20 @@ function checkType(data, dataType, logic, match, strict) {
             throw new TypeError(`type ${dtype} undefined !`);
           }
 
+          if (dt === null) {
+            if (dtype === null) {
+              return true;
+            }
+            continue;
+          }
+
+          if (dtype === undefined) {
+            if (dt === undefined) {
+              return true;
+            }
+            continue;
+          }
+
           if (typeof dt === dtype) {
             return true;
           }
@@ -396,6 +548,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError(`type ${dtype} undefined !`);
       //   //   // }
 
+      //   //   // if (data[0] === null) {
+      //   //   //   if (dtype === null) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dtype === undefined) {
+      //   //   //   if (data[0] === undefined) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (typeof data[0] === dtype) {
       //   //   //   return true;
       //   //   // }
@@ -434,6 +600,20 @@ function checkType(data, dataType, logic, match, strict) {
       //   //   //   throw new TypeError("type undefined !");
       //   //   // }
 
+      //   //   // if (dt === null) {
+      //   //   //   if (dataType[0] === null) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
+      //   //   // if (dataType[0] === undefined) {
+      //   //   //   if (dt === undefined) {
+      //   //   //     return true;
+      //   //   //   }
+      //   //   //   continue;
+      //   //   // }
+
       //   //   // if (typeof dt === dataType[0]) {
       //   //   //   return true;
       //   //   // }
@@ -553,6 +733,20 @@ function checkType(data, dataType, logic, match, strict) {
           throw new TypeError(`type ${dataType[i]} undefined !`);
         }
 
+        if (data[i] === null) {
+          if (dataType[i] !== null) {
+            return false;
+          }
+          continue;
+        }
+
+        if (dataType[i] === undefined) {
+          if (data[i] !== undefined) {
+            return false;
+          }
+          continue;
+        }
+
         if (!(typeof data[i] === dataType[i])) {
           return false;
         }
@@ -578,6 +772,20 @@ function checkType(data, dataType, logic, match, strict) {
           throw new TypeError(`type ${dataType[i]} undefined !`);
         }
 
+        if (data[i] === null) {
+          if (dataType[i] === null) {
+            return true;
+          }
+          continue;
+        }
+
+        if (dataType[i] === undefined) {
+          if (data[i] === undefined) {
+            return true;
+          }
+          continue;
+        }
+
         if (typeof data[i] === dataType[i]) {
           return true;
         }
@@ -606,6 +814,20 @@ function checkType(data, dataType, logic, match, strict) {
         throw new TypeError(`type ${dataType[i]} undefined !`);
       }
 
+      if (data[i] === null) {
+        if (dataType[i] !== null) {
+          return false;
+        }
+        continue;
+      }
+
+      if (dataType[i] === undefined) {
+        if (data[i] !== undefined) {
+          return false;
+        }
+        continue;
+      }
+
       if (!(typeof data[i] === dataType[i])) {
         return false;
       }
@@ -631,6 +853,20 @@ function checkType(data, dataType, logic, match, strict) {
         throw new TypeError(`type ${dataType[i]} undefined !`);
       }
 
+      if (data[i] === null) {
+        if (dataType[i] === null) {
+          return true;
+        }
+        continue;
+      }
+
+      if (dataType[i] === undefined) {
+        if (data[i] === undefined) {
+          return true;
+        }
+        continue;
+      }
+
       if (typeof data[i] === dataType[i]) {
         return true;
       }
@@ -668,7 +904,7 @@ function checkType(data, dataType, logic, match, strict) {
  * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
  */
 
-function isinstances(objs, type, logic, match, strict) {
+function isinstancesof(objs, type, logic, match, strict) {
   if (!(type instanceof Array)) {
     // uncomment (return objs instanceof type)
     // to enable the 1/4 of (one to one)
@@ -1222,6 +1458,21 @@ function isinstances(objs, type, logic, match, strict) {
   throw new TypeError("logic type undefined !");
 }
 
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+export function echo(data) {
+  if (arguments.length > 1) {
+    throw new TypeError('unexpected token ","');
+  }
+  process.stdout.write(data);
+}
+
 /**
  * Checks whether one or more objects are instances of a given class (or classes),
  * similar to using the `instanceof` operator — but extended to handle arrays
@@ -1266,7 +1517,7 @@ export function instancesof(
 
   if (len === 3) {
     if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
-      return isinstances(objs, type, and, logic_or_match, strict);
+      return isinstancesof(objs, type, and, logic_or_match, strict);
     }
   }
 
@@ -1279,11 +1530,56 @@ export function instancesof(
     }
 
     if (checkType(arguments[2], boolean) || arguments[2] instanceof Boolean) {
-      return isinstances(objs, type, and, logic_or_match, match_or_strict);
+      return isinstancesof(objs, type, and, logic_or_match, match_or_strict);
     }
   }
 
-  return isinstances(objs, type, logic_or_match, match_or_strict, strict);
+  return isinstancesof(objs, type, logic_or_match, match_or_strict, strict);
+}
+
+/**
+ * Checks whether an object is an instance of a given class or constructor.
+ *
+ * @function
+ * @param {any} obj - The object to check.
+ * @param {Function} cls - The class or constructor to check against.
+ * @returns {boolean} True if `obj` is an instance of `cls`, otherwise false.
+ * @throws {TypeError} If `cls` is not a valid constructor.
+ */
+
+export function isinstance(obj, cls) {
+  try {
+    return obj instanceof cls;
+  } catch (error) {
+    throw new TypeError("Right-hand side of 'isinstance' is not callable");
+  }
+}
+
+/**
+ * Checks whether one or more objects are instances of a given class (or classes),
+ * similar to using the `instanceof` operator — but extended to handle arrays
+ * and multiple constructors with logical control.
+ *
+ * Works like a plural form of `instanceof`, allowing you to check several objects
+ * against one or more classes, using `"and"` or `"or"` logic.
+ *
+ * @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.
+ * @returns {boolean} `true` if the provided object(s) match the given type(s) according to the chosen logic, otherwise `false`.
+ */
+
+export function isinstances(
+  objs,
+  type,
+  logic_or_match = and,
+  match_or_strict = true,
+  strict = true
+) {
+  return instancesof(objs, type, logic_or_match, match_or_strict, strict);
 }
 
 /**
@@ -1348,6 +1644,22 @@ export function isType(
   return checkType(data, dataType, logic_or_match, match_or_strict, strict);
 }
 
+/**
+ * Returns the length of an iterable or object that has a `length` property.
+ *
+ * @function
+ * @param {any} iter - The value to measure. Must have a `length` property.
+ * @returns {number} The length of the given value.
+ * @throws {TypeError} If the value does not have a `length` property.
+ */
+
+export function len(iter) {
+  if (iter.length === undefined) {
+    throw new TypeError(`type '${typeof iter}' has no len()`);
+  }
+  return iter.length;
+}
+
 /**
  * Checks whether all provided values have the same length.
  * Each value must have a numeric `length` property (e.g., arrays, strings, typed arrays, etc.).
@@ -1403,6 +1715,35 @@ export function lengths(...objs) {
   return [lens, equal];
 }
 
+/**
+ * Checks whether all provided values have the same length.
+ * Each value must have a numeric `length` property (e.g., arrays, strings, typed arrays, etc.).
+ *
+ * If all lengths are equal, returns a tuple containing that length and `true`.
+ * Otherwise, returns a tuple containing an array of all detected lengths and `false`.
+ *
+ * @param {...{length: number}} objs - The values to compare by their length property.
+ * @returns {[number | number[], boolean]} A tuple:
+ *   - `[length, true]` if all values have the same length.
+ *   - `[lengths, false]` if the lengths differ.
+ */
+
+export function lens(...objs) {
+  return lengths(...objs);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+export function log(...data) {
+  console.log(...data);
+}
+
 /**
  * Evaluates the truthiness of a given value.
  * Works like the logical NOT operator (`!`), returning `true` if the value is falsy and `false` if it is truthy.
@@ -1423,6 +1764,86 @@ export function not(obj) {
   return obj?.length === 0 || !obj; // handling the object case
 }
 
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+export function print(...data) {
+  console.log(...data);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+export function printf(data) {
+  if (arguments.length > 1) {
+    throw new TypeError('unexpected token ","');
+  }
+  process.stdout.write(...data);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+export function println(...data) {
+  console.log(...data);
+}
+
+/**
+ * Logs any number of values to the console.
+ *
+ * @function
+ * @param {...any} data - The values to be logged.
+ * @returns {void}
+ */
+
+export function puts(...data) {
+  console.log(...data);
+}
+
+/**
+ * Returns the JavaScript type of a value using the `typeof` operator.
+ *
+ * @function
+ * @param {any} data - The value whose type will be determined.
+ * @returns {string} The type of the value (e.g., "string", "number", "object", "undefined").
+ */
+
+export function type(data) {
+  return typeof data;
+}
+
+/**
+ * Checks whether all provided values are of the same type.
+ * Similar to the `typeof` operator but supports multiple inputs.
+ *
+ * If all values share the same type, returns a tuple containing that type as a string and `true`.
+ * Otherwise, returns a tuple containing an array of the detected types and `false`.
+ *
+ * @param {...*} objs - The values to check.
+ * @returns {[string | string[], boolean]} A tuple:
+ *   - `[type, true]` if all values are of the same type.
+ *   - `[types, false]` if values have mixed types.
+ */
+
+export function types(...objs) {
+  return typesof(...objs);
+}
+
 /**
  * Checks whether all provided values are of the same type.
  * Similar to the `typeof` operator but supports multiple inputs.

package/package.json

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