sela-core 0.1.0-alpha.1

package/dist/services/CrossFileHealer.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossFileHealer = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const DefinitionTracer_js_1 = require("./DefinitionTracer.js");
+const InitializerUpdater_js_1 = require("./InitializerUpdater.js");
+const logger_1 = require("../utils/logger");
+// ═══════════════════════════════════════════════════════════════════
+// CrossFileHealer  (T-9)
+//
+// Resolves an imported symbol to its definition in an external file,
+// then delegates mutation to InitializerUpdater.
+//
+// Entry point: CrossFileHealer.heal()
+//   modulePath  - the import specifier string (e.g. "./constants")
+//   symbolName  - the exported identifier name (e.g. "SHARED_SEL")
+//   oldValue    - the current string value (used for verification)
+//   newValue    - the replacement value
+//   callerFilePath - absolute path of the file containing the import
+//   project     - the shared ASTSourceUpdater Project instance
+// ═══════════════════════════════════════════════════════════════════
+const DEPTH_GUARD = 3;
+class CrossFileHealer {
+    static heal(modulePath, symbolName, newValue, callerFilePath, project, depth = 0) {
+        if (depth >= DEPTH_GUARD) {
+            return {
+                success: false,
+                reason: `CrossFileHealer: re-export chain depth exceeded for "${symbolName}"`,
+                strategy: "semantic-cross-file",
+            };
+        }
+        const externalPath = resolveModulePath(modulePath, callerFilePath);
+        if (!externalPath) {
+            return {
+                success: false,
+                reason: `CrossFileHealer: module "${modulePath}" not found relative to "${path.basename(callerFilePath)}"`,
+                strategy: "semantic-cross-file",
+            };
+        }
+        // Load external file into the shared project.
+        let externalSf = project.getSourceFile(externalPath);
+        if (externalSf) {
+            externalSf.refreshFromFileSystemSync();
+        }
+        else {
+            try {
+                externalSf = project.addSourceFileAtPath(externalPath);
+            }
+            catch (e) {
+                return {
+                    success: false,
+                    reason: `CrossFileHealer: failed to load "${path.basename(externalPath)}": ${e.message}`,
+                    strategy: "semantic-cross-file",
+                };
+            }
+        }
+        const traceResult = DefinitionTracer_js_1.DefinitionTracer.traceByName(symbolName, externalSf);
+        if (!traceResult.found) {
+            // Follow re-export chains (barrel files).
+            if (traceResult.crossFile) {
+                logger_1.logger.debug(`CrossFileHealer "${symbolName}" re-exported from "${traceResult.modulePath}" - following chain`);
+                return CrossFileHealer.heal(traceResult.modulePath, traceResult.symbolName, newValue, externalPath, project, depth + 1);
+            }
+            return {
+                success: false,
+                reason: `CrossFileHealer: ${traceResult.reason}`,
+                strategy: "semantic-cross-file",
+            };
+        }
+        const result = InitializerUpdater_js_1.InitializerUpdater.apply(traceResult.targetNode, traceResult.targetFile, newValue);
+        if (!result) {
+            return {
+                success: false,
+                reason: `CrossFileHealer: InitializerUpdater rejected node type ${traceResult.targetNode.getKindName()}`,
+                strategy: "semantic-cross-file",
+            };
+        }
+        logger_1.logger.debug(`CrossFileHealer healed "${symbolName}" in ${path.basename(externalPath)} ` +
+            `@ line ${result.lineUpdated + 1}`);
+        return {
+            success: true,
+            reason: `definition-site heal in ${path.basename(externalPath)}`,
+            strategy: "semantic-cross-file",
+            lineUpdated: result.lineUpdated,
+            healedLocatorString: newValue,
+        };
+    }
+}
+exports.CrossFileHealer = CrossFileHealer;
+// ─────────────────────────────────────────────────────────────────
+// Private helpers
+// ─────────────────────────────────────────────────────────────────
+function resolveModulePath(modulePath, fromFile) {
+    const base = path.dirname(path.resolve(fromFile));
+    const resolved = path.resolve(base, modulePath);
+    for (const candidate of [resolved, resolved + ".ts", resolved + ".js"]) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}

package/dist/services/DecisionEngine.d.ts

@@ -0,0 +1,51 @@
+import { Node, Block } from "ts-morph";
+import { AnchorKey, SourceSpan } from "./AnchorResolver";
+import { TraceTarget } from "./TraceBackEngine";
+export type DecisionStrategy = "MUTATE_IN_PLACE" | "FORK_AT_TEST" | "PROMPT_INTERACTIVE";
+export interface Edit {
+    kind: "replace" | "insert";
+    span: SourceSpan;
+    replacement: string;
+}
+export interface Decision {
+    strategy: DecisionStrategy;
+    reason: string;
+    /** Read-reference count to the declaration (the blast radius). */
+    blastRadius: number;
+    /** Distinct test/it blocks referencing the declaration. */
+    consumerTests: number;
+    /** Ordered edits. Apply via applyEdits (high→low offset). */
+    edits: Edit[];
+    /** When forking, the (possibly fresh) shadow variable name. */
+    forkVarName?: string;
+    /** 0..1 routing confidence (§5.3). */
+    confidence: number;
+    anchor: AnchorKey;
+}
+export interface DecideInput {
+    target: TraceTarget;
+    /** A node inside the FAILING statement — used to locate the test block. */
+    failingCallSite: Node;
+    /** Healed locator EXPRESSION text, e.g. `page.locator(".btn-v2")`. */
+    newLocatorExpr: string;
+    /** Runtime: only the failing test needs the new selector. */
+    contextSpecific: boolean;
+    /** Runtime: the selector rotted for ALL consumers (proven global). */
+    globalCorrect: boolean;
+}
+export declare class DecisionEngine {
+    static decide(input: DecideInput): Decision;
+}
+/**
+ * The Block of the nearest enclosing `test(...)` / `it(...)` callback. Hooks
+ * (`beforeEach`, etc.) are intentionally NOT matched — we fork into the test
+ * that failed, never into the shared hook.
+ */
+export declare function findEnclosingTestBlock(node: Node): Block | null;
+/**
+ * Apply edits to `original`, highest offset first so earlier offsets stay
+ * valid (the reverse-offset rule from the concurrency design §3.3.4).
+ * Throws on overlapping replace spans — never produces torn text.
+ */
+export declare function applyEdits(original: string, edits: Edit[]): string;
+//# sourceMappingURL=DecisionEngine.d.ts.map

package/dist/services/DecisionEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionEngine.d.ts","sourceRoot":"","sources":["../../src/services/DecisionEngine.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,IAAI,EAAc,KAAK,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EACL,WAAW,EAGZ,MAAM,mBAAmB,CAAC;AAM3B,MAAM,MAAM,gBAAgB,GACxB,iBAAiB,GACjB,cAAc,GACd,oBAAoB,CAAC;AAEzB,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,aAAa,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,2EAA2E;IAC3E,eAAe,EAAE,IAAI,CAAC;IACtB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,eAAe,EAAE,OAAO,CAAC;IACzB,sEAAsE;IACtE,aAAa,EAAE,OAAO,CAAC;CACxB;AAMD,qBAAa,cAAc;IACzB,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ;CAuD5C;AAqJD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,CAc/D;AAwCD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,CAsBlE"}

package/dist/services/DecisionEngine.js

@@ -0,0 +1,260 @@
+"use strict";
+// src/services/DecisionEngine.ts
+//
+// Ticket #2 — Stage 3: The Decision Tree & Multi-Consumer Forking.
+//
+// Final semantic phase. Given a trace-back TARGET (Stage 2) + the proposed
+// healed locator expression + runtime evidence, decide HOW to write it:
+//
+//   refsToDecl <= 1 ............................. MUTATE_IN_PLACE
+//   refsToDecl  > 1 & globalCorrect ............. MUTATE_IN_PLACE (all rot)
+//   refsToDecl  > 1 & contextSpecific ........... FORK_AT_TEST
+//   refsToDecl  > 1 & scope undeterminable ...... PROMPT_INTERACTIVE
+//
+// FORK_AT_TEST injects a collision-safe shadowing `const <name> = <expr>;`
+// at the top of the FAILING test's block so the other consumers of the
+// shared declaration (e.g. a `beforeEach` locator used by 4 other passing
+// tests) are left untouched. Same-name shadow keeps the call-site intact;
+// a real name collision falls back to a fresh name + a call-site rewrite.
+//
+// Reference census is delegated to BlastRadiusAnalyzer (cross-file accurate
+// via the ts-morph language service) — we do not re-implement findReferences.
+//
+// PURE: produces an edit plan; never writes to disk.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecisionEngine = void 0;
+exports.findEnclosingTestBlock = findEnclosingTestBlock;
+exports.applyEdits = applyEdits;
+const ts_morph_1 = require("ts-morph");
+const BlastRadiusAnalyzer_1 = require("./BlastRadiusAnalyzer");
+const TraceBackEngine_1 = require("./TraceBackEngine");
+// ═══════════════════════════════════════════════════════════════════
+// DecisionEngine
+// ═══════════════════════════════════════════════════════════════════
+class DecisionEngine {
+    static decide(input) {
+        const { target, newLocatorExpr } = input;
+        // Inline call-site or non-declaration target: the call-site is unique,
+        // there is nothing to share → mutate in place.
+        if (target.declKind === "InlineCallSite" || !target.declaration) {
+            return mutateInPlace(target, newLocatorExpr, 1, 1, "inline call-site");
+        }
+        // Reference census (delegated, cross-file accurate).
+        const { totalReferences, consumerTests } = census(target);
+        // ── refs <= 1 → safe global mutation ────────────────────────────
+        if (totalReferences <= 1) {
+            return mutateInPlace(target, newLocatorExpr, totalReferences, consumerTests, `single consumer (refs=${totalReferences})`);
+        }
+        // ── refs > 1 → multi-consumer ───────────────────────────────────
+        if (input.globalCorrect) {
+            return mutateInPlace(target, newLocatorExpr, totalReferences, consumerTests, `multi-consumer but selector rot is global (refs=${totalReferences})`, 0.85);
+        }
+        if (input.contextSpecific) {
+            const fork = buildFork(input, totalReferences, consumerTests);
+            if (fork)
+                return fork;
+            // Could not locate a test block to fork into → escalate.
+            return promptInteractive(target, totalReferences, consumerTests, "context-specific fix but no enclosing test block to fork into");
+        }
+        // Scope undeterminable → never silently break the other consumers.
+        return promptInteractive(target, totalReferences, consumerTests, `multi-consumer (refs=${totalReferences}) and scope undeterminable — global-vs-fork needs a human`);
+    }
+}
+exports.DecisionEngine = DecisionEngine;
+// ═══════════════════════════════════════════════════════════════════
+// REFERENCE CENSUS
+// ═══════════════════════════════════════════════════════════════════
+function census(target) {
+    const decl = target.declaration;
+    try {
+        const report = BlastRadiusAnalyzer_1.BlastRadiusAnalyzer.analyze(decl, decl.getSourceFile(), decl.getProject());
+        return {
+            totalReferences: report.totalReferences,
+            consumerTests: report.testFunctionCount,
+        };
+    }
+    catch {
+        // Census failure must not crash the pipeline; treat as single-consumer
+        // (the conservative MUTATE_IN_PLACE path the caller can still gate).
+        return { totalReferences: 1, consumerTests: 1 };
+    }
+}
+// ═══════════════════════════════════════════════════════════════════
+// PLAN BUILDERS
+// ═══════════════════════════════════════════════════════════════════
+function mutateInPlace(target, newLocatorExpr, blastRadius, consumerTests, reason, confidence = 0.9) {
+    return {
+        strategy: "MUTATE_IN_PLACE",
+        reason,
+        blastRadius,
+        consumerTests,
+        confidence,
+        anchor: target.anchor,
+        edits: [
+            {
+                kind: "replace",
+                span: {
+                    start: target.targetNode.getStart(),
+                    end: target.targetNode.getEnd(),
+                },
+                replacement: newLocatorExpr,
+            },
+        ],
+    };
+}
+function promptInteractive(target, blastRadius, consumerTests, reason) {
+    return {
+        strategy: "PROMPT_INTERACTIVE",
+        reason,
+        blastRadius,
+        consumerTests,
+        confidence: 0.4,
+        anchor: target.anchor,
+        edits: [], // no auto-edit; the CLI prompts the user
+    };
+}
+function buildFork(input, blastRadius, consumerTests) {
+    const { target, failingCallSite, newLocatorExpr } = input;
+    const testBlock = findEnclosingTestBlock(failingCallSite);
+    if (!testBlock)
+        return null;
+    const baseName = target.symbolName ?? "healedLocator";
+    // Collision-safe shadow naming. A plain block-scoped `const` of the SAME
+    // name legally shadows the outer (beforeEach/describe) declaration and the
+    // call-site needs no rewrite. Only when the failing test block ALREADY
+    // declares that name locally do we need a fresh name + call-site rewrite.
+    const localNames = collectBlockLocalNames(testBlock);
+    let forkVarName = baseName;
+    let needsCallSiteRewrite = false;
+    if (localNames.has(baseName)) {
+        forkVarName = freshName(baseName, localNames);
+        needsCallSiteRewrite = true;
+    }
+    const edits = [];
+    // 1. Insert the shadow declaration at the top of the test block.
+    const stmts = testBlock.getStatements();
+    const indent = stmts[0]?.getIndentationText() ?? "  ";
+    const insertPos = stmts[0]
+        ? stmts[0].getStart()
+        : testBlock.getStart() + 1; // just after the `{`
+    const insertText = stmts[0]
+        ? `const ${forkVarName} = ${newLocatorExpr};\n${indent}`
+        : `\n${indent}const ${forkVarName} = ${newLocatorExpr};\n`;
+    edits.push({
+        kind: "insert",
+        span: { start: insertPos, end: insertPos },
+        replacement: insertText,
+    });
+    // 2. If we had to rename, rewrite the failing call-site receiver.
+    if (needsCallSiteRewrite) {
+        const top = (0, TraceBackEngine_1.climbToTopCall)(failingCallSite);
+        if (top) {
+            const { leftmost } = (0, TraceBackEngine_1.getLeftmostReceiver)(top);
+            if (ts_morph_1.Node.isIdentifier(leftmost) && leftmost.getText() === baseName) {
+                edits.push({
+                    kind: "replace",
+                    span: { start: leftmost.getStart(), end: leftmost.getEnd() },
+                    replacement: forkVarName,
+                });
+            }
+        }
+    }
+    return {
+        strategy: "FORK_AT_TEST",
+        reason: `multi-consumer (refs=${blastRadius}, tests=${consumerTests}); context-specific fix forked into the failing test as "${forkVarName}"`,
+        blastRadius,
+        consumerTests,
+        confidence: 0.75,
+        forkVarName,
+        anchor: target.anchor,
+        edits,
+    };
+}
+// ═══════════════════════════════════════════════════════════════════
+// TEST-BLOCK / SCOPE HELPERS
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * The Block of the nearest enclosing `test(...)` / `it(...)` callback. Hooks
+ * (`beforeEach`, etc.) are intentionally NOT matched — we fork into the test
+ * that failed, never into the shared hook.
+ */
+function findEnclosingTestBlock(node) {
+    let cur = node;
+    while (cur) {
+        if (ts_morph_1.Node.isCallExpression(cur) && isTestCall(cur)) {
+            for (const arg of cur.getArguments()) {
+                if (ts_morph_1.Node.isArrowFunction(arg) || ts_morph_1.Node.isFunctionExpression(arg)) {
+                    const body = arg.getBody();
+                    if (body && ts_morph_1.Node.isBlock(body))
+                        return body;
+                }
+            }
+        }
+        cur = cur.getParent();
+    }
+    return null;
+}
+function isTestCall(call) {
+    if (!ts_morph_1.Node.isCallExpression(call))
+        return false;
+    const expr = call.getExpression();
+    const base = ts_morph_1.Node.isPropertyAccessExpression(expr)
+        ? expr.getExpression().getText()
+        : expr.getText();
+    return base === "test" || base === "it";
+}
+/** Names declared LOCALLY in this block (top-level var statements + fns). */
+function collectBlockLocalNames(block) {
+    const names = new Set();
+    for (const stmt of block.getStatements()) {
+        if (ts_morph_1.Node.isVariableStatement(stmt)) {
+            for (const d of stmt.getDeclarations()) {
+                const n = d.getNameNode();
+                if (ts_morph_1.Node.isIdentifier(n))
+                    names.add(n.getText());
+            }
+        }
+        else if (ts_morph_1.Node.isFunctionDeclaration(stmt)) {
+            const nm = stmt.getName();
+            if (nm)
+                names.add(nm);
+        }
+    }
+    return names;
+}
+function freshName(base, taken) {
+    const candidate = `${base}Healed`;
+    if (!taken.has(candidate))
+        return candidate;
+    let i = 2;
+    while (taken.has(`${candidate}${i}`))
+        i++;
+    return `${candidate}${i}`;
+}
+// ═══════════════════════════════════════════════════════════════════
+// PURE EDIT APPLICATION (used by callers + tests)
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Apply edits to `original`, highest offset first so earlier offsets stay
+ * valid (the reverse-offset rule from the concurrency design §3.3.4).
+ * Throws on overlapping replace spans — never produces torn text.
+ */
+function applyEdits(original, edits) {
+    const sorted = [...edits].sort((a, b) => b.span.start - a.span.start);
+    for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1];
+        const cur = sorted[i];
+        // prev.start >= cur.start (desc). Overlap if cur.end > prev.start AND
+        // both are replacements (inserts are zero-width and may share a point).
+        if (cur.span.end > prev.span.start &&
+            prev.kind === "replace" &&
+            cur.kind === "replace") {
+            throw new Error(`[DecisionEngine] overlapping edits at ${cur.span.start}..${cur.span.end} and ${prev.span.start}..${prev.span.end}`);
+        }
+    }
+    let text = original;
+    for (const e of sorted) {
+        text = text.slice(0, e.span.start) + e.replacement + text.slice(e.span.end);
+    }
+    return text;
+}

package/dist/services/DefinitionTracer.d.ts

@@ -0,0 +1,41 @@
+import { Node, SourceFile, StringLiteral, NoSubstitutionTemplateLiteral, TemplateExpression } from "ts-morph";
+export type TraceResult = {
+    found: true;
+    targetNode: Node;
+    targetFile: SourceFile;
+    /** The enclosing VariableDeclaration or PropertyAssignment - used by BlastRadiusAnalyzer. */
+    declarationNode?: Node;
+} | {
+    found: false;
+    crossFile: true;
+    modulePath: string;
+    symbolName: string;
+} | {
+    found: false;
+    crossFile: false;
+    reason: string;
+};
+export type FunctionalAnalysis = {
+    kind: "template";
+    templateNode: TemplateExpression;
+    bindings: Map<string, string>;
+    functionFile: SourceFile;
+    functionLine: number;
+} | {
+    kind: "literal";
+    literalNode: StringLiteral | NoSubstitutionTemplateLiteral;
+    functionFile: SourceFile;
+    functionLine: number;
+} | {
+    kind: "complex";
+    reason: string;
+};
+export declare class DefinitionTracer {
+    static traceIdentifier(identifierNode: Node, sourceFile: SourceFile, callerLine: number, depth?: number): TraceResult;
+    static tracePropertyAccess(propAccessNode: Node, sourceFile: SourceFile, callerLine: number): TraceResult;
+    static traceByName(symbolName: string, sourceFile: SourceFile): TraceResult;
+}
+export declare class FunctionalReturnAnalyzer {
+    static analyze(callNode: Node, sourceFile: SourceFile): FunctionalAnalysis;
+}
+//# sourceMappingURL=DefinitionTracer.d.ts.map

package/dist/services/DefinitionTracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefinitionTracer.d.ts","sourceRoot":"","sources":["../../src/services/DefinitionTracer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,UAAU,EAKV,aAAa,EACb,6BAA6B,EAC7B,kBAAkB,EAGnB,MAAM,UAAU,CAAC;AAOlB,MAAM,MAAM,WAAW,GACnB;IACE,KAAK,EAAE,IAAI,CAAC;IACZ,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;IACvB,6FAA6F;IAC7F,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB,GACD;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACzE;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAC1B;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,YAAY,EAAE,UAAU,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,WAAW,EAAE,aAAa,GAAG,6BAA6B,CAAC;IAC3D,YAAY,EAAE,UAAU,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB,GACD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAcxC,qBAAa,gBAAgB;IAK3B,MAAM,CAAC,eAAe,CACpB,cAAc,EAAE,IAAI,EACpB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,KAAK,SAAI,GACR,WAAW;IA0Fd,MAAM,CAAC,mBAAmB,CACxB,cAAc,EAAE,IAAI,EACpB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,GACjB,WAAW;IA+Ed,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,WAAW;CAkC5E;AASD,qBAAa,wBAAwB;IACnC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,GAAG,kBAAkB;CAmF3E"}