semantic-typescript 0.6.0 → 0.7.0

package/readme.ru.md

@@ -1,205 +1,224 @@
-# Semantic-TypeScript: Библиотека потоковой обработки, меняющая парадигму
+Перевод на русский, с учётом языковых норм, контекста и стилистических особенностей. Собственные имена не переведены:
 
-## Введение
-Semantic-TypeScript представляет собой значительный прогресс в технологии потоковой обработки, синтезируя наиболее эффективные концепции из JavaScript GeneratorFunctions, Java Streams и парадигм индексации баз данных. Его фундаментальный принцип проектирования сосредоточен на построении исключительно эффективных конвейеров обработки данных с помощью сложных вычислений с отложенным выполнением (lazy evaluation) и интеллектуальной индексации. Библиотека предоставляет строго типобезопасный, функционально чистый опыт работы с потоками, специально созданный для современной разработки на TypeScript и JavaScript.
+# Semantic-TypeScript
+Потоки данных, проиндексированные. Ваши данные под точным контролем.
 
-В отличие от традиционных синхронных архитектур обработки, Semantic-TypeScript реализует унифицированную модель, которая изящно обрабатывает как синхронные (Iterable), так и асинхронные (AsyncIterable) источники данных. Во время генерации потока поток и завершение данных точно контролируются механизмами обратных вызовов (callback), что позволяет библиотеке исключительно элегантно обрабатывать:
-*   Потоки данных в реальном времени (события DOM, WebSockets, интервалы) с детерминированным управлением
-*   Большие наборы данных с помощью эффективных по памяти, "ленивых" (lazy) конвейеров
-*   Сложные преобразования данных с помощью беглого, декларативного API
+---
 
-Инновационный подход библиотеки фундаментально переосмысливает то, как разработчики взаимодействуют с последовательностями данных, предоставляя как беспрецедентные характеристики производительности, так и эргономику для разработчиков в едином, целостном пакете.
+### Обзор
 
-## Основная философия: разделение определения и выполнения
-Ключевая архитектурная идея Semantic-TypeScript — это четкое разделение между определением потока и его выполнением:
-*   **Semantic<E>**: неизменяемый, "ленивый" (lazy) план конвейера преобразования данных. Он определяет, какие операции (filter, map и т.д.) будут выполнены.
-*   **Collectable<E>**: материализованное, исполняемое представление потока. Получается из Semantic и предоставляет все терминальные операции (collect, forEach и т.д.) для выполнения конвейера и получения результата.
+Semantic-TypeScript знаменует собой значительный скачок в развитии технологий обработки потоков данных, синтезируя наиболее эффективные концепции из JavaScript `GeneratorFunction`, Java Streams и индексирования в стиле MySQL. Его основная философия одновременно проста и мощна: создавайте исключительно эффективные конвейеры обработки данных с помощью интеллектуального индексирования, а не грубого перебора.
 
-Это разделение обеспечивает четкую ментальную модель и открывает возможность мощных оптимизаций, таких как выбор UnorderedCollectable для пропуска ненужной сортировки для максимальной скорости.
+Там, где обычные библиотеки навязывают синхронные циклы или громоздкие цепочки промисов, Semantic-TypeScript предлагает полностью асинхронный, функционально чистый и строго типобезопасный опыт, созданный для требований современной фронтенд-разработки.
 
-## Почему стоит выбрать Semantic-TypeScript?
-Выбор подходящей библиотеки для обработки потоков данных предполагает баланс между производительностью, типобезопасностью и выразительностью. Semantic-TypeScript создан для превосходства по всем этим параметрам.
+В этой элегантной модели данные достигают потребителя только тогда, когда вышестоящий конвейер явно вызывает коллбэки `accept` (и, опционально, `interrupt`). Вы полностью контролируете время — именно тогда, когда это необходимо.
 
-### 1. Унифицированная, типобезопасная парадигма для всех последовательностей данных
-Он предоставляет единый, декларативный API для обработки любой последовательности данных — будь то статические массивы, события в реальном времени или асинхронные фрагменты (chunks) — при этом используя всю мощь TypeScript для обеспечения сквозной типобезопасности. Это устраняет целый класс ошибок времени выполнения и превращает манипуляции с потоками в предсказуемую, проверяемую компилятором деятельность.
+---
 
-### 2. Непреклонная производительность с интеллектуальной "ленивостью" (Laziness)
-В своей основе библиотека построена на отложенном выполнении (lazy evaluation). Операции, такие как filter, map и flatMap, лишь составляют конвейер обработки; никакая работа не выполняется до тех пор, пока не будет вызвана терминальная операция. Это сочетается с возможностями короткого замыкания (short-circuiting) (через limit, anyMatch или пользовательские прерывающие обратные вызовы), что позволяет остановить обработку досрочно, значительно повышая эффективность для больших или бесконечных потоков.
+### Почему разработчики выбирают его
 
-### 3. Сила паттерна `Collector<E, A, R>`
-Вдохновленный Java, паттерн Collector — это двигатель гибкости. Он отделяет спецификацию того, как накапливать элементы потока, от самого выполнения потока. Библиотека предоставляет богатый набор встроенных коллекторов (collectors) (toArray, groupBy, summate и т.д.) для повседневных задач, позволяя при этом с легкостью реализовывать собственную сложную, повторно используемую логику свёртки (reduction). Это намного мощнее и композируемее, чем фиксированный набор терминальных методов.
+• Индексирование без шаблонного кода — каждый элемент несет свой естественный или специально созданный индекс.
 
-### 4. Поддержка современного веба и асинхронных данных "из коробки"
-Semantic-TypeScript создан для современной разработки. Он предлагает нативные фабричные методы для современных веб-источников:
-*   `useFrom(iterable)`, `useRange()` для статических данных
-*   `useInterval()`, `useAnimationFrame()` для потоков, основанных на времени
-*   `useBlob()` для обработки бинарных данных фрагментами (chunked)
-*   `useWebSocket()`, `useDocument()`, `useWindow()` для потоков событий в реальном времени
+• Чистый функциональный стиль — с полным выведением типов TypeScript.
 
-### 5. За пределами базовой агрегации: встроенный статистический анализ
-Выходите за рамки простых сумм и средних значений. Библиотека предоставляет специальные интерфейсы NumericStatistics и BigIntStatistics, предлагая немедленный доступ к расширенным статистическим показателям напрямую из ваших потоков — дисперсия, стандартное отклонение, медиана, асимметрия (skewness) и эксцесс (kurtosis). Это превращает сложный анализ данных в однострочник.
+• Потоки событий без утечек — `useWindow`, `useDocument`, `useHTMLElement` и `useWebSocket` созданы с учетом безопасности. Вы задаете границу — с помощью `limit(n)`, `sub(start, end)` или `takeWhile(predicate)` — а библиотека управляет очисткой. Никаких зависших слушателей, никаких утечек памяти.
 
-### 6. Спроектирован с учетом эргономики разработчика
-*   **Беглый, цепочечный (chainable) API**: Пишите сложные конвейеры данных в виде читаемых, последовательных цепочек.
-*   **Комплексный набор утилит**: Включены основные защиты (isFunction, isIterable), утилиты (useCompare, useTraverse) и функциональные интерфейсы.
-*   **Интеграция с Optional&lt;T&gt;**: Безопасно моделирует отсутствие значения, устраняя проблемы с нулевыми указателями (null-pointer).
-*   **Рекомендации по производительности**: Четкие указания, когда использовать неупорядоченную (unordered) коллекцию для скорости, а когда упорядоченную (ordered) для последовательности.
+• Встроенная статистика — всесторонний анализ для чисел и bigint, включая средние значения, медианы, моду, дисперсию, асимметрию и эксцесс.
 
-## Установка
-```bash
-npm install semantic-typescript
-```
+• Предсказуемая производительность — выбирайте между упорядоченными и неупорядоченными коллекторами в зависимости от ваших требований.
 
-## Основные концепции на практике
+• Эффективное использование памяти — потоки вычисляются лениво, что снимает проблемы с памятью.
 
-### 1. Создание потоков (Semantic)
-Потоки можно создавать из различных источников с помощью фабричных функций.
-```typescript
-import { useFrom, useInterval, useDocument } from 'semantic-typescript';
+• Без неопределенного поведения — TypeScript гарантирует типобезопасность и обработку null. Входные данные остаются неизменными, если явно не модифицированы в ваших функциях обратного вызова.
 
-// Из статического массива
-const staticStream = useFrom([1, 2, 3, 4, 5]);
+---
 
-// Из асинхронного генератора
-const asyncStream = useFrom(async function*() {
-  yield 1;
-  yield 2;
-});
-
-// Поток на основе времени
-const tickStream = useInterval(1000); // испускает значение каждую секунду
+### Установка
 
-// Поток событий DOM (см. важное примечание ниже)
-const clickStream = useDocument('click');
+```bash
+npm install semantic-typescript
 ```
-
-### 2. Преобразование потоков (Промежуточные операции)
-Операции лениво объединяются в цепочку для определения конвейера.
-```typescript
-const processedStream = staticStream
-  .filter(x => x % 2 === 0) // Оставляем только четные числа
-  .map(x => x * 10)         // Умножаем на 10
-  .flatMap(x => [x, x + 1]) // Преобразуем каждый элемент в два
-  .distinct();              // Удаляем дубликаты
-// Пока ничего не было выполнено
+или
+```bash
+yarn add semantic-typescript
 ```
 
-### 3. Выполнение потоков (Терминальные операции)
-Чтобы получить результат, вы должны получить Collectable и вызвать терминальную операцию.
-```typescript
-// Получаем неупорядоченный collectable для производительности
-const resultArray = await processedStream.toUnordered().toArray();
-console.log(resultArray); // например, [20, 21, 40, 41]
-
-// Используем встроенный коллектор
-const sum = await processedStream.toUnordered().collect(useSummate());
-console.log(sum);
-
-// Или используем общий метод collect
-const customResult = await processedStream.toOrdered().collect(
-  () => new Map<number, number>(),
-  (map, element, index) => map.set(index, element),
-  map => map
-);
-```
+---
 
-### 4. Важно: Работа с потоками событий
-Потоки событий (useDocument, useWindow, useHTMLElement, useWebSocket) по своей природе бесконечны. Вы должны использовать операции, такие как sub, takeWhile или limit, чтобы определить, когда прекратить сбор событий и завершить поток. В противном случае терминальная операция будет ждать неопределенно долго.
-```typescript
-import { useDocument } from 'semantic-typescript';
+### Быстрый старт
 
-// Собираем только первые 5 кликов
-const first5Clicks = await useDocument('click')
-  .limit(5) // <- Важно: ограничивает поток 5 событиями
+```typescript
+import { useOf, useFrom, useRange, useWindow, useHTMLElement, useWebSocket, useText, useStringify } from "semantic-typescript";
+
+// Числовая статистика
+let summate: number = useOf(10, 20, 30, 40)
+  .map((n: number): number => n * 2)
+  .toNumericStatistics()  // Требуется перед терминальной операцией
+  .summate();             // 200
+
+// Статистика для BigInt
+let summate: bigint = useOf(10n, 20n, 30n, 40n)
+  .map((n: bigint): bigint => n * 2)
+  .toBigIntStatistics()   // Требуется перед терминальной операцией
+  .summate();             // 200n
+
+// Перевернуть поток по индексу
+useFrom([1, 2, 3, 4, 5])
+  .redirect((element: E, index: bigint): bigint => -index) // Отрицательный индекс для разворота
+  .toOrdered() // Вызов toOrdered() для сохранения порядка индексов
+  .toArray(); // [5, 4, 3, 2, 1]
+
+// Перемешать поток
+useFrom([1, 2, 3, 4, 5])
+  .shuffle()
+  .toOrdered()
+  .toArray(); // напр., [2, 5, 1, 4, 3]
+
+// Сдвинуть элементы внутри потока
+useFrom([1, 2, 3, 4, 5])
+  .translate(2)  // Сдвиг элементов вправо на 2 позиции
+  .toOrdered()
+  .toArray(); // [4, 5, 1, 2, 3]
+
+useFrom([1, 2, 3, 4, 5])
+  .translate(-2) // Сдвиг элементов влево на 2 позиции
+  .toOrdered()
+  .toArray(); // [3, 4, 5, 1, 2]
+
+// Бесконечный диапазон с ранним завершением
+useRange(0n, 1_000_000n)
+  .filter(n => n % 17n === 0n)
+  .limit(10n)          // Остановиться после 10 элементов
   .toUnordered()
   .toArray();
 
-// Собираем клики в течение 10-секундного окна
-const clicksIn10s = await useDocument('click')
-  .takeWhile((_, index, startTime = Date.now()) => Date.now() - startTime < 10000)
+// Изменение размера окна в реальном времени (автоматически останавливается после 5 событий)
+useWindow("resize")
+  .limit(5n)          // Ключевой момент для потоков событий
   .toUnordered()
-  .toArray();
+  .forEach((ev, idx) => console.log(`Изменение размера #${idx}`));
 
-// Собираем клики с индекса 2 по 5 (0-based)
-const specificClicks = await useDocument('click')
-  .sub(2n, 6n) // <- Берет элементы с индексами 2, 3, 4, 5
+// Прослушивание HTML-элемента
+// <input id="input" type="text"/>
+useHTMLElement("#input", "change")
+  .limit(1)
   .toUnordered()
-  .toArray();
-```
-**Ключевое понимание**: Событие (например, MouseEvent) и его порядковый индекс срабатывания (в виде bigint) передаются вместе через конвейер с помощью обратного вызова `accept(event, index)`.
-
-### 5. Использование статистики
-```typescript
-const numericStream = useFrom([10, 20, 30, 40, 50]).toNumeric();
+  .forEach((event: Event) => submit(event));
 
-const average = await numericStream.average();
-const median = await numericStream.median();
-const standardDeviation = await numericStream.standardDeviation();
-const skewness = await numericStream.skewness();
+// Прослушивание нескольких элементов и событий
+useHTMLElement("input", ["change", "keyup"])
+  .takeWhile((event: Event): boolean => validate(event))
+  .toUnordered()
+  .forEach((event: Event) => submit(event));
 
-console.log(`Среднее: ${average}, Медиана: ${median}, Стандартное отклонение: ${standardDeviation}`);
-```
+// Прослушивание WebSocket
+let webSocket = new WebSocket("ws://localhost:8080");
+webSocket.addEventListener("close", (): void => {
+  webSocket.close();  // Управляйте жизненным циклом WebSocket вручную
+});
+useWebSocket(webSocket, "message")
+  .limit(1)
+  .toUnordered()
+  .forEach((message: MessageEvent) => console.log(message.data));
 
-## Основные возможности
-*   **Двойные типы потоков**: Полная поддержка как SynchronousSemantic (для Iterable), так и AsynchronousSemantic (для AsyncIterable и событий)
-*   **Богатый набор операций**: filter, map, flatMap, concat, distinct, sorted, limit, skip, peek, reverse, shuffle
-*   **Гибкие терминальные операции**: collect (с пользовательскими коллекторами), toArray, toSet, toMap, forEach, reduce, findFirst, anyMatch, allMatch, count
-*   **Продвинутые коллекторы**: Встроенные коллекторы для joining, groupingBy, partitioningBy, summing, averaging, maxBy, minBy
-*   **Статистический модуль**: Готовые к использованию методы для mean, median, mode, variance, standardDeviation, range, quantiles, skewness, kurtosis для числовых/bigint потоков
-*   **Вспомогательные функции**: Защитники типов (type guards) (isPromise, isAsyncIterable), компараторы (useCompare), обход (useTraverse) и хуки преобразования
-*   **Optional&lt;T&gt;**: Монадический контейнер для нулабельных значений, интегрированный с операциями поиска (find)
-
-## Обзор API
-### Основные классы и интерфейсы
-*   `Semantic<E>` / `AsynchronousSemantic<E>`: Абстрактное определение потока
-*   `Collectable<E>` / `AsynchronousCollectable<E>`: Исполняемый поток с терминальными операциями
-*   `OrderedCollectable<E>` / `UnorderedCollectable<E>`: Материализованные версии, оптимизированные для операций, чувствительных или нечувствительных к порядку
-*   `Collector<E, A, R>`: Абстракция для изменяемых (mutable) операций свёртки (reduction)
-
-### Фабричные функции (use*)
-*   **Из источников**: useFrom, useRange, useFill, useEmpty
-*   **Из времени**: useInterval, useAnimationFrame
-*   **Из веб-API**: useBlob, useDocument, useWindow, useHTMLElement, useWebSocket
-*   **Коллекторы**: useToArray, useGroupBy, useSummate, useJoin и т.д.
-
-## Примечания по производительности
-*   **Отложенное выполнение (Lazy Evaluation)**: Конвейеры составляются без выполнения до тех пор, пока не будет вызвана терминальная операция.
-*   **Короткое замыкание (Short-Circuiting)**: Операции, такие как limit, anyMatch и findFirst, остановят обработку элементов, как только результат будет определен.
-*   **Упорядоченное (Ordered) vs Неупорядоченное (Unordered)**:
-    *   Используйте `.toUnordered()` для терминальных операций, когда порядок исходных элементов не имеет значения для вашего результата (например, для sum, max или toSet). Это может позволить внутренние оптимизации, пропускающие затратные шаги сортировки.
-    *   Используйте `.toOrdered()`, когда важна последовательность (например, для toArray, где порядок должен быть сохранен).
-
-## Пример для начала работы
-```typescript
-import { useFrom, useSummate, useGroupBy } from 'semantic-typescript';
-
-interface Transaction {
-  id: number;
-  amount: number;
-  category: string;
-}
-
-const transactions: Transaction[] = [
-  { id: 1, amount: 100, category: 'Food' },
-  { id: 2, amount: 200, category: 'Electronics' },
-  { id: 3, amount: 50, category: 'Food' },
-  { id: 4, amount: 300, category: 'Electronics' },
-];
-
-// Вычисляем общую сумму по категориям
-const totalsByCategory = await useFrom(transactions)
+// Итерация по строке по кодовым точкам
+useText("Моё текущее настроение: 😊, а semantic — это 👍")
   .toUnordered()
-  .collect(
-    useGroupBy(
-      t => t.category,
-      t => t.amount,
-      useSummate() // Коллектор для значений
-    )
-  );
-
-console.log(totalsByCategory); // Map { 'Food' => 150, 'Electronics' => 500 }
+  .log(); // Выводит строку
+
+// Безопасная сериализация объекта с циклическими ссылками
+let o = {
+  a: 1,
+  b: "текст",
+  c: [o.a, o.b, o.c] // Циклическая ссылка
+};
+// let text: string = JSON.stringify(o); // Выбросит ошибку
+let text: string = useStringify(o); // Безопасно возвращает `{a: 1, b: "текст", c: []}`
 ```
 
-Semantic-TypeScript создан для разработчиков, которые ищут тщательно спроектированную, типобезопасную и высокопроизводительную библиотеку для потоковой обработки данных. Он привносит мощь шаблонов преобразования данных уровня предприятия в экосистему TypeScript, идеально подходящую для насыщенных данными фронтенд-приложений, обработки данных в Node.js и любого сценария, где требуется элегантная и эффективная обработка последовательностей.
+---
+
+### Основные концепции
+
+| Концепция | Назначение | Когда использовать |
+| :--- | :--- | :--- |
+| `AsynchronousSemantic` | Основной конструктор для асинхронных потоков, событий и ленивых конвейеров. | События в реальном времени, WebSockets, слушатели DOM, долгоиграющие или бесконечные потоки. |
+| `SynchronousSemantic` | Конструктор для синхронных потоков в памяти или на основе циклов. | Статические данные, диапазоны, немедленная итерация. |
+| `toUnordered()` | Самый быстрый терминальный коллектор (индексирование на основе Map). | Критичные к производительности задачи (время и память O(n), без сортировки). |
+| `toOrdered()` | Отсортированный коллектор со стабильной индексацией. | Когда требуется стабильный порядок или доступ по индексу. |
+| `toNumericStatistics()` | Богатый числовой статистический анализ (среднее, медиана, дисперсия, асимметрия, эксцесс и т.д.). | Анализ данных и статистические вычисления. |
+| `toBigIntStatistics()` | Богатый статистический анализ для bigint. | Анализ данных и статистические вычисления для больших целых чисел. |
+| `toWindow()` | Поддержка скользящих и тайм-серийных окон. | Обработка временных рядов, пакетная обработка, оконные операции. |
+
+---
+
+Важные правила использования
+
+1.  Потоки событий (`useWindow`, `useDocument`, `useHTMLElement`, `useWebSocket`, …) возвращают `AsynchronousSemantic`.
+    → Вы **должны** вызвать `.limit(n)`, `.sub(start, end)` или `.takeWhile()`, чтобы прекратить прослушивание. В противном случае слушатель останется активным.
+
+2.  Терминальные операции (`.toArray()`, `.count()`, `.average()`, `.reduce()`, `.findFirst()` и т.д.) доступны только после преобразования в коллектор:
+    ```typescript
+    .toUnordered()   // Время и память O(n), без сортировки
+    // или
+    .toOrdered()     // Отсортирован, сохраняет порядок
+    ```
+
+---
+
+### Характеристики производительности
+
+| Коллектор | Временная сложность | Пространственная сложность | Отсортирован? | Лучше всего для |
+| :--- | :--- | :--- | :--- | :--- |
+| `toUnordered()` | O(n) | O(n) | Нет | Максимальная скорость, порядок не важен. |
+| `toOrdered()` | O(2n) | O(n) | Да | Стабильный порядок, доступ по индексу, аналитика. |
+| `toNumericStatistics()` | O(2n) | O(n) | Да | Статистические операции, требующие сортировки данных. |
+| `toBigIntStatistics()` | O(2n) | O(n) | Да | Статистические операции для bigint. |
+| `toWindow()` | O(2n) | O(n) | Да | Временные оконные операции. |
+
+Выбирайте `toUnordered()`, когда важна максимальная скорость. Используйте `toOrdered()` только тогда, когда вам требуется стабильный порядок или статистические методы, зависящие от отсортированных данных.
+
+---
+
+Сравнение с другими процессорами потоков для фронтенда
+
+| Особенность | Semantic-TypeScript | RxJS | Нативные асинхронные итераторы / Генераторы | Most.js |
+| :--- | :--- | :--- | :--- | :--- |
+| Интеграция с TypeScript | Первоклассная, с глубокой типизацией и нативной осведомлённостью об индексе. | Отличная, но связана со сложными дженериками. | Хорошая, требует ручного описания типов. | Сильная, в функциональном стиле. |
+| Встроенный статистический анализ | Полная нативная поддержка для `number` и `bigint`. | Отсутствует нативно (требует пользовательских операторов). | Отсутствует. | Отсутствует. |
+| Индексирование и осведомленность о позиции | Нативное, мощное индексирование bigint для каждого элемента. | Требует пользовательских операторов (`scan`, `withLatestFrom`). | Требуется ручной счётчик. | Базовая, без встроенного индекса. |
+| Управление потоками событий | Специализированные, типобезопасные фабрики с явным контролем ранней остановки. | Мощное, но требует ручного управления подписками. | Ручной слушатель событий + отмена. | Хороший `fromEvent`, лёгкий. |
+| Производительность и эффективность памяти | Исключительные – оптимизированные коллекторы `toUnordered()` и `toOrdered()`. | Очень хорошая, но цепочки операторов добавляют накладные расходы. | Отличная (нулевые накладные расходы). | Отличная. |
+| Размер бандла | Очень лёгкий. | Большой (даже с tree-shaking). | Нулевой (нативный). | Маленький. |
+| Философия дизайна API | Функциональный паттерн коллектора с явным индексированием. | Реактивный паттерн Observable. | Паттерн Итератор / Генератор. | Функциональный, бесточечный. |
+| Раннее завершение и контроль | Явный (`interrupt`, `.limit()`, `.takeWhile()`, `.sub()`). | Хороший (`take`, `takeUntil`, `first`). | Ручной (`break` в `for await…of`). | Хороший (`take`, `until`). |
+| Поддержка синхронных и асинхронных операций | Унифицированный API – первоклассная поддержка обоих. | В основном асинхронный. | Оба, но ручной. | В основном асинхронный. |
+| Кривая обучения | Плавная для разработчиков, знакомых с функциональным программированием и индексированными конвейерами. | Круче (много операторов, горячие/холодные observable). | Низкая. | Умеренная. |
+
+Ключевые преимущества Semantic-TypeScript
+
+•   Уникальные встроенные возможности статистики и индексирования, исключающие необходимость ручного `reduce` или внешних библиотек.
+
+•   Явный контроль над потоками событий предотвращает утечки памяти, характерные для RxJS.
+
+•   Унифицированный синхронный/асинхронный дизайн предоставляет единый, последовательный API для различных случаев использования.
+
+Это сравнение показывает, почему Semantic-TypeScript особенно хорошо подходит для современных TypeScript фронтенд-приложений, которые требуют производительности, типобезопасности и богатой аналитики без церемоний традиционных реактивных библиотек.
+
+---
+
+### Готовы исследовать?
+
+Semantic-TypeScript превращает сложные потоки данных в читаемые, компонуемые и высокопроизводительные конвейеры. Обрабатываете ли вы события пользовательского интерфейса в реальном времени, обрабатываете большие наборы данных или создаёте аналитические панели — он предоставляет мощь индексирования уровня баз данных с элегантностью функционального программирования.
+
+Следующие шаги:
+
+•   Изучите полностью типизированный API в своей IDE (все экспорты из основного пакета).
+
+•   Присоединяйтесь к растущему сообществу разработчиков, которые заменили запутанные асинхронные итераторы чистыми Semantic-конвейерами.
+
+Semantic-TypeScript — где потоки встречаются со структурой.
+
+Начните строить сегодня и ощутите разницу, которую приносит продуманное индексирование.
 
-[![GitHub](./GitHub.png)](https://github.com/eloyhere/semantic-typescript)  [![NPM](./NPM.png)](https://www.npmjs.com/package/semantic-typescript) 
+Стройте с ясностью, действуйте с уверенностью и преобразуйте данные осмысленно.