@dexto/core 1.5.4 → 1.5.6

package/dist/filesystem/filesystem-service.cjs

@@ -1,534 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var filesystem_service_exports = {};
-__export(filesystem_service_exports, {
-  FileSystemService: () => FileSystemService
-});
-module.exports = __toCommonJS(filesystem_service_exports);
-var fs = __toESM(require("node:fs/promises"), 1);
-var path = __toESM(require("node:path"), 1);
-var import_glob = require("glob");
-var import_path = require("../utils/path.js");
-var import_path_validator = require("./path-validator.js");
-var import_errors = require("./errors.js");
-var import_types2 = require("../logger/v2/types.js");
-const DEFAULT_ENCODING = "utf-8";
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-const DEFAULT_MAX_RESULTS = 1e3;
-const DEFAULT_MAX_SEARCH_RESULTS = 100;
-class FileSystemService {
-  config;
-  pathValidator;
-  initialized = false;
-  logger;
-  constructor(config = {}, logger) {
-    this.config = {
-      allowedPaths: config.allowedPaths || ["."],
-      blockedPaths: config.blockedPaths || [".git", "node_modules/.bin", ".env"],
-      blockedExtensions: config.blockedExtensions || [".exe", ".dll", ".so"],
-      maxFileSize: config.maxFileSize || DEFAULT_MAX_FILE_SIZE,
-      enableBackups: config.enableBackups ?? false,
-      backupPath: config.backupPath,
-      // Optional absolute override, defaults handled by getBackupDir()
-      backupRetentionDays: config.backupRetentionDays || 7,
-      workingDirectory: config.workingDirectory
-    };
-    this.logger = logger.createChild(import_types2.DextoLogComponent.FILESYSTEM);
-    this.pathValidator = new import_path_validator.PathValidator(this.config, this.logger);
-  }
-  /**
-   * Get backup directory path (context-aware with optional override)
-   * TODO: Migrate to explicit configuration via CLI enrichment layer (per-agent paths)
-   */
-  getBackupDir() {
-    return this.config.backupPath || (0, import_path.getDextoPath)("backups");
-  }
-  /**
-   * Initialize the service
-   */
-  async initialize() {
-    if (this.initialized) {
-      this.logger.debug("FileSystemService already initialized");
-      return;
-    }
-    if (this.config.enableBackups) {
-      try {
-        const backupDir = this.getBackupDir();
-        await fs.mkdir(backupDir, { recursive: true });
-        this.logger.debug(`Backup directory created/verified: ${backupDir}`);
-      } catch (error) {
-        this.logger.warn(
-          `Failed to create backup directory: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    this.initialized = true;
-    this.logger.info("FileSystemService initialized successfully");
-  }
-  /**
-   * Check if a file path is within the configured allowed paths.
-   * This is a public method for external consumers (like ToolManager) to check
-   * if a path requires directory approval before file operations.
-   *
-   * @param filePath The file path to check (can be relative or absolute)
-   * @returns true if the path is within allowed paths, false otherwise
-   */
-  async isPathWithinAllowed(filePath) {
-    return this.pathValidator.isPathWithinAllowed(filePath);
-  }
-  /**
-   * Get the list of configured allowed paths.
-   * Useful for displaying to users when directory approval is needed.
-   *
-   * @returns Array of allowed path strings
-   */
-  getAllowedPaths() {
-    return this.pathValidator.getAllowedPaths();
-  }
-  /**
-   * Get the parent directory of a file path (resolved to absolute).
-   * Useful for directory approval requests.
-   *
-   * @param filePath The file path
-   * @returns The absolute parent directory path
-   */
-  getParentDirectory(filePath) {
-    return path.dirname(path.resolve(filePath));
-  }
-  /**
-   * Set a callback to check if a path is in an approved directory.
-   * This allows PathValidator to consult ApprovalManager without a direct dependency.
-   *
-   * @param checker Function that returns true if path is in an approved directory
-   */
-  setDirectoryApprovalChecker(checker) {
-    this.pathValidator.setDirectoryApprovalChecker(checker);
-  }
-  /**
-   * Read a file with validation and size limits
-   */
-  async readFile(filePath, options = {}) {
-    if (!this.initialized) {
-      throw import_errors.FileSystemError.notInitialized();
-    }
-    const validation = await this.pathValidator.validatePath(filePath);
-    if (!validation.isValid || !validation.normalizedPath) {
-      throw import_errors.FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
-    }
-    const normalizedPath = validation.normalizedPath;
-    try {
-      const stats = await fs.stat(normalizedPath);
-      if (!stats.isFile()) {
-        throw import_errors.FileSystemError.invalidPath(normalizedPath, "Path is not a file");
-      }
-      if (stats.size > this.config.maxFileSize) {
-        throw import_errors.FileSystemError.fileTooLarge(
-          normalizedPath,
-          stats.size,
-          this.config.maxFileSize
-        );
-      }
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw import_errors.FileSystemError.fileNotFound(normalizedPath);
-      }
-      if (error.code === "EACCES") {
-        throw import_errors.FileSystemError.permissionDenied(normalizedPath, "read");
-      }
-      throw import_errors.FileSystemError.readFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    try {
-      const encoding = options.encoding || DEFAULT_ENCODING;
-      const content = await fs.readFile(normalizedPath, encoding);
-      const lines = content.split("\n");
-      const limit = options.limit;
-      const offset1 = options.offset;
-      let selectedLines;
-      let truncated = false;
-      if (offset1 && offset1 > 0 || limit !== void 0) {
-        const start = offset1 && offset1 > 0 ? Math.max(0, offset1 - 1) : 0;
-        const end = limit !== void 0 ? start + limit : lines.length;
-        selectedLines = lines.slice(start, end);
-        truncated = end < lines.length;
-      } else {
-        selectedLines = lines;
-      }
-      return {
-        content: selectedLines.join("\n"),
-        lines: selectedLines.length,
-        encoding,
-        truncated,
-        size: Buffer.byteLength(content, encoding)
-      };
-    } catch (error) {
-      throw import_errors.FileSystemError.readFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Find files matching a glob pattern
-   */
-  async globFiles(pattern, options = {}) {
-    if (!this.initialized) {
-      throw import_errors.FileSystemError.notInitialized();
-    }
-    const cwd = options.cwd || this.config.workingDirectory || process.cwd();
-    const maxResults = options.maxResults || DEFAULT_MAX_RESULTS;
-    try {
-      const files = await (0, import_glob.glob)(pattern, {
-        cwd,
-        absolute: true,
-        nodir: true,
-        // Only files
-        follow: false
-        // Don't follow symlinks
-      });
-      const validFiles = [];
-      for (const file of files) {
-        const validation = await this.pathValidator.validatePath(file);
-        if (!validation.isValid || !validation.normalizedPath) {
-          this.logger.debug(`Skipping invalid path: ${file}`);
-          continue;
-        }
-        if (options.includeMetadata !== false) {
-          try {
-            const stats = await fs.stat(validation.normalizedPath);
-            validFiles.push({
-              path: validation.normalizedPath,
-              size: stats.size,
-              modified: stats.mtime,
-              isDirectory: stats.isDirectory()
-            });
-          } catch (error) {
-            this.logger.debug(
-              `Failed to stat file ${file}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        } else {
-          validFiles.push({
-            path: validation.normalizedPath,
-            size: 0,
-            modified: /* @__PURE__ */ new Date(),
-            isDirectory: false
-          });
-        }
-        if (validFiles.length >= maxResults) {
-          break;
-        }
-      }
-      const limited = validFiles.length >= maxResults;
-      return {
-        files: validFiles,
-        truncated: limited,
-        totalFound: validFiles.length
-      };
-    } catch (error) {
-      throw import_errors.FileSystemError.globFailed(
-        pattern,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Search for content in files (grep-like functionality)
-   */
-  async searchContent(pattern, options = {}) {
-    if (!this.initialized) {
-      throw import_errors.FileSystemError.notInitialized();
-    }
-    const searchPath = options.path || this.config.workingDirectory || process.cwd();
-    const globPattern = options.glob || "**/*";
-    const maxResults = options.maxResults || DEFAULT_MAX_SEARCH_RESULTS;
-    const contextLines = options.contextLines || 0;
-    try {
-      const flags = options.caseInsensitive ? "i" : "";
-      const regex = new RegExp(pattern, flags);
-      const globResult = await this.globFiles(globPattern, {
-        cwd: searchPath,
-        maxResults: 1e4
-        // Search more files, but limit results
-      });
-      const matches = [];
-      let filesSearched = 0;
-      for (const fileInfo of globResult.files) {
-        try {
-          const fileContent = await this.readFile(fileInfo.path);
-          const lines = fileContent.content.split("\n");
-          filesSearched++;
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (regex.test(line)) {
-              let context;
-              if (contextLines > 0) {
-                const before = [];
-                const after = [];
-                for (let j = Math.max(0, i - contextLines); j < i; j++) {
-                  before.push(lines[j]);
-                }
-                for (let j = i + 1; j < Math.min(lines.length, i + contextLines + 1); j++) {
-                  after.push(lines[j]);
-                }
-                context = { before, after };
-              }
-              matches.push({
-                file: fileInfo.path,
-                lineNumber: i + 1,
-                // 1-based line numbers
-                line,
-                ...context !== void 0 && { context }
-              });
-              if (matches.length >= maxResults) {
-                return {
-                  matches,
-                  totalMatches: matches.length,
-                  truncated: true,
-                  filesSearched
-                };
-              }
-            }
-          }
-        } catch (error) {
-          this.logger.debug(
-            `Skipping file ${fileInfo.path}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      return {
-        matches,
-        totalMatches: matches.length,
-        truncated: false,
-        filesSearched
-      };
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Invalid regular expression")) {
-        throw import_errors.FileSystemError.invalidPattern(pattern, "Invalid regular expression syntax");
-      }
-      throw import_errors.FileSystemError.searchFailed(
-        pattern,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Write content to a file
-   */
-  async writeFile(filePath, content, options = {}) {
-    if (!this.initialized) {
-      throw import_errors.FileSystemError.notInitialized();
-    }
-    const validation = await this.pathValidator.validatePath(filePath);
-    if (!validation.isValid || !validation.normalizedPath) {
-      throw import_errors.FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
-    }
-    const normalizedPath = validation.normalizedPath;
-    const encoding = options.encoding || DEFAULT_ENCODING;
-    let backupPath;
-    let fileExists = false;
-    try {
-      await fs.access(normalizedPath);
-      fileExists = true;
-    } catch {
-    }
-    if (fileExists && (options.backup ?? this.config.enableBackups)) {
-      backupPath = await this.createBackup(normalizedPath);
-    }
-    try {
-      if (options.createDirs) {
-        const dir = path.dirname(normalizedPath);
-        await fs.mkdir(dir, { recursive: true });
-      }
-      await fs.writeFile(normalizedPath, content, encoding);
-      const bytesWritten = Buffer.byteLength(content, encoding);
-      this.logger.debug(`File written: ${normalizedPath} (${bytesWritten} bytes)`);
-      return {
-        success: true,
-        path: normalizedPath,
-        bytesWritten,
-        backupPath
-      };
-    } catch (error) {
-      throw import_errors.FileSystemError.writeFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Edit a file by replacing text
-   */
-  async editFile(filePath, operation, options = {}) {
-    if (!this.initialized) {
-      throw import_errors.FileSystemError.notInitialized();
-    }
-    const validation = await this.pathValidator.validatePath(filePath);
-    if (!validation.isValid || !validation.normalizedPath) {
-      throw import_errors.FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
-    }
-    const normalizedPath = validation.normalizedPath;
-    const fileContent = await this.readFile(normalizedPath);
-    const originalContent = fileContent.content;
-    const occurrences = (originalContent.match(
-      new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")
-    ) || []).length;
-    if (occurrences === 0) {
-      throw import_errors.FileSystemError.stringNotFound(normalizedPath, operation.oldString);
-    }
-    if (!operation.replaceAll && occurrences > 1) {
-      throw import_errors.FileSystemError.stringNotUnique(normalizedPath, operation.oldString, occurrences);
-    }
-    let backupPath;
-    if (options.backup ?? this.config.enableBackups) {
-      backupPath = await this.createBackup(normalizedPath);
-    }
-    try {
-      let newContent;
-      if (operation.replaceAll) {
-        newContent = originalContent.replace(
-          new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
-          operation.newString
-        );
-      } else {
-        newContent = originalContent.replace(operation.oldString, operation.newString);
-      }
-      await fs.writeFile(normalizedPath, newContent, options.encoding || DEFAULT_ENCODING);
-      this.logger.debug(`File edited: ${normalizedPath} (${occurrences} replacements)`);
-      return {
-        success: true,
-        path: normalizedPath,
-        changesCount: occurrences,
-        backupPath,
-        originalContent,
-        newContent
-      };
-    } catch (error) {
-      throw import_errors.FileSystemError.editFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Create a backup of a file
-   */
-  async createBackup(filePath) {
-    const backupDir = this.getBackupDir();
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const basename = path.basename(filePath);
-    const backupFilename = `${basename}.${timestamp}.backup`;
-    const backupPath = path.join(backupDir, backupFilename);
-    try {
-      await fs.mkdir(backupDir, { recursive: true });
-      await fs.copyFile(filePath, backupPath);
-      this.logger.debug(`Backup created: ${backupPath}`);
-      await this.cleanupOldBackups();
-      return backupPath;
-    } catch (error) {
-      throw import_errors.FileSystemError.backupFailed(
-        filePath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Clean up old backup files based on retention policy
-   */
-  async cleanupOldBackups() {
-    if (!this.config.enableBackups) {
-      return 0;
-    }
-    let backupDir;
-    try {
-      backupDir = this.getBackupDir();
-    } catch (error) {
-      this.logger.warn(
-        `Failed to resolve backup directory: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return 0;
-    }
-    try {
-      await fs.access(backupDir);
-    } catch {
-      return 0;
-    }
-    const cutoffDate = new Date(
-      Date.now() - this.config.backupRetentionDays * 24 * 60 * 60 * 1e3
-    );
-    let deletedCount = 0;
-    try {
-      const files = await fs.readdir(backupDir);
-      const backupFiles = files.filter((file) => file.endsWith(".backup"));
-      for (const file of backupFiles) {
-        const filePath = path.join(backupDir, file);
-        try {
-          const stats = await fs.stat(filePath);
-          if (stats.mtime < cutoffDate) {
-            await fs.unlink(filePath);
-            deletedCount++;
-            this.logger.debug(`Cleaned up old backup: ${file}`);
-          }
-        } catch (error) {
-          this.logger.warn(
-            `Failed to process backup file ${file}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      if (deletedCount > 0) {
-        this.logger.info(`Backup cleanup: removed ${deletedCount} old backup files`);
-      }
-      return deletedCount;
-    } catch (error) {
-      this.logger.warn(
-        `Failed to cleanup backup directory: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return 0;
-    }
-  }
-  /**
-   * Get service configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Check if a path is allowed (async for non-blocking symlink resolution)
-   */
-  async isPathAllowed(filePath) {
-    const validation = await this.pathValidator.validatePath(filePath);
-    return validation.isValid;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FileSystemService
-});

package/dist/filesystem/filesystem-service.d.ts

@@ -1,97 +0,0 @@
-/**
- * FileSystem Service
- *
- * Secure file system operations for Dexto internal tools
- */
-import { FileSystemConfig, FileContent, ReadFileOptions, GlobOptions, GlobResult, GrepOptions, SearchResult, WriteFileOptions, WriteResult, EditFileOptions, EditResult, EditOperation } from './types.js';
-import { type DirectoryApprovalChecker } from './path-validator.js';
-import type { IDextoLogger } from '../logger/v2/types.js';
-/**
- * FileSystemService - Handles all file system operations with security checks
- * TODO: Add tests for this class
- * TODO: instantiate only when internal file tools are enabled to avoid file dependencies which won't work in serverless
- */
-export declare class FileSystemService {
-    private config;
-    private pathValidator;
-    private initialized;
-    private logger;
-    constructor(config: Partial<FileSystemConfig> | undefined, logger: IDextoLogger);
-    /**
-     * Get backup directory path (context-aware with optional override)
-     * TODO: Migrate to explicit configuration via CLI enrichment layer (per-agent paths)
-     */
-    private getBackupDir;
-    /**
-     * Initialize the service
-     */
-    initialize(): Promise<void>;
-    /**
-     * Check if a file path is within the configured allowed paths.
-     * This is a public method for external consumers (like ToolManager) to check
-     * if a path requires directory approval before file operations.
-     *
-     * @param filePath The file path to check (can be relative or absolute)
-     * @returns true if the path is within allowed paths, false otherwise
-     */
-    isPathWithinAllowed(filePath: string): Promise<boolean>;
-    /**
-     * Get the list of configured allowed paths.
-     * Useful for displaying to users when directory approval is needed.
-     *
-     * @returns Array of allowed path strings
-     */
-    getAllowedPaths(): string[];
-    /**
-     * Get the parent directory of a file path (resolved to absolute).
-     * Useful for directory approval requests.
-     *
-     * @param filePath The file path
-     * @returns The absolute parent directory path
-     */
-    getParentDirectory(filePath: string): string;
-    /**
-     * Set a callback to check if a path is in an approved directory.
-     * This allows PathValidator to consult ApprovalManager without a direct dependency.
-     *
-     * @param checker Function that returns true if path is in an approved directory
-     */
-    setDirectoryApprovalChecker(checker: DirectoryApprovalChecker): void;
-    /**
-     * Read a file with validation and size limits
-     */
-    readFile(filePath: string, options?: ReadFileOptions): Promise<FileContent>;
-    /**
-     * Find files matching a glob pattern
-     */
-    globFiles(pattern: string, options?: GlobOptions): Promise<GlobResult>;
-    /**
-     * Search for content in files (grep-like functionality)
-     */
-    searchContent(pattern: string, options?: GrepOptions): Promise<SearchResult>;
-    /**
-     * Write content to a file
-     */
-    writeFile(filePath: string, content: string, options?: WriteFileOptions): Promise<WriteResult>;
-    /**
-     * Edit a file by replacing text
-     */
-    editFile(filePath: string, operation: EditOperation, options?: EditFileOptions): Promise<EditResult>;
-    /**
-     * Create a backup of a file
-     */
-    private createBackup;
-    /**
-     * Clean up old backup files based on retention policy
-     */
-    cleanupOldBackups(): Promise<number>;
-    /**
-     * Get service configuration
-     */
-    getConfig(): Readonly<FileSystemConfig>;
-    /**
-     * Check if a path is allowed (async for non-blocking symlink resolution)
-     */
-    isPathAllowed(filePath: string): Promise<boolean>;
-}
-//# sourceMappingURL=filesystem-service.d.ts.map

package/dist/filesystem/filesystem-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filesystem-service.d.ts","sourceRoot":"","sources":["../../src/filesystem/filesystem-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EACH,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EAEZ,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,aAAa,EAGhB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAiB,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAQ1D;;;;GAIG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,YAAK,EAAE,MAAM,EAAE,YAAY;IAiBxE;;;OAGG;IACH,OAAO,CAAC,YAAY;IAKpB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBjC;;;;;;;OAOG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;;;;OAKG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;;;;;OAMG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI5C;;;;;OAKG;IACH,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAIpE;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,WAAW,CAAC;IA+ErF;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAwEhF;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAqGtF;;OAEG;IACG,SAAS,CACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC/B,OAAO,CAAC,WAAW,CAAC;IA0DvB;;OAEG;IACG,QAAQ,CACV,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,aAAa,EACxB,OAAO,GAAE,eAAoB,GAC9B,OAAO,CAAC,UAAU,CAAC;IAuEtB;;OAEG;YACW,YAAY;IA0B1B;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IA6D1C;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,gBAAgB,CAAC;IAIvC;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAI1D"}