sela-core 0.1.0-alpha.1

package/dist/services/LLMService.js

@@ -0,0 +1,475 @@
+"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.LLMService = void 0;
+const dotenv = __importStar(require("dotenv"));
+const SelaError_1 = require("../errors/SelaError");
+const SanitizingAnthropic_1 = require("./SanitizingAnthropic");
+const logger_1 = require("../utils/logger");
+dotenv.config();
+// ─────────────────────────────────────────────────────────────────
+// SYSTEM PROMPT
+// ─────────────────────────────────────────────────────────────────
+const SYSTEM_PROMPT_TEXT = `### ROLE
+You are an expert Playwright Automation Engineer specializing in self-healing test selectors (Project Sela).
+You deeply understand Playwright's locator API and always prefer semantic, resilient selectors
+over brittle CSS or XPath expressions.
+
+### STRICT RULES
+1. **NO PSEUDO-CLASSES**: NEVER use ':first-of-type', ':nth-child', etc., unless it is the ONLY way.
+2. **PRIORITIZE ATTRIBUTES**: Search DOM for stable attributes: id, data-testid, aria-label, name, role.
+3. **FRAME ACCURACY**: If a frame's ID changed, use the NEW ID from the DOM.
+4. **NO FX-ID**: Never return 'fx-id'.
+5. **VALID METHODS ONLY**: Only use real Playwright Locator methods.
+6. **RUNTIME SYNC (CRITICAL)**: The flat selector in "segments" MUST match the specificity of "chainSegments".
+   If your chain uses a 'name' or 'text' filter, you MUST include it in the flat string (e.g., using " >> internal:has-text="..."" or ":has-text('...')").
+7. **DATA-* ATTRIBUTE PRESERVATION (CRITICAL)**: If the original selector used a data-* attribute (e.g., data-role, data-testid, data-id), you MUST preserve that attribute in your response.
+   NEVER simplify "input[data-role='old-value']" to just "input".
+   Instead update the attribute value: "input[data-role='new-value']".
+   Even if the DOM context appears incomplete, when the DNA shows an attribute value changed, include the updated attribute value in your response.
+
+### VALID PLAYWRIGHT CHAIN METHODS
+Locator producers: locator, frameLocator, getByRole, getByLabel, getByText,
+  getByPlaceholder, getByTestId, getByAltText, getByTitle
+Narrowing: filter, first, last, nth
+
+### SMART CHAIN RESPONSE FORMAT
+You MUST return a "chainSegments" array for the permanent code fix AND a matching "segments" array for the runtime proxy.
+
+Build the chain in this priority order:
+  PRIORITY 1 - getByTestId
+  PRIORITY 2 - getByRole (ALWAYS include "name" if it exists in the DOM to ensure uniqueness)
+  PRIORITY 3 - getByLabel
+  PRIORITY 4 - getByText (use exact: true if possible)
+  NARROWING - Use filter({ hasText: "..." }) to isolate an element within a repeated container.
+
+### PROXY SELECTOR CONSTRUCTION (segments field)
+The "segments[0].selector" string is used for an immediate "live" retry. 
+- AVOID generic selectors like "internal:role=button".
+- PREFER specific selectors: ".user-item >> internal:has-text=\"Bob\" >> internal:role=button[name=\"Edit\"i]"
+- This prevents "Strict Mode" violations where Playwright finds multiple matches and times out.
+
+### DEVELOPER INTENT PRESERVATION
+Preserve the original code's structural pattern from "originalChainHint":
+  - If the original used a chain, return a chain.
+  - If the original was specific, stay specific.
+
+### TEMPLATE LITERAL / FUNCTION SELECTOR PRESERVATION
+When the failing selector originates from a Template Literal or a function returning a template,
+preserve the attribute structure - update the value inside the attribute rather than removing it.
+For chain selectors: if the original was "#section-B >> input[data-role='user_legacy']"
+and the DNA shows data-role changed to "user_active", return "#section-B >> input[data-role='user_active']".
+NEVER simplify to "#section-B >> input" - that loses the attribute and breaks automated source healing.
+The healing system depends on the attribute value being present in your response to patch the template variable.
+
+### TYPE SAFETY RULES
+  - A chain MUST end on a Locator (not FrameLocator).
+  - Never call frameLocator() on a Locator.
+
+### CONTENT CHANGE DETECTION
+If the element's text changed, you MUST include:
+  "contentChange": { "oldText": "<previous>", "newText": "<current>" }
+
+### CONFIDENCE SCORE (MANDATORY)
+You MUST include a numeric "confidence" field - an INTEGER in the range 0-100 -
+representing how certain you are that the returned chain will resolve the
+intended element on the next test run. Use this rubric:
+  - 90-100: stable id, data-testid, or unique role+name - zero ambiguity in the DOM.
+  - 70-89:  strong semantic match, but some structural drift or competing candidates.
+  - 50-69:  best-guess match - multiple plausible candidates required disambiguation.
+  - 1-49:   speculative match - return this only when no better candidate exists.
+NEVER omit this field. NEVER return it as a string, boolean, or null.
+Reports rendered downstream will show "n/a" when this field is missing - which
+is a clear failure signal to the developer reviewing the heal.
+
+### MANDATORY OUTPUT FORMAT
+Return ONLY valid JSON.
+
+Example output - Identifying a specific button in a list row:
+{
+  "status": "FIXED",
+  "confidence": 92,
+  "chainSegments": [
+    { "type": "locator", "selector": ".user-item" },
+    { "type": "filter", "hasText": "Bob Smith" },
+    { "type": "getByRole", "role": "button", "name": "Modify Bob" }
+  ],
+  "segments": [
+    {
+      "type": "element",
+      "selector": ".user-item >> internal:has-text=\"Bob Smith\"i >> internal:role=button[name=\"Modify Bob\"i]"
+    }
+  ],
+  "explanation": "Updated container to .user-item and targeted the button by its new semantic name 'Modify Bob' to ensure a unique match."
+}`;
+// ─────────────────────────────────────────────────────────────────
+// HELPERS
+// ─────────────────────────────────────────────────────────────────
+/**
+ * Reverse-engineer a SmartChainSegment hint from a flat selector
+ * string. This gives the AI context about how the original code
+ * was structured so it can preserve developer intent.
+ */
+function inferOriginalChainHint(selector) {
+    const parts = selector.split(" >> ").map((s) => s.trim());
+    const segments = [];
+    for (const part of parts) {
+        // internal:role=button[name="..."]
+        const roleMatch = part.match(/^internal:role=([a-zA-Z]+)(?:\[name="([^"]+)"(?:i)?\])?/);
+        if (roleMatch) {
+            const seg = {
+                type: "getByRole",
+                role: roleMatch[1],
+            };
+            if (roleMatch[2])
+                seg.name = roleMatch[2];
+            segments.push(seg);
+            continue;
+        }
+        // internal:label=
+        const labelMatch = part.match(/^internal:label=["']?([^"'\]]+)["']?/);
+        if (labelMatch) {
+            segments.push({ type: "getByLabel", text: labelMatch[1].trim() });
+            continue;
+        }
+        // internal:text=
+        const textMatch = part.match(/^internal:text=["']([^"']+)["'](i)?/);
+        if (textMatch) {
+            segments.push({
+                type: "getByText",
+                text: textMatch[1],
+                exact: !textMatch[2],
+            });
+            continue;
+        }
+        // internal:attr=[placeholder=...]
+        const placeholderMatch = part.match(/internal:attr=\[placeholder=["']([^"']+)["']\]/);
+        if (placeholderMatch) {
+            segments.push({ type: "getByPlaceholder", text: placeholderMatch[1] });
+            continue;
+        }
+        // [data-testid=...]
+        const testIdMatch = part.match(/\[data-testid=["']([^"']+)["']\]/);
+        if (testIdMatch) {
+            segments.push({ type: "getByTestId", testId: testIdMatch[1] });
+            continue;
+        }
+        // iframe / frame selectors
+        if (part.includes("frame") ||
+            part.startsWith("iframe") ||
+            part.match(/^#[a-z-]*frame[a-z-]*/i)) {
+            segments.push({ type: "frameLocator", selector: part });
+            continue;
+        }
+        // Fallback: CSS locator
+        segments.push({ type: "locator", selector: part });
+    }
+    return segments;
+}
+const DEFAULT_LLM_MODEL = "claude-sonnet-4-20250514";
+class LLMService {
+    anthropic;
+    model;
+    constructor(opts = {}) {
+        this.model = opts.model ?? DEFAULT_LLM_MODEL;
+        if (opts.anthropic) {
+            this.anthropic = opts.anthropic;
+            return;
+        }
+        const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+        if (!apiKey) {
+            throw new SelaError_1.SelaError({
+                subsystem: "LLMService",
+                code: SelaError_1.LLM_SERVICE_CODES.NO_API_KEY,
+                reason: "ANTHROPIC_API_KEY not found - pass an `anthropic` client or `apiKey` to LLMService(), or set the env var",
+            });
+        }
+        // Route the default client through the PII/secrets sanitizer (T3) so all
+        // outbound DOM/DNA context is scrubbed before leaving the process.
+        this.anthropic = (0, SanitizingAnthropic_1.createSanitizingAnthropic)({ apiKey });
+    }
+    cleanJson(text) {
+        let cleaned = text
+            .replace(/```json/g, "")
+            .replace(/```/g, "")
+            .trim();
+        const firstBrace = cleaned.indexOf("{");
+        const lastBrace = cleaned.lastIndexOf("}");
+        if (firstBrace !== -1 && lastBrace !== -1) {
+            return cleaned.substring(firstBrace, lastBrace + 1);
+        }
+        return cleaned;
+    }
+    /**
+     * Attempts to infer contentChange when the AI did not return the field.
+     *
+     * Strategies (in order of confidence):
+     *
+     * 1. previousState.text  vs  has-text() in new selector
+     * 2. has-text() in old selector vs new selector
+     * 3. intentDescription text vs new selector
+     */
+    inferContentChange(parsed, request) {
+        // Extract new text from either chainSegments or flat new_selector
+        let newText = null;
+        if (parsed.chainSegments) {
+            // Look for text in the last getByText / getByRole with name
+            for (const seg of [...parsed.chainSegments].reverse()) {
+                if ((seg.type === "getByText" ||
+                    seg.type === "getByLabel" ||
+                    seg.type === "filter") &&
+                    seg.text) {
+                    newText = seg.text;
+                    break;
+                }
+                if (seg.type === "getByRole" && seg.name) {
+                    newText = seg.name;
+                    break;
+                }
+                if (seg.type === "filter" && seg.hasText) {
+                    newText = seg.hasText;
+                    break;
+                }
+            }
+        }
+        if (!newText) {
+            const newSelector = parsed.new_selector ?? "";
+            const newHasText = newSelector.match(/has-text\(["']([^"']+)["']\)/);
+            if (newHasText)
+                newText = newHasText[1];
+        }
+        if (!newText)
+            return undefined;
+        // Strategy 1: DNA text
+        const prevText = request.previousState?.text;
+        if (prevText && prevText !== newText) {
+            const prevWords = prevText.split(/\s+/);
+            const newWords = newText.split(/\s+/);
+            const lenDiff = Math.abs(prevWords.length - newWords.length);
+            let diffCount = 0;
+            const minLen = Math.min(prevWords.length, newWords.length);
+            for (let i = 0; i < minLen; i++) {
+                if (prevWords[i] !== newWords[i])
+                    diffCount++;
+            }
+            if (lenDiff <= 1 && diffCount <= 3 && diffCount > 0) {
+                logger_1.logger.debug(`contentChange inferred from DNA text: "${prevText}" → "${newText}"`);
+                return { oldText: prevText, newText };
+            }
+        }
+        // Strategy 2: has-text in old selector
+        const oldHasText = request.failedSelector.match(/has-text\(["']([^"']+)["']\)/);
+        if (oldHasText && oldHasText[1] !== newText) {
+            logger_1.logger.debug(`contentChange inferred from has-text diff: "${oldHasText[1]}" → "${newText}"`);
+            return { oldText: oldHasText[1], newText };
+        }
+        // Strategy 3: intent description
+        const intentTextMatch = request.targetIntent?.match(/with text ["']([^"']+)["']/i);
+        if (intentTextMatch && intentTextMatch[1] !== newText) {
+            const oldIntentText = intentTextMatch[1];
+            const intentWords = oldIntentText.split(/\s+/);
+            const newWords = newText.split(/\s+/);
+            const lenDiff = Math.abs(intentWords.length - newWords.length);
+            let diffCount = 0;
+            const minLen = Math.min(intentWords.length, newWords.length);
+            for (let i = 0; i < minLen; i++) {
+                if (intentWords[i] !== newWords[i])
+                    diffCount++;
+            }
+            if (lenDiff <= 1 && diffCount <= 3 && diffCount > 0) {
+                logger_1.logger.debug(`contentChange inferred from intent: "${oldIntentText}" → "${newText}"`);
+                return { oldText: oldIntentText, newText };
+            }
+        }
+        return undefined;
+    }
+    async getFix(request) {
+        const dnaSummary = request.previousState;
+        // Reverse-engineer the original chain structure for the AI
+        const originalChainHint = inferOriginalChainHint(request.failedSelector);
+        const chainHintJson = JSON.stringify(originalChainHint, null, 2);
+        const userMessage = `
+### PROBLEM
+A Playwright test failed. Analyze the full selector path and return a Smart Chain fix.
+
+### FAILED SELECTOR (Full Path):
+"${request.failedSelector}"
+
+### ORIGINAL CHAIN STRUCTURE (reverse-engineered from failed selector):
+${chainHintJson}
+Use this to understand the developer's original intent. Preserve the same structural
+pattern in your "chainSegments" where possible (e.g., if original used a filter + getByRole
+pattern, try to keep filter + getByRole if the element still exists in a list context).
+
+### INTENT:
+${request.targetIntent}
+
+### PREVIOUS DNA (Element Fingerprint):
+${dnaSummary && Object.keys(dnaSummary).length > 0
+            ? JSON.stringify(dnaSummary, null, 2)
+            : "NO DNA (First run - infer from selector and DOM)"}
+
+### CURRENT DOM SNIPPET:
+${request.currentDom}
+
+### YOUR TASK
+1. Find the element in the current DOM.
+2. Build a "chainSegments" array using Playwright's semantic API (priority: getByTestId > getByRole > getByLabel > getByText > filter+narrow > locator).
+3. Preserve the developer's chain structure (filter patterns, role patterns) when possible.
+4. Populate "contentChange" if the element's visible text changed.
+5. Also populate "segments" (legacy format) for backward compatibility.
+
+Return ONLY a raw JSON object - no markdown, no preamble.`;
+        try {
+            const msg = await this.anthropic.messages.create({
+                model: this.model,
+                max_tokens: 1024,
+                system: SYSTEM_PROMPT_TEXT +
+                    "\nIMPORTANT: Respond ONLY with a raw JSON object.",
+                messages: [{ role: "user", content: userMessage }],
+            });
+            const rawText = msg.content[0].type === "text" ? msg.content[0].text : "";
+            logger_1.logger.debug(`AI Raw Response: ${rawText}`);
+            const jsonString = this.cleanJson(rawText);
+            if (!jsonString)
+                throw new Error("AI did not return a valid JSON object");
+            const parsed = JSON.parse(jsonString);
+            // ── Normalise confidence: keep only finite numbers in [0,100] ─────
+            // Anything else (undefined, NaN, null, string, out-of-range) collapses
+            // to `undefined` so reports render "n/a" instead of synthesising 0.
+            const rawConf = parsed.confidence;
+            if (typeof rawConf === "number" && Number.isFinite(rawConf)) {
+                parsed.confidence = Math.max(0, Math.min(100, Math.round(rawConf)));
+            }
+            else {
+                if (rawConf !== undefined) {
+                    logger_1.logger.warn(`Discarded non-numeric confidence: ${JSON.stringify(rawConf)}`);
+                }
+                parsed.confidence = undefined;
+            }
+            // ── Normalize chainSegments → segments (legacy) ───────────────────
+            if (parsed.chainSegments && Array.isArray(parsed.chainSegments)) {
+                // Reconstruct a flat new_selector from chain segments for legacy paths
+                const flatParts = [];
+                for (const seg of parsed.chainSegments) {
+                    switch (seg.type) {
+                        case "locator":
+                        case "frameLocator":
+                            flatParts.push(seg.selector);
+                            break;
+                        case "getByRole":
+                            flatParts.push(seg.name
+                                ? `[role="${seg.role}"]:has-text("${seg.name}")`
+                                : `[role="${seg.role}"]`);
+                            break;
+                        case "getByLabel":
+                            flatParts.push(`label:has-text("${seg.text}")`);
+                            break;
+                        case "getByText":
+                            flatParts.push(`:has-text("${seg.text}")`);
+                            break;
+                        case "getByTestId":
+                            flatParts.push(`[data-testid="${seg.testId}"]`);
+                            break;
+                        case "getByPlaceholder":
+                            flatParts.push(`[placeholder="${seg.text}"]`);
+                            break;
+                        case "filter":
+                            if (seg.hasText)
+                                flatParts.push(`:has-text("${seg.hasText}")`);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                if (flatParts.length > 0 && !parsed.new_selector) {
+                    parsed.new_selector = flatParts.join(" >> ");
+                }
+                // Also inject into legacy segments if missing
+                if (!parsed.segments || parsed.segments.length === 0) {
+                    const frameSegs = parsed.chainSegments.filter((s) => s.type === "frameLocator");
+                    const elemSegs = parsed.chainSegments.filter((s) => s.type !== "frameLocator");
+                    parsed.segments = [
+                        ...frameSegs.map((s) => ({
+                            type: "frame",
+                            selector: s.selector,
+                        })),
+                        { type: "element", selector: parsed.new_selector ?? "" },
+                    ];
+                }
+            }
+            // ── Normalize legacy new_selector → segments ──────────────────────
+            if (!parsed.segments && parsed.new_selector) {
+                const parts = parsed.new_selector
+                    .split(" >> ")
+                    .map((s) => s.trim());
+                parsed.segments = parts.map((s, i) => ({
+                    type: i === parts.length - 1 ? "element" : "frame",
+                    selector: s,
+                }));
+            }
+            if (!parsed.segments || !Array.isArray(parsed.segments)) {
+                throw new Error("AI response missing 'segments' array");
+            }
+            parsed.new_selector =
+                parsed.new_selector ??
+                    parsed.segments.map((s) => s.selector).join(" >> ");
+            // Attach original chain hint for ASTUpdater's partial healing logic
+            parsed.originalChainHint = originalChainHint;
+            // ── Ensure contentChange is populated ──────────────────────────────
+            if (!parsed.contentChange || typeof parsed.contentChange !== "object") {
+                const inferred = this.inferContentChange(parsed, request);
+                if (inferred) {
+                    parsed.contentChange = inferred;
+                }
+            }
+            if (parsed.contentChange) {
+                logger_1.logger.debug(`contentChange: "${parsed.contentChange.oldText}" → "${parsed.contentChange.newText}"`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            logger_1.logger.error("Analysis failed", error.message);
+            return {
+                status: "NOT_FOUND",
+                segments: [],
+                new_selector: null,
+                confidence: undefined,
+                explanation: `AI Error: ${error.message}`,
+            };
+        }
+    }
+}
+exports.LLMService = LLMService;

package/dist/services/MutationApplier.d.ts

@@ -0,0 +1,69 @@
+import { AnchorKey, SourceSpan } from "./AnchorResolver";
+/**
+ * A single edit. `replace` edits carry an `anchor` and are RE-RESOLVED at
+ * apply-time (span recomputed from the fresh parse). `insert` edits (forks)
+ * carry a literal `span` computed against the same content being applied.
+ */
+export interface AnchoredEdit {
+    kind: "replace" | "insert";
+    replacement: string;
+    /** Replace target — re-resolved via resolveAnchor at apply time. */
+    anchor?: AnchorKey;
+    /** Literal span for inserts (and as a fallback for anchorless replaces). */
+    span?: SourceSpan;
+    /**
+     * Require the replacement to be a Locator-returning expression. Defaults to
+     * true for `replace`. Set false for inserts / non-locator edits.
+     */
+    requireLocator?: boolean;
+}
+export interface FileBatch {
+    filePath: string;
+    edits: AnchoredEdit[];
+}
+export type ApplyStatus = "applied" | "rolled-back" | "no-op" | "skipped";
+export interface ApplyOutcome {
+    filePath: string;
+    status: ApplyStatus;
+    reason: string;
+    written: boolean;
+    /** Content after the run — the new content when applied, else the original. */
+    finalContent: string;
+    /** Edits that could not be applied (stale anchor, type-incompat, …). */
+    skipped: Array<{
+        reason: string;
+    }>;
+}
+export interface ApplyOptions {
+    /** When false, compute + gate but never touch disk. Default true. */
+    write?: boolean;
+    /** Honour SELA_DRY_RUN by leaving disk untouched. Default true. */
+    respectDryRun?: boolean;
+}
+export declare class MutationApplier {
+    /** Apply many batches; each file is processed independently. */
+    static applyBatches(batches: FileBatch[], opts?: ApplyOptions): ApplyOutcome[];
+    /**
+     * Apply a file batch under a per-file cross-process lock (SELA-5).
+     *
+     * The lock makes the read-modify-write of a single source file atomic across
+     * concurrent Playwright workers — the real lost-update risk is two specs that
+     * heal a SHARED page-object simultaneously (each reads the same baseline and
+     * the second write drops the first's fix). The lock dir is keyed by file
+     * path, so heals on DIFFERENT files never serialise — worker scalability is
+     * preserved. Read-only / dry-run runs skip the lock entirely (no disk RMW).
+     *
+     * A stale lock (crashed holder) is reclaimed after 30s so a worker crash can
+     * never permanently wedge CI.
+     */
+    static applyFileBatch(batch: FileBatch, opts?: ApplyOptions): ApplyOutcome;
+    private static applyFileBatchUnlocked;
+}
+/**
+ * Cheap return-type pre-check. The replacement must be an expression whose
+ * OUTERMOST call is a Locator-returning Playwright method (locator / getBy* /
+ * frameLocator / nth / first / last / filter / and / or). Rejects actions
+ * (.click()), string queries (.title(), .textContent()), bare literals, etc.
+ */
+export declare function isLocatorReturningExpr(text: string): boolean;
+//# sourceMappingURL=MutationApplier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MutationApplier.d.ts","sourceRoot":"","sources":["../../src/services/MutationApplier.ts"],"names":[],"mappings":"AA2BA,OAAO,EACL,SAAS,EAET,UAAU,EACX,MAAM,kBAAkB,CAAC;AAY1B;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AAE1E,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,OAAO,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAeD,qBAAa,eAAe;IAC1B,gEAAgE;IAChE,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,SAAS,EAAE,EACpB,IAAI,GAAE,YAAiB,GACtB,YAAY,EAAE;IAIjB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,cAAc,CACnB,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE,YAAiB,GACtB,YAAY;IAqCf,OAAO,CAAC,MAAM,CAAC,sBAAsB;CA2KtC;AA2CD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkB5D"}