jev-chess 1.0.0

package/ARCHITECTURE.md

@@ -0,0 +1,148 @@
+# Architectural Design: Chess Moves & Games with TypeSafe AI
+
+## 1. Executive Summary & Core Philosophy
+
+Building chess software with AI has historically faced two opposite extremes:
+1. **Classical Chess Engines (Stockfish, Komodo):** Masterful at minimax tree search and bitboard physics, but opaque and purely numeric. A scalar evaluation like `+1.4` cannot explain *why* a move is stylistically brilliant, prophylactic, psychological, or intuitive.
+2. **Generative LLMs (System Two / Chatbots):** Prone to hallucinating illegal coordinates, moving through pieces, losing track of castling rights, and taking 2–5 seconds with high token costs.
+
+**TypeSafe AI (System One / Jev)** introduces a third, superior paradigm: **AI-Powered Software**.
+
+```
+┌────────────────────────────────────────────────────────┐
+│                   DETERMINISTIC CODE                   │
+│   • Board Physics & Move Legality (chess.js / bitboard)│
+│   • FEN / SAN / PGN Parsing & Clock Management         │
+│   • Check, Checkmate & Draw Detection                  │
+└───────────────────────────┬────────────────────────────┘
+                            │ Structured State Context
+                            ▼
+┌────────────────────────────────────────────────────────┐
+│             TYPESAFE SYSTEM ONE (jev-latest)           │
+│   • Fast (~100ms) Semantic & Qualitative Judgments     │
+│   • Typed Primitives: Choice, Score, Noul               │
+│   • Calibrated Probabilities & Peaked Confidence       │
+│   • 100% Guaranteed Schema Conformance                 │
+└───────────────────────────┬────────────────────────────┘
+                            │ Typed Judgments
+                            ▼
+┌────────────────────────────────────────────────────────┐
+│                APPLICATION ORCHESTRATION               │
+│   • Natural Language Move Selection (Confidence-Gated) │
+│   • Persona-Driven AI Opponents (Composite Scoring)    │
+│   • Dynamic Commentary Badges & Game Tension Tracking  │
+│   • Post-Game Blunder Diagnostics & Mistake Taxonomy   │
+└────────────────────────────────────────────────────────┘
+```
+
+> **The Golden Rule:** Keep deterministic rules, execution, calculations, and side-effects in code. Insert System One where semantic understanding, natural language, and human common-sense judgment are needed.
+
+---
+
+## 2. Designing Chess Moves (The Atomic Level)
+
+### 2.1 State Representation
+State is the context presented to Jev. In chess, raw board graphics or cryptic FEN strings alone lack the semantic relationships the model needs. We structure the state cleanly into typed JSON:
+
+```json
+{
+  "user_intent": "Develop my knight to attack their e5 pawn",
+  "board": {
+    "turn": "white",
+    "move_number": 2,
+    "in_check": false,
+    "material_balance": "Equal",
+    "game_phase": "opening",
+    "fen": "rnbqkbnr/pppp1ppp/8/4p3/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2"
+  },
+  "legal_moves": [
+    { "san": "Nf3", "description": "Knight on g1 moves to f3" },
+    { "san": "Nc3", "description": "Knight on b1 moves to c3" },
+    { "san": "d4",  "description": "Pawn on d2 moves to d4" }
+  ]
+}
+```
+
+### 2.2 Pattern 1: Move Intent Resolution ("Select Instead of Generate")
+Traditional chatbot interfaces try to make LLMs generate algebraic notation directly from text (e.g. "play e4"), which fails when positions get complicated. 
+With TypeSafe, we use the **Select Instead of Generate** pattern:
+1. Code deterministically generates all legal moves in the current position.
+2. Jev selects from the candidate pool using `Choice`.
+3. If the user command is vague or illegal, Jev returns `none` or a low confidence score, triggering an interactive clarification prompt in code.
+
+```typescript
+const response = await client.systemOne({
+  state,
+  questions: {
+    matched_move: choice(
+      "Which legal chess move in `legal_moves` best fulfills the player's command in `user_intent`?",
+      criteria
+    ),
+  },
+});
+
+// Confidence-Gated Ambiguity Resolution
+if (response.answers.matched_move.choice === "none" || response.answers.matched_move.confidence < 0.6) {
+  promptUserForDisambiguation(response.answers.matched_move.probabilities);
+} else {
+  engine.makeMove(response.answers.matched_move.choice);
+}
+```
+
+### 2.3 Pattern 2: Multi-Dimensional Qualitative Assessment
+To explain moves to humans or show real-time broadcast commentary, we ask **parallel atomic questions** over the same state:
+
+| Dimension | Primitive | Levels / Criteria |
+| :--- | :--- | :--- |
+| **Tactical Sharpness** | `Score` (0-3) | 0: Quiet/prophylactic, 1: Solid consolidation, 2: Sharp tension, 3: Explosive sacrifice |
+| **Strategic Theme** | `Choice` | `pawn_break`, `piece_activation`, `prophylaxis`, `tactical_strike`, `king_hunt`, `simplification` |
+| **King Threat** | `Noul` (0.0-1.0) | Probability the move initiates a direct assault on the opposing monarch |
+| **Psychological Pressure** | `Noul` (0.0-1.0) | Probability the move provokes tactical panic or forces narrow only-moves |
+
+All 4 questions are evaluated in parallel in **one single network call (~100ms)**.
+
+---
+
+## 3. Designing Chess Games (The System Level)
+
+### 3.1 Pattern 3: Persona Opponents via Composite Scoring
+How do you build AI opponents that play with the distinct personalities of Mikhail Tal, Tigran Petrosian, or Jose Raul Capablanca without training expensive models?
+
+Use the **Composite Scoring Pattern**:
+1. For each candidate move, compute atomic scores:
+   - `aggression` (`Score` 0–3)
+   - `prophylaxis` (`Score` 0–3)
+   - `complexity` (`Score` 0–3)
+   - `material_greed` (`Noul` 0–1)
+2. Define client-side weight vectors for each persona:
+   - **Mikhail Tal (The Magician from Riga):**
+     $$\text{Score} = 0.45 \cdot \text{agg} - 0.15 \cdot \text{pro} + 0.50 \cdot \text{comp} - 0.20 \cdot \text{greed}$$
+   - **Tigran Petrosian (Iron Tigran):**
+     $$\text{Score} = 0.05 \cdot \text{agg} + 0.65 \cdot \text{pro} - 0.30 \cdot \text{comp} + 0.20 \cdot \text{greed}$$
+   - **José Raúl Capablanca (The Chess Machine):**
+     $$\text{Score} = 0.20 \cdot \text{agg} + 0.35 \cdot \text{pro} - 0.40 \cdot \text{comp} + 0.45 \cdot \text{greed}$$
+3. Code selects the move with the highest composite score.
+
+> [!TIP]
+> **Zero Inference Rerun:** If you want to make Mikhail Tal 15% more wild or Petrosian 10% more cautious, you simply adjust the weights in client code. The underlying model judgments remain reusable and unchanged.
+
+### 3.2 Pattern 4: Post-Game Blunder & Tactical Review (The Cascade Pattern)
+When an evaluation drops or a blunder occurs, traditional engines output a cold numeric penalty (`-4.2`). TypeSafe runs a diagnostic cascade:
+- `Choice(mistake_archetype)`:
+  - `tactical_blindness` (missed a fork, pin, skewer)
+  - `poisoned_pawn_greed` (grabbed pawns while king was exposed)
+  - `over_extension` (pushed pawns without support)
+  - `passive_concession` (yielded tempo and space)
+  - `king_safety_negligence` (compromised shelter)
+- `Score(defensive_difficulty)`:
+  - 0: Simple defense $\rightarrow$ 3: Hopeless human defense
+- Code maps the typed diagnosis directly into actionable coaching advice.
+
+---
+
+## 4. Verification & Testing Standards
+
+All move selection and game orchestration pipelines must obey three non-negotiable guarantees:
+1. **Zero Illegal Moves:** Every move presented to or selected by TypeSafe originates from the deterministic legal move generator.
+2. **Deterministic Schema Safety:** No regex parsing of LLM markdown or JSON extraction blocks. System One returns typed fields directly.
+3. **Graceful Degraded Mode:** If network connection or API keys are absent, the system falls back to calibrated simulation while preserving identical schemas.

package/README.md

@@ -0,0 +1,109 @@
+# jev-chess
+
+Chess moves, evaluations, persona opponents, and game classification using TypeSafe AI System One models.
+
+```bash
+npm install jev-chess
+```
+
+## Quick start
+
+```ts
+import { ChessEngine, MoveResolver, MoveEvaluator, PersonaEngine } from "jev-chess";
+
+const engine = new ChessEngine();
+const resolver = new MoveResolver();
+const evaluator = new MoveEvaluator();
+const personas = new PersonaEngine();
+
+// Natural language intent -> verified legal move
+const { matchedMove } = await resolver.resolveIntent(engine, "Develop knight to attack center");
+const move = engine.makeMove(matchedMove.san);
+
+// Parallel System One evaluation
+const evalResult = await evaluator.evaluateMove(engine, move);
+console.log(`${move.san}: ${evalResult.commentaryBadge} (Sharpness: ${evalResult.tacticalSharpness.score}/3.0)`);
+
+// Opponent response via composite scoring
+const { selectedMove, rationale } = await personas.selectMove(engine, "tal");
+engine.makeMove(selectedMove.san);
+console.log(`Tal plays ${selectedMove.san}: ${rationale}`);
+```
+
+`resolveIntent()` maps natural language to verified legal moves via `Choice`. `evaluateMove()` assesses sharpness, strategic themes, and king risk in parallel. `selectMove()` weighs candidates against persona archetypes. That's the whole loop.
+
+## Natural language move intent
+
+```ts
+const { matchedMove, confidence, alternativeCandidates } = await resolver.resolveIntent(
+  engine,
+  "Castle kingside to safety"
+);
+
+if (matchedMove && confidence > 0.6) {
+  engine.makeMove(matchedMove.san);
+}
+```
+
+Resolves ambiguous instructions against verified legal moves instead of generating coordinates from scratch. If confidence falls below threshold, it returns candidate alternatives rather than hallucinating illegal squares.
+
+## Parallel move evaluation
+
+```ts
+const evaluation = await evaluator.evaluateMove(engine, move);
+
+// evaluation.tacticalSharpness -> Score (0.0 to 3.0)
+// evaluation.strategicTheme    -> Choice (pawn_break, tactical_strike, prophylaxis, etc.)
+// evaluation.kingAttackRisk    -> Noul (0.0 to 1.0 probability)
+// evaluation.commentaryBadge   -> "Sharp Tactical Clash"
+```
+
+A single `systemOne()` call evaluates candidate moves across four orthogonal dimensions simultaneously. Deterministic code synthesizes the results into human-readable commentary without asking an LLM to generate prose.
+
+## Persona AI opponents
+
+```ts
+const decision = await personas.selectMove(engine, "tal");
+// or "petrosian", "capablanca", "coffeehouse"
+```
+
+Personas are client-side weight vectors over atomic System One dimensions:
+
+- **Tal**: Heavy weight on tactical sharpness, king attack, and psychological pressure
+- **Petrosian**: Dominant prophylaxis and king safety weights
+- **Capablanca**: Prioritizes simplification and clear piece coordination
+- **Coffeehouse**: Romantic gambiteer favoring king assault and complications
+
+## Historic game classification
+
+```ts
+import { ClassicMatchStudio, CLASSIC_MATCHES } from "jev-chess";
+
+const studio = new ClassicMatchStudio();
+const report = await studio.classifyMatch(CLASSIC_MATCHES[0]);
+
+console.log(report.archetype);            // "ROMANTIC SWASHBUCKLER"
+console.log(report.aestheticBrilliance);   // { score: 2.9, level: "Immortal artistic masterpiece..." }
+console.log(report.turningPoint);         // { moveNumber: 20, san: "Ke2", ... }
+```
+
+Classifies full games into historical archetypes, detects turning points, verifies sacrifices, and generates structural tension breakdowns.
+
+## Studio & demo
+
+```bash
+npm run demo     # Interactive terminal showcase
+npm run serve    # Browser studio on http://localhost:3333
+```
+
+Interactive studio with board replay, real-time move intelligence, dynamic API key configuration, and classic match recreations.
+
+## Related
+
+- [TypeSafe AI](https://typesafe.ai) — Small units of AI intelligence as programming primitives
+- [TypeSafe SDK](https://github.com/typesafe-ai/typesafe-sdk) — Official TypeScript SDK
+- [Architecture Manifesto](./ARCHITECTURE.md) — Architectural pattern for TypeSafe chess software
+
+## License
+
+MIT © [Hemanth.HM](https://h3manth.com)

package/dist/chessEngine.d.ts

@@ -0,0 +1,36 @@
+import { Chess } from "chess.js";
+import type { AnnotatedMove, BoardContext, GamePhase, MaterialBalance } from "./types.js";
+export declare class ChessEngine {
+    chess: Chess;
+    constructor(fen?: string);
+    reset(): void;
+    load(fen: string): boolean;
+    fen(): string;
+    turn(): "white" | "black";
+    isCheck(): boolean;
+    isGameOver(): boolean;
+    history(): string[];
+    /**
+     * Generates all legal moves in the current position, richly annotated with semantic facts.
+     * This is 100% deterministic code.
+     */
+    getAnnotatedMoves(): AnnotatedMove[];
+    /**
+     * Calculates material balance between white and black.
+     */
+    getMaterialBalance(): MaterialBalance;
+    /**
+     * Deterministically infers game phase based on remaining major/minor pieces and move number.
+     */
+    getGamePhase(): GamePhase;
+    /**
+     * Creates the complete structured context representing the board.
+     * This matches TypeSafe's principle: provide clear, structured JSON state.
+     */
+    getBoardContext(): BoardContext;
+    /**
+     * Deterministically applies a move in SAN (Standard Algebraic Notation).
+     */
+    makeMove(sanOrUci: string): AnnotatedMove | null;
+}
+//# sourceMappingURL=chessEngine.d.ts.map

package/dist/chessEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chessEngine.d.ts","sourceRoot":"","sources":["../src/chessEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAiC,MAAM,UAAU,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAoB1F,qBAAa,WAAW;IACf,KAAK,EAAE,KAAK,CAAC;IAEpB,YAAY,GAAG,CAAC,EAAE,MAAM,EAEvB;IAEM,KAAK,IAAI,IAAI,CAEnB;IAEM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOhC;IAEM,GAAG,IAAI,MAAM,CAEnB;IAEM,IAAI,IAAI,OAAO,GAAG,OAAO,CAE/B;IAEM,OAAO,IAAI,OAAO,CAExB;IAEM,UAAU,IAAI,OAAO,CAE3B;IAEM,OAAO,IAAI,MAAM,EAAE,CAEzB;IAED;;;OAGG;IACI,iBAAiB,IAAI,aAAa,EAAE,CAiC1C;IAED;;OAEG;IACI,kBAAkB,IAAI,eAAe,CAuB3C;IAED;;OAEG;IACI,YAAY,IAAI,SAAS,CAuB/B;IAED;;;OAGG;IACI,eAAe,IAAI,YAAY,CAcrC;IAED;;OAEG;IACI,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAUtD;CACF"}

package/dist/chessEngine.js

@@ -0,0 +1,173 @@
+import { Chess } from "chess.js";
+const PIECE_NAMES = {
+    p: "pawn",
+    n: "knight",
+    b: "bishop",
+    r: "rook",
+    q: "queen",
+    k: "king",
+};
+const PIECE_VALUES = {
+    p: 1,
+    n: 3,
+    b: 3,
+    r: 5,
+    q: 9,
+    k: 0,
+};
+export class ChessEngine {
+    chess;
+    constructor(fen) {
+        this.chess = new Chess(fen);
+    }
+    reset() {
+        this.chess.reset();
+    }
+    load(fen) {
+        try {
+            this.chess.load(fen);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    fen() {
+        return this.chess.fen();
+    }
+    turn() {
+        return this.chess.turn() === "w" ? "white" : "black";
+    }
+    isCheck() {
+        return this.chess.inCheck();
+    }
+    isGameOver() {
+        return this.chess.isGameOver();
+    }
+    history() {
+        return this.chess.history();
+    }
+    /**
+     * Generates all legal moves in the current position, richly annotated with semantic facts.
+     * This is 100% deterministic code.
+     */
+    getAnnotatedMoves() {
+        const rawMoves = this.chess.moves({ verbose: true });
+        return rawMoves.map((m) => {
+            const pieceName = PIECE_NAMES[m.piece] ?? m.piece;
+            const isCastling = m.san === "O-O" || m.san === "O-O-O";
+            const isCapture = Boolean(m.captured);
+            const capturedName = m.captured ? PIECE_NAMES[m.captured] : undefined;
+            let description = `${pieceName} moves from ${m.from} to ${m.to}`;
+            if (isCastling) {
+                description = m.san === "O-O" ? "Kingside castle" : "Queenside castle";
+            }
+            else if (isCapture) {
+                description = `${pieceName} on ${m.from} captures ${capturedName} on ${m.to}`;
+            }
+            if (m.san.includes("+")) {
+                description += " with check";
+            }
+            else if (m.san.includes("#")) {
+                description += " with checkmate!";
+            }
+            return {
+                san: m.san,
+                from: m.from,
+                to: m.to,
+                piece: pieceName,
+                color: m.color === "w" ? "white" : "black",
+                isCapture,
+                capturedPiece: capturedName,
+                isCheck: m.san.includes("+") || m.san.includes("#"),
+                isCastling,
+                description,
+            };
+        });
+    }
+    /**
+     * Calculates material balance between white and black.
+     */
+    getMaterialBalance() {
+        const board = this.chess.board();
+        let whiteScore = 0;
+        let blackScore = 0;
+        for (const row of board) {
+            for (const square of row) {
+                if (!square)
+                    continue;
+                const val = PIECE_VALUES[square.type];
+                if (square.color === "w")
+                    whiteScore += val;
+                else
+                    blackScore += val;
+            }
+        }
+        const diff = whiteScore - blackScore;
+        let description = "Material is exactly equal";
+        if (diff > 0) {
+            description = `White is up +${diff} point${diff > 1 ? "s" : ""}`;
+        }
+        else if (diff < 0) {
+            description = `Black is up +${Math.abs(diff)} point${Math.abs(diff) > 1 ? "s" : ""}`;
+        }
+        return { whiteScore, blackScore, diff, description };
+    }
+    /**
+     * Deterministically infers game phase based on remaining major/minor pieces and move number.
+     */
+    getGamePhase() {
+        const board = this.chess.board();
+        let totalPieces = 0;
+        let queenCount = 0;
+        for (const row of board) {
+            for (const square of row) {
+                if (!square)
+                    continue;
+                if (square.type !== "p" && square.type !== "k") {
+                    totalPieces++;
+                    if (square.type === "q")
+                        queenCount++;
+                }
+            }
+        }
+        const moveCount = this.chess.history().length;
+        if (moveCount < 16 && totalPieces >= 12) {
+            return "opening";
+        }
+        if (totalPieces <= 6 || queenCount === 0) {
+            return "endgame";
+        }
+        return "middlegame";
+    }
+    /**
+     * Creates the complete structured context representing the board.
+     * This matches TypeSafe's principle: provide clear, structured JSON state.
+     */
+    getBoardContext() {
+        const history = this.chess.history();
+        const recentHistory = history.slice(-6);
+        return {
+            fen: this.chess.fen(),
+            turn: this.turn(),
+            moveNumber: Math.floor(history.length / 2) + 1,
+            inCheck: this.isCheck(),
+            materialBalance: this.getMaterialBalance(),
+            gamePhase: this.getGamePhase(),
+            recentHistory,
+            candidateMoves: this.getAnnotatedMoves(),
+        };
+    }
+    /**
+     * Deterministically applies a move in SAN (Standard Algebraic Notation).
+     */
+    makeMove(sanOrUci) {
+        const candidate = this.getAnnotatedMoves().find((m) => m.san === sanOrUci || `${m.from}${m.to}` === sanOrUci);
+        if (!candidate) {
+            return null;
+        }
+        this.chess.move(candidate.san);
+        return candidate;
+    }
+}
+//# sourceMappingURL=chessEngine.js.map

package/dist/chessEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chessEngine.js","sourceRoot":"","sources":["../src/chessEngine.ts"],"names":[],"mappings":"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"}

package/dist/classicMatches.d.ts

@@ -0,0 +1,50 @@
+export interface ClassicMatch {
+    id: string;
+    title: string;
+    white: string;
+    black: string;
+    year: number;
+    event: string;
+    result: "1-0" | "0-1" | "1/2-1/2";
+    eco: string;
+    opening: string;
+    description: string;
+    moves: string[];
+    keyMoveIndex: number;
+}
+export interface MatchClassification {
+    matchId: string;
+    title: string;
+    archetype: string;
+    aestheticBrilliance: {
+        score: number;
+        level: string;
+        confidence: number;
+    };
+    overallSharpness: {
+        score: number;
+        level: string;
+    };
+    hasDecisiveSacrifice: boolean;
+    turningPoint: {
+        moveNumber: number;
+        san: string;
+        annotation: string;
+    };
+    strategicBreakdown: {
+        tacticalStrikesPct: number;
+        pawnBreaksPct: number;
+        prophylaxisPct: number;
+        pieceActivationPct: number;
+    };
+    verdict: string;
+}
+export declare const CLASSIC_MATCHES: ClassicMatch[];
+export declare class ClassicMatchStudio {
+    private get client();
+    /**
+     * Classifies a classic chess match using TypeSafe System One.
+     */
+    classifyMatch(match: ClassicMatch): Promise<MatchClassification>;
+}
+//# sourceMappingURL=classicMatches.d.ts.map

package/dist/classicMatches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classicMatches.d.ts","sourceRoot":"","sources":["../src/classicMatches.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,gBAAgB,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,oBAAoB,EAAE,OAAO,CAAC;IAC9B,YAAY,EAAE;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,kBAAkB,EAAE;QAClB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,eAAe,EAAE,YAAY,EAmHzC,CAAC;AAuBF,qBAAa,kBAAkB;IAC7B,OAAO,KAAK,MAAM,GAEjB;IAED;;OAEG;IACU,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAiG5E;CACF"}