text: "use strict";
  
  // Require Internal Dependencies
  const { getObjectType, isTypeOf, isObjectOfType } = require("./src/utils");
  
  /**
   * @constant Primitives
   * @description All JavaScript Primitives
   * @type {Set<string>}
   */
  const Primitives = new Set(["string", "number", "boolean", "undefined", "symbol", "bigint"]);
  
  /**
   * @constant TypedArrayTypes
   * @description All JavaScript Typed Array Types
   * @type {Set<string>}
   */
  const TypedArrayTypes = new Set([
      "Int8Array",
      "Uint8Array",
      "Uint8ClampedArray",
      "Int16Array",
      "Uint16Array",
      "Int32Array",
      "Uint32Array",
      "Float32Array",
      "Float64Array"
  ]);
  
  /**
   * @function nullOrUndefined
   * @param {number} value
   * @returns {number}
   */
  function nullOrUndefined(value) {
      return value === null || typeof value === "undefined";
  }
  
  // Export all methods
  module.exports = {
      undefined: isTypeOf("undefined"),
      void: isTypeOf("undefined"),
      string: isTypeOf("string"),
      number(value) {
          return !Number.isNaN(value) && isTypeOf("number")(value);
      },
      boolean: isTypeOf("boolean"),
      bool: isTypeOf("boolean"),
      symbol: isTypeOf("symbol"),
      bigint: isTypeOf("bigint"),
      func: isTypeOf("function"),
      nullValue: (value) => value === null,
      nullOrUndefined,
      array: Array.isArray,
      buffer: Buffer.isBuffer,
      primitive(value) {
          return value === null || Primitives.has(typeof value);
      },
      promise: isObjectOfType("Promise"),
      generatorFunction: isObjectOfType("GeneratorFunction"),
      asyncFunction: isObjectOfType("AsyncFunction"),
      boundFunction(value) {
          // eslint-disable-next-line no-prototype-builtins
          return isTypeOf("function")(value) && !value.hasOwnProperty("prototype");
      },
      regExp: isObjectOfType("RegExp"),
      date: isObjectOfType("Date"),
      error: isObjectOfType("Error"),
      map: isObjectOfType("Map"),
      set: isObjectOfType("Set"),
      weakMap: isObjectOfType("WeakMap"),
      weakSet: isObjectOfType("WeakSet"),
      int8Array: isObjectOfType("Int8Array"),
      uint8Array: isObjectOfType("Uint8Array"),
      uint8ClampedArray: isObjectOfType("uint8ClampedArray"),
      int16Array: isObjectOfType("int16Array"),
      uint16Array: isObjectOfType("uint16Array"),
      int32Array: isObjectOfType("int32Array"),
      uint32Array: isObjectOfType("uint32Array"),
      float32Array: isObjectOfType("float32Array"),
      float64Array: isObjectOfType("float64Array"),
      arrayBuffer: isObjectOfType("ArrayBuffer"),
      sharedArrayBuffer: isObjectOfType("SharedArrayBuffer"),
      dataView: isObjectOfType("DataView"),
      nan: (value) => Number.isNaN(value),
      integer: (value) => Number.isInteger(value),
      truthy: (value) => Boolean(value),
      falsy: (value) => !value,
      emptyString(value) {
          return typeof value === "string" && value === "";
      },
      plainObject(value) {
          if (getObjectType(value) !== "Object") {
              return false;
          }
          const prototype = Object.getPrototypeOf(value);
  
          return prototype === null || prototype === Object.getPrototypeOf({});
      },
      typedArray(value) {
          return TypedArrayTypes.has(getObjectType(value));
      },
      directInstanceOf(instance, focusClass) {
          return Object.getPrototypeOf(instance) === focusClass.prototype;
      },
      classObject(value) {
          return isTypeOf("function")(value) && value.toString().startsWith("class ");
      },
      object(value) {
          return !nullOrUndefined(value) && (isTypeOf("function")(value) || typeof value === "object");
      },
      iterable(value) {
          return !nullOrUndefined(value) && isTypeOf("function")(value[Symbol.iterator]);
      },
      asyncIterable(value) {
          return !nullOrUndefined(value) && isTypeOf("function")(value[Symbol.asyncIterator]);
      },
      generator(value) {
          const isFn = isTypeOf("function");
  
          return !nullOrUndefined(value) && isFn(value[Symbol.iterator]) && isFn(value.next) && isFn(value.throw);
      },
      utils: { getObjectType }
  };
  