@rogolev/value 0.0.3 → 0.0.5

package/src/classes/Type.mjs

@@ -1,1284 +1,2739 @@
-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;
+import {
+    TYPE_ARRAY,
+    TYPE_BIGINT,
+    TYPE_BOOLEAN,
+    TYPE_CLASS,
+    TYPE_FLOAT,
+    TYPE_FUNCTION,
+    TYPE_INFINITY,
+    TYPE_INTEGER,
+    TYPE_NAN,
+    TYPE_NULL,
+    TYPE_OBJECT,
+    TYPE_STRING,
+    TYPE_SYMBOL,
+    TYPE_UNDEFINED,
+} from '../constants.mjs';
+import empty from '../helpers/empty.mjs';
+import expect_array from '../helpers/expect_array.mjs';
+import expect_assoc from '../helpers/expect_assoc.mjs';
+import expect_bigint from '../helpers/expect_bigint.mjs';
+import expect_bool from '../helpers/expect_bool.mjs';
+import expect_char from '../helpers/expect_char.mjs';
+import expect_class from '../helpers/expect_class.mjs';
+import expect_float from '../helpers/expect_float.mjs';
+import expect_function from '../helpers/expect_function.mjs';
+import expect_infinity from '../helpers/expect_infinity.mjs';
+import expect_int from '../helpers/expect_int.mjs';
+import expect_integer from '../helpers/expect_integer.mjs';
+import expect_list from '../helpers/expect_list.mjs';
+import expect_nan from '../helpers/expect_nan.mjs';
+import expect_null from '../helpers/expect_null.mjs';
+import expect_number from '../helpers/expect_number.mjs';
+import expect_numeric from '../helpers/expect_numeric.mjs';
+import expect_object from '../helpers/expect_object.mjs';
+import expect_scalar from '../helpers/expect_scalar.mjs';
+import expect_string from '../helpers/expect_string.mjs';
+import expect_symbol from '../helpers/expect_symbol.mjs';
+import expect_undefined from '../helpers/expect_undefined.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 {
+    /**
+     * Константа, представляющая значение null.
+     * @type {string}
+     * @readonly
+     */
+    static NULL = 'null';
+
+    /**
+     * Константа, представляющая значение NaN (Not-a-Number).
+     * @type {string}
+     * @readonly
+     */
+    static NAN = 'NaN';
+
+    /**
+     * Константа, представляющая значение undefined.
+     * @type {string}
+     * @readonly
+     */
+    static UNDEFINED = 'undefined';
+
+    /**
+     * Константа, представляющая значение Infinity.
+     * @type {string}
+     * @readonly
+     */
+    static INFINITY = 'infinity';
+
+    /**
+     * Константа, представляющая тип boolean.
+     * @type {string}
+     * @readonly
+     */
+    static BOOLEAN = 'boolean';
+
+    /**
+     * Константа, представляющая тип integer (целое число).
+     * @type {string}
+     * @readonly
+     */
+    static INTEGER = 'integer';
+
+    /**
+     * Константа, представляющая тип bigint (большое целое число).
+     * @type {string}
+     * @readonly
+     */
+    static BIGINT = 'bigint';
+
+    /**
+     * Константа, представляющая тип float (число с плавающей запятой).
+     * @type {string}
+     * @readonly
+     */
+    static FLOAT = 'float';
+
+    /**
+     * Константа, представляющая тип string (строка).
+     * @type {string}
+     * @readonly
+     */
+    static STRING = 'string';
+
+    /**
+     * Константа, представляющая тип symbol (символ).
+     * @type {string}
+     * @readonly
+     */
+    static SYMBOL = 'symbol';
+
+    /**
+     * Константа, представляющая тип class (класс).
+     * @type {string}
+     * @readonly
+     */
+    static CLASS = 'class';
+
+    /**
+     * Константа, представляющая тип function (функция).
+     * @type {string}
+     * @readonly
+     */
+    static FUNCTION = 'function';
+
+    /**
+     * Константа, представляющая тип array (массив).
+     * @type {string}
+     * @readonly
+     */
+    static ARRAY = 'array';
+
+    /**
+     * Константа, представляющая тип object (объект).
+     * @type {string}
+     * @readonly
+     */
+    static OBJECT = 'object';
+
+    /**
+     * Проверяет, является ли значение массивом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectArray` используется для проверки, является ли переданное значение массивом.
+     * Если значение не является массивом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является массивом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является массивом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося массивом:
+     *
+     *    ```js
+     *    const array = [1, 2, 3];
+     *    const result = Type.expectArray(array);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося массивом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectArray('not an array', 'Значение должно быть массивом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть массивом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectArray(123, 'Ожидался массив.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался массив.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является массивом.
+     * @returns {boolean} Возвращает `true`, если значение является массивом.
+     * @throws {TypeError} Если значение не является массивом или если параметр `message` не является строкой.
+     */
+    static expectArray(value, message = '') {
+        return expect_array(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение ассоциативным массивом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectAssoc` используется для проверки, является ли переданное значение ассоциативным массивом.
+     * Если значение не является ассоциативным массивом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является ассоциативным массивом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является ассоциативным массивом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося ассоциативным массивом:
+     *
+     *    ```js
+     *    const assoc = { a: 1, b: 2, c: 3 };
+     *    const result = Type.expectAssoc(assoc);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося ассоциативным массивом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectAssoc([1, 2, 3], 'Значение должно быть ассоциативным массивом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть ассоциативным массивом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectAssoc(123, 'Ожидался ассоциативный массив.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался ассоциативный массив.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является ассоциативным массивом.
+     * @returns {boolean} Возвращает `true`, если значение является ассоциативным массивом.
+     * @throws {TypeError} Если значение не является ассоциативным массивом или если параметр `message` не является строкой.
+     */
+    static expectAssoc(value, message = '') {
+        return expect_assoc(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение BigInt, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectBigInt` используется для проверки, является ли переданное значение BigInt.
+     * Если значение не является BigInt, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является BigInt. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является BigInt.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося BigInt:
+     *
+     *    ```js
+     *    const value = 123n;
+     *    const result = Type.expectBigInt(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося BigInt:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectBigInt(123, 'Значение должно быть BigInt.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть BigInt.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectBigInt('123', 'Ожидался BigInt.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался BigInt.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является BigInt.
+     * @returns {boolean} Возвращает `true`, если значение является BigInt.
+     * @throws {TypeError} Если значение не является BigInt или если параметр `message` не является строкой.
+     */
+    static expectBigInt(value, message = '') {
+        return expect_bigint(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение логическим типом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectBool` используется для проверки, является ли переданное значение логическим типом.
+     * Если значение не является логическим типом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является логическим типом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является логическим типом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося логическим типом:
+     *
+     *    ```js
+     *    const value = true;
+     *    const result = Type.expectBool(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося логическим типом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectBool(123, 'Значение должно быть логическим типом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть логическим типом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectBool('true', 'Ожидался логический тип.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался логический тип.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является логическим типом.
+     * @returns {boolean} Возвращает `true`, если значение является логическим типом.
+     * @throws {TypeError} Если значение не является логическим типом или если параметр `message` не является строкой.
+     */
+    static expectBool(value, message = '') {
+        return expect_bool(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение логическим типом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectBoolean` используется для проверки, является ли переданное значение логическим типом.
+     * Если значение не является логическим типом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является логическим типом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является логическим типом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося логическим типом:
+     *
+     *    ```js
+     *    const value = true;
+     *    const result = Type.expectBoolean(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося логическим типом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectBoolean(123, 'Значение должно быть логическим типом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть логическим типом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectBoolean('true', 'Ожидался логический тип.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался логический тип.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является логическим типом.
+     * @returns {boolean} Возвращает `true`, если значение является логическим типом.
+     * @throws {TypeError} Если значение не является логическим типом или если параметр `message` не является строкой.
+     */
+    static expectBoolean(value, message = '') {
+        return expect_bool(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение символом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectChar` используется для проверки, является ли переданное значение символом.
+     * Если значение не является символом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является символом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является символом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося символом:
+     *
+     *    ```js
+     *    const value = 'a';
+     *    const result = Type.expectChar(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося символом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectChar('abc', 'Значение должно быть символом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть символом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectChar(123, 'Ожидался символ.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался символ.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является символом.
+     * @returns {boolean} Возвращает `true`, если значение является символом.
+     * @throws {TypeError} Если значение не является символом или если параметр `message` не является строкой.
+     */
+    static expectChar(value, message = '') {
+        return expect_char(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение классом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectClass` используется для проверки, является ли переданное значение классом.
+     * Если значение не является классом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является классом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является классом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося классом:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const result = Type.expectClass(MyClass);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося классом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectClass('not a class', 'Значение должно быть классом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть классом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectClass(123, 'Ожидался класс.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался класс.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является классом.
+     * @returns {boolean} Возвращает `true`, если значение является классом.
+     * @throws {TypeError} Если значение не является классом или если параметр `message` не является строкой.
+     */
+    static expectClass(value, message = '') {
+        return expect_class(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение числом с плавающей запятой, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectFloat` используется для проверки, является ли переданное значение числом с плавающей запятой.
+     * Если значение не является числом с плавающей запятой, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является числом с плавающей запятой. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом с плавающей запятой.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося числом с плавающей запятой:
+     *
+     *    ```js
+     *    const value = 123.45;
+     *    const result = Type.expectFloat(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося числом с плавающей запятой:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectFloat('123.45', 'Значение должно быть числом с плавающей запятой.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть числом с плавающей запятой.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectFloat(123, 'Ожидалось число с плавающей запятой.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось число с плавающей запятой.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является числом с плавающей запятой.
+     * @returns {boolean} Возвращает `true`, если значение является числом с плавающей запятой.
+     * @throws {TypeError} Если значение не является числом с плавающей запятой или если параметр `message` не является строкой.
+     */
+    static expectFloat(value, message = '') {
+        return expect_float(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение функцией, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectFunction` используется для проверки, является ли переданное значение функцией.
+     * Если значение не является функцией, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является функцией. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является функцией.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося функцией:
+     *
+     *    ```js
+     *    function myFunction() {}
+     *    const result = Type.expectFunction(myFunction);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося функцией:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectFunction(123, 'Значение должно быть функцией.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть функцией.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectFunction('not a function', 'Ожидалась функция.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалась функция.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является функцией.
+     * @returns {boolean} Возвращает `true`, если значение является функцией.
+     * @throws {TypeError} Если значение не является функцией или если параметр `message` не является строкой.
+     */
+    static expectFunction(value, message = '') {
+        return expect_function(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение бесконечностью, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectInfinity` используется для проверки, является ли переданное значение бесконечностью.
+     * Если значение не является бесконечностью, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является бесконечностью. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является бесконечностью.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося бесконечностью:
+     *
+     *    ```js
+     *    const value = Infinity;
+     *    const result = Type.expectInfinity(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося бесконечностью:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectInfinity(123, 'Значение должно быть бесконечностью.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть бесконечностью.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectInfinity('123', 'Ожидалась бесконечность.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалась бесконечность.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является бесконечностью.
+     * @returns {boolean} Возвращает `true`, если значение является бесконечностью.
+     * @throws {TypeError} Если значение не является бесконечностью или если параметр `message` не является строкой.
+     */
+    static expectInfinity(value, message = '') {
+        return expect_infinity(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectInt` используется для проверки, является ли переданное значение целым числом.
+     * Если значение не является целым числом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является целым числом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося целым числом:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = Type.expectInt(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося целым числом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectInt(123.45, 'Значение должно быть целым числом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть целым числом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectInt('123', 'Ожидалось целое число.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось целое число.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является целым числом.
+     * @returns {boolean} Возвращает `true`, если значение является целым числом.
+     * @throws {TypeError} Если значение не является целым числом или если параметр `message` не является строкой.
+     */
+    static expectInt(value, message = '') {
+        return expect_int(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectInteger` используется для проверки, является ли переданное значение целым числом.
+     * Если значение не является целым числом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является целым числом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося целым числом:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = Type.expectInteger(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося целым числом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectInteger(123.45, 'Значение должно быть целым числом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть целым числом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectInteger('123', 'Ожидалось целое число.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось целое число.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является целым числом.
+     * @returns {boolean} Возвращает `true`, если значение является целым числом.
+     * @throws {TypeError} Если значение не является целым числом или если параметр `message` не является строкой.
+     */
+    static expectInteger(value, message = '') {
+        return expect_integer(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение списком, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectList` используется для проверки, является ли переданное значение списком.
+     * Если значение не является списком, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является списком. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является списком.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося списком:
+     *
+     *    ```js
+     *    const value = [1, 2, 3];
+     *    const result = Type.expectList(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося списком:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectList('not a list', 'Значение должно быть списком.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть списком.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectList(123, 'Ожидался список.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался список.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является списком.
+     * @returns {boolean} Возвращает `true`, если значение является списком.
+     * @throws {TypeError} Если значение не является списком или если параметр `message` не является строкой.
+     */
+    static expectList(value, message = '') {
+        return expect_list(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение null, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectNull` используется для проверки, является ли переданное значение null.
+     * Если значение не является null, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является null. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является null.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося null:
+     *
+     *    ```js
+     *    const value = null;
+     *    const result = Type.expectNull(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося null:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNull(123, 'Значение должно быть null.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть null.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNull('not null', 'Ожидалось значение null.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось значение null.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является null.
+     * @returns {boolean} Возвращает `true`, если значение является null.
+     * @throws {TypeError} Если значение не является null или если параметр `message` не является строкой.
+     */
+    static expectNaN(value, message = '') {
+        return expect_nan(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение null, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectNull` используется для проверки, является ли переданное значение null.
+     * Если значение не является null, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является null. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является null.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося null:
+     *
+     *    ```js
+     *    const value = null;
+     *    const result = Type.expectNull(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося null:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNull(123, 'Значение должно быть null.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть null.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNull('not null', 'Ожидалось значение null.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось значение null.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является null.
+     * @returns {boolean} Возвращает `true`, если значение является null.
+     * @throws {TypeError} Если значение не является null или если параметр `message` не является строкой.
+     */
+    static expectNull(value, message = '') {
+        return expect_null(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение числом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectNumber` используется для проверки, является ли переданное значение числом.
+     * Если значение не является числом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является числом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося числом:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = Type.expectNumber(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося числом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNumber('123', 'Значение должно быть числом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть числом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNumber('not a number', 'Ожидалось число.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось число.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является числом.
+     * @returns {boolean} Возвращает `true`, если значение является числом.
+     * @throws {TypeError} Если значение не является числом или если параметр `message` не является строкой.
+     */
+    static expectNumber(value, message = '') {
+        return expect_number(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение числовым, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectNumeric` используется для проверки, является ли переданное значение числовым.
+     * Если значение не является числовым, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является числовым. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числовым.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося числовым:
+     *
+     *    ```js
+     *    const value = '123';
+     *    const result = Type.expectNumeric(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося числовым:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNumeric('abc', 'Значение должно быть числовым.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть числовым.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectNumeric({}, 'Ожидалось числовое значение.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось числовое значение.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является числовым.
+     * @returns {boolean} Возвращает `true`, если значение является числовым.
+     * @throws {TypeError} Если значение не является числовым или если параметр `message` не является строкой.
+     */
+    static expectNumeric(value, message = '') {
+        return expect_numeric(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение объектом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectObject` используется для проверки, является ли переданное значение объектом.
+     * Если значение не является объектом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является объектом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является объектом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося объектом:
+     *
+     *    ```js
+     *    class stdClass {}
+     *    const value = new stdClass();
+     *    const result = Type.expectObject(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося объектом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectObject(123, 'Значение должно быть объектом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть объектом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectObject('not an object', 'Ожидался объект.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался объект.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является объектом.
+     * @returns {boolean} Возвращает `true`, если значение является объектом.
+     * @throws {TypeError} Если значение не является объектом или если параметр `message` не является строкой.
+     */
+    static expectObject(value, message = '') {
+        return expect_object(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение скалярным, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectScalar` используется для проверки, является ли переданное значение скалярным.
+     * Если значение не является скалярным, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является скалярным. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является скалярным.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося скалярным:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = Type.expectScalar(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося скалярным:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectScalar([1, 2, 3], 'Значение должно быть скалярным.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть скалярным.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectScalar({}, 'Ожидалось скалярное значение.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось скалярное значение.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является скалярным.
+     * @returns {boolean} Возвращает `true`, если значение является скалярным.
+     * @throws {TypeError} Если значение не является скалярным или если параметр `message` не является строкой.
+     */
+    static expectScalar(value, message = '') {
+        return expect_scalar(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение строкой, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectString` используется для проверки, является ли переданное значение строкой.
+     * Если значение не является строкой, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является строкой. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является строкой.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося строкой:
+     *
+     *    ```js
+     *    const value = 'Hello, world!';
+     *    const result = Type.expectString(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося строкой:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectString(123, 'Значение должно быть строкой.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть строкой.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectString({}, 'Ожидалась строка.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалась строка.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является строкой.
+     * @returns {boolean} Возвращает `true`, если значение является строкой.
+     * @throws {TypeError} Если значение не является строкой или если параметр `message` не является строкой.
+     */
+    static expectString(value, message = '') {
+        return expect_string(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение символом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectSymbol` используется для проверки, является ли переданное значение символом.
+     * Если значение не является символом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является символом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является символом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося символом:
+     *
+     *    ```js
+     *    const value = Symbol('example');
+     *    const result = Type.expectSymbol(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося символом:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectSymbol('not a symbol', 'Значение должно быть символом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть символом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectSymbol(123, 'Ожидался символ.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался символ.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является символом.
+     * @returns {boolean} Возвращает `true`, если значение является символом.
+     * @throws {TypeError} Если значение не является символом или если параметр `message` не является строкой.
+     */
+    static expectSymbol(value, message = '') {
+        return expect_symbol(value, message);
+    }
+
+    /**
+     * Проверяет, является ли значение undefined, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `expectUndefined` используется для проверки, является ли переданное значение undefined.
+     * Если значение не является undefined, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `value` (any): Значение для проверки.
+     * - `message` (string): Сообщение об ошибке, если значение не является undefined. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является undefined.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося undefined:
+     *
+     *    ```js
+     *    let value;
+     *    const result = Type.expectUndefined(value);
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося undefined:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectUndefined(123, 'Значение должно быть undefined.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть undefined.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = Type.expectUndefined('not undefined', 'Ожидалось значение undefined.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось значение undefined.
+     *    }
+     *    ```
+     *
+     * @param {any} value Значение для проверки.
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является undefined.
+     * @returns {boolean} Возвращает `true`, если значение является undefined.
+     * @throws {TypeError} Если значение не является undefined или если параметр `message` не является строкой.
+     */
+    static expectUndefined(value, message = '') {
+        return expect_undefined(value, message);
+    }
+
+    /**
+     * Проверяет, является ли переменная пустой.
+     *
+     * ### Описание
+     *
+     * Метод `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);
+    }
+}
+
+Object.defineProperties(Type, {
+    NULL: {
+        value: TYPE_NULL,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    NAN: {
+        value: TYPE_NAN,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    UNDEFINED: {
+        value: TYPE_UNDEFINED,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    INFINITY: {
+        value: TYPE_INFINITY,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    BOOLEAN: {
+        value: TYPE_BOOLEAN,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    INTEGER: {
+        value: TYPE_INTEGER,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    BIGINT: {
+        value: TYPE_BIGINT,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    FLOAT: {
+        value: TYPE_FLOAT,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    STRING: {
+        value: TYPE_STRING,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    SYMBOL: {
+        value: TYPE_SYMBOL,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    CLASS: {
+        value: TYPE_CLASS,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    FUNCTION: {
+        value: TYPE_FUNCTION,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    ARRAY: {
+        value: TYPE_ARRAY,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+    OBJECT: {
+        value: TYPE_OBJECT,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    },
+});
+
+export default Type;