cspell-lib 6.1.3-alpha.1 → 6.2.0-alpha.1

package/dist/Models/CSpellSettingsInternalDef.d.ts

@@ -1,4 +1,4 @@
-import { CSpellSettingsWithSourceTrace, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionPreferred } from '@cspell/cspell-types';
+import { CSpellSettingsWithSourceTrace, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionPreferred, Parser } from '@cspell/cspell-types';
 import { WeightMap } from 'cspell-trie-lib';
 import { OptionalOrUndefined } from '../util/types';
 export declare const SymbolCSpellSettingsInternal: unique symbol;
@@ -7,6 +7,7 @@ export interface CSpellSettingsInternal extends Omit<CSpellSettingsWithSourceTra
     dictionaryDefinitions?: DictionaryDefinitionInternal[];
 }
 export interface CSpellSettingsInternalFinalized extends CSpellSettingsInternal {
+    parserFn: Parser | undefined;
     finalized: true;
     ignoreRegExpList: RegExp[];
     includeRegExpList: RegExp[];

package/dist/Settings/CSpellSettingsServer.js

@@ -228,7 +228,7 @@ function _finalizeSettings(settings) {
         finalized: true,
         ignoreRegExpList: (0, patterns_1.resolvePatterns)(settings.ignoreRegExpList, settings.patterns),
         includeRegExpList: (0, patterns_1.resolvePatterns)(settings.includeRegExpList, settings.patterns),
-        parser: resolveParser(settings),
+        parserFn: resolveParser(settings),
     };
     finalized.name = 'Finalized ' + (finalized.name || '');
     finalized.source = { name: settings.name || 'src', sources: [settings] };

package/dist/Settings/DictionarySettings.js

@@ -50,14 +50,17 @@ function fixPath(def) {
     if (def instanceof _DictionaryDefinitionInternalWithSource) {
         return def;
     }
-    const { path: filePath = '', file = '' } = def;
-    const newPath = !filePath && !file ? '' : path.join(filePath, file);
+    const newPath = fixDicPath(def.path, def.file);
     return {
         ...def,
         file: undefined,
         path: newPath,
     };
 }
+function fixDicPath(defPath, defFile) {
+    const parts = [defPath || '', defFile || ''].filter((p) => !!p);
+    return parts.length > 1 ? path.join(...parts) : parts[0] || '';
+}
 function mapDictDefsToInternal(defs, pathToSettingsFile) {
     return defs?.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
 }
@@ -103,7 +106,7 @@ class _DictionaryDefinitionInternalWithSource {
         const defAll = def;
         const { path: relPath = '', file = '', addWords, description, dictionaryInformation, type, repMap, noSuggest, scope, useCompounds, } = defAll;
         const defaultPath = path.dirname(__source);
-        const filePath = path.join(relPath, file);
+        const filePath = fixDicPath(relPath, file);
         const name = determineName(filePath, def);
         const r = (0, resolveFile_1.resolveFile)(filePath, defaultPath);
         const ddi = {

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,3 +1,4 @@
+import { Stats } from 'cspell-io';
 import { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
 import { SpellingDictionary } from './SpellingDictionary';
 export declare type LoadOptions = DictionaryDefinitionInternal;
@@ -49,37 +50,6 @@ export declare const testing: {
     loadEntry: typeof loadEntry;
     load: typeof load;
 };
-/**
- * Copied from the Node definition to avoid a dependency upon a specific version of Node
- */
-interface StatsBase<T> {
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isSymbolicLink(): boolean;
-    isFIFO(): boolean;
-    isSocket(): boolean;
-    dev: T;
-    ino: T;
-    mode: T;
-    nlink: T;
-    uid: T;
-    gid: T;
-    rdev: T;
-    size: T;
-    blksize: T;
-    blocks: T;
-    atimeMs: T;
-    mtimeMs: T;
-    ctimeMs: T;
-    birthtimeMs: T;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-}
-export declare type Stats = StatsBase<number>;
 export declare const __testing__: {
     debugLog: string[];
 };

package/dist/SpellingDictionary/DictionaryLoader.js

@@ -24,11 +24,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.testing = exports.refreshCacheEntries = exports.loadDictionarySync = exports.loadDictionary = void 0;
-const fs_1 = require("fs");
+const cspell_io_1 = require("cspell-io");
 const gensequence_1 = require("gensequence");
 const path = __importStar(require("path"));
 const util_1 = require("util");
-const errors_1 = require("../util/errors");
 const fileReader_1 = require("../util/fileReader");
 const createSpellingDictionary_1 = require("./createSpellingDictionary");
 const SpellingDictionaryError_1 = require("./SpellingDictionaryError");
@@ -120,7 +119,7 @@ async function refreshEntry(entry, maxAge, now) {
         // Write to the ts, so the next one will not do it.
         entry.sig = sig;
         entry.ts = now;
-        const pStat = getStat(entry.uri);
+        const pStat = (0, cspell_io_1.getStat)(entry.uri);
         const [newStat] = await Promise.all([pStat, entry.pending]);
         const hasChanged = !isEqual(newStat, entry.stat);
         const sigMatches = entry.sig === sig;
@@ -150,7 +149,7 @@ function isEqual(a, b) {
     if (isError(a)) {
         return isError(b) && a.message === b.message && a.name === b.name;
     }
-    return !isError(b) && (a.mtimeMs === b.mtimeMs || a.size === b.size);
+    return !isError(b) && a.mtimeMs === b.mtimeMs && a.size === b.size && a.eTag === b.eTag;
 }
 function isError(e) {
     const err = e;
@@ -158,7 +157,7 @@ function isError(e) {
 }
 function loadEntry(uri, options, now = Date.now()) {
     const pDictionary = load(uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
-    const pStat = getStat(uri);
+    const pStat = (0, cspell_io_1.getStat)(uri);
     const pending = Promise.all([pDictionary, pStat]);
     const sig = now + Math.random();
     const entry = {
@@ -181,7 +180,7 @@ function loadEntry(uri, options, now = Date.now()) {
     return entry;
 }
 function loadEntrySync(uri, options, now = Date.now()) {
-    const stat = getStatSync(uri);
+    const stat = (0, cspell_io_1.getStatSync)(uri);
     const sig = now + Math.random();
     try {
         const dictionary = loadSync(uri, options);
@@ -289,24 +288,6 @@ exports.testing = {
     loadEntry,
     load,
 };
-function toError(e) {
-    if ((0, errors_1.isErrnoException)(e))
-        return e;
-    if (e instanceof Error)
-        return e;
-    return new Error((0, util_1.format)(e));
-}
-function getStat(uri) {
-    return fs_1.promises.stat(uri).catch((e) => toError(e));
-}
-function getStatSync(uri) {
-    try {
-        return (0, fs_1.statSync)(uri);
-    }
-    catch (e) {
-        return toError(e);
-    }
-}
 exports.__testing__ = {
     debugLog,
 };

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -2,8 +2,8 @@ import type { ReplaceMap, DictionaryInformation } from '@cspell/cspell-types';
 import { CompoundWordsMethod, SuggestionCollector, SuggestionResult, WeightMap } from 'cspell-trie-lib';
 export { CompoundWordsMethod, SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
 export interface SearchOptions {
-    useCompounds?: boolean | number;
-    ignoreCase?: boolean;
+    useCompounds?: boolean | number | undefined;
+    ignoreCase?: boolean | undefined;
 }
 export interface SuggestOptions {
     /**

package/dist/SpellingDictionary/SpellingDictionaryMethods.d.ts

@@ -5,7 +5,7 @@ export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
 export declare type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
 export declare type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
 export declare const defaultNumSuggestions = 10;
-export declare function wordSearchFormsArray(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): string[];
+declare function wordSearchFormsArray(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): string[];
 export declare function wordSearchForms(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): Set<string>;
 export declare function wordSuggestFormsArray(word: string): string[];
 export declare function wordSuggestForms(word: string): Set<string>;
@@ -20,7 +20,7 @@ export declare function suggestArgsToSuggestOptions(args: SuggestArgs): SuggestO
 export declare function createWeightMapFromDictionaryInformation(di: undefined): undefined;
 export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation): WeightMap;
 export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation | undefined): WeightMap | undefined;
-export declare const __testMethods: {
+export declare const __testMethods__: {
     wordSearchForms: typeof wordSearchForms;
     wordSearchFormsArray: typeof wordSearchFormsArray;
     wordDictionaryForms: typeof wordDictionaryForms;

package/dist/SpellingDictionary/SpellingDictionaryMethods.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testMethods = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.hasOptionToSearchOption = exports.wordDictionaryFormsCollector = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.wordSearchFormsArray = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
+exports.__testMethods__ = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.hasOptionToSearchOption = exports.wordDictionaryFormsCollector = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const trie_util_1 = require("cspell-trie-lib/dist/lib/trie-util");
 const gensequence_1 = require("gensequence");
@@ -12,7 +12,6 @@ exports.defaultNumSuggestions = 10;
 function wordSearchFormsArray(word, isDictionaryCaseSensitive, ignoreCase) {
     return [...wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase)];
 }
-exports.wordSearchFormsArray = wordSearchFormsArray;
 function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
     const forms = new Set();
     word = word.normalize('NFC');
@@ -82,8 +81,9 @@ function wordDictionaryFormsCollector(prefixNoCase) {
     };
 }
 exports.wordDictionaryFormsCollector = wordDictionaryFormsCollector;
+const DEFAULT_HAS_OPTIONS = Object.freeze({});
 function hasOptionToSearchOption(opt) {
-    return !opt ? {} : opt;
+    return !opt ? DEFAULT_HAS_OPTIONS : opt;
 }
 exports.hasOptionToSearchOption = hasOptionToSearchOption;
 function suggestArgsToSuggestOptions(args) {
@@ -105,7 +105,7 @@ function createWeightMapFromDictionaryInformation(di) {
     return di ? (0, cspell_trie_lib_1.mapDictionaryInformationToWeightMap)(di) : undefined;
 }
 exports.createWeightMapFromDictionaryInformation = createWeightMapFromDictionaryInformation;
-exports.__testMethods = {
+exports.__testMethods__ = {
     wordSearchForms,
     wordSearchFormsArray,
     wordDictionaryForms,

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import * as Link from './Settings/index.link';
 import { SpellingDictionaryCollection } from './SpellingDictionary';
 import * as Text from './util/text';
 export * from '@cspell/cspell-types';
-export * from 'cspell-io';
+export { asyncIterableToArray, readFile, readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from 'cspell-io';
 export { ExcludeFilesGlobMap, ExclusionFunction } from './exclusionHelper';
 export { getLanguagesForExt } from './LanguageIds';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument';

package/dist/index.js

@@ -26,7 +26,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionary = exports.clearCachedFiles = exports.ExclusionHelper = exports.Link = exports.Text = exports.validateText = exports.IncludeExcludeFlag = exports.checkText = exports.resolveFile = exports.setLogger = exports.getLogger = exports.traceWordsAsync = exports.traceWords = exports.DocumentValidator = exports.suggestionsForWords = exports.suggestionsForWord = exports.SuggestionError = exports.SpellingDictionaryLoadError = exports.SpellingDictionaryCollection = exports.refreshDictionaryCache = exports.isSpellingDictionaryLoadError = exports.createSpellingDictionary = exports.CompoundWordsMethod = exports.spellCheckFile = exports.spellCheckDocument = exports.isBinaryFile = exports.fileToDocument = exports.determineFinalDocumentSettings = exports.constructSettingsForText = exports.combineTextAndLanguageSettings = exports.defaultSettingsFilename = exports.updateTextDocument = exports.createTextDocument = exports.getLanguagesForExt = void 0;
+exports.getDictionary = exports.clearCachedFiles = exports.ExclusionHelper = exports.Link = exports.Text = exports.validateText = exports.IncludeExcludeFlag = exports.checkText = exports.resolveFile = exports.setLogger = exports.getLogger = exports.traceWordsAsync = exports.traceWords = exports.DocumentValidator = exports.suggestionsForWords = exports.suggestionsForWord = exports.SuggestionError = exports.SpellingDictionaryLoadError = exports.SpellingDictionaryCollection = exports.refreshDictionaryCache = exports.isSpellingDictionaryLoadError = exports.createSpellingDictionary = exports.CompoundWordsMethod = exports.spellCheckFile = exports.spellCheckDocument = exports.isBinaryFile = exports.fileToDocument = exports.determineFinalDocumentSettings = exports.constructSettingsForText = exports.combineTextAndLanguageSettings = exports.defaultSettingsFilename = exports.updateTextDocument = exports.createTextDocument = exports.getLanguagesForExt = exports.writeToFileIterableP = exports.writeToFileIterable = exports.writeToFile = exports.readFileSync = exports.readFile = exports.asyncIterableToArray = void 0;
 const ExclusionHelper = __importStar(require("./exclusionHelper"));
 exports.ExclusionHelper = ExclusionHelper;
 const Settings_1 = require("./Settings");
@@ -37,7 +37,13 @@ const SpellingDictionary_1 = require("./SpellingDictionary");
 const Text = __importStar(require("./util/text"));
 exports.Text = Text;
 __exportStar(require("@cspell/cspell-types"), exports);
-__exportStar(require("cspell-io"), exports);
+var cspell_io_1 = require("cspell-io");
+Object.defineProperty(exports, "asyncIterableToArray", { enumerable: true, get: function () { return cspell_io_1.asyncIterableToArray; } });
+Object.defineProperty(exports, "readFile", { enumerable: true, get: function () { return cspell_io_1.readFile; } });
+Object.defineProperty(exports, "readFileSync", { enumerable: true, get: function () { return cspell_io_1.readFileSync; } });
+Object.defineProperty(exports, "writeToFile", { enumerable: true, get: function () { return cspell_io_1.writeToFile; } });
+Object.defineProperty(exports, "writeToFileIterable", { enumerable: true, get: function () { return cspell_io_1.writeToFileIterable; } });
+Object.defineProperty(exports, "writeToFileIterableP", { enumerable: true, get: function () { return cspell_io_1.writeToFileIterableP; } });
 var LanguageIds_1 = require("./LanguageIds");
 Object.defineProperty(exports, "getLanguagesForExt", { enumerable: true, get: function () { return LanguageIds_1.getLanguagesForExt; } });
 var TextDocument_1 = require("./Models/TextDocument");

package/dist/textValidation/ValidationTypes.d.ts

@@ -0,0 +1,41 @@
+import { MappedText, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
+export declare type TextOffsetRO = Readonly<TextOffsetRW>;
+export interface ValidationOptions extends IncludeExcludeOptions {
+    maxNumberOfProblems?: number;
+    maxDuplicateProblems?: number;
+    minWordLength?: number;
+    flagWords?: string[];
+    allowCompoundWords?: boolean;
+    /** ignore case when checking words against dictionary or ignore words list */
+    ignoreCase: boolean;
+}
+export interface CheckOptions extends ValidationOptions {
+    allowCompoundWords: boolean;
+    ignoreCase: boolean;
+}
+export interface IncludeExcludeOptions {
+    ignoreRegExpList?: RegExp[];
+    includeRegExpList?: RegExp[];
+}
+export interface WordRangeAcc {
+    textOffset: TextOffsetRO;
+    isIncluded: boolean;
+    rangePos: number;
+}
+export interface ValidationResult extends TextOffsetRW {
+    line: TextOffsetRW;
+    isFlagged?: boolean | undefined;
+    isFound?: boolean | undefined;
+}
+export declare type ValidationResultRO = Readonly<ValidationResult>;
+export declare type LineValidator = (line: LineSegment) => Iterable<ValidationResult>;
+export interface LineSegment {
+    line: TextOffsetRO;
+    segment: TextOffsetRO;
+}
+export interface MappedTextValidationResult extends MappedText {
+    isFlagged?: boolean | undefined;
+    isFound?: boolean | undefined;
+}
+export declare type TextValidator = (text: MappedText) => Iterable<MappedTextValidationResult>;
+//# sourceMappingURL=ValidationTypes.d.ts.map

package/dist/textValidation/ValidationTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ValidationTypes.js.map

package/dist/textValidation/docValidator.d.ts

@@ -1,10 +1,11 @@
-import type { CSpellUserSettings, ParsedText } from '@cspell/cspell-types';
+import type { CSpellUserSettings, MappedText, ParsedText } from '@cspell/cspell-types';
 import { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef';
 import { TextDocument } from '../Models/TextDocument';
 import { SpellingDictionaryCollection } from '../SpellingDictionary';
 import { MatchRange } from '../util/TextRange';
 import { SimpleRange } from './parsedText';
-import { LineValidator, ValidationOptions, type LineSegment } from './textValidator';
+import type { TextValidator } from './ValidationTypes';
+import { ValidationOptions } from './ValidationTypes';
 import { ValidateTextOptions, ValidationIssue } from './validator';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
     /**
@@ -81,8 +82,8 @@ interface Preparations {
     docSettings: CSpellSettingsInternal;
     finalSettings: CSpellSettingsInternalFinalized;
     includeRanges: MatchRange[];
-    lineValidator: LineValidator;
-    segmenter: (lineSegment: LineSegment) => LineSegment[];
+    textValidator: TextValidator;
+    segmenter: (texts: MappedText) => Iterable<MappedText>;
     shouldCheck: boolean;
     validateOptions: ValidationOptions;
     localConfig: CSpellUserSettings | undefined;

package/dist/textValidation/docValidator.js

@@ -17,6 +17,8 @@ const simpleCache_1 = require("../util/simpleCache");
 const timer_1 = require("../util/timer");
 const util_1 = require("../util/util");
 const determineTextDocumentSettings_1 = require("./determineTextDocumentSettings");
+const lineValidatorFactory_1 = require("./lineValidatorFactory");
+const parsedText_1 = require("./parsedText");
 const textValidator_1 = require("./textValidator");
 const validator_1 = require("./validator");
 const ERROR_NOT_PREPARED = 'Validator Must be prepared before calling this function.';
@@ -64,8 +66,8 @@ class DocumentValidator {
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
-        const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
-        const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
+        const segmenter = (0, parsedText_1.createMappedTextSegmenter)(includeRanges);
+        const textValidator = (0, lineValidatorFactory_1.textValidatorFactory)(dict, validateOptions);
         this._preparations = {
             config,
             dictionary: dict,
@@ -75,7 +77,7 @@ class DocumentValidator {
             validateOptions,
             includeRanges,
             segmenter,
-            lineValidator,
+            textValidator,
             localConfig,
             localConfigFilepath: localConfig?.__importRef?.filename,
         };
@@ -112,8 +114,8 @@ class DocumentValidator {
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
-        const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
-        const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
+        const segmenter = (0, parsedText_1.createMappedTextSegmenter)(includeRanges);
+        const textValidator = (0, lineValidatorFactory_1.textValidatorFactory)(dict, validateOptions);
         this._preparations = {
             config,
             dictionary: dict,
@@ -123,7 +125,7 @@ class DocumentValidator {
             validateOptions,
             includeRanges,
             segmenter,
-            lineValidator,
+            textValidator,
             localConfig,
             localConfigFilepath: localConfig?.__importRef?.filename,
         };
@@ -140,8 +142,8 @@ class DocumentValidator {
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
-        const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
-        const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
+        const segmenter = (0, parsedText_1.createMappedTextSegmenter)(includeRanges);
+        const textValidator = (0, lineValidatorFactory_1.textValidatorFactory)(dict, validateOptions);
         this._preparations = {
             ...prep,
             dictionary: dict,
@@ -150,7 +152,7 @@ class DocumentValidator {
             validateOptions,
             includeRanges,
             segmenter,
-            lineValidator,
+            textValidator,
         };
         this._preparationTime = timer.elapsed();
     }
@@ -167,22 +169,23 @@ class DocumentValidator {
     check(parsedText) {
         (0, assert_1.default)(this._ready);
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
-        const { range, text } = parsedText;
-        const { segmenter, lineValidator } = this._preparations;
+        const { segmenter, textValidator } = this._preparations;
         // Determine settings for text range
         // Slice text based upon include ranges
         // Check text against dictionaries.
-        const offset = range[0];
-        const line = this._document.lineAt(offset);
-        const lineSeg = {
-            line,
-            segment: {
-                text,
-                offset,
-            },
-        };
-        const aIssues = (0, cspell_pipe_1.pipeSync)(segmenter(lineSeg), (0, cspell_pipe_1.opConcatMap)(lineValidator));
-        const issues = [...aIssues];
+        const document = this._document;
+        let line = undefined;
+        function mapToIssue(issue) {
+            const { range, text, isFlagged, isFound } = issue;
+            const offset = range[0];
+            const length = range[1] - range[0];
+            (0, assert_1.default)(!line || line.offset <= offset);
+            if (!line || line.offset + line.text.length <= offset) {
+                line = document.lineAt(offset);
+            }
+            return { text, offset, line, length, isFlagged, isFound };
+        }
+        const issues = [...(0, cspell_pipe_1.pipeSync)(segmenter(parsedText), (0, cspell_pipe_1.opConcatMap)(textValidator), (0, cspell_pipe_1.opMap)(mapToIssue))];
         if (!this.options.generateSuggestions) {
             return issues;
         }
@@ -253,7 +256,7 @@ class DocumentValidator {
     }
     _parse() {
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
-        const parser = this._preparations.finalSettings.parser;
+        const parser = this._preparations.finalSettings.parserFn;
         if (typeof parser !== 'object')
             return this.defaultParser();
         return parser.parse(this.document.text, this.document.uri.path).parsedTexts;

package/dist/textValidation/index.d.ts

@@ -1,5 +1,5 @@
 export { calcTextInclusionRanges } from './textValidator';
-export type { CheckOptions, IncludeExcludeOptions, ValidationOptions, ValidationResult } from './textValidator';
+export type { CheckOptions, IncludeExcludeOptions, ValidationOptions, ValidationResult } from './ValidationTypes';
 export { checkText, IncludeExcludeFlag, validateText } from './validator';
 export type { CheckTextInfo, TextInfoItem, ValidateTextOptions, ValidationIssue } from './validator';
 export { DocumentValidator } from './docValidator';

package/dist/textValidation/isWordValid.d.ts

@@ -0,0 +1,12 @@
+import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionary';
+import { TextOffsetRO } from './ValidationTypes';
+export interface IsWordValidOptions {
+    ignoreCase: boolean;
+    useCompounds: boolean | undefined;
+}
+export declare function hasWordCheck(dict: SpellingDictionary, word: string, options: IsWordValidOptions): boolean;
+export declare function isWordValidWithEscapeRetry(dict: SpellingDictionary, wo: TextOffsetRO, line: TextOffsetRO, options: IsWordValidOptions): boolean;
+export declare const __testing__: {
+    hasWordCheck: typeof hasWordCheck;
+};
+//# sourceMappingURL=isWordValid.d.ts.map

package/dist/textValidation/isWordValid.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.isWordValidWithEscapeRetry = exports.hasWordCheck = void 0;
+function hasWordCheck(dict, word, options) {
+    word = word.replace(/\\/g, '');
+    return dict.has(word, options);
+}
+exports.hasWordCheck = hasWordCheck;
+function isWordValidWithEscapeRetry(dict, wo, line, options) {
+    const firstTry = hasWordCheck(dict, wo.text, options);
+    return (firstTry ||
+        // Drop the first letter if it is preceded by a '\'.
+        (line.text[wo.offset - line.offset - 1] === '\\' && hasWordCheck(dict, wo.text.slice(1), options)));
+}
+exports.isWordValidWithEscapeRetry = isWordValidWithEscapeRetry;
+exports.__testing__ = {
+    hasWordCheck,
+};
+//# sourceMappingURL=isWordValid.js.map

package/dist/textValidation/lineValidatorFactory.d.ts

@@ -0,0 +1,5 @@
+import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionary';
+import type { LineValidator, TextValidator, ValidationOptions } from './ValidationTypes';
+export declare function lineValidatorFactory(dict: SpellingDictionary, options: ValidationOptions): LineValidator;
+export declare function textValidatorFactory(dict: SpellingDictionary, options: ValidationOptions): TextValidator;
+//# sourceMappingURL=lineValidatorFactory.d.ts.map

package/dist/textValidation/lineValidatorFactory.js

@@ -0,0 +1,145 @@
+"use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textValidatorFactory = exports.lineValidatorFactory = void 0;
+const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const gensequence_1 = require("gensequence");
+const RxPat = __importStar(require("../Settings/RegExpPatterns"));
+const Text = __importStar(require("../util/text"));
+const util_1 = require("../util/util");
+const wordSplitter_1 = require("../util/wordSplitter");
+const textValidator_1 = require("./textValidator");
+const isWordValid_1 = require("./isWordValid");
+const parsedText_1 = require("./parsedText");
+function lineValidatorFactory(dict, options) {
+    const { minWordLength = textValidator_1.defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, } = options;
+    const hasWordOptions = {
+        ignoreCase,
+        useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
+    };
+    const dictCol = dict;
+    const setOfFlagWords = new Set(flagWords);
+    const setOfKnownSuccessfulWords = new Set();
+    const rememberFilter = (fn) => (v) => {
+        const keep = fn(v);
+        if (!keep) {
+            setOfKnownSuccessfulWords.add(v.text);
+        }
+        return keep;
+    };
+    const filterAlreadyChecked = (wo) => {
+        return !setOfKnownSuccessfulWords.has(wo.text);
+    };
+    function testForFlaggedWord(wo) {
+        const text = wo.text;
+        return setOfFlagWords.has(text) || setOfFlagWords.has(text.toLowerCase()) || dictCol.isForbidden(text);
+    }
+    function isWordIgnored(word) {
+        return dict.isNoSuggestWord(word, options);
+    }
+    function isWordFlagged(word) {
+        const isIgnored = isWordIgnored(word.text);
+        const isFlagged = !isIgnored && testForFlaggedWord(word);
+        return isFlagged;
+    }
+    function checkFlagWords(word) {
+        word.isFlagged = isWordFlagged(word);
+        return word;
+    }
+    function checkWord(word, options) {
+        const isIgnored = isWordIgnored(word.text);
+        const { isFlagged = !isIgnored && testForFlaggedWord(word) } = word;
+        const isFound = isFlagged
+            ? undefined
+            : isIgnored || (0, isWordValid_1.isWordValidWithEscapeRetry)(dictCol, word, word.line, options);
+        return (0, util_1.clean)({ ...word, isFlagged, isFound });
+    }
+    const fn = (lineSegment) => {
+        function splitterIsValid(word) {
+            return (setOfKnownSuccessfulWords.has(word.text) ||
+                (!testForFlaggedWord(word) &&
+                    (0, isWordValid_1.isWordValidWithEscapeRetry)(dictCol, word, lineSegment.line, hasWordOptions)));
+        }
+        function checkFullWord(vr) {
+            if (vr.isFlagged) {
+                return [vr];
+            }
+            const codeWordResults = (0, cspell_pipe_1.toArray)((0, cspell_pipe_1.pipeSync)(Text.extractWordsFromCodeTextOffset(vr), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opMap)((t) => ({ ...t, line: vr.line })), (0, cspell_pipe_1.opMap)(checkFlagWords), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, cspell_pipe_1.opMap)((wo) => (wo.isFlagged ? wo : checkWord(wo, hasWordOptions))), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
+            // get back the original text.
+            (0, cspell_pipe_1.opMap)((wo) => ({
+                ...wo,
+                text: Text.extractText(lineSegment.segment, wo.offset, wo.offset + wo.text.length),
+            }))));
+            if (!codeWordResults.length || isWordIgnored(vr.text) || checkWord(vr, hasWordOptions).isFound) {
+                rememberFilter((_) => false)(vr);
+                return [];
+            }
+            return codeWordResults;
+        }
+        function checkPossibleWords(possibleWord) {
+            if (isWordFlagged(possibleWord)) {
+                const vr = {
+                    ...possibleWord,
+                    line: lineSegment.line,
+                    isFlagged: true,
+                };
+                return [vr];
+            }
+            const mismatches = (0, cspell_pipe_1.toArray)((0, cspell_pipe_1.pipeSync)(Text.extractWordsFromTextOffset(possibleWord), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opMap)((wo) => ({ ...wo, line: lineSegment.line })), (0, cspell_pipe_1.opMap)(checkFlagWords), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, cspell_pipe_1.opConcatMap)(checkFullWord)));
+            if (mismatches.length) {
+                // Try the more expensive word splitter
+                const splitResult = (0, wordSplitter_1.split)(lineSegment.segment, possibleWord.offset, splitterIsValid);
+                const nonMatching = splitResult.words.filter((w) => !w.isFound);
+                if (nonMatching.length < mismatches.length) {
+                    return nonMatching.map((w) => ({ ...w, line: lineSegment.line })).map(checkFlagWords);
+                }
+            }
+            return mismatches;
+        }
+        const checkedPossibleWords = (0, gensequence_1.genSequence)((0, cspell_pipe_1.pipeSync)(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opConcatMap)(checkPossibleWords)));
+        return checkedPossibleWords;
+    };
+    return fn;
+}
+exports.lineValidatorFactory = lineValidatorFactory;
+function textValidatorFactory(dict, options) {
+    const lineValidator = lineValidatorFactory(dict, options);
+    function validator(pText) {
+        const { text, range: srcRange, map } = pText;
+        const srcOffset = srcRange[0];
+        const segment = { text, offset: 0 };
+        const lineSegment = { line: segment, segment };
+        function mapBackToOriginSimple(vr) {
+            const { text, offset, isFlagged, isFound } = vr;
+            const r = (0, parsedText_1.mapRangeBackToOriginalPos)([offset, offset + text.length], map);
+            const range = [r[0] + srcOffset, r[1] + srcOffset];
+            return { text, range, isFlagged, isFound };
+        }
+        return [...lineValidator(lineSegment)].map(mapBackToOriginSimple);
+    }
+    return validator;
+}
+exports.textValidatorFactory = textValidatorFactory;
+//# sourceMappingURL=lineValidatorFactory.js.map

package/dist/textValidation/parsedText.d.ts

@@ -1,7 +1,15 @@
-import { ParsedText } from '@cspell/cspell-types';
+import { MappedText } from '@cspell/cspell-types';
 import { ValidationIssue } from './validator';
+import * as TextRange from '../util/TextRange';
 export declare type Offset = number;
 export declare type SimpleRange = readonly [Offset, Offset];
-export declare function mapIssueBackToOriginalPos(parsedText: ParsedText, issue: ValidationIssue): ValidationIssue;
-export declare function mapRangeBackToOriginalPos(offRange: SimpleRange, map: number[]): SimpleRange;
+export declare function mapIssueBackToOriginalPos(mappedText: MappedText, issue: ValidationIssue): ValidationIssue;
+export declare function mapRangeBackToOriginalPos(offRange: SimpleRange, map: number[] | undefined): SimpleRange;
+export declare function mapRangeToLocal(rangeOrig: SimpleRange, map: number[] | undefined): SimpleRange;
+/**
+ * Factory to create a segmentation function that will segment MappedText against a set of includeRanges.
+ * The function produced is optimized for forward scanning. It will perform poorly for randomly ordered offsets.
+ * @param includeRanges Allowed ranges for words.
+ */
+export declare function createMappedTextSegmenter(includeRanges: TextRange.MatchRange[]): (text: MappedText) => Iterable<MappedText>;
 //# sourceMappingURL=parsedText.d.ts.map

package/dist/textValidation/parsedText.js

@@ -1,24 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapRangeBackToOriginalPos = exports.mapIssueBackToOriginalPos = void 0;
-function mapIssueBackToOriginalPos(parsedText, issue) {
-    if (!parsedText.map || parsedText.map.length === 0)
+exports.createMappedTextSegmenter = exports.mapRangeToLocal = exports.mapRangeBackToOriginalPos = exports.mapIssueBackToOriginalPos = void 0;
+const TextMap_1 = require("../util/TextMap");
+function mapIssueBackToOriginalPos(mappedText, issue) {
+    if (!mappedText.map || mappedText.map.length === 0)
         return issue;
-    const textOff = mapTextOffsetBackToOriginalPos(parsedText, issue);
+    const textOff = mapTextOffsetBackToOriginalPos(mappedText, issue);
     return {
         ...issue,
         ...textOff,
     };
 }
 exports.mapIssueBackToOriginalPos = mapIssueBackToOriginalPos;
-function mapTextOffsetBackToOriginalPos(parsedText, textOff) {
-    if (!parsedText.map || !parsedText.map.length)
+function mapTextOffsetBackToOriginalPos(mappedText, textOff) {
+    if (!mappedText.map || !mappedText.map.length)
         return textOff;
-    const off = textOff.offset - parsedText.range[0];
-    const range = mapRangeBackToOriginalPos([off, off + (textOff.length ?? textOff.text.length)], parsedText.map);
+    const off = textOff.offset - mappedText.range[0];
+    const range = mapRangeBackToOriginalPos([off, off + (textOff.length ?? textOff.text.length)], mappedText.map);
     return {
         text: textOff.text,
-        offset: parsedText.range[0] + range[0],
+        offset: mappedText.range[0] + range[0],
         length: range[1] - range[0],
     };
 }
@@ -42,4 +43,68 @@ function mapRangeBackToOriginalPos(offRange, map) {
     return [iA, iB];
 }
 exports.mapRangeBackToOriginalPos = mapRangeBackToOriginalPos;
+function mapRangeToLocal(rangeOrig, map) {
+    if (!map || !map.length)
+        return rangeOrig;
+    const [start, end] = rangeOrig;
+    let i = 0, j = 0, p = 0;
+    while (p < map.length && map[p] < start) {
+        i = map[p];
+        j = map[p + 1];
+        p += 2;
+    }
+    const jA = start - i + j;
+    while (p < map.length && map[p] < end) {
+        i = map[p];
+        j = map[p + 1];
+        p += 2;
+    }
+    const jB = end - i + j;
+    return [jA, jB];
+}
+exports.mapRangeToLocal = mapRangeToLocal;
+/**
+ * Factory to create a segmentation function that will segment MappedText against a set of includeRanges.
+ * The function produced is optimized for forward scanning. It will perform poorly for randomly ordered offsets.
+ * @param includeRanges Allowed ranges for words.
+ */
+function createMappedTextSegmenter(includeRanges) {
+    let rangePos = 0;
+    function* segmenter(pText) {
+        if (!includeRanges.length) {
+            return;
+        }
+        const range = pText.range;
+        const textEndPos = range[1];
+        let textStartPos = range[0];
+        while (rangePos && (rangePos >= includeRanges.length || includeRanges[rangePos].startPos > textStartPos)) {
+            rangePos -= 1;
+        }
+        const cur = includeRanges[rangePos];
+        if (textEndPos <= cur.endPos && textStartPos >= cur.startPos) {
+            yield pText;
+            return;
+        }
+        while (textStartPos < textEndPos) {
+            while (includeRanges[rangePos] && includeRanges[rangePos].endPos <= textStartPos) {
+                rangePos += 1;
+            }
+            if (!includeRanges[rangePos]) {
+                break;
+            }
+            const { startPos, endPos } = includeRanges[rangePos];
+            if (textEndPos < startPos) {
+                break;
+            }
+            const a = Math.max(textStartPos, startPos);
+            const b = Math.min(textEndPos, endPos);
+            if (a !== b) {
+                yield (0, TextMap_1.extractTextMapRangeOrigin)(pText, [a, b]);
+            }
+            textStartPos = b;
+        }
+    }
+    return segmenter;
+}
+exports.createMappedTextSegmenter = createMappedTextSegmenter;
 //# sourceMappingURL=parsedText.js.map

package/dist/textValidation/textValidator.d.ts

@@ -1,53 +1,17 @@
-import type { TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 import { Sequence } from 'gensequence';
 import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionary';
 import * as TextRange from '../util/TextRange';
-declare type TextOffsetRO = Readonly<TextOffsetRW>;
-export interface ValidationOptions extends IncludeExcludeOptions {
-    maxNumberOfProblems?: number;
-    maxDuplicateProblems?: number;
-    minWordLength?: number;
-    flagWords?: string[];
-    allowCompoundWords?: boolean;
-    /** ignore case when checking words against dictionary or ignore words list */
-    ignoreCase: boolean;
-}
-export interface CheckOptions extends ValidationOptions {
-    allowCompoundWords: boolean;
-    ignoreCase: boolean;
-}
-export interface IncludeExcludeOptions {
-    ignoreRegExpList?: RegExp[];
-    includeRegExpList?: RegExp[];
-}
-export interface WordRangeAcc {
-    textOffset: TextOffsetRO;
-    isIncluded: boolean;
-    rangePos: number;
-}
-export interface ValidationResult extends TextOffsetRW {
-    line: TextOffsetRW;
-    isFlagged?: boolean;
-    isFound?: boolean;
-}
+import { IncludeExcludeOptions, LineSegment, ValidationOptions, ValidationResult } from './ValidationTypes';
 export declare const defaultMaxNumberOfProblems = 200;
 export declare const defaultMaxDuplicateProblems = 5;
 export declare const defaultMinWordLength = 4;
 export declare const minWordSplitLen = 3;
+/**
+ * @deprecated
+ * @deprecation Use spellCheckDocument
+ */
 export declare function validateText(text: string, dict: SpellingDictionary, options: ValidationOptions): Sequence<ValidationResult>;
 export declare function calcTextInclusionRanges(text: string, options: IncludeExcludeOptions): TextRange.MatchRange[];
-export interface LineSegment {
-    line: TextOffsetRO;
-    segment: TextOffsetRO;
-}
-export declare type LineValidator = (line: LineSegment) => Iterable<ValidationResult>;
-export declare function lineValidatorFactory(dict: SpellingDictionary, options: ValidationOptions): LineValidator;
-export declare function isWordValid(dict: SpellingDictionary, wo: TextOffsetRO, line: TextOffsetRO, options: HasWordOptions): boolean;
-export interface HasWordOptions {
-    ignoreCase: boolean;
-    useCompounds: boolean | undefined;
-}
-export declare function hasWordCheck(dict: SpellingDictionary, word: string, options: HasWordOptions): boolean;
 /**
  * Returns a mapper function that will segment a TextOffset based upon the includeRanges.
  * This function is optimized for forward scanning. It will perform poorly for randomly ordered offsets.
@@ -57,5 +21,4 @@ export declare function mapLineSegmentAgainstRangesFactory(includeRanges: TextRa
 export declare const _testMethods: {
     mapWordsAgainstRanges: typeof mapLineSegmentAgainstRangesFactory;
 };
-export {};
 //# sourceMappingURL=textValidator.d.ts.map

package/dist/textValidation/textValidator.js

@@ -23,23 +23,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._testMethods = exports.mapLineSegmentAgainstRangesFactory = exports.hasWordCheck = exports.isWordValid = exports.lineValidatorFactory = exports.calcTextInclusionRanges = exports.validateText = exports.minWordSplitLen = exports.defaultMinWordLength = exports.defaultMaxDuplicateProblems = exports.defaultMaxNumberOfProblems = void 0;
+exports._testMethods = exports.mapLineSegmentAgainstRangesFactory = exports.calcTextInclusionRanges = exports.validateText = exports.minWordSplitLen = exports.defaultMinWordLength = exports.defaultMaxDuplicateProblems = exports.defaultMaxNumberOfProblems = void 0;
 const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const gensequence_1 = require("gensequence");
-const RxPat = __importStar(require("../Settings/RegExpPatterns"));
 const Text = __importStar(require("../util/text"));
 const TextRange = __importStar(require("../util/TextRange"));
-const util_1 = require("../util/util");
-const wordSplitter_1 = require("../util/wordSplitter");
+const lineValidatorFactory_1 = require("./lineValidatorFactory");
 exports.defaultMaxNumberOfProblems = 200;
 exports.defaultMaxDuplicateProblems = 5;
 exports.defaultMinWordLength = 4;
 exports.minWordSplitLen = 3;
+/**
+ * @deprecated
+ * @deprecation Use spellCheckDocument
+ */
 function validateText(text, dict, options) {
     const { maxNumberOfProblems = exports.defaultMaxNumberOfProblems, maxDuplicateProblems = exports.defaultMaxDuplicateProblems } = options;
     const mapOfProblems = new Map();
     const includeRanges = calcTextInclusionRanges(text, options);
-    const validator = lineValidatorFactory(dict, options);
+    const validator = (0, lineValidatorFactory_1.lineValidatorFactory)(dict, options);
     const iter = (0, cspell_pipe_1.pipeSync)(Text.extractLinesOfText(text), (0, cspell_pipe_1.opConcatMap)(mapLineToLineSegments(includeRanges)), (0, cspell_pipe_1.opConcatMap)(validator), (0, cspell_pipe_1.opFilter)((wo) => {
         const word = wo.text;
         // Keep track of the number of times we have seen the same problem
@@ -59,114 +61,6 @@ function calcTextInclusionRanges(text, options) {
     return includeRanges;
 }
 exports.calcTextInclusionRanges = calcTextInclusionRanges;
-function lineValidatorFactory(dict, options) {
-    const { minWordLength = exports.defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, } = options;
-    const hasWordOptions = {
-        ignoreCase,
-        useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
-    };
-    const dictCol = dict;
-    const setOfFlagWords = new Set(flagWords);
-    const setOfKnownSuccessfulWords = new Set();
-    const rememberFilter = (fn) => (v) => {
-        const keep = fn(v);
-        if (!keep) {
-            setOfKnownSuccessfulWords.add(v.text);
-        }
-        return keep;
-    };
-    const filterAlreadyChecked = (wo) => {
-        return !setOfKnownSuccessfulWords.has(wo.text);
-    };
-    function testForFlaggedWord(wo) {
-        const text = wo.text;
-        return setOfFlagWords.has(text) || setOfFlagWords.has(text.toLowerCase()) || dictCol.isForbidden(text);
-    }
-    function isWordIgnored(word) {
-        return dict.isNoSuggestWord(word, options);
-    }
-    function isWordFlagged(word) {
-        const isIgnored = isWordIgnored(word.text);
-        const isFlagged = !isIgnored && testForFlaggedWord(word);
-        return isFlagged;
-    }
-    function checkFlagWords(word) {
-        word.isFlagged = isWordFlagged(word);
-        return word;
-    }
-    function checkWord(word, options) {
-        const isIgnored = isWordIgnored(word.text);
-        const { isFlagged = !isIgnored && testForFlaggedWord(word) } = word;
-        const isFound = isFlagged ? undefined : isIgnored || isWordValid(dictCol, word, word.line, options);
-        return (0, util_1.clean)({ ...word, isFlagged, isFound });
-    }
-    const fn = (lineSegment) => {
-        function splitterIsValid(word) {
-            return (setOfKnownSuccessfulWords.has(word.text) ||
-                (!testForFlaggedWord(word) && isWordValid(dictCol, word, lineSegment.line, hasWordOptions)));
-        }
-        function checkFullWord(vr) {
-            if (vr.isFlagged) {
-                return [vr];
-            }
-            const codeWordResults = (0, cspell_pipe_1.toArray)((0, cspell_pipe_1.pipeSync)(Text.extractWordsFromCodeTextOffset(vr), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opMap)((t) => ({ ...t, line: vr.line })), (0, cspell_pipe_1.opMap)(checkFlagWords), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, cspell_pipe_1.opMap)((wo) => (wo.isFlagged ? wo : checkWord(wo, hasWordOptions))), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), // Filter out any repeated characters like xxxxxxxxxx
-            // get back the original text.
-            (0, cspell_pipe_1.opMap)((wo) => ({
-                ...wo,
-                text: Text.extractText(lineSegment.segment, wo.offset, wo.offset + wo.text.length),
-            }))));
-            if (!codeWordResults.length || isWordIgnored(vr.text) || checkWord(vr, hasWordOptions).isFound) {
-                rememberFilter((_) => false)(vr);
-                return [];
-            }
-            return codeWordResults;
-        }
-        function checkPossibleWords(possibleWord) {
-            if (isWordFlagged(possibleWord)) {
-                const vr = {
-                    ...possibleWord,
-                    line: lineSegment.line,
-                    isFlagged: true,
-                };
-                return [vr];
-            }
-            const mismatches = (0, cspell_pipe_1.toArray)((0, cspell_pipe_1.pipeSync)(Text.extractWordsFromTextOffset(possibleWord), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opMap)((wo) => ({ ...wo, line: lineSegment.line })), (0, cspell_pipe_1.opMap)(checkFlagWords), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, cspell_pipe_1.opConcatMap)(checkFullWord)));
-            if (mismatches.length) {
-                // Try the more expensive word splitter
-                const splitResult = (0, wordSplitter_1.split)(lineSegment.segment, possibleWord.offset, splitterIsValid);
-                const nonMatching = splitResult.words.filter((w) => !w.isFound);
-                if (nonMatching.length < mismatches.length) {
-                    return nonMatching.map((w) => ({ ...w, line: lineSegment.line })).map(checkFlagWords);
-                }
-            }
-            return mismatches;
-        }
-        const checkedPossibleWords = (0, gensequence_1.genSequence)((0, cspell_pipe_1.pipeSync)(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opConcatMap)(checkPossibleWords)));
-        return checkedPossibleWords;
-    };
-    return fn;
-}
-exports.lineValidatorFactory = lineValidatorFactory;
-function isWordValid(dict, wo, line, options) {
-    const firstTry = hasWordCheck(dict, wo.text, options);
-    return (firstTry ||
-        // Drop the first letter if it is preceded by a '\'.
-        (line.text[wo.offset - line.offset - 1] === '\\' && hasWordCheck(dict, wo.text.slice(1), options)));
-}
-exports.isWordValid = isWordValid;
-function hasWordCheck(dict, word, options) {
-    word = word.replace(/\\/g, '');
-    // Do not pass allowCompounds down if it is false, that allows for the dictionary to override the value based upon its own settings.
-    return dict.has(word, convertCheckOptionsToHasOptions(options));
-}
-exports.hasWordCheck = hasWordCheck;
-function convertCheckOptionsToHasOptions(opt) {
-    const { ignoreCase, useCompounds } = opt;
-    return (0, util_1.clean)({
-        ignoreCase,
-        useCompounds,
-    });
-}
 function mapLineToLineSegments(includeRanges) {
     const mapAgainstRanges = mapLineSegmentAgainstRangesFactory(includeRanges);
     return (line) => {

package/dist/textValidation/validator.d.ts

@@ -1,6 +1,6 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
 import { CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef';
-import type { ValidationOptions, ValidationResult } from './textValidator';
+import type { ValidationOptions, ValidationResult } from './ValidationTypes';
 export declare const diagSource = "cSpell Checker";
 export interface ValidationIssue extends ValidationResult {
     suggestions?: string[];
@@ -11,6 +11,10 @@ export interface ValidateTextOptions {
     /** The number of suggestions to generate. The higher the number the longer it takes. */
     numSuggestions?: number;
 }
+/**
+ * @deprecated
+ * @deprecationMessage Use spellCheckDocument
+ */
 export declare function validateText(text: string, settings: CSpellUserSettings, options?: ValidateTextOptions): Promise<ValidationIssue[]>;
 export declare function settingsToValidateOptions(settings: CSpellSettingsInternalFinalized): ValidationOptions;
 export interface CheckTextInfo {

package/dist/textValidation/validator.js

@@ -30,6 +30,10 @@ const Memorizer_1 = require("../util/Memorizer");
 const util_1 = require("../util/util");
 const textValidator_1 = require("./textValidator");
 exports.diagSource = 'cSpell Checker';
+/**
+ * @deprecated
+ * @deprecationMessage Use spellCheckDocument
+ */
 async function validateText(text, settings, options = {}) {
     const finalSettings = Settings.finalizeSettings(settings);
     const dict = await (0, SpellingDictionary_1.getDictionaryInternal)(finalSettings);

package/dist/util/Memorizer.d.ts

@@ -48,11 +48,18 @@ export declare function memorizeLastCall<T, K0, K1, K2>(fn: (...p: [K0, K1, K2])
 export declare function memorizeLastCall<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
 export declare function memorizeLastCall<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
 /**
- * calls a function exactly once and always returns the same value.
+ * Creates a function that will call `fn` exactly once when invoked and remember the value returned.
+ * All subsequent calls will return exactly same value.
  * @param fn - function to call
  * @returns a new function
  */
 export declare function callOnce<T>(fn: () => T): () => T;
+/**
+ * Create a function that will memorize all calls to `fn` to ensure that `fn` is
+ * called exactly once for each unique set of arguments.
+ * @param fn - function to memorize
+ * @returns a function
+ */
 export declare function memorizerAll<K extends any[], T>(fn: (...p: K) => T): (...p: K) => T;
 export {};
 //# sourceMappingURL=Memorizer.d.ts.map

package/dist/util/Memorizer.js

@@ -74,7 +74,8 @@ function memorizeLastCall(fn) {
 }
 exports.memorizeLastCall = memorizeLastCall;
 /**
- * calls a function exactly once and always returns the same value.
+ * Creates a function that will call `fn` exactly once when invoked and remember the value returned.
+ * All subsequent calls will return exactly same value.
  * @param fn - function to call
  * @returns a new function
  */
@@ -91,7 +92,12 @@ function callOnce(fn) {
     };
 }
 exports.callOnce = callOnce;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+/**
+ * Create a function that will memorize all calls to `fn` to ensure that `fn` is
+ * called exactly once for each unique set of arguments.
+ * @param fn - function to memorize
+ * @returns a function
+ */
 function memorizerAll(fn) {
     const r = {};
     function find(p) {

package/dist/util/TextMap.d.ts

@@ -0,0 +1,15 @@
+import { MappedText } from '@cspell/cspell-types';
+import { Range } from '@cspell/cspell-types/Parser';
+/**
+ * Extract a substring from a TextMap.
+ * @param textMap - A text range with an optional map
+ * @param extractRange - The range in the original document to extract
+ * @returns The TextMap covering extractRange
+ */
+export declare function extractTextMapRangeOrigin(textMap: MappedText, extractRange: Range): MappedText;
+interface WithRange {
+    readonly range: Range;
+}
+export declare function doesIntersect(textMap: WithRange, rangeOrigin: Range): boolean;
+export {};
+//# sourceMappingURL=TextMap.d.ts.map

package/dist/util/TextMap.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doesIntersect = exports.extractTextMapRangeOrigin = void 0;
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Extract a substring from a TextMap.
+ * @param textMap - A text range with an optional map
+ * @param extractRange - The range in the original document to extract
+ * @returns The TextMap covering extractRange
+ */
+function extractTextMapRangeOrigin(textMap, extractRange) {
+    const { text: srcTxt, range: srcRange, map: srcMap } = textMap;
+    const [r0, r1] = srcRange;
+    const startOrig = Math.min(Math.max(extractRange[0], r0), r1);
+    const endOrig = Math.min(Math.max(extractRange[1], r0), r1);
+    const a = startOrig - r0;
+    const b = endOrig - r0;
+    const range = [startOrig, endOrig];
+    if (!srcMap || !srcMap.length || a === b) {
+        const text = srcTxt.slice(a, b);
+        return { text, range };
+    }
+    (0, assert_1.default)((srcMap.length & 1) === 0, 'Map must be pairs of values.');
+    const mapLen = srcMap.length;
+    const mapEndSrc = srcMap[mapLen - 2];
+    const mapEndDst = srcMap[mapLen - 1];
+    const endDiff = srcTxt.length - mapEndDst;
+    const head = !srcMap[0] && !srcMap[1] ? [] : [0, 0];
+    const tail = [mapEndSrc + endDiff, mapEndDst + endDiff];
+    const sMap = head.concat(srcMap).concat(tail);
+    let idx = 0;
+    for (; idx < sMap.length && a >= sMap[idx]; idx += 2) {
+        // empty
+    }
+    const aIdx = idx;
+    idx -= 2;
+    const a0 = a - sMap[idx];
+    const a1 = a0 + sMap[idx + 1];
+    for (; idx < sMap.length && b > sMap[idx]; idx += 2) {
+        // empty
+    }
+    const bIdx = idx;
+    const b0 = b - sMap[idx];
+    const b1 = b0 + sMap[idx + 1];
+    const text = srcTxt.slice(a1, b1);
+    if (bIdx === aIdx) {
+        return { text, range };
+    }
+    const ab = [a0, a1];
+    const map = sMap.slice(aIdx, bIdx + 2).map((v, i) => v - ab[i & 1]);
+    return { text, range, map };
+}
+exports.extractTextMapRangeOrigin = extractTextMapRangeOrigin;
+function doesIntersect(textMap, rangeOrigin) {
+    const r = textMap.range;
+    return r[0] < rangeOrigin[1] && r[1] > rangeOrigin[0];
+}
+exports.doesIntersect = doesIntersect;
+//# sourceMappingURL=TextMap.js.map

package/dist/util/resolveFile.js

@@ -42,13 +42,14 @@ const testNodeModules = /^node_modules\//;
 function resolveFile(filename, relativeTo) {
     filename = filename.replace(/^~/, os.homedir());
     const steps = [
-        { filename: filename, fn: tryNodeResolve },
+        { filename, fn: tryUrl },
+        { filename, fn: tryNodeResolve },
         { filename: path.resolve(relativeTo, filename), fn: tryResolveExists },
         { filename: path.resolve(filename), fn: tryResolveExists },
-        { filename: filename, fn: tryNodeResolveDefaultPaths },
-        { filename: filename, fn: tryResolveFrom },
+        { filename, fn: tryNodeResolveDefaultPaths },
+        { filename, fn: tryResolveFrom },
         { filename: filename.replace(testNodeModules, ''), fn: tryResolveFrom },
-        { filename: filename, fn: tryResolveGlobal },
+        { filename, fn: tryResolveGlobal },
     ];
     for (const step of steps) {
         const r = step.fn(step.filename, relativeTo);
@@ -58,6 +59,23 @@ function resolveFile(filename, relativeTo) {
     return { filename: path.resolve(relativeTo, filename), relativeTo, found: false };
 }
 exports.resolveFile = resolveFile;
+const isUrlRegExp = /^\w+:\/\//i;
+/**
+ * Check to see if it is a URL.
+ * Note: URLs are absolute!
+ * @param filename - url string
+ * @returns ResolveFileResult
+ */
+function tryUrl(filename, relativeTo) {
+    if (isUrlRegExp.test(filename)) {
+        return { filename, relativeTo: undefined, found: true };
+    }
+    if (isUrlRegExp.test(relativeTo)) {
+        const url = new URL(filename, relativeTo);
+        return { filename: url.href, relativeTo, found: true };
+    }
+    return { filename, relativeTo: undefined, found: false };
+}
 function tryNodeResolveDefaultPaths(filename) {
     try {
         const r = require.resolve(filename);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.1.3-alpha.1",
+  "version": "6.2.0-alpha.1",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,16 +48,16 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^6.1.3-alpha.1",
-    "@cspell/cspell-pipe": "^6.1.3-alpha.1",
-    "@cspell/cspell-types": "^6.1.3-alpha.1",
+    "@cspell/cspell-bundled-dicts": "^6.2.0-alpha.1",
+    "@cspell/cspell-pipe": "^6.2.0-alpha.1",
+    "@cspell/cspell-types": "^6.2.0-alpha.1",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.2",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-glob": "^6.1.3-alpha.1",
-    "cspell-io": "^6.1.3-alpha.1",
-    "cspell-trie-lib": "^6.1.3-alpha.1",
+    "cspell-glob": "^6.2.0-alpha.1",
+    "cspell-io": "^6.2.0-alpha.1",
+    "cspell-trie-lib": "^6.2.0-alpha.1",
     "fast-equals": "^4.0.1",
     "find-up": "^5.0.0",
     "fs-extra": "^10.1.0",
@@ -82,15 +82,15 @@
     "@cspell/dict-python": "^2.0.6",
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^28.1.1",
-    "@types/node": "^17.0.43",
+    "@types/jest": "^28.1.3",
+    "@types/node": "^18.0.0",
     "cspell-dict-nl-nl": "^1.1.2",
-    "jest": "^28.1.1",
+    "jest": "^28.1.2",
     "lorem-ipsum": "^2.0.8",
     "rimraf": "^3.0.2",
-    "rollup": "^2.75.6",
+    "rollup": "^2.75.7",
     "rollup-plugin-dts": "^4.2.2",
     "ts-jest": "^28.0.5"
   },
-  "gitHead": "3b0a99870292387ca96aba8a7da701575b56ed5b"
+  "gitHead": "bb1862e9d5116b64451e625eb002f835e2873f9b"
 }