@rogolev/value 0.0.1 → 0.0.3

package/src/classes/Value.mjs

@@ -0,0 +1,2846 @@
+import empty from '../helpers/empty.mjs';
+import gettype from '../helpers/gettype.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';
+import print from '../helpers/print.mjs';
+import print_type from '../helpers/print_type.mjs';
+import settype from '../helpers/settype.mjs';
+import to_array from '../helpers/to_array.mjs';
+import to_assoc from '../helpers/to_assoc.mjs';
+import to_bool from '../helpers/to_bool.mjs';
+import to_float from '../helpers/to_float.mjs';
+import to_int from '../helpers/to_int.mjs';
+import to_list from '../helpers/to_list.mjs';
+import to_object from '../helpers/to_object.mjs';
+import to_string from '../helpers/to_string.mjs';
+
+/**
+ * Класс `Value` представляет обертку для значений различных типов и предоставляет методы для работы с ними.
+ *
+ * ### Описание
+ *
+ * Класс `Value` используется для хранения значения и предоставления методов для работы с этим значением.
+ * Значение хранится в приватном свойстве `#value` и не может быть изменено после создания экземпляра класса.
+ * Класс также предоставляет методы для получения типа значения, проверки значения на пустоту, преобразования значения в другие типы и другие операции.
+ */
+class Value {
+    /**
+     * Приватное свойство для хранения значения.
+     *
+     * ### Описание
+     *
+     * Свойство `#value` используется для хранения значения, переданного при создании экземпляра класса `Value`.
+     * Значение не может быть изменено после создания экземпляра класса.
+     *
+     * @type {any}
+     */
+    #value;
+
+    /**
+     * Приватное хранилище для кэширования вычисленных значений.
+     *
+     * ### Описание
+     *
+     * Свойство `#store` используется для хранения кэшированных значений, которые были вычислены методами класса.
+     * Это позволяет избежать повторных вычислений одного и того же значения, что может быть полезно для оптимизации производительности.
+     *
+     * @type {Object}
+     */
+    #store = {};
+
+    /**
+     * Создает экземпляр класса `Value` с заданным значением.
+     *
+     * ### Описание
+     *
+     *    const valueInstance = new Value(obj);
+     *    // Свойство: #value = { key: 'value' }
+     *    ```
+     *
+     * 3. Создание экземпляра класса `Value` с массивом:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    // Свойство: #value = [1, 2, 3]
+     *    ```
+     *
+     * @param {any} value Значение, которое необходимо сохранить в экземпляре класса `Value`.
+     */
+    constructor(value) {
+        this.#value = value;
+    }
+
+    /**
+     * Возвращает значение, хранящееся в экземпляре класса `Value`.
+     *
+     * ### Описание
+     *
+     * Метод `get` используется для получения значения, переданного при создании экземпляра класса `Value`.
+     * Это значение хранится в свойстве `#value` экземпляра и не может быть изменено после создания.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает значение, переданное при создании экземпляра класса `Value`.
+     *
+     * ### Примеры использования
+     *
+     * 1. Создание экземпляра класса `Value` и получение значения:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.get();
+     *    // Результат: 123
+     *    ```
+     *
+     * 2. Создание экземпляра класса `Value` с объектом:
+     *
+     *    ```js
+     *    const obj = { key: 'value' };
+     *    const valueInstance = new Value(obj);
+     *    const result = valueInstance.get();
+     *    // Результат: { key: 'value' }
+     *    ```
+     *
+     * 3. Создание экземпляра класса `Value` с массивом:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    const result = valueInstance.get();
+     *    // Результат: [1, 2, 3]
+     *    ```
+     *
+     * @returns {any} Возвращает значение, хранящееся в экземпляре класса `Value`.
+     */
+    get() {
+        return this.#value;
+    }
+
+    /**
+     * Возвращает тип значения, хранящегося в экземпляре класса `Value`.
+     *
+     * ### Описание
+     *
+     * Метод `getType` используется для получения типа значения, переданного при создании экземпляра класса `Value`.
+     * Тип значения определяется с помощью функции `gettype`, которая выполняет различные проверки для определения типа.
+     *
+     * Функция `gettype` выполняет следующие проверки:
+     *
+     * 1. **Null**: Проверяет, является ли значение `null`.
+     * 2. **NaN**: Проверяет, является ли значение `NaN`.
+     * 3. **Undefined**: Проверяет, является ли значение `undefined`.
+     * 4. **Infinity**: Проверяет, является ли значение бесконечностью.
+     * 5. **Boolean**: Проверяет, является ли значение логическим.
+     * 6. **Integer**: Проверяет, является ли значение целым числом.
+     * 7. **BigInt**: Проверяет, является ли значение типом BigInt.
+     * 8. **Float**: Проверяет, является ли значение числом с плавающей точкой.
+     * 9. **String**: Проверяет, является ли значение строкой.
+     * 10. **Symbol**: Проверяет, является ли значение символом.
+     * 11. **Class**: Проверяет, является ли значение классом.
+     * 12. **Function**: Проверяет, является ли значение функцией.
+     * 13. **Array**: Проверяет, является ли значение массивом.
+     * 14. **Object**: Проверяет, является ли значение объектом.
+     *
+     * Если значение не соответствует ни одному из этих типов, функция возвращает результат `typeof value`.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает строку, представляющую тип значения, хранящегося в экземпляре класса `Value`.
+     *
+     * ### Примеры использования
+     *
+     * Создание экземпляра класса `Value` и получение типа значения:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.getType();
+     *    // Результат: 'integer'
+     *    ```
+     *
+     * @returns {string} Возвращает тип значения, хранящегося в экземпляре класса `Value`.
+     */
+    getType() {
+        return this.#getFromStore('type', () => gettype(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к указанному типу.
+     *
+     * ### Описание
+     *
+     * Метод `setType` используется для преобразования значения, хранящегося в экземпляре класса `Value`, к указанному типу.
+     * Поддерживаются типы: `boolean`, `integer`, `float`, `string`, `array`, `object`.
+     *
+     * Метод использует функцию `settype` для выполнения преобразования.
+     *
+     * ### Параметры
+     *
+     * - `type` (string)
+     *      Тип, к которому необходимо привести значение.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование в булевое значение:
+     *
+     *    ```js
+     *    const valueInstance = new Value('true');
+     *    const result = valueInstance.setType('boolean');
+     *    // Результат: новый экземпляр класса Value с значением true
+     *    ```
+     *
+     * 2. Преобразование в целое число:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123');
+     *    const result = valueInstance.setType('integer');
+     *    // Результат: новый экземпляр класса Value с значением 123
+     *    ```
+     *
+     * 3. Преобразование в число с плавающей точкой:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123.45');
+     *    const result = valueInstance.setType('float');
+     *    // Результат: новый экземпляр класса Value с значением 123.45
+     *    ```
+     *
+     * 4. Преобразование в строку:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.setType('string');
+     *    // Результат: новый экземпляр класса Value с значением '123'
+     *    ```
+     *
+     * 5. Преобразование в массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.setType('array');
+     *    // Результат: новый экземпляр класса Value с значением ['example']
+     *    ```
+     *
+     * 6. Преобразование в объект:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.setType('object');
+     *    // Результат: новый экземпляр класса Value с значением { value: 'example' }
+     *    ```
+     *
+     * @param {string} type Тип, к которому необходимо привести значение.
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    setType(type) {
+        return new Value(settype(this.#value, type));
+    }
+
+    /**
+     * Проверяет, является ли значение, хранящееся в экземпляре класса `Value`, пустым.
+     *
+     * ### Описание
+     *
+     * Метод `isEmpty` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, пустым.
+     * Пустыми считаются значения `null`, `undefined`, пустая строка, `0`, `false`, пустой массив и пустой объект.
+     *
+     * Метод использует функцию `empty` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение пустое, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка пустых значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.isEmpty();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.isEmpty();
+     *    // Результат: true
+     *
+     *    const valueInstance3 = new Value('');
+     *    const result3 = valueInstance3.isEmpty();
+     *    // Результат: true
+     *
+     *    const valueInstance4 = new Value(0);
+     *    const result4 = valueInstance4.isEmpty();
+     *    // Результат: true
+     *
+     *    const valueInstance5 = new Value(false);
+     *    const result5 = valueInstance5.isEmpty();
+     *    // Результат: true
+     *
+     *    const valueInstance6 = new Value([]);
+     *    const result6 = valueInstance6.isEmpty();
+     *    // Результат: true
+     *
+     *    const valueInstance7 = new Value({});
+     *    const result7 = valueInstance7.isEmpty();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка непустых значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value('example');
+     *    const result1 = valueInstance1.isEmpty();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(123);
+     *    const result2 = valueInstance2.isEmpty();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value(true);
+     *    const result3 = valueInstance3.isEmpty();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value([1, 2, 3]);
+     *    const result4 = valueInstance4.isEmpty();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value({ key: 'value' });
+     *    const result5 = valueInstance5.isEmpty();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение пустое, и `false` в противном случае.
+     */
+    isEmpty() {
+        return this.#getFromStore('isEmpty', () => empty(this.#value));
+    }
+
+    /**
+     * Преобразует значение переменной в строку и выводит его на консоль.
+     *
+     * ### Описание
+     *
+     * Метод `print` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в строку и вывода его на консоль.
+     * Он обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое представление.
+     *
+     * Метод использует функцию `print` для выполнения преобразования и вывода значения на консоль.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает текущий экземпляр класса `Value`.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "example"
+     *    ```
+     *
+     * 2. Преобразование числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    123
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    true
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(false);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    false
+     *    ```
+     *
+     * 4. Преобразование null и undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    null
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    undefined
+     *    ```
+     *
+     * 5. Преобразование массива:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    [
+     *        0: 1,
+     *        1: 2,
+     *        2: 3,
+     *    ]
+     *    ```
+     *
+     * 6. Преобразование ассоциативного массива:
+     *
+     *    ```js
+     *    const obj = { key: 'value' };
+     *    const valueInstance = new Value(obj);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    {
+     *        key: "value",
+     *    }
+     *    ```
+     *
+     * 7. Преобразование функции:
+     *
+     *    ```js
+     *    const func = function() {};
+     *    const valueInstance = new Value(func);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    function func() {}
+     *    ```
+     *
+     * 8. Преобразование символа:
+     *
+     *    ```js
+     *    const symbol = Symbol('example');
+     *    const valueInstance = new Value(symbol);
+     *    valueInstance.print();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    Symbol(example)
+     *    ```
+     *
+     * @returns {Value} Возвращает текущий экземпляр класса `Value`.
+     */
+    print() {
+        console.log(this.#getFromStore('print', () => print(this.#value, true)));
+
+        return this;
+    }
+
+    /**
+     * Преобразует значение переменной в строку и возвращает новый экземпляр класса `Value` с этим значением.
+     *
+     * ### Описание
+     *
+     * Метод `toPrint` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в строку и возвращает новый экземпляр класса `Value` с этим значением.
+     * Он обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое представление.
+     *
+     * Метод использует функцию `print` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением "example"
+     *    ```
+     *
+     * 2. Преобразование числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением 123
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(false);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * 4. Преобразование null и undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением null
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением undefined
+     *    ```
+     *
+     * 5. Преобразование массива:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением [
+     *    //     0: 1,
+     *    //     1: 2,
+     *    //     2: 3,
+     *    // ]
+     *    ```
+     *
+     * 6. Преобразование ассоциативного массива:
+     *
+     *    ```js
+     *    const obj = { key: 'value' };
+     *    const valueInstance = new Value(obj);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением {
+     *    //     key: "value",
+     *    // }
+     *    ```
+     *
+     * 7. Преобразование функции:
+     *
+     *    ```js
+     *    const func = function() {};
+     *    const valueInstance = new Value(func);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением function func() {}
+     *    ```
+     *
+     * 8. Преобразование символа:
+     *
+     *    ```js
+     *    const symbol = Symbol('example');
+     *    const valueInstance = new Value(symbol);
+     *    const result = valueInstance.toPrint();
+     *    // Результат: новый экземпляр класса Value с значением Symbol(example)
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toPrint() {
+        return new Value(this.#getFromStore('print', () => print(this.#value, true)));
+    }
+
+    /**
+     * Преобразует тип значения переменной в строку и выводит его на консоль.
+     *
+     * ### Описание
+     *
+     * Метод `printType` используется для преобразования типа значения, хранящегося в экземпляре класса `Value`, в строку и вывода его на консоль.
+     * Он обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое представление.
+     *
+     * Метод использует функцию `print_type` для выполнения преобразования и вывода значения на консоль.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает текущий экземпляр класса `Value`.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "string"
+     *    ```
+     *
+     * 2. Преобразование числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "integer"
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "boolean"
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(false);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "boolean"
+     *    ```
+     *
+     * 4. Преобразование null и undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "null"
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "undefined"
+     *    ```
+     *
+     * 5. Преобразование массива:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "array"
+     *    ```
+     *
+     * 6. Преобразование ассоциативного массива:
+     *
+     *    ```js
+     *    const obj = { key: 'value' };
+     *    const valueInstance = new Value(obj);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "object"
+     *    ```
+     *
+     * 7. Преобразование функции:
+     *
+     *    ```js
+     *    const func = function() {};
+     *    const valueInstance = new Value(func);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "function"
+     *    ```
+     *
+     * 8. Преобразование символа:
+     *
+     *    ```js
+     *    const symbol = Symbol('example');
+     *    const valueInstance = new Value(symbol);
+     *    valueInstance.printType();
+     *    ```
+     *    Вывод:
+     *    ```txt
+     *    "symbol"
+     *    ```
+     *
+     * @returns {Value} Возвращает текущий экземпляр класса `Value`.
+     */
+    printType() {
+        console.log(this.#getFromStore('printType', () => print_type(this.#value, true)));
+
+        return this;
+    }
+
+    /**
+     * Преобразует тип значения переменной в строку и возвращает новый экземпляр класса `Value` с этим значением.
+     *
+     * ### Описание
+     *
+     * Метод `toPrintType` используется для преобразования типа значения, хранящегося в экземпляре класса `Value`, в строку и возвращает новый экземпляр класса `Value` с этим значением.
+     * Он обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое представление.
+     *
+     * Метод использует функцию `print_type` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "string"
+     *    ```
+     *
+     * 2. Преобразование числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "integer"
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "boolean"
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(false);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "boolean"
+     *    ```
+     *
+     * 4. Преобразование null и undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "null"
+     *    ```
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "undefined"
+     *    ```
+     *
+     * 5. Преобразование массива:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "array"
+     *    ```
+     *
+     * 6. Преобразование ассоциативного массива:
+     *
+     *    ```js
+     *    const obj = { key: 'value' };
+     *    const valueInstance = new Value(obj);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "object"
+     *    ```
+     *
+     * 7. Преобразование функции:
+     *
+     *    ```js
+     *    const func = function() {};
+     *    const valueInstance = new Value(func);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "function"
+     *    ```
+     *
+     * 8. Преобразование символа:
+     *
+     *    ```js
+     *    const symbol = Symbol('example');
+     *    const valueInstance = new Value(symbol);
+     *    const result = valueInstance.toPrintType();
+     *    // Результат: новый экземпляр класса Value с значением "symbol"
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toPrintType() {
+        return new Value(this.#getFromStore('printType', () => print_type(this.#value, true)));
+    }
+
+    /**
+     * Проверяет, является ли значение массивом.
+     *
+     * ### Описание
+     *
+     * Метод `isArray` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, массивом.
+     * Массивом считается значение, которое является экземпляром класса `Array`.
+     *
+     * Метод использует функцию `is_array` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является массивом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка массива:
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.isArray();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка объекта:
+     *
+     *    ```js
+     *    const valueInstance = new Value({ key: 'value' });
+     *    const result = valueInstance.isArray();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.isArray();
+     *    // Результат: false
+     *    ```
+     *
+     * 4. Проверка числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.isArray();
+     *    // Результат: false
+     *    ```
+     *
+     * 5. Проверка булевого значения:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    const result = valueInstance.isArray();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является массивом, и `false` в противном случае.
+     */
+    isArray() {
+        return this.#getFromStore('isArray', () => is_array(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение ассоциативным массивом.
+     *
+     * ### Описание
+     *
+     * Метод `isAssoc` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, ассоциативным массивом.
+     * Ассоциативным массивом считается объект, который не является массивом и не является `null`.
+     *
+     * Метод использует функцию `is_assoc` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является ассоциативным массивом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка ассоциативного массива:
+     *
+     *    ```js
+     *    const valueInstance = new Value({ key: 'value' });
+     *    const result = valueInstance.isAssoc();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка массива:
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.isAssoc();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка null:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.isAssoc();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является ассоциативным массивом, и `false` в противном случае.
+     */
+    isAssoc() {
+        return this.#getFromStore('isAssoc', () => is_assoc(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение типом BigInt.
+     *
+     * ### Описание
+     *
+     * Метод `isBigInt` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, типом BigInt.
+     * BigInt - это встроенный тип данных в JavaScript, который используется для представления целых чисел произвольной длины.
+     *
+     * Метод использует функцию `is_bigint` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является типом BigInt, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения типа BigInt:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123n);
+     *    const result = valueInstance.isBigInt();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значения типа Number:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.isBigInt();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123');
+     *    const result = valueInstance.isBigInt();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является типом BigInt, и `false` в противном случае.
+     */
+    isBigInt() {
+        return this.#getFromStore('isBigInt', () => is_bigint(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение логическим (булевым).
+     *
+     * ### Описание
+     *
+     * Метод `isBool` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, логическим (булевым).
+     * Логическим значением считается значение, которое является `true` или `false`.
+     *
+     * Метод использует функцию `is_bool` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является логическим, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения `true`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    const result = valueInstance.isBool();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значения `false`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(false);
+     *    const result = valueInstance.isBool();
+     *    // Результат: true
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('true');
+     *    const result = valueInstance.isBool();
+     *    // Результат: false
+     *    ```
+     *
+     * 4. Проверка числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(1);
+     *    const result = valueInstance.isBool();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является логическим, и `false` в противном случае.
+     */
+    isBool() {
+        return this.#getFromStore('isBool', () => is_bool(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение логическим (булевым).
+     *
+     * ### Описание
+     *
+     * Метод `isBoolean` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, логическим (булевым).
+     * Логическим значением считается значение, которое является `true` или `false`.
+     *
+     * Метод использует функцию `is_bool` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является логическим, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения `true`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    const result = valueInstance.isBoolean();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значения `false`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(false);
+     *    const result = valueInstance.isBoolean();
+     *    // Результат: true
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('true');
+     *    const result = valueInstance.isBoolean();
+     *    // Результат: false
+     *    ```
+     *
+     * 4. Проверка числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(1);
+     *    const result = valueInstance.isBoolean();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является логическим, и `false` в противном случае.
+     */
+    isBoolean() {
+        return this.#getFromStore('isBool', () => is_bool(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение классом.
+     *
+     * ### Описание
+     *
+     * Метод `isClass` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, классом.
+     * Классом считается значение, которое является функцией и имеет свойство `prototype`, являющееся объектом.
+     *
+     * Метод использует функцию `is_class` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является классом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка класса:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const valueInstance = new Value(MyClass);
+     *    const result = valueInstance.isClass();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка функции:
+     *
+     *    ```js
+     *    const myFunction = function() {};
+     *    const valueInstance = new Value(myFunction);
+     *    const result = valueInstance.isClass();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка объекта:
+     *
+     *    ```js
+     *    const myObject = {};
+     *    const valueInstance = new Value(myObject);
+     *    const result = valueInstance.isClass();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является классом, и `false` в противном случае.
+     */
+    isClass() {
+        return this.#getFromStore('isClass', () => is_class(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение числом с плавающей точкой.
+     *
+     * ### Описание
+     *
+     * Метод `isFloat` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, числом с плавающей точкой.
+     * Числом с плавающей точкой считается значение, которое является числом и не является целым числом.
+     *
+     * Метод использует функцию `is_float` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом с плавающей точкой, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка числа с плавающей точкой:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123.45);
+     *    const result = valueInstance.isFloat();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка целого числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.isFloat();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123.45');
+     *    const result = valueInstance.isFloat();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является числом с плавающей точкой, и `false` в противном случае.
+     */
+    isFloat() {
+        return this.#getFromStore('isFloat', () => is_float(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение функцией.
+     *
+     * ### Описание
+     *
+     * Метод `isFunction` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, функцией.
+     * Функцией считается значение, которое является экземпляром класса `Function`.
+     *
+     * Метод использует функцию `is_function` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является функцией, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка функции:
+     *
+     *    ```js
+     *    const valueInstance = new Value(function() {});
+     *    const result = valueInstance.isFunction();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка стрелочной функции:
+     *
+     *    ```js
+     *    const valueInstance = new Value(() => {});
+     *    const result = valueInstance.isFunction();
+     *    // Результат: true
+     *    ```
+     *
+     * 3. Проверка класса:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const valueInstance = new Value(MyClass);
+     *    const result = valueInstance.isFunction();
+     *    // Результат: false
+     *    ```
+     *
+     * 4. Проверка объекта:
+     *
+     *    ```js
+     *    const valueInstance = new Value({});
+     *    const result = valueInstance.isFunction();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является функцией, и `false` в противном случае.
+     */
+    isFunction() {
+        return this.#getFromStore('isFunction', () => is_function(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение бесконечностью.
+     *
+     * ### Описание
+     *
+     * Метод `isInfinity` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, бесконечностью.
+     * Значение считается бесконечностью, если оно равно `Infinity` или `-Infinity`.
+     *
+     * Метод использует функцию `is_infinity` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является бесконечностью, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения `Infinity`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(Infinity);
+     *    const result = valueInstance.isInfinity();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значения `-Infinity`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(-Infinity);
+     *    const result = valueInstance.isInfinity();
+     *    // Результат: true
+     *    ```
+     *
+     * 3. Проверка значения `123`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.isInfinity();
+     *    // Результат: false
+     *    ```
+     *
+     * 4. Проверка значения `NaN`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(NaN);
+     *    const result = valueInstance.isInfinity();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является бесконечностью, и `false` в противном случае.
+     */
+    isInfinity() {
+        return this.#getFromStore('isInfinity', () => is_infinity(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом.
+     *
+     * ### Описание
+     *
+     * Метод `isInt` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, целым числом.
+     * Целым числом считается значение, которое имеет тип `number`, является конечным и не имеет дробной части.
+     *
+     * Метод использует функцию `is_int` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка целого числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.isInt();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка числа с плавающей точкой:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123.45);
+     *    const result = valueInstance.isInt();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123');
+     *    const result = valueInstance.isInt();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является целым числом, и `false` в противном случае.
+     */
+    isInt() {
+        return this.#getFromStore('isInt', () => is_int(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение целым числом.
+     *
+     * ### Описание
+     *
+     * Метод `isInteger` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, целым числом.
+     * Целым числом считается значение, которое имеет тип `number`, является конечным и не имеет дробной части.
+     *
+     * Метод использует функцию `is_int` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является целым числом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка целого числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.isInteger();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка числа с плавающей точкой:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123.45);
+     *    const result = valueInstance.isInteger();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123');
+     *    const result = valueInstance.isInteger();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является целым числом, и `false` в противном случае.
+     */
+    isInteger() {
+        return this.#getFromStore('isInt', () => is_int(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение списком.
+     *
+     * ### Описание
+     *
+     * Метод `isList` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, списком.
+     * Списком считается значение, которое является массивом.
+     *
+     * Метод использует функцию `is_list` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является списком, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка массивов:
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.isList();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value({});
+     *    const result = valueInstance.isList();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value('string');
+     *    const result2 = valueInstance2.isList();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value(42);
+     *    const result3 = valueInstance3.isList();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value(null);
+     *    const result4 = valueInstance4.isList();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value(undefined);
+     *    const result5 = valueInstance5.isList();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является списком, и `false` в противном случае.
+     */
+    isList() {
+        return this.#getFromStore('isList', () => is_list(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение NaN.
+     *
+     * ### Описание
+     *
+     * Метод `isNaN` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, NaN (Not-a-Number).
+     *
+     * Метод использует функцию `is_nan` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является NaN, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения NaN:
+     *
+     *    ```js
+     *    const valueInstance = new Value(NaN);
+     *    const result = valueInstance.isNaN();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка числовых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(42);
+     *    const result = valueInstance.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(3.14);
+     *    const result2 = valueInstance2.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value(Infinity);
+     *    const result3 = valueInstance3.isNaN();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value('42');
+     *    const result = valueInstance.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(true);
+     *    const result2 = valueInstance2.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value(null);
+     *    const result3 = valueInstance3.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value(undefined);
+     *    const result4 = valueInstance4.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value({});
+     *    const result5 = valueInstance5.isNaN();
+     *    // Результат: false
+     *
+     *    const valueInstance6 = new Value([]);
+     *    const result6 = valueInstance6.isNaN();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является NaN, и `false` в противном случае.
+     */
+    isNaN() {
+        return this.#getFromStore('isNaN', () => is_nan(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение null.
+     *
+     * ### Описание
+     *
+     * Метод `isNull` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, null.
+     * Значение считается null, если оно строго равно null.
+     *
+     * Метод использует функцию `is_null` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является null, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения null:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.isNull();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значения undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.isNull();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка значения 0:
+     *
+     *    ```js
+     *    const valueInstance = new Value(0);
+     *    const result = valueInstance.isNull();
+     *    // Результат: false
+     *    ```
+     *
+     * 4. Проверка значения пустой строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('');
+     *    const result = valueInstance.isNull();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является null, и `false` в противном случае.
+     */
+    isNull() {
+        return this.#getFromStore('isNull', () => is_null(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение числом.
+     *
+     * ### Описание
+     *
+     * Метод `isNumber` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, числом.
+     * Метод использует оператор `typeof` для проверки типа значения и убеждается, что значение не является `Infinity` или `NaN`.
+     *
+     * Метод использует функцию `is_number` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка числовых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(42);
+     *    const result = valueInstance.isNumber();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value(3.14);
+     *    const result2 = valueInstance2.isNumber();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка специальных числовых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(NaN);
+     *    const result = valueInstance.isNumber();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(Infinity);
+     *    const result2 = valueInstance2.isNumber();
+     *    // Результат: false
+     *    ```
+     *
+     * 3. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value('42');
+     *    const result = valueInstance.isNumber();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(true);
+     *    const result2 = valueInstance2.isNumber();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value(null);
+     *    const result3 = valueInstance3.isNumber();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value(undefined);
+     *    const result4 = valueInstance4.isNumber();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value({});
+     *    const result5 = valueInstance5.isNumber();
+     *    // Результат: false
+     *
+     *    const valueInstance6 = new Value([]);
+     *    const result6 = valueInstance6.isNumber();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является числом, и `false` в противном случае.
+     */
+    isNumber() {
+        return this.#getFromStore('isNumber', () => is_number(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение числом или числовой строкой.
+     *
+     * ### Описание
+     *
+     * Метод `isNumeric` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, числом или строкой, которая может быть преобразована в число.
+     *
+     * Метод использует функцию `is_numeric` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является числом или числовой строкой, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка числовых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value(42);
+     *    const result = valueInstance.isNumeric();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value(3.14);
+     *    const result2 = valueInstance2.isNumeric();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка числовых строк:
+     *
+     *    ```js
+     *    const valueInstance = new Value('42');
+     *    const result = valueInstance.isNumeric();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value('3.14');
+     *    const result2 = valueInstance2.isNumeric();
+     *    // Результат: true
+     *    ```
+     *
+     * 3. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value(true);
+     *    const result = valueInstance.isNumeric();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(null);
+     *    const result2 = valueInstance2.isNumeric();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value(undefined);
+     *    const result3 = valueInstance3.isNumeric();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value({});
+     *    const result4 = valueInstance4.isNumeric();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value([]);
+     *    const result5 = valueInstance5.isNumeric();
+     *    // Результат: false
+     *
+     *    const valueInstance6 = new Value('hello');
+     *    const result6 = valueInstance6.isNumeric();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является числом или числовой строкой, и `false` в противном случае.
+     */
+    isNumeric() {
+        return this.#getFromStore('isNumeric', () => is_numeric(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение объектом.
+     *
+     * ### Описание
+     *
+     * Метод `isObject` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, объектом.
+     * Метод использует оператор `typeof` для проверки типа значения и убеждается, что значение не является `null`.
+     *
+     * Метод использует функцию `is_object` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является объектом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка объектов:
+     *
+     *    ```js
+     *    const valueInstance = new Value({});
+     *    const result = valueInstance.isObject();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value({ key: 'value' });
+     *    const result2 = valueInstance2.isObject();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value(42);
+     *    const result = valueInstance.isObject();
+     *    // Результат: false (число)
+     *
+     *    const valueInstance2 = new Value('string');
+     *    const result2 = valueInstance2.isObject();
+     *    // Результат: false (строка)
+     *
+     *    const valueInstance3 = new Value(null);
+     *    const result3 = valueInstance3.isObject();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value(undefined);
+     *    const result4 = valueInstance4.isObject();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value([]);
+     *    const result5 = valueInstance5.isObject();
+     *    // Результат: false (массив)
+     *
+     *    const valueInstance6 = new Value(() => {});
+     *    const result6 = valueInstance6.isObject();
+     *    // Результат: false (функция)
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является объектом, и `false` в противном случае.
+     */
+    isObject() {
+        return this.#getFromStore('isObject', () => is_object(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение скалярным.
+     *
+     * ### Описание
+     *
+     * Метод `isScalar` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, скалярным.
+     * Скалярные переменные — это переменные, содержащие `int`, `float`, `string`, `bool` и `symbol`.
+     * Типы `array`, `object`, `null`, `undefined` — не скалярные.
+     *
+     * Метод использует функцию `is_scalar` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является скалярным, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка скалярных значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(true);
+     *    const result1 = valueInstance1.isScalar();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value(42);
+     *    const result2 = valueInstance2.isScalar();
+     *    // Результат: true
+     *
+     *    const valueInstance3 = new Value('hello');
+     *    const result3 = valueInstance3.isScalar();
+     *    // Результат: true
+     *
+     *    const valueInstance4 = new Value(Symbol('symbol'));
+     *    const result4 = valueInstance4.isScalar();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка не скалярных значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.isScalar();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.isScalar();
+     *    // Результат: false
+     *
+     *    const valueInstance3 = new Value({});
+     *    const result3 = valueInstance3.isScalar();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value([]);
+     *    const result4 = valueInstance4.isScalar();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value(() => {});
+     *    const result5 = valueInstance5.isScalar();
+     *    // Результат: false
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является скалярным, и `false` в противном случае.
+     */
+    isScalar() {
+        return this.#getFromStore('isScalar', () => is_scalar(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение строкой.
+     *
+     * ### Описание
+     *
+     * Метод `isString` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, строкой.
+     * Метод использует оператор `typeof` для проверки типа значения.
+     *
+     * Метод использует функцию `is_string` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является строкой, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка строковых значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value('hello');
+     *    const result = valueInstance.isString();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value('');
+     *    const result2 = valueInstance2.isString();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value(42);
+     *    const result = valueInstance.isString();
+     *    // Результат: false (число)
+     *
+     *    const valueInstance2 = new Value(true);
+     *    const result2 = valueInstance2.isString();
+     *    // Результат: false (логическое значение)
+     *
+     *    const valueInstance3 = new Value(null);
+     *    const result3 = valueInstance3.isString();
+     *    // Результат: false
+     *
+     *    const valueInstance4 = new Value(undefined);
+     *    const result4 = valueInstance4.isString();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value({});
+     *    const result5 = valueInstance5.isString();
+     *    // Результат: false (объект)
+     *
+     *    const valueInstance6 = new Value([]);
+     *    const result6 = valueInstance6.isString();
+     *    // Результат: false (массив)
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является строкой, и `false` в противном случае.
+     */
+    isString() {
+        return this.#getFromStore('isString', () => is_string(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение символом.
+     *
+     * ### Описание
+     *
+     * Метод `isSymbol` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, символом.
+     * Метод использует оператор `typeof` для проверки типа значения.
+     *
+     * Метод использует функцию `is_symbol` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является символом, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка символов:
+     *
+     *    ```js
+     *    const valueInstance = new Value(Symbol('symbol'));
+     *    const result = valueInstance.isSymbol();
+     *    // Результат: true
+     *
+     *    const valueInstance2 = new Value(Symbol.iterator);
+     *    const result2 = valueInstance2.isSymbol();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value('hello');
+     *    const result = valueInstance.isSymbol();
+     *    // Результат: false (строка)
+     *
+     *    const valueInstance2 = new Value(42);
+     *    const result2 = valueInstance2.isSymbol();
+     *    // Результат: false (число)
+     *
+     *    const valueInstance3 = new Value(true);
+     *    const result3 = valueInstance3.isSymbol();
+     *    // Результат: false (логическое значение)
+     *
+     *    const valueInstance4 = new Value(null);
+     *    const result4 = valueInstance4.isSymbol();
+     *    // Результат: false
+     *
+     *    const valueInstance5 = new Value(undefined);
+     *    const result5 = valueInstance5.isSymbol();
+     *    // Результат: false
+     *
+     *    const valueInstance6 = new Value({});
+     *    const result6 = valueInstance6.isSymbol();
+     *    // Результат: false (объект)
+     *
+     *    const valueInstance7 = new Value([]);
+     *    const result7 = valueInstance7.isSymbol();
+     *    // Результат: false (массив)
+     *
+     *    const valueInstance8 = new Value(() => {});
+     *    const result8 = valueInstance8.isSymbol();
+     *    // Результат: false (функция)
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является символом, и `false` в противном случае.
+     */
+    isSymbol() {
+        return this.#getFromStore('isSymbol', () => is_symbol(this.#value));
+    }
+
+    /**
+     * Проверяет, является ли значение `undefined`.
+     *
+     * ### Описание
+     *
+     * Метод `isUndefined` используется для проверки, является ли значение, хранящееся в экземпляре класса `Value`, `undefined`.
+     * Метод использует оператор `typeof` для проверки типа значения.
+     *
+     * Метод использует функцию `is_undefined` для выполнения проверки.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает `true`, если значение является `undefined`, и `false` в противном случае.
+     *
+     * ### Примеры использования
+     *
+     * 1. Проверка значения `undefined`:
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.isUndefined();
+     *    // Результат: true
+     *    ```
+     *
+     * 2. Проверка значений других типов:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.isUndefined();
+     *    // Результат: false
+     *
+     *    const valueInstance2 = new Value(42);
+     *    const result2 = valueInstance2.isUndefined();
+     *    // Результат: false (число)
+     *
+     *    const valueInstance3 = new Value('hello');
+     *    const result3 = valueInstance3.isUndefined();
+     *    // Результат: false (строка)
+     *
+     *    const valueInstance4 = new Value(true);
+     *    const result4 = valueInstance4.isUndefined();
+     *    // Результат: false (логическое значение)
+     *
+     *    const valueInstance5 = new Value({});
+     *    const result5 = valueInstance5.isUndefined();
+     *    // Результат: false (объект)
+     *
+     *    const valueInstance6 = new Value([]);
+     *    const result6 = valueInstance6.isUndefined();
+     *    // Результат: false (массив)
+     *
+     *    const valueInstance7 = new Value(() => {});
+     *    const result7 = valueInstance7.isUndefined();
+     *    // Результат: false (функция)
+     *    ```
+     *
+     * @returns {boolean} Возвращает `true`, если значение является `undefined`, и `false` в противном случае.
+     */
+    isUndefined() {
+        return this.#getFromStore('isUndefined', () => is_undefined(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к массиву.
+     *
+     * ### Описание
+     *
+     * Метод `toArray` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в массив.
+     * Если значение уже является массивом (тип `Array` или ассоциативный массив), возвращается оно же.
+     * Объекты (экземпляры классов) преобразуются в массив с одним элементом.
+     *
+     * Метод использует функцию `to_array` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки в массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением ["example"]
+     *    ```
+     *
+     * 2. Преобразование числа в массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением [123]
+     *    ```
+     *
+     * 3. Преобразование массива (без изменений):
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением [1, 2, 3]
+     *    ```
+     *
+     * 4. Преобразование объекта в массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value({ key: 'value' });
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением { key: "value" }
+     *    ```
+     *
+     * 5. Преобразование экземпляра класса в массив:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const valueInstance = new Value(new MyClass());
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением [instance]
+     *    ```
+     *
+     * 6. Преобразование null:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением []
+     *    ```
+     *
+     * 7. Преобразование undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.toArray();
+     *    // Результат: новый экземпляр класса Value с значением []
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toArray() {
+        return new Value(to_array(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к ассоциативному массиву.
+     *
+     * ### Описание
+     *
+     * Метод `toAssoc` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в ассоциативный массив.
+     * Если значение уже является объектом, возвращается оно же. Массивы преобразуются в объекты с индексами в качестве ключей.
+     *
+     * Метод использует функцию `to_assoc` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки в ассоциативный массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением { 0: 'example' }
+     *    ```
+     *
+     * 2. Преобразование числа в ассоциативный массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением { 0: 123 }
+     *    ```
+     *
+     * 3. Преобразование массива в ассоциативный массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением { 0: 1, 1: 2, 2: 3 }
+     *    ```
+     *
+     * 4. Преобразование ассоциативного массива (без изменений):
+     *
+     *    ```js
+     *    const valueInstance = new Value({ key: 'value' });
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением { key: 'value' }
+     *    ```
+     *
+     * 5. Преобразование экземпляра класса в ассоциативный массив:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const valueInstance = new Value(new MyClass());
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением { 0: instance }
+     *    ```
+     *
+     * 6. Преобразование null:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением {}
+     *    ```
+     *
+     * 7. Преобразование undefined:
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.toAssoc();
+     *    // Результат: новый экземпляр класса Value с значением {}
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toAssoc() {
+        return new Value(to_assoc(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к логическому типу.
+     *
+     * ### Описание
+     *
+     * Метод `toBool` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в логическое значение.
+     * Если значение является пустым массивом, метод возвращает `false`.
+     *
+     * Метод использует функцию `to_bool` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование пустого массива в `false`:
+     *
+     *    ```js
+     *    const valueInstance = new Value([]);
+     *    const result = valueInstance.toBool();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * 2. Преобразование пустого ассоциативного массива в `false`:
+     *
+     *    ```js
+     *    const valueInstance = new Value({});
+     *    const result = valueInstance.toBool();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * 3. Преобразование непустого массива в `true`:
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.toBool();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *    ```
+     *
+     * 4. Преобразование других значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value('example');
+     *    const result1 = valueInstance1.toBool();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *
+     *    const valueInstance2 = new Value(123);
+     *    const result2 = valueInstance2.toBool();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *
+     *    const valueInstance3 = new Value(null);
+     *    const result3 = valueInstance3.toBool();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *
+     *    const valueInstance4 = new Value(undefined);
+     *    const result4 = valueInstance4.toBool();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toBool() {
+        return new Value(to_bool(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к логическому типу.
+     *
+     * ### Описание
+     *
+     * Метод `toBoolean` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в логическое значение.
+     * Если значение является пустым массивом, метод возвращает `false`.
+     *
+     * Метод использует функцию `to_bool` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование пустого массива в `false`:
+     *
+     *    ```js
+     *    const valueInstance = new Value([]);
+     *    const result = valueInstance.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * 2. Преобразование пустого ассоциативного массива в `false`:
+     *
+     *    ```js
+     *    const valueInstance = new Value({});
+     *    const result = valueInstance.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * 3. Преобразование непустого массива в `true`:
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *    ```
+     *
+     * 4. Преобразование других значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value('example');
+     *    const result1 = valueInstance1.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *
+     *    const valueInstance2 = new Value(123);
+     *    const result2 = valueInstance2.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением true
+     *
+     *    const valueInstance3 = new Value(null);
+     *    const result3 = valueInstance3.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *
+     *    const valueInstance4 = new Value(undefined);
+     *    const result4 = valueInstance4.toBoolean();
+     *    // Результат: новый экземпляр класса Value с значением false
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toBoolean() {
+        return new Value(to_bool(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к числу с плавающей точкой.
+     *
+     * ### Описание
+     *
+     * Метод `toFloat` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в число с плавающей точкой.
+     * Если значение не является числом или строкой, метод возвращает `1` для истинных значений и `0` для ложных значений.
+     *
+     * Метод использует функцию `to_float` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки в число с плавающей точкой:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123.45');
+     *    const result = valueInstance.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 123.45
+     *    ```
+     *
+     * 2. Преобразование целого числа в число с плавающей точкой:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 123.0
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(true);
+     *    const result1 = valueInstance1.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 1.0
+     *
+     *    const valueInstance2 = new Value(false);
+     *    const result2 = valueInstance2.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 0.0
+     *    ```
+     *
+     * 4. Преобразование других значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 0.0
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 0.0
+     *
+     *    const valueInstance3 = new Value('example');
+     *    const result3 = valueInstance3.toFloat();
+     *    // Результат: новый экземпляр класса Value с значением 0.0
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toFloat() {
+        return new Value(to_float(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к целому числу.
+     *
+     * ### Описание
+     *
+     * Метод `toInt` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в целое число.
+     * Если значение не является числом или строкой, метод возвращает `1` для истинных значений и `0` для ложных значений.
+     *
+     * Метод использует функцию `to_int` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки в целое число:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123');
+     *    const result = valueInstance.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 123
+     *    ```
+     *
+     * 2. Преобразование числа с плавающей точкой в целое число:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123.45);
+     *    const result = valueInstance.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 123
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(true);
+     *    const result1 = valueInstance1.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 1
+     *
+     *    const valueInstance2 = new Value(false);
+     *    const result2 = valueInstance2.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *    ```
+     *
+     * 4. Преобразование других значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *
+     *    const valueInstance3 = new Value('example');
+     *    const result3 = valueInstance3.toInt();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toInt() {
+        return new Value(to_int(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к целому числу.
+     *
+     * ### Описание
+     *
+     * Метод `toInteger` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в целое число.
+     * Если значение не является числом или строкой, метод возвращает `1` для истинных значений и `0` для ложных значений.
+     *
+     * Метод использует функцию `to_int` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки в целое число:
+     *
+     *    ```js
+     *    const valueInstance = new Value('123');
+     *    const result = valueInstance.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 123
+     *    ```
+     *
+     * 2. Преобразование числа с плавающей точкой в целое число:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123.45);
+     *    const result = valueInstance.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 123
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(true);
+     *    const result1 = valueInstance1.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 1
+     *
+     *    const valueInstance2 = new Value(false);
+     *    const result2 = valueInstance2.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *    ```
+     *
+     * 4. Преобразование других значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *
+     *    const valueInstance3 = new Value('example');
+     *    const result3 = valueInstance3.toInteger();
+     *    // Результат: новый экземпляр класса Value с значением 0
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toInteger() {
+        return new Value(to_int(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к списку.
+     *
+     * ### Описание
+     *
+     * Метод `toList` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в список.
+     * Если значение является `null` или `undefined`, возвращается пустой массив.
+     * Если значение уже является массивом, возвращается оно же.
+     * Если значение является ассоциативным массивом, возвращается массив значений объекта.
+     * Для других значений создается массив, содержащий это значение.
+     *
+     * Метод использует функцию `to_list` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование `null` в пустой массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value(null);
+     *    const result = valueInstance.toList();
+     *    // Результат: новый экземпляр класса Value с значением []
+     *    ```
+     *
+     * 2. Преобразование `undefined` в пустой массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value(undefined);
+     *    const result = valueInstance.toList();
+     *    // Результат: новый экземпляр класса Value с значением []
+     *    ```
+     *
+     * 3. Преобразование массива (без изменений):
+     *
+     *    ```js
+     *    const valueInstance = new Value([1, 2, 3]);
+     *    const result = valueInstance.toList();
+     *    // Результат: новый экземпляр класса Value с значением [1, 2, 3]
+     *    ```
+     *
+     * 4. Преобразование ассоциативного массива в массив значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value({ key: 'value' });
+     *    const result = valueInstance.toList();
+     *    // Результат: новый экземпляр класса Value с значением ['value']
+     *    ```
+     *
+     * 5. Преобразование строки в массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toList();
+     *    // Результат: новый экземпляр класса Value с значением ['example']
+     *    ```
+     *
+     * 6. Преобразование числа в массив:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toList();
+     *    // Результат: новый экземпляр класса Value с значением [123]
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toList() {
+        return new Value(to_list(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к объекту.
+     *
+     * ### Описание
+     *
+     * Метод `toObject` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в объект.
+     * Если значение уже является объектом, оно возвращается без изменений.
+     * Если значение является классом, возвращается новый экземпляр этого класса.
+     * Если значение является массивом, элементы массива копируются в новый объект.
+     * Для других значений создается объект с полем `value`, содержащим это значение.
+     *
+     * Метод использует функцию `to_object` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование объекта:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const obj = new MyClass();
+     *    const valueInstance = new Value(obj);
+     *    const result = valueInstance.toObject();
+     *    // Результат: новый экземпляр класса Value с значением obj
+     *    ```
+     *
+     * 2. Преобразование класса:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const valueInstance = new Value(MyClass);
+     *    const result = valueInstance.toObject();
+     *    // Результат: новый экземпляр класса Value с значением экземпляра MyClass
+     *    ```
+     *
+     * 3. Преобразование null и undefined:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.toObject();
+     *    // Результат: новый экземпляр класса Value с значением экземпляра анонимного класса
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.toObject();
+     *    // Результат: новый экземпляр класса Value с значением экземпляра анонимного класса
+     *    ```
+     *
+     * 4. Преобразование массива:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    const result = valueInstance.toObject();
+     *    // Результат: новый экземпляр класса Value с значением объекта с элементами массива
+     *    ```
+     *
+     * 5. Преобразование других значений:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toObject();
+     *    // Результат: новый экземпляр класса Value с значением объекта с полем value, содержащим 'example'
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toObject() {
+        return new Value(to_object(this.#value));
+    }
+
+    /**
+     * Преобразует значение в экземпляре класса `Value` к строке.
+     *
+     * ### Описание
+     *
+     * Метод `toString` используется для преобразования значения, хранящегося в экземпляре класса `Value`, в строку.
+     * Он обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое представление.
+     *
+     * Метод использует функцию `to_string` для выполнения преобразования.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     *
+     * ### Примеры использования
+     *
+     * 1. Преобразование строки:
+     *
+     *    ```js
+     *    const valueInstance = new Value('example');
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'example'
+     *    ```
+     *
+     * 2. Преобразование числа:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением '123'
+     *    ```
+     *
+     * 3. Преобразование булевых значений:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(true);
+     *    const result1 = valueInstance1.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'true'
+     *
+     *    const valueInstance2 = new Value(false);
+     *    const result2 = valueInstance2.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'false'
+     *    ```
+     *
+     * 4. Преобразование null и undefined:
+     *
+     *    ```js
+     *    const valueInstance1 = new Value(null);
+     *    const result1 = valueInstance1.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'null'
+     *
+     *    const valueInstance2 = new Value(undefined);
+     *    const result2 = valueInstance2.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'undefined'
+     *    ```
+     *
+     * 5. Преобразование массива:
+     *
+     *    ```js
+     *    const arr = [1, 2, 3];
+     *    const valueInstance = new Value(arr);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением '[\n    1,\n    2,\n    3,\n]'
+     *    ```
+     *
+     * 6. Преобразование объекта:
+     *
+     *    ```js
+     *    const obj = { key: 'value' };
+     *    const valueInstance = new Value(obj);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением '{\n    key: 'value',\n}'
+     *    ```
+     *
+     * 7. Преобразование функции:
+     *
+     *    ```js
+     *    const func = function() {};
+     *    const valueInstance = new Value(func);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'function func() {}'
+     *    ```
+     *
+     * 8. Преобразование символа:
+     *
+     *    ```js
+     *    const symbol = Symbol('example');
+     *    const valueInstance = new Value(symbol);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'Symbol(example)'
+     *    ```
+     *
+     * 9. Преобразование BigInt:
+     *
+     *    ```js
+     *    const bigInt = BigInt(123);
+     *    const valueInstance = new Value(bigInt);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением '123'
+     *    ```
+     *
+     * 10. Преобразование класса:
+     *
+     *    ```js
+     *    class MyClass {
+     *        static test = 'test';
+     *    }
+     *    const valueInstance = new Value(MyClass);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'class MyClass {}'
+     *    ```
+     *
+     * 11. Преобразование экземпляра класса:
+     *
+     *    ```js
+     *    class MyClass {}
+     *    const instance = new MyClass();
+     *    const valueInstance = new Value(instance);
+     *    const result = valueInstance.toString();
+     *    // Результат: новый экземпляр класса Value с значением 'object MyClass'
+     *    ```
+     *
+     * @returns {Value} Возвращает новый экземпляр класса `Value` с преобразованным значением.
+     */
+    toString() {
+        return new Value(to_string(this.#value));
+    }
+
+    /**
+     * Получает значение из хранилища или вычисляет его с помощью переданной функции.
+     *
+     * ### Описание
+     *
+     * Приватный метод `#getFromStore` используется для получения значения из внутреннего хранилища `#store`.
+     * Если значение уже существует в хранилище, оно возвращается. В противном случае значение вычисляется с помощью переданной функции `getter`, сохраняется в хранилище и затем возвращается.
+     *
+     * Этот метод позволяет избежать повторных вычислений одного и того же значения, что может быть полезно для оптимизации производительности.
+     *
+     * ### Параметры
+     *
+     * - `name` (string)
+     *      Имя ключа, под которым значение хранится в хранилище.
+     * - `getter` (function)
+     *      Функция, которая используется для вычисления значения, если оно отсутствует в хранилище.
+     *
+     * ### Возвращаемое значение
+     *
+     * Возвращает значение, хранящееся под указанным ключом в хранилище, или вычисленное значение, если его не было в хранилище.
+     *
+     * ### Примеры использования
+     *
+     * 1. Получение значения из хранилища:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.#getFromStore('type', () => 'integer');
+     *    // Результат: 'integer'
+     *    ```
+     *
+     * 2. Использование функции для вычисления значения:
+     *
+     *    ```js
+     *    const valueInstance = new Value(123);
+     *    const result = valueInstance.#getFromStore('type', () => gettype(123));
+     *    // Результат: 'integer'
+     *    ```
+     *
+     * @param {string} name Имя ключа, под которым значение хранится в хранилище.
+     * @param {function} getter Функция, которая используется для вычисления значения, если оно отсутствует в хранилище.
+     * @returns {any} Возвращает значение, хранящееся под указанным ключом в хранилище, или вычисленное значение, если его не было в хранилище.
+     */
+    #getFromStore(name, getter) {
+        if (!(name in this.#store)) {
+            this.#store[name] = getter();
+        }
+
+        return this.#store[name];
+    }
+}
+
+export default Value;