@dexto/core 1.1.11 → 1.2.0

package/dist/filesystem/filesystem-service.js

@@ -0,0 +1,449 @@
+import "../chunk-C6A6W6XS.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { glob } from "glob";
+import { PathValidator } from "./path-validator.js";
+import { FileSystemError } from "./errors.js";
+import { logger } from "../logger/index.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;
+  constructor(config = {}) {
+    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 ?? true,
+      backupPath: config.backupPath || ".dexto/backups",
+      backupRetentionDays: config.backupRetentionDays || 7,
+      workingDirectory: config.workingDirectory
+    };
+    this.pathValidator = new PathValidator(this.config);
+  }
+  /**
+   * Initialize the service
+   */
+  async initialize() {
+    if (this.initialized) {
+      logger.debug("FileSystemService already initialized");
+      return;
+    }
+    if (this.config.enableBackups) {
+      try {
+        const backupDir = path.resolve(
+          this.config.workingDirectory || process.cwd(),
+          this.config.backupPath
+        );
+        await fs.mkdir(backupDir, { recursive: true });
+        logger.debug(`Backup directory created/verified: ${backupDir}`);
+      } catch (error) {
+        logger.warn(
+          `Failed to create backup directory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    this.initialized = true;
+    logger.info("FileSystemService initialized successfully");
+  }
+  /**
+   * Read a file with validation and size limits
+   */
+  async readFile(filePath, options = {}) {
+    if (!this.initialized) {
+      throw FileSystemError.notInitialized();
+    }
+    const validation = this.pathValidator.validatePath(filePath);
+    if (!validation.isValid || !validation.normalizedPath) {
+      throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
+    }
+    const normalizedPath = validation.normalizedPath;
+    try {
+      const stats = await fs.stat(normalizedPath);
+      if (!stats.isFile()) {
+        throw FileSystemError.invalidPath(normalizedPath, "Path is not a file");
+      }
+      if (stats.size > this.config.maxFileSize) {
+        throw FileSystemError.fileTooLarge(
+          normalizedPath,
+          stats.size,
+          this.config.maxFileSize
+        );
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw FileSystemError.fileNotFound(normalizedPath);
+      }
+      if (error.code === "EACCES") {
+        throw FileSystemError.permissionDenied(normalizedPath, "read");
+      }
+      throw 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 FileSystemError.readFailed(
+        normalizedPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Find files matching a glob pattern
+   */
+  async globFiles(pattern, options = {}) {
+    if (!this.initialized) {
+      throw FileSystemError.notInitialized();
+    }
+    const cwd = options.cwd || this.config.workingDirectory || process.cwd();
+    const maxResults = options.maxResults || DEFAULT_MAX_RESULTS;
+    try {
+      const files = await glob(pattern, {
+        cwd,
+        absolute: true,
+        nodir: true,
+        // Only files
+        follow: false
+        // Don't follow symlinks
+      });
+      const validFiles = [];
+      for (const file of files) {
+        const validation = this.pathValidator.validatePath(file);
+        if (!validation.isValid || !validation.normalizedPath) {
+          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) {
+            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 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 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) {
+          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 FileSystemError.invalidPattern(pattern, "Invalid regular expression syntax");
+      }
+      throw FileSystemError.searchFailed(
+        pattern,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Write content to a file
+   */
+  async writeFile(filePath, content, options = {}) {
+    if (!this.initialized) {
+      throw FileSystemError.notInitialized();
+    }
+    const validation = this.pathValidator.validatePath(filePath);
+    if (!validation.isValid || !validation.normalizedPath) {
+      throw 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);
+      logger.debug(`File written: ${normalizedPath} (${bytesWritten} bytes)`);
+      return {
+        success: true,
+        path: normalizedPath,
+        bytesWritten,
+        backupPath
+      };
+    } catch (error) {
+      throw 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 FileSystemError.notInitialized();
+    }
+    const validation = this.pathValidator.validatePath(filePath);
+    if (!validation.isValid || !validation.normalizedPath) {
+      throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
+    }
+    const normalizedPath = validation.normalizedPath;
+    const fileContent = await this.readFile(normalizedPath);
+    let content = fileContent.content;
+    const occurrences = (content.match(
+      new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")
+    ) || []).length;
+    if (occurrences === 0) {
+      throw FileSystemError.stringNotFound(normalizedPath, operation.oldString);
+    }
+    if (!operation.replaceAll && occurrences > 1) {
+      throw FileSystemError.stringNotUnique(normalizedPath, operation.oldString, occurrences);
+    }
+    let backupPath;
+    if (options.backup ?? this.config.enableBackups) {
+      backupPath = await this.createBackup(normalizedPath);
+    }
+    try {
+      if (operation.replaceAll) {
+        content = content.replace(
+          new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+          operation.newString
+        );
+      } else {
+        content = content.replace(operation.oldString, operation.newString);
+      }
+      await fs.writeFile(normalizedPath, content, options.encoding || DEFAULT_ENCODING);
+      logger.debug(`File edited: ${normalizedPath} (${occurrences} replacements)`);
+      return {
+        success: true,
+        path: normalizedPath,
+        changesCount: occurrences,
+        backupPath
+      };
+    } catch (error) {
+      throw FileSystemError.editFailed(
+        normalizedPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Create a backup of a file
+   */
+  async createBackup(filePath) {
+    const backupDir = path.resolve(
+      this.config.workingDirectory || process.cwd(),
+      this.config.backupPath
+    );
+    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);
+      logger.debug(`Backup created: ${backupPath}`);
+      await this.cleanupOldBackups();
+      return backupPath;
+    } catch (error) {
+      throw 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;
+    }
+    const backupDir = path.resolve(
+      this.config.workingDirectory || process.cwd(),
+      this.config.backupPath
+    );
+    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++;
+            logger.debug(`Cleaned up old backup: ${file}`);
+          }
+        } catch (error) {
+          logger.warn(
+            `Failed to process backup file ${file}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      if (deletedCount > 0) {
+        logger.info(`Backup cleanup: removed ${deletedCount} old backup files`);
+      }
+      return deletedCount;
+    } catch (error) {
+      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
+   */
+  isPathAllowed(filePath) {
+    const validation = this.pathValidator.validatePath(filePath);
+    return validation.isValid;
+  }
+}
+export {
+  FileSystemService
+};

package/dist/filesystem/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filesystem_exports = {};
+__export(filesystem_exports, {
+  FileSystemError: () => import_errors.FileSystemError,
+  FileSystemErrorCode: () => import_error_codes.FileSystemErrorCode,
+  FileSystemService: () => import_filesystem_service.FileSystemService,
+  PathValidator: () => import_path_validator.PathValidator
+});
+module.exports = __toCommonJS(filesystem_exports);
+var import_filesystem_service = require("./filesystem-service.js");
+var import_path_validator = require("./path-validator.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSystemError,
+  FileSystemErrorCode,
+  FileSystemService,
+  PathValidator
+});

package/dist/filesystem/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * FileSystem Module
+ *
+ * Exports file system service, types, errors, and utilities
+ */
+export { FileSystemService } from './filesystem-service.js';
+export { PathValidator } from './path-validator.js';
+export { FileSystemError } from './errors.js';
+export { FileSystemErrorCode } from './error-codes.js';
+export type { FileSystemConfig, FileContent, ReadFileOptions, GlobOptions, GlobResult, GrepOptions, SearchResult, SearchMatch, WriteFileOptions, WriteResult, EditFileOptions, EditResult, EditOperation, FileMetadata, PathValidation, BufferEncoding, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/filesystem/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,YAAY,EACR,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,GACjB,MAAM,YAAY,CAAC"}

package/dist/filesystem/index.js

@@ -0,0 +1,11 @@
+import "../chunk-C6A6W6XS.js";
+import { FileSystemService } from "./filesystem-service.js";
+import { PathValidator } from "./path-validator.js";
+import { FileSystemError } from "./errors.js";
+import { FileSystemErrorCode } from "./error-codes.js";
+export {
+  FileSystemError,
+  FileSystemErrorCode,
+  FileSystemService,
+  PathValidator
+};

package/dist/filesystem/path-validator.cjs

@@ -0,0 +1,172 @@
+"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 path_validator_exports = {};
+__export(path_validator_exports, {
+  PathValidator: () => PathValidator
+});
+module.exports = __toCommonJS(path_validator_exports);
+var path = __toESM(require("node:path"), 1);
+var import_node_fs = require("node:fs");
+var import_logger = require("../logger/index.js");
+class PathValidator {
+  config;
+  normalizedAllowedPaths;
+  normalizedBlockedPaths;
+  normalizedBlockedExtensions;
+  constructor(config) {
+    this.config = config;
+    const workingDir = config.workingDirectory || process.cwd();
+    this.normalizedAllowedPaths = config.allowedPaths.map((p) => path.resolve(workingDir, p));
+    this.normalizedBlockedPaths = config.blockedPaths.map((p) => path.normalize(p));
+    this.normalizedBlockedExtensions = (config.blockedExtensions || []).map((ext) => {
+      const e = ext.startsWith(".") ? ext : `.${ext}`;
+      return e.toLowerCase();
+    });
+    import_logger.logger.debug(
+      `PathValidator initialized with ${this.normalizedAllowedPaths.length} allowed paths`
+    );
+  }
+  /**
+   * Validate a file path for security and policy compliance
+   */
+  validatePath(filePath) {
+    if (!filePath || filePath.trim() === "") {
+      return {
+        isValid: false,
+        error: "Path cannot be empty"
+      };
+    }
+    const workingDir = this.config.workingDirectory || process.cwd();
+    let normalizedPath;
+    try {
+      normalizedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(workingDir, filePath);
+      try {
+        normalizedPath = import_node_fs.realpathSync.native(normalizedPath);
+      } catch {
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `Failed to normalize path: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    if (this.hasPathTraversal(filePath, normalizedPath)) {
+      return {
+        isValid: false,
+        error: "Path traversal detected"
+      };
+    }
+    if (!this.isPathAllowed(normalizedPath)) {
+      return {
+        isValid: false,
+        error: `Path is not within allowed paths. Allowed: ${this.normalizedAllowedPaths.join(", ")}`
+      };
+    }
+    const blockedReason = this.isPathBlocked(normalizedPath);
+    if (blockedReason) {
+      return {
+        isValid: false,
+        error: `Path is blocked: ${blockedReason}`
+      };
+    }
+    const ext = path.extname(normalizedPath).toLowerCase();
+    if (ext && this.normalizedBlockedExtensions.includes(ext)) {
+      return {
+        isValid: false,
+        error: `File extension ${ext} is not allowed`
+      };
+    }
+    return {
+      isValid: true,
+      normalizedPath
+    };
+  }
+  /**
+   * Check if path contains traversal attempts
+   */
+  hasPathTraversal(originalPath, normalizedPath) {
+    if (originalPath.includes("../") || originalPath.includes("..\\")) {
+      const workingDir = this.config.workingDirectory || process.cwd();
+      const relative = path.relative(workingDir, normalizedPath);
+      if (relative.startsWith("..")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if path is within allowed paths (whitelist check)
+   */
+  isPathAllowed(normalizedPath) {
+    if (this.normalizedAllowedPaths.length === 0) {
+      return true;
+    }
+    return this.normalizedAllowedPaths.some((allowedPath) => {
+      const relative = path.relative(allowedPath, normalizedPath);
+      return !relative.startsWith("..") && !path.isAbsolute(relative);
+    });
+  }
+  /**
+   * Check if path matches blocked patterns (blacklist check)
+   */
+  isPathBlocked(normalizedPath) {
+    const roots = this.normalizedAllowedPaths.length > 0 ? this.normalizedAllowedPaths : [this.config.workingDirectory || process.cwd()];
+    for (const blocked of this.normalizedBlockedPaths) {
+      for (const root of roots) {
+        const blockedFull = path.isAbsolute(blocked) ? path.normalize(blocked) : path.resolve(root, blocked);
+        if (normalizedPath === blockedFull || normalizedPath.startsWith(blockedFull + path.sep)) {
+          return `Within blocked directory: ${blocked}`;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Quick check if a path is allowed (for internal use)
+   */
+  isPathAllowedQuick(normalizedPath) {
+    return this.isPathAllowed(normalizedPath) && !this.isPathBlocked(normalizedPath);
+  }
+  /**
+   * Get normalized allowed paths
+   */
+  getAllowedPaths() {
+    return [...this.normalizedAllowedPaths];
+  }
+  /**
+   * Get blocked paths
+   */
+  getBlockedPaths() {
+    return [...this.normalizedBlockedPaths];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PathValidator
+});