semantic-typescript 0.6.0 → 0.7.0

package/readme.es.md

@@ -1,208 +1,213 @@
-# Semantic-TypeScript: Una biblioteca de procesamiento de flujo que cambia paradigmas
+# **Semantic-TypeScript**
+**Flujos, Indexados.** Sus datos, bajo control preciso.
 
-## Introducción
-Semantic-TypeScript representa un avance significativo en la tecnología de procesamiento de flujos, sintetizando los conceptos más efectivos de JavaScript GeneratorFunctions, Java Streams y los paradigmas de indexación de bases de datos. Su principio de diseño fundamental se centra en la construcción de pipelines de procesamiento de datos excepcionalmente eficientes mediante evaluación diferida (lazy) sofisticada e indexación inteligente. La biblioteca ofrece una experiencia de operación de flujos rigurosamente segura en tipos y funcionalmente pura, específicamente diseñada para el desarrollo moderno en TypeScript y JavaScript.
+---
 
-En contraste con las arquitecturas de procesamiento sincrónico convencionales, Semantic-TypeScript implementa un modelo unificado que maneja con gracia tanto fuentes de datos sincrónicas (Iterable) como asincrónicas (AsyncIterable). Durante la generación del flujo, el flujo y la terminación de los datos se controlan con precisión mediante mecanismos de callback, lo que permite a la biblioteca manejar con excepcional gracia:
-- Flujos de datos en tiempo real (eventos DOM, WebSockets, intervalos) con control determinista
-- Conjuntos de datos a gran escala mediante pipelines diferidos y eficientes en memoria
-- Transformaciones de datos complejas con una API fluida y declarativa
+### Descripción general
 
-El enfoque innovador de la biblioteca reinterpreta fundamentalmente cómo los desarrolladores interactúan con secuencias de datos, ofreciendo tanto características de rendimiento sin precedentes como ergonomía para el desarrollador en un paquete único y cohesivo.
+Semantic-TypeScript marca un avance significativo en la tecnología de procesamiento de flujos, **sintetizando** los conceptos más efectivos de `GeneratorFunction` de JavaScript, Java Streams e indexación de estilo MySQL. Su filosofía central es a la vez simple y poderosa: construir pipelines de procesamiento de datos excepcionalmente eficientes mediante indexación inteligente, no a través de iteración de fuerza bruta.
 
-## Filosofía Central: Separación de Definición y Ejecución
-Una idea arquitectónica clave de Semantic-TypeScript es la clara separación entre la definición de un flujo y su ejecución:
-- **Semantic<E>**: Un plano inmutable y diferido de un pipeline de transformación de datos. Define qué operaciones (filter, map, etc.) se realizarán
-- **Collectable<E>**: Una vista materializada y ejecutable del flujo. Se obtiene a partir de un Semantic y proporciona todas las operaciones terminales (collect, forEach, etc.) para ejecutar el pipeline y producir un resultado
+Donde las librerías convencionales imponen bucles síncronos o cadenas de promesas incómodas, Semantic-TypeScript ofrece una experiencia **completamente asíncrona**, funcionalmente pura y rigurosamente segura en tipos, diseñada para las demandas del desarrollo front-end moderno.
 
-Esta separación impone un modelo mental limpio y desbloquea optimizaciones potentes, como elegir un UnorderedCollectable para omitir ordenaciones innecesarias y obtener la máxima velocidad.
+En su modelo elegante, los datos solo llegan al consumidor cuando el pipeline ascendente invoca explícitamente las devoluciones de llamada `accept` (y, opcionalmente, `interrupt`). Usted tiene control total sobre el momento exacto en que se necesita.
 
-## ¿Por qué elegir Semantic-TypeScript?
-Seleccionar la biblioteca adecuada para el procesamiento de flujos de datos implica equilibrar rendimiento, seguridad de tipos y expresividad. Semantic-TypeScript está diseñada para sobresalir en todas estas dimensiones.
+---
 
-### 1. Un paradigma unificado y seguro en tipos para todas las secuencias de datos
-Proporciona una API declarativa y consistente para procesar cualquier secuencia de datos, ya sean arreglos estáticos, eventos en tiempo real o fragmentos asincrónicos, al tiempo que aprovecha todo el poder de TypeScript para garantizar seguridad de tipos de extremo a extremo. Esto elimina toda una clase de errores en tiempo de ejecución y transforma la manipulación de flujos en una actividad predecible y verificada por el compilador.
+### Por qué los desarrolladores lo prefieren
 
-### 2. Rendimiento sin concesiones con evaluación diferida inteligente
-En su núcleo, la biblioteca está construida sobre evaluación diferida. Operaciones como filter, map y flatMap simplemente componen un pipeline de procesamiento; no se realiza ningún trabajo hasta que se invoca una operación terminal. Esto se combina con capacidades de cortocircuito (a través de limit, anyMatch o callbacks de interrupción personalizados), que permiten detener el procesamiento anticipadamente, mejorando drásticamente la eficiencia para flujos grandes o infinitos.
+-   **Indexación Cero-Boilerplate** — cada elemento lleva su índice natural o personalizado.
+-   **Estilo Puramente Funcional** — con inferencia completa de TypeScript.
+-   **Flujos de Eventos a Prueba de Fugas** — `useWindow`, `useDocument`, `useHTMLElement` y `useWebSocket` están construidos con la seguridad en mente. Usted define el límite (usando `limit(n)`, `sub(start, end)` o `takeWhile(predicate)`) y la librería gestiona la limpieza. Sin oyentes persistentes, sin fugas de memoria.
+-   **Estadísticas Integradas** — análisis numérico y de bigint integral que incluye promedios, medianas, modas, varianza, asimetría y curtosis.
+-   **Rendimiento Predecible** — elija entre recolectores ordenados o desordenados según sus requisitos.
+-   **Eficiencia de Memoria** — los flujos se evalúan de forma perezosa, aliviando las preocupaciones de memoria.
+-   **Sin Comportamiento Indefinido** — TypeScript garantiza seguridad de tipos y nulabilidad. Los datos de entrada permanecen sin modificar a menos que se alteren explícitamente dentro de sus funciones de devolución de llamada.
 
-### 3. El poder del patrón `Collector<E, A, R>`
-Inspirado en Java, el patrón Collector es el motor de la flexibilidad. Desacopla la especificación de cómo acumular elementos del flujo de la ejecución del flujo en sí. La biblioteca proporciona un rico conjunto de coleccionadores integrados (toArray, groupBy, summate, etc.) para tareas cotidianas, al tiempo que hace que sea trivial implementar tu propia lógica de reducción compleja y reutilizable. Esto es mucho más potente y componible que un conjunto fijo de métodos terminales.
+---
 
-### 4. Soporte de primera clase para datos web modernos y asincrónicos
-Semantic-TypeScript está diseñada para el desarrollo contemporáneo. Ofrece métodos de fábrica nativos para fuentes web modernas:
-- `useFrom(iterable)`, `useRange()` para datos estáticos
-- `useInterval()`, `useAnimationFrame()` para flujos basados en tiempo
-- `useBlob()` para procesamiento de datos binarios fragmentados
-- `useWebSocket()`, `useDocument()`, `useWindow()` para flujos de eventos en tiempo real
+### Instalación
 
-### 5. Más allá de la agregación básica: análisis estadístico integrado
-Ve más allá de simples sumas y promedios. La biblioteca proporciona interfaces dedicadas NumericStatistics y BigIntStatistics, ofreciendo acceso inmediato a medidas estadísticas avanzadas directamente desde tus flujos: varianza, desviación estándar, mediana, asimetría y curtosis. Esto convierte el análisis de datos complejos en una sola línea de código.
-
-### 6. Diseñada para la ergonomía del desarrollador
-- **API fluida y encadenable**: Escribe pipelines de datos complejos como cadenas secuenciales y legibles
-- **Suite integral de utilidades**: Protecciones esenciales (isFunction, isIterable), utilidades (useCompare, useTraverse) e interfaces funcionales incluidas
-- **Integración Optional<T>**: Modela de forma segura la ausencia de un valor, eliminando preocupaciones de punteros nulos
-- **Guía de rendimiento**: Orientación clara sobre cuándo usar recolección no ordenada (unordered) para velocidad versus ordenada (ordered) para secuencia
-
-## Instalación
 ```bash
 npm install semantic-typescript
 ```
+o
+```bash
+yarn add semantic-typescript
+```
+
+---
 
-## Conceptos centrales en la práctica
+### Comienzo rápido
 
-### 1. Creación de flujos (Semantic)
-Los flujos se pueden crear desde varias fuentes usando funciones de fábrica.
 ```typescript
-import { useFrom, useInterval, useDocument } from 'semantic-typescript';
+import { useOf, useFrom, useRange, useWindow, useHTMLElement, useWebSocket, useText, useStringify } from "semantic-typescript";
+
+// Estadísticas numéricas
+let summate: number = useOf(10, 20, 30, 40)
+  .map((n: number): number => n * 2)
+  .toNumericStatistics()  // Requerido antes de la operación terminal
+  .summate();             // 200
+
+// Estadísticas de BigInt
+let summate: bigint = useOf(10n, 20n, 30n, 40n)
+  .map((n: bigint): bigint => n * 2)
+  .toBigIntStatistics()   // Requerido antes de la operación terminal
+  .summate();             // 200n
+
+// Invertir un flujo por índice
+useFrom([1, 2, 3, 4, 5])
+  .redirect((element: E, index: bigint): bigint => -index) // Índice negativo para inversión
+  .toOrdered() // Llamar a toOrdered() para preservar el orden del índice
+  .toArray(); // [5, 4, 3, 2, 1]
+
+// Mezclar un flujo
+useFrom([1, 2, 3, 4, 5])
+  .shuffle()
+  .toOrdered()
+  .toArray(); // ej., [2, 5, 1, 4, 3]
+
+// Trasladar elementos dentro de un flujo
+useFrom([1, 2, 3, 4, 5])
+  .translate(2)  // Desplazar elementos 2 posiciones a la derecha
+  .toOrdered()
+  .toArray(); // [4, 5, 1, 2, 3]
+
+useFrom([1, 2, 3, 4, 5])
+  .translate(-2) // Desplazar elementos 2 posiciones a la izquierda
+  .toOrdered()
+  .toArray(); // [3, 4, 5, 1, 2]
+
+// Rango infinito con terminación temprana
+useRange(0n, 1_000_000n)
+  .filter(n => n % 17n === 0n)
+  .limit(10n)          // Detenerse después de 10 elementos
+  .toUnordered()
+  .toArray();
 
-// Desde un arreglo estático
-const staticStream = useFrom([1, 2, 3, 4, 5]);
+// Redimensión de ventana en tiempo real (se detiene automáticamente tras 5 eventos)
+useWindow("resize")
+  .limit(5n)          // Crucial para flujos de eventos
+  .toUnordered()
+  .forEach((ev, idx) => console.log(`Redimensión #${idx}`));
 
-// Desde un generador asincrónico
-const asyncStream = useFrom(async function*() {
-  yield 1;
-  yield 2;
-});
+// Escuchar un elemento HTML
+// <input id="input" type="text"/>
+useHTMLElement("#input", "change")
+  .limit(1)
+  .toUnordered()
+  .forEach((event: Event) => submit(event));
+
+// Escuchar múltiples elementos y eventos
+useHTMLElement("input", ["change", "keyup"])
+  .takeWhile((event: Event): boolean => validate(event))
+  .toUnordered()
+  .forEach((event: Event) => submit(event));
 
-// Un flujo basado en tiempo
-const tickStream = useInterval(1000); // emite cada segundo
+// Escuchar un WebSocket
+let webSocket = new WebSocket("ws://localhost:8080");
+webSocket.addEventListener("close", (): void => {
+  webSocket.close();  // Gestionar el ciclo de vida del WebSocket manualmente
+});
+useWebSocket(webSocket, "message")
+  .limit(1)
+  .toUnordered()
+  .forEach((message: MessageEvent) => console.log(message.data));
 
-// Un flujo de eventos DOM (ver nota crucial a continuación)
-const clickStream = useDocument('click');
+// Iterar sobre una cadena por punto de código
+useText("My emotion now is: 😊, and semantic is 👍")
+  .toUnordered()
+  .log(); // Imprime la cadena
+
+// Convertir a cadena de forma segura un objeto con referencias circulares
+let o = {
+  a: 1,
+  b: "text",
+  c: [o.a, o.b, o.c] // Referencia circular
+};
+// let text: string = JSON.stringify(o); // Lanza un error
+let text: string = useStringify(o); // Produce de forma segura `{a: 1, b: "text", c: []}`
 ```
 
-### 2. Transformación de flujos (Operaciones intermedias)
-Las operaciones se encadenan de forma diferida para definir el pipeline.
-```typescript
-const processedStream = staticStream
-  .filter(x => x % 2 === 0) // Mantener solo números pares
-  .map(x => x * 10) // Multiplicar por 10
-  .flatMap(x => [x, x + 1]) // Transformar cada elemento en dos
-  .distinct(); // Eliminar duplicados
+---
 
-// Nada se ha ejecutado todavía
-```
+### Conceptos centrales
 
-### 3. Ejecución de flujos (Operaciones terminales)
-Para obtener un resultado, debes obtener un Collectable e invocar una operación terminal.
-```typescript
-// Obtener un collectable no ordenado para rendimiento
-const resultArray = await processedStream.toUnordered().toArray();
-console.log(resultArray); // ej., [20, 21, 40, 41]
-
-// Usar un coleccionador incorporado
-const sum = await processedStream.toUnordered().collect(useSummate());
-console.log(sum);
-
-// O usar el método collect genérico
-const customResult = await processedStream.toOrdered().collect(
-  () => new Map<number, number>(),
-  (map, element, index) => map.set(index, element),
-  map => map
-);
-```
+| Concepto | Propósito | Cuándo usarlo |
+| :--- | :--- | :--- |
+| `AsynchronousSemantic` | Constructor central para flujos asíncronos, eventos y pipelines perezosos. | Eventos en tiempo real, WebSockets, oyentes DOM, flujos de larga duración o infinitos. |
+| `SynchronousSemantic` | Constructor para flujos síncronos, en memoria o basados en bucle. | Datos estáticos, rangos, iteración inmediata. |
+| `toUnordered()` | Recolector terminal más rápido (indexación basada en Map). | Rutas críticas de rendimiento (tiempo y espacio O(n), sin ordenación). |
+| `toOrdered()` | Recolector ordenado, estable en índices. | Cuando se requiere orden estable o acceso indexado. |
+| `toNumericStatistics()` | Análisis estadístico numérico rico (media, mediana, varianza, asimetría, curtosis, etc.). | Análisis de datos y cálculos estadísticos. |
+| `toBigIntStatistics()` | Análisis estadístico de bigint. | Análisis de datos y cálculos estadísticos para enteros grandes. |
+| `toWindow()` | Soporte para ventanas deslizantes y fijas. | Procesamiento de series temporales, procesamiento por lotes y operaciones con ventanas. |
 
-### 4. Crucial: Trabajar con flujos de eventos
-Los flujos de eventos (useDocument, useWindow, useHTMLElement, useWebSocket) son infinitos por naturaleza. Debes usar operaciones como sub, takeWhile o limit para definir cuándo dejar de recolectar eventos y completar el flujo. De lo contrario, la operación terminal esperará indefinidamente.
-```typescript
-import { useDocument } from 'semantic-typescript';
+---
 
-// Recolectar solo los primeros 5 clics
-const first5Clicks = await useDocument('click')
-  .limit(5) // <- Esencial: limita el flujo a 5 eventos
-  .toUnordered()
-  .toArray();
+**Reglas de uso importantes**
 
-// Recolectar clics durante una ventana de 10 segundos
-const clicksIn10s = await useDocument('click')
-  .takeWhile((_, index, startTime = Date.now()) => Date.now() - startTime < 10000)
-  .toUnordered()
-  .toArray();
+1.  **Flujos de eventos** (`useWindow`, `useDocument`, `useHTMLElement`, `useWebSocket`, …) devuelven un `AsynchronousSemantic`.
+    → **Debe** llamar a `.limit(n)`, `.sub(start, end)` o `.takeWhile()` para dejar de escuchar. De lo contrario, el oyente permanece activo.
 
-// Recolectar clics desde el índice 2 al 5 (base 0)
-const specificClicks = await useDocument('click')
-  .sub(2n, 6n) // <- Toma elementos con índice 2, 3, 4, 5
-  .toUnordered()
-  .toArray();
-```
+2.  **Operaciones terminales** (`.toArray()`, `.count()`, `.average()`, `.reduce()`, `.findFirst()`, etc.) **solo están disponibles después** de la conversión a un recolector:
+    ```typescript
+    .toUnordered()   // Tiempo y espacio O(n), sin ordenación
+    // o
+    .toOrdered()     // Ordenado, mantiene el orden
+    ```
 
-**Perspicacia clave**: El evento (por ejemplo, un MouseEvent) y su índice de disparo secuencial (como un bigint) se pasan juntos a través del pipeline mediante el callback `accept(event, index)`.
+---
 
-### 5. Aprovechando las estadísticas
-```typescript
-const numericStream = useFrom([10, 20, 30, 40, 50]).toNumeric();
+### Características de rendimiento
 
-const average = await numericStream.average();
-const median = await numericStream.median();
-const standardDeviation = await numericStream.standardDeviation();
-const skewness = await numericStream.skewness();
+| Recolector | Complejidad Temporal | Complejidad Espacial | ¿Ordenado? | Mejor para |
+| :--- | :--- | :--- | :--- | :--- |
+| `toUnordered()` | O(n) | O(n) | No | Velocidad bruta, orden no requerido. |
+| `toOrdered()` | O(2n) | O(n) | Sí | Orden estable, acceso indexado, análisis. |
+| `toNumericStatistics()` | O(2n) | O(n) | Sí | Operaciones estadísticas que requieren datos ordenados. |
+| `toBigIntStatistics()` | O(2n) | O(n) | Sí | Operaciones estadísticas para bigint. |
+| `toWindow()` | O(2n) | O(n) | Sí | Operaciones de ventana basadas en tiempo. |
 
-console.log(`Promedio: ${average}, Mediana: ${median}, DesvEst: ${standardDeviation}`);
-```
+Opte por `toUnordered()` cuando la velocidad sea primordial. Use `toOrdered()` solo cuando necesite un orden estable o métodos estadísticos que dependan de datos ordenados.
 
-## Características principales
-- **Tipos de flujo dual**: Soporte completo para ambos SynchronousSemantic (para Iterable) y AsynchronousSemantic (para AsyncIterable y eventos)
-- **Conjunto de operaciones rico**: filter, map, flatMap, concat, distinct, sorted, limit, skip, peek, reverse, shuffle
-- **Operaciones terminales flexibles**: collect (con coleccionadores personalizados), toArray, toSet, toMap, forEach, reduce, findFirst, anyMatch, allMatch, count
-- **Coleccionadores avanzados**: Coleccionadores integrados para joining, groupingBy, partitioningBy, summing, averaging, maxBy, minBy
-- **Módulo estadístico**: Métodos listos para usar para media, mediana, moda, varianza, desviaciónEstándar, rango, cuantiles, asimetría, curtosis en flujos numéricos/de bigint
-- **Funciones de utilidad**: Protecciones de tipo (isPromise, isAsyncIterable), comparadores (useCompare), recorrido (useTraverse) y ganchos de conversión
-- **Optional<T>**: Un contenedor monádico para valores anulables, integrado con operaciones de búsqueda
-
-## Resumen de la API
-
-### Clases e interfaces centrales
-- `Semantic<E>` / `AsynchronousSemantic<E>`: La definición abstracta del flujo
-- `Collectable<E>` / `AsynchronousCollectable<E>`: El flujo ejecutable con operaciones terminales
-- `OrderedCollectable<E>` / `UnorderedCollectable<E>`: Versiones materializadas optimizadas para operaciones sensibles o no sensibles al orden
-- `Collector<E, A, R>`: La abstracción para operaciones de reducción mutables
-
-### Funciones de fábrica (use*)
-- **Desde fuentes**: useFrom, useRange, useFill, useEmpty
-- **Desde tiempo**: useInterval, useAnimationFrame
-- **Desde APIs web**: useBlob, useDocument, useWindow, useHTMLElement, useWebSocket
-- **Coleccionadores**: useToArray, useGroupBy, useSummate, useJoin, etc.
-
-## Notas de rendimiento
-- **Evaluación diferida**: Los pipelines se componen sin ejecución hasta que se llama a una operación terminal
-- **Cortocircuito**: Operaciones como limit, anyMatch y findFirst detendrán el procesamiento de elementos tan pronto como se determine el resultado
-- **Ordenado vs No ordenado**:
-  - Usa `.toUnordered()` para operaciones terminales cuando el orden de los elementos fuente no importa para tu resultado (por ejemplo, para suma, máximo o toSet). Esto puede permitir optimizaciones internas que omiten costosos pasos de ordenación
-  - Usa `.toOrdered()` cuando la secuencia es importante (por ejemplo, para toArray donde se debe preservar el orden)
-
-## Ejemplo de inicio
-```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' },
-];
-
-// Calcular el monto total por categoría
-const totalsByCategory = await useFrom(transactions)
-  .toUnordered()
-  .collect(
-    useGroupBy(
-      t => t.category,
-      t => t.amount,
-      useSummate() // Coleccionador para los valores
-    )
-  );
-
-console.log(totalsByCategory); // Map { 'Food' => 150, 'Electronics' => 500 }
-```
+---
+
+**Comparación con otros procesadores de flujo para Front-End**
+
+| Característica | Semantic-TypeScript | RxJS | Iteradores/Generadores Asíncronos Nativos | Most.js |
+| :--- | :--- | :--- | :--- | :--- |
+| **Integración con TypeScript** | De primer nivel, profundamente tipado con consciencia nativa de índices. | Excelente, pero involucra genéricos complejos. | Buena, requiere tipado manual. | Estilo funcional fuerte. |
+| **Análisis Estadístico Integrado** | Soporte nativo integral para `number` y `bigint`. | No disponible de forma nativa (requiere operadores personalizados). | Ninguno. | Ninguno. |
+| **Indexación y Conciencia de Posición** | Indexación nativa y potente de bigint en cada elemento. | Requiere operadores personalizados (`scan`, `withLatestFrom`). | Se requiere contador manual. | Básica, sin índice incorporado. |
+| **Gestión de Flujos de Eventos** | Fábricas dedicadas y seguras en tipos con control explícito de parada temprana. | Potente pero requiere gestión manual de suscripciones. | Oyente de eventos manual + cancelación. | Buena `fromEvent`, ligero. |
+| **Rendimiento y Eficiencia de Memoria** | Excepcional – recolectores optimizados `toUnordered()` y `toOrdered()`. | Muy buena, pero las cadenas de operadores añaden sobrecarga. | Excelente (sobrecarga cero). | Excelente. |
+| **Tamaño del Paquete** | Muy ligero. | Grande (incluso con tree-shaking). | Cero (nativo). | Pequeño. |
+| **Filosofía de Diseño de API** | Patrón de recolector funcional con indexación explícita. | Patrón Observable Reactivo. | Patrón Iterador / Generador. | Funcional, point-free. |
+| **Terminación Temprana y Control** | Explícito (`interrupt`, `.limit()`, `.takeWhile()`, `.sub()`). | Bueno (`take`, `takeUntil`, `first`). | Manual (`break` en `for await…of`). | Bueno (`take`, `until`). |
+| **Soporte Síncrono y Asíncrono** | API unificada – soporte de primer nivel para ambos. | Principalmente asíncrono. | Ambos, pero manual. | Principalmente asíncrono. |
+| **Curva de Aprendizaje** | Suave para desarrolladores familiarizados con pipelines funcionales e indexados. | Más pronunciada (muchos operadores, observables fríos/calientes). | Baja. | Moderada. |
+
+**Ventajas clave de Semantic-TypeScript**
+
+*   Capacidades únicas de estadística e indexación integradas, eliminando la necesidad de `reduce` manual o librerías externas.
+*   Control explícito sobre los flujos de eventos previene las fugas de memoria comunes en RxJS.
+*   Un diseño síncrono/asíncrono unificado proporciona una única API consistente para diversos casos de uso.
+
+Esta comparación ilustra por qué Semantic-TypeScript es particularmente adecuado para aplicaciones front-end modernas con TypeScript que exigen rendimiento, seguridad de tipos y análisis ricos sin la ceremonia de las librerías reactivas tradicionales.
+
+---
+
+### ¿Listo para explorar?
+
+Semantic-TypeScript transforma flujos de datos complejos en pipelines legibles, componibles y de alto rendimiento. Ya sea que esté manejando eventos de UI en tiempo real, procesando grandes conjuntos de datos o construyendo paneles de análisis, proporciona el poder de la indexación a nivel de base de datos con la elegancia de la programación funcional.
+
+**Próximos pasos:**
+
+*   Explore la API completamente tipada en su IDE (todas las exportaciones son del paquete principal).
+*   Únase a la creciente comunidad de desarrolladores que han reemplazado iteradores asíncronos complejos con pipelines Semantic limpios.
+
+**Semantic-TypeScript** — donde los flujos se encuentran con la estructura.
 
-Semantic-TypeScript está construida para desarrolladores que buscan una biblioteca de procesamiento de flujos rigurosamente diseñada, segura en tipos y de alto rendimiento. Lleva el poder de los patrones de transformación de datos a nivel empresarial al ecosistema TypeScript, perfectamente adecuada para aplicaciones front-end intensivas en datos, procesamiento de datos en Node.js y cualquier escenario donde se requiera un manejo elegante y eficiente de secuencias.
+Comience a construir hoy y experimente la diferencia que proporciona una indexación bien pensada.
 
-[![GitHub](./GitHub.png)](https://github.com/eloyhere/semantic-typescript)  [![NPM](./NPM.png)](https://www.npmjs.com/package/semantic-typescript) 
+**Construya con claridad, proceda con confianza y transforme los datos con intención.**