distill-mcp 0.6.0-beta

package/dist/utils/output-estimator.test.js

@@ -0,0 +1,115 @@
+/**
+ * Output Estimator Tests
+ */
+import { describe, it, expect } from "vitest";
+import { estimateOutputTokens, isQuestion, isInstruction, getOutputRatio, } from "./output-estimator.js";
+describe("Output Estimator", () => {
+    describe("isQuestion", () => {
+        it("should detect questions starting with question words", () => {
+            expect(isQuestion("What is TypeScript?")).toBe(true);
+            expect(isQuestion("How do I fix this error?")).toBe(true);
+            expect(isQuestion("Why is this happening?")).toBe(true);
+            expect(isQuestion("Can you explain this?")).toBe(true);
+        });
+        it("should detect questions ending with question mark", () => {
+            expect(isQuestion("This is broken?")).toBe(true);
+            expect(isQuestion("Is this correct?")).toBe(true);
+        });
+        it("should detect explain/describe patterns", () => {
+            expect(isQuestion("Explain how promises work")).toBe(true);
+            expect(isQuestion("Describe the architecture")).toBe(true);
+            expect(isQuestion("Tell me about this function")).toBe(true);
+        });
+        it("should not detect non-questions", () => {
+            expect(isQuestion("Fix this bug")).toBe(false);
+            expect(isQuestion("Create a new function")).toBe(false);
+            expect(isQuestion("const x = 5")).toBe(false);
+        });
+    });
+    describe("isInstruction", () => {
+        it("should detect imperative commands", () => {
+            expect(isInstruction("Create a new function")).toBe(true);
+            expect(isInstruction("Write a test for this")).toBe(true);
+            expect(isInstruction("Fix the authentication bug")).toBe(true);
+            expect(isInstruction("Add error handling")).toBe(true);
+            expect(isInstruction("Refactor this code")).toBe(true);
+        });
+        it("should detect polite requests", () => {
+            expect(isInstruction("Please update the README")).toBe(true);
+            expect(isInstruction("Can you implement this feature")).toBe(true);
+            expect(isInstruction("Could you review this PR")).toBe(true);
+        });
+        it("should detect creation patterns", () => {
+            expect(isInstruction("I need a function to parse JSON")).toBe(false); // Not at start
+            expect(isInstruction("Write a utility for caching")).toBe(true);
+        });
+        it("should not detect non-instructions", () => {
+            expect(isInstruction("What is this?")).toBe(false);
+            expect(isInstruction("const x = 5")).toBe(false);
+            expect(isInstruction("Error: something failed")).toBe(false);
+        });
+    });
+    describe("estimateOutputTokens", () => {
+        it("should estimate output for code content", () => {
+            const codeContent = `
+function hello() {
+  return "world";
+}
+      `.trim();
+            const result = estimateOutputTokens(codeContent, 500, "code");
+            // Code default ratio is 0.8x
+            expect(result.estimated).toBeGreaterThan(0);
+            expect(result.estimated).toBeLessThanOrEqual(500 * 1.5);
+            expect(result.confidence).toBe("medium");
+        });
+        it("should estimate lower output for logs", () => {
+            const logsContent = `
+[2025-12-23 10:00:00] INFO: Server started
+[2025-12-23 10:00:01] DEBUG: Loading config
+      `.trim();
+            const result = estimateOutputTokens(logsContent, 1000, "logs");
+            // Logs ratio is 0.2x, so output should be much smaller than input
+            expect(result.estimated).toBeLessThan(500);
+        });
+        it("should estimate higher output for questions", () => {
+            const question = "What is the difference between let and const?";
+            const result = estimateOutputTokens(question, 100, "generic");
+            // Questions get 1.0x ratio by default
+            expect(result.estimated).toBeGreaterThanOrEqual(50); // Minimum floor
+            expect(result.confidence).toBeDefined();
+        });
+        it("should apply minimum floor of 50 tokens", () => {
+            const shortContent = "Hi";
+            const result = estimateOutputTokens(shortContent, 5, "generic");
+            expect(result.estimated).toBeGreaterThanOrEqual(50);
+        });
+        it("should apply maximum ceiling of 16000 tokens", () => {
+            const longContent = "x".repeat(100000);
+            const result = estimateOutputTokens(longContent, 50000, "generic");
+            expect(result.estimated).toBeLessThanOrEqual(16000);
+        });
+        it("should have low confidence for short inputs", () => {
+            const shortInput = "Help";
+            const result = estimateOutputTokens(shortInput, 50, "generic");
+            expect(result.confidence).toBe("low");
+            expect(result.reasoning).toContain("Short input");
+        });
+        it("should adjust for very long inputs", () => {
+            const longInput = "x".repeat(50000);
+            const result = estimateOutputTokens(longInput, 15000, "generic");
+            expect(result.reasoning).toContain("Long input");
+        });
+    });
+    describe("getOutputRatio", () => {
+        it("should return ratio config for known types", () => {
+            const codeRatio = getOutputRatio("code");
+            expect(codeRatio.defaultRatio).toBe(0.8);
+            const logsRatio = getOutputRatio("logs");
+            expect(logsRatio.defaultRatio).toBe(0.2);
+        });
+        it("should return generic ratio for unknown types", () => {
+            const ratio = getOutputRatio("generic");
+            expect(ratio.defaultRatio).toBe(0.5);
+        });
+    });
+});

package/dist/utils/output-similarity.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Output Similarity Calculator
+ *
+ * Calculates similarity between command outputs to detect
+ * retry loops with similar errors.
+ */
+/**
+ * Generate a short hash of the output for quick comparison
+ */
+export declare function hashOutput(output: string): string;
+/**
+ * Calculate similarity percentage between two hashes
+ * Returns 100 if identical, 0 otherwise (hash-based)
+ */
+export declare function calculateHashSimilarity(hash1: string, hash2: string): number;
+/**
+ * Count error lines in output (lines containing "error", "Error", "ERROR")
+ */
+export declare function countErrors(output: string): number;
+/**
+ * Count warning lines in output
+ */
+export declare function countWarnings(output: string): number;
+/**
+ * Extract error count from common build output patterns
+ * e.g., "Found 147 errors" or "147 errors"
+ */
+export declare function extractErrorCount(output: string): number | null;
+/**
+ * Analyze the trend of errors across multiple outputs
+ */
+export interface ErrorTrendAnalysis {
+    trend: "same" | "decreasing" | "increasing" | "fluctuating" | "unknown";
+    errorCounts: number[];
+    firstCount: number;
+    lastCount: number;
+    delta: number;
+}
+export declare function analyzeErrorTrend(outputs: string[]): ErrorTrendAnalysis;
+/**
+ * Calculate overall similarity between current output and history
+ */
+export declare function calculateOutputSimilarity(historyHashes: string[], currentHash: string): number;
+/**
+ * Format a timespan for display
+ */
+export declare function formatTimespan(startTime: Date, endTime: Date | number): string;
+//# sourceMappingURL=output-similarity.d.ts.map

package/dist/utils/output-similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-similarity.d.ts","sourceRoot":"","sources":["../../src/utils/output-similarity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAe/D;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa,GAAG,SAAS,CAAC;IACxE,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,kBAAkB,CAwDvE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAQ9F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAe9E"}

package/dist/utils/output-similarity.js

@@ -0,0 +1,140 @@
+/**
+ * Output Similarity Calculator
+ *
+ * Calculates similarity between command outputs to detect
+ * retry loops with similar errors.
+ */
+import { createHash } from "crypto";
+/**
+ * Generate a short hash of the output for quick comparison
+ */
+export function hashOutput(output) {
+    return createHash("sha256").update(output).digest("hex").slice(0, 16);
+}
+/**
+ * Calculate similarity percentage between two hashes
+ * Returns 100 if identical, 0 otherwise (hash-based)
+ */
+export function calculateHashSimilarity(hash1, hash2) {
+    return hash1 === hash2 ? 100 : 0;
+}
+/**
+ * Count error lines in output (lines containing "error", "Error", "ERROR")
+ */
+export function countErrors(output) {
+    const errorPattern = /\b(error|Error|ERROR|fail|Fail|FAIL)\b/gi;
+    const lines = output.split("\n");
+    return lines.filter((line) => errorPattern.test(line)).length;
+}
+/**
+ * Count warning lines in output
+ */
+export function countWarnings(output) {
+    const warningPattern = /\b(warning|Warning|WARNING|warn|Warn|WARN)\b/gi;
+    const lines = output.split("\n");
+    return lines.filter((line) => warningPattern.test(line)).length;
+}
+/**
+ * Extract error count from common build output patterns
+ * e.g., "Found 147 errors" or "147 errors"
+ */
+export function extractErrorCount(output) {
+    // TypeScript: "Found X error(s)"
+    const tsMatch = output.match(/Found\s+(\d+)\s+error/i);
+    if (tsMatch) {
+        return parseInt(tsMatch[1] ?? "0", 10);
+    }
+    // ESLint: "X error(s)"
+    const eslintMatch = output.match(/(\d+)\s+error/i);
+    if (eslintMatch) {
+        return parseInt(eslintMatch[1] ?? "0", 10);
+    }
+    // Generic: count error lines
+    return null;
+}
+export function analyzeErrorTrend(outputs) {
+    if (outputs.length === 0) {
+        return {
+            trend: "unknown",
+            errorCounts: [],
+            firstCount: 0,
+            lastCount: 0,
+            delta: 0,
+        };
+    }
+    const errorCounts = outputs.map((output) => {
+        const extracted = extractErrorCount(output);
+        return extracted ?? countErrors(output);
+    });
+    const firstCount = errorCounts[0] ?? 0;
+    const lastCount = errorCounts[errorCounts.length - 1] ?? 0;
+    const delta = lastCount - firstCount;
+    // Determine trend
+    let trend = "unknown";
+    if (errorCounts.length >= 2) {
+        const allSame = errorCounts.every((c) => c === firstCount);
+        if (allSame) {
+            trend = "same";
+        }
+        else {
+            // Check if monotonically increasing or decreasing
+            let increasing = true;
+            let decreasing = true;
+            for (let i = 1; i < errorCounts.length; i++) {
+                const prev = errorCounts[i - 1] ?? 0;
+                const curr = errorCounts[i] ?? 0;
+                if (curr < prev)
+                    increasing = false;
+                if (curr > prev)
+                    decreasing = false;
+            }
+            if (decreasing && delta < 0) {
+                trend = "decreasing";
+            }
+            else if (increasing && delta > 0) {
+                trend = "increasing";
+            }
+            else {
+                trend = "fluctuating";
+            }
+        }
+    }
+    return {
+        trend,
+        errorCounts,
+        firstCount,
+        lastCount,
+        delta,
+    };
+}
+/**
+ * Calculate overall similarity between current output and history
+ */
+export function calculateOutputSimilarity(historyHashes, currentHash) {
+    if (historyHashes.length === 0)
+        return 0;
+    // Count how many previous outputs match exactly
+    const matches = historyHashes.filter((h) => h === currentHash).length;
+    // Return percentage of matches
+    return Math.round((matches / historyHashes.length) * 100);
+}
+/**
+ * Format a timespan for display
+ */
+export function formatTimespan(startTime, endTime) {
+    const start = startTime.getTime();
+    const end = typeof endTime === "number" ? endTime : endTime.getTime();
+    const diffMs = end - start;
+    if (diffMs < 60000) {
+        const seconds = Math.round(diffMs / 1000);
+        return `last ${seconds} seconds`;
+    }
+    else if (diffMs < 3600000) {
+        const minutes = Math.round(diffMs / 60000);
+        return `last ${minutes} minute${minutes > 1 ? "s" : ""}`;
+    }
+    else {
+        const hours = Math.round(diffMs / 3600000);
+        return `last ${hours} hour${hours > 1 ? "s" : ""}`;
+    }
+}

package/dist/utils/project-detector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Project Detector
+ *
+ * Detects the type of project in the current working directory.
+ */
+export interface ProjectInfo {
+    rootPath: string;
+    name: string;
+    type: "node" | "python" | "rust" | "go" | "unknown";
+    packageManager?: "npm" | "yarn" | "pnpm" | "bun";
+    hasTypeScript: boolean;
+    detectedAt: Date;
+}
+export declare function detectProject(rootPath?: string): ProjectInfo | null;
+export declare function getProjectSummary(project: ProjectInfo | null): string;
+//# sourceMappingURL=project-detector.d.ts.map

package/dist/utils/project-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-detector.d.ts","sourceRoot":"","sources":["../../src/utils/project-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACpD,cAAc,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IACjD,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,IAAI,CAAC;CAClB;AAQD,wBAAgB,aAAa,CAAC,QAAQ,GAAE,MAAsB,GAAG,WAAW,GAAG,IAAI,CA8GlF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAgBrE"}

package/dist/utils/project-detector.js

@@ -0,0 +1,119 @@
+/**
+ * Project Detector
+ *
+ * Detects the type of project in the current working directory.
+ */
+import { existsSync, readFileSync } from "fs";
+import { join, basename } from "path";
+export function detectProject(rootPath = process.cwd()) {
+    // Try to detect project type based on config files
+    const projectInfo = {
+        rootPath,
+        name: basename(rootPath),
+        type: "unknown",
+        hasTypeScript: false,
+        detectedAt: new Date(),
+    };
+    // Check for Node.js project
+    const packageJsonPath = join(rootPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            projectInfo.name = packageJson.name || projectInfo.name;
+            projectInfo.type = "node";
+            // Check for TypeScript
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            projectInfo.hasTypeScript = "typescript" in deps || existsSync(join(rootPath, "tsconfig.json"));
+            // Detect package manager
+            if (existsSync(join(rootPath, "bun.lockb")) || existsSync(join(rootPath, "bun.lock"))) {
+                projectInfo.packageManager = "bun";
+            }
+            else if (existsSync(join(rootPath, "pnpm-lock.yaml"))) {
+                projectInfo.packageManager = "pnpm";
+            }
+            else if (existsSync(join(rootPath, "yarn.lock"))) {
+                projectInfo.packageManager = "yarn";
+            }
+            else if (existsSync(join(rootPath, "package-lock.json"))) {
+                projectInfo.packageManager = "npm";
+            }
+            return projectInfo;
+        }
+        catch {
+            // Invalid package.json, continue checking other types
+        }
+    }
+    // Check for Python project
+    if (existsSync(join(rootPath, "pyproject.toml")) ||
+        existsSync(join(rootPath, "setup.py")) ||
+        existsSync(join(rootPath, "requirements.txt"))) {
+        projectInfo.type = "python";
+        // Try to get project name from pyproject.toml
+        const pyprojectPath = join(rootPath, "pyproject.toml");
+        if (existsSync(pyprojectPath)) {
+            try {
+                const content = readFileSync(pyprojectPath, "utf-8");
+                const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+                if (nameMatch?.[1]) {
+                    projectInfo.name = nameMatch[1];
+                }
+            }
+            catch {
+                // Ignore parsing errors
+            }
+        }
+        return projectInfo;
+    }
+    // Check for Rust project
+    if (existsSync(join(rootPath, "Cargo.toml"))) {
+        projectInfo.type = "rust";
+        try {
+            const cargoToml = readFileSync(join(rootPath, "Cargo.toml"), "utf-8");
+            const nameMatch = cargoToml.match(/name\s*=\s*["']([^"']+)["']/);
+            if (nameMatch?.[1]) {
+                projectInfo.name = nameMatch[1];
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+        return projectInfo;
+    }
+    // Check for Go project
+    if (existsSync(join(rootPath, "go.mod"))) {
+        projectInfo.type = "go";
+        try {
+            const goMod = readFileSync(join(rootPath, "go.mod"), "utf-8");
+            const moduleMatch = goMod.match(/module\s+(\S+)/);
+            if (moduleMatch?.[1]) {
+                const modulePath = moduleMatch[1];
+                projectInfo.name = modulePath.split("/").pop() ?? modulePath;
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+        return projectInfo;
+    }
+    // If we found any config files but couldn't determine type
+    if (existsSync(join(rootPath, ".git")) ||
+        existsSync(join(rootPath, "README.md")) ||
+        existsSync(join(rootPath, "Makefile"))) {
+        return projectInfo;
+    }
+    // No project detected
+    return null;
+}
+export function getProjectSummary(project) {
+    if (!project) {
+        return "No project detected in current directory.";
+    }
+    const parts = [`**${project.name}** (${project.type})`];
+    if (project.packageManager) {
+        parts.push(`Package Manager: ${project.packageManager}`);
+    }
+    if (project.hasTypeScript) {
+        parts.push("TypeScript enabled");
+    }
+    return parts.join(" | ");
+}

package/dist/utils/segment-scorer.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Segment Scorer
+ *
+ * Combines multiple scoring signals to determine segment importance:
+ * - TF-IDF: Unique/rare terms are more important
+ * - Position: Beginning and end of content are more important
+ * - Keywords: Errors, instructions, code blocks get priority
+ */
+/**
+ * Segment types based on content structure
+ */
+export type SegmentType = "sentence" | "line" | "paragraph" | "code-block";
+/**
+ * A segment of content with metadata
+ */
+export interface Segment {
+    text: string;
+    startLine: number;
+    endLine: number;
+    type: SegmentType;
+    /** Normalized position in document (0-1) */
+    position: number;
+    /** Token count for this segment */
+    tokens: number;
+    /** Whether this segment matches a preserve pattern */
+    isPreserved: boolean;
+}
+/**
+ * Segment with calculated importance scores
+ */
+export interface ScoredSegment extends Segment {
+    /** Combined importance score (0-1) */
+    importance: number;
+    /** Individual score components */
+    scores: {
+        tfidf: number;
+        position: number;
+        keyword: number;
+        combined: number;
+    };
+}
+/**
+ * Weights for combining different scoring signals
+ */
+export interface ScoringWeights {
+    tfidf: number;
+    position: number;
+    keyword: number;
+}
+/**
+ * Default scoring weights (must sum to 1.0)
+ */
+export declare const DEFAULT_WEIGHTS: ScoringWeights;
+/**
+ * Calculate position weight using a U-shaped curve
+ * Beginning (0-10%) and end (90-100%) get highest weight
+ * Middle content gets lower weight
+ *
+ * @param position - Normalized position (0-1)
+ * @returns Position weight (0.6-1.0)
+ */
+export declare function calculatePositionWeight(position: number): number;
+/**
+ * Calculate keyword boost based on content patterns
+ * Multiple matches compound additively up to 1.0
+ *
+ * @param text - Segment text to analyze
+ * @returns Keyword boost (0-1)
+ */
+export declare function calculateKeywordBoost(text: string): number;
+/**
+ * Create a segment from text
+ *
+ * @param text - Segment text
+ * @param startLine - Starting line number
+ * @param endLine - Ending line number
+ * @param type - Segment type
+ * @param totalLines - Total lines in document (for position calculation)
+ * @returns Segment object
+ */
+export declare function createSegment(text: string, startLine: number, endLine: number, type: SegmentType, totalLines: number): Segment;
+/**
+ * Score a segment combining all signals
+ *
+ * @param segment - Segment to score
+ * @param tfidfScore - Pre-calculated TF-IDF score (0-1)
+ * @param weights - Scoring weights
+ * @returns Scored segment with importance
+ */
+export declare function scoreSegment(segment: Segment, tfidfScore: number, weights?: ScoringWeights): ScoredSegment;
+/**
+ * Check if text contains error indicators
+ */
+export declare function hasErrorIndicators(text: string): boolean;
+/**
+ * Check if text contains instruction indicators
+ */
+export declare function hasInstructionIndicators(text: string): boolean;
+//# sourceMappingURL=segment-scorer.d.ts.map

package/dist/utils/segment-scorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-scorer.d.ts","sourceRoot":"","sources":["../../src/utils/segment-scorer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,WAAW,GAAG,YAAY,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,OAAO;IAC5C,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,cAI7B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAYhE;AA+BD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0B1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAUT;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,cAAgC,GACxC,aAAa,CAoBf;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D"}