@nejs/basic-extensions 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Brielle Harrison
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# @nejs/basic-extensions
+
+## Overview
+
+@nejs/basic-extensions is a JavaScript library that provides a collection of essential extensions
+to built-in JavaScript objects like Array, Object, Function, and Reflect. These extensions are
+designed to enhance the native capabilities of JavaScript objects, providing developers with
+additional utility methods for common tasks and improving code readability and efficiency.
+
+## Features
+
+- **Array Extensions**: Adds convenience methods to JavaScript arrays, like `first` and `last`,
+  for easy access to the first and last elements.
+
+- **Object Extensions**: Introduces utility functions to the Object class, such as methods for
+  checking object types and manipulating properties.
+
+- **Function Extensions**: Enriches the Function class with methods to identify function types,
+  such as arrow functions, async functions, and bound functions.
+
+- **Reflect Extensions**: Extends the Reflect object with advanced property interaction methods,
+  including checks for the presence of multiple or specific keys.
+
+## Installation
+
+Install @nejs/basic-extensions using npm:
+
+```bash
+npm install @nejs/basic-extensions
+```
+
+Or using yarn:
+
+```bash
+yarn add @nejs/basic-extensions
+```
+
+## Usage
+
+Import the desired extensions in your JavaScript project:
+
+```javascript
+import { ArrayPrototypeExtensions } from '@nejs/basic-extensions';
+// Use the Array extensions
+```
+
+```javascript
+import { FunctionExtensions } from '@nejs/basic-extensions';
+// Use the Function extensions
+```
+
+## Documentation
+
+For detailed documentation on each extension and its methods, please refer to the respective
+sections in this README or visit our [documentation website](#).
+
+## Contributing
+
+Contributions to @nejs/basic-extensions are always welcome. Please refer to our contributing
+guidelines for more information on how to report issues, submit pull requests, and more.
+
+## License
+
+@nejs/basic-extensions is licensed under the MIT License. See the [LICENSE](LICENSE) file for
+more details.

package/bin/build

@@ -0,0 +1,30 @@
+#!/usr/bin/env zsh
+
+inRoot() {
+  test -e tsconfig.base.json &&
+  test -e tsconfig.esm.json &&
+  test -e tsconfig.cjs.json &&
+  test -e bin &&
+  test -e src
+}
+
+if ! inRoot; then
+  printf "Please move to the root of the package\n"
+  printf "You are currently in $(pwd)\n"
+  exit 1
+fi
+
+# Make dist if missing
+[[ ! -e dist ]] && mkdir dist
+
+# Clean the dist directory
+rm -fr dist/*
+
+# Build ecmascript modules build
+npx tsc -p tsconfig.esm.json
+
+# Build commonjs build
+npx tsc -p tsconfig.cjs.json
+
+# Generate unfortunately necessary sub- package.json files
+bin/fixup

package/bin/fixup

@@ -0,0 +1,13 @@
+#!/usr/bin/env zsh
+
+cat >dist/cjs/package.json <<!EOF
+{
+  "type": "commonjs"
+}
+!EOF
+
+cat >dist/mjs/package.json <<!EOF
+{
+  "type": "module"
+}
+!EOF

package/dist/cjs/arrayextensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `ArrayPrototypeExtensions` patch extends the prototype of the built-in
+ * JavaScript `Array` with additional properties for convenience and improved
+ * readability. By applying this patch, all array instances gain new getter
+ * properties `first` and `last`, which provide quick access to the first and
+ * last elements of the array, respectively. This enhancement simplifies common
+ * operations on arrays and makes code more expressive and concise.
+ */
+export const ArrayPrototypeExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/cjs/arrayextensions.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayPrototypeExtensions = void 0;
+const extension_1 = require("@nejs/extension");
+/**
+ * The `ArrayPrototypeExtensions` patch extends the prototype of the built-in
+ * JavaScript `Array` with additional properties for convenience and improved
+ * readability. By applying this patch, all array instances gain new getter
+ * properties `first` and `last`, which provide quick access to the first and
+ * last elements of the array, respectively. This enhancement simplifies common
+ * operations on arrays and makes code more expressive and concise.
+ */
+exports.ArrayPrototypeExtensions = new extension_1.Patch(Array.prototype, {
+    /**
+     * A getter property that returns the first element of the array. If the
+     * array is empty, it returns `undefined`. This property is useful for
+     * scenarios where you need to quickly access the first item of an array
+     * without the need for additional checks or method calls.
+     *
+     * @returns {*} The first element of the array or `undefined` if the array
+     * is empty.
+     */
+    get first() {
+        return this[0];
+    },
+    /**
+     * A getter property that returns the last element of the array. It
+     * calculates the last index based on the array's length. If the array is
+     * empty, it returns `undefined`. This property is beneficial when you need
+     * to access the last item in an array, improving code readability and
+     * avoiding manual index calculation.
+     *
+     * @returns {*} The last element of the array or `undefined` if the
+     * array is empty.
+     */
+    get last() {
+        return this[this.length - 1];
+    }
+});

package/dist/cjs/functionextensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
+ * constructor. It extends `Function` with additional utility methods for determining the
+ * specific type or nature of function-like objects. These methods allow developers to
+ * distinguish between classes, regular functions, async functions, and arrow functions
+ * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
+ * library and enhances the capabilities of function handling and introspection in JavaScript.
+ */
+export const FunctionExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/cjs/functionextensions.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionExtensions = void 0;
+const extension_1 = require("@nejs/extension");
+/**
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
+ * constructor. It extends `Function` with additional utility methods for determining the
+ * specific type or nature of function-like objects. These methods allow developers to
+ * distinguish between classes, regular functions, async functions, and arrow functions
+ * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
+ * library and enhances the capabilities of function handling and introspection in JavaScript.
+ */
+exports.FunctionExtensions = new extension_1.Patch(Function, {
+    /**
+     * Determines if a given value is a class. It checks if the value is an instance of
+     * `Function` and if its string representation includes the keyword 'class'. This method
+     * is useful for distinguishing classes from other function types in JavaScript.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is a class, otherwise `false`.
+     */
+    isClass(value) {
+        return value instanceof Function && String(value).includes('class');
+    },
+    /**
+     * Checks if a given value is a regular function. This method verifies if the value is
+     * an instance of `Function`, which includes regular functions, classes, and async
+     * functions but excludes arrow functions.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is a regular function, otherwise `false`.
+     */
+    isFunction(value) {
+        return value instanceof Function;
+    },
+    /**
+     * Determines if a given value is an asynchronous function. It checks if the value is an
+     * instance of `Function` and if its string representation includes the keyword 'Async'.
+     * This method is particularly useful for identifying async functions.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is an async function, otherwise `false`.
+     */
+    isAsync(value) {
+        const stringTag = /(\w+)]/g.exec(Object.prototype.toString.call(value))[1];
+        return (value instanceof Function &&
+            stringTag.includes('Async'));
+    },
+    /**
+     * Checks if a given value is an arrow function. It verifies if the value is an instance
+     * of `Function`, if its string representation includes the '=>' symbol, and if it lacks
+     * a prototype, which is a characteristic of arrow functions in JavaScript.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is an arrow function, otherwise `false`.
+     */
+    isBigArrow(value) {
+        return (value instanceof Function &&
+            String(value).includes('=>') &&
+            !String(value).startsWith('bound') &&
+            !Reflect.has(value, 'prototype'));
+    },
+    /**
+     * Determines if a given value is a bound function. Bound functions are created using
+     * the `Function.prototype.bind` method, which allows setting the `this` value at the
+     * time of binding. This method checks if the value is an instance of `Function`, if
+     * its string representation starts with 'bound', and if it lacks a `prototype`
+     * property. These characteristics are indicative of bound functions in JavaScript.
+     *
+     * @param {*} value - The value to be checked, typically a function.
+     * @returns {boolean} Returns `true` if the value is a bound function, otherwise
+     * `false`. Bound functions have a specific format in their string representation
+     * and do not have their own `prototype` property.
+     */
+    isBound(value) {
+        return (value instanceof Function &&
+            String(value).startsWith('bound') &&
+            !Reflect.has(value, 'prototype'));
+    },
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export function enableAll(owners: any): void;
+export function disableAll(owners: any): void;
+import { ObjectExtensions } from './objectextensions.js';
+import { FunctionExtensions } from './functionextensions.js';
+import { ReflectExtensions } from './reflectextensions.js';
+import { ArrayPrototypeExtensions } from './arrayextensions.js';
+export { ObjectExtensions, FunctionExtensions, ReflectExtensions, ArrayPrototypeExtensions };

package/dist/cjs/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayPrototypeExtensions = exports.ReflectExtensions = exports.FunctionExtensions = exports.ObjectExtensions = exports.disableAll = exports.enableAll = void 0;
+const functionextensions_js_1 = require("./functionextensions.js");
+Object.defineProperty(exports, "FunctionExtensions", { enumerable: true, get: function () { return functionextensions_js_1.FunctionExtensions; } });
+const objectextensions_js_1 = require("./objectextensions.js");
+Object.defineProperty(exports, "ObjectExtensions", { enumerable: true, get: function () { return objectextensions_js_1.ObjectExtensions; } });
+const reflectextensions_js_1 = require("./reflectextensions.js");
+Object.defineProperty(exports, "ReflectExtensions", { enumerable: true, get: function () { return reflectextensions_js_1.ReflectExtensions; } });
+const arrayextensions_js_1 = require("./arrayextensions.js");
+Object.defineProperty(exports, "ArrayPrototypeExtensions", { enumerable: true, get: function () { return arrayextensions_js_1.ArrayPrototypeExtensions; } });
+const extension_1 = require("@nejs/extension");
+const Owners = [
+    Object,
+    Function,
+    Reflect,
+    Array.prototype,
+];
+function enableAll(owners) {
+    (owners || Owners).forEach(owner => {
+        extension_1.Patch.enableFor(owner);
+    });
+}
+exports.enableAll = enableAll;
+function disableAll(owners) {
+    (owners || Owners).forEach(owner => {
+        extension_1.Patch.disableFor(owner);
+    });
+}
+exports.disableAll = disableAll;

package/dist/cjs/objectextensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class. It
+ * adds utility methods to the `Object` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `Object` class with additional
+ * utility functions.
+ */
+export const ObjectExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/cjs/objectextensions.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectExtensions = void 0;
+const extension_1 = require("@nejs/extension");
+/**
+ * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class. It
+ * adds utility methods to the `Object` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `Object` class with additional
+ * utility functions.
+ */
+exports.ObjectExtensions = new extension_1.Patch(Object, {
+    /**
+     * Checks if the given value is a valid key for an object. In JavaScript, a valid
+     * key can be either a string or a symbol. This method is useful for validating
+     * object keys before using them in operations like setting or getting object properties.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} - Returns `true` if the value is a valid object key (string or symbol),
+     *                      otherwise `false`.
+     */
+    isValidKey(value) {
+        return (typeof value === 'string' || typeof value === 'symbol');
+    },
+    /**
+     * Determines if the provided value is an object. This method checks whether the
+     * value is an instance of `Object` or if its type is 'object'. It's a utility
+     * method for type-checking, ensuring that a value is an object before performing
+     * operations that are specific to objects.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} - Returns `true` if the value is an object, otherwise `false`.
+     */
+    isObject(value) {
+        return value && (value instanceof Object || typeof value === 'object');
+    },
+    /**
+     * Retrieves the string tag of an object. The string tag is a representation of
+     * the object's type, as defined by its `Object.prototype.toString` method. This
+     * utility method is helpful for getting a more descriptive type of an object than
+     * what is returned by the `typeof` operator, especially for custom objects.
+     *
+     * @param {*} value - The object whose string tag is to be retrieved.
+     * @returns {string} - The string tag of the object, indicating its type.
+     */
+    getStringTag(value) {
+        return /(\w+)]/.exec(Object.prototype.toString.call(value))[1];
+    },
+    /**
+     * Determines the type of the given value based on its string tag. This method
+     * uses `Object.getStringTag` to obtain the string tag of the value, which
+     * represents its more specific type (e.g., Array, Map, Set) rather than just
+     * 'object'. The method then maps this string tag to the corresponding type
+     * present in the provided `owner` object, which defaults to `globalThis`.
+     * This utility method is especially useful for identifying the specific
+     * constructor or class of an object, beyond the basic types identified by
+     * the `typeof` operator.
+     *
+     * @param {any} value - The value whose type is to be determined.
+     * @param {object} [owner=globalThis] - The object in which to look up the
+     * constructor corresponding to the string tag. Defaults to `globalThis`, which
+     * covers global constructors like `Array`, `Object`, etc.
+     * @returns {Function|object|null|undefined} - Returns the constructor or type
+     * of the value based on its string tag. For 'Null' and 'Undefined', it returns
+     * `null` and `undefined`, respectively. For other types, it returns the
+     * corresponding constructor (e.g., `Array` for arrays) if available in the
+     * `owner` object.
+     */
+    getType(value, owner = globalThis) {
+        const stringTag = Object.getStringTag(value);
+        switch (stringTag) {
+            case 'Null': return null;
+            case 'Undefined': return undefined;
+            default:
+                return owner[stringTag];
+        }
+    },
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/reflectextensions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
+ * `Reflect` object. It extends `Reflect` with additional utility methods that
+ * enhance its capabilities. These methods provide more advanced ways of
+ * interacting with object properties, such as checking for the presence of
+ * multiple keys at once (`hasAll`) or verifying if at least one specified key
+ * exists in an object (`hasSome`). This class is part of the `@nejs/extension`
+ * library and is designed to offer these extended functionalities in a way
+ * that is consistent with the existing `Reflect` API, making it intuitive for
+ * developers who are already familiar with standard reflection methods in
+ * JavaScript.
+ */
+export const ReflectExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/cjs/reflectextensions.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectExtensions = void 0;
+const extension_1 = require("@nejs/extension");
+/**
+ * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
+ * `Reflect` object. It extends `Reflect` with additional utility methods that
+ * enhance its capabilities. These methods provide more advanced ways of
+ * interacting with object properties, such as checking for the presence of
+ * multiple keys at once (`hasAll`) or verifying if at least one specified key
+ * exists in an object (`hasSome`). This class is part of the `@nejs/extension`
+ * library and is designed to offer these extended functionalities in a way
+ * that is consistent with the existing `Reflect` API, making it intuitive for
+ * developers who are already familiar with standard reflection methods in
+ * JavaScript.
+ */
+exports.ReflectExtensions = new extension_1.Patch(Reflect, {
+    /**
+     * The function checks if an object has all the specified keys.
+     *
+     * @param object - The `object` parameter is the object that we want to
+     * check if it has all the specified keys.
+     * @param keys - The `keys` parameter is a rest parameter, which means
+     * it can accept any number of arguments. In this case, it is expected
+     * to receive multiple keys as arguments.
+     * @returns a boolean value.
+     */
+    hasAll(object, ...keys) {
+        return Object.isObject(object) && (keys.flat(Infinity)
+            .map(key => Reflect.has(object, key))
+            .every(has => has));
+    },
+    /**
+     * The function checks if an object has at least one of the specified keys.
+     *
+     * @param object - The `object` parameter is the object that we want to check
+     * for the presence of certain keys.
+     * @param keys - The `keys` parameter is a rest parameter, which means it can
+     * accept any number of arguments. These arguments are the keys that we want
+     * to check if they exist in the `object`.
+     * @returns The function `hasSome` returns a boolean value indicating whether
+     * at least one of the keys provided as arguments exists in the given object.
+     */
+    hasSome(object, ...keys) {
+        return Object.isObject(object) && (keys.flat(Infinity)
+            .map(key => Reflect.has(object, key))
+            .some(has => has));
+    },
+    /**
+     * Retrieves an array of [key, descriptor] pairs for each property of the
+     * provided object. This method is akin to `Object.entries` but includes
+     * property descriptors instead of the property values. It's useful for cases
+     * where you need detailed information about properties, including their
+     * configurability, enumerability, and accessors.
+     *
+     * @param {object} object - The object whose property entries are to be
+     * retrieved.
+     * @returns {Array} An array of [key, descriptor] pairs, where each pair
+     * consists of the property name (key) and its descriptor. Returns an empty
+     * array if the input is not a valid object.
+     */
+    entries(object) {
+        if (!object || typeof object !== 'object') {
+            return [];
+        }
+        return Reflect.ownKeys(object).map(key => [
+            key, Object.getOwnPropertyDescriptor(object, key)
+        ]);
+    },
+    /**
+     * Retrieves an array of values from the property descriptors of the given
+     * object. This method works similarly to `Object.values` but operates on
+     * property descriptors instead. It's useful when you need the values of
+     * properties including getters, setters, and other descriptor-specific
+     * attributes.
+     *
+     * @param {object} object - The object whose property values are to be
+     * retrieved.
+     * @returns {Array} An array of values extracted from the object's property
+     * descriptors. The values correspond to the `value` attribute in each
+     * property's descriptor. Returns an empty array if the input is not a valid
+     * object.
+     */
+    values(object) {
+        return Reflect.entries.map(([, value]) => value);
+    }
+});

package/dist/mjs/arrayextensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `ArrayPrototypeExtensions` patch extends the prototype of the built-in
+ * JavaScript `Array` with additional properties for convenience and improved
+ * readability. By applying this patch, all array instances gain new getter
+ * properties `first` and `last`, which provide quick access to the first and
+ * last elements of the array, respectively. This enhancement simplifies common
+ * operations on arrays and makes code more expressive and concise.
+ */
+export const ArrayPrototypeExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/mjs/arrayextensions.js

@@ -0,0 +1,36 @@
+import { Patch } from '@nejs/extension';
+/**
+ * The `ArrayPrototypeExtensions` patch extends the prototype of the built-in
+ * JavaScript `Array` with additional properties for convenience and improved
+ * readability. By applying this patch, all array instances gain new getter
+ * properties `first` and `last`, which provide quick access to the first and
+ * last elements of the array, respectively. This enhancement simplifies common
+ * operations on arrays and makes code more expressive and concise.
+ */
+export const ArrayPrototypeExtensions = new Patch(Array.prototype, {
+    /**
+     * A getter property that returns the first element of the array. If the
+     * array is empty, it returns `undefined`. This property is useful for
+     * scenarios where you need to quickly access the first item of an array
+     * without the need for additional checks or method calls.
+     *
+     * @returns {*} The first element of the array or `undefined` if the array
+     * is empty.
+     */
+    get first() {
+        return this[0];
+    },
+    /**
+     * A getter property that returns the last element of the array. It
+     * calculates the last index based on the array's length. If the array is
+     * empty, it returns `undefined`. This property is beneficial when you need
+     * to access the last item in an array, improving code readability and
+     * avoiding manual index calculation.
+     *
+     * @returns {*} The last element of the array or `undefined` if the
+     * array is empty.
+     */
+    get last() {
+        return this[this.length - 1];
+    }
+});

package/dist/mjs/functionextensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
+ * constructor. It extends `Function` with additional utility methods for determining the
+ * specific type or nature of function-like objects. These methods allow developers to
+ * distinguish between classes, regular functions, async functions, and arrow functions
+ * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
+ * library and enhances the capabilities of function handling and introspection in JavaScript.
+ */
+export const FunctionExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/mjs/functionextensions.js

@@ -0,0 +1,77 @@
+import { Patch } from '@nejs/extension';
+/**
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
+ * constructor. It extends `Function` with additional utility methods for determining the
+ * specific type or nature of function-like objects. These methods allow developers to
+ * distinguish between classes, regular functions, async functions, and arrow functions
+ * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
+ * library and enhances the capabilities of function handling and introspection in JavaScript.
+ */
+export const FunctionExtensions = new Patch(Function, {
+    /**
+     * Determines if a given value is a class. It checks if the value is an instance of
+     * `Function` and if its string representation includes the keyword 'class'. This method
+     * is useful for distinguishing classes from other function types in JavaScript.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is a class, otherwise `false`.
+     */
+    isClass(value) {
+        return value instanceof Function && String(value).includes('class');
+    },
+    /**
+     * Checks if a given value is a regular function. This method verifies if the value is
+     * an instance of `Function`, which includes regular functions, classes, and async
+     * functions but excludes arrow functions.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is a regular function, otherwise `false`.
+     */
+    isFunction(value) {
+        return value instanceof Function;
+    },
+    /**
+     * Determines if a given value is an asynchronous function. It checks if the value is an
+     * instance of `Function` and if its string representation includes the keyword 'Async'.
+     * This method is particularly useful for identifying async functions.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is an async function, otherwise `false`.
+     */
+    isAsync(value) {
+        const stringTag = /(\w+)]/g.exec(Object.prototype.toString.call(value))[1];
+        return (value instanceof Function &&
+            stringTag.includes('Async'));
+    },
+    /**
+     * Checks if a given value is an arrow function. It verifies if the value is an instance
+     * of `Function`, if its string representation includes the '=>' symbol, and if it lacks
+     * a prototype, which is a characteristic of arrow functions in JavaScript.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} Returns `true` if the value is an arrow function, otherwise `false`.
+     */
+    isBigArrow(value) {
+        return (value instanceof Function &&
+            String(value).includes('=>') &&
+            !String(value).startsWith('bound') &&
+            !Reflect.has(value, 'prototype'));
+    },
+    /**
+     * Determines if a given value is a bound function. Bound functions are created using
+     * the `Function.prototype.bind` method, which allows setting the `this` value at the
+     * time of binding. This method checks if the value is an instance of `Function`, if
+     * its string representation starts with 'bound', and if it lacks a `prototype`
+     * property. These characteristics are indicative of bound functions in JavaScript.
+     *
+     * @param {*} value - The value to be checked, typically a function.
+     * @returns {boolean} Returns `true` if the value is a bound function, otherwise
+     * `false`. Bound functions have a specific format in their string representation
+     * and do not have their own `prototype` property.
+     */
+    isBound(value) {
+        return (value instanceof Function &&
+            String(value).startsWith('bound') &&
+            !Reflect.has(value, 'prototype'));
+    },
+});