distill-mcp 0.6.0-beta

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

@@ -0,0 +1,329 @@
+/**
+ * Rust Tree-sitter Parser Tests
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { rustTreeSitterParser, parseRustAsync, initRustParser, } from "./parser.js";
+// Sample Rust code for testing
+const SAMPLE_RUST = `
+use std::collections::HashMap;
+use std::io::{self, Read, Write};
+use serde::{Deserialize, Serialize};
+
+/// Maximum allowed size for the buffer
+pub const MAX_SIZE: usize = 1024;
+
+/// Debug mode flag
+static DEBUG: bool = false;
+
+/// Represents a user in the system
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct User {
+    pub name: String,
+    pub age: u32,
+}
+
+impl User {
+    /// Creates a new user with the given name and age
+    pub fn new(name: String, age: u32) -> Self {
+        Self { name, age }
+    }
+
+    /// Returns a greeting message
+    pub fn greet(&self) -> String {
+        format!("Hello, {}!", self.name)
+    }
+
+    /// Fetches user data as a map
+    async fn fetch_data(&self) -> HashMap<String, String> {
+        let mut data = HashMap::new();
+        data.insert("name".to_string(), self.name.clone());
+        data
+    }
+}
+
+/// Admin user with additional permissions
+pub struct AdminUser {
+    user: User,
+    permissions: Vec<String>,
+}
+
+impl AdminUser {
+    /// Checks if the admin has a specific permission
+    pub fn has_permission(&self, perm: &str) -> bool {
+        self.permissions.iter().any(|p| p == perm)
+    }
+}
+
+/// Represents different error types
+pub enum AppError {
+    NotFound,
+    Unauthorized,
+    InternalError(String),
+}
+
+/// Handler trait for processing requests
+pub trait Handler {
+    /// Handles the incoming request
+    fn handle(&self, request: &str) -> Result<String, AppError>;
+
+    /// Gets the handler name
+    fn name(&self) -> &str;
+}
+
+/// Calculates the sum of numbers
+pub fn calculate_sum(numbers: &[i32]) -> i32 {
+    numbers.iter().sum()
+}
+
+/// Private function for internal use
+fn private_func() {
+    // internal function
+}
+
+/// Async function that processes data
+pub async fn process_data(data: &str) -> Result<String, io::Error> {
+    Ok(data.to_uppercase())
+}
+
+/// Type alias for a result type
+pub type AppResult<T> = Result<T, AppError>;
+
+/// Module for utilities
+mod utils {
+    pub fn helper() {}
+}
+`;
+describe("Rust Tree-sitter Parser", () => {
+    beforeAll(async () => {
+        await initRustParser();
+    });
+    describe("parseRustAsync", () => {
+        it("should parse use statements correctly", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            expect(structure.language).toBe("rust");
+            expect(structure.imports.length).toBeGreaterThanOrEqual(3);
+            const importNames = structure.imports.map((i) => i.name);
+            expect(importNames).toContain("HashMap");
+            expect(importNames.some((n) => n.includes("Read") || n.includes("Write"))).toBe(true);
+        });
+        it("should parse functions correctly", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const funcNames = structure.functions.map((f) => f.name);
+            expect(funcNames).toContain("calculate_sum");
+            expect(funcNames).toContain("private_func");
+            expect(funcNames).toContain("process_data");
+        });
+        it("should detect exported functions (pub)", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const calcSum = structure.functions.find((f) => f.name === "calculate_sum");
+            expect(calcSum?.isExported).toBe(true);
+            const privateFunc = structure.functions.find((f) => f.name === "private_func");
+            expect(privateFunc?.isExported).toBe(false);
+        });
+        it("should detect async functions", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const processData = structure.functions.find((f) => f.name === "process_data");
+            expect(processData?.isAsync).toBe(true);
+            const calcSum = structure.functions.find((f) => f.name === "calculate_sum");
+            expect(calcSum?.isAsync).toBeFalsy();
+        });
+        it("should parse methods from impl blocks", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const methods = structure.functions.filter((f) => f.type === "method");
+            expect(methods.length).toBeGreaterThanOrEqual(4);
+            const methodNames = methods.map((m) => m.name);
+            expect(methodNames).toContain("new");
+            expect(methodNames).toContain("greet");
+            expect(methodNames).toContain("fetch_data");
+            expect(methodNames).toContain("has_permission");
+        });
+        it("should track parent type for methods", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const greet = structure.functions.find((f) => f.name === "greet");
+            expect(greet?.parent).toBe("User");
+            const hasPermission = structure.functions.find((f) => f.name === "has_permission");
+            expect(hasPermission?.parent).toBe("AdminUser");
+        });
+        it("should parse structs as classes", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            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 enums as classes", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const classNames = structure.classes.map((c) => c.name);
+            expect(classNames).toContain("AppError");
+        });
+        it("should detect exported structs (pub)", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const user = structure.classes.find((c) => c.name === "User");
+            expect(user?.isExported).toBe(true);
+        });
+        it("should parse traits as interfaces", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            expect(structure.interfaces.length).toBeGreaterThanOrEqual(1);
+            const interfaceNames = structure.interfaces.map((i) => i.name);
+            expect(interfaceNames).toContain("Handler");
+        });
+        it("should extract doc comments", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const userStruct = structure.classes.find((c) => c.name === "User");
+            expect(userStruct?.documentation).toContain("Represents a user");
+            const calcSum = structure.functions.find((f) => f.name === "calculate_sum");
+            expect(calcSum?.documentation).toContain("Calculates the sum");
+        });
+        it("should parse constants", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const varNames = structure.variables.map((v) => v.name);
+            expect(varNames).toContain("MAX_SIZE");
+        });
+        it("should parse static variables", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const varNames = structure.variables.map((v) => v.name);
+            expect(varNames).toContain("DEBUG");
+        });
+        it("should parse type aliases", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const typeNames = structure.types.map((t) => t.name);
+            expect(typeNames).toContain("AppResult");
+        });
+        it("should return correct line numbers", async () => {
+            const structure = await parseRustAsync(SAMPLE_RUST);
+            const userStruct = structure.classes.find((c) => c.name === "User");
+            expect(userStruct?.startLine).toBeGreaterThan(0);
+            expect(userStruct?.endLine).toBeGreaterThan(userStruct?.startLine ?? 0);
+        });
+    });
+    describe("LanguageParser interface", () => {
+        it("should implement parse() method", () => {
+            const structure = rustTreeSitterParser.parse(SAMPLE_RUST);
+            expect(structure).toBeDefined();
+            expect(structure.language).toBe("rust");
+        });
+        it("should implement extractElement() method for functions", async () => {
+            await initRustParser();
+            const result = rustTreeSitterParser.extractElement(SAMPLE_RUST, { type: "function", name: "calculate_sum" }, { includeImports: true, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("fn calculate_sum");
+            expect(result?.elements[0]?.name).toBe("calculate_sum");
+        });
+        it("should extract methods by name", async () => {
+            await initRustParser();
+            const result = rustTreeSitterParser.extractElement(SAMPLE_RUST, { type: "method", name: "greet" }, { includeImports: false, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("fn greet");
+        });
+        it("should extract structs by name", async () => {
+            await initRustParser();
+            const result = rustTreeSitterParser.extractElement(SAMPLE_RUST, { type: "class", name: "User" }, { includeImports: false, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("pub struct User");
+        });
+        it("should implement searchElements() method", async () => {
+            await initRustParser();
+            const results = rustTreeSitterParser.searchElements(SAMPLE_RUST, "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 initRustParser();
+            const result = rustTreeSitterParser.extractElement(SAMPLE_RUST, { type: "function", name: "non_existent_func" }, { includeImports: false, includeComments: false });
+            expect(result).toBeNull();
+        });
+    });
+    describe("Edge cases", () => {
+        it("should handle empty content", async () => {
+            const structure = await parseRustAsync("");
+            expect(structure.language).toBe("rust");
+            expect(structure.totalLines).toBe(1);
+            expect(structure.functions).toHaveLength(0);
+        });
+        it("should handle simple use statement", async () => {
+            const code = `
+use std::io;
+
+fn main() {}
+`;
+            const structure = await parseRustAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle use with as alias", async () => {
+            const code = `
+use std::collections::HashMap as Map;
+use std::io::Result as IoResult;
+`;
+            const structure = await parseRustAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should handle glob imports", async () => {
+            const code = `
+use std::collections::*;
+`;
+            const structure = await parseRustAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle nested modules in use", async () => {
+            const code = `
+use std::{
+    collections::{HashMap, HashSet},
+    io::{self, Read, Write},
+};
+`;
+            const structure = await parseRustAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle impl for trait", async () => {
+            const code = `
+pub trait Greet {
+    fn greet(&self) -> String;
+}
+
+pub struct Person {
+    name: String,
+}
+
+impl Greet for Person {
+    fn greet(&self) -> String {
+        format!("Hello, {}!", self.name)
+    }
+}
+`;
+            const structure = await parseRustAsync(code);
+            expect(structure.interfaces.length).toBeGreaterThanOrEqual(1);
+            expect(structure.classes.length).toBeGreaterThanOrEqual(1);
+            expect(structure.functions.filter((f) => f.type === "method").length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle generic types", async () => {
+            const code = `
+pub struct Container<T> {
+    value: T,
+}
+
+impl<T> Container<T> {
+    pub fn new(value: T) -> Self {
+        Self { value }
+    }
+}
+`;
+            const structure = await parseRustAsync(code);
+            expect(structure.classes.some((c) => c.name === "Container")).toBe(true);
+        });
+        it("should handle async methods", async () => {
+            const code = `
+pub struct Client {}
+
+impl Client {
+    pub async fn fetch(&self) -> Result<String, Error> {
+        Ok("data".to_string())
+    }
+}
+`;
+            const structure = await parseRustAsync(code);
+            const fetchMethod = structure.functions.find((f) => f.name === "fetch");
+            expect(fetchMethod?.isAsync).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,66 @@
+/**
+ * Rust Tree-sitter Queries
+ *
+ * S-expression queries for extracting Rust code elements.
+ */
+/**
+ * Query to find all function declarations
+ */
+export declare const FUNCTION_QUERY = "\n(function_item\n  name: (identifier) @name) @function\n";
+/**
+ * Query to find all struct declarations
+ */
+export declare const STRUCT_QUERY = "\n(struct_item\n  name: (type_identifier) @name) @struct\n";
+/**
+ * Query to find all enum declarations
+ */
+export declare const ENUM_QUERY = "\n(enum_item\n  name: (type_identifier) @name) @enum\n";
+/**
+ * Query to find all trait declarations
+ */
+export declare const TRAIT_QUERY = "\n(trait_item\n  name: (type_identifier) @name) @trait\n";
+/**
+ * Query to find all impl blocks
+ */
+export declare const IMPL_QUERY = "\n(impl_item\n  type: (type_identifier) @impl_type) @impl\n";
+/**
+ * Query to find all use declarations (imports)
+ */
+export declare const USE_QUERY = "\n(use_declaration) @use\n";
+/**
+ * Query to find type aliases
+ */
+export declare const TYPE_ALIAS_QUERY = "\n(type_item\n  name: (type_identifier) @name) @type_alias\n";
+/**
+ * Query to find const declarations
+ */
+export declare const CONST_QUERY = "\n(const_item\n  name: (identifier) @name) @const\n";
+/**
+ * Query to find static declarations
+ */
+export declare const STATIC_QUERY = "\n(static_item\n  name: (identifier) @name) @static\n";
+/**
+ * Query to find module declarations
+ */
+export declare const MOD_QUERY = "\n(mod_item\n  name: (identifier) @name) @mod\n";
+/**
+ * Combined query for all definitions
+ */
+export declare const ALL_DEFINITIONS_QUERY = "\n; Use declarations (imports)\n(use_declaration) @use_decl\n\n; Function declarations\n(function_item\n  name: (identifier) @func_name) @function\n\n; Struct declarations\n(struct_item\n  name: (type_identifier) @struct_name) @struct\n\n; Enum declarations\n(enum_item\n  name: (type_identifier) @enum_name) @enum\n\n; Trait declarations\n(trait_item\n  name: (type_identifier) @trait_name) @trait\n\n; Impl blocks\n(impl_item) @impl\n\n; Type aliases\n(type_item\n  name: (type_identifier) @type_name) @type_alias\n\n; Const declarations\n(const_item\n  name: (identifier) @const_name) @const\n\n; Static declarations\n(static_item\n  name: (identifier) @static_name) @static\n\n; Module declarations\n(mod_item\n  name: (identifier) @mod_name) @mod\n";
+/**
+ * Query patterns as a single object for easy access
+ */
+export declare const QUERIES: {
+    readonly function: "\n(function_item\n  name: (identifier) @name) @function\n";
+    readonly struct: "\n(struct_item\n  name: (type_identifier) @name) @struct\n";
+    readonly enum: "\n(enum_item\n  name: (type_identifier) @name) @enum\n";
+    readonly trait: "\n(trait_item\n  name: (type_identifier) @name) @trait\n";
+    readonly impl: "\n(impl_item\n  type: (type_identifier) @impl_type) @impl\n";
+    readonly use: "\n(use_declaration) @use\n";
+    readonly typeAlias: "\n(type_item\n  name: (type_identifier) @name) @type_alias\n";
+    readonly const: "\n(const_item\n  name: (identifier) @name) @const\n";
+    readonly static: "\n(static_item\n  name: (identifier) @name) @static\n";
+    readonly mod: "\n(mod_item\n  name: (identifier) @name) @mod\n";
+    readonly all: "\n; Use declarations (imports)\n(use_declaration) @use_decl\n\n; Function declarations\n(function_item\n  name: (identifier) @func_name) @function\n\n; Struct declarations\n(struct_item\n  name: (type_identifier) @struct_name) @struct\n\n; Enum declarations\n(enum_item\n  name: (type_identifier) @enum_name) @enum\n\n; Trait declarations\n(trait_item\n  name: (type_identifier) @trait_name) @trait\n\n; Impl blocks\n(impl_item) @impl\n\n; Type aliases\n(type_item\n  name: (type_identifier) @type_name) @type_alias\n\n; Const declarations\n(const_item\n  name: (identifier) @const_name) @const\n\n; Static declarations\n(static_item\n  name: (identifier) @static_name) @static\n\n; Module declarations\n(mod_item\n  name: (identifier) @mod_name) @mod\n";
+};
+//# sourceMappingURL=queries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/ast/rust/queries.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,8DAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,+DAGxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,2DAGtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,6DAGvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,gEAGtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,+BAErB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,iEAG5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,wDAGvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,0DAGxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,oDAGrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,svBAsCjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;CAYV,CAAC"}

package/dist/ast/rust/queries.js

@@ -0,0 +1,132 @@
+/**
+ * Rust Tree-sitter Queries
+ *
+ * S-expression queries for extracting Rust code elements.
+ */
+/**
+ * Query to find all function declarations
+ */
+export const FUNCTION_QUERY = `
+(function_item
+  name: (identifier) @name) @function
+`;
+/**
+ * Query to find all struct declarations
+ */
+export const STRUCT_QUERY = `
+(struct_item
+  name: (type_identifier) @name) @struct
+`;
+/**
+ * Query to find all enum declarations
+ */
+export const ENUM_QUERY = `
+(enum_item
+  name: (type_identifier) @name) @enum
+`;
+/**
+ * Query to find all trait declarations
+ */
+export const TRAIT_QUERY = `
+(trait_item
+  name: (type_identifier) @name) @trait
+`;
+/**
+ * Query to find all impl blocks
+ */
+export const IMPL_QUERY = `
+(impl_item
+  type: (type_identifier) @impl_type) @impl
+`;
+/**
+ * Query to find all use declarations (imports)
+ */
+export const USE_QUERY = `
+(use_declaration) @use
+`;
+/**
+ * Query to find type aliases
+ */
+export const TYPE_ALIAS_QUERY = `
+(type_item
+  name: (type_identifier) @name) @type_alias
+`;
+/**
+ * Query to find const declarations
+ */
+export const CONST_QUERY = `
+(const_item
+  name: (identifier) @name) @const
+`;
+/**
+ * Query to find static declarations
+ */
+export const STATIC_QUERY = `
+(static_item
+  name: (identifier) @name) @static
+`;
+/**
+ * Query to find module declarations
+ */
+export const MOD_QUERY = `
+(mod_item
+  name: (identifier) @name) @mod
+`;
+/**
+ * Combined query for all definitions
+ */
+export const ALL_DEFINITIONS_QUERY = `
+; Use declarations (imports)
+(use_declaration) @use_decl
+
+; Function declarations
+(function_item
+  name: (identifier) @func_name) @function
+
+; Struct declarations
+(struct_item
+  name: (type_identifier) @struct_name) @struct
+
+; Enum declarations
+(enum_item
+  name: (type_identifier) @enum_name) @enum
+
+; Trait declarations
+(trait_item
+  name: (type_identifier) @trait_name) @trait
+
+; Impl blocks
+(impl_item) @impl
+
+; Type aliases
+(type_item
+  name: (type_identifier) @type_name) @type_alias
+
+; Const declarations
+(const_item
+  name: (identifier) @const_name) @const
+
+; Static declarations
+(static_item
+  name: (identifier) @static_name) @static
+
+; Module declarations
+(mod_item
+  name: (identifier) @mod_name) @mod
+`;
+/**
+ * Query patterns as a single object for easy access
+ */
+export const QUERIES = {
+    function: FUNCTION_QUERY,
+    struct: STRUCT_QUERY,
+    enum: ENUM_QUERY,
+    trait: TRAIT_QUERY,
+    impl: IMPL_QUERY,
+    use: USE_QUERY,
+    typeAlias: TYPE_ALIAS_QUERY,
+    const: CONST_QUERY,
+    static: STATIC_QUERY,
+    mod: MOD_QUERY,
+    all: ALL_DEFINITIONS_QUERY,
+};

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

@@ -0,0 +1,91 @@
+/**
+ * Rust Parser Utilities
+ *
+ * Helper functions for converting Tree-sitter nodes to CodeElements
+ * and extracting Rust-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 Rust doc comment from above a declaration
+ * Rust uses /// and //! for doc comments, or block doc comments
+ */
+export declare function extractRustDoc(node: Node, lines: string[]): string | undefined;
+/**
+ * Check if a node has a visibility modifier (pub, pub(crate), etc.)
+ */
+export declare function hasVisibility(node: Node): boolean;
+/**
+ * Get visibility string from a node
+ */
+export declare function getVisibility(node: Node): string | undefined;
+/**
+ * Check if a function is async
+ */
+export declare function isAsyncFn(node: Node): boolean;
+/**
+ * Get function signature from a function_item node
+ */
+export declare function getFunctionSignature(node: Node): string;
+/**
+ * Get struct signature
+ */
+export declare function getStructSignature(node: Node): string;
+/**
+ * Get enum signature
+ */
+export declare function getEnumSignature(node: Node): string;
+/**
+ * Get trait signature
+ */
+export declare function getTraitSignature(node: Node): string;
+/**
+ * Get impl block signature
+ */
+export declare function getImplSignature(node: Node): string;
+/**
+ * Get the type name from an impl block
+ */
+export declare function getImplTypeName(node: Node): string;
+/**
+ * Get the trait name from an impl block (if implementing a trait)
+ */
+export declare function getImplTraitName(node: Node): string | undefined;
+/**
+ * Extract the use path from a use_declaration
+ */
+export declare function getUsePath(node: Node): string;
+/**
+ * Get the short name from a use path
+ * e.g., "std::collections::HashMap" -> "HashMap"
+ */
+export declare function getUseShortName(usePath: string): string;
+/**
+ * Get const/static signature
+ */
+export declare function getConstSignature(node: Node, kind: "const" | "static"): string;
+/**
+ * Get type alias signature
+ */
+export declare function getTypeAliasSignature(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/rust/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ast/rust/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,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CA8B9E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAWjD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAO5D;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAW7C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAgBvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAOrD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAOnD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAOpD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAUnD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAGlD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAG/D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAY7C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA4BvD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAS9E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAOxD;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"}