distill-mcp 0.6.0-beta

package/dist/sandbox/sdk/code.js

@@ -0,0 +1,104 @@
+/**
+ * SDK Code/AST Functions
+ *
+ * Wraps AST parsing functionality for sandbox use.
+ */
+import { parseFile } from "../../ast/index.js";
+/**
+ * Convert AST element to SDK element
+ */
+function toCodeElement(el) {
+    return {
+        type: el.type,
+        name: el.name,
+        startLine: el.startLine,
+        endLine: el.endLine,
+        signature: el.signature,
+        documentation: el.documentation,
+    };
+}
+/**
+ * Parse code content to structure
+ */
+export function codeParse(content, language) {
+    const parsed = parseFile(content, language);
+    return {
+        language,
+        functions: parsed.functions.map(toCodeElement),
+        classes: parsed.classes.map(toCodeElement),
+        interfaces: parsed.interfaces?.map(toCodeElement) || [],
+        types: parsed.types?.map(toCodeElement) || [],
+        variables: parsed.variables?.map(toCodeElement) || [],
+        imports: parsed.imports?.map(toCodeElement) || [],
+        exports: parsed.exports?.map(toCodeElement) || [],
+    };
+}
+/**
+ * Extract a specific element from code
+ */
+export function codeExtract(content, language, target) {
+    const lines = content.split("\n");
+    const parsed = parseFile(content, language);
+    // Find matching element
+    const allElements = [
+        ...parsed.functions,
+        ...parsed.classes,
+        ...(parsed.interfaces || []),
+        ...(parsed.types || []),
+        ...(parsed.variables || []),
+    ];
+    const element = allElements.find((el) => el.type === target.type && el.name === target.name);
+    if (!element) {
+        return null;
+    }
+    // Extract lines
+    const start = element.startLine - 1; // 0-indexed
+    const end = element.endLine || element.startLine;
+    return lines.slice(start, end).join("\n");
+}
+/**
+ * Get code skeleton (signatures only)
+ */
+export function codeSkeleton(content, language) {
+    const parsed = parseFile(content, language);
+    const lines = [];
+    // Imports (first 5)
+    if (parsed.imports && parsed.imports.length > 0) {
+        lines.push("// Imports:");
+        for (const imp of parsed.imports.slice(0, 5)) {
+            lines.push(`//   ${imp.name}`);
+        }
+        if (parsed.imports.length > 5) {
+            lines.push(`//   ... +${parsed.imports.length - 5} more`);
+        }
+        lines.push("");
+    }
+    // Classes
+    for (const cls of parsed.classes) {
+        const sig = cls.signature || `class ${cls.name}`;
+        lines.push(sig);
+        lines.push("");
+    }
+    // Interfaces
+    if (parsed.interfaces) {
+        for (const iface of parsed.interfaces) {
+            const sig = iface.signature || `interface ${iface.name}`;
+            lines.push(sig);
+            lines.push("");
+        }
+    }
+    // Types
+    if (parsed.types) {
+        for (const type of parsed.types) {
+            const sig = type.signature || `type ${type.name}`;
+            lines.push(sig);
+            lines.push("");
+        }
+    }
+    // Functions
+    for (const fn of parsed.functions) {
+        const sig = fn.signature || `function ${fn.name}()`;
+        lines.push(sig);
+    }
+    return lines.join("\n");
+}

package/dist/sandbox/sdk/compress.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SDK Compress Functions
+ *
+ * Wraps compression functionality for sandbox use.
+ */
+import type { CompressResult, LogSummary } from "../types.js";
+/**
+ * Auto-detect content type and apply optimal compression
+ */
+export declare function compressAuto(content: string, hint?: string): CompressResult;
+/**
+ * Summarize log output
+ */
+export declare function compressLogs(logs: string): LogSummary;
+/**
+ * Compress git diff output
+ */
+export declare function compressDiff(diff: string): CompressResult;
+/**
+ * TF-IDF based semantic compression
+ */
+export declare function compressSemantic(content: string, ratio?: number): CompressResult;
+//# sourceMappingURL=compress.d.ts.map

package/dist/sandbox/sdk/compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/compress.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9D;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,cAAc,CAmB3E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAYrD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CA2CzD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAY,GAAG,cAAc,CAiBrF"}

package/dist/sandbox/sdk/compress.js

@@ -0,0 +1,107 @@
+/**
+ * SDK Compress Functions
+ *
+ * Wraps compression functionality for sandbox use.
+ */
+import { compressContent, analyzeContent, semanticCompressor } from "../../compressors/index.js";
+import { getSummarizer } from "../../summarizers/index.js";
+import { countTokens } from "../../utils/token-counter.js";
+/**
+ * Auto-detect content type and apply optimal compression
+ */
+export function compressAuto(content, hint) {
+    const analysis = analyzeContent(content);
+    const contentType = hint || analysis.detectedType;
+    const result = compressContent(content, {
+        contentType: contentType,
+    });
+    const originalTokens = countTokens(content);
+    const compressedTokens = countTokens(result.compressed);
+    return {
+        compressed: result.compressed,
+        stats: {
+            original: originalTokens,
+            compressed: compressedTokens,
+            reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
+        },
+    };
+}
+/**
+ * Summarize log output
+ */
+export function compressLogs(logs) {
+    const summarizer = getSummarizer(logs);
+    const result = summarizer.summarize(logs, { detail: "normal" });
+    return {
+        summary: result.overview,
+        stats: {
+            totalLines: logs.split("\n").length,
+            errorCount: result.errors?.length || 0,
+            warningCount: result.warnings?.length || 0,
+        },
+    };
+}
+/**
+ * Compress git diff output
+ */
+export function compressDiff(diff) {
+    // Extract key changes from diff
+    const lines = diff.split("\n");
+    const importantLines = [];
+    let addedCount = 0;
+    let removedCount = 0;
+    for (const line of lines) {
+        if (line.startsWith("diff --git")) {
+            const match = line.match(/diff --git a\/(.*) b\/(.*)/);
+            if (match) {
+                importantLines.push(`\n## ${match[2]}`);
+            }
+        }
+        else if (line.startsWith("@@")) {
+            importantLines.push(line);
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            addedCount++;
+            if (line.trim().length > 1) {
+                importantLines.push(line);
+            }
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            removedCount++;
+            if (line.trim().length > 1) {
+                importantLines.push(line);
+            }
+        }
+    }
+    const header = `[diff] +${addedCount}/-${removedCount} lines`;
+    const compressed = [header, ...importantLines].join("\n");
+    const originalTokens = countTokens(diff);
+    const compressedTokens = countTokens(compressed);
+    return {
+        compressed,
+        stats: {
+            original: originalTokens,
+            compressed: compressedTokens,
+            reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
+        },
+    };
+}
+/**
+ * TF-IDF based semantic compression
+ */
+export function compressSemantic(content, ratio = 0.5) {
+    const result = semanticCompressor.compress(content, {
+        targetRatio: ratio,
+        detail: "normal",
+    });
+    const originalTokens = countTokens(content);
+    const compressedTokens = countTokens(result.compressed);
+    return {
+        compressed: result.compressed,
+        stats: {
+            original: originalTokens,
+            compressed: compressedTokens,
+            reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
+        },
+    };
+}

package/dist/sandbox/sdk/conversation.d.ts

@@ -0,0 +1,148 @@
+/**
+ * SDK Conversation Functions
+ *
+ * Conversation memory management for sandbox use.
+ * Provides compression, decision extraction, and context restoration.
+ */
+import type { HostCallbacks } from "../types.js";
+import { type ConversationMessage, type ConversationCompressResult, type ConversationMemory, type ConversationMemoryResult, type MemoryRestoreOptions, type Decision, type CodeReference } from "../../compressors/conversation.js";
+/**
+ * SDK conversation compress options (simplified)
+ */
+export interface SdkConversationOptions {
+    /** Compression strategy */
+    strategy?: "rolling-summary" | "key-extraction" | "hybrid";
+    /** Maximum tokens for output */
+    maxTokens?: number;
+    /** Preserve system messages */
+    preserveSystem?: boolean;
+    /** Number of recent messages to preserve */
+    preserveLastN?: number;
+}
+/**
+ * Create conversation API with memory state
+ */
+export declare function createConversationAPI(workingDir: string, callbacks: HostCallbacks): {
+    /**
+     * Compress conversation messages
+     *
+     * @param messages - Array of conversation messages
+     * @param options - Compression options
+     * @returns Compressed messages and statistics
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.compress(messages, { strategy: "hybrid" })
+     * ```
+     */
+    compress(messages: ConversationMessage[], options?: SdkConversationOptions): ConversationCompressResult;
+    /**
+     * Compress conversation and update memory state
+     *
+     * @param messages - Array of conversation messages
+     * @param options - Compression options
+     * @returns Memory result with context and statistics
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.createMemory(messages)
+     * ```
+     */
+    createMemory(messages: ConversationMessage[], options?: SdkConversationOptions): ConversationMemoryResult;
+    /**
+     * Extract key decisions from messages
+     *
+     * @param messages - Array of conversation messages
+     * @returns Array of extracted decisions
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.extractDecisions(messages)
+     * ```
+     */
+    extractDecisions(messages: ConversationMessage[]): Decision[];
+    /**
+     * Extract code references from messages
+     *
+     * @param messages - Array of conversation messages
+     * @returns Array of code references with actions
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.extractCodeRefs(messages)
+     * ```
+     */
+    extractCodeRefs(messages: ConversationMessage[]): CodeReference[];
+    /**
+     * Restore context from stored memory
+     *
+     * @param options - Restoration options
+     * @returns Restored context string
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.restore({ includeSummary: true, recentMessages: 3 })
+     * ```
+     */
+    restore(options?: MemoryRestoreOptions): string;
+    /**
+     * Get current memory state
+     *
+     * @returns Current memory or null if not set
+     *
+     * @example
+     * ```typescript
+     * const memory = ctx.conversation.getMemory()
+     * ```
+     */
+    getMemory(): ConversationMemory | null;
+    /**
+     * Set memory state (for restoring from external source)
+     *
+     * @param memory - Memory state to set
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.setMemory(savedMemory)
+     * ```
+     */
+    setMemory(memory: ConversationMemory): void;
+    /**
+     * Clear stored memory
+     *
+     * @example
+     * ```typescript
+     * ctx.conversation.clearMemory()
+     * ```
+     */
+    clearMemory(): void;
+    /**
+     * Check if memory is stored
+     *
+     * @returns True if memory exists
+     *
+     * @example
+     * ```typescript
+     * if (ctx.conversation.hasMemory()) { ... }
+     * ```
+     */
+    hasMemory(): boolean;
+    /**
+     * Get summary of current memory state
+     *
+     * @returns Summary object or null
+     *
+     * @example
+     * ```typescript
+     * const summary = ctx.conversation.getSummary()
+     * ```
+     */
+    getSummary(): {
+        summary: string;
+        decisionsCount: number;
+        codeRefsCount: number;
+        messagesCount: number;
+        lastUpdated: number;
+    } | null;
+};
+//# sourceMappingURL=conversation.d.ts.map

package/dist/sandbox/sdk/conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/conversation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAML,KAAK,mBAAmB,EAExB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,mCAAmC,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,QAAQ,CAAC;IAC3D,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,aAAa;IAMtB;;;;;;;;;;;OAWG;uBAES,mBAAmB,EAAE,YACrB,sBAAsB,GAC/B,0BAA0B;IAW7B;;;;;;;;;;;OAWG;2BAES,mBAAmB,EAAE,YACrB,sBAAsB,GAC/B,wBAAwB;IAgB3B;;;;;;;;;;OAUG;+BACwB,mBAAmB,EAAE,GAAG,QAAQ,EAAE;IAI7D;;;;;;;;;;OAUG;8BACuB,mBAAmB,EAAE,GAAG,aAAa,EAAE;IAIjE;;;;;;;;;;OAUG;sBACe,oBAAoB,GAAG,MAAM;IAQ/C;;;;;;;;;OASG;iBACU,kBAAkB,GAAG,IAAI;IAItC;;;;;;;;;OASG;sBACe,kBAAkB,GAAG,IAAI;IAI3C;;;;;;;OAOG;mBACY,IAAI;IAInB;;;;;;;;;OASG;iBACU,OAAO;IAIpB;;;;;;;;;OASG;kBACW;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACrB,GAAG,IAAI;EAYX"}

package/dist/sandbox/sdk/conversation.js

@@ -0,0 +1,177 @@
+/**
+ * SDK Conversation Functions
+ *
+ * Conversation memory management for sandbox use.
+ * Provides compression, decision extraction, and context restoration.
+ */
+import { compressConversation, compressConversationWithMemory, extractDecisions, extractCodeReferences, restoreContext, } from "../../compressors/conversation.js";
+/**
+ * Create conversation API with memory state
+ */
+export function createConversationAPI(workingDir, callbacks) {
+    // In-memory state for conversation tracking
+    let currentMemory = null;
+    return {
+        /**
+         * Compress conversation messages
+         *
+         * @param messages - Array of conversation messages
+         * @param options - Compression options
+         * @returns Compressed messages and statistics
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.compress(messages, { strategy: "hybrid" })
+         * ```
+         */
+        compress(messages, options) {
+            const opts = {
+                strategy: options?.strategy || "hybrid",
+                maxTokens: options?.maxTokens || 10000,
+                preserveSystem: options?.preserveSystem ?? true,
+                preserveLastN: options?.preserveLastN ?? 2,
+            };
+            return compressConversation(messages, opts);
+        },
+        /**
+         * Compress conversation and update memory state
+         *
+         * @param messages - Array of conversation messages
+         * @param options - Compression options
+         * @returns Memory result with context and statistics
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.createMemory(messages)
+         * ```
+         */
+        createMemory(messages, options) {
+            const opts = {
+                strategy: options?.strategy || "hybrid",
+                maxTokens: options?.maxTokens || 10000,
+                preserveSystem: options?.preserveSystem ?? true,
+                preserveLastN: options?.preserveLastN ?? 2,
+            };
+            const result = compressConversationWithMemory(messages, opts);
+            // Store memory for later restoration
+            currentMemory = result.memory;
+            return result;
+        },
+        /**
+         * Extract key decisions from messages
+         *
+         * @param messages - Array of conversation messages
+         * @returns Array of extracted decisions
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.extractDecisions(messages)
+         * ```
+         */
+        extractDecisions(messages) {
+            return extractDecisions(messages);
+        },
+        /**
+         * Extract code references from messages
+         *
+         * @param messages - Array of conversation messages
+         * @returns Array of code references with actions
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.extractCodeRefs(messages)
+         * ```
+         */
+        extractCodeRefs(messages) {
+            return extractCodeReferences(messages);
+        },
+        /**
+         * Restore context from stored memory
+         *
+         * @param options - Restoration options
+         * @returns Restored context string
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.restore({ includeSummary: true, recentMessages: 3 })
+         * ```
+         */
+        restore(options) {
+            if (!currentMemory) {
+                return "[No memory stored. Call createMemory() first.]";
+            }
+            return restoreContext(currentMemory, options);
+        },
+        /**
+         * Get current memory state
+         *
+         * @returns Current memory or null if not set
+         *
+         * @example
+         * ```typescript
+         * const memory = ctx.conversation.getMemory()
+         * ```
+         */
+        getMemory() {
+            return currentMemory;
+        },
+        /**
+         * Set memory state (for restoring from external source)
+         *
+         * @param memory - Memory state to set
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.setMemory(savedMemory)
+         * ```
+         */
+        setMemory(memory) {
+            currentMemory = memory;
+        },
+        /**
+         * Clear stored memory
+         *
+         * @example
+         * ```typescript
+         * ctx.conversation.clearMemory()
+         * ```
+         */
+        clearMemory() {
+            currentMemory = null;
+        },
+        /**
+         * Check if memory is stored
+         *
+         * @returns True if memory exists
+         *
+         * @example
+         * ```typescript
+         * if (ctx.conversation.hasMemory()) { ... }
+         * ```
+         */
+        hasMemory() {
+            return currentMemory !== null;
+        },
+        /**
+         * Get summary of current memory state
+         *
+         * @returns Summary object or null
+         *
+         * @example
+         * ```typescript
+         * const summary = ctx.conversation.getSummary()
+         * ```
+         */
+        getSummary() {
+            if (!currentMemory)
+                return null;
+            return {
+                summary: currentMemory.summary,
+                decisionsCount: currentMemory.decisions.length,
+                codeRefsCount: currentMemory.codeReferences.length,
+                messagesCount: currentMemory.compressedHistory.length,
+                lastUpdated: currentMemory.lastUpdated,
+            };
+        },
+    };
+}

package/dist/sandbox/sdk/files.d.ts

@@ -0,0 +1,29 @@
+/**
+ * SDK Files Functions
+ *
+ * Safe file operations for sandbox use.
+ * Uses host callbacks for actual file I/O.
+ */
+import type { HostCallbacks, FileStructure } from "../types.js";
+/**
+ * Create files API with host callbacks
+ */
+export declare function createFilesAPI(callbacks: HostCallbacks): {
+    /**
+     * Read file content
+     */
+    read(path: string): string;
+    /**
+     * Check if file exists
+     */
+    exists(path: string): boolean;
+    /**
+     * Find files matching glob pattern
+     */
+    glob(pattern: string): string[];
+    /**
+     * Read file and parse to structure
+     */
+    readStructure(path: string): FileStructure;
+};
+//# sourceMappingURL=files.d.ts.map

package/dist/sandbox/sdk/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/files.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIhE;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,aAAa;IAEnD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAI1B;;OAEG;iBACU,MAAM,GAAG,OAAO;IAI7B;;OAEG;kBACW,MAAM,GAAG,MAAM,EAAE;IAI/B;;OAEG;wBACiB,MAAM,GAAG,aAAa;EAM7C"}

package/dist/sandbox/sdk/files.js

@@ -0,0 +1,41 @@
+/**
+ * SDK Files Functions
+ *
+ * Safe file operations for sandbox use.
+ * Uses host callbacks for actual file I/O.
+ */
+import { codeParse } from "./code.js";
+import { detectLanguageFromPath } from "../../utils/language-detector.js";
+/**
+ * Create files API with host callbacks
+ */
+export function createFilesAPI(callbacks) {
+    return {
+        /**
+         * Read file content
+         */
+        read(path) {
+            return callbacks.readFile(path);
+        },
+        /**
+         * Check if file exists
+         */
+        exists(path) {
+            return callbacks.fileExists(path);
+        },
+        /**
+         * Find files matching glob pattern
+         */
+        glob(pattern) {
+            return callbacks.glob(pattern);
+        },
+        /**
+         * Read file and parse to structure
+         */
+        readStructure(path) {
+            const content = callbacks.readFile(path);
+            const language = detectLanguageFromPath(path);
+            return codeParse(content, language);
+        },
+    };
+}

package/dist/sandbox/sdk/git.d.ts

@@ -0,0 +1,37 @@
+/**
+ * SDK Git Functions
+ *
+ * Git operations for sandbox use.
+ * Uses child_process.execSync for git commands.
+ */
+import type { GitDiff, GitCommit, GitBlame, GitStatus, GitBranch } from "../types.js";
+/**
+ * Create Git API for sandbox
+ */
+export declare function createGitAPI(workingDir: string): {
+    /**
+     * Get git diff
+     * @param ref - Optional ref to diff against (default: HEAD)
+     */
+    diff(ref?: string): GitDiff;
+    /**
+     * Get git log
+     * @param limit - Number of commits to return (default: 10)
+     */
+    log(limit?: number): GitCommit[];
+    /**
+     * Get git blame for a file
+     * @param file - File path to blame
+     * @param line - Optional specific line number
+     */
+    blame(file: string, line?: number): GitBlame;
+    /**
+     * Get git status
+     */
+    status(): GitStatus;
+    /**
+     * Get git branch info
+     */
+    branch(): GitBranch;
+};
+//# sourceMappingURL=git.d.ts.map

package/dist/sandbox/sdk/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/git.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,OAAO,EAEP,SAAS,EACT,QAAQ,EAER,SAAS,EACT,SAAS,EACV,MAAM,aAAa,CAAC;AAmQrB;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM;IAE3C;;;OAGG;eACQ,MAAM,GAAG,OAAO;IAqB3B;;;OAGG;gBACS,MAAM,GAAG,SAAS,EAAE;IAYhC;;;;OAIG;gBACS,MAAM,SAAS,MAAM,GAAG,QAAQ;IAmB5C;;OAEG;cACO,SAAS;IAUnB;;OAEG;cACO,SAAS;EAmBtB"}