cspell 5.19.5 → 5.20.0

package/dist/commandLint.js

@@ -81,6 +81,7 @@ function commandLint(prog) {
         .addOption(new commander_1.Option('--local <local>', 'Deprecated -- Use: --locale').hideHelp())
         .option('--cache', 'Use cache to only check changed files.')
         .option('--no-cache', 'Do not use cache.')
+        .option('--cache-reset', 'Reset the cache file.')
         .addOption(new commander_1.Option('--cache-strategy <strategy>', 'Strategy to use for detecting changed files.').choices([
         'metadata',
         'content',

package/dist/lint/lint.js

@@ -43,6 +43,7 @@ const chalk = require("chalk");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const npmPackage = require('../../package.json');
 const version = npmPackage.version;
+const { opFilterAsync } = cspell_pipe_1.operators;
 async function runLint(cfg) {
     let { reporter } = cfg;
     cspell.setLogger(getLoggerFromReporter(reporter));
@@ -126,6 +127,9 @@ async function runLint(cfg) {
         const fileCount = files instanceof Array ? files.length : undefined;
         const status = runResult();
         const cache = (0, cache_1.createCache)(cacheSettings);
+        if (cfg.options.cacheReset) {
+            cache.reset();
+        }
         const failFast = (_b = (_a = cfg.options.failFast) !== null && _a !== void 0 ? _a : configInfo.config.failFast) !== null && _b !== void 0 ? _b : false;
         const emitProgressBegin = (filename, fileNum, fileCount) => reporter.progress({
             type: 'ProgressFileBegin',
@@ -413,8 +417,8 @@ async function useFileLists(fileListFiles, includeGlobPatterns, root, dot) {
         options.dot = dot;
     }
     const globMatcher = new cspell_glob_1.GlobMatcher(includeGlobPatterns, options);
-    const files = await (0, fileHelper_1.readFileListFiles)(fileListFiles);
     const filterFiles = (file) => globMatcher.match(file);
-    return files instanceof Array ? files.filter(filterFiles) : (0, cspell_pipe_1.pipeAsync)(files, (0, cspell_pipe_1.opFilter)(filterFiles));
+    const files = (0, fileHelper_1.readFileListFiles)(fileListFiles);
+    return (0, cspell_pipe_1.pipeAsync)(files, (0, cspell_pipe_1.opFilter)(filterFiles), opFilterAsync(fileHelper_1.isNotDir));
 }
 //# sourceMappingURL=lint.js.map

package/dist/util/async.d.ts

@@ -1,2 +1,3 @@
-export { toAsyncIterable as mergeAsyncIterables, toArray as asyncIterableToArray } from '@cspell/cspell-pipe';
+export { helpers as asyncHelpers, operators as asyncOperators, pipeAsync as asyncPipe, toArray as asyncIterableToArray, toAsyncIterable as mergeAsyncIterables, } from '@cspell/cspell-pipe';
+export declare const asyncMap: typeof import("@cspell/cspell-pipe/operators").opMapAsync, asyncFilter: typeof import("@cspell/cspell-pipe/operators").opFilterAsync, asyncAwait: typeof import("@cspell/cspell-pipe").opAwaitAsync, asyncFlatten: typeof import("@cspell/cspell-pipe/operators").opFlattenAsync;
 //# sourceMappingURL=async.d.ts.map

package/dist/util/async.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncIterableToArray = exports.mergeAsyncIterables = void 0;
-var cspell_pipe_1 = require("@cspell/cspell-pipe");
-Object.defineProperty(exports, "mergeAsyncIterables", { enumerable: true, get: function () { return cspell_pipe_1.toAsyncIterable; } });
-Object.defineProperty(exports, "asyncIterableToArray", { enumerable: true, get: function () { return cspell_pipe_1.toArray; } });
+exports.asyncFlatten = exports.asyncAwait = exports.asyncFilter = exports.asyncMap = exports.mergeAsyncIterables = exports.asyncIterableToArray = exports.asyncPipe = exports.asyncOperators = exports.asyncHelpers = void 0;
+const cspell_pipe_1 = require("@cspell/cspell-pipe");
+var cspell_pipe_2 = require("@cspell/cspell-pipe");
+Object.defineProperty(exports, "asyncHelpers", { enumerable: true, get: function () { return cspell_pipe_2.helpers; } });
+Object.defineProperty(exports, "asyncOperators", { enumerable: true, get: function () { return cspell_pipe_2.operators; } });
+Object.defineProperty(exports, "asyncPipe", { enumerable: true, get: function () { return cspell_pipe_2.pipeAsync; } });
+Object.defineProperty(exports, "asyncIterableToArray", { enumerable: true, get: function () { return cspell_pipe_2.toArray; } });
+Object.defineProperty(exports, "mergeAsyncIterables", { enumerable: true, get: function () { return cspell_pipe_2.toAsyncIterable; } });
+exports.asyncMap = cspell_pipe_1.operators.opMapAsync, exports.asyncFilter = cspell_pipe_1.operators.opFilterAsync, exports.asyncAwait = cspell_pipe_1.operators.opAwaitAsync, exports.asyncFlatten = cspell_pipe_1.operators.opFlattenAsync;
 //# sourceMappingURL=async.js.map

package/dist/util/cache/CSpellLintResultCache.d.ts

@@ -12,5 +12,9 @@ export interface CSpellLintResultCache {
      * Persists the in-memory cache to disk.
      */
     reconcile(): void;
+    /**
+     * Resets the cache.
+     */
+    reset(): void;
 }
 //# sourceMappingURL=CSpellLintResultCache.d.ts.map

package/dist/util/cache/CacheOptions.d.ts

@@ -19,5 +19,9 @@ export interface CacheOptions {
      * Strategy to use for detecting changed files, default: metadata
      */
     cacheStrategy?: CacheStrategy;
+    /**
+     * Resets the cache
+     */
+    cacheReset?: boolean;
 }
 //# sourceMappingURL=CacheOptions.d.ts.map

package/dist/util/cache/DiskCache.d.ts

@@ -1,37 +1,58 @@
 import type { FileDescriptor } from 'file-entry-cache';
 import type { FileResult } from '../../util/fileHelper';
 import type { CSpellLintResultCache } from './CSpellLintResultCache';
-export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs'>;
+export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs' | 'cached'>;
 /**
  * This is the data cached.
  * Property names are short to help keep the cache file size small.
  */
 interface CachedData {
+    /** meta version + suffix */
+    v?: string;
     /** results */
-    r: CachedFileResult;
+    r?: CachedFileResult;
     /** dependencies */
-    d: string[];
-    /** meta version */
-    v: string;
+    d?: Dependency[];
+}
+interface Dependency {
+    /** filename */
+    f: string;
+    /** hash of file contents */
+    h?: string | undefined;
 }
 interface CSpellCachedMetaData {
     data?: CachedData;
 }
-export declare type CSpellCacheMeta = (FileDescriptor['meta'] & CSpellCachedMetaData) | undefined;
+declare type Meta = FileDescriptor['meta'];
+export declare type CSpellCacheMeta = (Meta & CSpellCachedMetaData) | undefined;
 /**
  * Caches cspell results on disk
  */
 export declare class DiskCache implements CSpellLintResultCache {
-    readonly version: string;
+    readonly useCheckSum: boolean;
+    readonly cspellVersion: string;
     private fileEntryCache;
-    private changedDependencies;
-    private knownDependencies;
-    constructor(cacheFileLocation: string, useCheckSum: boolean, version: string);
+    private dependencyCache;
+    private dependencyCacheTree;
+    private objectCollection;
+    private ocCacheFileResult;
+    readonly version: string;
+    constructor(cacheFileLocation: string, useCheckSum: boolean, cspellVersion: string);
     getCachedLintResults(filename: string): Promise<FileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, dependsUponFiles: string[]): void;
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }: FileResult, dependsUponFiles: string[]): void;
     reconcile(): void;
-    private cacheDependencies;
+    reset(): void;
+    private normalizeResult;
+    private calcDependencyHashes;
+    private checkDependency;
+    private getDependency;
+    private getFileDep;
     private checkDependencies;
+    private getHash;
 }
+declare function calcVersion(version: string): string;
+export declare const __testing__: {
+    calcVersion: typeof calcVersion;
+};
 export {};
 //# sourceMappingURL=DiskCache.d.ts.map

package/dist/util/cache/DiskCache.js

@@ -23,19 +23,37 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiskCache = void 0;
+exports.__testing__ = exports.DiskCache = void 0;
+const crypto = __importStar(require("crypto"));
 const fileEntryCache = __importStar(require("file-entry-cache"));
+const fs = __importStar(require("fs"));
 const path_1 = require("path");
 const fileHelper_1 = require("../../util/fileHelper");
+const ObjectCollection_1 = require("./ObjectCollection");
+const cacheDataKeys = {
+    v: 'v',
+    r: 'r',
+    d: 'd',
+};
+/**
+ * Meta Data Version is used to detect if the structure of the meta data has changed.
+ * This is used in combination with the Suffix and the version of CSpell.
+ */
+const META_DATA_BASE_VERSION = '1';
+const META_DATA_VERSION_SUFFIX = '-' + META_DATA_BASE_VERSION + '-' + Object.keys(cacheDataKeys).join('|');
 /**
  * Caches cspell results on disk
  */
 class DiskCache {
-    constructor(cacheFileLocation, useCheckSum, version) {
-        this.version = version;
-        this.changedDependencies = new Set();
-        this.knownDependencies = new Set();
+    constructor(cacheFileLocation, useCheckSum, cspellVersion) {
+        this.useCheckSum = useCheckSum;
+        this.cspellVersion = cspellVersion;
+        this.dependencyCache = new Map();
+        this.dependencyCacheTree = {};
+        this.objectCollection = new ObjectCollection_1.ShallowObjectCollection();
+        this.ocCacheFileResult = new ObjectCollection_1.ShallowObjectCollection();
         this.fileEntryCache = fileEntryCache.createFromFile((0, path_1.resolve)(cacheFileLocation), useCheckSum);
+        this.version = calcVersion(cspellVersion);
     }
     async getCachedLintResults(filename) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
@@ -56,6 +74,12 @@ class DiskCache {
             !this.checkDependencies(data.d)) {
             return undefined;
         }
+        const dd = { ...data };
+        if (dd.d) {
+            dd.d = setTreeEntry(this.dependencyCacheTree, dd.d);
+        }
+        dd.r = dd.r && this.normalizeResult(dd.r);
+        meta.data = this.objectCollection.get(dd);
         // Skip reading empty files and files without lint error
         const hasErrors = !!result && (result.errors > 0 || result.configErrors > 0 || result.issues.length > 0);
         const cached = true;
@@ -67,41 +91,131 @@ class DiskCache {
             cached,
         };
     }
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, dependsUponFiles) {
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }, dependsUponFiles) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(fileInfo.filename);
         const meta = fileDescriptor.meta;
         if (fileDescriptor.notFound || !meta) {
             return;
         }
-        const data = {
-            r: result,
-            d: dependsUponFiles,
+        const data = this.objectCollection.get({
             v: this.version,
-        };
+            r: this.normalizeResult(result),
+            d: this.calcDependencyHashes(dependsUponFiles),
+        });
         meta.data = data;
-        this.cacheDependencies(dependsUponFiles);
     }
     reconcile() {
         this.fileEntryCache.reconcile();
     }
-    cacheDependencies(files) {
-        this.fileEntryCache.analyzeFiles(files);
+    reset() {
+        this.fileEntryCache.destroy();
+        this.dependencyCache.clear();
+        this.dependencyCacheTree = {};
+        this.objectCollection = new ObjectCollection_1.ShallowObjectCollection();
+        this.ocCacheFileResult = new ObjectCollection_1.ShallowObjectCollection();
     }
-    checkDependencies(files) {
-        for (const file of files) {
-            if (this.changedDependencies.has(file)) {
-                return false;
-            }
+    normalizeResult(result) {
+        const { issues, processed, errors, configErrors, ...rest } = result;
+        if (!Object.keys(rest).length) {
+            return this.ocCacheFileResult.get(result);
         }
-        const unknown = files.filter((f) => !this.knownDependencies.has(f));
-        if (!unknown.length) {
+        return this.ocCacheFileResult.get({ issues, processed, errors, configErrors });
+    }
+    calcDependencyHashes(dependsUponFiles) {
+        dependsUponFiles.sort();
+        const c = getTreeEntry(this.dependencyCacheTree, dependsUponFiles);
+        if (c === null || c === void 0 ? void 0 : c.d) {
+            return c.d;
+        }
+        const dependencies = dependsUponFiles.map((f) => this.getDependency(f));
+        return setTreeEntry(this.dependencyCacheTree, dependencies);
+    }
+    checkDependency(dep) {
+        const cDep = this.dependencyCache.get(dep.f);
+        if (cDep && compDep(dep, cDep))
             return true;
+        if (cDep)
+            return false;
+        const d = this.getFileDep(dep.f);
+        if (compDep(dep, d)) {
+            this.dependencyCache.set(dep.f, dep);
+            return true;
+        }
+        this.dependencyCache.set(d.f, d);
+        return false;
+    }
+    getDependency(file) {
+        const dep = this.dependencyCache.get(file);
+        if (dep)
+            return dep;
+        const d = this.getFileDep(file);
+        this.dependencyCache.set(file, d);
+        return d;
+    }
+    getFileDep(file) {
+        let h;
+        try {
+            const buffer = fs.readFileSync(file);
+            h = this.getHash(buffer);
+        }
+        catch (e) {
+            return { f: file };
         }
-        const { changedFiles, notFoundFiles } = this.fileEntryCache.analyzeFiles(files);
-        changedFiles.map((f) => this.changedDependencies.add(f));
-        unknown.forEach((f) => this.knownDependencies.add(f));
-        return changedFiles.length === 0 && notFoundFiles.length === 0;
+        return { f: file, h };
+    }
+    checkDependencies(dependencies) {
+        if (!dependencies)
+            return false;
+        for (const dep of dependencies) {
+            if (!this.checkDependency(dep)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getHash(buffer) {
+        return crypto.createHash('md5').update(buffer).digest('hex');
     }
 }
 exports.DiskCache = DiskCache;
+function getTreeEntry(tree, keys) {
+    var _a;
+    let r = tree;
+    for (const k of keys) {
+        r = (_a = r.c) === null || _a === void 0 ? void 0 : _a.get(k);
+        if (!r)
+            return r;
+    }
+    return r;
+}
+function setTreeEntry(tree, deps, update = false) {
+    let r = tree;
+    for (const d of deps) {
+        const k = d.f;
+        if (!r.c) {
+            r.c = new Map();
+        }
+        const cn = r.c.get(k);
+        const n = cn !== null && cn !== void 0 ? cn : {};
+        if (!cn) {
+            r.c.set(k, n);
+        }
+        r = n;
+    }
+    let d = r.d;
+    if (!d || (r.d && update)) {
+        r.d = deps;
+        d = deps;
+    }
+    return d;
+}
+function compDep(a, b) {
+    return a.f === b.f && a.h === b.h;
+}
+function calcVersion(version) {
+    return version + META_DATA_VERSION_SUFFIX;
+}
+exports.__testing__ = {
+    calcVersion,
+};
 //# sourceMappingURL=DiskCache.js.map

package/dist/util/cache/DummyCache.d.ts

@@ -6,5 +6,6 @@ export declare class DummyCache implements CSpellLintResultCache {
     getCachedLintResults(): Promise<undefined>;
     setCachedLintResults(): void;
     reconcile(): void;
+    reset(): void;
 }
 //# sourceMappingURL=DummyCache.d.ts.map

package/dist/util/cache/DummyCache.js

@@ -14,6 +14,9 @@ class DummyCache {
     reconcile() {
         return;
     }
+    reset() {
+        return;
+    }
 }
 exports.DummyCache = DummyCache;
 //# sourceMappingURL=DummyCache.js.map

package/dist/util/cache/ObjectCollection.d.ts

@@ -0,0 +1,17 @@
+export declare class ShallowObjectCollection<T extends object> {
+    private tree;
+    get(v: T): T;
+}
+export declare class Collection {
+    private col;
+    /**
+     * Add a plain object to the collection.
+     * The actual object used is returned.
+     * By adding the object to the collection, it is now owned by the collection.
+     * Do not add class objects.
+     * @param v any object or primitive
+     * @returns v or the matching object.
+     */
+    add<T>(v: T): T;
+}
+//# sourceMappingURL=ObjectCollection.d.ts.map

package/dist/util/cache/ObjectCollection.js

@@ -0,0 +1,137 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = exports.ShallowObjectCollection = void 0;
+const compare = Intl.Collator().compare;
+class ShallowObjectCollection {
+    constructor() {
+        this.tree = {};
+    }
+    get(v) {
+        if (typeof v !== 'object' || v === null) {
+            return v;
+        }
+        const keys = Object.entries(v)
+            .filter((entry) => entry[1] !== undefined)
+            .sort((a, b) => compare(a[0], b[0]));
+        let t = this.tree;
+        for (const [key, obj] of keys) {
+            if (!t.c) {
+                t.c = new Map();
+            }
+            const c0 = t.c.get(key);
+            const cc = c0 || new Map();
+            if (!c0) {
+                t.c.set(key, cc);
+            }
+            const c1 = cc.get(obj);
+            const ccc = c1 || {};
+            if (!c1) {
+                cc.set(obj, ccc);
+            }
+            t = ccc;
+        }
+        if (t.v)
+            return t.v;
+        t.v = v;
+        return v;
+    }
+}
+exports.ShallowObjectCollection = ShallowObjectCollection;
+class Collection {
+    constructor() {
+        this.col = { contains: new Map() };
+    }
+    /**
+     * Add a plain object to the collection.
+     * The actual object used is returned.
+     * By adding the object to the collection, it is now owned by the collection.
+     * Do not add class objects.
+     * @param v any object or primitive
+     * @returns v or the matching object.
+     */
+    add(v) {
+        return addToCollection(this.col, v);
+    }
+}
+exports.Collection = Collection;
+// const objectLike: TypeMask = {
+//     array: true,
+//     object: true,
+// };
+function addToCollection(root, v) {
+    const known = root.contains;
+    function addValToCol(c, v) {
+        var _a;
+        const t = toValueType(v);
+        const val = c.v || Object.create(null);
+        const r = (_a = val[t]) !== null && _a !== void 0 ? _a : v;
+        val[t] = r;
+        c.v = val;
+        return val[t];
+    }
+    function walk(col, path) {
+        path = path.filter((entry) => entry[1] !== undefined).sort((a, b) => compare(a[0], b[0]));
+        for (const [k, v] of path) {
+            const c = col.c || Object.create(null);
+            col.c = c;
+            const m = c[k] || new Map();
+            c[k] = m;
+            const has = m.get(v);
+            col = has || Object.create(null);
+            if (!has) {
+                m.set(v, col);
+            }
+        }
+        return col;
+    }
+    function normalizeObjectEntries(entries) {
+        for (const entry of entries) {
+            entry[1] = add(entry[1]);
+        }
+        return entries;
+    }
+    function normalizeToPath(v) {
+        if (typeof v !== 'object' || !v) {
+            return [['', v]];
+        }
+        const entries = normalizeObjectEntries(Object.entries(v));
+        const obj = v;
+        if (!Object.isFrozen(v)) {
+            for (const [k, v] of entries) {
+                obj[k] = v;
+            }
+            Object.freeze(obj);
+        }
+        return entries;
+    }
+    function add(v) {
+        const isObjectLike = typeof v === 'object' && !!v;
+        if (isObjectLike) {
+            const cached = known.get(v);
+            if (cached !== undefined) {
+                return cached;
+            }
+            known.set(v, v);
+        }
+        const path = normalizeToPath(v);
+        const c = walk(root, path);
+        const r = addValToCol(c, v);
+        if (isObjectLike) {
+            known.set(v, r);
+        }
+        return r;
+    }
+    return add(v);
+}
+function toValueType(v) {
+    const t = typeof v;
+    if (t !== 'object')
+        return t;
+    if (v instanceof Array)
+        return 'array';
+    if (v === null)
+        return 'null';
+    return t;
+}
+//# sourceMappingURL=ObjectCollection.js.map

package/dist/util/fileHelper.d.ts

@@ -1,5 +1,6 @@
-import { GlobOptions } from './glob';
+/// <reference types="node" />
 import { CSpellUserSettings, Document, Issue } from 'cspell-lib';
+import { GlobOptions } from './glob';
 export interface ConfigInfo {
     source: string;
     config: CSpellUserSettings;
@@ -29,8 +30,8 @@ export declare function fileInfoToDocument(fileInfo: FileInfo, languageId: strin
 interface ReadFileInfoResult extends FileInfo {
     text: string;
 }
-export declare function readFileInfo(filename: string, encoding?: string, handleNotFound?: boolean): Promise<ReadFileInfoResult>;
-export declare function readFile(filename: string, encoding?: string): Promise<string>;
+export declare function readFileInfo(filename: string, encoding?: BufferEncoding, handleNotFound?: boolean): Promise<ReadFileInfoResult>;
+export declare function readFile(filename: string, encoding?: BufferEncoding): Promise<string>;
 /**
  * Looks for matching glob patterns or stdin
  * @param globPatterns patterns or stdin
@@ -43,7 +44,7 @@ export declare function calcFinalConfigInfo(configInfo: ConfigInfo, settingsFrom
  *   file will be resolved relative to the containing file.
  * @returns - a list of files to be processed.
  */
-export declare function readFileListFiles(listFiles: string[]): Promise<string[] | AsyncIterable<string>>;
+export declare function readFileListFiles(listFiles: string[]): AsyncIterable<string>;
 /**
  * Read a `listFile` and return the containing file paths resolved relative to the `listFile`.
  * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
@@ -51,5 +52,8 @@ export declare function readFileListFiles(listFiles: string[]): Promise<string[]
  * @returns - a list of files to be processed.
  */
 export declare function readFileListFile(listFile: string): Promise<string[]>;
+export declare function isFile(filename: string): Promise<boolean>;
+export declare function isDir(filename: string): Promise<boolean>;
+export declare function isNotDir(filename: string): Promise<boolean>;
 export {};
 //# sourceMappingURL=fileHelper.d.ts.map

package/dist/util/fileHelper.js

@@ -26,15 +26,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFileListFile = exports.readFileListFiles = exports.calcFinalConfigInfo = exports.findFiles = exports.readFile = exports.readFileInfo = exports.fileInfoToDocument = exports.readConfig = void 0;
+exports.isNotDir = exports.isDir = exports.isFile = exports.readFileListFile = exports.readFileListFiles = exports.calcFinalConfigInfo = exports.findFiles = exports.readFile = exports.readFileInfo = exports.fileInfoToDocument = exports.readConfig = void 0;
 const cspell = __importStar(require("cspell-lib"));
-const fsp = __importStar(require("fs-extra"));
+const cspell_lib_1 = require("cspell-lib");
+const fs_1 = require("fs");
 const get_stdin_1 = __importDefault(require("get-stdin"));
-const glob_1 = require("./glob");
 const path = __importStar(require("path"));
-const cspell_lib_1 = require("cspell-lib");
-const errors_1 = require("./errors");
 const async_1 = require("./async");
+const errors_1 = require("./errors");
+const glob_1 = require("./glob");
 const stdin_1 = require("./stdin");
 const UTF8 = 'utf8';
 const STDIN = 'stdin';
@@ -64,7 +64,7 @@ function fileInfoToDocument(fileInfo, languageId, locale) {
 }
 exports.fileInfoToDocument = fileInfoToDocument;
 function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
-    const pText = filename === STDIN ? (0, get_stdin_1.default)() : fsp.readFile(filename, encoding);
+    const pText = filename === STDIN ? (0, get_stdin_1.default)() : fs_1.promises.readFile(filename, encoding);
     return pText.then((text) => ({ text, filename }), (e) => {
         const error = (0, errors_1.toError)(e);
         return handleNotFound && error.code === 'EISDIR'
@@ -107,22 +107,27 @@ function calcFinalConfigInfo(configInfo, settingsFromCommandLine, filename, text
     };
 }
 exports.calcFinalConfigInfo = calcFinalConfigInfo;
+function resolveFilename(filename) {
+    return path.resolve(filename);
+}
+const resolveFilenames = (0, async_1.asyncMap)(resolveFilename);
 /**
  * Read
  * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
  *   file will be resolved relative to the containing file.
  * @returns - a list of files to be processed.
  */
-async function readFileListFiles(listFiles) {
+function readFileListFiles(listFiles) {
     let useStdin = false;
     const files = listFiles.filter((file) => {
         const isStdin = file === 'stdin';
         useStdin = useStdin || isStdin;
         return !isStdin;
     });
-    const found = flatten(await Promise.all(files.map(readFileListFile)));
+    const found = (0, async_1.asyncPipe)(files, (0, async_1.asyncMap)((file) => readFileListFile(file)), (0, async_1.asyncAwait)(), (0, async_1.asyncFlatten)());
     // Move `stdin` to the end.
-    return useStdin ? (0, async_1.mergeAsyncIterables)(found, (0, stdin_1.readStdin)()) : found;
+    const stdin = useStdin ? (0, stdin_1.readStdin)() : [];
+    return (0, async_1.asyncPipe)((0, async_1.mergeAsyncIterables)(found, stdin), resolveFilenames);
 }
 exports.readFileListFiles = readFileListFiles;
 /**
@@ -147,12 +152,28 @@ async function readFileListFile(listFile) {
     }
 }
 exports.readFileListFile = readFileListFile;
-function flatten(fileLists) {
-    function* f() {
-        for (const list of fileLists) {
-            yield* list;
-        }
+async function isFile(filename) {
+    try {
+        const stat = await fs_1.promises.stat(filename);
+        return stat.isFile();
+    }
+    catch (e) {
+        return false;
     }
-    return [...f()];
 }
+exports.isFile = isFile;
+async function isDir(filename) {
+    try {
+        const stat = await fs_1.promises.stat(filename);
+        return stat.isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isDir = isDir;
+function isNotDir(filename) {
+    return isDir(filename).then((a) => !a);
+}
+exports.isNotDir = isNotDir;
 //# sourceMappingURL=fileHelper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.19.5",
+  "version": "5.20.0",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -70,19 +70,19 @@
   },
   "homepage": "https://streetsidesoftware.github.io/cspell/",
   "dependencies": {
-    "@cspell/cspell-pipe": "^5.19.5",
+    "@cspell/cspell-pipe": "^5.20.0",
     "chalk": "^4.1.2",
-    "commander": "^9.1.0",
-    "cspell-gitignore": "^5.19.5",
-    "cspell-glob": "^5.19.5",
-    "cspell-lib": "^5.19.5",
+    "commander": "^9.2.0",
+    "cspell-gitignore": "^5.20.0",
+    "cspell-glob": "^5.20.0",
+    "cspell-lib": "^5.20.0",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
-    "fs-extra": "^10.0.1",
+    "fs-extra": "^10.1.0",
     "get-stdin": "^8.0.0",
-    "glob": "^7.2.0",
+    "glob": "^8.0.1",
     "imurmurhash": "^0.1.4",
-    "semver": "^7.3.5",
+    "semver": "^7.3.7",
     "strip-ansi": "^6.0.1",
     "vscode-uri": "^3.0.3"
   },
@@ -90,8 +90,8 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.19.5",
-    "@cspell/cspell-types": "^5.19.5",
+    "@cspell/cspell-json-reporter": "^5.20.0",
+    "@cspell/cspell-types": "^5.20.0",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
@@ -103,8 +103,8 @@
     "micromatch": "^4.0.5",
     "minimatch": "^5.0.1",
     "rimraf": "^3.0.2",
-    "rollup": "^2.70.1",
-    "rollup-plugin-dts": "^4.2.0"
+    "rollup": "^2.71.1",
+    "rollup-plugin-dts": "^4.2.1"
   },
-  "gitHead": "0d113f01b51c3bc149a01269878d4217a58ecb97"
+  "gitHead": "626dd9068d625c2100dee6a3fef4dea95ae83376"
 }

package/dist/util/cache/getConfigHash.d.ts

@@ -1,6 +0,0 @@
-import { ConfigInfo } from '../../util/fileHelper';
-/**
- * Hashes ConfigInfo and cspell version for using in DiskCache
- */
-export declare function getConfigHash(configInfo: ConfigInfo): string;
-//# sourceMappingURL=getConfigHash.d.ts.map

package/dist/util/cache/getConfigHash.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigHash = void 0;
-const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
-const path_1 = __importDefault(require("path"));
-const hash_1 = require("./hash");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { version } = require(path_1.default.join(__dirname, '..', '..', '..', 'package.json'));
-const configHashes = new WeakMap();
-/**
- * Hashes ConfigInfo and cspell version for using in DiskCache
- */
-function getConfigHash(configInfo) {
-    const cachedHash = configHashes.get(configInfo);
-    if (cachedHash !== undefined) {
-        return cachedHash;
-    }
-    const hashValue = (0, hash_1.hash)(`${version}_${(0, fast_json_stable_stringify_1.default)(configInfo)}`);
-    configHashes.set(configInfo, hashValue);
-    return hashValue;
-}
-exports.getConfigHash = getConfigHash;
-//# sourceMappingURL=getConfigHash.js.map

package/dist/util/cache/hash.d.ts

@@ -1,5 +0,0 @@
-/**
- * Hash the given string using MurmurHash3
- */
-export declare function hash(str: string): string;
-//# sourceMappingURL=hash.d.ts.map

package/dist/util/cache/hash.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hash = void 0;
-// cspell:word imurmurhash
-const imurmurhash_1 = __importDefault(require("imurmurhash"));
-/**
- * Hash the given string using MurmurHash3
- */
-function hash(str) {
-    return (0, imurmurhash_1.default)(str).result().toString(36);
-}
-exports.hash = hash;
-//# sourceMappingURL=hash.js.map