wave-agent-sdk 0.0.15 → 0.0.17-alpha.0

package/dist/managers/permissionManager.js

@@ -6,16 +6,25 @@
  * handles custom callback integration.
  */
 import path from "node:path";
+import { minimatch } from "minimatch";
 import { RESTRICTED_TOOLS } from "../types/permissions.js";
 import { splitBashCommand, stripEnvVars, stripRedirections, getSmartPrefix, DANGEROUS_COMMANDS, } from "../utils/bashParser.js";
 import { isPathInside } from "../utils/pathSafety.js";
-const SAFE_COMMANDS = ["cd", "ls", "pwd"];
+import { BASH_TOOL_NAME, EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME, DELETE_FILE_TOOL_NAME, WRITE_TOOL_NAME, READ_TOOL_NAME, LS_TOOL_NAME, } from "../constants/tools.js";
+const SAFE_COMMANDS = ["cd", "ls", "pwd", "true", "false"];
 export class PermissionManager {
     constructor(options = {}) {
         this.allowedRules = [];
+        this.deniedRules = [];
+        this.temporaryRules = [];
+        this.additionalDirectories = [];
         this.logger = options.logger;
         this.configuredDefaultMode = options.configuredDefaultMode;
         this.allowedRules = options.allowedRules || [];
+        this.deniedRules = options.deniedRules || [];
+        this.workdir = options.workdir;
+        this.planFilePath = options.planFilePath;
+        this.updateAdditionalDirectories(options.additionalDirectories || []);
     }
     /**
      * Set a callback to be notified when the effective permission mode changes due to configuration updates
@@ -58,11 +67,105 @@ export class PermissionManager {
         });
         this.allowedRules = rules;
     }
+    /**
+     * Update the denied rules (e.g., when configuration reloads)
+     */
+    updateDeniedRules(rules) {
+        this.logger?.debug("Updating denied permission rules", {
+            count: rules.length,
+        });
+        this.deniedRules = rules;
+    }
+    /**
+     * Add temporary rules for the current session
+     */
+    addTemporaryRules(rules) {
+        this.logger?.debug("Adding temporary permission rules", {
+            count: rules.length,
+            rules,
+        });
+        this.temporaryRules.push(...rules);
+    }
+    /**
+     * Clear all temporary rules
+     */
+    clearTemporaryRules() {
+        this.logger?.debug("Clearing temporary permission rules");
+        this.temporaryRules = [];
+    }
+    /**
+     * Update the additional directories (e.g., when configuration reloads)
+     */
+    updateAdditionalDirectories(directories) {
+        this.logger?.debug("Updating additional directories", {
+            count: directories.length,
+        });
+        this.additionalDirectories = directories.map((dir) => {
+            if (this.workdir && !path.isAbsolute(dir)) {
+                return path.resolve(this.workdir, dir);
+            }
+            return path.resolve(dir);
+        });
+    }
+    /**
+     * Update the working directory
+     */
+    updateWorkdir(workdir) {
+        this.logger?.debug("Updating working directory", {
+            workdir,
+        });
+        this.workdir = workdir;
+    }
+    /**
+     * Set the current plan file path
+     */
+    setPlanFilePath(path) {
+        this.logger?.debug("Setting plan file path", { path });
+        this.planFilePath = path;
+    }
+    /**
+     * Get the current plan file path
+     */
+    getPlanFilePath() {
+        return this.planFilePath;
+    }
+    /**
+     * Check if a path is inside the Safe Zone (workdir + additionalDirectories)
+     */
+    isInsideSafeZone(targetPath, workdir) {
+        const effectiveWorkdir = workdir || this.workdir;
+        // Resolve the target path relative to effectiveWorkdir if it's not absolute
+        const absolutePath = effectiveWorkdir && !path.isAbsolute(targetPath)
+            ? path.resolve(effectiveWorkdir, targetPath)
+            : path.resolve(targetPath);
+        // Check workdir
+        if (effectiveWorkdir && isPathInside(absolutePath, effectiveWorkdir)) {
+            return { isInside: true, resolvedPath: absolutePath };
+        }
+        // Check additional directories
+        for (const dir of this.additionalDirectories) {
+            if (isPathInside(absolutePath, dir)) {
+                return { isInside: true, resolvedPath: absolutePath };
+            }
+        }
+        this.logger?.debug("Path is outside Safe Zone", {
+            absolutePath,
+            workdir: effectiveWorkdir,
+            additionalDirectories: this.additionalDirectories,
+        });
+        return { isInside: false, resolvedPath: absolutePath };
+    }
     /**
      * Get the current effective permission mode for tool execution context
      */
     getCurrentEffectiveMode(cliPermissionMode) {
-        return this.resolveEffectivePermissionMode(cliPermissionMode);
+        const mode = this.resolveEffectivePermissionMode(cliPermissionMode);
+        this.logger?.debug("getCurrentEffectiveMode", {
+            cliPermissionMode,
+            configuredDefaultMode: this.configuredDefaultMode,
+            resolvedMode: mode,
+        });
+        return mode;
     }
     /**
      * Resolve the effective permission mode based on CLI override and configured default
@@ -97,6 +200,19 @@ export class PermissionManager {
             permissionMode: context.permissionMode,
             hasCallback: !!context.canUseToolCallback,
         });
+        // 0. Check denied rules first - Deny always takes precedence
+        for (const rule of this.deniedRules) {
+            if (this.matchesRule(context, rule)) {
+                this.logger?.warn("Permission denied by rule", {
+                    toolName: context.toolName,
+                    rule,
+                });
+                return {
+                    behavior: "deny",
+                    message: `Access to tool '${context.toolName}' is explicitly denied by rule: ${rule}`,
+                };
+            }
+        }
         // 1. If bypassPermissions mode, always allow
         if (context.permissionMode === "bypassPermissions") {
             this.logger?.debug("Permission bypassed for tool", {
@@ -106,14 +222,77 @@ export class PermissionManager {
         }
         // 1.1 If acceptEdits mode, allow Edit, MultiEdit, Delete, Write
         if (context.permissionMode === "acceptEdits") {
-            const autoAcceptedTools = ["Edit", "MultiEdit", "Delete", "Write"];
+            const autoAcceptedTools = [
+                EDIT_TOOL_NAME,
+                MULTI_EDIT_TOOL_NAME,
+                DELETE_FILE_TOOL_NAME,
+                WRITE_TOOL_NAME,
+            ];
             if (autoAcceptedTools.includes(context.toolName)) {
+                // Enforce Safe Zone for file operations
+                const targetPath = (context.toolInput?.file_path ||
+                    context.toolInput?.target_file);
+                const workdir = context.toolInput?.workdir;
+                if (targetPath) {
+                    const { isInside, resolvedPath } = this.isInsideSafeZone(targetPath, workdir);
+                    if (!isInside) {
+                        this.logger?.warn("File operation outside the Safe Zone in acceptEdits mode", {
+                            toolName: context.toolName,
+                            targetPath,
+                            resolvedPath,
+                        });
+                        return {
+                            behavior: "deny",
+                            message: `Tool '${context.toolName}' attempted to modify a file outside the Safe Zone: ${targetPath}. Operations outside the Safe Zone always require manual confirmation.`,
+                        };
+                    }
+                }
                 this.logger?.debug("Permission automatically accepted for tool in acceptEdits mode", {
                     toolName: context.toolName,
                 });
                 return { behavior: "allow" };
             }
         }
+        // 1.3 If plan mode, allow Read-only tools and Edit/Write for plan file
+        if (context.permissionMode === "plan") {
+            if (context.toolName === BASH_TOOL_NAME) {
+                return {
+                    behavior: "deny",
+                    message: "Bash commands are not allowed in plan mode.",
+                };
+            }
+            const writeTools = [
+                EDIT_TOOL_NAME,
+                MULTI_EDIT_TOOL_NAME,
+                WRITE_TOOL_NAME,
+                DELETE_FILE_TOOL_NAME,
+            ];
+            if (context.toolName === DELETE_FILE_TOOL_NAME) {
+                return {
+                    behavior: "deny",
+                    message: "Delete operations are not allowed in plan mode.",
+                };
+            }
+            if (writeTools.includes(context.toolName)) {
+                const targetPath = (context.toolInput?.file_path ||
+                    context.toolInput?.target_file);
+                if (this.planFilePath && targetPath) {
+                    const absoluteTargetPath = path.resolve(targetPath);
+                    const absolutePlanPath = path.resolve(this.planFilePath);
+                    if (absoluteTargetPath === absolutePlanPath) {
+                        this.logger?.debug("Allowing write to plan file in plan mode", {
+                            toolName: context.toolName,
+                            targetPath,
+                        });
+                        return { behavior: "allow" };
+                    }
+                }
+                return {
+                    behavior: "deny",
+                    message: `In plan mode, you are only allowed to edit the designated plan file: ${this.planFilePath || "not set"}.`,
+                };
+            }
+        }
         // 1.2 Check if tool call matches any allowed rule
         if (this.isAllowedByRule(context)) {
             this.logger?.debug("Permission allowed by persistent rule", {
@@ -179,7 +358,7 @@ export class PermissionManager {
      */
     createContext(toolName, permissionMode, callback, toolInput) {
         let suggestedPrefix;
-        if (toolName === "Bash" && toolInput?.command) {
+        if (toolName === BASH_TOOL_NAME && toolInput?.command) {
             const command = String(toolInput.command);
             const parts = splitBashCommand(command);
             // Only suggest prefix for single commands to avoid confusion with complex chains
@@ -196,7 +375,7 @@ export class PermissionManager {
             suggestedPrefix,
         };
         // Set hidePersistentOption for dangerous or out-of-bounds bash commands
-        if (toolName === "Bash" && toolInput?.command) {
+        if (toolName === BASH_TOOL_NAME && toolInput?.command) {
             const command = String(toolInput.command);
             const workdir = toolInput.workdir;
             const parts = splitBashCommand(command);
@@ -211,12 +390,12 @@ export class PermissionManager {
                         return true;
                     }
                     // Check out-of-bounds for cd and ls
-                    if (workdir && (cmd === "cd" || cmd === "ls")) {
+                    if (cmd === "cd" || cmd === "ls") {
                         const pathArgs = (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter((arg) => !arg.startsWith("-")) || [];
                         return pathArgs.some((pathArg) => {
                             const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
-                            const absolutePath = path.resolve(workdir, cleanPath);
-                            return !isPathInside(absolutePath, workdir);
+                            const { isInside } = this.isInsideSafeZone(cleanPath, workdir);
+                            return !isInside;
                         });
                     }
                 }
@@ -236,60 +415,112 @@ export class PermissionManager {
         return context;
     }
     /**
-     * Check if a tool call is allowed by persistent rules
+     * Check if a tool call matches a specific permission rule
+     */
+    matchesRule(context, rule) {
+        // 1. Simple tool name match (e.g., "Bash", "Write")
+        if (rule === context.toolName) {
+            return true;
+        }
+        // 2. Tool with pattern match (e.g., "Bash(rm:*)", "Read(**/*.env)")
+        const match = rule.match(/^(\w+)\((.*)\)$/);
+        if (!match) {
+            return false;
+        }
+        const [, toolName, pattern] = match;
+        if (toolName !== context.toolName) {
+            return false;
+        }
+        // Handle Bash command rules
+        if (toolName === BASH_TOOL_NAME) {
+            const command = String(context.toolInput?.command || "");
+            const processedPart = stripRedirections(stripEnvVars(command));
+            if (pattern.endsWith(":*")) {
+                return processedPart.startsWith(pattern.slice(0, -2));
+            }
+            return processedPart === pattern;
+        }
+        // Handle path-based rules (e.g., "Read(**/*.env)")
+        const pathTools = [
+            READ_TOOL_NAME,
+            WRITE_TOOL_NAME,
+            EDIT_TOOL_NAME,
+            MULTI_EDIT_TOOL_NAME,
+            DELETE_FILE_TOOL_NAME,
+            LS_TOOL_NAME,
+        ];
+        if (pathTools.includes(toolName)) {
+            const targetPath = (context.toolInput?.file_path ||
+                context.toolInput?.target_file ||
+                context.toolInput?.path);
+            if (targetPath) {
+                return minimatch(targetPath, pattern, { dot: true });
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a tool call is allowed by persistent or temporary rules
      */
     isAllowedByRule(context) {
-        if (context.toolName === "Bash" && context.toolInput?.command) {
-            const command = String(context.toolInput.command);
-            const parts = splitBashCommand(command);
-            if (parts.length === 0)
-                return false;
-            const workdir = context.toolInput?.workdir;
-            return parts.every((part) => {
-                const processedPart = stripRedirections(stripEnvVars(part));
-                // Check for safe commands
-                const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
-                if (commandMatch) {
-                    const cmd = commandMatch[1];
-                    const args = commandMatch[2]?.trim() || "";
-                    if (SAFE_COMMANDS.includes(cmd)) {
-                        if (workdir) {
-                            if (cmd === "pwd") {
-                                return true;
-                            }
-                            // For cd and ls, check paths
-                            const pathArgs = (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter((arg) => !arg.startsWith("-")) || [];
-                            if (pathArgs.length === 0) {
-                                // cd or ls without arguments operates on current dir (workdir)
+        const isAllowedByRuleList = (ctx, rules) => {
+            if (ctx.toolName === BASH_TOOL_NAME && ctx.toolInput?.command) {
+                const command = String(ctx.toolInput.command);
+                const parts = splitBashCommand(command);
+                if (parts.length === 0)
+                    return false;
+                const workdir = ctx.toolInput?.workdir;
+                return parts.every((part) => {
+                    const processedPart = stripRedirections(stripEnvVars(part));
+                    // Check for safe commands
+                    const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
+                    if (commandMatch) {
+                        const cmd = commandMatch[1];
+                        const args = commandMatch[2]?.trim() || "";
+                        if (SAFE_COMMANDS.includes(cmd)) {
+                            if (cmd === "pwd" || cmd === "true" || cmd === "false") {
                                 return true;
                             }
-                            const allPathsSafe = pathArgs.every((pathArg) => {
-                                // Remove quotes if present
-                                const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
-                                const absolutePath = path.resolve(workdir, cleanPath);
-                                return isPathInside(absolutePath, workdir);
-                            });
-                            if (allPathsSafe) {
-                                return true;
+                            if (workdir) {
+                                // For cd and ls, check paths
+                                const pathArgs = (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter((arg) => !arg.startsWith("-")) || [];
+                                if (pathArgs.length === 0) {
+                                    // cd or ls without arguments operates on current dir (workdir)
+                                    return true;
+                                }
+                                const allPathsSafe = pathArgs.every((pathArg) => {
+                                    // Remove quotes if present
+                                    const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
+                                    const { isInside } = this.isInsideSafeZone(cleanPath, workdir);
+                                    return isInside;
+                                });
+                                if (allPathsSafe) {
+                                    return true;
+                                }
                             }
                         }
                     }
-                }
-                const action = `${context.toolName}(${processedPart})`;
-                const allowedByRule = this.allowedRules.some((rule) => {
-                    if (rule.endsWith(":*)")) {
-                        const prefix = rule.slice(0, -3);
-                        return action.startsWith(prefix);
-                    }
-                    return action === rule;
+                    // Check if this specific part is allowed by any rule
+                    // We create a temporary context with just this part of the command
+                    const partContext = {
+                        ...ctx,
+                        toolInput: { ...ctx.toolInput, command: processedPart },
+                    };
+                    const allowedByRule = rules.some((rule) => this.matchesRule(partContext, rule));
+                    if (allowedByRule)
+                        return true;
+                    return !this.isRestrictedTool(ctx.toolName);
                 });
-                if (allowedByRule)
-                    return true;
-                return !this.isRestrictedTool(context.toolName);
-            });
+            }
+            // For other tools, check if any rule matches
+            return rules.some((rule) => this.matchesRule(ctx, rule));
+        };
+        // Check temporary rules first
+        if (isAllowedByRuleList(context, this.temporaryRules)) {
+            return true;
         }
-        // Add other tools if needed in the future
-        return false;
+        // Check persistent allowed rules
+        return isAllowedByRuleList(context, this.allowedRules);
     }
     /**
      * Expand a bash command into individual permission rules, filtering out safe commands.
@@ -311,7 +542,7 @@ export class PermissionManager {
                 const cmd = commandMatch[1];
                 const args = commandMatch[2]?.trim() || "";
                 if (SAFE_COMMANDS.includes(cmd)) {
-                    if (cmd === "pwd") {
+                    if (cmd === "pwd" || cmd === "true" || cmd === "false") {
                         isSafe = true;
                     }
                     else {
@@ -323,8 +554,8 @@ export class PermissionManager {
                         else {
                             const allPathsSafe = pathArgs.every((pathArg) => {
                                 const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
-                                const absolutePath = path.resolve(workdir, cleanPath);
-                                return isPathInside(absolutePath, workdir);
+                                const { isInside } = this.isInsideSafeZone(cleanPath, workdir);
+                                return isInside;
                             });
                             if (allPathsSafe) {
                                 isSafe = true;
@@ -346,8 +577,8 @@ export class PermissionManager {
                         const pathArgs = (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter((arg) => !arg.startsWith("-")) || [];
                         const isOutOfBounds = pathArgs.some((pathArg) => {
                             const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
-                            const absolutePath = path.resolve(workdir, cleanPath);
-                            return !isPathInside(absolutePath, workdir);
+                            const { isInside } = this.isInsideSafeZone(cleanPath, workdir);
+                            return !isInside;
                         });
                         if (isOutOfBounds) {
                             continue;

package/dist/managers/planManager.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from "../types/core.js";
+/**
+ * Manages plan files for plan mode
+ */
+export declare class PlanManager {
+    private logger?;
+    private planDir;
+    constructor(logger?: Logger | undefined);
+    /**
+     * Ensures the plan directory exists and generates a new plan file path with a random name
+     */
+    getOrGeneratePlanFilePath(): Promise<{
+        path: string;
+        name: string;
+    }>;
+    /**
+     * Returns the directory where plan files are stored
+     */
+    getPlanDir(): string;
+}
+//# sourceMappingURL=planManager.d.ts.map

package/dist/managers/planManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planManager.d.ts","sourceRoot":"","sources":["../../src/managers/planManager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;GAEG;AACH,qBAAa,WAAW;IAGV,OAAO,CAAC,MAAM,CAAC;IAF3B,OAAO,CAAC,OAAO,CAAS;gBAEJ,MAAM,CAAC,EAAE,MAAM,YAAA;IAInC;;OAEG;IACU,yBAAyB,IAAI,OAAO,CAAC;QAChD,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IAgBF;;OAEG;IACI,UAAU,IAAI,MAAM;CAG5B"}

package/dist/managers/planManager.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+import { generateRandomName } from "../utils/nameGenerator.js";
+/**
+ * Manages plan files for plan mode
+ */
+export class PlanManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.planDir = path.join(os.homedir(), ".wave", "plans");
+    }
+    /**
+     * Ensures the plan directory exists and generates a new plan file path with a random name
+     */
+    async getOrGeneratePlanFilePath() {
+        try {
+            await fs.mkdir(this.planDir, { recursive: true });
+        }
+        catch (error) {
+            this.logger?.error(`Failed to create plan directory: ${this.planDir}`, error);
+            throw error;
+        }
+        const name = generateRandomName();
+        const filePath = path.join(this.planDir, `${name}.md`);
+        this.logger?.info(`Generated plan file path: ${filePath}`);
+        return { path: filePath, name };
+    }
+    /**
+     * Returns the directory where plan files are stored
+     */
+    getPlanDir() {
+        return this.planDir;
+    }
+}

package/dist/managers/pluginManager.d.ts

@@ -0,0 +1,57 @@
+import { Plugin, PluginConfig, Logger } from "../types/index.js";
+import { SkillManager } from "./skillManager.js";
+import { HookManager } from "./hookManager.js";
+import { LspManager } from "./lspManager.js";
+import { McpManager } from "./mcpManager.js";
+import { SlashCommandManager } from "./slashCommandManager.js";
+import { ConfigurationService } from "../services/configurationService.js";
+export interface PluginManagerOptions {
+    workdir: string;
+    logger?: Logger;
+    skillManager?: SkillManager;
+    hookManager?: HookManager;
+    lspManager?: LspManager;
+    mcpManager?: McpManager;
+    slashCommandManager?: SlashCommandManager;
+    enabledPlugins?: Record<string, boolean>;
+    configurationService?: ConfigurationService;
+}
+export declare class PluginManager {
+    private plugins;
+    private workdir;
+    private logger?;
+    private skillManager?;
+    private hookManager?;
+    private lspManager?;
+    private mcpManager?;
+    private slashCommandManager?;
+    private enabledPlugins;
+    private configurationService?;
+    constructor(options: PluginManagerOptions);
+    /**
+     * Update enabled plugins configuration
+     */
+    updateEnabledPlugins(enabledPlugins: Record<string, boolean>): void;
+    /**
+     * Load plugins installed via marketplace
+     */
+    private loadInstalledPlugins;
+    /**
+     * Load a single plugin from an absolute path
+     */
+    private loadSinglePlugin;
+    /**
+     * Load plugins from configuration
+     * @param configs Array of plugin configurations
+     */
+    loadPlugins(configs: PluginConfig[]): Promise<void>;
+    /**
+     * Get all loaded plugins
+     */
+    getPlugins(): Plugin[];
+    /**
+     * Get a plugin by name
+     */
+    getPlugin(name: string): Plugin | undefined;
+}
+//# sourceMappingURL=pluginManager.d.ts.map

package/dist/managers/pluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginManager.d.ts","sourceRoot":"","sources":["../../src/managers/pluginManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAE3E,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,mBAAmB,CAAC,CAAsB;IAClD,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,oBAAoB,CAAC,CAAuB;gBAExC,OAAO,EAAE,oBAAoB;IAYzC;;OAEG;IACH,oBAAoB,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAInE;;OAEG;YACW,oBAAoB;IA2BlC;;OAEG;YACW,gBAAgB;IA2D9B;;;OAGG;IACG,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBzD;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IAItB;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAG5C"}