@rogolev/value 0.0.4 → 0.0.5

package/src/classes/Expect.mjs

@@ -0,0 +1,1445 @@
+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_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_equal from '../helpers/is_equal.mjs';
+import is_string from '../helpers/is_string.mjs';
+
+/**
+ * Класс `Expect` предоставляет методы для проверки значений.
+ *
+ * ### Описание
+ *
+ * Класс `Expect` используется для создания объектов, которые могут проверять различные свойства и типы значений.
+ * Он предоставляет методы для проверки, такие как `toBe`, `toBeArray`, `toBeBigInt` и многие другие.
+ * Каждый метод выбрасывает ошибку, если проверка не проходит, и возвращает `true`, если проверка успешна.
+ *
+ * ### Методы
+ *
+ * - `toBe(expected, message)`: Проверяет, что фактическое значение строго равно ожидаемому значению.
+ * - `toBeArray(message)`: Проверяет, что фактическое значение является массивом.
+ * - `toBeAssoc(message)`: Проверяет, что фактическое значение является ассоциативным массивом.
+ * - `toBeBigInt(message)`: Проверяет, что фактическое значение является BigInt.
+ * - `toBeBool(message)`: Проверяет, что фактическое значение является логическим типом (boolean).
+ * - `toBeBoolean(message)`: Проверяет, что фактическое значение является логическим типом (boolean).
+ * - `toBeChar(message)`: Проверяет, что фактическое значение является символом (char).
+ * - `toBeClass(message)`: Проверяет, что фактическое значение является классом.
+ * - `toBeFloat(message)`: Проверяет, что фактическое значение является числом с плавающей запятой (float).
+ * - `toBeFunction(message)`: Проверяет, является ли значение функцией.
+ * - `toBeInfinity(message)`: Проверяет, является ли значение бесконечностью (Infinity).
+ * - `toBeInt(message)`: Проверяет, является ли значение целым числом (integer).
+ * - `toBeInteger(message)`: Проверяет, является ли значение целым числом (integer).
+ * - `toBeList(message)`: Проверяет, является ли значение списком (list).
+ * - `toBeNaN(message)`: Проверяет, является ли значение NaN (Not-a-Number).
+ * - `toBeNull(message)`: Проверяет, является ли значение null.
+ * - `toBeNumber(message)`: Проверяет, является ли значение числом.
+ * - `toBeNumeric(message)`: Проверяет, является ли значение числовым.
+ * - `toBeObject(message)`: Проверяет, является ли значение объектом.
+ * - `toBeScalar(message)`: Проверяет, является ли значение скалярным (boolean, number, string, или symbol).
+ * - `toBeString(message)`: Проверяет, является ли значение строкой.
+ * - `toBeSymbol(message)`: Проверяет, является ли значение символом (Symbol).
+ * - `toBeUndefined(message)`: Проверяет, является ли значение undefined.
+ * - `toEqual(expected, message)`: Проверяет, что фактическое значение эквивалентно ожидаемому значению.
+ * - `toStrictEqual(expected, message)`: Проверяет, что фактическое значение строго эквивалентно ожидаемому значению.
+ *
+ * ### Примеры использования
+ *
+ * 1. Создание экземпляра класса `Expect` и проверка значения:
+ *
+ *    ```js
+ *    const expect = new Expect(5);
+ *    expect.toBe(5); // true
+ *    ```
+ *
+ * 2. Проверка значения, являющегося массивом:
+ *
+ *    ```js
+ *    const expect = new Expect([1, 2, 3]);
+ *    expect.toBeArray(); // true
+ *    ```
+ *
+ * 3. Проверка значения, являющегося BigInt:
+ *
+ *    ```js
+ *    const expect = new Expect(123n);
+ *    expect.toBeBigInt(); // true
+ *    ```
+ */
+class Expect {
+    /**
+     * Приватное поле, содержащее значение, которое будет проверяться методами класса.
+     *
+     * ### Описание
+     *
+     * Поле `#actual` используется для хранения значения, переданного в конструктор класса `Expect`.
+     * Это значение затем используется различными методами класса для выполнения проверок.
+     * Поле является приватным, что означает, что оно не может быть доступно или изменено извне класса.
+     */
+    #actual;
+
+    /**
+     * Создает экземпляр класса `Expect`.
+     *
+     * ### Описание
+     *
+     * Конструктор класса `Expect` используется для создания нового экземпляра этого класса.
+     * Он принимает одно значение, которое будет проверяться методами класса.
+     * Это значение сохраняется в приватное поле `#actual`.
+     *
+     * ### Параметры
+     *
+     * - `actual` (any): Значение, которое будет проверяться методами класса.
+     *
+     * ### Примеры использования
+     *
+     * 1. Создание экземпляра класса `Expect` с числовым значением:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    ```
+     *
+     * 2. Создание экземпляра класса `Expect` со строковым значением:
+     *
+     *    ```js
+     *    const expect = new Expect('hello');
+     *    ```
+     *
+     * 3. Создание экземпляра класса `Expect` с объектом:
+     *
+     *    ```js
+     *    const expect = new Expect({ a: 1, b: 2 });
+     *    ```
+     *
+     * @param {any} actual Значение, которое будет проверяться методами класса.
+     */
+    constructor(actual) {
+        this.#actual = actual;
+    }
+
+    /**
+     * Проверяет, что фактическое значение строго равно ожидаемому значению.
+     *
+     * ### Описание
+     *
+     * Метод `toBe` используется для проверки, что фактическое значение (`actual`) строго равно ожидаемому значению (`expected`).
+     * Строгое равенство проверяется с использованием метода `Object.is`, который учитывает типы значений.
+     * Если значения не равны, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `expected` (any): Ожидаемое значение для сравнения.
+     * - `message` (string): Сообщение об ошибке, если значения не равны. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значения равны.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка равенства чисел:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    expect.toBe(5); // true
+     *    ```
+     *
+     * 2. Проверка равенства строк:
+     *
+     *    ```js
+     *    const expect = new Expect('hello');
+     *    expect.toBe('hello'); // true
+     *    ```
+     *
+     * 3. Проверка неравенства с сообщением об ошибке:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    try {
+     *        expect.toBe(10, 'Значения не равны');
+     *    } catch (e) {
+     *        console.error(e.message); // Значения не равны
+     *    }
+     *    ```
+     *
+     * @param {any} expected Ожидаемое значение для сравнения.
+     * @param {string} [message=''] Сообщение об ошибке, если значения не равны.
+     * @returns {boolean} Возвращает `true`, если значения равны.
+     * @throws {TypeError} Если значения не равны.
+     */
+    toBe(expected, message = '') {
+        if (!is_string(message)) {
+            throw new TypeError('Параметр "message" должен быть строкой.');
+        }
+
+        if (!Object.is(this.#actual, expected)) {
+            throw new TypeError(message);
+        }
+
+        return true;
+    }
+
+    /**
+     * Проверяет, что фактическое значение является массивом.
+     *
+     * ### Описание
+     *
+     * Метод `toBeArray` используется для проверки, что фактическое значение (`actual`) является массивом.
+     * Если значение не является массивом, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является массивом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является массивом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося массивом:
+     *
+     *    ```js
+     *    const expect = new Expect([1, 2, 3]);
+     *    expect.toBeArray(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося массивом:
+     *
+     *    ```js
+     *    const expect = new Expect('not an array');
+     *    try {
+     *        expect.toBeArray('Значение должно быть массивом');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть массивом
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является массивом.
+     * @returns {boolean} Возвращает `true`, если значение является массивом.
+     * @throws {TypeError} Если значение не является массивом.
+     */
+    toBeArray(message = '') {
+        return expect_array(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является ассоциативным массивом.
+     *
+     * ### Описание
+     *
+     * Метод `toBeAssoc` используется для проверки, что фактическое значение (`actual`) является ассоциативным массивом.
+     * Если значение не является ассоциативным массивом, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является ассоциативным массивом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является ассоциативным массивом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося ассоциативным массивом:
+     *
+     *    ```js
+     *    const expect = new Expect({ a: 1, b: 2, c: 3 });
+     *    expect.toBeAssoc(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося ассоциативным массивом:
+     *
+     *    ```js
+     *    const expect = new Expect([1, 2, 3]);
+     *    try {
+     *        expect.toBeAssoc('Значение должно быть ассоциативным массивом');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть ассоциативным массивом
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является ассоциативным массивом.
+     * @returns {boolean} Возвращает `true`, если значение является ассоциативным массивом.
+     * @throws {TypeError} Если значение не является ассоциативным массивом.
+     */
+    toBeAssoc(message = '') {
+        return expect_assoc(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является BigInt.
+     *
+     * ### Описание
+     *
+     * Метод `toBeBigInt` используется для проверки, что фактическое значение (`actual`) является BigInt.
+     * Если значение не является BigInt, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является BigInt. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является BigInt.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося BigInt:
+     *
+     *    ```js
+     *    const expect = new Expect(123n);
+     *    expect.toBeBigInt(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося BigInt:
+     *
+     *    ```js
+     *    const expect = new Expect(123);
+     *    try {
+     *        expect.toBeBigInt('Значение должно быть BigInt');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть BigInt
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является BigInt.
+     * @returns {boolean} Возвращает `true`, если значение является BigInt.
+     * @throws {TypeError} Если значение не является BigInt.
+     */
+    toBeBigInt(message = '') {
+        return expect_bigint(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является логическим типом (boolean).
+     *
+     * ### Описание
+     *
+     * Метод `toBeBool` используется для проверки, что фактическое значение (`actual`) является логическим типом (`boolean`).
+     * Если значение не является логическим типом, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является логическим типом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является логическим типом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося логическим типом:
+     *
+     *    ```js
+     *    const expect = new Expect(true);
+     *    expect.toBeBool(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося логическим типом:
+     *
+     *    ```js
+     *    const expect = new Expect(1);
+     *    try {
+     *        expect.toBeBool('Значение должно быть логическим типом');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть логическим типом
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является логическим типом.
+     * @returns {boolean} Возвращает `true`, если значение является логическим типом.
+     * @throws {TypeError} Если значение не является логическим типом.
+     */
+    toBeBool(message = '') {
+        return expect_bool(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является логическим типом (boolean).
+     *
+     * ### Описание
+     *
+     * Метод `toBeBoolean` используется для проверки, что фактическое значение (`actual`) является логическим типом (`boolean`).
+     * Если значение не является логическим типом, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является логическим типом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является логическим типом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося логическим типом:
+     *
+     *    ```js
+     *    const expect = new Expect(false);
+     *    expect.toBeBoolean(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося логическим типом:
+     *
+     *    ```js
+     *    const expect = new Expect(0);
+     *    try {
+     *        expect.toBeBoolean('Значение должно быть логическим типом');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть логическим типом
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является логическим типом.
+     * @returns {boolean} Возвращает `true`, если значение является логическим типом.
+     * @throws {TypeError} Если значение не является логическим типом.
+     */
+    toBeBoolean(message = '') {
+        return expect_bool(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является символом (char).
+     *
+     * ### Описание
+     *
+     * Метод `toBeChar` используется для проверки, что фактическое значение (`actual`) является символом (строкой длиной 1).
+     * Если значение не является символом, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является символом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является символом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося символом:
+     *
+     *    ```js
+     *    const expect = new Expect('a');
+     *    expect.toBeChar(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося символом:
+     *
+     *    ```js
+     *    const expect = new Expect('abc');
+     *    try {
+     *        expect.toBeChar('Значение должно быть символом');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть символом
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является символом.
+     * @returns {boolean} Возвращает `true`, если значение является символом.
+     * @throws {TypeError} Если значение не является символом.
+     */
+    toBeChar(message = '') {
+        return expect_char(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является классом.
+     *
+     * ### Описание
+     *
+     * Метод `toBeClass` используется для проверки, что фактическое значение (`actual`) является классом.
+     * Если значение не является классом, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является классом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является классом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося классом:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const expect = new Expect(MyClass);
+     *    expect.toBeClass(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося классом:
+     *
+     *    ```js
+     *    const expect = new Expect(function() {});
+     *    try {
+     *        expect.toBeClass('Значение должно быть классом');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть классом
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является классом.
+     * @returns {boolean} Возвращает `true`, если значение является классом.
+     * @throws {TypeError} Если значение не является классом.
+     */
+    toBeClass(message = '') {
+        return expect_class(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение является числом с плавающей запятой (float).
+     *
+     * ### Описание
+     *
+     * Метод `toBeFloat` используется для проверки, что фактическое значение (`actual`) является числом с плавающей запятой (float).
+     * Если значение не является числом с плавающей запятой, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является числом с плавающей запятой. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом с плавающей запятой.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося числом с плавающей запятой:
+     *
+     *    ```js
+     *    const expect = new Expect(3.14);
+     *    expect.toBeFloat(); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося числом с плавающей запятой:
+     *
+     *    ```js
+     *    const expect = new Expect(3);
+     *    try {
+     *        expect.toBeFloat('Значение должно быть числом с плавающей запятой');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть числом с плавающей запятой
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является числом с плавающей запятой.
+     * @returns {boolean} Возвращает `true`, если значение является числом с плавающей запятой.
+     * @throws {TypeError} Если значение не является числом с плавающей запятой.
+     */
+    toBeFloat(message = '') {
+        return expect_float(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение функцией, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeFunction` используется для проверки, является ли переданное значение функцией.
+     * Если значение не является функцией, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является функцией. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является функцией.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося функцией:
+     *
+     *    ```js
+     *    function myFunction() {}
+     *    const result = new Expect(myFunction).toBeFunction();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося функцией:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeFunction('Значение должно быть функцией.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть функцией.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not a function').toBeFunction('Ожидалась функция.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалась функция.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является функцией.
+     * @returns {boolean} Возвращает `true`, если значение является функцией.
+     * @throws {TypeError} Если значение не является функцией или если параметр `message` не является строкой.
+     */
+    toBeFunction(message = '') {
+        return expect_function(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение бесконечностью (Infinity), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeInfinity` используется для проверки, является ли переданное значение бесконечностью (Infinity).
+     * Если значение не является бесконечностью, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является бесконечностью. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является бесконечностью.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося бесконечностью:
+     *
+     *    ```js
+     *    const value = Infinity;
+     *    const result = new Expect(value).toBeInfinity();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося бесконечностью:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeInfinity('Значение должно быть бесконечностью.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть бесконечностью.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not infinity').toBeInfinity('Ожидалась бесконечность.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалась бесконечность.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является бесконечностью.
+     * @returns {boolean} Возвращает `true`, если значение является бесконечностью.
+     * @throws {TypeError} Если значение не является бесконечностью или если параметр `message` не является строкой.
+     */
+    toBeInfinity(message = '') {
+        return expect_infinity(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом (integer), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeInt` используется для проверки, является ли переданное значение целым числом (integer).
+     * Если значение не является целым числом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является целым числом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося целым числом:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = new Expect(value).toBeInt();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося целым числом:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123.45).toBeInt('Значение должно быть целым числом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть целым числом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('123').toBeInt('Ожидалось целое число.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось целое число.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является целым числом.
+     * @returns {boolean} Возвращает `true`, если значение является целым числом.
+     * @throws {TypeError} Если значение не является целым числом или если параметр `message` не является строкой.
+     */
+    toBeInt(message = '') {
+        return expect_int(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом (integer), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeInteger` используется для проверки, является ли переданное значение целым числом (integer).
+     * Если значение не является целым числом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является целым числом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося целым числом:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = new Expect(value).toBeInteger();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося целым числом:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123.45).toBeInteger('Значение должно быть целым числом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть целым числом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('123').toBeInteger('Ожидалось целое число.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось целое число.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является целым числом.
+     * @returns {boolean} Возвращает `true`, если значение является целым числом.
+     * @throws {TypeError} Если значение не является целым числом или если параметр `message` не является строкой.
+     */
+    toBeInteger(message = '') {
+        return expect_int(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение списком (list), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeList` используется для проверки, является ли переданное значение списком (list).
+     * Если значение не является списком, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является списком. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является списком.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося списком:
+     *
+     *    ```js
+     *    const value = [1, 2, 3];
+     *    const result = new Expect(value).toBeList();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося списком:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not a list').toBeList('Значение должно быть списком.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть списком.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeList('Ожидался список.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался список.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является списком.
+     * @returns {boolean} Возвращает `true`, если значение является списком.
+     * @throws {TypeError} Если значение не является списком или если параметр `message` не является строкой.
+     */
+    toBeList(message = '') {
+        return expect_list(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение NaN (Not-a-Number), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeNaN` используется для проверки, является ли переданное значение NaN (Not-a-Number).
+     * Если значение не является NaN, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является NaN. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является NaN.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося NaN:
+     *
+     *    ```js
+     *    const value = NaN;
+     *    const result = new Expect(value).toBeNaN();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося NaN:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeNaN('Значение должно быть NaN.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть NaN.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not NaN').toBeNaN('Ожидалось значение NaN.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось значение NaN.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является NaN.
+     * @returns {boolean} Возвращает `true`, если значение является NaN.
+     * @throws {TypeError} Если значение не является NaN или если параметр `message` не является строкой.
+     */
+    toBeNaN(message = '') {
+        return expect_nan(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение null, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeNull` используется для проверки, является ли переданное значение null.
+     * Если значение не является null, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является null. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является null.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося null:
+     *
+     *    ```js
+     *    const value = null;
+     *    const result = new Expect(value).toBeNull();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося null:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeNull('Значение должно быть null.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть null.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not null').toBeNull('Ожидалось значение null.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось значение null.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является null.
+     * @returns {boolean} Возвращает `true`, если значение является null.
+     * @throws {TypeError} Если значение не является null или если параметр `message` не является строкой.
+     */
+    toBeNull(message = '') {
+        return expect_null(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение числом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeNumber` используется для проверки, является ли переданное значение числом.
+     * Если значение не является числом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является числом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося числом:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = new Expect(value).toBeNumber();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося числом:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('123').toBeNumber('Значение должно быть числом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть числом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not a number').toBeNumber('Ожидалось число.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось число.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является числом.
+     * @returns {boolean} Возвращает `true`, если значение является числом.
+     * @throws {TypeError} Если значение не является числом или если параметр `message` не является строкой.
+     */
+    toBeNumber(message = '') {
+        return expect_number(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение числовым, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeNumeric` используется для проверки, является ли переданное значение числовым.
+     * Если значение не является числовым, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является числовым. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числовым.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося числовым:
+     *
+     *    ```js
+     *    const value = '123';
+     *    const result = new Expect(value).toBeNumeric();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося числовым:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('abc').toBeNumeric('Значение должно быть числовым.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть числовым.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect({}).toBeNumeric('Ожидалось числовое значение.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось числовое значение.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является числовым.
+     * @returns {boolean} Возвращает `true`, если значение является числовым.
+     * @throws {TypeError} Если значение не является числовым или если параметр `message` не является строкой.
+     */
+    toBeNumeric(message = '') {
+        return expect_numeric(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение объектом, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeObject` используется для проверки, является ли переданное значение объектом.
+     * Если значение не является объектом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является объектом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является объектом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося объектом:
+     *
+     *    ```js
+     *    const value = { a: 1, b: 2 };
+     *    const result = new Expect(value).toBeObject();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося объектом:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeObject('Значение должно быть объектом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть объектом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not an object').toBeObject('Ожидался объект.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался объект.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является объектом.
+     * @returns {boolean} Возвращает `true`, если значение является объектом.
+     * @throws {TypeError} Если значение не является объектом или если параметр `message` не является строкой.
+     */
+    toBeObject(message = '') {
+        return expect_object(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение скалярным (boolean, number, string, или symbol), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeScalar` используется для проверки, является ли переданное значение скалярным (boolean, number, string, или symbol).
+     * Если значение не является скалярным, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является скалярным. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является скалярным.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося скалярным:
+     *
+     *    ```js
+     *    const value = 123;
+     *    const result = new Expect(value).toBeScalar();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося скалярным:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect([1, 2, 3]).toBeScalar('Значение должно быть скалярным.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть скалярным.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect({}).toBeScalar('Ожидалось скалярное значение.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось скалярное значение.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является скалярным.
+     * @returns {boolean} Возвращает `true`, если значение является скалярным.
+     * @throws {TypeError} Если значение не является скалярным или если параметр `message` не является строкой.
+     */
+    toBeScalar(message = '') {
+        return expect_scalar(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение строкой, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeString` используется для проверки, является ли переданное значение строкой.
+     * Если значение не является строкой, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является строкой. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является строкой.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося строкой:
+     *
+     *    ```js
+     *    const value = 'Hello, world!';
+     *    const result = new Expect(value).toBeString();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося строкой:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeString('Значение должно быть строкой.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть строкой.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(true).toBeString('Ожидалась строка.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалась строка.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является строкой.
+     * @returns {boolean} Возвращает `true`, если значение является строкой.
+     * @throws {TypeError} Если значение не является строкой или если параметр `message` не является строкой.
+     */
+    toBeString(message = '') {
+        return expect_string(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение символом (Symbol), и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeSymbol` используется для проверки, является ли переданное значение символом (Symbol).
+     * Если значение не является символом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является символом. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является символом.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося символом:
+     *
+     *    ```js
+     *    const value = Symbol('example');
+     *    const result = new Expect(value).toBeSymbol();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося символом:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not a symbol').toBeSymbol('Значение должно быть символом.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть символом.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeSymbol('Ожидался символ.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидался символ.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является символом.
+     * @returns {boolean} Возвращает `true`, если значение является символом.
+     * @throws {TypeError} Если значение не является символом или если параметр `message` не является строкой.
+     */
+    toBeSymbol(message = '') {
+        return expect_symbol(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, является ли значение undefined, и выбрасывает ошибку с указанным сообщением, если это не так.
+     *
+     * ### Описание
+     *
+     * Метод `toBeUndefined` используется для проверки, является ли переданное значение undefined.
+     * Если значение не является undefined, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `message` (string): Сообщение об ошибке, если значение не является undefined. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является undefined.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения, являющегося undefined:
+     *
+     *    ```js
+     *    let value;
+     *    const result = new Expect(value).toBeUndefined();
+     *    console.log(result); // true
+     *    ```
+     *
+     * 2. Проверка значения, не являющегося undefined:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect(123).toBeUndefined('Значение должно быть undefined.');
+     *    } catch (e) {
+     *        console.error(e.message); // Значение должно быть undefined.
+     *    }
+     *    ```
+     *
+     * 3. Проверка значения с использованием пользовательского сообщения об ошибке:
+     *
+     *    ```js
+     *    try {
+     *        const result = new Expect('not undefined').toBeUndefined('Ожидалось значение undefined.');
+     *    } catch (e) {
+     *        console.error(e.message); // Ожидалось значение undefined.
+     *    }
+     *    ```
+     *
+     * @param {string} [message=''] Сообщение об ошибке, если значение не является undefined.
+     * @returns {boolean} Возвращает `true`, если значение является undefined.
+     * @throws {TypeError} Если значение не является undefined или если параметр `message` не является строкой.
+     */
+    toBeUndefined(message = '') {
+        return expect_undefined(this.#actual, message);
+    }
+
+    /**
+     * Проверяет, что фактическое значение эквивалентно ожидаемому значению.
+     *
+     * ### Описание
+     *
+     * Метод `toEqual` используется для проверки, что фактическое значение (`actual`) эквивалентно ожидаемому значению (`expected`).
+     * Эквивалентность проверяется с использованием функции `is_equal`, которая рекурсивно сравнивает ключи и значения объектов и массивов.
+     * Если значения не эквивалентны, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `expected` (any): Ожидаемое значение для сравнения.
+     * - `message` (string): Сообщение об ошибке, если значения не эквивалентны. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значения эквивалентны.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка эквивалентности чисел:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    expect.toEqual(5); // true
+     *    ```
+     *
+     * 2. Проверка эквивалентности строк:
+     *
+     *    ```js
+     *    const expect = new Expect('hello');
+     *    expect.toEqual('hello'); // true
+     *    ```
+     *
+     * 3. Проверка эквивалентности объектов:
+     *
+     *    ```js
+     *    const expect = new Expect({ a: 1, b: 2 });
+     *    expect.toEqual({ a: 1, b: 2 }); // true
+     *    ```
+     *
+     * 4. Проверка неэквивалентности с сообщением об ошибке:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    try {
+     *        expect.toEqual(10, 'Значения не эквивалентны');
+     *    } catch (e) {
+     *        console.error(e.message); // Значения не эквивалентны
+     *    }
+     *    ```
+     *
+     * @param {any} expected Ожидаемое значение для сравнения.
+     * @param {string} [message=''] Сообщение об ошибке, если значения не эквивалентны.
+     * @returns {boolean} Возвращает `true`, если значения эквивалентны.
+     * @throws {TypeError} Если значения не эквивалентны.
+     */
+    toEqual(expected, message = '') {
+        if (!is_string(message)) {
+            throw new TypeError('Параметр "message" должен быть строкой.');
+        }
+
+        if (!is_equal(this.#actual, expected)) {
+            throw new TypeError(message);
+        }
+
+        return true;
+    }
+
+    /**
+     * Проверяет, что фактическое значение строго эквивалентно ожидаемому значению.
+     *
+     * ### Описание
+     *
+     * Метод `toStrictEqual` используется для проверки, что фактическое значение (`actual`) строго эквивалентно ожидаемому значению (`expected`).
+     * Строгая эквивалентность проверяется с использованием функции `is_equal` в строгом режиме, которая рекурсивно сравнивает ключи и значения объектов и массивов с учетом типов.
+     * Если значения не строго эквивалентны, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+     *
+     * ### Параметры
+     *
+     * - `expected` (any): Ожидаемое значение для сравнения.
+     * - `message` (string): Сообщение об ошибке, если значения не строго эквивалентны. По умолчанию пустая строка.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значения строго эквивалентны.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка строгой эквивалентности чисел:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    expect.toStrictEqual(5); // true
+     *    ```
+     *
+     * 2. Проверка строгой эквивалентности строк:
+     *
+     *    ```js
+     *    const expect = new Expect('hello');
+     *    expect.toStrictEqual('hello'); // true
+     *    ```
+     *
+     * 3. Проверка строгой эквивалентности объектов:
+     *
+     *    ```js
+     *    const expect = new Expect({ a: 1, b: 2 });
+     *    expect.toStrictEqual({ a: 1, b: 2 }); // true
+     *    ```
+     *
+     * 4. Проверка нестрогой эквивалентности с сообщением об ошибке:
+     *
+     *    ```js
+     *    const expect = new Expect(5);
+     *    try {
+     *        expect.toStrictEqual('5', 'Значения не строго эквивалентны');
+     *    } catch (e) {
+     *        console.error(e.message); // Значения не строго эквивалентны
+     *    }
+     *    ```
+     *
+     * @param {any} expected Ожидаемое значение для сравнения.
+     * @param {string} [message=''] Сообщение об ошибке, если значения не строго эквивалентны.
+     * @returns {boolean} Возвращает `true`, если значения строго эквивалентны.
+     * @throws {TypeError} Если значения не строго эквивалентны.
+     */
+    toStrictEqual(expected, message = '') {
+        if (!is_string(message)) {
+            throw new TypeError('Параметр "message" должен быть строкой.');
+        }
+
+        if (!is_equal(this.#actual, expected, true)) {
+            throw new TypeError(message);
+        }
+
+        return true;
+    }
+}
+
+export default Expect;