cspell-lib 6.1.2 → 6.1.3

package/dist/textValidation/docValidator.d.ts

@@ -1,10 +1,11 @@
-import type { CSpellUserSettings } from '@cspell/cspell-types';
-import { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef';
+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 { ParsedText, SimpleRange } from './parsedText';
-import { LineValidator, ValidationOptions, type LineSegment } from './textValidator';
+import { SimpleRange } from './parsedText';
+import type { TextValidator } from './ValidationTypes';
+import { ValidationOptions } from './ValidationTypes';
 import { ValidateTextOptions, ValidationIssue } from './validator';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
     /**
@@ -51,10 +52,12 @@ export declare class DocumentValidator {
     checkDocument(forceCheck?: boolean): ValidationIssue[];
     get document(): TextDocument;
     updateDocumentText(text: string): void;
-    private checkDocumentLines;
+    private defaultParser;
+    private _checkParsedText;
     private addPossibleError;
     private catchError;
     private errorCatcherWrapper;
+    private _parse;
     private suggest;
     private genSuggestions;
     getFinalizedDocSettings(): CSpellSettingsInternal;
@@ -77,9 +80,10 @@ interface Preparations {
     dictionary: SpellingDictionaryCollection;
     /** configuration after applying in-doc settings */
     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.';
@@ -39,7 +41,6 @@ class DocumentValidator {
         return this._ready;
     }
     prepareSync() {
-        var _a, _b, _c;
         // @todo
         // Determine doc settings.
         // Calc include ranges
@@ -55,29 +56,30 @@ class DocumentValidator {
             : useSearchForConfig
                 ? this.errorCatcherWrapper(() => searchForDocumentConfigSync(this._document, settings, settings))
                 : undefined;
-        this.addPossibleError((_a = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _a === void 0 ? void 0 : _a.error);
+        this.addPossibleError(localConfig?.__importRef?.error);
         const config = (0, Settings_1.mergeSettings)(settings, localConfig);
         const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, config);
         const dict = (0, SpellingDictionary_1.getDictionaryInternalSync)(docSettings);
-        const matcher = new cspell_glob_1.GlobMatcher((localConfig === null || localConfig === void 0 ? void 0 : localConfig.ignorePaths) || [], { root: process.cwd(), dot: true });
+        const matcher = new cspell_glob_1.GlobMatcher(localConfig?.ignorePaths || [], { root: process.cwd(), dot: true });
         const uri = this._document.uri;
-        const shouldCheck = !matcher.match(uri.fsPath) && ((_b = docSettings.enabled) !== null && _b !== void 0 ? _b : true);
+        const shouldCheck = !matcher.match(uri.fsPath) && (docSettings.enabled ?? true);
         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,
             docSettings,
+            finalSettings,
             shouldCheck,
             validateOptions,
             includeRanges,
             segmenter,
-            lineValidator,
+            textValidator,
             localConfig,
-            localConfigFilepath: (_c = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _c === void 0 ? void 0 : _c.filename,
+            localConfigFilepath: localConfig?.__importRef?.filename,
         };
         this._ready = true;
         this._preparationTime = timer.elapsed();
@@ -92,7 +94,6 @@ class DocumentValidator {
         return this._prepared;
     }
     async _prepareAsync() {
-        var _a, _b, _c;
         (0, assert_1.default)(!this._ready);
         const timer = (0, timer_1.createTimer)();
         const { options, settings } = this;
@@ -103,46 +104,46 @@ class DocumentValidator {
                 ? this.catchError(searchForDocumentConfig(this._document, settings, settings))
                 : undefined;
         const localConfig = (await pLocalConfig) || {};
-        this.addPossibleError((_a = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _a === void 0 ? void 0 : _a.error);
+        this.addPossibleError(localConfig?.__importRef?.error);
         const config = (0, Settings_1.mergeSettings)(settings, localConfig);
         const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, config);
         const dict = await (0, SpellingDictionary_1.getDictionaryInternal)(docSettings);
-        const matcher = new cspell_glob_1.GlobMatcher((localConfig === null || localConfig === void 0 ? void 0 : localConfig.ignorePaths) || [], { root: process.cwd(), dot: true });
+        const matcher = new cspell_glob_1.GlobMatcher(localConfig?.ignorePaths || [], { root: process.cwd(), dot: true });
         const uri = this._document.uri;
-        const shouldCheck = !matcher.match(uri.fsPath) && ((_b = docSettings.enabled) !== null && _b !== void 0 ? _b : true);
+        const shouldCheck = !matcher.match(uri.fsPath) && (docSettings.enabled ?? true);
         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,
             docSettings,
+            finalSettings,
             shouldCheck,
             validateOptions,
             includeRanges,
             segmenter,
-            lineValidator,
+            textValidator,
             localConfig,
-            localConfigFilepath: (_c = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _c === void 0 ? void 0 : _c.filename,
+            localConfigFilepath: localConfig?.__importRef?.filename,
         };
         this._ready = true;
         this._preparationTime = timer.elapsed();
     }
     _updatePrep() {
-        var _a;
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const timer = (0, timer_1.createTimer)();
         const prep = this._preparations;
         const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, prep.config);
         const dict = (0, SpellingDictionary_1.getDictionaryInternalSync)(docSettings);
-        const shouldCheck = (_a = docSettings.enabled) !== null && _a !== void 0 ? _a : true;
+        const shouldCheck = docSettings.enabled ?? true;
         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,
@@ -151,7 +152,7 @@ class DocumentValidator {
             validateOptions,
             includeRanges,
             segmenter,
-            lineValidator,
+            textValidator,
         };
         this._preparationTime = timer.elapsed();
     }
@@ -163,27 +164,28 @@ class DocumentValidator {
     }
     checkText(range, _text, scope) {
         const text = this._document.text.slice(range[0], range[1]);
-        return this.check({ text, range, scope });
+        return this.check({ text, range, scope: scope.join(' ') });
     }
     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;
         }
@@ -198,7 +200,7 @@ class DocumentValidator {
     checkDocument(forceCheck = false) {
         (0, assert_1.default)(this._ready);
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
-        return forceCheck || this.shouldCheckDocument() ? [...this.checkDocumentLines()] : [];
+        return forceCheck || this.shouldCheckDocument() ? [...this._checkParsedText(this._parse())] : [];
     }
     get document() {
         return this._document;
@@ -207,15 +209,20 @@ class DocumentValidator {
         (0, TextDocument_1.updateTextDocument)(this._document, [{ text }]);
         this._updatePrep();
     }
-    *checkDocumentLines() {
+    defaultParser() {
+        return (0, cspell_pipe_1.pipeSync)(this.document.getLines(), (0, cspell_pipe_1.opMap)((line) => {
+            const { text, offset } = line;
+            const range = [offset, offset + text.length];
+            return { text, range };
+        }));
+    }
+    *_checkParsedText(parsedTexts) {
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const { maxNumberOfProblems = textValidator_1.defaultMaxNumberOfProblems, maxDuplicateProblems = textValidator_1.defaultMaxDuplicateProblems } = this._preparations.validateOptions;
         let numProblems = 0;
         const mapOfProblems = new Map();
-        for (const line of this.document.getLines()) {
-            const { text, offset } = line;
-            const range = [offset, offset + text.length];
-            for (const issue of this.check({ text, range })) {
+        for (const pText of parsedTexts) {
+            for (const issue of this.check(pText)) {
                 const { text } = issue;
                 const n = (mapOfProblems.get(text) || 0) + 1;
                 mapOfProblems.set(text, n);
@@ -247,11 +254,17 @@ class DocumentValidator {
         }
         return undefined;
     }
+    _parse() {
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
+        const parser = this._preparations.finalSettings.parser;
+        if (typeof parser !== 'object')
+            return this.defaultParser();
+        return parser.parse(this.document.text, this.document.uri.path).parsedTexts;
+    }
     suggest(text) {
         return this._suggestions.get(text);
     }
     genSuggestions(text) {
-        var _a;
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const settings = this._preparations.docSettings;
         const dict = this._preparations.dictionary;
@@ -259,7 +272,7 @@ class DocumentValidator {
             compoundMethod: 0,
             numSuggestions: this.options.numSuggestions,
             includeTies: false,
-            ignoreCase: !((_a = settings.caseSensitive) !== null && _a !== void 0 ? _a : false),
+            ignoreCase: !(settings.caseSensitive ?? false),
             timeout: settings.suggestionsTimeout,
             numChanges: settings.suggestionNumChanges,
         });

package/dist/textValidation/index.d.ts

@@ -1,8 +1,8 @@
 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';
 export type { DocumentValidatorOptions } from './docValidator';
-export type { Offset, SimpleRange, ParsedText } from './parsedText';
+export type { Offset, SimpleRange } from './parsedText';
 //# sourceMappingURL=index.d.ts.map

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,21 +1,15 @@
+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 interface ParsedText {
-    /**
-     * Transformed text
-     */
-    text: string;
-    /**
-     * Offset pair of the original text
-     */
-    range: SimpleRange;
-    /**
-     * Relative map to the original text.
-     */
-    map?: number[];
-    scope?: string[];
-}
-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,25 +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) {
-    var _a;
-    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 + ((_a = textOff.length) !== null && _a !== void 0 ? _a : 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],
     };
 }
@@ -43,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