@dexto/tools-filesystem 1.7.1 → 1.8.0

package/dist/grep-content-tool.js

@@ -1,7 +1,14 @@
 import { z } from "zod";
-import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
+import safeRegex from "safe-regex";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core/tools";
 import { createDirectoryAccessApprovalHandlers } from "./directory-approval.js";
 import { resolveUserPath } from "./path-utils.js";
+import { FileSystemError } from "./errors.js";
+import {
+  assertWorkspaceRelativeGlob,
+  isWorkspaceFileNotFound,
+  toWorkspaceRelativePath
+} from "./workspace-paths.js";
 const GrepContentInputSchema = z.object({
   pattern: z.string().describe("Regular expression pattern to search for"),
   path: z.string().optional().describe("Directory to search in (defaults to working directory)"),
@@ -42,7 +49,6 @@ function createGrepContentTool(getFileSystemService) {
       }
     }),
     async execute(input, context) {
-      const resolvedFileSystemService = await getFileSystemService(context);
       const {
         pattern,
         path: searchPath,
@@ -51,49 +57,122 @@ function createGrepContentTool(getFileSystemService) {
         case_insensitive,
         max_results
       } = input;
-      const baseDir = resolvedFileSystemService.getWorkingDirectory();
-      const resolvedSearchPath = resolveUserPath(baseDir, searchPath || ".");
-      const result = await resolvedFileSystemService.searchContent(pattern, {
-        path: resolvedSearchPath,
-        glob,
-        contextLines: context_lines,
-        caseInsensitive: case_insensitive,
-        maxResults: max_results
-      });
-      const _display = {
-        type: "search",
-        pattern,
-        matches: result.matches.map((match) => ({
-          file: match.file,
-          line: match.lineNumber,
-          content: match.line,
-          ...match.context && {
-            context: [...match.context.before, ...match.context.after]
-          }
-        })),
-        totalMatches: result.totalMatches,
-        truncated: result.truncated
-      };
-      return {
-        matches: result.matches.map((match) => ({
-          file: match.file,
-          line_number: match.lineNumber,
-          line: match.line,
-          ...match.context && {
-            context: {
-              before: match.context.before,
-              after: match.context.after
-            }
+      if (!context.services) {
+        throw new Error("grep_content requires ToolExecutionContext.services");
+      }
+      if (!safeRegex(pattern)) {
+        throw FileSystemError.invalidPattern(
+          pattern,
+          "Pattern may cause catastrophic backtracking (ReDoS). Please simplify the regex."
+        );
+      }
+      const handle = await context.services.workspaceManager.open({ intent: "read" });
+      const regex = createRegex(pattern, case_insensitive);
+      const files = await findSearchFiles(
+        handle.files,
+        handle.context.path,
+        searchPath,
+        glob
+      );
+      const matches = [];
+      let filesSearched = 0;
+      for (const file of files) {
+        let content;
+        try {
+          content = await handle.files.readText(file);
+        } catch (error) {
+          context.logger.debug(
+            `Skipping file ${file}: ${error instanceof Error ? error.message : String(error)}`
+          );
+          continue;
+        }
+        filesSearched += 1;
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index += 1) {
+          const line = lines[index] ?? "";
+          regex.lastIndex = 0;
+          if (!regex.test(line)) continue;
+          const matchContext = context_lines > 0 ? collectContext(lines, index, context_lines) : void 0;
+          matches.push({
+            file,
+            lineNumber: index + 1,
+            line,
+            ...matchContext !== void 0 && { context: matchContext }
+          });
+          if (matches.length >= max_results) {
+            return formatSearchResult(pattern, matches, filesSearched, true);
           }
-        })),
-        total_matches: result.totalMatches,
-        files_searched: result.filesSearched,
-        truncated: result.truncated,
-        _display
-      };
+        }
+      }
+      return formatSearchResult(pattern, matches, filesSearched, false);
     }
   });
 }
+function createRegex(pattern, caseInsensitive) {
+  try {
+    return new RegExp(pattern, caseInsensitive ? "i" : "");
+  } catch {
+    throw FileSystemError.invalidPattern(pattern, "Invalid regular expression syntax");
+  }
+}
+async function findSearchFiles(files, workspaceRoot, searchPath, globPattern) {
+  const workspacePath = toWorkspaceRelativePath("grep_content", workspaceRoot, searchPath || ".");
+  if (searchPath && !globPattern) {
+    try {
+      await files.readText(workspacePath);
+      return [workspacePath];
+    } catch (error) {
+      if (!isWorkspaceFileNotFound(error)) {
+        throw error;
+      }
+    }
+  }
+  const pattern = globPattern ?? "**/*";
+  assertWorkspaceRelativeGlob("grep_content", pattern);
+  if (workspacePath === "." || workspacePath === "") {
+    return files.glob(pattern);
+  }
+  return files.glob(`${workspacePath.replace(/\/$/, "")}/${pattern}`);
+}
+function collectContext(lines, matchIndex, contextLines) {
+  return {
+    before: lines.slice(Math.max(0, matchIndex - contextLines), matchIndex),
+    after: lines.slice(matchIndex + 1, matchIndex + contextLines + 1)
+  };
+}
+function formatSearchResult(pattern, matches, filesSearched, truncated) {
+  const _display = {
+    type: "search",
+    pattern,
+    matches: matches.map((match) => ({
+      file: match.file,
+      line: match.lineNumber,
+      content: match.line,
+      ...match.context && {
+        context: [...match.context.before, ...match.context.after]
+      }
+    })),
+    totalMatches: matches.length,
+    truncated
+  };
+  return {
+    matches: matches.map((match) => ({
+      file: match.file,
+      line_number: match.lineNumber,
+      line: match.line,
+      ...match.context && {
+        context: {
+          before: match.context.before,
+          after: match.context.after
+        }
+      }
+    })),
+    total_matches: matches.length,
+    files_searched: filesSearched,
+    truncated,
+    _display
+  };
+}
 export {
   createGrepContentTool
 };

package/dist/grep-content-tool.test.cjs

@@ -1,31 +1,7 @@
 "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 __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 import_vitest = require("vitest");
-var path = __toESM(require("node:path"), 1);
-var fs = __toESM(require("node:fs/promises"), 1);
-var os = __toESM(require("node:os"), 1);
-var import_filesystem_service = require("./filesystem-service.js");
+var import_core = require("@dexto/core");
+var import_workspace = require("@dexto/core/workspace");
 var import_grep_content_tool = require("./grep-content-tool.js");
 const createMockLogger = () => {
   const logger = {
@@ -44,72 +20,131 @@ const createMockLogger = () => {
   };
   return logger;
 };
-function createToolContext(logger) {
-  return { logger };
+function createToolContext(logger, filesByPath, glob = import_vitest.vi.fn(async () => Object.keys(filesByPath))) {
+  const workspaceManager = {
+    open: import_vitest.vi.fn(async () => ({
+      context: {
+        id: "test-workspace",
+        path: "/repo",
+        createdAt: Date.now(),
+        lastActiveAt: Date.now()
+      },
+      capabilities: ["files"],
+      files: {
+        readFile: async (filePath) => readTestFile(filesByPath, filePath),
+        readText: async (filePath) => readTestFile(filesByPath, filePath),
+        glob,
+        writeFile: import_vitest.vi.fn(async () => void 0),
+        listFiles: import_vitest.vi.fn(async () => [])
+      }
+    }))
+  };
+  return {
+    logger,
+    services: {
+      approval: {},
+      search: {},
+      resources: {},
+      prompts: {},
+      skills: {},
+      mcp: {},
+      taskForker: null,
+      workspaceManager
+    }
+  };
+}
+function readTestFile(filesByPath, filePath) {
+  const content = filesByPath[filePath];
+  if (content === void 0) {
+    throw import_workspace.WorkspaceError.fileNotFound(filePath);
+  }
+  return content;
 }
 (0, import_vitest.describe)("grep_content tool", () => {
-  let mockLogger;
-  let tempDir;
-  let fileSystemService;
-  (0, import_vitest.beforeEach)(async () => {
-    mockLogger = createMockLogger();
-    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-grep-test-"));
-    tempDir = await fs.realpath(rawTempDir);
-    fileSystemService = new import_filesystem_service.FileSystemService(
+  (0, import_vitest.it)("searches content through WorkspaceManager.open without FileSystemService execution", async () => {
+    const mockLogger = createMockLogger();
+    const getFileSystemService = import_vitest.vi.fn(async () => {
+      throw new Error("grep_content execute must not use FileSystemService");
+    });
+    const glob = import_vitest.vi.fn(async () => ["src/notes.txt"]);
+    const tool = (0, import_grep_content_tool.createGrepContentTool)(getFileSystemService);
+    const parsedInput = tool.inputSchema.parse({
+      pattern: "needle",
+      path: "src",
+      glob: "**/*.txt",
+      context_lines: 1
+    });
+    const result = await tool.execute(
+      parsedInput,
+      createToolContext(mockLogger, { "src/notes.txt": "alpha\nneedle\nomega\n" }, glob)
+    );
+    (0, import_vitest.expect)(getFileSystemService).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(glob).toHaveBeenCalledWith("src/**/*.txt");
+    (0, import_vitest.expect)(result.files_searched).toBe(1);
+    (0, import_vitest.expect)(result.matches).toEqual([
       {
-        allowedPaths: [tempDir],
-        blockedPaths: [],
-        blockedExtensions: [],
-        maxFileSize: 10 * 1024 * 1024,
-        workingDirectory: tempDir,
-        enableBackups: false,
-        backupRetentionDays: 7
-      },
-      mockLogger
+        file: "src/notes.txt",
+        line_number: 2,
+        line: "needle",
+        context: {
+          before: ["alpha"],
+          after: ["omega"]
+        }
+      }
+    ]);
+  });
+  (0, import_vitest.it)("normalizes workspace-contained absolute search paths before globbing", async () => {
+    const mockLogger = createMockLogger();
+    const glob = import_vitest.vi.fn(async () => ["src/notes.txt"]);
+    const tool = (0, import_grep_content_tool.createGrepContentTool)(import_vitest.vi.fn());
+    await tool.execute(
+      tool.inputSchema.parse({
+        pattern: "needle",
+        path: "/repo/src",
+        glob: "**/*.txt"
+      }),
+      createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
     );
-    await fileSystemService.initialize();
+    (0, import_vitest.expect)(glob).toHaveBeenCalledWith("src/**/*.txt");
   });
-  (0, import_vitest.afterEach)(async () => {
-    import_vitest.vi.restoreAllMocks();
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch {
-    }
+  (0, import_vitest.it)("rejects external absolute search paths before file provider calls", async () => {
+    const mockLogger = createMockLogger();
+    const glob = import_vitest.vi.fn(async () => ["src/notes.txt"]);
+    const tool = (0, import_grep_content_tool.createGrepContentTool)(import_vitest.vi.fn());
+    await (0, import_vitest.expect)(
+      tool.execute(
+        tool.inputSchema.parse({
+          pattern: "needle",
+          path: "/outside/src",
+          glob: "**/*.txt"
+        }),
+        createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
+      )
+    ).rejects.toMatchObject({ code: import_core.ToolErrorCode.VALIDATION_FAILED });
+    (0, import_vitest.expect)(glob).not.toHaveBeenCalled();
   });
-  (0, import_vitest.it)("expands home-directory shorthand for search paths", async () => {
-    const homeTempDir = await fs.mkdtemp(path.join(os.homedir(), ".dexto-grep-home-test-"));
-    const fileSystemServiceForHome = new import_filesystem_service.FileSystemService(
-      {
-        allowedPaths: [homeTempDir],
-        blockedPaths: [],
-        blockedExtensions: [],
-        maxFileSize: 10 * 1024 * 1024,
-        workingDirectory: tempDir,
-        enableBackups: false,
-        backupRetentionDays: 7
-      },
-      mockLogger
-    );
-    await fileSystemServiceForHome.initialize();
-    try {
-      const filePath = path.join(homeTempDir, "notes.txt");
-      await fs.writeFile(filePath, "alpha\nneedle\nomega\n");
-      const tool = (0, import_grep_content_tool.createGrepContentTool)(async () => fileSystemServiceForHome);
-      const parsedInput = tool.inputSchema.parse({
-        pattern: "needle",
-        path: `~/${path.basename(homeTempDir)}`
-      });
-      const result = await tool.execute(parsedInput, createToolContext(mockLogger));
-      (0, import_vitest.expect)(result.files_searched).toBe(1);
-      (0, import_vitest.expect)(result.matches).toEqual([
-        {
-          file: filePath,
-          line_number: 2,
-          line: "needle"
-        }
-      ]);
-    } finally {
-      await fs.rm(homeTempDir, { recursive: true, force: true });
-    }
+  (0, import_vitest.it)("rejects absolute and escaping glob filters before file provider calls", async () => {
+    const mockLogger = createMockLogger();
+    const glob = import_vitest.vi.fn(async () => ["src/notes.txt"]);
+    const tool = (0, import_grep_content_tool.createGrepContentTool)(import_vitest.vi.fn());
+    await (0, import_vitest.expect)(
+      tool.execute(
+        tool.inputSchema.parse({
+          pattern: "needle",
+          glob: "/outside/**/*.txt"
+        }),
+        createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
+      )
+    ).rejects.toMatchObject({ code: import_core.ToolErrorCode.VALIDATION_FAILED });
+    await (0, import_vitest.expect)(
+      tool.execute(
+        tool.inputSchema.parse({
+          pattern: "needle",
+          glob: "../**/*.txt"
+        }),
+        createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
+      )
+    ).rejects.toMatchObject({ code: import_core.ToolErrorCode.VALIDATION_FAILED });
+    (0, import_vitest.expect)(glob).not.toHaveBeenCalled();
   });
 });

package/dist/grep-content-tool.test.js

@@ -1,8 +1,6 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import { FileSystemService } from "./filesystem-service.js";
+import { describe, it, expect, vi } from "vitest";
+import { ToolErrorCode } from "@dexto/core";
+import { WorkspaceError } from "@dexto/core/workspace";
 import { createGrepContentTool } from "./grep-content-tool.js";
 const createMockLogger = () => {
   const logger = {
@@ -21,72 +19,131 @@ const createMockLogger = () => {
   };
   return logger;
 };
-function createToolContext(logger) {
-  return { logger };
+function createToolContext(logger, filesByPath, glob = vi.fn(async () => Object.keys(filesByPath))) {
+  const workspaceManager = {
+    open: vi.fn(async () => ({
+      context: {
+        id: "test-workspace",
+        path: "/repo",
+        createdAt: Date.now(),
+        lastActiveAt: Date.now()
+      },
+      capabilities: ["files"],
+      files: {
+        readFile: async (filePath) => readTestFile(filesByPath, filePath),
+        readText: async (filePath) => readTestFile(filesByPath, filePath),
+        glob,
+        writeFile: vi.fn(async () => void 0),
+        listFiles: vi.fn(async () => [])
+      }
+    }))
+  };
+  return {
+    logger,
+    services: {
+      approval: {},
+      search: {},
+      resources: {},
+      prompts: {},
+      skills: {},
+      mcp: {},
+      taskForker: null,
+      workspaceManager
+    }
+  };
+}
+function readTestFile(filesByPath, filePath) {
+  const content = filesByPath[filePath];
+  if (content === void 0) {
+    throw WorkspaceError.fileNotFound(filePath);
+  }
+  return content;
 }
 describe("grep_content tool", () => {
-  let mockLogger;
-  let tempDir;
-  let fileSystemService;
-  beforeEach(async () => {
-    mockLogger = createMockLogger();
-    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-grep-test-"));
-    tempDir = await fs.realpath(rawTempDir);
-    fileSystemService = new FileSystemService(
+  it("searches content through WorkspaceManager.open without FileSystemService execution", async () => {
+    const mockLogger = createMockLogger();
+    const getFileSystemService = vi.fn(async () => {
+      throw new Error("grep_content execute must not use FileSystemService");
+    });
+    const glob = vi.fn(async () => ["src/notes.txt"]);
+    const tool = createGrepContentTool(getFileSystemService);
+    const parsedInput = tool.inputSchema.parse({
+      pattern: "needle",
+      path: "src",
+      glob: "**/*.txt",
+      context_lines: 1
+    });
+    const result = await tool.execute(
+      parsedInput,
+      createToolContext(mockLogger, { "src/notes.txt": "alpha\nneedle\nomega\n" }, glob)
+    );
+    expect(getFileSystemService).not.toHaveBeenCalled();
+    expect(glob).toHaveBeenCalledWith("src/**/*.txt");
+    expect(result.files_searched).toBe(1);
+    expect(result.matches).toEqual([
       {
-        allowedPaths: [tempDir],
-        blockedPaths: [],
-        blockedExtensions: [],
-        maxFileSize: 10 * 1024 * 1024,
-        workingDirectory: tempDir,
-        enableBackups: false,
-        backupRetentionDays: 7
-      },
-      mockLogger
+        file: "src/notes.txt",
+        line_number: 2,
+        line: "needle",
+        context: {
+          before: ["alpha"],
+          after: ["omega"]
+        }
+      }
+    ]);
+  });
+  it("normalizes workspace-contained absolute search paths before globbing", async () => {
+    const mockLogger = createMockLogger();
+    const glob = vi.fn(async () => ["src/notes.txt"]);
+    const tool = createGrepContentTool(vi.fn());
+    await tool.execute(
+      tool.inputSchema.parse({
+        pattern: "needle",
+        path: "/repo/src",
+        glob: "**/*.txt"
+      }),
+      createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
     );
-    await fileSystemService.initialize();
+    expect(glob).toHaveBeenCalledWith("src/**/*.txt");
   });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch {
-    }
+  it("rejects external absolute search paths before file provider calls", async () => {
+    const mockLogger = createMockLogger();
+    const glob = vi.fn(async () => ["src/notes.txt"]);
+    const tool = createGrepContentTool(vi.fn());
+    await expect(
+      tool.execute(
+        tool.inputSchema.parse({
+          pattern: "needle",
+          path: "/outside/src",
+          glob: "**/*.txt"
+        }),
+        createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
+      )
+    ).rejects.toMatchObject({ code: ToolErrorCode.VALIDATION_FAILED });
+    expect(glob).not.toHaveBeenCalled();
   });
-  it("expands home-directory shorthand for search paths", async () => {
-    const homeTempDir = await fs.mkdtemp(path.join(os.homedir(), ".dexto-grep-home-test-"));
-    const fileSystemServiceForHome = new FileSystemService(
-      {
-        allowedPaths: [homeTempDir],
-        blockedPaths: [],
-        blockedExtensions: [],
-        maxFileSize: 10 * 1024 * 1024,
-        workingDirectory: tempDir,
-        enableBackups: false,
-        backupRetentionDays: 7
-      },
-      mockLogger
-    );
-    await fileSystemServiceForHome.initialize();
-    try {
-      const filePath = path.join(homeTempDir, "notes.txt");
-      await fs.writeFile(filePath, "alpha\nneedle\nomega\n");
-      const tool = createGrepContentTool(async () => fileSystemServiceForHome);
-      const parsedInput = tool.inputSchema.parse({
-        pattern: "needle",
-        path: `~/${path.basename(homeTempDir)}`
-      });
-      const result = await tool.execute(parsedInput, createToolContext(mockLogger));
-      expect(result.files_searched).toBe(1);
-      expect(result.matches).toEqual([
-        {
-          file: filePath,
-          line_number: 2,
-          line: "needle"
-        }
-      ]);
-    } finally {
-      await fs.rm(homeTempDir, { recursive: true, force: true });
-    }
+  it("rejects absolute and escaping glob filters before file provider calls", async () => {
+    const mockLogger = createMockLogger();
+    const glob = vi.fn(async () => ["src/notes.txt"]);
+    const tool = createGrepContentTool(vi.fn());
+    await expect(
+      tool.execute(
+        tool.inputSchema.parse({
+          pattern: "needle",
+          glob: "/outside/**/*.txt"
+        }),
+        createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
+      )
+    ).rejects.toMatchObject({ code: ToolErrorCode.VALIDATION_FAILED });
+    await expect(
+      tool.execute(
+        tool.inputSchema.parse({
+          pattern: "needle",
+          glob: "../**/*.txt"
+        }),
+        createToolContext(mockLogger, { "src/notes.txt": "needle" }, glob)
+      )
+    ).rejects.toMatchObject({ code: ToolErrorCode.VALIDATION_FAILED });
+    expect(glob).not.toHaveBeenCalled();
   });
 });

package/dist/index.d.cts

@@ -1,6 +1,8 @@
 import { ToolFactory } from '@dexto/agent-config';
 import { z } from 'zod';
-import { Logger, ToolExecutionContext, DextoRuntimeError, Tool } from '@dexto/core';
+import { ToolExecutionContext, Tool } from '@dexto/core/tools';
+import { Logger } from '@dexto/core/logger';
+import { DextoRuntimeError } from '@dexto/core/errors';
 
 /**
  * FileSystem Tools Factory
@@ -219,8 +221,6 @@ interface SearchResult {
  * Options for writing files
  */
 interface WriteFileOptions {
-    /** Create parent directories if they don't exist */
-    createDirs?: boolean | undefined;
     /** File encoding (default: utf-8) */
     encoding?: BufferEncoding | undefined;
     /** Create backup before overwriting */
@@ -749,7 +749,6 @@ declare function createReadMediaFileTool(getFileSystemService: FileSystemService
 declare const WriteFileInputSchema: z.ZodObject<{
     file_path: z.ZodString;
     content: z.ZodString;
-    create_dirs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     encoding: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         ascii: "ascii";
         "utf-8": "utf-8";

package/dist/path-validator.d.ts

@@ -4,7 +4,7 @@
  * Security-focused path validation for file system operations
  */
 import { FileSystemConfig, PathValidation } from './types.js';
-import type { Logger } from '@dexto/core';
+import type { Logger } from '@dexto/core/logger';
 /**
  * Callback type for checking if a path is in an approved directory.
  * Used to consult ApprovalManager without creating a direct dependency.

package/dist/path-validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-validator.d.ts","sourceRoot":"","sources":["../src/path-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,2BAA2B,CAAW;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,wBAAwB,CAAuC;gBAE3D,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM;IA0BpD;;;;;OAKG;IACH,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAKpE;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAI7D;;;;;;;;;;;OAWG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YAIzD,oBAAoB;IA0FlC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAInD;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAyBzB;;;;;;;;;OASG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA+B7D;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;CAG9B"}
+{"version":3,"file":"path-validator.d.ts","sourceRoot":"","sources":["../src/path-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAGjD;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,2BAA2B,CAAW;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,wBAAwB,CAAuC;gBAE3D,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM;IA0BpD;;;;;OAKG;IACH,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAKpE;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAI7D;;;;;;;;;;;OAWG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YAIzD,oBAAoB;IA0FlC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAInD;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAyBzB;;;;;;;;;OASG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA+B7D;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;CAG9B"}