api-tests-coverage 1.0.0

package/dist/src/coverage/deep-analysis/resolveMethodChains.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Deep Code Analysis — Method Chain Resolution
+ *
+ * Traces method calls to helper/wrapper functions within the same file,
+ * following the call graph up to a configurable depth.
+ *
+ * Also detects builder-style method chains that resolve to HTTP calls.
+ *
+ * Supported patterns:
+ *
+ * TypeScript/JavaScript:
+ *   function getUsers(client) { return client.get('/users'); }
+ *   getUsers(apiClient);  → GET /users
+ *
+ * Java:
+ *   private Response fetchUser(String id) { return api.get("/users/" + id); }
+ *   fetchUser(userId);  → GET /users/{id}
+ *
+ * Python:
+ *   def fetch_customer(customer_id): return client.get(build_path(customer_id))
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWrapperCall = resolveWrapperCall;
+exports.resolveHelperReturnPath = resolveHelperReturnPath;
+exports.extractPythonHelperCallsInHttpArgs = extractPythonHelperCallsInHttpArgs;
+exports.extractJsHelperCallsInHttpArgs = extractJsHelperCallsInHttpArgs;
+exports.extractJavaHelperCallsInHttpArgs = extractJavaHelperCallsInHttpArgs;
+const resolvePaths_1 = require("./resolvePaths");
+const resolveConstants_1 = require("./resolveConstants");
+// ─── Wrapper method resolution ────────────────────────────────────────────────
+/**
+ * Given a function call expression like `getUsers(apiClient)`, look up the
+ * callee in the call graph, recurse into its body (up to maxDepth), and return
+ * any HTTP calls found inside.
+ */
+function resolveWrapperCall(callee, graph, table, sourceFile, sourceLanguage, maxDepth, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return [];
+    const node = graph.get(callee);
+    if (!node)
+        return [];
+    const results = [];
+    // Direct HTTP calls found inside this function body
+    for (const { method, path } of node.directHttpCalls) {
+        const normalized = (0, resolvePaths_1.normalizePathToTemplate)(path);
+        results.push({
+            method,
+            path,
+            normalizedPath: normalized !== path ? normalized : undefined,
+            sourceFile,
+            sourceLanguage,
+            resolutionType: 'wrapper-method',
+            confidence: 'high',
+        });
+    }
+    // HTTP calls found by resolving the return value as a path
+    if (node.returnValue) {
+        // If the function returns a path string, it may be used inside a call
+        // that's resolved by the caller. Nothing to add here directly.
+    }
+    // Recurse into called local functions
+    for (const calledName of node.calls) {
+        const nested = resolveWrapperCall(calledName, graph, table, sourceFile, sourceLanguage, maxDepth, currentDepth + 1);
+        for (const call of nested) {
+            results.push({ ...call, resolutionType: 'wrapper-method', confidence: currentDepth === 0 ? 'high' : 'medium' });
+        }
+    }
+    return results;
+}
+/**
+ * Resolve the path returned by a helper function when it is passed as the
+ * argument to an HTTP call.
+ *
+ * Example: client.get(getUserPath(userId))
+ *   → getUserPath is in the call graph, returns `/users/${userId}`
+ *   → normalized: /users/{id}
+ */
+function resolveHelperReturnPath(calleeName, graph, table, maxDepth, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return undefined;
+    const node = graph.get(calleeName);
+    if (!node)
+        return undefined;
+    // Direct return value
+    if (node.returnValue !== undefined) {
+        // Resolve any constants in the return value
+        const resolved = (0, resolveConstants_1.resolveToken)(node.returnValue, table);
+        return resolved !== null && resolved !== void 0 ? resolved : node.returnValue;
+    }
+    // If the function body contains a template literal return
+    const templateReturn = /return\s+`([^`]+)`/.exec(node.body);
+    if (templateReturn) {
+        return templateReturn[1];
+    }
+    // Recurse: if this function itself calls another helper that returns a path
+    for (const called of node.calls) {
+        const nested = resolveHelperReturnPath(called, graph, table, maxDepth, currentDepth + 1);
+        if (nested !== undefined)
+            return nested;
+    }
+    return undefined;
+}
+// ─── Python path builder detection ───────────────────────────────────────────
+/**
+ * Detect calls to local helper functions inside HTTP call argument positions
+ * in Python source.
+ *
+ * Example:
+ *   client.get(build_customer_path(customer_id))
+ *   → extracts 'build_customer_path' as a path-builder call
+ */
+function extractPythonHelperCallsInHttpArgs(content) {
+    const calls = [];
+    // Pattern: .get(helper_name(...)  or requests.get(helper_name(...))
+    const pattern = /\b(?:client|self\.client|requests|httpx)\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/gi;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), helperName: m[2] });
+    }
+    return calls;
+}
+/**
+ * Detect calls to local helper functions inside HTTP call argument positions
+ * in TypeScript/JavaScript source.
+ *
+ * Example:
+ *   client.get(getUserPath(userId))
+ */
+function extractJsHelperCallsInHttpArgs(content) {
+    const calls = [];
+    const pattern = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/gi;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), helperName: m[2] });
+    }
+    return calls;
+}
+/**
+ * Detect calls to local helper functions inside HTTP call argument positions
+ * in Java/Kotlin source.
+ */
+function extractJavaHelperCallsInHttpArgs(content) {
+    const calls = [];
+    // api.get(userPath(id)) or client.get(buildPath(id))
+    const pattern = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([a-z][A-Za-z0-9_]*)\s*\(/gi;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), helperName: m[2] });
+    }
+    return calls;
+}

package/dist/src/coverage/deep-analysis/resolvePaths.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Deep Code Analysis — Path Resolution and Normalization
+ *
+ * Resolves endpoint paths built from:
+ *   - Template literals: `${BASE}/users/${id}`
+ *   - String concatenation: BASE + "/users/" + id
+ *   - Java/Kotlin string concatenation: BASE + "/users/" + id
+ *   - Python f-strings: f"{BASE}/users/{user_id}"
+ *   - Ruby interpolation: "#{BASE}/users/#{id}"
+ *
+ * Also normalizes concrete paths or partially concrete paths to OpenAPI-style
+ * path templates: /users/123 → /users/{id}
+ */
+import type { SymbolTable } from './types';
+/**
+ * Attempt to resolve a JavaScript/TypeScript template literal to a partial or
+ * complete path string.
+ *
+ * Input:  `${BASE_URL}/users/${userId}`
+ * Output: /users/${userId}  (if BASE_URL is known) or
+ *         /users/{userId}   (normalized)
+ */
+export declare function resolveTemplateLiteral(template: string, table: SymbolTable): string;
+/**
+ * Resolve a string concatenation expression like:
+ *   BASE + "/users/" + id
+ *   BASE_URL + RESOURCE_PATH
+ *
+ * Splits on `+` and resolves each token, then joins.
+ * Tokens that cannot be resolved are treated as path parameters.
+ */
+export declare function resolveStringConcatenation(expr: string, table: SymbolTable): string;
+/**
+ * Resolve a Java string concatenation (also uses + operator).
+ * Functionally identical to resolveStringConcatenation but handles Java
+ * specific quoted strings (double quotes only).
+ */
+export declare function resolveJavaConcatenation(expr: string, table: SymbolTable): string;
+/**
+ * Resolve a Python f-string: f"{BASE_URL}/users/{user_id}"
+ *
+ * Input (without the f prefix and outer quotes): {BASE_URL}/users/{user_id}
+ */
+export declare function resolvePythonFString(template: string, table: SymbolTable): string;
+/**
+ * Resolve a Ruby string interpolation: "#{BASE_URL}/users/#{id}"
+ */
+export declare function resolveRubyInterpolation(template: string, table: SymbolTable): string;
+/**
+ * Normalize a concrete or partially-concrete path to an OpenAPI path template.
+ *
+ * Rules:
+ *   - UUID-like segments → {id}
+ *   - Purely numeric IDs → {id}
+ *   - Variable-looking segments like {variable} are kept as-is
+ *   - Short alpha-numeric slugs that look like IDs (>= 8 hex chars) → {id}
+ *
+ * Examples:
+ *   /users/123            → /users/{id}
+ *   /users/abc-def-456    → /users/{id}
+ *   /users/123/orders/9   → /users/{id}/orders/{id}
+ *   /accounts/{accountId} → /accounts/{accountId}  (already a template)
+ */
+export declare function normalizePathToTemplate(rawPath: string): string;
+/**
+ * Detect and extract template literals that may contain a path.
+ * Returns all template literal strings found in the content that look path-like.
+ */
+export declare function extractTemplateLiterals(content: string): string[];
+/**
+ * Detect and extract Python f-string paths.
+ * Returns the inner template strings.
+ */
+export declare function extractPythonFStrings(content: string): string[];
+/**
+ * Strip the scheme and host from a fully qualified URL, returning just the path.
+ * If the input already looks like a path or a template variable, return it unchanged.
+ */
+export declare function stripUrlBase(value: string): string;
+//# sourceMappingURL=resolvePaths.d.ts.map

package/dist/src/coverage/deep-analysis/resolvePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePaths.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/resolvePaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAK3C;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,CAWnF;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,CAwBnF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,CAsBjF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,CAQjF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,CAQrF;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkB/D;AAID;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAWjE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/D;AAID;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQlD"}

package/dist/src/coverage/deep-analysis/resolvePaths.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Deep Code Analysis — Path Resolution and Normalization
+ *
+ * Resolves endpoint paths built from:
+ *   - Template literals: `${BASE}/users/${id}`
+ *   - String concatenation: BASE + "/users/" + id
+ *   - Java/Kotlin string concatenation: BASE + "/users/" + id
+ *   - Python f-strings: f"{BASE}/users/{user_id}"
+ *   - Ruby interpolation: "#{BASE}/users/#{id}"
+ *
+ * Also normalizes concrete paths or partially concrete paths to OpenAPI-style
+ * path templates: /users/123 → /users/{id}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTemplateLiteral = resolveTemplateLiteral;
+exports.resolveStringConcatenation = resolveStringConcatenation;
+exports.resolveJavaConcatenation = resolveJavaConcatenation;
+exports.resolvePythonFString = resolvePythonFString;
+exports.resolveRubyInterpolation = resolveRubyInterpolation;
+exports.normalizePathToTemplate = normalizePathToTemplate;
+exports.extractTemplateLiterals = extractTemplateLiterals;
+exports.extractPythonFStrings = extractPythonFStrings;
+exports.stripUrlBase = stripUrlBase;
+const resolveConstants_1 = require("./resolveConstants");
+// ─── Template literal resolution (TypeScript/JavaScript) ──────────────────────
+/**
+ * Attempt to resolve a JavaScript/TypeScript template literal to a partial or
+ * complete path string.
+ *
+ * Input:  `${BASE_URL}/users/${userId}`
+ * Output: /users/${userId}  (if BASE_URL is known) or
+ *         /users/{userId}   (normalized)
+ */
+function resolveTemplateLiteral(template, table) {
+    // Replace ${IDENTIFIER} with their resolved value or a path parameter placeholder
+    return template.replace(/\$\{([^}]+)\}/g, (_match, expr) => {
+        const resolved = (0, resolveConstants_1.resolveToken)(expr.trim(), table);
+        if (resolved !== undefined) {
+            // If it resolved to a URL base, strip the scheme+host
+            return stripUrlBase(resolved);
+        }
+        // Unknown identifer — treat as a path parameter
+        return `{${expr.trim()}}`;
+    });
+}
+/**
+ * Resolve a string concatenation expression like:
+ *   BASE + "/users/" + id
+ *   BASE_URL + RESOURCE_PATH
+ *
+ * Splits on `+` and resolves each token, then joins.
+ * Tokens that cannot be resolved are treated as path parameters.
+ */
+function resolveStringConcatenation(expr, table) {
+    const fragments = expr.split(/\s*\+\s*/);
+    const parts = [];
+    for (const frag of fragments) {
+        const trimmed = frag.trim();
+        if (!trimmed)
+            continue;
+        // Quoted literal
+        if (/^['"`]/.test(trimmed)) {
+            parts.push(trimmed.slice(1, -1));
+            continue;
+        }
+        const resolved = (0, resolveConstants_1.resolveToken)(trimmed, table);
+        if (resolved !== undefined) {
+            parts.push(stripUrlBase(resolved));
+        }
+        else {
+            // Identifier with unknown value → path parameter
+            parts.push(`{${trimmed}}`);
+        }
+    }
+    return parts.join('');
+}
+/**
+ * Resolve a Java string concatenation (also uses + operator).
+ * Functionally identical to resolveStringConcatenation but handles Java
+ * specific quoted strings (double quotes only).
+ */
+function resolveJavaConcatenation(expr, table) {
+    const fragments = expr.split(/\s*\+\s*/);
+    const parts = [];
+    for (const frag of fragments) {
+        const trimmed = frag.trim();
+        if (!trimmed)
+            continue;
+        if (/^"[^"]*"$/.test(trimmed)) {
+            parts.push(trimmed.slice(1, -1));
+            continue;
+        }
+        const resolved = (0, resolveConstants_1.resolveToken)(trimmed, table);
+        if (resolved !== undefined) {
+            parts.push(stripUrlBase(resolved));
+        }
+        else {
+            parts.push(`{${trimmed}}`);
+        }
+    }
+    return parts.join('');
+}
+/**
+ * Resolve a Python f-string: f"{BASE_URL}/users/{user_id}"
+ *
+ * Input (without the f prefix and outer quotes): {BASE_URL}/users/{user_id}
+ */
+function resolvePythonFString(template, table) {
+    return template.replace(/\{([^}]+)\}/g, (_match, expr) => {
+        const resolved = (0, resolveConstants_1.resolveToken)(expr.trim(), table);
+        if (resolved !== undefined) {
+            return stripUrlBase(resolved);
+        }
+        return `{${expr.trim()}}`;
+    });
+}
+/**
+ * Resolve a Ruby string interpolation: "#{BASE_URL}/users/#{id}"
+ */
+function resolveRubyInterpolation(template, table) {
+    return template.replace(/#\{([^}]+)\}/g, (_match, expr) => {
+        const resolved = (0, resolveConstants_1.resolveToken)(expr.trim(), table);
+        if (resolved !== undefined) {
+            return stripUrlBase(resolved);
+        }
+        return `{${expr.trim()}}`;
+    });
+}
+// ─── Path normalization ───────────────────────────────────────────────────────
+/**
+ * Normalize a concrete or partially-concrete path to an OpenAPI path template.
+ *
+ * Rules:
+ *   - UUID-like segments → {id}
+ *   - Purely numeric IDs → {id}
+ *   - Variable-looking segments like {variable} are kept as-is
+ *   - Short alpha-numeric slugs that look like IDs (>= 8 hex chars) → {id}
+ *
+ * Examples:
+ *   /users/123            → /users/{id}
+ *   /users/abc-def-456    → /users/{id}
+ *   /users/123/orders/9   → /users/{id}/orders/{id}
+ *   /accounts/{accountId} → /accounts/{accountId}  (already a template)
+ */
+function normalizePathToTemplate(rawPath) {
+    return rawPath
+        .split('/')
+        .map((segment) => {
+        if (!segment)
+            return segment;
+        // Already a template parameter
+        if (/^\{.+\}$/.test(segment))
+            return segment;
+        // Purely numeric
+        if (/^\d+$/.test(segment))
+            return '{id}';
+        // UUID
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment))
+            return '{id}';
+        // Long hex / alphanumeric slug (>= 8 chars, looks like an ID, not a resource word)
+        if (/^[0-9a-f]{8,}$/i.test(segment) && !/^[a-z]+$/i.test(segment))
+            return '{id}';
+        // Mixed alphanumeric that looks like a slug: abc-123, def_456
+        if (/^[a-z0-9]+-[a-z0-9-]+$/i.test(segment) && /\d/.test(segment))
+            return '{id}';
+        return segment;
+    })
+        .join('/');
+}
+// ─── Extraction helpers ───────────────────────────────────────────────────────
+/**
+ * Detect and extract template literals that may contain a path.
+ * Returns all template literal strings found in the content that look path-like.
+ */
+function extractTemplateLiterals(content) {
+    const results = [];
+    // Template literals that contain at least one /
+    const pattern = /`([^`]*\/[^`]*)`/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+        if (!m[1].includes('\n')) {
+            results.push(m[1]);
+        }
+    }
+    return results;
+}
+/**
+ * Detect and extract Python f-string paths.
+ * Returns the inner template strings.
+ */
+function extractPythonFStrings(content) {
+    const results = [];
+    const pattern = /f['"]([^'"]*\/[^'"]*)['"]/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+        results.push(m[1]);
+    }
+    return results;
+}
+// ─── Utility ──────────────────────────────────────────────────────────────────
+/**
+ * Strip the scheme and host from a fully qualified URL, returning just the path.
+ * If the input already looks like a path or a template variable, return it unchanged.
+ */
+function stripUrlBase(value) {
+    if (value.startsWith('/') || value.startsWith('{'))
+        return value;
+    try {
+        const url = new URL(value);
+        return url.pathname;
+    }
+    catch {
+        return value;
+    }
+}

package/dist/src/coverage/deep-analysis/resolveRequestWrappers.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Deep Code Analysis — Request Object and Builder Pattern Resolution
+ *
+ * Detects and resolves HTTP calls that are hidden inside request object
+ * construction or builder patterns.
+ *
+ * Supported patterns:
+ *
+ * TypeScript/JavaScript:
+ *   const request = new ApiRequest('GET', '/users');
+ *   client.execute(request);
+ *
+ * Java:
+ *   Request req = Request.builder().method(GET).path("/users").build();
+ *   client.execute(req);
+ *
+ * Kotlin:
+ *   val req = RequestBuilder().get().path("/users").build()
+ *   api.execute(req)
+ *
+ * Python:
+ *   request = ApiRequest(method='GET', path='/users')
+ *   client.execute(request)
+ */
+import type { SymbolTable } from './types';
+export interface RequestObjectCall {
+    method: string;
+    path: string;
+    normalizedPath?: string;
+    confidence: 'high' | 'medium' | 'low';
+    pattern: string;
+}
+/**
+ * Extract HTTP calls from TypeScript/JavaScript request object and builder patterns.
+ *
+ * Detects:
+ *   new ApiRequest('GET', '/users')
+ *   new Request({ method: 'GET', url: '/users' })
+ *   ApiRequest.create({ method: 'get', path: '/users' })
+ */
+export declare function extractJsRequestBuilders(content: string, table: SymbolTable): RequestObjectCall[];
+/**
+ * Extract HTTP calls from Java builder patterns.
+ *
+ * Detects:
+ *   Request.builder().method(HttpMethod.GET).path("/users").build()
+ *   new HttpRequest.Builder().uri("/users").method("GET", ...).build()
+ *   MockMvcRequestBuilders.get("/users")
+ */
+export declare function extractJavaRequestBuilders(content: string, table: SymbolTable): RequestObjectCall[];
+/**
+ * Extract HTTP calls from Kotlin builder patterns.
+ *
+ * Detects:
+ *   RequestBuilder().get().path("/users").build()
+ *   val req = RequestBuilder().method("GET").path("/users").build()
+ */
+export declare function extractKotlinRequestBuilders(content: string, table: SymbolTable): RequestObjectCall[];
+/**
+ * Extract HTTP calls from Python request object patterns.
+ *
+ * Detects:
+ *   ApiRequest(method='GET', path='/users')
+ *   requests.Request('GET', '/users')
+ */
+export declare function extractPythonRequestBuilders(content: string, table: SymbolTable): RequestObjectCall[];
+/**
+ * Extract request builder / request object HTTP calls for any supported language.
+ */
+export declare function extractRequestBuilders(content: string, language: string, table: SymbolTable): RequestObjectCall[];
+//# sourceMappingURL=resolveRequestWrappers.d.ts.map

package/dist/src/coverage/deep-analysis/resolveRequestWrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveRequestWrappers.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/resolveRequestWrappers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAID;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,GACjB,iBAAiB,EAAE,CAkDrB;AAID;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,GACjB,iBAAiB,EAAE,CAmCrB;AAID;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,GACjB,iBAAiB,EAAE,CAmCrB;AAID;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,GACjB,iBAAiB,EAAE,CAmCrB;AAID;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,WAAW,GACjB,iBAAiB,EAAE,CAarB"}