@rogolev/value 0.0.1 → 0.0.3

package/src/classes/Type.mjs

@@ -0,0 +1,1284 @@
+import empty from '../helpers/empty.mjs';
+import is_array from '../helpers/is_array.mjs';
+import is_assoc from '../helpers/is_assoc.mjs';
+import is_bigint from '../helpers/is_bigint.mjs';
+import is_bool from '../helpers/is_bool.mjs';
+import is_class from '../helpers/is_class.mjs';
+import is_float from '../helpers/is_float.mjs';
+import is_function from '../helpers/is_function.mjs';
+import is_infinity from '../helpers/is_infinity.mjs';
+import is_int from '../helpers/is_int.mjs';
+import is_list from '../helpers/is_list.mjs';
+import is_nan from '../helpers/is_nan.mjs';
+import is_null from '../helpers/is_null.mjs';
+import is_number from '../helpers/is_number.mjs';
+import is_numeric from '../helpers/is_numeric.mjs';
+import is_object from '../helpers/is_object.mjs';
+import is_scalar from '../helpers/is_scalar.mjs';
+import is_string from '../helpers/is_string.mjs';
+import is_symbol from '../helpers/is_symbol.mjs';
+import is_undefined from '../helpers/is_undefined.mjs';
+
+/**
+ * Класс `Type` предоставляет методы для проверки типов данных в JavaScript.
+ *
+ * ### Описание
+ *
+ * Класс `Type` включает в себя статические методы, которые позволяют проверять типы различных значений.
+ * Эти методы охватывают широкий спектр типов данных, включая примитивы, объекты, массивы, функции и специальные значения.
+ *
+ * ### Методы
+ *
+ * - `Type.isEmpty(value)` - Проверяет, является ли переменная пустой.
+ * - `Type.isArray(value)` - Проверяет, является ли переданное значение массивом или ассоциативным массивом.
+ * - `Type.isAssoc(value)` - Проверяет, является ли значение ассоциативным массивом.
+ * - `Type.isBigInt(value)` - Проверяет, является ли значение типом `bigint`.
+ * - `Type.isBool(value)` - Проверяет, является ли переданное значение логическим типом (`boolean`).
+ * - `Type.isBoolean(value)` - Проверяет, является ли переданное значение логическим типом (`boolean`).
+ * - `Type.isClass(value)` - Проверяет, является ли переданная переменная классом.
+ * - `Type.isFloat(value)` - Проверяет, является ли значение числом с плавающей точкой.
+ * - `Type.isFunction(value)` - Проверяет, что значение является функцией, исключая классы.
+ * - `Type.isInfinity(value)` - Проверяет, является ли значение бесконечностью (Infinity или -Infinity).
+ * - `Type.isInt(value)` - Проверяет, является ли значение целым числом.
+ * - `Type.isInteger(value)` - Проверяет, является ли значение целым числом.
+ * - `Type.isList(value)` - Проверяет, является ли значение списком.
+ * - `Type.isNaN(value)` - Проверяет, является ли значение NaN.
+ * - `Type.isNull(value)` - Проверяет, является ли значение `null`.
+ * - `Type.isNumber(value)` - Проверяет, является ли значение числом.
+ * - `Type.isNumeric(value)` - Проверяет, является ли значение числом или числовой строкой.
+ * - `Type.isObject(value)` - Проверяет, является ли переданная переменная объектом.
+ * - `Type.isScalar(value)` - Проверяет, является ли значение скалярным.
+ * - `Type.isString(value)` - Проверяет, является ли значение строкой.
+ * - `Type.isSymbol(value)` - Проверяет, является ли значение символом.
+ * - `Type.isUndefined(value)` - Проверяет, является ли значение `undefined`.
+ *
+ * ### Примеры использования
+ *
+ * ```js
+ * // Проверка пустых значений
+ * Type.isEmpty(null); // true
+ * Type.isEmpty(''); // true
+ *
+ * // Проверка массивов и ассоциативных массивов
+ * Type.isArray([1, 2, 3]); // true
+ * Type.isArray({ foo: 'bar' }); // true
+ *
+ * // Проверка логических значений
+ * Type.isBool(true); // true
+ * Type.isBoolean(false); // true
+ *
+ * // Проверка чисел и числовых строк
+ * Type.isNumber(42); // true
+ * Type.isNumeric('42'); // true
+ *
+ * // Проверка объектов и символов
+ * Type.isObject({}); // true
+ * Type.isSymbol(Symbol('symbol')); // true
+ *
+ * // Проверка функций и классов
+ * function test() {}
+ * class MyClass {}
+ * Type.isFunction(test); // true
+ * Type.isClass(MyClass); // true
+ * ```
+ */
+class Type {
+    /**
+     * Проверяет, является ли переменная пустой.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isEmpty` используется для проверки, является ли переменная пустой. Пустыми считаются значения `null`, `undefined`, пустая строка, `0`, `false`, пустой массив и пустой объект.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Переменная, которую необходимо проверить на пустоту.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если переменная пустая, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка пустых значений:
+     *
+     *    ```js
+     *    const result1 = Type.isEmpty(null);
+     *    // Результат: true
+     *
+     *    const result2 = Type.isEmpty(undefined);
+     *    // Результат: true
+     *
+     *    const result3 = Type.isEmpty('');
+     *    // Результат: true
+     *
+     *    const result4 = Type.isEmpty(0);
+     *    // Результат: true
+     *
+     *    const result5 = Type.isEmpty(false);
+     *    // Результат: true
+     *
+     *    const result6 = Type.isEmpty([]);
+     *    // Результат: true
+     *
+     *    const result7 = Type.isEmpty({});
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка непустых значений:
+     *
+     *    ```js
+     *    const result1 = Type.isEmpty('example');
+     *    // Результат: false
+     *
+     *    const result2 = Type.isEmpty(123);
+     *    // Результат: false
+     *
+     *    const result3 = Type.isEmpty(true);
+     *    // Результат: false
+     *
+     *    const result4 = Type.isEmpty([1, 2, 3]);
+     *    // Результат: false
+     *
+     *    const result5 = Type.isEmpty({ key: 'value' });
+     *    // Результат: false
+     *    ```
+     *
+     * @param {any} value Переменная, которую необходимо проверить на пустоту.
+     * @returns {boolean} Возвращает `true`, если переменная пустая, и `false` в противном случае.
+     */
+    static isEmpty(value) {
+        return empty(value);
+    }
+
+    /**
+     * Проверяет, является ли переданное значение массивом или ассоциативным массивом (объектом с ключами и значениями).
+     *
+     * ### Описание
+     *
+     * В JavaScript массивы и объекты имеют разные структуры и предназначения:
+     *
+     * - Массивы (Array) являются упорядоченными коллекциями элементов, которые могут быть индексированы.
+     * - Объекты (Object) содержат пары "ключ-значение", которые могут быть неупорядоченными.
+     *
+     * Этот метод проверяет, является ли переданное значение обычным массивом (например, `[1, 2, 3]`),
+     * либо ассоциативным массивом (объектом с парами "ключ-значение", например, `{foo: 'bar'}`).
+     *
+     * ### Алгоритм работы метода
+     *
+     * 1. Сначала проверяется, является ли переданное значение обычным массивом с помощью встроенного метода `Array.isArray(value)`. Если это массив, метод сразу возвращает `true`.
+     *
+     * 2. Если переменная не является массивом, то выполняются дополнительные проверки:
+     *
+     *    - Проверяется, что значение не равно `null` (так как `null` в JavaScript также является объектом, но не является ни массивом, ни объектом с парами "ключ-значение").
+     *    - Проверяется, что значение является объектом JavaScript (с помощью `typeof value === 'object'`).
+     *    - Проверяется, что прототип объекта совпадает с `Object.prototype` (это объект, от которого наследуются все объекты в JavaScript) или является `null` (это означает, что объект был создан с помощью `Object.create(null)` и не имеет прототипа).
+     *    - Исключаются массивоподобные объекты (например, `arguments`, `NodeList`), путем проверки, что свойство `length` не является собственным свойством объекта.
+     *    - Дополнительно проверяется, что объект является простым (его конструктор равен `Object`), а также исключаются встроенные объекты (`Math`, `JSON`, `Reflect`, `Intl`), для которых метод возвращает `true`.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Проверяемая переменная.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если переменная является обычным массивом (`Array`), ассоциативным массивом (объектом с парами "ключ-значение"), ассоциативным массивом, созданным с помощью `Object.create(null)`. В остальных случаях метод возвращает `false`.
+     *
+     * ### Примеры использования
+     *
+     * 1. Простые массивы:
+     *
+     *    ```js
+     *    Type.isArray([1, 2, 3]); // true
+     *    Type.isArray([]); // true
+     *    ```
+     *
+     * 2. Ассоциативные массивы (объекты с ключами и значениями):
+     *
+     *    ```js
+     *    Type.isArray({ foo: 'bar', baz: 42 }); // true
+     *    Type.isArray({ '0': 'a', '1': 'b' }); // true
+     *    ```
+     *
+     * 3. Объекты, созданные без прототипа:
+     *
+     *    ```js
+     *    const noProtoObject = Object.create(null);
+     *    noProtoObject.foo = 'bar';
+     *    Type.isArray(noProtoObject); // true
+     *    ```
+     *
+     * 4. Примитивы и невалидные значения:
+     *
+     *    ```js
+     *    Type.isArray(null);         // false
+     *    Type.isArray(undefined);    // false
+     *    Type.isArray(42);           // false
+     *    Type.isArray('hello');      // false
+     *    ```
+     *
+     * 5. Специальные объекты:
+     *
+     *    ```js
+     *    Type.isArray(new Map());    // false
+     *    Type.isArray(new Set());    // false
+     *    Type.isArray(() => {});     // false
+     *    ```
+     *
+     * 6. Классы и их экземпляры:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const instance = new MyClass();
+     *    Type.isArray(instance); // false
+     *    ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является массивом или ассоциативным массивом, иначе `false`.
+     */
+    static isArray(value) {
+        return is_array(value);
+    }
+
+    /**
+     * Проверяет, является ли значение ассоциативным массивом.
+     *
+     * ### Описание
+     *
+     * Ассоциативные массивы в JavaScript представляют собой объекты с парами "ключ-значение".
+     * Этот метод проверяет, является ли переданное значение ассоциативным массивом.
+     *
+     * Метод использует функцию `is_array` для проверки значения и убеждается, что значение не является обычным массивом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является ассоциативным массивом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Ассоциативные массивы:
+     *
+     *    ```js
+     *    Type.isAssoc({ foo: 'bar' }); // true
+     *    Type.isAssoc({}); // true
+     *    ```
+     *
+     * 2. Обычные массивы:
+     *
+     *    ```js
+     *    Type.isAssoc([]); // false
+     *    Type.isAssoc([1, 2, 3]); // false
+     *    ```
+     *
+     * 3. Значения других типов:
+     *
+     *    ```js
+     *    Type.isAssoc('string'); // false
+     *    Type.isAssoc(42); // false
+     *    Type.isAssoc(null); // false
+     *    Type.isAssoc(undefined); // false
+     *    ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является ассоциативным массивом, и `false` в противном случае.
+     */
+    static isAssoc(value) {
+        return is_assoc(value);
+    }
+
+    /**
+     * Проверяет, является ли значение типом `bigint`.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isBigInt` проверяет, является ли переданное значение типом `bigint`.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является типом `bigint`, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка значений типа bigint
+     *
+     * ```js
+     * Type.isBigInt(BigInt(123456)); // true
+     * Type.isBigInt(BigInt(-123456)); // true
+     * ```
+     *
+     * #### Пример 2: Проверка значений других типов
+     *
+     * ```js
+     * Type.isBigInt(42); // false (число)
+     * Type.isBigInt('42'); // false (строка)
+     * Type.isBigInt(true); // false (логическое значение)
+     * Type.isBigInt(null); // false
+     * Type.isBigInt(undefined); // false
+     * Type.isBigInt({}); // false (объект)
+     * Type.isBigInt([]); // false (массив)
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является типом bigint, и `false` в противном случае.
+     */
+    static isBigInt(value) {
+        return is_bigint(value);
+    }
+
+    /**
+     * Проверяет, является ли переданное значение логическим типом (`boolean`).
+     *
+     * ### Описание
+     *
+     * В JavaScript логическое значение может быть только двумя состояниями: `true` или `false`.
+     * Метод проверяет тип переданного значения с использованием оператора `typeof`.
+     * Если значение является примитивом типа `boolean`, метод возвращает `true`.
+     * Для всех других типов (включая объекты, строки, числа, `null`, `undefined` и другие) метод вернёт `false`.
+     *
+     * #### Примечание
+     *
+     * - Метод возвращает `false` для объектов типа `Boolean`, созданных с помощью конструктора `new Boolean()`.
+     * - Возвращает `false` для массивов, объектов и других типов данных, отличных от `boolean`.
+     *
+     * ### Параметры
+     *
+     * - `value` (any):
+     *      Проверяемая переменная.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение `value` является логическим (`boolean`), иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * ```js
+     * Type.isBool(true);   // Возвращает: true
+     * Type.isBool(false);  // Возвращает: true
+     * Type.isBool(0);      // Возвращает: false
+     * Type.isBool('true'); // Возвращает: false
+     * Type.isBool(null);   // Возвращает: false
+     * Type.isBool([]);     // Возвращает: false
+     * Type.isBool({});     // Возвращает: false
+     * Type.isBool(new Boolean(true)); // Возвращает: false
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является логическим, иначе `false`.
+     */
+    static isBool(value) {
+        return is_bool(value);
+    }
+
+    /**
+     * Проверяет, является ли переданное значение логическим типом (`boolean`).
+     *
+     * ### Описание
+     *
+     * В JavaScript логическое значение может быть только двумя состояниями: `true` или `false`.
+     * Метод проверяет тип переданного значения с использованием оператора `typeof`.
+     * Если значение является примитивом типа `boolean`, метод возвращает `true`.
+     * Для всех других типов (включая объекты, строки, числа, `null`, `undefined` и другие) метод вернёт `false`.
+     *
+     * #### Примечание
+     *
+     * - Метод возвращает `false` для объектов типа `Boolean`, созданных с помощью конструктора `new Boolean()`.
+     * - Возвращает `false` для массивов, объектов и других типов данных, отличных от `boolean`.
+     *
+     * ### Параметры
+     *
+     * - `value` (any):
+     *      Проверяемая переменная.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение `value` является логическим (`boolean`), иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * ```js
+     * Type.isBoolean(true);   // Возвращает: true
+     * Type.isBoolean(false);  // Возвращает: true
+     * Type.isBoolean(0);      // Возвращает: false
+     * Type.isBoolean('true'); // Возвращает: false
+     * Type.isBoolean(null);   // Возвращает: false
+     * Type.isBoolean([]);     // Возвращает: false
+     * Type.isBoolean({});     // Возвращает: false
+     * Type.isBoolean(new Boolean(true)); // Возвращает: false
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является логическим, иначе `false`.
+     */
+    static isBoolean(value) {
+        return is_bool(value);
+    }
+
+    /**
+     * Проверяет, является ли переданная переменная классом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Проверяемая переменная.
+     *
+     * ### Описание
+     *
+     * В JavaScript классы являются функциями, но с уникальным поведением.
+     *
+     * Для определения класса метод проверяет:
+     *
+     * 1. Что переданная переменная является функцией.
+     * 2. Что строковое представление функции начинается с `class `.
+     *
+     * #### Примечание
+     *
+     * Конструкторы функций, созданные с помощью `function`, не будут распознаны как классы.
+     *
+     * Для примера:
+     *
+     * ```js
+     * function Foo() {}
+     * Type.isClass(Foo); // Возвращает: false
+     * ```
+     *
+     * В отличие от классов, которые выглядят так:
+     *
+     * ```js
+     * class MyClass {}
+     * Type.isClass(MyClass); // Возвращает: true
+     * ```
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является классом, иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * 1. Классы:
+     *
+     * ```js
+     * class MyClass {}
+     * Type.isClass(MyClass); // true
+     * ```
+     *
+     * 2. Функции-конструкторы:
+     *
+     * ```js
+     * function MyFunction() {}
+     * Type.isClass(MyFunction); // false
+     * ```
+     *
+     * 3. Объекты и примитивы:
+     *
+     * ```js
+     * Type.isClass({}); // false
+     * Type.isClass([]); // false
+     * Type.isClass(null); // false
+     * Type.isClass(42); // false
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является классом, иначе `false`.
+     */
+    static isClass(value) {
+        return is_class(value);
+    }
+
+    /**
+     * Проверяет, является ли значение числом с плавающей точкой.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение для проверки.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isFloat` проверяет, является ли переданное значение числом с дробной частью, которое отличается от целого числа.
+     *
+     * Она работает следующим образом:
+     *
+     * 1. Проверяет, что значение имеет тип `number`.
+     * 2. Исключает значения `NaN`, которые также относятся к типу `number`, но не считаются числовыми значениями.
+     * 3. Проверяет, что у числа есть дробная часть, проверяя остаток от деления на `1` (`value % 1 !== 0`).
+     *
+     * Значения, которые не являются числами или числа без дробной части, не считаются числами с плавающей точкой.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом с плавающей точкой, иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * #### Числа с плавающей точкой
+     *
+     * ```js
+     * Type.isFloat(3.14);    // true
+     * Type.isFloat(-0.5);    // true
+     * Type.isFloat(0.1 + 0.2); // true
+     * ```
+     *
+     * #### Целые числа
+     *
+     * ```js
+     * Type.isFloat(0);       // false
+     * Type.isFloat(42);      // false
+     * Type.isFloat(-100);    // false
+     * ```
+     *
+     * #### Нечисловые значения
+     *
+     * ```js
+     * Type.isFloat('3.14');  // false
+     * Type.isFloat(NaN);     // false
+     * Type.isFloat(null);    // false
+     * Type.isFloat(undefined); // false
+     * Type.isFloat(true);    // false
+     * Type.isFloat({});      // false
+     * Type.isFloat([]);      // false
+     * ```
+     *
+     * #### Специальные значения
+     *
+     * ```js
+     * Type.isFloat(Infinity);   // false
+     * Type.isFloat(-Infinity);  // false
+     * ```
+     *
+     * @param {any} value Значение для проверки.
+     * @returns {boolean} Возвращает `true`, если значение является числом с плавающей точкой, иначе `false`.
+     */
+    static isFloat(value) {
+        return is_float(value);
+    }
+
+    /**
+     * Проверяет, что значение является функцией, исключая классы.
+     *
+     * ### Параметры
+     *
+     * - `value` (any):
+     *      Проверяемое значение. Может быть любым типом данных.
+     *
+     * ### Описание
+     *
+     * Метод проверяет, является ли переданное значение функцией, исключая классы.
+     * В JavaScript функции и классы оба являются типом `function`, но классы имеют особый синтаксис и поведение.
+     * Метод `Type.isFunction` различает их, проверяя, не начинается ли строковое представление функции с `class`, что указывает на то, что это класс, а не обычная функция.
+     * Если значение является функцией (но не классом), метод возвращает `true`.
+     * Для всех остальных типов данных (включая классы, объекты, примитивы) метод возвращает `false`.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если переданное значение является функцией (но не классом).
+     * Возвращает `false`, если переданное значение является классом или любым другим типом данных.
+     *
+     * ### Примеры использования
+     *
+     * Пример 1: обычная функция
+     *
+     * ```js
+     * function test() {}
+     * Type.isFunction(test); // Возвращает: true
+     * ```
+     *
+     * Пример 2: класс
+     *
+     * ```js
+     * class MyClass {}
+     * Type.isFunction(MyClass); // Возвращает: false
+     * ```
+     *
+     * Пример 3: объект
+     *
+     * ```js
+     * const obj = {};
+     * Type.isFunction(obj); // Возвращает: false
+     * ```
+     *
+     * Пример 4: примитив
+     *
+     * ```js
+     * Type.isFunction(42); // Возвращает: false
+     * Type.isFunction('hello'); // Возвращает: false
+     * ```
+     *
+     * @param {any} value - Проверяемое значение.
+     * @returns {boolean} Возвращает `true`, если значение является функцией, иначе `false`.
+     */
+    static isFunction(value) {
+        return is_function(value);
+    }
+
+    /**
+     * Проверяет, является ли значение бесконечностью (Infinity или -Infinity).
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isInfinity` проверяет, является ли переданное значение бесконечностью (Infinity или -Infinity).
+     *
+     * Он проверяет, равно ли значение `Number.POSITIVE_INFINITY` или `Number.NEGATIVE_INFINITY`.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является бесконечностью, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка значения Infinity
+     *
+     * ```js
+     * Type.isInfinity(Infinity); // true
+     * Type.isInfinity(-Infinity); // true
+     * ```
+     *
+     * #### Пример 2: Проверка числовых значений
+     *
+     * ```js
+     * Type.isInfinity(42); // false
+     * Type.isInfinity(3.14); // false
+     * Type.isInfinity(NaN); // false
+     * ```
+     *
+     * #### Пример 3: Проверка значений других типов
+     *
+     * ```js
+     * Type.isInfinity('Infinity'); // false (строка)
+     * Type.isInfinity(true); // false (логическое значение)
+     * Type.isInfinity(null); // false
+     * Type.isInfinity(undefined); // false
+     * Type.isInfinity({}); // false (объект)
+     * Type.isInfinity([]); // false (массив)
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является бесконечностью, и `false` в противном случае.
+     */
+    static isInfinity(value) {
+        return is_infinity(value);
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое нужно проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isInt` определяет, является ли переданное значение целым числом.
+     *
+     * Он выполняет следующие проверки:
+     *
+     * 1. **Тип значения**: Убеждается, что `value` имеет тип `number`.
+     * 2. **Конечность числа**: Проверяет, что значение не является `Infinity` или `NaN` с помощью `Number.isFinite(value)`.
+     * 3. **Целочисленность**: Убедится, что остаток от деления числа на 1 равен нулю (`value % 1 === 0`).
+     *
+     * Если значение соответствует всем этим условиям, оно считается целым числом.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом, иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * ```js
+     * // Проверка целых чисел
+     * Type.isInt(42);       // true
+     * Type.isInt(0);        // true
+     * Type.isInt(-123);     // true
+     *
+     * // Проверка дробных чисел
+     * Type.isInt(3.14);     // false
+     * Type.isInt(-0.001);   // false
+     *
+     * // Некорректные типы данных
+     * Type.isInt('42');     // false (строка)
+     * Type.isInt(true);     // false (логическое значение)
+     * Type.isInt(null);     // false (null)
+     * Type.isInt(undefined);// false (undefined)
+     *
+     * // Бесконечные и некорректные числовые значения
+     * Type.isInt(Infinity); // false (бесконечность)
+     * Type.isInt(-Infinity);// false (отрицательная бесконечность)
+     * Type.isInt(NaN);      // false (не число)
+     *
+     * // Проверка типа bigint
+     * Type.isInt(BigInt(123456)); // false
+     * ```
+     *
+     * @param {any} value Значение для проверки.
+     * @returns {boolean} Возвращает `true`, если значение является целым числом, иначе `false`.
+     */
+    static isInt(value) {
+        return is_int(value);
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isInteger` проверяет, является ли переданное значение целым числом.
+     *
+     * 1. Проверяется, что значение имеет тип `number`.
+     * 2. Убеждается, что значение является конечным числом.
+     * 3. Проверяется, что остаток от деления значения на 1 равен 0.
+     *
+     * Метод возвращает `false` для:
+     *
+     * - Чисел с плавающей точкой (например, `3.14`, `-0.99`).
+     * - Специальных чисел (`NaN`, `Infinity`, `-Infinity`).
+     * - Значений других типов, таких как строки, объекты или массивы.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка целых чисел
+     *
+     * ```js
+     * Type.isInteger(42); // true
+     * Type.isInteger(-7); // true
+     * Type.isInteger(0); // true
+     * ```
+     *
+     * #### Пример 2: Проверка чисел с плавающей точкой
+     *
+     * ```js
+     * Type.isInteger(3.14); // false
+     * Type.isInteger(-0.5); // false
+     * ```
+     *
+     * #### Пример 3: Проверка специальных чисел
+     *
+     * ```js
+     * Type.isInteger(NaN); // false
+     * Type.isInteger(Infinity); // false
+     * Type.isInteger(-Infinity); // false
+     * ```
+     *
+     * #### Пример 4: Проверка других типов данных
+     *
+     * ```js
+     * Type.isInteger('42'); // false (строка)
+     * Type.isInteger(true); // false (логическое значение)
+     * Type.isInteger(null); // false
+     * Type.isInteger(undefined); // false
+     * Type.isInteger({}); // false (объект)
+     * Type.isInteger([]); // false (массив)
+     * ```
+     *
+     * #### Пример 5: Проверка типа bigint
+     *
+     * ```js
+     * Type.isInteger(BigInt(123456)); // false
+     * ```
+     *
+     * @param {any} value Значение для проверки.
+     * @returns {boolean} Возвращает `true`, если значение является целым числом, иначе `false`.
+     */
+    static isInteger(value) {
+        return is_int(value);
+    }
+
+    /**
+     * Проверяет, является ли значение списком.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isList` проверяет, является ли переданное значение списком.
+     *
+     * Он использует метод `Array.isArray` для проверки значения.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является списком, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка массивов
+     *
+     * ```js
+     * Type.isList([]); // true
+     * Type.isList([1, 2, 3]); // true
+     * ```
+     *
+     * #### Пример 2: Проверка значений других типов
+     *
+     * ```js
+     * Type.isList({}); // false (ассоциативный массив)
+     * Type.isList('string'); // false (строка)
+     * Type.isList(42); // false (число)
+     * Type.isList(null); // false
+     * Type.isList(undefined); // false
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является списком, и `false` в противном случае.
+     */
+    static isList(value) {
+        return is_list(value);
+    }
+
+    /**
+     * Проверяет, является ли значение NaN.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isNaN` проверяет, является ли переданное значение NaN (Not-a-Number).
+     *
+     * Он использует метод `Number.isNaN` для проверки значения.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является NaN, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка значения NaN
+     *
+     * ```js
+     * Type.isNaN(NaN); // true
+     * ```
+     *
+     * #### Пример 2: Проверка числовых значений
+     *
+     * ```js
+     * Type.isNaN(42); // false
+     * Type.isNaN(3.14); // false
+     * Type.isNaN(Infinity); // false
+     * ```
+     *
+     * #### Пример 3: Проверка значений других типов
+     *
+     * ```js
+     * Type.isNaN('42'); // false (строка)
+     * Type.isNaN(true); // false (логическое значение)
+     * Type.isNaN(null); // false
+     * Type.isNaN(undefined); // false
+     * Type.isNaN({}); // false (объект)
+     * Type.isNaN([]); // false (массив)
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является NaN, и `false` в противном случае.
+     */
+    static isNaN(value) {
+        return is_nan(value);
+    }
+
+    /**
+     * Проверяет, является ли значение `null`.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isNull` проверяет, является ли переданное значение `null`.
+     *
+     * Он просто сравнивает значение с `null`.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является `null`, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка значения `null`
+     *
+     * ```js
+     * Type.isNull(null); // true
+     * ```
+     *
+     * #### Пример 2: Проверка значений других типов
+     *
+     * ```js
+     * Type.isNull(undefined); // false
+     * Type.isNull(0); // false
+     * Type.isNull(''); // false
+     * Type.isNull(false); // false
+     * Type.isNull({}); // false
+     * Type.isNull([]); // false
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является `null`, и `false` в противном случае.
+     */
+    static isNull(value) {
+        return is_null(value);
+    }
+
+    /**
+     * Проверяет, является ли значение числом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isNumber` проверяет, является ли переданное значение числом.
+     *
+     * Он использует оператор `typeof` для проверки типа значения.
+     *
+     * Метод возвращает `false` для значений других типов, таких как строки, объекты или массивы.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка числовых значений
+     *
+     * ```js
+     * Type.isNumber(42); // true
+     * Type.isNumber(3.14); // true
+     * ```
+     *
+     * #### Пример 2: Проверка значений других типов
+     *
+     * ```js
+     * Type.isNumber('42'); // false (строка)
+     * Type.isNumber(true); // false (логическое значение)
+     * Type.isNumber(null); // false
+     * Type.isNumber(undefined); // false
+     * Type.isNumber({}); // false (объект)
+     * Type.isNumber([]); // false (массив)
+     * ```
+     *
+     * #### Пример 3: Проверка специальных чисел
+     *
+     * ```js
+     * Type.isNumber(NaN); // false
+     * Type.isNumber(Infinity); // false
+     * Type.isNumber(-Infinity); // false
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является числом, и `false` в противном случае.
+     */
+    static isNumber(value) {
+        return is_number(value);
+    }
+
+    /**
+     * Проверяет, является ли значение числом или числовой строкой.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isNumeric` проверяет, является ли переданное значение числом или строкой, которая может быть преобразована в число.
+     *
+     * Он использует функцию `is_numeric` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом или числовой строкой, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка числовых значений
+     *
+     * ```js
+     * Type.isNumeric(42); // true
+     * Type.isNumeric(3.14); // true
+     * ```
+     *
+     * #### Пример 2: Проверка числовых строк
+     *
+     * ```js
+     * Type.isNumeric('42'); // true
+     * Type.isNumeric('3.14'); // true
+     * ```
+     *
+     * #### Пример 3: Проверка значений других типов
+     *
+     * ```js
+     * Type.isNumeric(true); // false (логическое значение)
+     * Type.isNumeric(null); // false
+     * Type.isNumeric(undefined); // false
+     * Type.isNumeric({}); // false (объект)
+     * Type.isNumeric([]); // false (массив)
+     * Type.isNumeric('hello'); // false (строка)
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является числом или числовой строкой, и `false` в противном случае.
+     */
+    static isNumeric(value) {
+        return is_numeric(value);
+    }
+
+    /**
+     * Проверяет, является ли переданная переменная объектом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Проверяемая переменная.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isObject` проверяет, является ли переданное значение объектом.
+     *
+     * Он использует оператор `typeof` для проверки типа значения и убеждается, что значение не является `null`.
+     *
+     * Метод возвращает `false` для значений других типов, таких как числа, строки, массивы или функции.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является объектом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка объектов
+     *
+     * ```js
+     * Type.isObject({}); // true
+     * Type.isObject({ key: 'value' }); // true
+     * ```
+     *
+     * #### Пример 2: Проверка значений других типов
+     *
+     * ```js
+     * Type.isObject(42); // false (число)
+     * Type.isObject('string'); // false (строка)
+     * Type.isObject(null); // false
+     * Type.isObject(undefined); // false
+     * Type.isObject([]); // false (массив)
+     * Type.isObject(() => {}); // false (функция)
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является объектом, иначе `false`.
+     */
+    static isObject(value) {
+        return is_object(value);
+    }
+
+    /**
+     * Проверяет, является ли значение скалярным.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Проверяемая переменная.
+     *
+     * ### Описание
+     *
+     * Скалярные переменные — это переменные, содержащие `int`, `float`, `string`, `bool` и `symbol`.
+     * Типы `array`, `object`, `null`, `undefined` — не скалярные.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является скалярным, иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * ```js
+     * // Пример 1: Проверка скалярных значений
+     * Type.isScalar(true); // true
+     * Type.isScalar(42); // true
+     * Type.isScalar('hello'); // true
+     * Type.isScalar(Symbol('symbol')); // true
+     *
+     * // Пример 2: Проверка не скалярных значений
+     * Type.isScalar(null); // false
+     * Type.isScalar(undefined); // false
+     * Type.isScalar({}); // false (объект)
+     * Type.isScalar([]); // false (массив)
+     * Type.isScalar(() => {}); // false (функция)
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является скалярным, иначе `false`.
+     */
+    static isScalar(value) {
+        return is_scalar(value);
+    }
+
+    /**
+     * Проверяет, является ли значение строкой.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Значение, которое необходимо проверить.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isString` проверяет, является ли переданное значение строкой.
+     *
+     * Он использует оператор `typeof` для проверки типа значения.
+     *
+     * Метод возвращает `false` для значений других типов, таких как числа, объекты или массивы.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является строкой, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * #### Пример 1: Проверка строковых значений
+     *
+     * ```js
+     * Type.isString('hello'); // true
+     * Type.isString(''); // true
+     * ```
+     *
+     * #### Пример 2: Проверка значений других типов
+     *
+     * ```js
+     * Type.isString(42); // false (число)
+     * Type.isString(true); // false (логическое значение)
+     * Type.isString(null); // false
+     * Type.isString(undefined); // false
+     * Type.isString({}); // false (объект)
+     * Type.isString([]); // false (массив)
+     * ```
+     *
+     * @param {any} value Значение, которое необходимо проверить.
+     * @returns {boolean} Возвращает `true`, если значение является строкой, иначе `false`.
+     */
+    static isString(value) {
+        return is_string(value);
+    }
+
+    /**
+     * Проверяет, является ли значение символом.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Проверяемая переменная.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isSymbol` предназначен для проверки, является ли переданное значение символом.
+     *
+     * Он проверяет:
+     *
+     * 1. Что значение имеет тип `symbol`.
+     *
+     * Метод возвращает `false` для всех значений, не принадлежащих типу `symbol`.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является символом, иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * ```js
+     * // Пример 1: Проверка символов
+     * Type.isSymbol(Symbol('symbol')); // true
+     * Type.isSymbol(Symbol.iterator); // true
+     *
+     * // Пример 2: Проверка значений других типов
+     * Type.isSymbol('hello'); // false (строка)
+     * Type.isSymbol(42); // false (число)
+     * Type.isSymbol(true); // false (логическое значение)
+     * Type.isSymbol(null); // false
+     * Type.isSymbol(undefined); // false
+     * Type.isSymbol({}); // false (объект)
+     * Type.isSymbol([]); // false (массив)
+     * Type.isSymbol(() => {}); // false (функция)
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является символом, иначе `false`.
+     */
+    static isSymbol(value) {
+        return is_symbol(value);
+    }
+
+    /**
+     * Проверяет, является ли значение `undefined`.
+     *
+     * ### Параметры
+     *
+     * - `value` (any)
+     *      Проверяемая переменная.
+     *
+     * ### Описание
+     *
+     * Метод `Type.isUndefined` проверяет, является ли переданное значение `undefined`.
+     *
+     * Он использует оператор `typeof` для проверки типа значения.
+     *
+     * Метод возвращает `false` для всех значений, не принадлежащих типу `undefined`.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является `undefined`, иначе `false`.
+     *
+     * ### Примеры использования
+     *
+     * ```js
+     * // Пример 1: Проверка значения undefined
+     * Type.isUndefined(undefined); // true
+     *
+     * // Пример 2: Проверка значений других типов
+     * Type.isUndefined(null); // false
+     * Type.isUndefined(42); // false (число)
+     * Type.isUndefined('hello'); // false (строка)
+     * Type.isUndefined(true); // false (логическое значение)
+     * Type.isUndefined({}); // false (объект)
+     * Type.isUndefined([]); // false (массив)
+     * Type.isUndefined(() => {}); // false (функция)
+     * ```
+     *
+     * @param {any} value Проверяемая переменная.
+     * @returns {boolean} Возвращает `true`, если значение является `undefined`, иначе `false`.
+     */
+    static isUndefined(value) {
+        return is_undefined(value);
+    }
+}
+
+export default Type;