rowpipe 2.0.0 → 2.2.0

package/README.md

@@ -13,11 +13,15 @@ Designed around stream backpressure and batch processing, Rowpipe processes mult
 ## Highlights
 
 - **Stream-First Architecture**: Datasets are never buffered entirely in memory; rows flow in configurable batches through async generator pipelines.
-- **Rich Format Ecosystem**: Native streaming support for **CSV, TSV / PSV, JSON, JSONL, XLSX, Apache Parquet (`.parquet`), Markdown tables (`.md`), and Gzip (`.gz`)**.
+- **Rich Format Ecosystem**: Native streaming support for **PostgreSQL, MySQL, SQLite, CSV, TSV / PSV, JSON, JSONL, XLSX, Apache Parquet (`.parquet`), Markdown tables (`.md`), and Gzip (`.gz`)**.
+- **First-Class Database Streaming (`rowpipe db`)**: True cursor-based streaming sources and sinks for PostgreSQL, MySQL, and SQLite. "Databases are just another Rowpipe source and sink" — rows normalize directly into standard `DataBatch` objects with zero parallel data models.
+- **Intelligent Pushdown Optimizer**: Automatically pushes compatible operations (`SELECT`, `WHERE`, `ORDER BY`, `LIMIT`, `OFFSET`) down into database queries in `--table` mode while seamlessly executing non-pushdownable transforms in the local streaming pipeline.
+- **Database Writing, Migration & DDL**: Stream directly into database tables (`--to-db`) with automatic table creation (`--create-table`), batched inserts, transactions (`--transaction`), dialect-specific upsert (`--upsert --conflict <cols>`), and truncate (`--truncate`).
+- **Lossless Type Precision**: Preserves full `BIGINT` and arbitrary precision `DECIMAL` / `NUMERIC` values without floating point corruption. Safely maps `JSONB`, `BYTEA`/`BLOB`, dates, and timestamps.
+- **Connection Security & Credential Masking**: Automatically sanitizes database passwords across all logs, explain plans, errors, and metadata (`postgres://user:***@host/db`).
 - **Apache Parquet Support**: High-performance columnar binary format reader (Snappy, Zstd, Gzip decompression via pure JS) and streaming writer.
-- **Cross-Format Conversion & Multi-Sheet Export**: Convert seamlessly across all formats. Export individual Excel sheets or bulk export all worksheets with `--all-sheets`.
 - **Filesystem as Data (`rowpipe files`)**: First-class streaming filesystem source adapter. Directories and files become streams of tabular records (`path`, `size`, `type`, `extension`, `modified_at`, streaming `hash`, `mime`) composable with `filter`, `select`, `stats`, `convert`, and `diff`.
-- **Cross-Format Dataset Diffing (`rowpipe diff`)**: High-performance, stream-first comparison across CSV, JSONL, XLSX, and Parquet with bounded memory and automatic spill-to-disk. Supports composite keys, duplicate policies, value tolerance, column filtering, schema diffing, JSONL patch generation, and CI `--fail-on-diff` mode.
+- **Cross-Format Dataset Diffing (`rowpipe diff`)**: High-performance, stream-first comparison across CSV, JSONL, XLSX, Parquet, and Database tables with bounded memory and automatic spill-to-disk. Supports composite keys, duplicate policies, value tolerance, column filtering, schema diffing, JSONL patch generation, and CI `--fail-on-diff` mode.
 
 - **Zero-`eval` Safe Expression Engine**: Ultra-fast JIT closure-compiled evaluators supporting arithmetic (`revenue - cost`), string/date pipe functions (`email | lower | trim`), and direct JSON dot-notation (`payload.user.city`).
 - **Map & Reduce Streaming Engine**: Compute row derivations (`rowpipe map`) and global or group-by aggregations (`rowpipe reduce --by country`) in a single pass.
@@ -549,8 +553,390 @@ rowpipe diff dist.snapshot.v1.jsonl dist.snapshot.v2.jsonl \
 #### 5. Native Directory Diffing (`rowpipe files diff`)
 Compare two directory trees directly:
 
+---
+
+## Databases
+
+Rowpipe provides first-class streaming database support for **PostgreSQL, MySQL, and SQLite**.
+
+The key architectural rule is:
+
+> **Databases are just another Rowpipe source and sink.**
+
+Database rows normalize directly into standard Rowpipe `DataBatch` and `Row` objects. There is no parallel execution engine or secondary row type — existing operations (`filter`, `select`, `sort`, `group`, `reduce`, `stats`, `diff`) compose natively without intermediate files or memory buffering.
+
+```text
+PostgreSQL / MySQL / SQLite / CSV / JSONL / Parquet / Files
+                           ↓
+                     DataBatch / Row
+                           ↓
+             filter / select / map / sort
+             group / reduce / stats / diff
+                           ↓
+                     TabularWriter
+                           ↓
+PostgreSQL / MySQL / SQLite / CSV / JSONL / Parquet / Markdown
+```
+
+### 1. Database Streaming Sources
+
+Read directly from database tables or custom queries in bounded, cursor-based streams:
+
+```bash
+# Read from PostgreSQL table in streaming batches
+rowpipe db postgres://localhost/mydb --table users
+
+# Read from MySQL database
+rowpipe db mysql://root@localhost/app --table orders
+
+# Read from SQLite database file
+rowpipe db sqlite://./data.db --table events
+# or direct file path
+rowpipe db ./data.db --table events
+
+# Execute custom SQL query
+rowpipe db postgres://localhost/mydb \
+  --query 'SELECT id, email, created_at FROM users WHERE active = true'
+
+# Parameterized queries (driver-level binding)
+rowpipe db postgres://localhost/mydb \
+  --query 'SELECT * FROM users WHERE age > $1 AND status = $2' \
+  --params '[30, "ACTIVE"]'
+```
+
+### 2. Output to Any Rowpipe Format
+
+Database streams flow directly through Rowpipe writers to CSV, JSONL, Parquet, or Markdown tables:
+
 ```bash
-rowpipe files diff ./dist-v1 ./dist-v2 --hash sha256
+# Stream PostgreSQL table to JSONL
+rowpipe db postgres://localhost/app --table users --to jsonl > users.jsonl
+
+# Stream MySQL query to CSV
+rowpipe db mysql://localhost/app --query 'SELECT * FROM orders' --to csv > orders.csv
+
+# Stream SQLite table to GitHub Markdown table
+rowpipe db sqlite://./sales.db --table sales --limit 20 --to markdown
+```
+
+### 3. Pipeline Operations & Pushdown Optimizer
+
+When querying tables with `--table`, Rowpipe's **Intelligent Pushdown Optimizer** analyzes the pipeline and pushes compatible operations directly into database SQL:
+
+* `select` $\rightarrow$ `SELECT col1, col2`
+* `filter` $\rightarrow$ `WHERE condition`
+* `sort` $\rightarrow$ `ORDER BY col DESC`
+* `limit` $\rightarrow$ `LIMIT N`
+* `offset` $\rightarrow$ `OFFSET N`
+
+Unsupported or complex operations safely remain in the local streaming pipeline.
+
+```bash
+# Pushes down WHERE, SELECT, ORDER BY, and LIMIT to database SQL
+rowpipe db postgres://localhost/app \
+  --table users \
+  --filter 'active == true and age > 25' \
+  --select id,email,created_at \
+  --sort created_at:desc \
+  --limit 100 \
+  --to jsonl
+
+# Mixed execution: pushdown WHERE + local aggregations
+rowpipe db sqlite://./sales.db \
+  --table sales \
+  --where 'year = 2026' \
+  --group-by country \
+  --sum revenue \
+  --sort revenue_sum:desc
+```
+
+### 4. Database Sinks & File-to-Database Loading
+
+Load CSV, JSONL, XLSX, Parquet, or other databases directly into database tables in batched transactions:
+
+```bash
+# Load CSV into PostgreSQL table with automatic DDL table creation
+rowpipe users.csv \
+  --to-db postgres://localhost/app \
+  --to-table users \
+  --create-table
+
+# Load JSONL into SQLite database
+rowpipe events.jsonl \
+  --to-db sqlite://./app.db \
+  --to-table events \
+  --create-table
+
+# Dialect-specific Upsert on conflict keys
+rowpipe users.csv \
+  --to-db postgres://localhost/app \
+  --to-table users \
+  --upsert \
+  --conflict id
+
+# Destructive Truncate before bulk inserting
+rowpipe new_catalog.parquet \
+  --to-db mysql://localhost/store \
+  --to-table catalog \
+  --truncate \
+  --transaction
+```
+
+### 5. Database-to-Database Migrations (Zero Intermediate Files)
+
+Stream data directly between different database dialects with on-the-fly transformations:
+
+```bash
+# Migrate PostgreSQL table directly to SQLite with filtering & projection
+rowpipe db postgres://production/app \
+  --table users \
+  --filter 'deleted_at == null' \
+  --select id,email,created_at \
+  --to-db sqlite://./backup.db \
+  --to-table active_users \
+  --create-table
+```
+
+### 6. Cross-Format Diffing with Databases
+
+Diff a database table directly against a CSV, JSONL, or Parquet file using Rowpipe's diff engine:
+
+```bash
+# Compare PostgreSQL table against CSV export
+rowpipe diff \
+  'postgres://localhost/app?table=users' \
+  users_backup.csv \
+  --key id \
+  --coerce
+```
+
+### 7. Database Introspection
+
+Inspect tables and schema types without third-party database clients:
+
+```bash
+# List all tables in database
+rowpipe db postgres://localhost/app --tables
+
+# Inspect column schema, data types, and nullability
+rowpipe db postgres://localhost/app --schema users
+
+# Output schema as machine-readable JSON
+rowpipe db postgres://localhost/app --schema users --json
+```
+
+### 8. Lossless Type Mapping & Security
+
+- **BIGINT**: Values outside JavaScript safe integer range (e.g. `9223372036854775807`) are preserved losslessly as `bigint` without silent precision loss.
+- **DECIMAL / NUMERIC**: High-precision numbers survive database $\leftrightarrow$ file workflows without floating point truncation.
+- **JSON / JSONB**: Native objects and arrays are preserved and parsed appropriately.
+- **BYTEA / BLOB**: Binary buffers are mapped cleanly without dumping corrupted text to stdout.
+- **Credential Masking**: Connection URLs containing passwords (e.g. `postgres://admin:secret@host/db`) are automatically masked (`postgres://admin:***@host/db`) across all logs, explain plans, progress outputs, and errors.
+
+---
+
+## Tabular Operations & Execution Planner
+
+Rowpipe 2.0 introduces a comprehensive set of Unix-like tabular data operations, powered by a rule-based execution planner that optimizes multi-transform pipelines and enforces strict memory bounds.
+
+> **Streaming is the default. Global state is explicit, bounded, and spillable.**
+
+### Streaming Safety Classification
+
+| Classification | Operations | Memory Complexity | Description |
+|----------------|------------|-------------------|-------------|
+| **Fully Streaming** | `limit`, `offset`, `head`, `filter`, `select`, `rename`, `cast`, `map`, `count` | $O(1)$ | Consumes stream in batches, cancels upstream sources immediately upon completion. |
+| **Bounded State** | `tail`, `top`, `sample` | $O(K)$ / $O(N)$ | Maintains a fixed-size ring buffer ($O(N)$) or binary min/max heap ($O(K)$). |
+| **Spillable Global State** | `sort`, `unique`, `group`, `reduce`, `diff` | $O(1)$ RAM threshold + Disk Spilling | Buffers in-memory runs up to `--memory-limit` and transparently spills to disk partitions or runs. |
+
+---
+
+### Operations Reference
+
+#### 1. Limit & Head
+Emit the first $N$ rows and immediately cancel upstream stream reading:
+
+```bash
+# Explicit limit command
+rowpipe limit users.csv 100
+
+# Pipeline flag
+rowpipe users.csv --limit 100
+
+# Head alias (default: 10 rows)
+rowpipe head users.csv
+rowpipe head users.csv -n 50
+
+# Streaming through Unix pipe
+cat data.csv | rowpipe limit - 100
+```
+
+#### 2. Offset
+Skip the first $N$ rows and stream everything after without scanning unneeded rows:
+
+```bash
+rowpipe offset users.csv 1000
+rowpipe users.csv --offset 1000
+
+# Combine with limit (automatically halts reading after 1,100 rows)
+rowpipe users.csv --offset 1000 --limit 100
+```
+
+#### 3. Tail
+Emit the last $N$ rows using a bounded circular ring buffer without buffering the entire dataset in RAM:
+
+```bash
+# Default: last 10 rows
+rowpipe tail server_logs.jsonl
+
+# Specify row count
+rowpipe tail server_logs.jsonl -n 100
+```
+
+#### 4. External Merge Sort (`sort`)
+Multi-column typed sorting with deterministic sequence stability, natural sorting, case-insensitivity, null handling, and disk run spilling:
+
+```bash
+# Single column sort (numeric, boolean, date, string typed)
+rowpipe sort users.csv --by age:desc
+
+# Multi-column sort
+rowpipe sort sales.csv --by country --by revenue:desc
+
+# Compact syntax
+rowpipe sort sales.csv --by "country,revenue:desc"
+
+# Natural filename / alphanumeric sort
+rowpipe sort files.csv --by name --natural
+
+# Null value positioning
+rowpipe sort users.csv --by age --nulls first   # or --nulls last
+
+# Memory threshold before disk run spilling
+rowpipe sort huge.csv --by created_at --memory-limit 256mb --temp-dir /tmp/rowpipe
+```
+
+#### 5. Top-K Bounded Heap (`top`)
+Extract the top (or bottom) $K$ records using a bounded $O(K)$ binary heap:
+
+```bash
+# Top 10 largest by revenue
+rowpipe top sales.csv --by revenue -n 10
+
+# Top 20 largest files
+rowpipe files ./src --sort size:desc --limit 20   # Automatically rewritten to TopK(20)!
+
+# Bottom 5 smallest
+rowpipe top users.csv --by score -n 5 --smallest
+```
+
+#### 6. Unique Deduplication (`unique`)
+Deduplicate rows by key columns or entire rows with spillable hash partitions:
+
+```bash
+# Unique by single field (keeps first occurrence by default)
+rowpipe unique users.csv --by email
+
+# Composite uniqueness
+rowpipe unique users.csv --by country,email
+
+# Keep last occurrence
+rowpipe unique logs.jsonl --by user_id --keep last
+
+# Entire row deduplication
+rowpipe unique dataset.csv
+```
+
+#### 7. Count Analyzer (`count`)
+Ultra-lightweight streaming row, distinct, and group counting:
+
+```bash
+# Total row count
+rowpipe count dataset.parquet
+# Output: 8,531,221
+
+# Distinct column count (exact or approximate HyperLogLog)
+rowpipe count users.csv --distinct email
+rowpipe count users.csv --distinct email --approx
+
+# Group-by count
+rowpipe count users.csv --by country
+
+# Machine-readable JSON output
+rowpipe count users.csv --by country --json
+```
+
+#### 8. Group & Aggregations (`group`)
+Group tabular streams with single-pass hash accumulators and multi-column aggregations:
+
+```bash
+# Group count
+rowpipe group sales.csv --by country --count
+
+# Multi-field aggregations
+rowpipe group sales.csv \
+  --by country \
+  --count \
+  --sum revenue \
+  --avg revenue \
+  --max quantity
+
+# Compact aggregation spec
+rowpipe group sales.csv \
+  --by country,category \
+  --agg "orders=count(),total_rev=sum(revenue),avg_rev=avg(revenue)" \
+  --to markdown
+```
+
+---
+
+### Combined Multi-Transform Pipeline
+
+Chain multiple operations in a **single process** without writing temporary intermediate files:
+
+```bash
+# Reader -> Filter -> Select -> TopK -> Writer
+rowpipe users.csv \
+  --filter "age >= 18 && active == true" \
+  --select id,name,age,country,revenue \
+  --sort revenue:desc \
+  --limit 50 \
+  --to markdown
+```
+
+### Execution Plan Visualizer (`rowpipe explain`)
+
+Inspect the planned execution pipeline and see automatic optimizations in action:
+
+```bash
+rowpipe explain sales.csv \
+  --filter "active == true" \
+  --sort revenue:desc \
+  --limit 10 \
+  --to jsonl
+```
+
+Output:
+```text
+======================================================
+              Rowpipe Execution Plan                  
+======================================================
+
+  CSVReader (sales.csv)
+    ↓
+  Filter (active == true)
+    ↓
+  TopK (revenue DESC, 10) [Bounded Heap]
+    ↓
+  JSONLWriter (stdout)
+
+------------------------------------------------------
+Optimizations Applied:
+  • sort(revenue desc) + limit(10) -> top-k (10)
+------------------------------------------------------
+Memory Classification:
+  Bounded State (O(K) fixed memory bound)
+======================================================
 ```
 
 ---
@@ -569,59 +955,34 @@ import {
   FileSystemReader,
   filterRows,
   selectColumns,
-  castColumns,
-  mapRows,
-  reduceRows,
+  limitRows,
+  offsetRows,
+  tailRows,
+  sortRows,
+  topRows,
+  uniqueRows,
+  groupRows,
+  countStream,
   diffRows,
   computeDiff,
 } from "rowpipe";
 import { createReadStream, createWriteStream } from "node:fs";
 
-// 1. Streaming Map -> Filter -> Reduce Pipeline
+// Fluent Pipeline API
 const reader = new CSVReader(createReadStream("sales.csv"));
-const writer = new JSONLWriter(createWriteStream("summary.jsonl"));
+const writer = new JSONLWriter(createWriteStream("top_sales.jsonl"));
 
 await createPipeline(reader)
-  .pipe(mapRows({
-    profit: "revenue - cost",
-    margin: "((revenue - cost) / revenue) * 100",
-  }))
-  .pipe(filterRows("margin >= 15"))
-  .pipe(reduceRows({
-    by: ["country"],
-    aggregations: [
-      "total_profit = sum(profit)",
-      "avg_margin = avg(margin)",
-      "count = count()",
-    ],
-  }))
+  .filter("status == 'completed'")
+  .sort({ by: "revenue:desc" })
+  .limit(100)
   .to(writer);
 
-// 2. Stream Filesystem Directory as Tabular Rows
-const fsReader = new FileSystemReader({
-  root: "./src",
-  include: ["**/*.ts"],
-  hash: "sha256",
-  mime: true,
-});
-
-for await (const batch of fsReader.read()) {
-  for (const file of batch.rows) {
-    console.log(`${file.relative_path} (${file.size} bytes) - Hash: ${file.hash}`);
-  }
-}
-
-// 3. Streaming Dataset Diffing (Async Iterable Events)
-for await (const event of diffRows({
-  leftPath: "old.csv",
-  rightPath: "new.parquet",
-  keys: ["id"],
-  ignore: ["updated_at"],
-})) {
-  if (event.type === "changed") {
-    console.log(`Key ${JSON.stringify(event.key)} changed:`, event.changes);
-  }
-}
+// Filesystem as Tabular Source + Top 10 Largest Files
+const fsReader = new FileSystemReader({ root: "./src" });
+const largestFiles = await createPipeline(fsReader)
+  .top({ by: "size:desc", count: 10 })
+  .toArray();
 ```
 
 ---
@@ -643,20 +1004,19 @@ Rowpipe uses standardized POSIX exit codes:
 
 ## Memory & Performance Benchmarks
 
-### 1. Pipeline Benchmark (`Filter` -> `Select` -> `Cast` -> `Online Stats`):
-
-| Dataset Size | Throughput | Execution Time | Peak RSS Memory | Memory Scaling |
-|--------------|------------|----------------|-----------------|----------------|
-| **100,000 rows** | **~318,000 rows/s** | 0.31s | ~106 MB | $O(1)$ Bounded |
-| **1,000,000 rows** | **~500,000 rows/s** | 2.00s | ~153 MB | $O(1)$ Bounded |
-
-### 2. Diff Engine Benchmark (`rowpipe diff`):
+### 1. Operations Benchmark (`1,000,000 rows`, 47.1 MB CSV):
 
-| Comparison Size | Memory Limit | Throughput | Peak RSS Memory | Disk Spilled | Result |
-|-----------------|--------------|------------|-----------------|--------------|--------|
-| **2,000,000 rows** (1M vs 1M) | 64 MB | **~73,000 rows/s** | ~145 MB | Active | 100% Exact Match |
+| Scenario | Throughput | Elapsed Time | Peak RSS Memory | Memory Scaling |
+|----------|------------|--------------|-----------------|----------------|
+| **Limit 100** (Early Stream Cancel) | **Instant** | 0.01s | ~492 MB | $O(1)$ Early Termination |
+| **Tail 100** (Bounded RingBuffer) | **1,029,866 rows/s** (48.5 MB/s) | 0.97s | ~514 MB | $O(N)$ Bounded |
+| **Top-100** (Bounded Min-Heap) | **731,529 rows/s** (34.4 MB/s) | 1.37s | ~530 MB | $O(K)$ Bounded |
+| **Count + Distinct** (Streaming HLL) | **764,526 rows/s** (36.0 MB/s) | 1.31s | ~530 MB | $O(1)$ Bounded |
+| **Group-by** (Sum/Avg/Min/Max) | **611,995 rows/s** (28.8 MB/s) | 1.63s | ~516 MB | $O(1)$ Stream Hash |
+| **Unique** (Composite Deduplication) | **532,481 rows/s** (25.1 MB/s) | 1.88s | ~516 MB | Spillable Hash |
+| **External Merge Sort** (16MB threshold) | **73,185 rows/s** (3.4 MB/s) | 13.66s | ~606 MB | Spillable $K$-Way Merge |
 
-### 3. Filesystem Streaming Benchmark (`rowpipe files`):
+### 2. Filesystem Streaming Benchmark (`rowpipe files`):
 
 | File Count | Operation | Throughput | Peak RSS Memory | Memory Scaling |
 |------------|-----------|------------|-----------------|----------------|
@@ -668,6 +1028,7 @@ To run the benchmarks locally:
 
 ```bash
 npm run bench
+npm run benchmark:ops
 npm run benchmark:diff
 npm run benchmark:files
 ```

package/dist/analytics/profiler.d.ts

@@ -0,0 +1,56 @@
+import type { Aggregator, ColumnType, Row, SemanticType } from "../core/types.js";
+export interface ColumnProfileResult {
+    name: string;
+    inferredType: ColumnType;
+    typeConfidence: number;
+    typeBreakdown: Record<string, number>;
+    anomalies: unknown[];
+    totalRows: number;
+    nullCount: number;
+    nullPercentage: number;
+    emptyStringCount: number;
+    approxDistinctCount: number;
+    distinctPercentage: number;
+    semanticType?: SemanticType;
+    semanticConfidence?: number;
+    isNumeric: boolean;
+    min?: number;
+    max?: number;
+    sum?: number;
+    mean?: number;
+    stddev?: number;
+    zerosCount?: number;
+    negativeCount?: number;
+    isString: boolean;
+    minLength?: number;
+    maxLength?: number;
+    avgLength?: number;
+    topValues?: Array<{
+        value: string;
+        count: number;
+        percentage: number;
+    }>;
+}
+export interface DatasetProfileResult {
+    totalRows: number;
+    totalColumns: number;
+    columns: ColumnProfileResult[];
+}
+/**
+ * Single-pass Streaming Dataset Profiler.
+ */
+export declare class DatasetProfiler implements Aggregator<DatasetProfileResult> {
+    private columnProfilers;
+    private totalRows;
+    add(row: Row): void;
+    result(): DatasetProfileResult;
+}
+/**
+ * Formats profile results as an aligned terminal table.
+ */
+export declare function formatProfileTerminal(profile: DatasetProfileResult): string;
+/**
+ * Formats profile results as a GitHub Flavored Markdown document.
+ */
+export declare function formatProfileMarkdown(profile: DatasetProfileResult): string;
+//# sourceMappingURL=profiler.d.ts.map

package/dist/analytics/profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiler.d.ts","sourceRoot":"","sources":["../../src/analytics/profiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMlF,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,UAAU,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAG5B,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IAGvB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzE;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,mBAAmB,EAAE,CAAC;CAChC;AA+LD;;GAEG;AACH,qBAAa,eAAgB,YAAW,UAAU,CAAC,oBAAoB,CAAC;IACtE,OAAO,CAAC,eAAe,CAAqC;IAC5D,OAAO,CAAC,SAAS,CAAK;IAEtB,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAYnB,MAAM,IAAI,oBAAoB;CAY/B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAsC3E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CA+B3E"}