distill-mcp 0.6.0-beta

package/dist/ast/php/parser.test.js

@@ -0,0 +1,328 @@
+/**
+ * PHP Tree-sitter Parser Tests
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { phpTreeSitterParser, parsePhpAsync, initPhpParser, } from "./parser.js";
+// Sample PHP code for testing
+const SAMPLE_PHP = `<?php
+
+namespace App\\Models;
+
+use Illuminate\\Database\\Eloquent\\Model;
+use App\\Traits\\HasTimestamps;
+use App\\Contracts\\UserInterface;
+
+/**
+ * Maximum number of users allowed
+ */
+const MAX_USERS = 100;
+
+/**
+ * Represents a user in the system
+ */
+class User extends Model implements UserInterface
+{
+    use HasTimestamps;
+
+    /**
+     * The user's name
+     */
+    public string $name;
+
+    /**
+     * The user's email
+     */
+    protected string $email;
+
+    /**
+     * The user's password hash
+     */
+    private string $password;
+
+    /**
+     * Create a new user instance
+     */
+    public function __construct(string $name, string $email)
+    {
+        $this->name = $name;
+        $this->email = $email;
+    }
+
+    /**
+     * Get the user's greeting
+     */
+    public function greet(): string
+    {
+        return "Hello, " . $this->name;
+    }
+
+    /**
+     * Check if user is admin
+     */
+    public static function isAdmin(): bool
+    {
+        return false;
+    }
+
+    /**
+     * Internal helper method
+     */
+    private function hashPassword(string $password): string
+    {
+        return password_hash($password, PASSWORD_DEFAULT);
+    }
+}
+
+/**
+ * Admin user with extra permissions
+ */
+class AdminUser extends User
+{
+    /**
+     * The admin's permissions
+     */
+    protected array $permissions = [];
+
+    /**
+     * Check if admin has a permission
+     */
+    public function hasPermission(string $perm): bool
+    {
+        return in_array($perm, $this->permissions);
+    }
+}
+
+/**
+ * Interface for user-related operations
+ */
+interface Authenticatable
+{
+    /**
+     * Authenticate the user
+     */
+    public function authenticate(string $password): bool;
+
+    /**
+     * Get the user's ID
+     */
+    public function getId(): int;
+}
+
+/**
+ * Trait for soft deletes
+ */
+trait SoftDeletes
+{
+    /**
+     * Soft delete the model
+     */
+    public function softDelete(): void
+    {
+        $this->deleted_at = new DateTime();
+    }
+}
+
+/**
+ * Calculate the sum of numbers
+ */
+function calculateSum(array $numbers): int
+{
+    return array_sum($numbers);
+}
+
+/**
+ * Private helper function
+ */
+function privateHelper(): void
+{
+    // internal function
+}
+`;
+describe("PHP Tree-sitter Parser", () => {
+    beforeAll(async () => {
+        await initPhpParser();
+    });
+    describe("parsePhpAsync", () => {
+        it("should parse use statements correctly", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            expect(structure.language).toBe("php");
+            expect(structure.imports.length).toBeGreaterThanOrEqual(3);
+            const importNames = structure.imports.map((i) => i.name);
+            expect(importNames).toContain("Model");
+            expect(importNames).toContain("HasTimestamps");
+            expect(importNames).toContain("UserInterface");
+        });
+        it("should parse functions correctly", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const funcNames = structure.functions
+                .filter((f) => f.type === "function")
+                .map((f) => f.name);
+            expect(funcNames).toContain("calculateSum");
+            expect(funcNames).toContain("privateHelper");
+        });
+        it("should parse methods correctly", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const methods = structure.functions.filter((f) => f.type === "method");
+            expect(methods.length).toBeGreaterThanOrEqual(5);
+            const methodNames = methods.map((m) => m.name);
+            expect(methodNames).toContain("__construct");
+            expect(methodNames).toContain("greet");
+            expect(methodNames).toContain("isAdmin");
+            expect(methodNames).toContain("hashPassword");
+        });
+        it("should track parent class for methods", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const greet = structure.functions.find((f) => f.name === "greet");
+            expect(greet?.parent).toBe("User");
+            const hasPermission = structure.functions.find((f) => f.name === "hasPermission");
+            expect(hasPermission?.parent).toBe("AdminUser");
+        });
+        it("should parse classes correctly", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            expect(structure.classes.length).toBeGreaterThanOrEqual(2);
+            const classNames = structure.classes.map((c) => c.name);
+            expect(classNames).toContain("User");
+            expect(classNames).toContain("AdminUser");
+        });
+        it("should parse traits as classes", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const classNames = structure.classes.map((c) => c.name);
+            expect(classNames).toContain("SoftDeletes");
+        });
+        it("should parse interfaces", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            expect(structure.interfaces.length).toBeGreaterThanOrEqual(1);
+            const interfaceNames = structure.interfaces.map((i) => i.name);
+            expect(interfaceNames).toContain("Authenticatable");
+        });
+        it("should extract PHPDoc comments", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const userClass = structure.classes.find((c) => c.name === "User");
+            expect(userClass?.documentation).toContain("Represents a user");
+            const calcSum = structure.functions.find((f) => f.name === "calculateSum");
+            expect(calcSum?.documentation).toContain("Calculate the sum");
+        });
+        it("should parse constants", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const varNames = structure.variables.map((v) => v.name);
+            expect(varNames).toContain("MAX_USERS");
+        });
+        it("should return correct line numbers", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const userClass = structure.classes.find((c) => c.name === "User");
+            expect(userClass?.startLine).toBeGreaterThan(0);
+            expect(userClass?.endLine).toBeGreaterThan(userClass?.startLine ?? 0);
+        });
+        it("should detect visibility", async () => {
+            const structure = await parsePhpAsync(SAMPLE_PHP);
+            const greet = structure.functions.find((f) => f.name === "greet");
+            expect(greet?.isExported).toBe(true); // public
+            const hashPassword = structure.functions.find((f) => f.name === "hashPassword");
+            expect(hashPassword?.isExported).toBe(false); // private
+        });
+    });
+    describe("LanguageParser interface", () => {
+        it("should implement parse() method", () => {
+            const structure = phpTreeSitterParser.parse(SAMPLE_PHP);
+            expect(structure).toBeDefined();
+            expect(structure.language).toBe("php");
+        });
+        it("should implement extractElement() method for functions", async () => {
+            await initPhpParser();
+            const result = phpTreeSitterParser.extractElement(SAMPLE_PHP, { type: "function", name: "calculateSum" }, { includeImports: true, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("function calculateSum");
+            expect(result?.elements[0]?.name).toBe("calculateSum");
+        });
+        it("should extract methods by name", async () => {
+            await initPhpParser();
+            const result = phpTreeSitterParser.extractElement(SAMPLE_PHP, { type: "method", name: "greet" }, { includeImports: false, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("function greet");
+        });
+        it("should extract classes by name", async () => {
+            await initPhpParser();
+            const result = phpTreeSitterParser.extractElement(SAMPLE_PHP, { type: "class", name: "User" }, { includeImports: false, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("class User");
+        });
+        it("should implement searchElements() method", async () => {
+            await initPhpParser();
+            const results = phpTreeSitterParser.searchElements(SAMPLE_PHP, "user");
+            expect(results.length).toBeGreaterThan(0);
+            const names = results.map((r) => r.name.toLowerCase());
+            expect(names.some((n) => n.includes("user"))).toBe(true);
+        });
+        it("should return null for non-existent elements", async () => {
+            await initPhpParser();
+            const result = phpTreeSitterParser.extractElement(SAMPLE_PHP, { type: "function", name: "nonExistentFunc" }, { includeImports: false, includeComments: false });
+            expect(result).toBeNull();
+        });
+    });
+    describe("Edge cases", () => {
+        it("should handle empty content", async () => {
+            const structure = await parsePhpAsync("<?php");
+            expect(structure.language).toBe("php");
+            expect(structure.functions).toHaveLength(0);
+        });
+        it("should handle simple use statement", async () => {
+            const code = `<?php
+use App\\Models\\User;
+
+function test(): void {}
+`;
+            const structure = await parsePhpAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle use with alias", async () => {
+            const code = `<?php
+use App\\Models\\User as UserModel;
+use App\\Services\\Auth as AuthService;
+`;
+            const structure = await parsePhpAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should handle grouped use", async () => {
+            const code = `<?php
+use App\\Models\\{User, Post, Comment};
+`;
+            const structure = await parsePhpAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle abstract classes", async () => {
+            const code = `<?php
+abstract class BaseModel
+{
+    abstract public function save(): void;
+}
+`;
+            const structure = await parsePhpAsync(code);
+            expect(structure.classes.some((c) => c.name === "BaseModel")).toBe(true);
+        });
+        it("should handle final classes", async () => {
+            const code = `<?php
+final class FinalClass
+{
+    public function method(): void {}
+}
+`;
+            const structure = await parsePhpAsync(code);
+            expect(structure.classes.some((c) => c.name === "FinalClass")).toBe(true);
+        });
+        it("should handle static methods", async () => {
+            const code = `<?php
+class Helper
+{
+    public static function format(string $value): string
+    {
+        return trim($value);
+    }
+}
+`;
+            const structure = await parsePhpAsync(code);
+            const format = structure.functions.find((f) => f.name === "format");
+            expect(format).toBeDefined();
+            expect(format?.signature).toContain("static");
+        });
+    });
+});

package/dist/ast/php/queries.d.ts

@@ -0,0 +1,61 @@
+/**
+ * PHP Tree-sitter Queries
+ *
+ * S-expression queries for extracting PHP code elements.
+ */
+/**
+ * Query to find all function definitions
+ */
+export declare const FUNCTION_QUERY = "\n(function_definition\n  name: (name) @name) @function\n";
+/**
+ * Query to find all class declarations
+ */
+export declare const CLASS_QUERY = "\n(class_declaration\n  name: (name) @name) @class\n";
+/**
+ * Query to find all interface declarations
+ */
+export declare const INTERFACE_QUERY = "\n(interface_declaration\n  name: (name) @name) @interface\n";
+/**
+ * Query to find all trait declarations
+ */
+export declare const TRAIT_QUERY = "\n(trait_declaration\n  name: (name) @name) @trait\n";
+/**
+ * Query to find all namespace definitions
+ */
+export declare const NAMESPACE_QUERY = "\n(namespace_definition\n  name: (namespace_name) @name) @namespace\n";
+/**
+ * Query to find all use declarations (imports)
+ */
+export declare const USE_QUERY = "\n(namespace_use_declaration) @use\n";
+/**
+ * Query to find all method declarations
+ */
+export declare const METHOD_QUERY = "\n(method_declaration\n  name: (name) @name) @method\n";
+/**
+ * Query to find all property declarations
+ */
+export declare const PROPERTY_QUERY = "\n(property_declaration) @property\n";
+/**
+ * Query to find const declarations
+ */
+export declare const CONST_QUERY = "\n(const_declaration) @const\n";
+/**
+ * Combined query for all definitions
+ */
+export declare const ALL_DEFINITIONS_QUERY = "\n; Namespace definitions\n(namespace_definition\n  name: (namespace_name) @namespace_name) @namespace\n\n; Use declarations (imports)\n(namespace_use_declaration) @use_decl\n\n; Function definitions\n(function_definition\n  name: (name) @func_name) @function\n\n; Class declarations\n(class_declaration\n  name: (name) @class_name) @class\n\n; Interface declarations\n(interface_declaration\n  name: (name) @interface_name) @interface\n\n; Trait declarations\n(trait_declaration\n  name: (name) @trait_name) @trait\n\n; Method declarations\n(method_declaration\n  name: (name) @method_name) @method\n\n; Const declarations\n(const_declaration) @const\n\n; Property declarations\n(property_declaration) @property\n";
+/**
+ * Query patterns as a single object for easy access
+ */
+export declare const QUERIES: {
+    readonly function: "\n(function_definition\n  name: (name) @name) @function\n";
+    readonly class: "\n(class_declaration\n  name: (name) @name) @class\n";
+    readonly interface: "\n(interface_declaration\n  name: (name) @name) @interface\n";
+    readonly trait: "\n(trait_declaration\n  name: (name) @name) @trait\n";
+    readonly namespace: "\n(namespace_definition\n  name: (namespace_name) @name) @namespace\n";
+    readonly use: "\n(namespace_use_declaration) @use\n";
+    readonly method: "\n(method_declaration\n  name: (name) @name) @method\n";
+    readonly property: "\n(property_declaration) @property\n";
+    readonly const: "\n(const_declaration) @const\n";
+    readonly all: "\n; Namespace definitions\n(namespace_definition\n  name: (namespace_name) @namespace_name) @namespace\n\n; Use declarations (imports)\n(namespace_use_declaration) @use_decl\n\n; Function definitions\n(function_definition\n  name: (name) @func_name) @function\n\n; Class declarations\n(class_declaration\n  name: (name) @class_name) @class\n\n; Interface declarations\n(interface_declaration\n  name: (name) @interface_name) @interface\n\n; Trait declarations\n(trait_declaration\n  name: (name) @trait_name) @trait\n\n; Method declarations\n(method_declaration\n  name: (name) @method_name) @method\n\n; Const declarations\n(const_declaration) @const\n\n; Property declarations\n(property_declaration) @property\n";
+};
+//# sourceMappingURL=queries.d.ts.map

package/dist/ast/php/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/ast/php/queries.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,8DAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,yDAGvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,iEAG3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,yDAGvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,0EAG3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,yCAErB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,2DAGxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,yCAE1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,mCAEvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,+sBAiCjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;CAWV,CAAC"}

package/dist/ast/php/queries.js

@@ -0,0 +1,117 @@
+/**
+ * PHP Tree-sitter Queries
+ *
+ * S-expression queries for extracting PHP code elements.
+ */
+/**
+ * Query to find all function definitions
+ */
+export const FUNCTION_QUERY = `
+(function_definition
+  name: (name) @name) @function
+`;
+/**
+ * Query to find all class declarations
+ */
+export const CLASS_QUERY = `
+(class_declaration
+  name: (name) @name) @class
+`;
+/**
+ * Query to find all interface declarations
+ */
+export const INTERFACE_QUERY = `
+(interface_declaration
+  name: (name) @name) @interface
+`;
+/**
+ * Query to find all trait declarations
+ */
+export const TRAIT_QUERY = `
+(trait_declaration
+  name: (name) @name) @trait
+`;
+/**
+ * Query to find all namespace definitions
+ */
+export const NAMESPACE_QUERY = `
+(namespace_definition
+  name: (namespace_name) @name) @namespace
+`;
+/**
+ * Query to find all use declarations (imports)
+ */
+export const USE_QUERY = `
+(namespace_use_declaration) @use
+`;
+/**
+ * Query to find all method declarations
+ */
+export const METHOD_QUERY = `
+(method_declaration
+  name: (name) @name) @method
+`;
+/**
+ * Query to find all property declarations
+ */
+export const PROPERTY_QUERY = `
+(property_declaration) @property
+`;
+/**
+ * Query to find const declarations
+ */
+export const CONST_QUERY = `
+(const_declaration) @const
+`;
+/**
+ * Combined query for all definitions
+ */
+export const ALL_DEFINITIONS_QUERY = `
+; Namespace definitions
+(namespace_definition
+  name: (namespace_name) @namespace_name) @namespace
+
+; Use declarations (imports)
+(namespace_use_declaration) @use_decl
+
+; Function definitions
+(function_definition
+  name: (name) @func_name) @function
+
+; Class declarations
+(class_declaration
+  name: (name) @class_name) @class
+
+; Interface declarations
+(interface_declaration
+  name: (name) @interface_name) @interface
+
+; Trait declarations
+(trait_declaration
+  name: (name) @trait_name) @trait
+
+; Method declarations
+(method_declaration
+  name: (name) @method_name) @method
+
+; Const declarations
+(const_declaration) @const
+
+; Property declarations
+(property_declaration) @property
+`;
+/**
+ * Query patterns as a single object for easy access
+ */
+export const QUERIES = {
+    function: FUNCTION_QUERY,
+    class: CLASS_QUERY,
+    interface: INTERFACE_QUERY,
+    trait: TRAIT_QUERY,
+    namespace: NAMESPACE_QUERY,
+    use: USE_QUERY,
+    method: METHOD_QUERY,
+    property: PROPERTY_QUERY,
+    const: CONST_QUERY,
+    all: ALL_DEFINITIONS_QUERY,
+};

package/dist/ast/php/utils.d.ts

@@ -0,0 +1,83 @@
+/**
+ * PHP Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting PHP-specific constructs.
+ */
+import type Parser from "web-tree-sitter";
+type Node = Parser.SyntaxNode;
+import type { CodeElement, ElementType } from "../types.js";
+/**
+ * Get line number from a Tree-sitter node (1-indexed)
+ */
+export declare function getLineNumber(node: Node): number;
+/**
+ * Get end line number from a Tree-sitter node (1-indexed)
+ */
+export declare function getEndLineNumber(node: Node): number;
+/**
+ * Extract PHPDoc comment from above a declaration
+ * PHP uses block doc comments starting with /**
+ */
+export declare function extractPhpDoc(node: Node, lines: string[]): string | undefined;
+/**
+ * Get visibility from a node (public, private, protected)
+ */
+export declare function getVisibility(node: Node): string | undefined;
+/**
+ * Check if a node has public visibility (explicit or default)
+ */
+export declare function isPublic(node: Node): boolean;
+/**
+ * Check if a function/method has static modifier
+ */
+export declare function isStatic(node: Node): boolean;
+/**
+ * Get function signature from a function_definition node
+ */
+export declare function getFunctionSignature(node: Node): string;
+/**
+ * Get method signature from a method_declaration node
+ */
+export declare function getMethodSignature(node: Node): string;
+/**
+ * Get class signature
+ */
+export declare function getClassSignature(node: Node): string;
+/**
+ * Get interface signature
+ */
+export declare function getInterfaceSignature(node: Node): string;
+/**
+ * Get trait signature
+ */
+export declare function getTraitSignature(node: Node): string;
+/**
+ * Extract the use path from a namespace_use_declaration
+ */
+export declare function getUsePath(node: Node): string;
+/**
+ * Get the short name from a use path
+ * e.g., "App\\Models\\User" -> "User"
+ */
+export declare function getUseShortName(usePath: string): string;
+/**
+ * Get const declaration info
+ */
+export declare function getConstSignature(node: Node): string;
+/**
+ * Get const name from declaration
+ */
+export declare function getConstName(node: Node): string;
+/**
+ * Create a CodeElement from a Tree-sitter node
+ */
+export declare function createCodeElement(type: ElementType, name: string, node: Node, options?: {
+    signature?: string;
+    documentation?: string;
+    isAsync?: boolean;
+    isExported?: boolean;
+    parent?: string;
+}): CodeElement;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/ast/php/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ast/php/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAC1C,KAAK,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5D;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAyC7E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAO5D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAG5C;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAO5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAUvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAYrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAkBpD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAIxD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAIpD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAY7C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoBvD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAYpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAW/C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,WAAW,CAYb"}