wave-agent-sdk 0.0.1

package/dist/hooks/manager.js

@@ -0,0 +1,395 @@
+/**
+ * Hook Manager
+ *
+ * Central orchestrator for the hooks system. Handles configuration loading,
+ * validation, and hook execution across all supported events.
+ */
+import { HookConfigurationError, isValidHookEvent, isValidHookEventConfig, } from "./types.js";
+import { HookMatcher } from "./matcher.js";
+import { HookExecutor } from "./executor.js";
+import { loadMergedHooksConfig } from "./settings.js";
+export class HookManager {
+    constructor(workdir, matcher = new HookMatcher(), executor, logger) {
+        this.workdir = workdir;
+        this.matcher = matcher;
+        // Create executor with logger if provided, or use passed executor, or create default
+        this.executor = logger
+            ? new HookExecutor(logger)
+            : executor || new HookExecutor();
+        this.logger = logger;
+    }
+    /**
+     * Load and merge hook configurations from user and project settings
+     * Project settings take precedence over user settings
+     */
+    loadConfiguration(userHooks, projectHooks) {
+        const merged = {};
+        // Start with user hooks
+        if (userHooks) {
+            this.mergeHooksConfiguration(merged, userHooks);
+        }
+        // Override with project hooks (project settings take precedence)
+        if (projectHooks) {
+            this.mergeHooksConfiguration(merged, projectHooks);
+        }
+        // Validate merged configuration
+        const validation = this.validatePartialConfiguration(merged);
+        if (!validation.valid) {
+            throw new HookConfigurationError("merged configuration", validation.errors);
+        }
+        this.configuration = merged;
+    }
+    /**
+     * Load configuration from filesystem settings
+     * Automatically loads and merges user and project hooks configuration
+     */
+    loadConfigurationFromSettings() {
+        try {
+            this.logger?.debug(`[HookManager] Loading configuration...`);
+            const mergedConfig = loadMergedHooksConfig(this.workdir);
+            this.logger?.debug(`[HookManager] Merged config result:`, mergedConfig);
+            this.configuration = mergedConfig;
+            // Validate the loaded configuration
+            const validation = this.validatePartialConfiguration(mergedConfig);
+            if (!validation.valid) {
+                throw new HookConfigurationError("filesystem settings", validation.errors);
+            }
+            this.logger?.debug(`[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig).length} event types`);
+        }
+        catch (error) {
+            // If loading fails, start with undefined configuration (no hooks)
+            this.configuration = undefined;
+            // Re-throw configuration errors, but handle file system errors gracefully
+            if (error instanceof HookConfigurationError) {
+                throw error;
+            }
+            else {
+                this.logger?.warn("Failed to load hooks configuration from settings:", error);
+            }
+        }
+    }
+    /**
+     * Execute hooks for a specific event
+     */
+    async executeHooks(event, context) {
+        // Validate execution context
+        const contextValidation = this.validateExecutionContext(event, context);
+        if (!contextValidation.valid) {
+            this.logger?.error(`[HookManager] Invalid execution context for ${event}: ${contextValidation.errors.join(", ")}`);
+            return [
+                {
+                    success: false,
+                    stderr: `Invalid execution context: ${contextValidation.errors.join(", ")}`,
+                    duration: 0,
+                    timedOut: false,
+                },
+            ];
+        }
+        if (!this.configuration) {
+            this.logger?.debug(`[HookManager] No configuration loaded, skipping ${event} hooks`);
+            return [];
+        }
+        const eventConfigs = this.configuration[event];
+        if (!eventConfigs || eventConfigs.length === 0) {
+            this.logger?.debug(`[HookManager] No hooks configured for ${event} event`);
+            return [];
+        }
+        this.logger?.debug(`[HookManager] Starting ${event} hook execution with ${eventConfigs.length} configurations`);
+        const results = [];
+        const startTime = Date.now();
+        for (let configIndex = 0; configIndex < eventConfigs.length; configIndex++) {
+            const config = eventConfigs[configIndex];
+            // Check if this config applies to the current context
+            if (!this.configApplies(config, event, context.toolName)) {
+                this.logger?.debug(`[HookManager] Skipping configuration ${configIndex + 1}: matcher '${config.matcher}' does not match tool '${context.toolName}'`);
+                continue;
+            }
+            this.logger?.debug(`[HookManager] Executing configuration ${configIndex + 1} with ${config.hooks.length} commands (matcher: ${config.matcher || "any"})`);
+            // Execute all commands for this configuration
+            for (let commandIndex = 0; commandIndex < config.hooks.length; commandIndex++) {
+                const hookCommand = config.hooks[commandIndex];
+                try {
+                    this.logger?.debug(`[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`);
+                    const result = await this.executor.executeCommand(hookCommand.command, context);
+                    results.push(result);
+                    // Report individual command result
+                    if (result.success) {
+                        this.logger?.debug(`[HookManager] Command ${commandIndex + 1} completed successfully in ${result.duration}ms`);
+                    }
+                    else {
+                        this.logger?.warn(`[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`);
+                    }
+                    // Continue with next command even if this one fails
+                    // This allows for non-critical hooks to fail without stopping the workflow
+                }
+                catch (error) {
+                    // This should be rare as executor handles most errors
+                    const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
+                    this.logger?.error(`[HookManager] Unexpected error in command ${commandIndex + 1}: ${errorMessage}`);
+                    results.push({
+                        success: false,
+                        stderr: errorMessage,
+                        duration: 0,
+                        timedOut: false,
+                    });
+                }
+            }
+        }
+        // Generate execution summary
+        const totalDuration = Date.now() - startTime;
+        const summary = this.generateExecutionSummary(event, results, totalDuration);
+        this.logger?.info(`[HookManager] ${event} execution summary: ${summary}`);
+        return results;
+    }
+    /**
+     * Check if hooks are configured for an event/tool combination
+     */
+    hasHooks(event, toolName) {
+        if (!this.configuration)
+            return false;
+        const eventConfigs = this.configuration[event];
+        if (!eventConfigs || eventConfigs.length === 0)
+            return false;
+        return eventConfigs.some((config) => this.configApplies(config, event, toolName));
+    }
+    /**
+     * Validate hook configuration structure and content
+     */
+    validateConfiguration(config) {
+        const errors = [];
+        if (!config || typeof config !== "object") {
+            return { valid: false, errors: ["Configuration must be an object"] };
+        }
+        if (!config.hooks || typeof config.hooks !== "object") {
+            return {
+                valid: false,
+                errors: ["Configuration must have a hooks property"],
+            };
+        }
+        // Validate each hook event
+        for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
+            // Validate event name
+            if (!isValidHookEvent(eventName)) {
+                errors.push(`Invalid hook event: ${eventName}`);
+                continue;
+            }
+            // Validate event configurations
+            if (!Array.isArray(eventConfigs)) {
+                errors.push(`Hook event ${eventName} must be an array of configurations`);
+                continue;
+            }
+            eventConfigs.forEach((eventConfig, index) => {
+                const configErrors = this.validateEventConfig(eventName, eventConfig, index);
+                errors.push(...configErrors);
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Validate partial hook configuration structure and content
+     */
+    validatePartialConfiguration(config) {
+        const errors = [];
+        if (!config || typeof config !== "object") {
+            return { valid: false, errors: ["Configuration must be an object"] };
+        }
+        // Validate each hook event that is present
+        for (const [eventName, eventConfigs] of Object.entries(config)) {
+            // Validate event name
+            if (!isValidHookEvent(eventName)) {
+                errors.push(`Invalid hook event: ${eventName}`);
+                continue;
+            }
+            // Validate event configurations
+            if (!Array.isArray(eventConfigs)) {
+                errors.push(`Hook event ${eventName} must be an array of configurations`);
+                continue;
+            }
+            eventConfigs.forEach((eventConfig, index) => {
+                const configErrors = this.validateEventConfig(eventName, eventConfig, index);
+                errors.push(...configErrors);
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfiguration() {
+        if (!this.configuration)
+            return undefined;
+        // Deep clone to prevent external modification
+        return JSON.parse(JSON.stringify(this.configuration));
+    }
+    /**
+     * Clear current configuration
+     */
+    clearConfiguration() {
+        this.configuration = undefined;
+    }
+    /**
+     * Validate execution context for a specific event
+     */
+    validateExecutionContext(event, context) {
+        const errors = [];
+        // Validate basic context structure
+        if (!context || typeof context !== "object") {
+            return { valid: false, errors: ["Context must be an object"] };
+        }
+        // Warn about event mismatch but don't fail validation
+        if (context.event !== event) {
+            this.logger?.warn(`[HookManager] Context event '${context.event}' does not match requested event '${event}'`);
+        }
+        // Validate project directory
+        if (!context.projectDir || typeof context.projectDir !== "string") {
+            errors.push("Context must have a valid projectDir string");
+        }
+        // Validate timestamp
+        if (!context.timestamp || !(context.timestamp instanceof Date)) {
+            errors.push("Context must have a valid timestamp Date object");
+        }
+        // Validate tool-specific requirements
+        if (event === "PreToolUse" || event === "PostToolUse") {
+            if (!context.toolName || typeof context.toolName !== "string") {
+                errors.push(`${event} event requires a valid toolName in context`);
+            }
+        }
+        // Validate non-tool events don't have unexpected tool names
+        if ((event === "UserPromptSubmit" || event === "Stop") &&
+            context.toolName !== undefined) {
+            this.logger?.warn(`[HookManager] ${event} event has unexpected toolName in context: ${context.toolName}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Generate a summary of hook execution results
+     */
+    generateExecutionSummary(event, results, totalDuration) {
+        if (results.length === 0) {
+            return `No hooks executed for ${event}`;
+        }
+        const successful = results.filter((r) => r.success).length;
+        const failed = results.length - successful;
+        const timedOut = results.filter((r) => r.timedOut).length;
+        const avgDuration = results.reduce((sum, r) => sum + r.duration, 0) / results.length;
+        let summary = `${successful}/${results.length} commands successful`;
+        if (failed > 0) {
+            summary += `, ${failed} failed`;
+        }
+        if (timedOut > 0) {
+            summary += `, ${timedOut} timed out`;
+        }
+        summary += ` (avg: ${Math.round(avgDuration)}ms, total: ${totalDuration}ms)`;
+        return summary;
+    }
+    /**
+     * Merge hook configurations, with the second taking precedence
+     */
+    mergeHooksConfiguration(target, source) {
+        for (const [event, configs] of Object.entries(source)) {
+            if (isValidHookEvent(event)) {
+                // For now, completely replace event configs rather than merging
+                // This ensures project settings completely override user settings for each event
+                target[event] = [...configs];
+            }
+        }
+    }
+    /**
+     * Check if a hook configuration applies to the current context
+     */
+    configApplies(config, event, toolName) {
+        // For events that don't use matchers, config always applies
+        if (event === "UserPromptSubmit" || event === "Stop") {
+            return true;
+        }
+        // For tool-based events, check matcher if present
+        if (event === "PreToolUse" || event === "PostToolUse") {
+            if (!config.matcher) {
+                // No matcher means applies to all tools
+                return true;
+            }
+            if (!toolName) {
+                // No tool name provided, cannot match
+                return false;
+            }
+            return this.matcher.matches(config.matcher, toolName);
+        }
+        return false;
+    }
+    /**
+     * Validate a single event configuration
+     */
+    validateEventConfig(event, config, index) {
+        const errors = [];
+        const prefix = `Hook event ${event}[${index}]`;
+        if (!isValidHookEventConfig(config)) {
+            errors.push(`${prefix}: Invalid hook event configuration structure`);
+            return errors;
+        }
+        // Validate matcher requirements
+        if ((event === "PreToolUse" || event === "PostToolUse") && config.matcher) {
+            if (!this.matcher.isValidPattern(config.matcher)) {
+                errors.push(`${prefix}: Invalid matcher pattern: ${config.matcher}`);
+            }
+        }
+        // Validate that non-tool events don't have matchers
+        if ((event === "UserPromptSubmit" || event === "Stop") && config.matcher) {
+            errors.push(`${prefix}: Event ${event} should not have a matcher`);
+        }
+        // Validate commands
+        config.hooks.forEach((hookCommand, cmdIndex) => {
+            if (!this.executor.isCommandSafe(hookCommand.command)) {
+                errors.push(`${prefix}.hooks[${cmdIndex}]: Command may be unsafe: ${hookCommand.command}`);
+            }
+        });
+        return errors;
+    }
+    /**
+     * Get statistics about current configuration
+     */
+    getConfigurationStats() {
+        if (!this.configuration) {
+            return {
+                totalEvents: 0,
+                totalConfigs: 0,
+                totalCommands: 0,
+                eventBreakdown: {
+                    PreToolUse: 0,
+                    PostToolUse: 0,
+                    UserPromptSubmit: 0,
+                    Stop: 0,
+                },
+            };
+        }
+        const eventBreakdown = {
+            PreToolUse: 0,
+            PostToolUse: 0,
+            UserPromptSubmit: 0,
+            Stop: 0,
+        };
+        let totalConfigs = 0;
+        let totalCommands = 0;
+        Object.entries(this.configuration).forEach(([event, configs]) => {
+            if (isValidHookEvent(event)) {
+                eventBreakdown[event] = configs.length;
+                totalConfigs += configs.length;
+                totalCommands += configs.reduce((sum, config) => sum + config.hooks.length, 0);
+            }
+        });
+        return {
+            totalEvents: Object.keys(this.configuration).length,
+            totalConfigs,
+            totalCommands,
+            eventBreakdown,
+        };
+    }
+}

package/dist/hooks/matcher.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hook Pattern Matcher
+ *
+ * Provides pattern matching functionality for hook tool name matching.
+ * Supports exact matching, wildcard patterns, and pipe-separated alternatives.
+ */
+export interface IHookMatcher {
+    matches(pattern: string, toolName: string): boolean;
+    isValidPattern(pattern: string): boolean;
+    getPatternType(pattern: string): "exact" | "glob" | "regex" | "alternatives";
+}
+export declare class HookMatcher implements IHookMatcher {
+    /**
+     * Test if pattern matches tool name
+     * Supports multiple matching strategies:
+     * - Exact matching: "Edit" matches "Edit"
+     * - Pipe alternatives: "Edit|Write" matches "Edit" or "Write"
+     * - Glob patterns: "Edit*" matches "EditFile", "EditText", etc.
+     * - Case insensitive matching
+     */
+    matches(pattern: string, toolName: string): boolean;
+    /**
+     * Match a single pattern against tool name
+     */
+    private matchesSingle;
+    /**
+     * Validate pattern syntax
+     */
+    isValidPattern(pattern: string): boolean;
+    /**
+     * Validate single pattern syntax
+     */
+    private isValidSinglePattern;
+    /**
+     * Get pattern type for optimization
+     */
+    getPatternType(pattern: string): "exact" | "glob" | "regex" | "alternatives";
+    /**
+     * Get all tool names that would match this pattern from a given list
+     * Useful for testing and validation
+     */
+    getMatches(pattern: string, toolNames: string[]): string[];
+    /**
+     * Optimize pattern for repeated matching
+     * Returns a compiled matcher function for performance
+     */
+    compile(pattern: string): (toolName: string) => boolean;
+}
+//# sourceMappingURL=matcher.d.ts.map

package/dist/hooks/matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matcher.d.ts","sourceRoot":"","sources":["../../src/hooks/matcher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,YAAY;IAE3B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAGpD,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAGzC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,cAAc,CAAC;CAC9E;AAED,qBAAa,WAAY,YAAW,YAAY;IAC9C;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAYnD;;OAEG;IACH,OAAO,CAAC,aAAa;IAmBrB;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAoBxC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAmB5B;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,cAAc;IA6B5E;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAI1D;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO;CAkCxD"}

package/dist/hooks/matcher.js

@@ -0,0 +1,147 @@
+/**
+ * Hook Pattern Matcher
+ *
+ * Provides pattern matching functionality for hook tool name matching.
+ * Supports exact matching, wildcard patterns, and pipe-separated alternatives.
+ */
+import { minimatch } from "minimatch";
+export class HookMatcher {
+    /**
+     * Test if pattern matches tool name
+     * Supports multiple matching strategies:
+     * - Exact matching: "Edit" matches "Edit"
+     * - Pipe alternatives: "Edit|Write" matches "Edit" or "Write"
+     * - Glob patterns: "Edit*" matches "EditFile", "EditText", etc.
+     * - Case insensitive matching
+     */
+    matches(pattern, toolName) {
+        if (!pattern || !toolName)
+            return false;
+        // Handle pipe-separated alternatives (e.g., "Edit|Write|Delete")
+        if (pattern.includes("|")) {
+            const alternatives = pattern.split("|").map((alt) => alt.trim());
+            return alternatives.some((alt) => this.matchesSingle(alt, toolName));
+        }
+        return this.matchesSingle(pattern, toolName);
+    }
+    /**
+     * Match a single pattern against tool name
+     */
+    matchesSingle(pattern, toolName) {
+        // Exact match (case insensitive)
+        if (pattern.toLowerCase() === toolName.toLowerCase()) {
+            return true;
+        }
+        // Glob pattern matching using minimatch
+        try {
+            return minimatch(toolName, pattern, {
+                nocase: true, // Case insensitive
+                noglobstar: false, // Allow ** patterns
+                nonegate: true, // Disable negation for security
+            });
+        }
+        catch {
+            // Invalid pattern, fall back to exact match
+            return false;
+        }
+    }
+    /**
+     * Validate pattern syntax
+     */
+    isValidPattern(pattern) {
+        if (!pattern || typeof pattern !== "string")
+            return false;
+        // Empty pattern is invalid
+        if (pattern.trim().length === 0)
+            return false;
+        // Handle pipe-separated alternatives
+        if (pattern.includes("|")) {
+            const alternatives = pattern.split("|").map((alt) => alt.trim());
+            return (alternatives.length > 0 &&
+                alternatives.every((alt) => alt.length > 0 && this.isValidSinglePattern(alt)));
+        }
+        return this.isValidSinglePattern(pattern);
+    }
+    /**
+     * Validate single pattern syntax
+     */
+    isValidSinglePattern(pattern) {
+        // Basic validation - non-empty string
+        if (!pattern || pattern.trim().length === 0)
+            return false;
+        // Check for dangerous characters that could be used for command injection
+        // Note: [ ] are allowed for glob patterns
+        const dangerousChars = /[;&|`$(){}><]/;
+        if (dangerousChars.test(pattern))
+            return false;
+        // Validate glob pattern syntax using minimatch
+        try {
+            // Test with a dummy string to validate pattern
+            minimatch("test", pattern, { nocase: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get pattern type for optimization
+     */
+    getPatternType(pattern) {
+        if (!pattern)
+            return "exact";
+        // Check for pipe alternatives first
+        if (pattern.includes("|")) {
+            return "alternatives";
+        }
+        // Check for regex patterns first (before glob check)
+        if (pattern.startsWith("/") &&
+            pattern.endsWith("/") &&
+            pattern.length > 2) {
+            return "regex";
+        }
+        // Check for glob patterns
+        if (pattern.includes("*") ||
+            pattern.includes("?") ||
+            pattern.includes("[")) {
+            return "glob";
+        }
+        return "exact";
+    }
+    /**
+     * Get all tool names that would match this pattern from a given list
+     * Useful for testing and validation
+     */
+    getMatches(pattern, toolNames) {
+        return toolNames.filter((toolName) => this.matches(pattern, toolName));
+    }
+    /**
+     * Optimize pattern for repeated matching
+     * Returns a compiled matcher function for performance
+     */
+    compile(pattern) {
+        if (!this.isValidPattern(pattern)) {
+            return () => false;
+        }
+        const patternType = this.getPatternType(pattern);
+        switch (patternType) {
+            case "exact": {
+                const lowerPattern = pattern.toLowerCase();
+                return (toolName) => toolName.toLowerCase() === lowerPattern;
+            }
+            case "alternatives": {
+                const alternatives = pattern
+                    .split("|")
+                    .map((alt) => alt.trim().toLowerCase());
+                return (toolName) => {
+                    const lowerTool = toolName.toLowerCase();
+                    return alternatives.some((alt) => lowerTool === alt || minimatch(toolName, alt, { nocase: true }));
+                };
+            }
+            case "glob":
+                return (toolName) => minimatch(toolName, pattern, { nocase: true });
+            default:
+                return (toolName) => this.matches(pattern, toolName);
+        }
+    }
+}

package/dist/hooks/settings.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Hook Settings Management
+ *
+ * Handles loading and merging of hook configurations from:
+ * - User settings: ~/.wave/hooks.json
+ * - Project settings: ./.wave/hooks.json
+ */
+import type { PartialHookConfiguration } from "./types.js";
+/**
+ * Get the user-specific hooks configuration file path
+ */
+export declare function getUserHooksConfigPath(): string;
+/**
+ * Get the project-specific hooks configuration file path
+ */
+export declare function getProjectHooksConfigPath(workdir: string): string;
+/**
+ * Load hooks configuration from a JSON file
+ */
+export declare function loadHooksConfigFromFile(filePath: string): PartialHookConfiguration | null;
+/**
+ * Load user hooks configuration
+ */
+export declare function loadUserHooksConfig(): PartialHookConfiguration | null;
+/**
+ * Load project hooks configuration
+ */
+export declare function loadProjectHooksConfig(workdir: string): PartialHookConfiguration | null;
+/**
+ * Load and merge hooks configuration with project settings taking precedence
+ */
+export declare function loadMergedHooksConfig(workdir: string): PartialHookConfiguration;
+/**
+ * Check if any hooks configuration files exist
+ */
+export declare function hasHooksConfiguration(workdir: string): boolean;
+/**
+ * Get information about available hooks configuration files
+ */
+export declare function getHooksConfigurationInfo(workdir: string): {
+    userConfigExists: boolean;
+    projectConfigExists: boolean;
+    userConfigPath: string;
+    projectConfigPath: string;
+};
+//# sourceMappingURL=settings.d.ts.map

package/dist/hooks/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/hooks/settings.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAqB,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG9E;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GACf,wBAAwB,GAAG,IAAI,CAoBjC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,wBAAwB,GAAG,IAAI,CAErE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GACd,wBAAwB,GAAG,IAAI,CAEjC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GACd,wBAAwB,CAyB1B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK9D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG;IAC1D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAOA"}