@prbe.ai/electron-sdk 0.1.3 → 0.1.5

package/dist/tools/filesystem.d.ts

@@ -1,63 +0,0 @@
-/**
- * tools/filesystem.ts — Built-in filesystem tools
- *
- * Implements: client_list_directory, client_read_file, client_search_content,
- *             client_find_files, client_flag_file
- *
- * Mirrors PRBEAgentTools.swift filesystem tool implementations.
- */
-import type { PRBEToolDeclaration, FlaggedFileIn } from "../models";
-import type { PRBEInteractionRequester } from "../interactions";
-import type { PRBETool } from "./index";
-export declare class ListDirectoryTool implements PRBETool {
-    private readonly autoApprovedDirs;
-    private readonly requester?;
-    private readonly grantedPaths?;
-    constructor(autoApprovedDirs: string[], requester?: PRBEInteractionRequester, grantedPaths?: Set<string>);
-    get declaration(): PRBEToolDeclaration;
-    execute(args: Record<string, unknown>): Promise<string>;
-    private static readonly MAX_ENTRIES;
-    private listDir;
-}
-export declare class ReadFileTool implements PRBETool {
-    private readonly autoApprovedDirs;
-    private readonly requester?;
-    private readonly grantedPaths?;
-    constructor(autoApprovedDirs: string[], requester?: PRBEInteractionRequester, grantedPaths?: Set<string>);
-    get declaration(): PRBEToolDeclaration;
-    execute(args: Record<string, unknown>): Promise<string>;
-}
-export declare class SearchContentTool implements PRBETool {
-    private readonly autoApprovedDirs;
-    private readonly requester?;
-    private readonly grantedPaths?;
-    constructor(autoApprovedDirs: string[], requester?: PRBEInteractionRequester, grantedPaths?: Set<string>);
-    get declaration(): PRBEToolDeclaration;
-    execute(args: Record<string, unknown>): Promise<string>;
-    private collectFiles;
-}
-export declare class FindFilesTool implements PRBETool {
-    private readonly autoApprovedDirs;
-    private readonly requester?;
-    private readonly grantedPaths?;
-    constructor(autoApprovedDirs: string[], requester?: PRBEInteractionRequester, grantedPaths?: Set<string>);
-    get declaration(): PRBEToolDeclaration;
-    execute(args: Record<string, unknown>): Promise<string>;
-    private walkAndMatch;
-    /**
-     * Simple glob matching: supports *, ?, and character classes [...].
-     * Converts glob to regex and tests against the filename.
-     */
-    private globMatch;
-}
-export declare class FlagFileTool implements PRBETool {
-    private readonly autoApprovedDirs;
-    private readonly onFlag;
-    private readonly requester?;
-    private readonly grantedPaths?;
-    private static readonly MAX_BINARY_SIZE;
-    constructor(autoApprovedDirs: string[], onFlag: (file: FlaggedFileIn) => void, requester?: PRBEInteractionRequester, grantedPaths?: Set<string>);
-    get declaration(): PRBEToolDeclaration;
-    execute(args: Record<string, unknown>): Promise<string>;
-}
-//# sourceMappingURL=filesystem.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/tools/filesystem.ts"],"names":[],"mappings":"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"}

package/dist/tools/filesystem.js

@@ -1,573 +0,0 @@
-"use strict";
-/**
- * tools/filesystem.ts — Built-in filesystem tools
- *
- * Implements: client_list_directory, client_read_file, client_search_content,
- *             client_find_files, client_flag_file
- *
- * Mirrors PRBEAgentTools.swift filesystem tool implementations.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlagFileTool = exports.FindFilesTool = exports.SearchContentTool = exports.ReadFileTool = exports.ListDirectoryTool = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const models_1 = require("../models");
-const index_1 = require("./index");
-/** Resolve a path using access request if available, else basic validation. Returns [resolved, error]. */
-async function resolvePath(pathStr, autoApprovedDirs, requester, grantedPaths) {
-    if (requester && grantedPaths) {
-        const result = await (0, index_1.resolveWithAccessRequest)(pathStr, autoApprovedDirs, grantedPaths, requester);
-        if (result && "error" in result)
-            return [null, result.error];
-        if (result && "path" in result)
-            return [result.path, null];
-    }
-    const resolved = (0, index_1.resolveAndValidate)(pathStr, autoApprovedDirs);
-    return [resolved, resolved ? null : "path is outside auto-approved directories"];
-}
-// ---------------------------------------------------------------------------
-// ListDirectoryTool
-// ---------------------------------------------------------------------------
-class ListDirectoryTool {
-    autoApprovedDirs;
-    requester;
-    grantedPaths;
-    constructor(autoApprovedDirs, requester, grantedPaths) {
-        this.autoApprovedDirs = autoApprovedDirs;
-        this.requester = requester;
-        this.grantedPaths = grantedPaths;
-    }
-    get declaration() {
-        return {
-            name: models_1.ToolName.CLIENT_LIST_DIRECTORY,
-            description: "List directory contents",
-            parameters: [
-                { name: "path", type: models_1.ToolParamType.STRING, description: "Directory path", required: true },
-                { name: "recursive", type: models_1.ToolParamType.BOOLEAN, description: "List recursively", required: false },
-                { name: "max_depth", type: models_1.ToolParamType.INTEGER, description: "Max depth (default 3)", required: false },
-            ],
-        };
-    }
-    async execute(args) {
-        const pathStr = args["path"];
-        if (!pathStr)
-            return "Error: 'path' parameter is required";
-        const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
-        if (!resolved)
-            return `Error: ${resolveErr}`;
-        try {
-            const stat = fs.statSync(resolved);
-            if (!stat.isDirectory())
-                return `Error: '${pathStr}' is not a directory`;
-        }
-        catch {
-            return `Error: '${pathStr}' does not exist or is not accessible`;
-        }
-        const recursive = args["recursive"] === true;
-        const maxDepth = typeof args["max_depth"] === "number" ? args["max_depth"] : 3;
-        const lines = [];
-        this.listDir(resolved, 0, recursive ? maxDepth : 1, lines);
-        if (lines.length >= ListDirectoryTool.MAX_ENTRIES) {
-            lines.push(`\n(truncated at ${ListDirectoryTool.MAX_ENTRIES} entries — use a more specific path)`);
-        }
-        return lines.join("\n") || "(empty directory)";
-    }
-    static MAX_ENTRIES = 1000;
-    listDir(dirPath, depth, maxDepth, lines) {
-        if (depth >= maxDepth)
-            return;
-        if (lines.length >= ListDirectoryTool.MAX_ENTRIES)
-            return;
-        const indent = "  ".repeat(depth);
-        let entries;
-        try {
-            entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        }
-        catch {
-            lines.push(`${indent}(access denied)`);
-            return;
-        }
-        // Sort entries alphabetically, skip hidden files
-        const sorted = entries
-            .filter((e) => !e.name.startsWith("."))
-            .sort((a, b) => a.name.localeCompare(b.name));
-        for (const entry of sorted) {
-            const fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory()) {
-                lines.push(`${indent}${entry.name}/`);
-                this.listDir(fullPath, depth + 1, maxDepth, lines);
-            }
-            else {
-                try {
-                    const stat = fs.statSync(fullPath);
-                    lines.push(`${indent}${entry.name}  (${(0, index_1.humanReadableSize)(stat.size)})`);
-                }
-                catch {
-                    lines.push(`${indent}${entry.name}  (unknown size)`);
-                }
-            }
-        }
-    }
-}
-exports.ListDirectoryTool = ListDirectoryTool;
-// ---------------------------------------------------------------------------
-// ReadFileTool
-// ---------------------------------------------------------------------------
-class ReadFileTool {
-    autoApprovedDirs;
-    requester;
-    grantedPaths;
-    constructor(autoApprovedDirs, requester, grantedPaths) {
-        this.autoApprovedDirs = autoApprovedDirs;
-        this.requester = requester;
-        this.grantedPaths = grantedPaths;
-    }
-    get declaration() {
-        return {
-            name: models_1.ToolName.CLIENT_READ_FILE,
-            description: "Read file contents",
-            parameters: [
-                { name: "path", type: models_1.ToolParamType.STRING, description: "File path", required: true },
-                { name: "offset", type: models_1.ToolParamType.INTEGER, description: "Line offset", required: false },
-                { name: "limit", type: models_1.ToolParamType.INTEGER, description: "Max lines (default 200)", required: false },
-            ],
-        };
-    }
-    async execute(args) {
-        const pathStr = args["path"];
-        if (!pathStr)
-            return "Error: 'path' parameter is required";
-        const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
-        if (!resolved)
-            return `Error: ${resolveErr}`;
-        let content;
-        try {
-            content = fs.readFileSync(resolved, "utf-8");
-        }
-        catch {
-            return `Error: could not read file at '${pathStr}'`;
-        }
-        const allLines = content.split(/\r?\n/);
-        const totalLines = allLines.length;
-        const limit = typeof args["limit"] === "number" ? args["limit"] : 200;
-        const rawOffset = typeof args["offset"] === "number" ? args["offset"] : 0;
-        let startIndex;
-        if (rawOffset < 0) {
-            startIndex = Math.max(0, totalLines + rawOffset);
-        }
-        else {
-            startIndex = rawOffset;
-        }
-        const endIndex = Math.min(startIndex + limit, totalLines);
-        if (startIndex >= totalLines) {
-            return `File has ${totalLines} lines; offset ${rawOffset} is out of range.`;
-        }
-        let stat;
-        try {
-            stat = fs.statSync(resolved);
-        }
-        catch {
-            stat = { size: 0 };
-        }
-        const sizeStr = (0, index_1.humanReadableSize)(stat.size);
-        let result = `File: ${pathStr} (${totalLines} lines, ${sizeStr}, showing ${startIndex + 1}-${endIndex})\n`;
-        for (let i = startIndex; i < endIndex; i++) {
-            const lineNum = String(i + 1).padStart(4, " ");
-            result += `${lineNum} | ${allLines[i]}\n`;
-        }
-        return result;
-    }
-}
-exports.ReadFileTool = ReadFileTool;
-// ---------------------------------------------------------------------------
-// SearchContentTool
-// ---------------------------------------------------------------------------
-class SearchContentTool {
-    autoApprovedDirs;
-    requester;
-    grantedPaths;
-    constructor(autoApprovedDirs, requester, grantedPaths) {
-        this.autoApprovedDirs = autoApprovedDirs;
-        this.requester = requester;
-        this.grantedPaths = grantedPaths;
-    }
-    get declaration() {
-        return {
-            name: models_1.ToolName.CLIENT_SEARCH_CONTENT,
-            description: "Search file contents",
-            parameters: [
-                { name: "pattern", type: models_1.ToolParamType.STRING, description: "Regex pattern", required: true },
-                { name: "path", type: models_1.ToolParamType.STRING, description: "File or directory to search", required: true },
-                { name: "context_lines", type: models_1.ToolParamType.INTEGER, description: "Context lines (default 2)", required: false },
-                { name: "max_results", type: models_1.ToolParamType.INTEGER, description: "Max results (default 50)", required: false },
-            ],
-        };
-    }
-    async execute(args) {
-        const pattern = args["pattern"];
-        if (!pattern)
-            return "Error: 'pattern' parameter is required";
-        const pathStr = args["path"];
-        if (!pathStr)
-            return "Error: 'path' parameter is required";
-        const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
-        if (!resolved)
-            return `Error: ${resolveErr}`;
-        const contextLines = typeof args["context_lines"] === "number" ? args["context_lines"] : 2;
-        const maxResults = typeof args["max_results"] === "number" ? args["max_results"] : 50;
-        let regex;
-        try {
-            regex = new RegExp(pattern);
-        }
-        catch {
-            return `Error: invalid regex pattern '${pattern}'`;
-        }
-        // Collect file paths to search
-        const fileURLs = [];
-        let isDirectory = false;
-        try {
-            const stat = fs.statSync(resolved);
-            if (stat.isDirectory()) {
-                isDirectory = true;
-                this.collectFiles(resolved, fileURLs);
-            }
-            else {
-                fileURLs.push(resolved);
-            }
-        }
-        catch {
-            return `Error: could not access '${pathStr}'`;
-        }
-        const results = [];
-        for (const filePath of fileURLs) {
-            if (results.length >= maxResults)
-                break;
-            let content;
-            try {
-                content = fs.readFileSync(filePath, "utf-8");
-            }
-            catch {
-                continue;
-            }
-            const lines = content.split(/\r?\n/);
-            const relativePath = isDirectory
-                ? path.relative(resolved, filePath)
-                : path.basename(filePath);
-            for (let idx = 0; idx < lines.length; idx++) {
-                if (results.length >= maxResults)
-                    break;
-                if (!regex.test(lines[idx]))
-                    continue;
-                let snippet;
-                if (contextLines > 0) {
-                    const start = Math.max(0, idx - contextLines);
-                    const end = Math.min(lines.length - 1, idx + contextLines);
-                    snippet = "";
-                    for (let ci = start; ci <= end; ci++) {
-                        const marker = ci === idx ? ">" : " ";
-                        snippet += `${relativePath}:${ci + 1}:${marker} ${lines[ci]}\n`;
-                    }
-                }
-                else {
-                    snippet = `${relativePath}:${idx + 1}: ${lines[idx]}`;
-                }
-                results.push(snippet);
-            }
-        }
-        if (results.length === 0) {
-            return `No matches found for '${pattern}' in '${pathStr}'`;
-        }
-        return `Found ${results.length} match(es):\n\n${results.join("\n---\n")}`;
-    }
-    collectFiles(dirPath, fileURLs) {
-        let entries;
-        try {
-            entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith("."))
-                continue;
-            const fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory()) {
-                this.collectFiles(fullPath, fileURLs);
-            }
-            else if (entry.isFile()) {
-                fileURLs.push(fullPath);
-            }
-        }
-    }
-}
-exports.SearchContentTool = SearchContentTool;
-// ---------------------------------------------------------------------------
-// FindFilesTool
-// ---------------------------------------------------------------------------
-class FindFilesTool {
-    autoApprovedDirs;
-    requester;
-    grantedPaths;
-    constructor(autoApprovedDirs, requester, grantedPaths) {
-        this.autoApprovedDirs = autoApprovedDirs;
-        this.requester = requester;
-        this.grantedPaths = grantedPaths;
-    }
-    get declaration() {
-        return {
-            name: models_1.ToolName.CLIENT_FIND_FILES,
-            description: "Find files by name",
-            parameters: [
-                { name: "pattern", type: models_1.ToolParamType.STRING, description: "Glob pattern", required: true },
-                { name: "path", type: models_1.ToolParamType.STRING, description: "Directory to search", required: true },
-                { name: "max_results", type: models_1.ToolParamType.INTEGER, description: "Max results (default 50)", required: false },
-            ],
-        };
-    }
-    async execute(args) {
-        const pattern = args["pattern"];
-        if (!pattern)
-            return "Error: 'pattern' parameter is required";
-        const pathStr = args["path"];
-        if (!pathStr)
-            return "Error: 'path' parameter is required";
-        const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
-        if (!resolved)
-            return `Error: ${resolveErr}`;
-        const maxResults = typeof args["max_results"] === "number" ? args["max_results"] : 50;
-        const matches = [];
-        this.walkAndMatch(resolved, pattern, matches);
-        // Sort newest-first
-        matches.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-        const limited = matches.slice(0, maxResults);
-        if (limited.length === 0) {
-            return `No files matching '${pattern}' found in '${pathStr}'`;
-        }
-        let result = `Found ${matches.length} file(s) matching '${pattern}':\n\n`;
-        for (const m of limited) {
-            const sizeStr = (0, index_1.humanReadableSize)(m.size);
-            const dateStr = m.modified.toISOString();
-            result += `${m.path}  (${sizeStr}, ${dateStr})\n`;
-        }
-        return result;
-    }
-    walkAndMatch(dirPath, pattern, matches) {
-        let entries;
-        try {
-            entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith("."))
-                continue;
-            const fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory()) {
-                this.walkAndMatch(fullPath, pattern, matches);
-            }
-            else if (entry.isFile()) {
-                if (this.globMatch(entry.name, pattern)) {
-                    try {
-                        const stat = fs.statSync(fullPath);
-                        matches.push({
-                            path: fullPath,
-                            size: stat.size,
-                            modified: stat.mtime,
-                        });
-                    }
-                    catch {
-                        // Skip files we can't stat
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Simple glob matching: supports *, ?, and character classes [...].
-     * Converts glob to regex and tests against the filename.
-     */
-    globMatch(filename, pattern) {
-        // Convert glob pattern to regex
-        let regexStr = "^";
-        for (let i = 0; i < pattern.length; i++) {
-            const c = pattern[i];
-            switch (c) {
-                case "*":
-                    regexStr += ".*";
-                    break;
-                case "?":
-                    regexStr += ".";
-                    break;
-                case "[":
-                    // Find closing bracket
-                    const closeBracket = pattern.indexOf("]", i + 1);
-                    if (closeBracket === -1) {
-                        regexStr += "\\[";
-                    }
-                    else {
-                        regexStr += pattern.substring(i, closeBracket + 1);
-                        i = closeBracket;
-                    }
-                    break;
-                case ".":
-                case "(":
-                case ")":
-                case "+":
-                case "^":
-                case "$":
-                case "|":
-                case "{":
-                case "}":
-                case "\\":
-                    regexStr += `\\${c}`;
-                    break;
-                default:
-                    regexStr += c;
-            }
-        }
-        regexStr += "$";
-        try {
-            return new RegExp(regexStr).test(filename);
-        }
-        catch {
-            return false;
-        }
-    }
-}
-exports.FindFilesTool = FindFilesTool;
-// ---------------------------------------------------------------------------
-// FlagFileTool
-// ---------------------------------------------------------------------------
-class FlagFileTool {
-    autoApprovedDirs;
-    onFlag;
-    requester;
-    grantedPaths;
-    static MAX_BINARY_SIZE = 100 * 1024 * 1024; // 100MB
-    constructor(autoApprovedDirs, onFlag, requester, grantedPaths) {
-        this.autoApprovedDirs = autoApprovedDirs;
-        this.onFlag = onFlag;
-        this.requester = requester;
-        this.grantedPaths = grantedPaths;
-    }
-    get declaration() {
-        return {
-            name: models_1.ToolName.CLIENT_FLAG_FILE,
-            description: "Flag a file (or part of a text file) as evidence. For large text files, use offset and limit to flag only the relevant section. Binary files are flagged in full (up to 100MB).",
-            parameters: [
-                { name: "path", type: models_1.ToolParamType.STRING, description: "File path", required: true },
-                { name: "reason", type: models_1.ToolParamType.STRING, description: "Reason for flagging", required: true },
-                { name: "offset", type: models_1.ToolParamType.INTEGER, description: "Starting line number (1-based, text files only). Negative = from end.", required: false },
-                { name: "limit", type: models_1.ToolParamType.INTEGER, description: "Max number of lines to include (text files only).", required: false },
-            ],
-        };
-    }
-    async execute(args) {
-        const pathStr = args["path"];
-        if (!pathStr)
-            return "Error: 'path' parameter is required";
-        const reason = args["reason"];
-        if (!reason)
-            return "Error: 'reason' parameter is required";
-        const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
-        if (!resolved)
-            return `Error: ${resolveErr}`;
-        if (!fs.existsSync(resolved)) {
-            return `Error: file does not exist at '${pathStr}'`;
-        }
-        const offset = typeof args["offset"] === "number" ? args["offset"] : undefined;
-        const limit = typeof args["limit"] === "number" ? args["limit"] : undefined;
-        // Try reading as text first
-        let textContent = null;
-        try {
-            textContent = fs.readFileSync(resolved, "utf-8");
-        }
-        catch {
-            // Not readable as text
-        }
-        if (textContent !== null) {
-            let content = textContent;
-            if (offset !== undefined || limit !== undefined) {
-                let lines = content.split(/\r?\n/);
-                const totalLines = lines.length;
-                let startIdx = 0;
-                if (offset !== undefined) {
-                    startIdx = offset < 0 ? Math.max(0, totalLines + offset) : Math.max(0, offset - 1);
-                }
-                lines = lines.slice(startIdx);
-                if (limit !== undefined && limit > 0) {
-                    lines = lines.slice(0, limit);
-                }
-                const rangeDesc = `lines ${startIdx + 1}-${startIdx + lines.length} of ${totalLines}`;
-                content = `[${rangeDesc}]\n${lines.join("\n")}`;
-            }
-            const redacted = (0, models_1.redactPII)(content);
-            this.onFlag({
-                originalPath: resolved,
-                reason,
-                data: Buffer.from(redacted, "utf-8"),
-                isText: true,
-            });
-            const sizeDesc = offset !== undefined || limit !== undefined ? " (partial)" : "";
-            return `Flagged '${pathStr}'${sizeDesc} — reason: ${reason}`;
-        }
-        // Binary file — flag in full, no partial support
-        if (offset !== undefined || limit !== undefined) {
-            return "Error: offset/limit not supported for binary files. Flag the full file instead.";
-        }
-        let data;
-        try {
-            data = fs.readFileSync(resolved);
-        }
-        catch {
-            return `Error: could not read file at '${pathStr}'`;
-        }
-        if (data.length > FlagFileTool.MAX_BINARY_SIZE) {
-            const sizeMB = Math.floor(data.length / (1024 * 1024));
-            return `Error: file is ${sizeMB}MB — exceeds 100MB limit`;
-        }
-        this.onFlag({
-            originalPath: resolved,
-            reason,
-            data,
-            isText: false,
-        });
-        return `Flagged '${pathStr}' (binary, ${data.length} bytes) — reason: ${reason}`;
-    }
-}
-exports.FlagFileTool = FlagFileTool;
-//# sourceMappingURL=filesystem.js.map