fix: rangeIterable

README.md

@@ -107,9 +107,25 @@ for await (const value of asyncIter) {
 ## Important Notes on Numbers
 - **The `digits: true` option**: Allows iterating over individual digits of a number, supporting both regular numbers and `BigInt`.
 - Numbers (`number`) are always processed as **_synchronous_** iterators, regardless of whether the `{ async: true }` option is passed.
+- **For negative numbers**: The negative sign is discarded, and the number is treated as positive. For example, -123 will be processed as [1, 2, 3].
+- **Floating-point numbers are not supported**: If a floating-point number is passed, a RangeError will be thrown because the number must be an integer to create a valid iterator.
 
+```javascript
+const negativeDigitsIter = new Iter8or(-98765, { digits: true });
+console.log([...negativeDigitsIter]); // [9, 8, 7, 6, 5]
+```
 ### Iteration Over Ranges (RangeIterable):
-Range iterators (`range`) are limited to numbers **_from -(2 ** 32 - 1) to 2 ** 32 - 1_**. This limitation is in place to prevent excessive memory and resource usage. If you try to create a range beyond these values, the library will throw a _RangeError_.
+Range iterators (`range`) are limited to numbers **_from -(2 ** 53 - 1) to 2 ** 53 - 1_**. This limitation is in place to prevent excessive memory and resource usage. If you try to create a range beyond these values, the library will throw a _RangeError_.
+- **Note**: When working with very large ranges, using the spread operator (e.g., ...rangeIter) can lead to memory and performance issues. Instead, it is recommended to manually process large ranges in a loop to avoid memory overflow:
+
+```javascript
+const largeRangeIter = new Iter8or(1000000000); // Very large range
+
+for (let num of largeRangeIter) {
+  // Process each number
+  if (num > 100) break; // Example: Stop after processing the first 100 numbers
+}
+```
 
 ### Example with RangeIterable:
 ```javascript

README.ru.md

@@ -106,9 +106,21 @@ for await (const value of asyncIter) {
 ## Важные замечания о числах
 - **Опция `digits: true`:** Позволяет итерировать по отдельным цифрам числа, поддерживая как обычные числа, так и `BigInt`.
 - Цифры (`number`) всегда обрабатываются как **_синхронные_** итераторы, независимо от того, передана опция `{ async: true }` или нет.
+- **Отрицательные числа при digits: true**: Знак отбрасывается, и число обрабатывается как положительное.
+- Числа с плавающей точкой не поддерживаются при `digits: true`: Такие числа приводят к выбросу исключения RangeError.
 
 ### Итерация по диапазонам (RangeIterable):
-Итераторы диапазонов (`range`) ограничены числом **от -(2 ** 32 - 1) до 2 ** 32 - 1**. Это ограничение введено для предотвращения чрезмерного использования памяти и ресурсов. Если пытаться создать диапазон за пределами этих значений, библиотека выбросит _RangeError_.
+Итераторы диапазонов (_range_) ограничены числами от **-(2^53 - 1)** до **2^53 - 1** (что соответствует значению _Number.MAX_SAFE_INTEGER_). Это ограничение гарантирует, что диапазон может быть обработан без ошибок потери точности. Если вы попытаетесь создать диапазон за пределами этих значений, библиотека выбросит исключение RangeError.
+
+- **Внимание**: При работе с очень большими диапазонами использование оператора spread (например, ...rangeIter) может привести к проблемам с памятью и производительностью. Вместо этого рекомендуется вручную обрабатывать большие диапазоны в цикле, чтобы избежать переполнения памяти:
+```javascript
+const largeRangeIter = new Iter8or(1000000000); // Очень большой диапазон
+
+for (let num of largeRangeIter) {
+  // Обрабатываем каждое число
+  if (num > 100) break; // Пример: Останавливаемся после обработки первых 100 чисел
+}
+```
 
 ### Пример с диапазоном RangeIterable:
 ```javascript

src/core/RangeIterable.js

@@ -1,13 +1,15 @@
 export class RangeIterable {
   constructor(number) {
-    const MAX_LIMIT = 2 ** 32 - 1;
+    const MAX_LIMIT = Number.MAX_SAFE_INTEGER;
+    const MIN_LIMIT = Number.MIN_SAFE_INTEGER;
+
     if (
       typeof number !== 'number' ||
       number > MAX_LIMIT ||
-      number < -MAX_LIMIT
+      number < MIN_LIMIT
     ) {
       throw new RangeError(
-        'Number exceeds MAX_LIMIT. You can create a range up to ±(2 ** 32 - 1).'
+        `Number exceeds MAX_LIMIT. You can create a range up to +${MAX_LIMIT} and down to ${MIN_LIMIT}.`
       );
     }
     this.number = number;

src/core/__tests__/RangeIterable.spec.js

@@ -14,11 +14,11 @@ describe('RangeIterable', () => {
   });
 
   it('should throw an error if number exceeds the positive limit', () => {
-    expect(() => new RangeIterable(2 ** 32)).toThrow(RangeError);
+    expect(() => new RangeIterable(Number.MAX_SAFE_INTEGER + 1)).toThrow(RangeError);
   });
 
   it('should throw an error if number exceeds the negative limit', () => {
-    expect(() => new RangeIterable(-(2 ** 32)).toThrow(RangeError));
+    expect(() => new RangeIterable(Number.MIN_SAFE_INTEGER - 1)).toThrow(RangeError);
   });
 
   it('should correctly handle the maximum positive range', () => {