@cobwds/mcp-server 1.19.3

package/dist/resources/index.js

@@ -0,0 +1,13 @@
+/**
+ * MCP Resources Registration
+ *
+ * Registers all COBWDS resources with the MCP server.
+ */
+import { registerComponentResources } from "./components.js";
+import { registerTokenResources } from "./tokens.js";
+import { registerGuideResources } from "./guides.js";
+export function registerResources(server) {
+    registerComponentResources(server);
+    registerTokenResources(server);
+    registerGuideResources(server);
+}

package/dist/resources/tokens.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Token Resources
+ *
+ * MCP resources for COBWDS design tokens.
+ *
+ * Resources:
+ * - cobwds://tokens - All tokens in CSS-centric format
+ * - cobwds://tokens/css - Raw tokens.css file content
+ * - cobwds://tokens/graph - Token dependency graph with stats
+ * - cobwds://tokens/color - Color tokens only
+ * - cobwds://tokens/font - Typography tokens
+ * - cobwds://tokens/space - Spacing tokens
+ * - cobwds://tokens/size - Size tokens
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTokenResources(server: McpServer): void;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/resources/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/resources/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AASzE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAiZ9D"}

package/dist/resources/tokens.js

@@ -0,0 +1,312 @@
+/**
+ * Token Resources
+ *
+ * MCP resources for COBWDS design tokens.
+ *
+ * Resources:
+ * - cobwds://tokens - All tokens in CSS-centric format
+ * - cobwds://tokens/css - Raw tokens.css file content
+ * - cobwds://tokens/graph - Token dependency graph with stats
+ * - cobwds://tokens/color - Color tokens only
+ * - cobwds://tokens/font - Typography tokens
+ * - cobwds://tokens/space - Spacing tokens
+ * - cobwds://tokens/size - Size tokens
+ */
+import { getCSSTokens, getCSSTokensByCategory, getCSSTokenCategories, buildTokenGraph, getTokensCSS, } from "../lib/token-parser.js";
+export function registerTokenResources(server) {
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens - All design tokens in CSS-centric format
+    // ---------------------------------------------------------------------------
+    server.resource("tokens", "cobwds://tokens", {
+        description: "All COBWDS design tokens with CSS variable names, values, and descriptions",
+        mimeType: "application/json",
+    }, async () => {
+        const tokens = getCSSTokens();
+        const categories = getCSSTokenCategories();
+        const formatted = tokens.map((t) => ({
+            cssVariable: t.cssVariable,
+            cssValue: t.cssValue,
+            referencesVariable: t.referencesVariable,
+            resolvedValue: t.resolvedValue,
+            description: t.description,
+            category: t.category,
+            layer: t.layer,
+        }));
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens",
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalTokens: tokens.length,
+                        categories: categories.map((c) => c.category),
+                        tokens: formatted,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens/css - Raw tokens.css file content
+    // ---------------------------------------------------------------------------
+    server.resource("tokens-css", "cobwds://tokens/css", {
+        description: "Raw tokens.css file content for direct CSS usage",
+        mimeType: "text/css",
+    }, async () => {
+        const css = getTokensCSS();
+        if (!css) {
+            return {
+                contents: [
+                    {
+                        uri: "cobwds://tokens/css",
+                        mimeType: "text/plain",
+                        text: "/* tokens.css not found. Run 'npm run build -w packages/tokens' to generate. */",
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens/css",
+                    mimeType: "text/css",
+                    text: css,
+                },
+            ],
+        };
+    });
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens/graph - Token dependency graph with stats
+    // ---------------------------------------------------------------------------
+    server.resource("tokens-graph", "cobwds://tokens/graph", {
+        description: "Token dependency graph showing which tokens reference which and usage statistics",
+        mimeType: "application/json",
+    }, async () => {
+        const graph = buildTokenGraph();
+        const nodes = Array.from(graph.values());
+        // Calculate statistics
+        const aliasTokens = nodes.filter((n) => n.referencesVariable);
+        const primitiveTokens = nodes.filter((n) => !n.referencesVariable);
+        const usedTokens = nodes.filter((n) => n.usedBy.length > 0);
+        // Find most referenced tokens
+        const mostReferenced = [...usedTokens]
+            .sort((a, b) => b.usedBy.length - a.usedBy.length)
+            .slice(0, 10)
+            .map((n) => ({
+            cssVariable: n.cssVariable,
+            usedByCount: n.usedBy.length,
+            usedBy: n.usedBy.slice(0, 5),
+        }));
+        // Build a simplified graph representation
+        const graphData = nodes
+            .filter((n) => n.referencesVariable || n.usedBy.length > 0)
+            .map((n) => ({
+            cssVariable: n.cssVariable,
+            referencesVariable: n.referencesVariable,
+            usedBy: n.usedBy.length > 0 ? n.usedBy : undefined,
+        }));
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens/graph",
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        stats: {
+                            totalTokens: nodes.length,
+                            aliasTokens: aliasTokens.length,
+                            primitiveTokens: primitiveTokens.length,
+                            tokensWithDependents: usedTokens.length,
+                        },
+                        mostReferenced,
+                        graph: graphData,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens/color - Color tokens only
+    // ---------------------------------------------------------------------------
+    server.resource("tokens-color", "cobwds://tokens/color", {
+        description: "All COBWDS color tokens including primitives, semantic colors, and theme colors",
+        mimeType: "application/json",
+    }, async () => {
+        const tokens = getCSSTokensByCategory("color");
+        // Group by layer for better organization
+        const primitive = tokens.filter((t) => t.layer === "primitive");
+        const applied = tokens.filter((t) => t.layer === "applied");
+        const base = tokens.filter((t) => t.layer === "base" || t.layer === "color");
+        const formatToken = (t) => ({
+            cssVariable: t.cssVariable,
+            cssValue: t.cssValue,
+            referencesVariable: t.referencesVariable,
+            resolvedValue: t.resolvedValue,
+            description: t.description,
+        });
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens/color",
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalColors: tokens.length,
+                        layers: {
+                            primitive: {
+                                count: primitive.length,
+                                description: "Raw color values - reference these via applied tokens",
+                                tokens: primitive.map(formatToken),
+                            },
+                            applied: {
+                                count: applied.length,
+                                description: "Semantic color tokens - use these in code",
+                                tokens: applied.map(formatToken),
+                            },
+                            theme: {
+                                count: base.length,
+                                description: "Theme-aware colors that change per agency",
+                                tokens: base.map(formatToken),
+                            },
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens/font - Typography tokens
+    // ---------------------------------------------------------------------------
+    server.resource("tokens-font", "cobwds://tokens/font", {
+        description: "All COBWDS typography tokens including font families, sizes, weights, and line heights",
+        mimeType: "application/json",
+    }, async () => {
+        const tokens = getCSSTokensByCategory("font");
+        // Group by subcategory based on CSS variable name
+        const families = tokens.filter((t) => t.cssVariable.includes("-font-family-"));
+        const sizes = tokens.filter((t) => t.cssVariable.includes("-font-size-"));
+        const weights = tokens.filter((t) => t.cssVariable.includes("-font-weight-"));
+        const lineHeights = tokens.filter((t) => t.cssVariable.includes("-font-lineheight-"));
+        const letterSpacing = tokens.filter((t) => t.cssVariable.includes("-font-letterspacing-"));
+        const formatToken = (t) => ({
+            cssVariable: t.cssVariable,
+            cssValue: t.cssValue,
+            resolvedValue: t.resolvedValue,
+            description: t.description,
+        });
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens/font",
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalTypography: tokens.length,
+                        groups: {
+                            families: {
+                                count: families.length,
+                                description: "Font family stacks",
+                                tokens: families.map(formatToken),
+                            },
+                            sizes: {
+                                count: sizes.length,
+                                description: "Font sizes for different contexts",
+                                tokens: sizes.map(formatToken),
+                            },
+                            weights: {
+                                count: weights.length,
+                                description: "Font weight values",
+                                tokens: weights.map(formatToken),
+                            },
+                            lineHeights: {
+                                count: lineHeights.length,
+                                description: "Line height values",
+                                tokens: lineHeights.map(formatToken),
+                            },
+                            letterSpacing: {
+                                count: letterSpacing.length,
+                                description: "Letter spacing adjustments",
+                                tokens: letterSpacing.map(formatToken),
+                            },
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens/space - Spacing tokens
+    // ---------------------------------------------------------------------------
+    server.resource("tokens-space", "cobwds://tokens/space", {
+        description: "All COBWDS spacing tokens for margins, padding, and gaps. Based on an 8px grid.",
+        mimeType: "application/json",
+    }, async () => {
+        const tokens = getCSSTokensByCategory("space");
+        const formatToken = (t) => ({
+            cssVariable: t.cssVariable,
+            cssValue: t.cssValue,
+            resolvedValue: t.resolvedValue,
+            description: t.description,
+        });
+        // Sort by numeric value if possible
+        const sorted = [...tokens].sort((a, b) => {
+            const aNum = parseFloat(a.resolvedValue || "0");
+            const bNum = parseFloat(b.resolvedValue || "0");
+            return aNum - bNum;
+        });
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens/space",
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalSpacing: tokens.length,
+                        description: "Spacing scale based on 8px base unit. Use for margins, padding, and gaps.",
+                        tokens: sorted.map(formatToken),
+                        usage: {
+                            padding: "padding: var(--cob-space-200);",
+                            margin: "margin-block: var(--cob-space-400);",
+                            gap: "gap: var(--cob-space-100);",
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // ---------------------------------------------------------------------------
+    // cobwds://tokens/size - Size tokens
+    // ---------------------------------------------------------------------------
+    server.resource("tokens-size", "cobwds://tokens/size", {
+        description: "All COBWDS size tokens for widths, heights, and component dimensions",
+        mimeType: "application/json",
+    }, async () => {
+        const tokens = getCSSTokensByCategory("size");
+        const formatToken = (t) => ({
+            cssVariable: t.cssVariable,
+            cssValue: t.cssValue,
+            resolvedValue: t.resolvedValue,
+            description: t.description,
+        });
+        // Sort by numeric value if possible
+        const sorted = [...tokens].sort((a, b) => {
+            const aNum = parseFloat(a.resolvedValue || "0");
+            const bNum = parseFloat(b.resolvedValue || "0");
+            return aNum - bNum;
+        });
+        return {
+            contents: [
+                {
+                    uri: "cobwds://tokens/size",
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalSizes: tokens.length,
+                        description: "Size tokens for component dimensions, icon sizes, and fixed widths/heights.",
+                        tokens: sorted.map(formatToken),
+                        usage: {
+                            iconSize: "width: var(--cob-size-200); height: var(--cob-size-200);",
+                            minHeight: "min-height: var(--cob-size-400);",
+                            componentSize: "inline-size: var(--cob-size-600);",
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * COBWDS MCP Server Setup
+ *
+ * Configures the MCP server with tools, resources, and prompts
+ * for the City of Boston Web Design System.
+ */
+export interface CobwdsMcpServer {
+    start(): Promise<void>;
+}
+export declare function createServer(): Promise<CobwdsMcpServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,MAAM,WAAW,eAAe;IAC9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAsB,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC,CAkB7D"}

package/dist/server.js

@@ -0,0 +1,30 @@
+/**
+ * COBWDS MCP Server Setup
+ *
+ * Configures the MCP server with tools, resources, and prompts
+ * for the City of Boston Web Design System.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./tools/index.js";
+import { registerResources } from "./resources/index.js";
+import { registerPrompts } from "./prompts/cobwds-mode.js";
+const SERVER_NAME = "cobwds-mcp";
+const SERVER_VERSION = "1.0.0";
+export async function createServer() {
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    // Register all capabilities
+    registerTools(server);
+    registerResources(server);
+    registerPrompts(server);
+    return {
+        async start() {
+            const transport = new StdioServerTransport();
+            await server.connect(transport);
+            console.error(`${SERVER_NAME} v${SERVER_VERSION} started`);
+        },
+    };
+}

package/dist/tools/component-tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Component Tools
+ *
+ * MCP tools for working with COBWDS components.
+ *
+ * Tools:
+ * - find_components: Search or list all components
+ * - get_component: Full documentation for a specific component
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerComponentTools(server: McpServer): void;
+//# sourceMappingURL=component-tools.d.ts.map

package/dist/tools/component-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-tools.d.ts","sourceRoot":"","sources":["../../src/tools/component-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA+G9D"}

package/dist/tools/component-tools.js

@@ -0,0 +1,95 @@
+/**
+ * Component Tools
+ *
+ * MCP tools for working with COBWDS components.
+ *
+ * Tools:
+ * - find_components: Search or list all components
+ * - get_component: Full documentation for a specific component
+ */
+import { z } from "zod";
+import { getComponent, getAllComponents } from "../lib/cem-parser.js";
+import { searchComponents } from "../lib/search.js";
+export function registerComponentTools(server) {
+    // find_components - Search or list all components
+    server.tool("find_components", "Search for COBWDS components by name or description. Omit query to list all components.", {
+        query: z
+            .string()
+            .optional()
+            .describe("Search query to match against component names and descriptions. Omit to list all components."),
+    }, async ({ query }) => {
+        // If no query, return all components
+        if (!query || query.trim() === "") {
+            const components = getAllComponents();
+            const list = components.map((c) => ({
+                tagName: c.tagName,
+                name: c.name,
+                summary: c.summary || c.description?.split("\n")[0] || "No description",
+                resourceUri: `cobwds://component/${c.tagName}`,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(list, null, 2),
+                    },
+                ],
+            };
+        }
+        // Otherwise search
+        const results = searchComponents(query).map((r) => ({
+            ...r,
+            resourceUri: `cobwds://component/${r.tagName}`,
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(results, null, 2),
+                },
+            ],
+        };
+    });
+    // get_component - Full documentation for a specific component
+    server.tool("get_component", "Get full documentation for a specific COBWDS component including properties, events, slots, and CSS custom properties", {
+        tagName: z
+            .string()
+            .describe("The tag name of the component (e.g., 'cob-button')"),
+        includeExamples: z
+            .boolean()
+            .default(false)
+            .describe("Include HTML code examples from component JSDoc. Set to true when you need usage patterns."),
+    }, async ({ tagName, includeExamples }) => {
+        const component = getComponent(tagName);
+        if (!component) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Component "${tagName}" not found. Use find_components to see available components.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Remove members array to avoid duplication with attributes
+        // Attributes contains the HTML API, members duplicates this plus private methods
+        const { 
+        // members: _members,
+        examples, ...componentWithoutMembers } = component;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ...componentWithoutMembers,
+                        examples: includeExamples && examples && examples.length > 0
+                            ? examples
+                            : undefined,
+                        resourceUri: `cobwds://component/${tagName}`,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/guide-tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Guide Tools
+ *
+ * Consolidated MCP tool for COBWDS guides and documentation.
+ * Loads guide content from data/guides/ markdown files.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGuideTools(server: McpServer): void;
+//# sourceMappingURL=guide-tools.d.ts.map

package/dist/tools/guide-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guide-tools.d.ts","sourceRoot":"","sources":["../../src/tools/guide-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA8CzE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA0C1D"}

package/dist/tools/guide-tools.js

@@ -0,0 +1,80 @@
+/**
+ * Guide Tools
+ *
+ * Consolidated MCP tool for COBWDS guides and documentation.
+ * Loads guide content from data/guides/ markdown files.
+ */
+import { z } from "zod";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+// ESM-compatible __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Path to guides directory (relative to dist/tools/)
+const GUIDES_DIR = join(__dirname, "../../data/guides");
+/**
+ * Load a guide markdown file
+ */
+function loadGuide(filename) {
+    try {
+        return readFileSync(join(GUIDES_DIR, filename), "utf-8");
+    }
+    catch {
+        return `Guide not found: ${filename}`;
+    }
+}
+/**
+ * Load a framework-specific guide
+ */
+function loadFrameworkGuide(framework) {
+    try {
+        return readFileSync(join(GUIDES_DIR, "frameworks", `${framework}.md`), "utf-8");
+    }
+    catch {
+        return `Framework guide not found: ${framework}`;
+    }
+}
+const TOPIC_TO_FILE = {
+    installation: "installation.md",
+    "form-validation": "form-validation.md",
+    styles: "styles.md",
+    fonts: "fonts.md",
+    "page-structure": "page-structure.md",
+    themes: "themes.md",
+};
+export function registerGuideTools(server) {
+    server.tool("get_guide", "Get COBWDS guides for installation, forms, styles, fonts, page structure, themes, or framework setup", {
+        topic: z
+            .enum([
+            "installation",
+            "form-validation",
+            "styles",
+            "fonts",
+            "page-structure",
+            "themes",
+        ])
+            .describe("The guide topic to retrieve"),
+        framework: z
+            .enum(["angular", "react", "dotnet", "drupal", "vanilla"])
+            .optional()
+            .describe("When provided, returns framework-specific setup guide instead of the topic guide. Use with topic 'installation' to get framework install instructions."),
+    }, async ({ topic, framework }) => {
+        let content;
+        if (framework) {
+            content = loadFrameworkGuide(framework);
+        }
+        else {
+            const filename = TOPIC_TO_FILE[topic];
+            content = filename ? loadGuide(filename) : `Unknown topic: ${topic}`;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: content,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP Tools Registration
+ *
+ * Registers all COBWDS tools with the MCP server.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTools(server: McpServer): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAOzE,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAMrD"}

package/dist/tools/index.js

@@ -0,0 +1,17 @@
+/**
+ * MCP Tools Registration
+ *
+ * Registers all COBWDS tools with the MCP server.
+ */
+import { registerComponentTools } from "./component-tools.js";
+import { registerTokenTools } from "./token-tools.js";
+import { registerValidationTools } from "./validation-tools.js";
+import { registerUtilityTools } from "./utility-tools.js";
+import { registerGuideTools } from "./guide-tools.js";
+export function registerTools(server) {
+    registerComponentTools(server);
+    registerTokenTools(server);
+    registerValidationTools(server);
+    registerUtilityTools(server);
+    registerGuideTools(server);
+}

package/dist/tools/token-tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Token Tools
+ *
+ * MCP tools for working with COBWDS design tokens.
+ *
+ * Tools:
+ * - find_tokens: Search or browse tokens (discovery)
+ * - get_token: Get full details for a specific token (deep dive)
+ * - get_token_graph: Get token dependency graph
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTokenTools(server: McpServer): void;
+//# sourceMappingURL=token-tools.d.ts.map

package/dist/tools/token-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-tools.d.ts","sourceRoot":"","sources":["../../src/tools/token-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAuCzE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6N1D"}