distyll 0.1.0

package/CONTRIBUTING.md

@@ -0,0 +1,159 @@
+# Contributing to Distyll
+
+## Development Setup
+
+```bash
+# Clone the repo
+git clone https://github.com/your-org/distyll.git
+cd distyll
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Watch mode for development
+npm run dev          # TypeScript watch
+npm run test:watch   # Vitest watch
+```
+
+## Project Structure
+
+```
+src/
+  cli.ts              # CLI entry point (commander)
+  scanner.ts          # File scanning orchestration
+  parser.ts           # Tree-sitter AST parsing
+  scorer.ts           # Slop score calculation
+  config.ts           # .distyll.json config loading
+  formatter.ts        # Text and JSON output formatting
+  errors.ts           # Centralized error handling
+  types.ts            # Shared TypeScript types
+  cache.ts            # Score history caching
+  git.ts              # Git diff integration
+  commands/           # CLI subcommands (scan, diff, hook, ci, init, fingerprint)
+  rules/              # Detection rules (one file per rule)
+  fixes/              # Fix suggestion generators
+  fingerprint/        # Style profile analysis
+  languages/          # Language-specific tree-sitter configs
+  reporters/          # Output formatters (terminal, GitHub)
+tests/
+  *.test.ts           # Test files matching src/ structure
+```
+
+## Adding a New Rule
+
+1. Create `src/rules/your-rule-name.ts`:
+
+```typescript
+import type { Rule, Finding } from '../types';
+import { findNodes } from '../parser';
+
+export const yourRuleName: Rule = {
+  name: 'your-rule-name',
+  description: 'What this rule detects',
+  severity: 'warning',
+  check(tree, source, filePath): Finding[] {
+    const findings: Finding[] = [];
+
+    // Use tree-sitter AST to find patterns
+    const nodes = findNodes(tree.rootNode, 'some_node_type');
+
+    for (const node of nodes) {
+      // Your detection logic here
+      // Be conservative — only flag clear AI slop, not legitimate code
+      findings.push({
+        file: filePath,
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        rule: 'your-rule-name',
+        severity: 'warning',
+        message: 'Clear, actionable description of the issue',
+      });
+    }
+
+    return findings;
+  },
+};
+```
+
+2. Register the rule in `src/rules/index.ts`:
+
+```typescript
+import { yourRuleName } from './your-rule-name';
+
+export const allRules: Rule[] = [
+  // ... existing rules
+  yourRuleName,
+];
+```
+
+3. Write tests in `tests/rules/your-rule-name.test.ts`:
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { scanFile } from '../../src/scanner';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+function createTempFile(content: string, ext = '.js'): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-test-'));
+  const filePath = path.join(dir, `test${ext}`);
+  fs.writeFileSync(filePath, content);
+  return filePath;
+}
+
+describe('your-rule-name', () => {
+  it('flags the slop pattern', () => {
+    const file = createTempFile('/* code that triggers rule */');
+    const result = scanFile(file);
+    const findings = result!.findings.filter(f => f.rule === 'your-rule-name');
+    expect(findings.length).toBeGreaterThan(0);
+  });
+
+  it('does not flag legitimate code', () => {
+    const file = createTempFile('/* clean code */');
+    const result = scanFile(file);
+    const findings = result!.findings.filter(f => f.rule === 'your-rule-name');
+    expect(findings).toHaveLength(0);
+  });
+});
+```
+
+4. Run `npm test` to verify.
+
+## Guidelines
+
+### False Positives Are Bugs
+
+The #1 priority is avoiding false positives. Every rule should be conservative — it's better to miss some real slop than to flag legitimate code. Test with real-world codebases before submitting.
+
+### Rule Quality Checklist
+
+- [ ] Only flags patterns that are clearly AI-generated slop
+- [ ] Does not trigger on well-known idioms or framework patterns
+- [ ] Has at least one test for a true positive and one for a true negative
+- [ ] Includes a clear, actionable message explaining what's wrong
+- [ ] Works for all supported languages where the pattern applies
+
+### Code Style
+
+- TypeScript strict mode
+- No `any` types except for tree-sitter grammar imports
+- Prefer `const` over `let`
+- Use early returns over nested conditionals
+
+### Testing
+
+```bash
+npm test                 # Run all tests
+npm run test:watch       # Watch mode
+npx vitest run tests/rules/your-rule.test.ts  # Single file
+```

package/POSTMORTEM.json

@@ -0,0 +1,60 @@
+{
+  "weakest_link": {
+    "what": "Fix suggestions are only implemented for 1 of 12 rules (unnecessary-try-catch has a real fix; single-use-wrapper works but is simple; verbose-comments and unused-imports fix files exist but are stubs). The landing page and product idea promise 'Fix suggestions with one-click apply' as a key differentiator over free OSS tools, but 10 of 12 rules produce no fix.",
+    "where": "src/fixes/ directory \u2014 only unnecessary-try-catch.ts and single-use-wrapper.ts have real implementations; verbose-comments.ts and unused-imports.ts are stub files",
+    "impact": "Fix suggestions are positioned as THE paid-tier differentiator over free alternatives (AI-SLOP-Detector, KarpeSlop). Without them, the free tier and the pro tier deliver nearly identical value. Users who see 'Fix: ...' on one finding but not the other 11 will feel the tool is incomplete.",
+    "fix": "Implement fix generators for the 4 highest-signal rules: unused-imports (remove the import line), redundant-else-return (remove the else wrapper), verbose-comments (delete the comment), and dead-code-paths (remove unreachable lines). These are all straightforward AST-to-text transforms."
+  },
+  "one_and_done_risk": "The slop score of 100/100 on a single trivial wrapper function is immediately discrediting. A user runs `distyll scan` on a real project for the first time and sees scores of 60-80 on codebases they consider clean \u2014 because the scoring formula (weighted sum / LOC * 100) is hypersensitive on small files and doesn't calibrate against project size. If the first scan produces a number that feels wrong, the user stops trusting the tool entirely. The score needs to feel earned, not alarmist. Additionally, the core value proposition IS delivered \u2014 AST-based detection works, findings are real, and the rules are conservative \u2014 but the numeric score undermines credibility before users discover the quality underneath.",
+  "hn_skeptic_comment": "This is just ESLint with a marketing rebrand. Half of these 'AI slop patterns' are things ESLint already catches (unused imports, dead code paths, redundant else). The 'hallucinated imports' rule is just checking if a module exists \u2014 TypeScript's compiler already does this. The 'slop score' is a vanity metric with no calibration data \u2014 what does 42 mean? Is that good? Compared to what? And the 'style fingerprinting' is just computing averages of function length and naming conventions, which SonarQube has done for a decade. The only genuinely novel rule here is 'verbose comments restating code,' and even that could be an ESLint plugin in 50 lines. At $9/user/month you're charging for what should be a free ESLint config. Also, the 'Pro' tier promises LLM-powered features but they're not implemented \u2014 it's just heuristic analysis all the way down. Ship the ESLint plugin for free, get adoption, then maybe charge for the dashboard.",
+  "most_likely_failure_mode": {
+    "mode": "retention",
+    "explanation": "Users install it, run a scan, see findings, maybe fix a few things \u2014 then never run it again because it doesn't integrate into their existing workflow seamlessly enough. The pre-commit hook is opt-in, the CI integration requires manual setup, and the slop score doesn't connect to any feedback loop (no PR comments, no Slack notifications, no dashboard showing trends over time in the free tier). The tool produces output but doesn't create a habit. Code quality tools only stick when they're invisible and automatic \u2014 ESLint succeeds because it runs in your editor on every keystroke, not because you remember to invoke it.",
+    "mitigation": "Ship a VS Code extension that shows inline warnings as you type (like ESLint). Make the GitHub Action dead simple (one-line workflow file). Add a `distyll watch` mode for local development. The goal is zero-friction continuous feedback, not periodic scanning."
+  },
+  "two_hour_fix_list": [
+    {
+      "priority": 1,
+      "file": "src/scorer.ts",
+      "change": "Recalibrate the scoring formula. Currently `min(100, round(weightedSum / totalLOC * 100))` produces 100 on a 1-line file with 1 finding. Add a minimum LOC floor (e.g., max(totalLOC, 50)) and apply a logarithmic curve so scores feel proportional. Test against 3-4 real open-source repos to ensure scores land in a believable 10-60 range for typical codebases.",
+      "why": "The first number users see IS the product. A score of 100 on a trivial file destroys trust instantly. Calibrated scores that feel fair make users share their results ('we got our slop score down to 23!').",
+      "time": "30min"
+    },
+    {
+      "priority": 2,
+      "file": "src/fixes/unused-imports.ts, src/fixes/verbose-comments.ts",
+      "change": "Implement the two easiest fix generators: unused-imports (delete the import line from source) and verbose-comments (delete the comment line). Both are simple string operations given the line number from the finding.",
+      "why": "Fix suggestions are the #1 differentiator over free tools. Even 4/12 rules having fixes is better than 2/12.",
+      "time": "25min"
+    },
+    {
+      "priority": 3,
+      "file": "site/index.html",
+      "change": "Replace the hardcoded GitHub link (https://github.com/distyll-dev/distyll) with a real repo URL or a '#' placeholder. Add actual terminal demo output to the animated terminal instead of relying solely on JS animation (provide a static fallback). The terminal is empty if JS fails.",
+      "why": "A broken GitHub link and an empty terminal widget on the landing page signal 'vaporware' to the exact skeptical developer audience you're targeting.",
+      "time": "15min"
+    },
+    {
+      "priority": 4,
+      "file": "README.md",
+      "change": "Add a 'Sample Output' section showing real terminal output from running distyll on a known-sloppy file. Show the before (sloppy code) and after (distyll output with findings and score). This is the single most convincing thing a README can contain for a CLI tool.",
+      "why": "Developers evaluate CLI tools by reading the README on npm/GitHub. If they can't see what the output looks like in 5 seconds, they move on.",
+      "time": "15min"
+    },
+    {
+      "priority": 5,
+      "file": "package.json",
+      "change": "Verify `npm pack` and `npx distyll` work end-to-end. The bin entry points to dist/cli.js but tree-sitter native bindings may fail on install for users without node-gyp/build tools. Consider adding a postinstall check or documenting the native dependency requirement prominently.",
+      "why": "If `npx distyll scan .` fails on first try due to native build errors, you lose 80% of potential users at the install step. Tree-sitter's native bindings are the #1 adoption barrier for this tool.",
+      "time": "20min"
+    }
+  ],
+  "scores": {
+    "first_impression": 7,
+    "core_functionality": 7,
+    "code_quality": 8,
+    "production_readiness": 5,
+    "market_fit": 6
+  },
+  "overall_assessment": "Distyll is a genuinely well-engineered prototype \u2014 the tree-sitter AST analysis is real, the 12 rules are thoughtfully conservative, 85 tests pass, and the CLI works end-to-end. The code quality is notably high for a prototype. But it ships with two credibility-killing issues: a scoring formula that produces absurd numbers on real code, and fix suggestions that are mostly unimplemented despite being the headline differentiator. I would use this on a side project to audit AI-generated PRs, but I wouldn't pay $9/month for it \u2014 ESLint + a careful code review gets me 70% of the way there for free. The path to a real product is: nail the scoring calibration so the number means something, finish the fix suggestions, and ship a GitHub Action that 'just works' in one line."
+}

package/README.md

@@ -0,0 +1,218 @@
+# Distyll
+
+Catch AI-generated code slop before it ships — a quality gate for the vibe-coding era.
+
+Distyll analyzes pull requests for AI-generated code anti-patterns and assigns a **slop score** (0-100) with specific, actionable fixes. It uses AST-based pattern detection via tree-sitter to catch structural issues that traditional linters miss.
+
+## Quick Start
+
+```bash
+# Install globally
+npm install -g distyll
+
+# Scan a project
+distyll scan .
+
+# Or use npx without installing
+npx distyll scan .
+```
+
+## What It Detects
+
+Distyll ships with 12 detection rules targeting patterns unique to AI-generated code:
+
+| Rule | What It Catches |
+|------|----------------|
+| `unnecessary-try-catch` | Try-catch blocks wrapping synchronous pure functions that cannot throw |
+| `single-use-wrapper` | Functions that wrap a single call and are only used once — pointless abstraction |
+| `verbose-comments` | Comments that restate the code verbatim (e.g., `// increment counter` above `counter++`) |
+| `unused-imports` | Import statements for modules/symbols never referenced in the file |
+| `single-option-object` | Options/config objects that only ever use one property — over-engineering |
+| `redundant-else-return` | `else` blocks after a `return` statement — the else is unnecessary |
+| `hallucinated-imports` | Imports of modules that don't exist in the project or standard library |
+| `near-duplicate-functions` | Function bodies that are >85% similar — copy-paste with subtle variations |
+| `over-defensive-nulls` | Null/undefined checks on values that are already guaranteed non-null |
+| `magic-values` | Magic strings and numbers used inline instead of named constants |
+| `dead-code-paths` | Unreachable code after unconditional return/throw/break/continue |
+| `excessive-comments` | Files where >50% of lines have trailing comments — a hallmark of AI verbosity |
+
+Every rule is **conservative by design**. The #1 complaint about existing slop detectors is false positives. Distyll only flags patterns that are clearly AI-generated bloat, not legitimate code.
+
+## CLI Reference
+
+### `distyll scan <paths...>`
+
+Scan files or directories for slop patterns.
+
+```bash
+distyll scan .                          # Scan current directory
+distyll scan src/ lib/                  # Scan specific directories
+distyll scan src/utils.ts               # Scan a single file
+distyll scan . --format json            # JSON output
+distyll scan . --threshold 50           # Exit code 1 if score > 50
+distyll scan . --style                  # Compare against style profile
+distyll scan . --verbose                # Show parsing details per file
+distyll scan . --quiet                  # Output only the score number
+```
+
+**Options:**
+- `-f, --format <format>` — Output format: `text` (default) or `json`
+- `-t, --threshold <number>` — Exit with code 1 if slop score exceeds this value
+- `-s, --style` — Compare against project style profile (run `distyll fingerprint` first)
+- `-v, --verbose` — Show AST parsing details and rule execution time per file
+- `-q, --quiet` — Only output the slop score number (useful for scripting)
+
+### `distyll diff`
+
+Scan only changed lines in a git diff. Only reports findings on new/modified code.
+
+```bash
+distyll diff                            # Scan unstaged changes
+distyll diff --staged                   # Scan staged changes only
+distyll diff --ref main                 # Diff against a branch
+distyll diff --ref HEAD~3               # Diff against 3 commits ago
+```
+
+**Options:**
+- `-s, --staged` — Scan staged changes only
+- `-r, --ref <ref>` — Git ref to diff against
+- `-f, --format <format>` — Output format: `text` or `json`
+- `-t, --threshold <number>` — Exit with code 1 if score exceeds threshold
+- `-v, --verbose` — Show detailed info
+- `-q, --quiet` — Output only the score number
+
+### `distyll hook install`
+
+Install a pre-commit hook that blocks commits above a slop threshold.
+
+```bash
+distyll hook install                    # Default threshold: 70
+distyll hook install --threshold 50     # Custom threshold
+distyll hook uninstall                  # Remove the hook
+```
+
+### `distyll ci`
+
+Run in CI mode with GitHub Actions-optimized output.
+
+```bash
+distyll ci                              # Annotations format (default)
+distyll ci --format summary             # Markdown summary
+distyll ci --format json                # JSON output
+distyll ci --threshold 60               # Fail CI if score > 60
+distyll ci --ref main                   # Diff against main branch
+```
+
+### `distyll fingerprint [dir]`
+
+Analyze your codebase to build a style profile. This captures your team's actual patterns (function length, naming conventions, comment density, etc.) so `--style` mode can flag deviations.
+
+```bash
+distyll fingerprint                     # Analyze current directory
+distyll fingerprint ./src               # Analyze specific directory
+```
+
+The profile is stored in `.distyll/profile.json`.
+
+### `distyll init [dir]`
+
+Initialize Distyll in a project. Creates `.distyll.json` config and `.distyll/` cache directory.
+
+```bash
+distyll init                            # Initialize in current directory
+distyll init ./my-project               # Initialize in specific directory
+```
+
+## Configuration
+
+Create a `.distyll.json` file in your project root (or run `distyll init`):
+
+```json
+{
+  "rules": {
+    "unnecessary-try-catch": "error",
+    "verbose-comments": "warn",
+    "magic-values": "off"
+  },
+  "threshold": 70,
+  "ignore": [
+    "**/generated/**",
+    "**/migrations/**"
+  ]
+}
+```
+
+### Config Options
+
+- **`rules`** — Override severity or disable rules. Values: `"off"`, `"warn"`, `"error"`
+- **`threshold`** — Default slop score threshold for hooks and CI
+- **`ignore`** — Additional glob patterns to exclude from scanning (node_modules, dist, build, and vendor are always excluded)
+
+## GitHub Actions
+
+Add Distyll to your CI pipeline. Create `.github/workflows/distyll.yml`:
+
+```yaml
+name: Distyll Slop Check
+on: [pull_request]
+
+jobs:
+  distyll:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+      - run: npm install -g distyll
+      - run: distyll ci --ref origin/main --threshold 50
+```
+
+Or use the bundled action:
+
+```yaml
+- uses: ./action.yml
+  with:
+    threshold: 50
+```
+
+## Scoring
+
+The slop score (0-100) is calculated from weighted findings normalized by lines of code:
+
+- **Info** findings: weight 1
+- **Warning** findings: weight 3
+- **Error** findings: weight 5
+
+Formula: `min(100, round(weightedSum / totalLOC * 100))`
+
+| Score | Rating | Meaning |
+|-------|--------|---------|
+| 0-20 | Clean | Minimal AI slop detected |
+| 21-50 | Moderate | Some patterns worth reviewing |
+| 51-100 | High | Significant AI-generated bloat |
+
+## Supported Languages
+
+- JavaScript (`.js`, `.mjs`, `.cjs`)
+- TypeScript (`.ts`, `.tsx`)
+- Python (`.py`)
+
+## How It Compares
+
+| Feature | Distyll | ESLint | CodeRabbit | SonarQube |
+|---------|---------|--------|------------|-----------|
+| AI slop detection | 12 rules | No | Generic | No |
+| Slop score | 0-100 | No | No | Complexity only |
+| Fix suggestions | Yes | Some | Yes | Some |
+| Style fingerprinting | Yes | No | No | No |
+| Git hook | Built-in | Via plugin | No | No |
+| CI integration | Native | Native | Native | Native |
+| Offline/local-first | Yes | Yes | No | Self-host |
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Git (for `diff`, `hook`, and `ci` commands)

package/SETUP.md

@@ -0,0 +1,79 @@
+# Distyll — Setup Guide
+
+## Prerequisites
+
+- **Node.js 18+** — [Download here](https://nodejs.org/)
+- **npm** (comes with Node.js)
+- A C++ compiler for native modules (tree-sitter):
+  - **macOS**: `xcode-select --install`
+  - **Ubuntu/Debian**: `sudo apt install build-essential`
+  - **Windows**: Install Visual Studio Build Tools
+
+## Quick Start
+
+```bash
+# Clone and install
+cd distyll
+npm install
+
+# Build the TypeScript source
+npm run build
+
+# Scan a file
+node dist/cli.js scan path/to/your/file.js
+
+# Scan a directory
+node dist/cli.js scan src/
+
+# JSON output
+node dist/cli.js scan src/ --format json
+
+# Fail if slop score exceeds threshold (for CI)
+node dist/cli.js scan src/ --threshold 50
+```
+
+## Global Installation (optional)
+
+```bash
+npm install -g .
+distyll scan src/
+```
+
+## What It Does
+
+Distyll scans JavaScript and TypeScript files for AI-generated code anti-patterns and gives you a **slop score** from 0-100.
+
+### Detection Rules
+
+| Rule | Severity | What it catches |
+|------|----------|----------------|
+| `unnecessary-try-catch` | warning | try-catch blocks wrapping code that can't throw |
+| `single-use-wrapper` | warning | Functions that only delegate to another function |
+| `verbose-comments` | info | Comments that restate the code they describe |
+| `unused-imports` | warning | Imported names never used in the file |
+| `single-option-object` | info | Destructured options objects with only 1 property |
+| `redundant-else-return` | info | Else blocks after if blocks that return/throw |
+
+## Running Tests
+
+```bash
+npm test
+```
+
+## Troubleshooting
+
+### `node-gyp` build errors during `npm install`
+
+tree-sitter requires native compilation. Make sure you have:
+- Python 3 installed
+- A C++ compiler (see Prerequisites above)
+
+On macOS, run: `xcode-select --install`
+
+### "Unsupported language" warnings
+
+Distyll currently supports `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs` files. Other file types are silently skipped.
+
+### No findings on a file
+
+The rules are intentionally conservative to avoid false positives. A clean score means the code doesn't exhibit the specific AI slop patterns Distyll checks for.

package/action.yml

@@ -0,0 +1,37 @@
+name: 'Distyll Slop Detector'
+description: 'Detect AI-generated code anti-patterns in pull requests'
+author: 'Distyll'
+
+inputs:
+  threshold:
+    description: 'Maximum allowed slop score (0-100). Fails the check if exceeded.'
+    required: false
+    default: '70'
+  format:
+    description: 'Output format: annotations, json, or summary'
+    required: false
+    default: 'annotations'
+  ref:
+    description: 'Git ref to diff against (e.g., origin/main). Defaults to HEAD~1.'
+    required: false
+    default: 'HEAD~1'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '18'
+
+    - name: Install Distyll
+      shell: bash
+      run: npm install -g distyll
+
+    - name: Run Distyll
+      shell: bash
+      run: distyll ci --ref "${{ inputs.ref }}" --format "${{ inputs.format }}" --threshold "${{ inputs.threshold }}"
+
+branding:
+  icon: 'filter'
+  color: 'purple'

package/dist/cache.d.ts

@@ -0,0 +1,26 @@
+interface CacheEntry {
+    timestamp: string;
+    ref?: string;
+    branch?: string;
+    score: number;
+    totalFindings: number;
+    fileCount: number;
+}
+interface CacheData {
+    entries: CacheEntry[];
+}
+export declare function loadCache(repoRoot: string): CacheData;
+export declare function saveScore(repoRoot: string, score: number, totalFindings: number, fileCount: number, ref?: string, branch?: string): void;
+export interface TrendSummary {
+    current: number;
+    previous: number | null;
+    delta: number | null;
+    direction: 'improving' | 'worsening' | 'stable' | 'first-scan';
+    history: {
+        timestamp: string;
+        score: number;
+    }[];
+}
+export declare function getTrend(repoRoot: string, currentScore: number): TrendSummary;
+export {};
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAGA,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,SAAS;IACjB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAiBD,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAYrD;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,IAAI,CAsBN;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,YAAY,CAAC;IAC/D,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACjD;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,YAAY,CA6B7E"}