@j0hanz/filesystem-mcp 1.1.2 → 1.2.1

package/dist/lib/file-operations/read-multiple-files.js

@@ -2,6 +2,7 @@ import * as fsp from 'node:fs/promises';
 import { DEFAULT_READ_MANY_MAX_TOTAL_SIZE, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../constants.js';
 import { processInParallel, readFile, readFileWithStats, withAbort, } from '../fs-helpers.js';
 import { validateExistingPath } from '../path-validation.js';
+const UNKNOWN_PATH = '(unknown)';
 function estimateReadSize(stats, maxSize) {
     // `readFile`/`readFileWithStats` are always invoked with a `maxSize` cap, so the
     // combined budget should reflect the maximum number of bytes we might actually read.
@@ -12,45 +13,33 @@ function buildReadOptions(options) {
         encoding: options.encoding,
         maxSize: options.maxSize,
     };
-    if (options.head !== undefined) {
-        readOptions.head = options.head;
-    }
-    if (options.startLine !== undefined) {
-        readOptions.startLine = options.startLine;
-    }
-    if (options.endLine !== undefined) {
-        readOptions.endLine = options.endLine;
-    }
+    applyLineSelection(readOptions, options);
     return readOptions;
 }
 function buildReadMultipleResult(filePath, result) {
-    const value = {
+    const output = {
         path: filePath,
         content: result.content,
         truncated: result.truncated,
         readMode: result.readMode,
     };
     if (result.totalLines !== undefined)
-        value.totalLines = result.totalLines;
+        output.totalLines = result.totalLines;
     if (result.head !== undefined)
-        value.head = result.head;
+        output.head = result.head;
     if (result.startLine !== undefined)
-        value.startLine = result.startLine;
+        output.startLine = result.startLine;
     if (result.endLine !== undefined)
-        value.endLine = result.endLine;
+        output.endLine = result.endLine;
     if (result.linesRead !== undefined)
-        value.linesRead = result.linesRead;
+        output.linesRead = result.linesRead;
     if (result.hasMoreLines !== undefined) {
-        value.hasMoreLines = result.hasMoreLines;
+        output.hasMoreLines = result.hasMoreLines;
     }
-    return value;
+    return output;
 }
-async function readSingleFile(task, options, signal) {
+async function readSingleFile(task, readOptions) {
     const { filePath, index, validPath, stats } = task;
-    const readOptions = buildReadOptions(options);
-    if (signal) {
-        readOptions.signal = signal;
-    }
     const result = validPath && stats
         ? await readFileWithStats(filePath, validPath, stats, readOptions)
         : await readFile(filePath, readOptions);
@@ -60,7 +49,11 @@ async function readSingleFile(task, options, signal) {
     };
 }
 async function readFilesInParallel(filesToProcess, options, signal) {
-    return await processInParallel(filesToProcess, async (task) => readSingleFile(task, options, signal), PARALLEL_CONCURRENCY, signal);
+    const readOptions = buildReadOptions(options);
+    if (signal) {
+        readOptions.signal = signal;
+    }
+    return processInParallel(filesToProcess, async (task) => readSingleFile(task, readOptions), PARALLEL_CONCURRENCY, signal);
 }
 function normalizeReadMultipleOptions(options) {
     const normalized = {
@@ -68,24 +61,23 @@ function normalizeReadMultipleOptions(options) {
         maxSize: Math.min(options.maxSize ?? MAX_TEXT_FILE_SIZE, MAX_TEXT_FILE_SIZE),
         maxTotalSize: options.maxTotalSize ?? DEFAULT_READ_MANY_MAX_TOTAL_SIZE,
     };
-    if (options.head !== undefined) {
-        normalized.head = options.head;
-    }
-    if (options.startLine !== undefined) {
-        normalized.startLine = options.startLine;
-    }
-    if (options.endLine !== undefined) {
-        normalized.endLine = options.endLine;
-    }
+    applyLineSelection(normalized, options);
     return normalized;
 }
+function applyLineSelection(target, source) {
+    if (source.head !== undefined)
+        target.head = source.head;
+    if (source.startLine !== undefined)
+        target.startLine = source.startLine;
+    if (source.endLine !== undefined)
+        target.endLine = source.endLine;
+}
 function resolveNormalizedOptions(options) {
     const { signal, ...rest } = options;
-    const resolved = { normalized: normalizeReadMultipleOptions(rest) };
-    if (signal) {
-        resolved.signal = signal;
-    }
-    return resolved;
+    return {
+        normalized: normalizeReadMultipleOptions(rest),
+        ...(signal ? { signal } : {}),
+    };
 }
 async function validateFile(filePath, index, signal) {
     const validPath = await validateExistingPath(filePath, signal);
@@ -108,7 +100,7 @@ async function tryValidateFile(filePath, index, signal) {
 async function validateBatch(tasks, signal) {
     if (tasks.length === 0)
         return new Map();
-    const { results } = await processInParallel(tasks, async (task) => await tryValidateFile(task.filePath, task.index, signal), PARALLEL_CONCURRENCY, signal);
+    const { results } = await processInParallel(tasks, async (task) => tryValidateFile(task.filePath, task.index, signal), PARALLEL_CONCURRENCY, signal);
     const infos = new Map();
     for (const info of results) {
         if (!info)
@@ -124,7 +116,9 @@ async function applyBudgetForRange(options) {
         const filePath = filePaths[index];
         if (!filePath)
             continue;
-        const info = await resolveValidatedInfo(filePath, index, validated, signal);
+        const cached = validated.get(index);
+        const info = cached ??
+            (await resolveValidatedInfo(filePath, index, validated, signal));
         if (!info)
             continue;
         const { exceeded, totalSize: nextTotalSize } = applyBudget(totalSize, estimateReadSize(info.stats, maxSize), maxTotalSize, index, totalFiles, skippedBudget);
@@ -176,24 +170,23 @@ async function collectFileBudget(filePaths, maxTotalSize, maxSize, signal) {
     return { skippedBudget, validated };
 }
 async function resolveValidatedInfo(filePath, index, validated, signal) {
-    if (!validated.has(index)) {
-        const info = await tryValidateFile(filePath, index, signal);
-        if (info) {
-            validated.set(index, info);
-        }
+    const existing = validated.get(index);
+    if (existing) {
+        return existing;
     }
-    return validated.get(index);
-}
-function applyBudget(totalSize, estimatedSize, maxTotalSize, index, totalFiles, skippedBudget) {
-    if (totalSize + estimatedSize > maxTotalSize) {
-        skippedBudget.add(index);
-        markRemainingSkipped(index + 1, totalFiles, skippedBudget);
-        return { totalSize, exceeded: true };
+    const info = await tryValidateFile(filePath, index, signal);
+    if (info) {
+        validated.set(index, info);
+        return info;
     }
-    return { totalSize: totalSize + estimatedSize, exceeded: false };
+    return undefined;
 }
 function buildOutput(filePaths) {
-    return filePaths.map((filePath) => ({ path: filePath }));
+    const output = new Array(filePaths.length);
+    for (let index = 0; index < filePaths.length; index += 1) {
+        output[index] = { path: filePaths[index] ?? UNKNOWN_PATH };
+    }
+    return output;
 }
 function applyResults(output, results) {
     for (const result of results) {
@@ -219,7 +212,7 @@ function applyErrors(output, errors, filesToProcess, filePaths) {
         const originalIndex = resolveErrorOriginalIndex(failure.index, filesToProcess, filePaths.length);
         if (originalIndex === undefined)
             continue;
-        const filePath = filePaths[originalIndex] ?? '(unknown)';
+        const filePath = filePaths[originalIndex] ?? UNKNOWN_PATH;
         output[originalIndex] = {
             path: filePath,
             error: failure.error.message,
@@ -227,19 +220,34 @@ function applyErrors(output, errors, filesToProcess, filePaths) {
     }
 }
 function buildFilesToProcess(filePaths, validated, skippedBudget) {
-    return filePaths
-        .map((filePath, index) => {
+    const filesToProcess = [];
+    for (let index = 0; index < filePaths.length; index += 1) {
+        if (skippedBudget.has(index))
+            continue;
+        const filePath = filePaths[index];
+        if (!filePath)
+            continue;
         const cached = validated.get(index);
-        return cached
-            ? {
+        if (cached) {
+            filesToProcess.push({
                 filePath,
                 index,
                 validPath: cached.validPath,
                 stats: cached.stats,
-            }
-            : { filePath, index };
-    })
-        .filter(({ index }) => !skippedBudget.has(index));
+            });
+            continue;
+        }
+        filesToProcess.push({ filePath, index });
+    }
+    return filesToProcess;
+}
+function applyBudget(totalSize, estimatedSize, maxTotalSize, index, totalFiles, skippedBudget) {
+    if (totalSize + estimatedSize > maxTotalSize) {
+        skippedBudget.add(index);
+        markRemainingSkipped(index + 1, totalFiles, skippedBudget);
+        return { totalSize, exceeded: true };
+    }
+    return { totalSize: totalSize + estimatedSize, exceeded: false };
 }
 function applySkippedBudget(output, skippedBudget, filePaths, maxTotalSize) {
     for (const index of skippedBudget) {

package/dist/lib/file-operations/search-content.js

@@ -10,6 +10,7 @@ import { ErrorCode, formatUnknownErrorMessage, isTimeoutLikeError, McpError, } f
 import { assertNotAborted, createTimedAbortSignal, isProbablyBinary, withAbort, } from '../fs-helpers.js';
 import { assertAllowedFileAccess, isSensitivePath } from '../path-policy.js';
 import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { withOptionalStoppedReason } from './common.js';
 import { globEntries } from './glob-engine.js';
 // --- Configuration & Schemas ---
 const INTERNAL_MAX_RESULTS = 500;
@@ -64,6 +65,16 @@ function resolveOptions(options) {
     }
     return result.data;
 }
+function countRegexLineMatches(regex, line) {
+    regex.lastIndex = 0;
+    let count = 0;
+    while (regex.exec(line) !== null) {
+        count++;
+        if (regex.lastIndex === 0)
+            regex.lastIndex++;
+    }
+    return count;
+}
 function escapeLiteral(pattern) {
     return pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -85,16 +96,7 @@ function buildLiteralMatcher(pattern, options) {
     if (!options.caseSensitive) {
         const final = escapeLiteral(pattern);
         const regex = new RegExp(final, 'gi');
-        return (line) => {
-            regex.lastIndex = 0;
-            let count = 0;
-            while (regex.exec(line) !== null) {
-                count++;
-                if (regex.lastIndex === 0)
-                    regex.lastIndex++;
-            }
-            return count;
-        };
+        return (line) => countRegexLineMatches(regex, line);
     }
     // Fast path for case-sensitive literal
     const needle = pattern;
@@ -114,16 +116,7 @@ function buildLiteralMatcher(pattern, options) {
 }
 function buildRegexMatcher(final, caseSensitive) {
     const regex = new RE2(final, caseSensitive ? 'g' : 'gi');
-    return (line) => {
-        regex.lastIndex = 0;
-        let count = 0;
-        while (regex.exec(line) !== null) {
-            count++;
-            if (regex.lastIndex === 0)
-                regex.lastIndex++; // Avoid infinite loop on zero-width match
-        }
-        return count;
-    };
+    return (line) => countRegexLineMatches(regex, line);
 }
 export function buildMatcher(pattern, options) {
     if (options.isLiteral && pattern.length === 0)
@@ -213,7 +206,8 @@ function trimContent(line) {
 }
 async function readMatches(handle, requestedPath, matcher, options, maxMatches, isCancelled, signal) {
     const matches = [];
-    const ctx = new ContextBuffer(options.contextLines);
+    const hasContext = options.contextLines > 0;
+    const ctx = hasContext ? new ContextBuffer(options.contextLines) : undefined;
     let lineNumber = 1;
     // Use for-await with readLines for memory efficiency
     const lines = handle.readLines({ encoding: 'utf-8', signal });
@@ -224,22 +218,34 @@ async function readMatches(handle, requestedPath, matcher, options, maxMatches,
             if (isCancelled())
                 break;
             const matchCount = matcher(rawLine);
-            const content = trimContent(rawLine);
+            let content;
+            const getContent = () => {
+                content ??= trimContent(rawLine);
+                return content;
+            };
             if (matchCount > 0) {
-                matches.push({
-                    file: requestedPath,
-                    line: lineNumber,
-                    content,
-                    matchCount,
-                    ...(options.contextLines > 0
-                        ? {
-                            contextBefore: ctx.snapshotBefore(),
-                            contextAfter: ctx.scheduleAfter(),
-                        }
-                        : {}),
-                });
+                if (ctx) {
+                    matches.push({
+                        file: requestedPath,
+                        line: lineNumber,
+                        content: getContent(),
+                        matchCount,
+                        contextBefore: ctx.snapshotBefore(),
+                        contextAfter: ctx.scheduleAfter(),
+                    });
+                }
+                else {
+                    matches.push({
+                        file: requestedPath,
+                        line: lineNumber,
+                        content: getContent(),
+                        matchCount,
+                    });
+                }
+            }
+            if (ctx) {
+                ctx.add(getContent());
             }
-            ctx.add(content);
             lineNumber++;
         }
     }
@@ -304,24 +310,22 @@ function createScanSummary() {
     };
 }
 function buildSearchResult(root, pattern, filePattern, matches, summary) {
+    const baseSummary = {
+        filesScanned: summary.filesScanned,
+        filesMatched: summary.filesMatched,
+        matches: matches.length,
+        truncated: summary.truncated,
+        skippedTooLarge: summary.skippedTooLarge,
+        skippedBinary: summary.skippedBinary,
+        skippedInaccessible: summary.skippedInaccessible,
+        linesSkippedDueToRegexTimeout: 0,
+    };
     return {
         basePath: root,
         pattern,
         filePattern,
         matches,
-        summary: {
-            filesScanned: summary.filesScanned,
-            filesMatched: summary.filesMatched,
-            matches: matches.length,
-            truncated: summary.truncated,
-            skippedTooLarge: summary.skippedTooLarge,
-            skippedBinary: summary.skippedBinary,
-            skippedInaccessible: summary.skippedInaccessible,
-            linesSkippedDueToRegexTimeout: 0,
-            ...(summary.stoppedReason
-                ? { stoppedReason: summary.stoppedReason }
-                : {}),
-        },
+        summary: withOptionalStoppedReason(baseSummary, summary.stoppedReason),
     };
 }
 const currentDir = path.dirname(fileURLToPath(import.meta.url));
@@ -448,9 +452,15 @@ class SearchWorkerPool {
         for (const p of this.pending.values())
             p.reject(new Error(ERROR_WORKER_POOL_CLOSED));
         this.pending.clear();
-        const workers = this.workers.filter((worker) => worker !== undefined);
-        await Promise.all(workers.map((worker) => worker.terminate()));
-        this.workers = Array.from({ length: this.size }, () => undefined);
+        const terminations = [];
+        for (let index = 0; index < this.workers.length; index += 1) {
+            const worker = this.workers[index];
+            if (!worker)
+                continue;
+            terminations.push(worker.terminate());
+            this.workers[index] = undefined;
+        }
+        await Promise.all(terminations);
     }
 }
 function isWorkerPoolAvailable() {
@@ -545,9 +555,14 @@ function processScanResult(winner, summary, matches, maxResults) {
             summary.skippedBinary++;
         if (res.skippedTooLarge)
             summary.skippedTooLarge++;
-        const take = maxResults - matches.length;
-        if (take > 0 && res.matches.length > 0) {
-            matches.push(...res.matches.slice(0, take));
+        const remaining = maxResults - matches.length;
+        if (remaining > 0 && res.matches.length > 0) {
+            const take = Math.min(remaining, res.matches.length);
+            for (let index = 0; index < take; index += 1) {
+                const match = res.matches[index];
+                if (match)
+                    matches.push(match);
+            }
         }
     }
 }
@@ -559,14 +574,17 @@ function reportSearchProgress(onProgress, current, total, force = false) {
     onProgress({ current, total });
 }
 async function waitForWinner(pending) {
-    const pendingTasks = Array.from(pending);
-    return Promise.race(pendingTasks.map((t) => t.promise.then((res) => ({ task: t, result: res, error: undefined }), (err) => ({
-        task: t,
-        result: undefined,
-        error: err instanceof Error
-            ? err
-            : new Error(formatUnknownErrorMessage(err)),
-    }))));
+    const raceCandidates = [];
+    for (const task of pending) {
+        raceCandidates.push(task.promise.then((result) => ({ task, result, error: undefined }), (err) => ({
+            task,
+            result: undefined,
+            error: err instanceof Error
+                ? err
+                : new Error(formatUnknownErrorMessage(err)),
+        })));
+    }
+    return Promise.race(raceCandidates);
 }
 async function executeParallel(files, pattern, opts, signal, summary) {
     const pool = getPool();
@@ -661,12 +679,13 @@ export async function searchContent(basePath, pattern, options = {}) {
             }, signal, opts.maxResults);
             if (result.matched)
                 summary.filesMatched = 1;
-            return buildSearchResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, [...result.matches], summary);
+            return buildSearchResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
         }
         if (!stats.isDirectory()) {
             throw new McpError(ErrorCode.E_INVALID_INPUT, `Path must be file or directory`, basePath);
         }
         const root = await validateExistingDirectory(details.resolvedPath, signal);
+        const rootDirectories = [root];
         // Glob
         const stream = globEntries({
             cwd: root,
@@ -693,7 +712,7 @@ export async function searchContent(basePath, pattern, options = {}) {
                 // Helper to resolve
                 // We duplicate simple resolution logic to keep it fast
                 const normalized = normalizePath(entry.path);
-                if (!isPathWithinDirectories(normalized, [root]))
+                if (!isPathWithinDirectories(normalized, rootDirectories))
                     continue;
                 if (isSensitivePath(entry.path, normalized))
                     continue;

package/dist/lib/file-operations/search-files.js

@@ -3,8 +3,9 @@ import { DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constan
 import { createTimedAbortSignal } from '../fs-helpers.js';
 import { isSensitivePath } from '../path-policy.js';
 import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { needsStatsForSort, withOptionalStoppedReason } from './common.js';
 import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
-import { globEntries } from './glob-engine.js';
+import { globEntries, resolveEntryType } from './glob-engine.js';
 // Internal default for find tool - not exposed to MCP users
 const INTERNAL_MAX_RESULTS = 1000;
 function normalizeOptions(options) {
@@ -23,15 +24,6 @@ function normalizeOptions(options) {
     }
     return normalized;
 }
-function resolveEntryType(dirent) {
-    if (dirent.isDirectory())
-        return 'directory';
-    if (dirent.isSymbolicLink())
-        return 'symlink';
-    if (dirent.isFile())
-        return 'file';
-    return 'other';
-}
 function buildSearchResult(entry, entryType, needsStats) {
     let resolvedType = 'other';
     if (entryType === 'directory') {
@@ -49,9 +41,6 @@ function buildSearchResult(entry, entryType, needsStats) {
         ...(modified !== undefined ? { modified } : {}),
     };
 }
-function needsStatsForSort(sortBy) {
-    return sortBy === 'size' || sortBy === 'modified';
-}
 function markStopped(state, reason) {
     state.truncated = true;
     state.stoppedReason = reason;
@@ -108,8 +97,6 @@ function buildCollectResult(state) {
     return outcome;
 }
 function handleEntry(entry, entryType, needsStats, normalized, state) {
-    if (!shouldIncludeEntry(entryType, normalized))
-        return;
     state.results.push(buildSearchResult(entry, entryType, needsStats));
     if (state.results.length >= normalized.maxResults) {
         markStopped(state, 'maxResults');
@@ -122,21 +109,20 @@ function reportSearchFilesProgress(onProgress, current, total, force = false) {
         return;
     onProgress({ current, total });
 }
-async function collectFromStream(stream, root, gitignoreMatcher, normalized, needsStats, state, signal, onProgress) {
+async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, onProgress) {
     for await (const entry of stream) {
         if (shouldStopCollecting(state, normalized, signal))
             break;
         state.filesScanned++;
         reportSearchFilesProgress(onProgress, state.filesScanned, normalized.maxFilesScanned);
-        if (gitignoreMatcher &&
-            isIgnoredByGitignore(gitignoreMatcher, root, entry.path)) {
+        if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path)) {
             continue;
         }
         const entryType = resolveEntryType(entry.dirent);
         if (!shouldIncludeEntry(entryType, normalized)) {
             continue;
         }
-        const isAccessible = await isEntryAccessible(entry, entryType, root, signal);
+        const isAccessible = await isEntryAccessible(entry, entryType, rootDirectories, signal);
         if (!isAccessible) {
             state.skippedInaccessible++;
             continue;
@@ -147,7 +133,12 @@ async function collectFromStream(stream, root, gitignoreMatcher, normalized, nee
     }
     reportSearchFilesProgress(onProgress, state.filesScanned, normalized.maxFilesScanned, true);
 }
-async function isEntryAccessible(entry, entryType, root, signal) {
+function isEntryIgnoredByGitignore(matcher, root, entryPath) {
+    if (!matcher)
+        return false;
+    return isIgnoredByGitignore(matcher, root, entryPath);
+}
+async function isEntryAccessible(entry, entryType, rootDirectories, signal) {
     if (entryType === 'symlink') {
         try {
             const validated = await validateExistingPathDetailed(entry.path, signal);
@@ -158,7 +149,7 @@ async function isEntryAccessible(entry, entryType, root, signal) {
         }
     }
     const resolvedPath = normalizePath(entry.path);
-    if (!isPathWithinDirectories(resolvedPath, [root])) {
+    if (!isPathWithinDirectories(resolvedPath, rootDirectories)) {
         return false;
     }
     return !isSensitivePath(entry.path, resolvedPath);
@@ -167,10 +158,11 @@ async function collectSearchResults(root, pattern, excludePatterns, normalized,
     const needsStats = needsStatsForSort(normalized.sortBy);
     const stream = buildSearchStream(root, pattern, excludePatterns, normalized, needsStats);
     const state = createCollectState();
+    const rootDirectories = [root];
     const gitignoreMatcher = normalized.respectGitignore
         ? await loadRootGitignore(root, signal)
         : null;
-    await collectFromStream(stream, root, gitignoreMatcher, normalized, needsStats, state, signal, onProgress);
+    await collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, onProgress);
     return buildCollectResult(state);
 }
 function buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible) {
@@ -179,9 +171,8 @@ function buildSearchSummary(results, filesScanned, truncated, stoppedReason, ski
         truncated,
         skippedInaccessible,
         filesScanned,
-        ...(stoppedReason !== undefined ? { stoppedReason } : {}),
     };
-    return summary;
+    return withOptionalStoppedReason(summary, stoppedReason);
 }
 const collator = new Intl.Collator(undefined, { numeric: true });
 function compareString(a, b) {
@@ -213,11 +204,17 @@ const SORT_COMPARATORS = {
 };
 export function sortSearchResults(results, sortBy) {
     if (sortBy === 'name') {
-        const decorated = results.map((item, index) => ({
-            item,
-            baseName: path.basename(item.path ?? ''),
-            index,
-        }));
+        const decorated = [];
+        for (let index = 0; index < results.length; index += 1) {
+            const item = results[index];
+            if (!item)
+                continue;
+            decorated.push({
+                item,
+                baseName: path.basename(item.path ?? ''),
+                index,
+            });
+        }
         decorated.sort((a, b) => {
             const baseCompare = compareString(a.baseName, b.baseName);
             if (baseCompare !== 0)
@@ -227,7 +224,12 @@ export function sortSearchResults(results, sortBy) {
                 return pathCompare;
             return a.index - b.index;
         });
-        results.splice(0, results.length, ...decorated.map((entry) => entry.item));
+        for (let index = 0; index < decorated.length; index += 1) {
+            const entry = decorated[index];
+            if (entry) {
+                results[index] = entry.item;
+            }
+        }
         return;
     }
     const comparator = SORT_COMPARATORS[sortBy];