mgcheck 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Migration Guardian Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,416 @@
+# 🛡️ Migration Guardian (`mgcheck`)
+
+**Catch unsafe database migrations before they hit production.**
+
+Migration Guardian sits between your migration file and your real database — running it against a disposable shadow Postgres, analyzing it against known unsafe patterns, and reporting exactly what's dangerous and why.
+
+Built for teams using **Prisma**, **Drizzle**, or **raw SQL** migrations with PostgreSQL. Works as a **CLI**, a **CI gate**, or an **MCP tool** that AI coding agents call automatically.
+
+[![npm version](https://img.shields.io/npm/v/mgcheck.svg)](https://www.npmjs.com/package/mgcheck)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)
+[![CI](https://img.shields.io/github/actions/workflow/status/yourusername/mgcheck/ci.yml?branch=main)](https://github.com/yourusername/mgcheck/actions)
+
+---
+
+## Why?
+
+AI coding agents (Claude Code, Cursor, etc.) write database migrations constantly. They get the *schema intent* right — but they don't know whether the operation is *safe to run on production*:
+
+- `CREATE INDEX` without `CONCURRENTLY` → **locks the entire table** during index build
+- `ALTER COLUMN TYPE` → **full table rewrite**, blocking all reads/writes
+- `ADD COLUMN NOT NULL` without a default → **table rewrite on large tables**
+- `DROP TABLE` / `DROP COLUMN` → **irreversible data loss**
+- No `lock_timeout` → **lock queue death spiral** under contention
+
+**Existing tools catch some of this. None of them close the loop:**
+
+| Tool | Static Analysis | Shadow DB Execution | Auto-Fix + Re-verify | Open Source |
+|---|:---:|:---:|:---:|:---:|
+| Squawk | ✅ | ❌ | ❌ | ✅ |
+| pgfence | ✅ | ❌ | ❌ | ✅ |
+| Atlas lint | ✅ | ✅ | ❌ | ❌ (Pro tier) |
+| **mgcheck** | ✅ | ✅ | ✅ (v1) | ✅ |
+
+---
+
+## Quick Start
+
+### 1. Zero-Install Interactive Setup (One Command)
+
+Just run this in any project terminal:
+
+```bash
+npx mgcheck
+```
+
+It automatically:
+1. Detects your AI editors (**Antigravity**, **Cursor**, **Claude Desktop**).
+2. Asks: `Connect Migration Guardian to your AI agents? [Y/n]`
+3. Instantly configures the MCP server so your AI coding agent can automatically call `check_migration` and `analyze_migration` before touching your schema!
+
+---
+
+### 2. Manual CLI Usage
+
+```bash
+# Check a single migration file against shadow Postgres
+npx mgcheck run ./migrations/0007_add_status.sql
+
+# Static analysis only (zero database required)
+npx mgcheck analyze ./migrations/0007_add_status.sql
+
+# Non-interactive auto-setup
+npx mgcheck setup -y
+```
+
+### Example Output
+
+```
+  mgcheck v0.1.0 — Migration Guardian
+
+  📁 Detected: Raw SQL migration
+  📄 File: ./migrations/0007_add_status.sql
+
+  ⚡ Shadow Database
+  ├─ Provider: Docker (postgres:16-alpine)
+  ├─ Started in 2.3s
+  └─ Execution: ✅ Success (45ms, 3 statements)
+
+  🔍 Rule Analysis
+
+  ❌ MG001: CREATE INDEX without CONCURRENTLY
+  Line 12: CREATE INDEX idx_users_email ON users (email);
+
+  Why this is dangerous:
+    CREATE INDEX without CONCURRENTLY acquires a SHARE lock on the table,
+    blocking all INSERT, UPDATE, and DELETE operations for the entire
+    duration of the index build. On a table with millions of rows, this
+    can block writes for minutes or hours.
+
+  Suggested fix:
+    CREATE INDEX CONCURRENTLY idx_users_email ON users (email);
+    Note: CONCURRENTLY cannot run inside a transaction block.
+
+  ⚠️  MG009: No lock_timeout guard
+  No SET lock_timeout found before risky operations.
+
+  Suggested fix:
+    Prepend: SET lock_timeout = '5s';
+
+  ──────────────────────────────────────────
+  Result: ❌ FAILED (1 error, 1 warning)
+```
+
+---
+
+## CLI Reference
+
+### Commands
+
+```bash
+mgcheck run <path>       # Full check: analyze + execute against shadow DB
+mgcheck analyze <path>   # Static analysis only (no shadow DB required)
+mgcheck setup            # Auto-connect MCP to Antigravity, Cursor, & Claude
+mgcheck mcp              # Start the MCP server for AI agent stdio
+mgcheck version          # Print version
+```
+
+### Flags
+
+| Flag | Description | Default |
+|---|---|---|
+| `--db-url <url>` | Use existing Postgres instead of Docker | — |
+| `--seed <path>` | Base schema SQL to apply before target migration | — |
+| `--docker-image <img>` | Postgres Docker image | `postgres:16-alpine` |
+| `--provider <p>` | Shadow DB provider: `docker` \| `pglite` | `docker` |
+| `--format <f>` | Output: `terminal` \| `json` \| `markdown` | `terminal` |
+| `--ci` | Machine-readable JSON + exit codes only | `false` |
+| `--confirm-destructive` | Allow destructive ops (DROP, TRUNCATE) | `false` |
+| `--llm-fix` | *(v1)* Enable LLM-assisted fix generation | `false` |
+| `--verbose` | Show detailed logs | `false` |
+| `--config <path>` | Path to config file | auto-detect |
+
+### Exit Codes
+
+| Code | Meaning |
+|---|---|
+| `0` | All checks passed |
+| `1` | Execution failed or blocking rule violation |
+| `2` | Warnings only (no blocking errors) |
+| `3` | Internal error / misconfiguration |
+
+---
+
+## Safety Rules
+
+mgcheck ships with 10 built-in safety rules, inspired by [Squawk](https://squawkhq.com/) and [pgfence](https://github.com/flvmnt/pgfence):
+
+| Rule | Name | Detects | Severity | Safe Alternative |
+|---|---|---|---|---|
+| **MG001** | `create-index-not-concurrent` | `CREATE INDEX` without `CONCURRENTLY` | error | `CREATE INDEX CONCURRENTLY` |
+| **MG002** | `alter-column-type` | `ALTER TABLE ... ALTER COLUMN ... TYPE` | error | Expand/contract: add new column → migrate → drop old |
+| **MG003** | `add-column-not-null-no-default` | `ADD COLUMN ... NOT NULL` without `DEFAULT` | error | Add nullable → backfill → `SET NOT NULL` |
+| **MG004** | `add-constraint-not-valid` | `ADD CONSTRAINT` without `NOT VALID` | warning | `NOT VALID` + separate `VALIDATE CONSTRAINT` |
+| **MG005** | `drop-column` | `DROP COLUMN` | error | Requires `--confirm-destructive` |
+| **MG006** | `drop-table` | `DROP TABLE` | error | Requires `--confirm-destructive` |
+| **MG007** | `rename-column` | `RENAME COLUMN` | warning | Add new column + update code + drop old |
+| **MG008** | `rename-table` | `RENAME TABLE` | warning | Create new table + view/alias |
+| **MG009** | `missing-lock-timeout` | No `lock_timeout` before risky ops | warning | Prepend `SET lock_timeout = '5s';` |
+| **MG010** | `missing-down-migration` | No rollback migration detected | warning | Create corresponding down migration |
+
+### Configuring Rules
+
+Override severity or disable rules in `.mgcheckrc.json`:
+
+```json
+{
+  "rules": {
+    "MG004": "error",
+    "MG009": "off",
+    "MG010": "off"
+  }
+}
+```
+
+---
+
+## Configuration
+
+Create `.mgcheckrc.json` in your project root:
+
+```json
+{
+  "shadowDb": {
+    "provider": "docker",
+    "dockerImage": "postgres:16-alpine",
+    "seedFile": "./prisma/migrations/0001_init/migration.sql"
+  },
+  "rules": {
+    "MG007": "error",
+    "MG010": "off"
+  },
+  "output": {
+    "format": "terminal",
+    "verbose": false
+  }
+}
+```
+
+### Environment Variables
+
+| Variable | Description |
+|---|---|
+| `MGCHECK_DB_URL` | Postgres connection string for shadow DB |
+| `MGCHECK_DOCKER_IMAGE` | Docker image override |
+| `MGCHECK_LLM_PROVIDER` | *(v1)* LLM provider (`openai`, `anthropic`, or base URL) |
+| `MGCHECK_LLM_API_KEY` | *(v1)* LLM API key |
+| `MGCHECK_LLM_MODEL` | *(v1)* Model name (e.g., `claude-sonnet-4-20250514`) |
+
+---
+
+## CI / GitHub Actions
+
+### Direct CLI Usage
+
+```yaml
+name: Migration Safety Check
+on:
+  pull_request:
+    paths:
+      - 'prisma/migrations/**'
+      - 'drizzle/**'
+
+jobs:
+  check-migrations:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:16-alpine
+        env:
+          POSTGRES_PASSWORD: test
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Check migrations
+        run: npx mgcheck run ./prisma/migrations/ --ci --format json
+        env:
+          MGCHECK_DB_URL: postgresql://postgres:test@localhost:5432/postgres
+```
+
+### GitHub Action (Prebuilt)
+
+```yaml
+- name: Migration Guardian
+  uses: yourusername/mgcheck-action@v1
+  with:
+    migration-path: ./prisma/migrations/
+    seed-path: ./schema/base.sql
+```
+
+---
+
+## MCP Server (AI Agent Integration)
+
+mgcheck exposes an MCP server so AI coding agents (Claude Code, Cursor, etc.) can verify migrations inline:
+
+### Setup
+
+Add to your MCP configuration (e.g., `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "mgcheck": {
+      "command": "npx",
+      "args": ["mgcheck", "mcp"],
+      "env": {
+        "MGCHECK_DOCKER_IMAGE": "postgres:16-alpine"
+      }
+    }
+  }
+}
+```
+
+### Available Tools
+
+| Tool | Description |
+|---|---|
+| `check_migration` | Full pipeline: analyze + execute against shadow DB |
+| `analyze_migration` | Static analysis only (no Docker required) |
+
+The agent can call `check_migration` with the SQL content and get back a structured report with violations, explanations, and suggested fixes — all before the migration ever touches a real database.
+
+---
+
+## Migration Format Support
+
+| Format | Auto-Detected By | Status |
+|---|---|---|
+| **Raw SQL** (`.sql` files) | File extension | ✅ Supported |
+| **Prisma** | `migration.sql` in `prisma/migrations/*/` | ✅ Supported |
+| **Drizzle** | `meta/_journal.json` in directory | ✅ Supported |
+| MySQL / SQLite | — | 🔮 Planned |
+
+---
+
+## How It Works
+
+```
+┌──────────────┐     ┌──────────────┐     ┌──────────────┐
+│  Migration   │     │  Shadow DB   │     │    Rule      │
+│  Detector    │────▶│  Executor    │────▶│   Analyzer   │
+│              │     │  (Docker/    │     │  (10 rules)  │
+│ SQL/Prisma/  │     │   PGlite)    │     │              │
+│ Drizzle      │     └──────────────┘     └──────────────┘
+└──────────────┘            │                     │
+                            │                     │
+                            ▼                     ▼
+                     ┌──────────────────────────────┐
+                     │         Report Builder       │
+                     │  • Terminal (pretty)          │
+                     │  • JSON (CI/machine)          │
+                     │  • Markdown (PR comments)     │
+                     └──────────────────────────────┘
+                                   │
+                            ┌──────┴──────┐
+                            │ v1: LLM Fix │
+                            │ + Re-verify │
+                            └─────────────┘
+```
+
+1. **Detect**: Auto-detect migration format (raw SQL, Prisma, Drizzle)
+2. **Analyze**: Parse SQL into AST, run 10 safety rules
+3. **Execute**: Spin up disposable Postgres, run migration, capture result
+4. **Report**: Clear pass/fail with plain-English explanations
+5. *(v1)* **Fix**: LLM generates corrected migration, re-verified from scratch
+
+---
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/yourusername/mgcheck.git
+cd mgcheck
+npm install
+
+# Run in development
+npm run dev -- run ./test/fixtures/migrations/unsafe-create-index.sql
+
+# Run tests
+npm run test:unit              # No Docker needed
+npm run test:integration       # Requires Docker
+
+# Build
+npm run build
+
+# Link locally
+npm link
+mgcheck run ./your-migration.sql
+```
+
+---
+
+## Roadmap
+
+### v0 (Current) — Detection & Reporting
+- [x] CLI tool with `run` and `analyze` commands
+- [x] Auto-detect Raw SQL, Prisma, Drizzle formats
+- [x] Shadow DB via Docker + PGlite fallback
+- [x] 10 safety rules with plain-English explanations
+- [x] Terminal, JSON, Markdown output formats
+- [x] CI-compatible exit codes
+- [x] MCP server for AI agent integration
+- [x] GitHub Action
+
+### v1 — LLM Fix & Re-verify
+- [ ] Pluggable LLM backend (Claude, GPT, etc.)
+- [ ] Fix generation with structured output
+- [ ] Fresh shadow DB re-verification of fixes
+- [ ] Destructive operation guardrails (never auto-fix drops)
+- [ ] Single-attempt cap (no infinite loops)
+
+### v2 — Multi-Database & Beyond
+- [ ] MySQL support
+- [ ] SQLite support
+- [ ] Custom rule authoring API
+- [ ] Schema drift detection
+- [ ] Migration dependency graph
+
+---
+
+## Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
+
+```bash
+# Fork the repo, then:
+git checkout -b feat/my-feature
+npm test
+git commit -m "feat: add my feature"
+git push origin feat/my-feature
+# Open a Pull Request
+```
+
+---
+
+## License
+
+MIT © [Your Name]
+
+---
+
+<p align="center">
+  <strong>Stop shipping unsafe migrations. Start with <code>mgcheck</code>.</strong>
+</p>

package/dist/activity-log-ETNHCZ7B.js

@@ -0,0 +1,13 @@
+import {
+  LOG_FILE,
+  formatActivityEntry,
+  logActivity,
+  watchActivityLog
+} from "./chunk-3G3R2NM3.js";
+export {
+  LOG_FILE,
+  formatActivityEntry,
+  logActivity,
+  watchActivityLog
+};
+//# sourceMappingURL=activity-log-ETNHCZ7B.js.map

package/dist/activity-log-ETNHCZ7B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/applier-TLGJ6SZ2.js

@@ -0,0 +1,9 @@
+import {
+  applyToRealDatabase,
+  promptAndApplyIfConfirmed
+} from "./chunk-7ENQ5WVM.js";
+export {
+  applyToRealDatabase,
+  promptAndApplyIfConfirmed
+};
+//# sourceMappingURL=applier-TLGJ6SZ2.js.map

package/dist/applier-TLGJ6SZ2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-3G3R2NM3.js

@@ -0,0 +1,73 @@
+// src/core/activity-log.ts
+import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import os from "os";
+import chalk from "chalk";
+var LOG_DIR = join(os.homedir(), ".mgcheck");
+var LOG_FILE = join(LOG_DIR, "activity.log");
+function logActivity(entry) {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+  const line = JSON.stringify(entry) + "\n";
+  appendFileSync(LOG_FILE, line, "utf-8");
+}
+function watchActivityLog(handler) {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+  if (!existsSync(LOG_FILE)) {
+    appendFileSync(LOG_FILE, "", "utf-8");
+  }
+  let lastSize = statSync(LOG_FILE).size;
+  const interval = setInterval(() => {
+    try {
+      const currentSize = statSync(LOG_FILE).size;
+      if (currentSize > lastSize) {
+        const fd = readFileSync(LOG_FILE, "utf-8");
+        const newContent = fd.substring(lastSize);
+        lastSize = currentSize;
+        const lines = newContent.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            handler(entry);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }, 500);
+  return () => {
+    clearInterval(interval);
+  };
+}
+function formatActivityEntry(entry) {
+  const time = chalk.dim(`[${entry.timestamp}]`);
+  const tool = chalk.cyan(entry.tool);
+  const lines = [];
+  lines.push(`${time} ${tool} called`);
+  if (entry.statements.length > 0) {
+    for (const stmt of entry.statements) {
+      const truncated = stmt.length > 80 ? stmt.substring(0, 77) + "..." : stmt;
+      lines.push(chalk.dim("  \u2502 ") + chalk.white(truncated));
+    }
+  }
+  if (entry.passed) {
+    lines.push(chalk.dim("  \u2514\u2500 ") + chalk.green("\u2705 PASSED") + chalk.dim(` (${entry.violations} violations)`));
+  } else {
+    lines.push(
+      chalk.dim("  \u2514\u2500 ") + chalk.red("\u274C BLOCKED") + chalk.dim(` (${entry.errors} error${entry.errors !== 1 ? "s" : ""}, ${entry.warnings} warning${entry.warnings !== 1 ? "s" : ""})`)
+    );
+  }
+  return lines.join("\n");
+}
+
+export {
+  LOG_FILE,
+  logActivity,
+  watchActivityLog,
+  formatActivityEntry
+};
+//# sourceMappingURL=chunk-3G3R2NM3.js.map

package/dist/chunk-3G3R2NM3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/activity-log.ts"],"sourcesContent":["import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync, watchFile, unwatchFile } from 'node:fs';\nimport { join } from 'node:path';\nimport os from 'node:os';\nimport chalk from 'chalk';\n\nconst LOG_DIR = join(os.homedir(), '.mgcheck');\nconst LOG_FILE = join(LOG_DIR, 'activity.log');\n\nexport interface ActivityEntry {\n  timestamp: string;\n  tool: string;\n  summary: string;\n  violations: number;\n  errors: number;\n  warnings: number;\n  passed: boolean;\n  statements: string[];\n}\n\n/**\n * Append an activity entry to the shared log file.\n * Called by the MCP server when a tool is invoked.\n */\nexport function logActivity(entry: ActivityEntry): void {\n  if (!existsSync(LOG_DIR)) {\n    mkdirSync(LOG_DIR, { recursive: true });\n  }\n  const line = JSON.stringify(entry) + '\\n';\n  appendFileSync(LOG_FILE, line, 'utf-8');\n}\n\n/**\n * Watch the activity log and call the handler for each new entry.\n * Returns a cleanup function to stop watching.\n */\nexport function watchActivityLog(handler: (entry: ActivityEntry) => void): () => void {\n  if (!existsSync(LOG_DIR)) {\n    mkdirSync(LOG_DIR, { recursive: true });\n  }\n\n  // Create log file if it doesn't exist\n  if (!existsSync(LOG_FILE)) {\n    appendFileSync(LOG_FILE, '', 'utf-8');\n  }\n\n  // Track current file size to only read new content\n  let lastSize = statSync(LOG_FILE).size;\n\n  const interval = setInterval(() => {\n    try {\n      const currentSize = statSync(LOG_FILE).size;\n      if (currentSize > lastSize) {\n        // Read only the new bytes\n        const fd = readFileSync(LOG_FILE, 'utf-8');\n        const newContent = fd.substring(lastSize);\n        lastSize = currentSize;\n\n        const lines = newContent.split('\\n').filter((l) => l.trim());\n        for (const line of lines) {\n          try {\n            const entry: ActivityEntry = JSON.parse(line);\n            handler(entry);\n          } catch {\n            // Skip malformed lines\n          }\n        }\n      }\n    } catch {\n      // File may be temporarily unavailable\n    }\n  }, 500);\n\n  return () => {\n    clearInterval(interval);\n  };\n}\n\n/**\n * Format an activity entry for terminal display.\n */\nexport function formatActivityEntry(entry: ActivityEntry): string {\n  const time = chalk.dim(`[${entry.timestamp}]`);\n  const tool = chalk.cyan(entry.tool);\n\n  const lines: string[] = [];\n  lines.push(`${time} ${tool} called`);\n\n  // Show each statement\n  if (entry.statements.length > 0) {\n    for (const stmt of entry.statements) {\n      const truncated = stmt.length > 80 ? stmt.substring(0, 77) + '...' : stmt;\n      lines.push(chalk.dim('  │ ') + chalk.white(truncated));\n    }\n  }\n\n  // Show result\n  if (entry.passed) {\n    lines.push(chalk.dim('  └─ ') + chalk.green('✅ PASSED') + chalk.dim(` (${entry.violations} violations)`));\n  } else {\n    lines.push(\n      chalk.dim('  └─ ') +\n        chalk.red('❌ BLOCKED') +\n        chalk.dim(` (${entry.errors} error${entry.errors !== 1 ? 's' : ''}, ${entry.warnings} warning${entry.warnings !== 1 ? 's' : ''})`)\n    );\n  }\n\n  return lines.join('\\n');\n}\n\nexport { LOG_FILE };\n"],"mappings":";AAAA,SAAS,YAAY,WAAW,gBAAgB,cAAc,gBAAwC;AACtG,SAAS,YAAY;AACrB,OAAO,QAAQ;AACf,OAAO,WAAW;AAElB,IAAM,UAAU,KAAK,GAAG,QAAQ,GAAG,UAAU;AAC7C,IAAM,WAAW,KAAK,SAAS,cAAc;AAiBtC,SAAS,YAAY,OAA4B;AACtD,MAAI,CAAC,WAAW,OAAO,GAAG;AACxB,cAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AACA,QAAM,OAAO,KAAK,UAAU,KAAK,IAAI;AACrC,iBAAe,UAAU,MAAM,OAAO;AACxC;AAMO,SAAS,iBAAiB,SAAqD;AACpF,MAAI,CAAC,WAAW,OAAO,GAAG;AACxB,cAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAGA,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,mBAAe,UAAU,IAAI,OAAO;AAAA,EACtC;AAGA,MAAI,WAAW,SAAS,QAAQ,EAAE;AAElC,QAAM,WAAW,YAAY,MAAM;AACjC,QAAI;AACF,YAAM,cAAc,SAAS,QAAQ,EAAE;AACvC,UAAI,cAAc,UAAU;AAE1B,cAAM,KAAK,aAAa,UAAU,OAAO;AACzC,cAAM,aAAa,GAAG,UAAU,QAAQ;AACxC,mBAAW;AAEX,cAAM,QAAQ,WAAW,MAAM,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3D,mBAAW,QAAQ,OAAO;AACxB,cAAI;AACF,kBAAM,QAAuB,KAAK,MAAM,IAAI;AAC5C,oBAAQ,KAAK;AAAA,UACf,QAAQ;AAAA,UAER;AAAA,QACF;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF,GAAG,GAAG;AAEN,SAAO,MAAM;AACX,kBAAc,QAAQ;AAAA,EACxB;AACF;AAKO,SAAS,oBAAoB,OAA8B;AAChE,QAAM,OAAO,MAAM,IAAI,IAAI,MAAM,SAAS,GAAG;AAC7C,QAAM,OAAO,MAAM,KAAK,MAAM,IAAI;AAElC,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,GAAG,IAAI,IAAI,IAAI,SAAS;AAGnC,MAAI,MAAM,WAAW,SAAS,GAAG;AAC/B,eAAW,QAAQ,MAAM,YAAY;AACnC,YAAM,YAAY,KAAK,SAAS,KAAK,KAAK,UAAU,GAAG,EAAE,IAAI,QAAQ;AACrE,YAAM,KAAK,MAAM,IAAI,WAAM,IAAI,MAAM,MAAM,SAAS,CAAC;AAAA,IACvD;AAAA,EACF;AAGA,MAAI,MAAM,QAAQ;AAChB,UAAM,KAAK,MAAM,IAAI,iBAAO,IAAI,MAAM,MAAM,eAAU,IAAI,MAAM,IAAI,KAAK,MAAM,UAAU,cAAc,CAAC;AAAA,EAC1G,OAAO;AACL,UAAM;AAAA,MACJ,MAAM,IAAI,iBAAO,IACf,MAAM,IAAI,gBAAW,IACrB,MAAM,IAAI,KAAK,MAAM,MAAM,SAAS,MAAM,WAAW,IAAI,MAAM,EAAE,KAAK,MAAM,QAAQ,WAAW,MAAM,aAAa,IAAI,MAAM,EAAE,GAAG;AAAA,IACrI;AAAA,EACF;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;","names":[]}