cspell-lib 6.29.2 → 6.30.0

package/dist/cjs/Models/ValidationIssue.d.ts

@@ -1,7 +1,7 @@
 import type { ExtendedSuggestion } from './Suggestion.js';
 import type { ValidationResult } from './ValidationResult.js';
 export interface ValidationIssue extends ValidationResult {
-    suggestions?: string[];
-    suggestionsEx?: ExtendedSuggestion[];
+    suggestions?: string[] | undefined;
+    suggestionsEx?: ExtendedSuggestion[] | undefined;
 }
 //# sourceMappingURL=ValidationIssue.d.ts.map

package/dist/cjs/textValidation/ValidationTypes.d.ts

@@ -1,5 +1,6 @@
 import type { MappedText, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
-import type { ValidationResult } from '../Models/ValidationResult.js';
+import type { ExtendedSuggestion } from '../Models/Suggestion.js';
+import type { ValidationIssue } from '../Models/ValidationIssue.js';
 export type TextOffsetRO = Readonly<TextOffsetRW>;
 export interface ValidationOptions extends IncludeExcludeOptions {
     maxNumberOfProblems?: number;
@@ -23,8 +24,8 @@ export interface WordRangeAcc {
     isIncluded: boolean;
     rangePos: number;
 }
-export type ValidationResultRO = Readonly<ValidationResult>;
-export type LineValidatorFn = (line: LineSegment) => Iterable<ValidationResult>;
+export type ValidationIssueRO = Readonly<ValidationIssue>;
+export type LineValidatorFn = (line: LineSegment) => Iterable<ValidationIssue>;
 export interface LineSegment {
     line: TextOffsetRO;
     segment: TextOffsetRO;
@@ -32,6 +33,7 @@ export interface LineSegment {
 export interface MappedTextValidationResult extends MappedText {
     isFlagged?: boolean | undefined;
     isFound?: boolean | undefined;
+    suggestionsEx?: ExtendedSuggestion[] | undefined;
 }
 export type TextValidatorFn = (text: MappedText) => Iterable<MappedTextValidationResult>;
 //# sourceMappingURL=ValidationTypes.d.ts.map

package/dist/cjs/textValidation/docValidator.d.ts

@@ -83,6 +83,7 @@ export declare class DocumentValidator {
     private _parse;
     private getSuggestions;
     private genSuggestions;
+    private adjustSuggestions;
     getFinalizedDocSettings(): CSpellSettingsInternal;
     /**
      * Returns true if the final result of the configuration calculation results

package/dist/cjs/textValidation/docValidator.js

@@ -196,18 +196,24 @@ class DocumentValidator {
         const document = this._document;
         let line = undefined;
         function mapToIssue(issue) {
-            const { range, text, isFlagged, isFound } = issue;
+            const { range, text, isFlagged, isFound, suggestionsEx } = 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 };
+            return { text, offset, line, length, isFlagged, isFound, suggestionsEx };
         }
         const issues = [...(0, sync_1.pipeSync)(segmenter(parsedText), (0, sync_1.opConcatMap)(textValidator.validate), (0, sync_1.opMap)(mapToIssue))];
         if (!this.options.generateSuggestions) {
-            return issues;
+            return issues.map((issue) => {
+                if (!issue.suggestionsEx)
+                    return issue;
+                const suggestionsEx = this.adjustSuggestions(issue.text, issue.suggestionsEx);
+                const suggestions = suggestionsEx.map((s) => s.word);
+                return { ...issue, suggestionsEx, suggestions };
+            });
         }
         const withSugs = issues.map((t) => {
             // lazy suggestion calculation.
@@ -323,9 +329,16 @@ class DocumentValidator {
             timeout: settings.suggestionsTimeout,
             numChanges: settings.suggestionNumChanges,
         };
-        const locale = this._preparations.config.language;
         const rawSuggestions = dict.suggest(text, sugOptions);
-        const sugsWithAlt = (0, suggestions_js_1.calcSuggestionAdjustedToToMatchCase)(text, rawSuggestions, locale, sugOptions.ignoreCase, dict);
+        return this.adjustSuggestions(text, rawSuggestions);
+    }
+    adjustSuggestions(text, rawSuggestions) {
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
+        const settings = this._preparations.docSettings;
+        const ignoreCase = !(settings.caseSensitive ?? false);
+        const locale = this._preparations.config.language;
+        const dict = this._preparations.dictionary;
+        const sugsWithAlt = (0, suggestions_js_1.calcSuggestionAdjustedToToMatchCase)(text, rawSuggestions.map(mapSug), locale, ignoreCase, dict);
         return sugsWithAlt.map(sanitizeSuggestion);
     }
     getFinalizedDocSettings() {
@@ -368,6 +381,9 @@ async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
         return Promise.resolve(defaultConfig);
     return (0, index_js_2.searchForConfig)(path_1.default.dirname((0, Uri_js_1.uriToFilePath)(uri)), pnpSettings).then((s) => s || defaultConfig);
 }
+function mapSug(sug) {
+    return { cost: 999, ...sug };
+}
 function searchForDocumentConfigSync(document, defaultConfig, pnpSettings) {
     const { uri } = document;
     if (uri.scheme !== 'file')

package/dist/cjs/textValidation/isWordValid.d.ts

@@ -1,8 +1,9 @@
 import type { CachingDictionary } from 'cspell-dictionary';
 import type { TextOffsetRO } from './ValidationTypes.js';
-export declare function hasWordCheck(dict: CachingDictionary, word: string): boolean;
+declare function hasWordCheck(dict: CachingDictionary, word: string): boolean;
 export declare function isWordValidWithEscapeRetry(dict: CachingDictionary, wo: TextOffsetRO, line: TextOffsetRO): boolean;
 export declare const __testing__: {
     hasWordCheck: typeof hasWordCheck;
 };
+export {};
 //# sourceMappingURL=isWordValid.d.ts.map

package/dist/cjs/textValidation/isWordValid.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.isWordValidWithEscapeRetry = exports.hasWordCheck = void 0;
+exports.__testing__ = exports.isWordValidWithEscapeRetry = void 0;
 function hasWordCheck(dict, word) {
-    word = word.replace(/\\/g, '');
+    word = word.includes('\\') ? word.replace(/\\/g, '') : word;
     return dict.has(word);
 }
-exports.hasWordCheck = hasWordCheck;
 function isWordValidWithEscapeRetry(dict, wo, line) {
     const firstTry = hasWordCheck(dict, wo.text);
     return (firstTry ||

package/dist/cjs/textValidation/lineValidatorFactory.js

@@ -26,7 +26,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.textValidatorFactory = exports.lineValidatorFactory = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_dictionary_1 = require("cspell-dictionary");
-const gensequence_1 = require("gensequence");
 const RxPat = __importStar(require("../Settings/RegExpPatterns.js"));
 const Text = __importStar(require("../util/text.js"));
 const util_js_1 = require("../util/util.js");
@@ -60,15 +59,25 @@ function lineValidatorFactory(sDict, options) {
     function isWordIgnored(word) {
         return dictCol.isNoSuggestWord(word);
     }
+    function getSuggestions(word) {
+        return dictCol.getPreferredSuggestions(word);
+    }
     function isWordFlagged(word) {
         const isIgnored = isWordIgnored(word.text);
         const isFlagged = !isIgnored && testForFlaggedWord(word);
         return isFlagged;
     }
-    function checkFlagWords(word) {
+    function annotateIsFlagged(word) {
         word.isFlagged = isWordFlagged(word);
         return word;
     }
+    function annotateIssue(issue) {
+        const sugs = getSuggestions(issue.text);
+        if (sugs && sugs.length) {
+            issue.suggestionsEx = sugs;
+        }
+        return issue;
+    }
     function checkWord(word) {
         const isIgnored = isWordIgnored(word.text);
         const { isFlagged = !isIgnored && testForFlaggedWord(word) } = word;
@@ -84,7 +93,7 @@ function lineValidatorFactory(sDict, options) {
             if (vr.isFlagged) {
                 return [vr];
             }
-            const codeWordResults = (0, sync_1.toArray)((0, sync_1.pipe)(Text.extractWordsFromCodeTextOffset(vr), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opMap)((t) => ({ ...t, line: vr.line })), (0, sync_1.opMap)(checkFlagWords), (0, sync_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, sync_1.opMap)((wo) => (wo.isFlagged ? wo : checkWord(wo))), (0, sync_1.opFilter)(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), (0, sync_1.opFilter)(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
+            const codeWordResults = (0, sync_1.toArray)((0, sync_1.pipe)(Text.extractWordsFromCodeTextOffset(vr), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opMap)((t) => ({ ...t, line: vr.line })), (0, sync_1.opMap)(annotateIsFlagged), (0, sync_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, sync_1.opMap)((wo) => (wo.isFlagged ? wo : checkWord(wo))), (0, sync_1.opFilter)(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), (0, sync_1.opFilter)(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
             // get back the original text.
             (0, sync_1.opMap)((wo) => ({
                 ...wo,
@@ -105,18 +114,18 @@ function lineValidatorFactory(sDict, options) {
                 };
                 return [vr];
             }
-            const mismatches = (0, sync_1.toArray)((0, sync_1.pipe)(Text.extractWordsFromTextOffset(possibleWord), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opMap)((wo) => ({ ...wo, line: lineSegment.line })), (0, sync_1.opMap)(checkFlagWords), (0, sync_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, sync_1.opConcatMap)(checkFullWord)));
+            const mismatches = (0, sync_1.toArray)((0, sync_1.pipe)(Text.extractWordsFromTextOffset(possibleWord), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opMap)((wo) => ({ ...wo, line: lineSegment.line })), (0, sync_1.opMap)(annotateIsFlagged), (0, sync_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, sync_1.opConcatMap)(checkFullWord)));
             if (mismatches.length) {
                 // Try the more expensive word splitter
                 const splitResult = (0, wordSplitter_js_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 nonMatching.map((w) => ({ ...w, line: lineSegment.line })).map(annotateIsFlagged);
                 }
             }
             return mismatches;
         }
-        const checkedPossibleWords = (0, gensequence_1.genSequence)((0, sync_1.pipe)(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opConcatMap)(checkPossibleWords)));
+        const checkedPossibleWords = (0, sync_1.pipe)(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opConcatMap)(checkPossibleWords), (0, sync_1.opMap)(annotateIssue));
         return checkedPossibleWords;
     };
     return { fn, dict: dictCol };
@@ -131,10 +140,10 @@ function textValidatorFactory(dict, options) {
         const segment = { text, offset: 0 };
         const lineSegment = { line: segment, segment };
         function mapBackToOriginSimple(vr) {
-            const { text, offset, isFlagged, isFound } = vr;
+            const { text, offset, isFlagged, isFound, suggestionsEx } = vr;
             const r = (0, parsedText_js_1.mapRangeBackToOriginalPos)([offset, offset + text.length], map);
             const range = [r[0] + srcOffset, r[1] + srcOffset];
-            return { text, range, isFlagged, isFound };
+            return { text, range, isFlagged, isFound, suggestionsEx };
         }
         return [...lineValidatorFn(lineSegment)].map(mapBackToOriginSimple);
     }

package/dist/cjs/textValidation/textValidator.d.ts

@@ -1,5 +1,4 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
-import type { Sequence } from 'gensequence';
 import type { ValidationResult } from '../Models/ValidationResult.js';
 import * as TextRange from '../util/TextRange.js';
 import type { IncludeExcludeOptions, LineSegment, ValidationOptions } from './ValidationTypes.js';
@@ -7,7 +6,7 @@ import type { IncludeExcludeOptions, LineSegment, ValidationOptions } from './Va
  * @deprecated
  * @deprecation Use spellCheckDocument
  */
-export declare function validateText(text: string, dict: SpellingDictionary, options: ValidationOptions): Sequence<ValidationResult>;
+export declare function validateText(text: string, dict: SpellingDictionary, options: ValidationOptions): Iterable<ValidationResult>;
 export declare function calcTextInclusionRanges(text: string, options: IncludeExcludeOptions): TextRange.MatchRange[];
 /**
  * Returns a mapper function that will segment a TextOffset based upon the includeRanges.

package/dist/cjs/textValidation/textValidator.js

@@ -25,7 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._testMethods = exports.mapLineSegmentAgainstRangesFactory = exports.calcTextInclusionRanges = exports.validateText = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
-const gensequence_1 = require("gensequence");
 const Text = __importStar(require("../util/text.js"));
 const TextRange = __importStar(require("../util/TextRange.js"));
 const defaultConstants_js_1 = require("./defaultConstants.js");
@@ -48,7 +47,7 @@ function validateText(text, dict, options) {
         // Filter out if there is too many
         return n <= maxDuplicateProblems;
     }), (0, sync_1.opTake)(maxNumberOfProblems));
-    return (0, gensequence_1.genSequence)(iter);
+    return iter;
 }
 exports.validateText = validateText;
 function calcTextInclusionRanges(text, options) {

package/dist/cjs/util/textRegex.js

@@ -6,12 +6,12 @@ exports.regExUpperSOrIng = /([\p{Lu}\p{M}]+\\?['’]?(?:s|ing|ies|es|ings|ed|nin
 exports.regExSplitWords = /(\p{Ll}\p{M}?)(\p{Lu})/gu;
 exports.regExSplitWords2 = /(\p{Lu}\p{M}?)(\p{Lu}\p{M}?\p{Ll})/gu;
 exports.regExWords = /\p{L}\p{M}?(?:(?:\\?['’])?\p{L}\p{M}?)*/gu;
-exports.regExWordsAndDigits = /(?:\d+)?[\p{L}\p{M}_'’-](?:(?:\\?['’])?[\p{L}\p{M}\w'’-])*/gu;
+exports.regExWordsAndDigits = /(?:\d+)?[\p{L}\p{M}_'’-](?:(?:\\?['’])?[\p{L}\p{M}\w'’.-])*/gu;
 exports.regExIgnoreCharacters = /[\p{sc=Hiragana}\p{sc=Han}\p{sc=Katakana}\u30A0-\u30FF\p{sc=Hangul}]/gu;
 exports.regExFirstUpper = /^\p{Lu}\p{M}?\p{Ll}+$/u;
 exports.regExAllUpper = /^(?:\p{Lu}\p{M}?)+$/u;
 exports.regExAllLower = /^(?:\p{Ll}\p{M}?)+$/u;
-exports.regExPossibleWordBreaks = /[-_’']/g;
+exports.regExPossibleWordBreaks = /[-_’'.]/g;
 exports.regExMatchRegExParts = /^\s*\/([\s\S]*?)\/([gimuxy]*)\s*$/;
 exports.regExAccents = /\p{M}/gu;
 exports.regExEscapeCharacters = /(?<=\\)[anrvtbf]/gi;

package/dist/esm/Models/ValidationIssue.d.mts

@@ -1,7 +1,7 @@
 import type { ExtendedSuggestion } from './Suggestion.mjs';
 import type { ValidationResult } from './ValidationResult.mjs';
 export interface ValidationIssue extends ValidationResult {
-    suggestions?: string[];
-    suggestionsEx?: ExtendedSuggestion[];
+    suggestions?: string[] | undefined;
+    suggestionsEx?: ExtendedSuggestion[] | undefined;
 }
 //# sourceMappingURL=ValidationIssue.d.mts.map

package/dist/esm/textValidation/ValidationTypes.d.mts

@@ -1,5 +1,6 @@
 import type { MappedText, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
-import type { ValidationResult } from '../Models/ValidationResult.mjs';
+import type { ExtendedSuggestion } from '../Models/Suggestion.mjs';
+import type { ValidationIssue } from '../Models/ValidationIssue.mjs';
 export type TextOffsetRO = Readonly<TextOffsetRW>;
 export interface ValidationOptions extends IncludeExcludeOptions {
     maxNumberOfProblems?: number;
@@ -23,8 +24,8 @@ export interface WordRangeAcc {
     isIncluded: boolean;
     rangePos: number;
 }
-export type ValidationResultRO = Readonly<ValidationResult>;
-export type LineValidatorFn = (line: LineSegment) => Iterable<ValidationResult>;
+export type ValidationIssueRO = Readonly<ValidationIssue>;
+export type LineValidatorFn = (line: LineSegment) => Iterable<ValidationIssue>;
 export interface LineSegment {
     line: TextOffsetRO;
     segment: TextOffsetRO;
@@ -32,6 +33,7 @@ export interface LineSegment {
 export interface MappedTextValidationResult extends MappedText {
     isFlagged?: boolean | undefined;
     isFound?: boolean | undefined;
+    suggestionsEx?: ExtendedSuggestion[] | undefined;
 }
 export type TextValidatorFn = (text: MappedText) => Iterable<MappedTextValidationResult>;
 //# sourceMappingURL=ValidationTypes.d.mts.map

package/dist/esm/textValidation/docValidator.d.mts

@@ -83,6 +83,7 @@ export declare class DocumentValidator {
     private _parse;
     private getSuggestions;
     private genSuggestions;
+    private adjustSuggestions;
     getFinalizedDocSettings(): CSpellSettingsInternal;
     /**
      * Returns true if the final result of the configuration calculation results

package/dist/esm/textValidation/docValidator.mjs

@@ -190,18 +190,24 @@ export class DocumentValidator {
         const document = this._document;
         let line = undefined;
         function mapToIssue(issue) {
-            const { range, text, isFlagged, isFound } = issue;
+            const { range, text, isFlagged, isFound, suggestionsEx } = issue;
             const offset = range[0];
             const length = range[1] - range[0];
             assert(!line || line.offset <= offset);
             if (!line || line.offset + line.text.length <= offset) {
                 line = document.lineAt(offset);
             }
-            return { text, offset, line, length, isFlagged, isFound };
+            return { text, offset, line, length, isFlagged, isFound, suggestionsEx };
         }
         const issues = [...pipeSync(segmenter(parsedText), opConcatMap(textValidator.validate), opMap(mapToIssue))];
         if (!this.options.generateSuggestions) {
-            return issues;
+            return issues.map((issue) => {
+                if (!issue.suggestionsEx)
+                    return issue;
+                const suggestionsEx = this.adjustSuggestions(issue.text, issue.suggestionsEx);
+                const suggestions = suggestionsEx.map((s) => s.word);
+                return { ...issue, suggestionsEx, suggestions };
+            });
         }
         const withSugs = issues.map((t) => {
             // lazy suggestion calculation.
@@ -317,9 +323,16 @@ export class DocumentValidator {
             timeout: settings.suggestionsTimeout,
             numChanges: settings.suggestionNumChanges,
         };
-        const locale = this._preparations.config.language;
         const rawSuggestions = dict.suggest(text, sugOptions);
-        const sugsWithAlt = calcSuggestionAdjustedToToMatchCase(text, rawSuggestions, locale, sugOptions.ignoreCase, dict);
+        return this.adjustSuggestions(text, rawSuggestions);
+    }
+    adjustSuggestions(text, rawSuggestions) {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const settings = this._preparations.docSettings;
+        const ignoreCase = !(settings.caseSensitive ?? false);
+        const locale = this._preparations.config.language;
+        const dict = this._preparations.dictionary;
+        const sugsWithAlt = calcSuggestionAdjustedToToMatchCase(text, rawSuggestions.map(mapSug), locale, ignoreCase, dict);
         return sugsWithAlt.map(sanitizeSuggestion);
     }
     getFinalizedDocSettings() {
@@ -361,6 +374,9 @@ async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
         return Promise.resolve(defaultConfig);
     return searchForConfig(path.dirname(uriToFilePath(uri)), pnpSettings).then((s) => s || defaultConfig);
 }
+function mapSug(sug) {
+    return { cost: 999, ...sug };
+}
 function searchForDocumentConfigSync(document, defaultConfig, pnpSettings) {
     const { uri } = document;
     if (uri.scheme !== 'file')

package/dist/esm/textValidation/isWordValid.d.mts

@@ -1,8 +1,9 @@
 import type { CachingDictionary } from 'cspell-dictionary';
 import type { TextOffsetRO } from './ValidationTypes.mjs';
-export declare function hasWordCheck(dict: CachingDictionary, word: string): boolean;
+declare function hasWordCheck(dict: CachingDictionary, word: string): boolean;
 export declare function isWordValidWithEscapeRetry(dict: CachingDictionary, wo: TextOffsetRO, line: TextOffsetRO): boolean;
 export declare const __testing__: {
     hasWordCheck: typeof hasWordCheck;
 };
+export {};
 //# sourceMappingURL=isWordValid.d.mts.map

package/dist/esm/textValidation/isWordValid.mjs

@@ -1,5 +1,5 @@
-export function hasWordCheck(dict, word) {
-    word = word.replace(/\\/g, '');
+function hasWordCheck(dict, word) {
+    word = word.includes('\\') ? word.replace(/\\/g, '') : word;
     return dict.has(word);
 }
 export function isWordValidWithEscapeRetry(dict, wo, line) {

package/dist/esm/textValidation/lineValidatorFactory.mjs

@@ -1,6 +1,5 @@
 import { opConcatMap, opFilter, opMap, pipe, toArray } from '@cspell/cspell-pipe/sync';
 import { createCachingDictionary } from 'cspell-dictionary';
-import { genSequence } from 'gensequence';
 import * as RxPat from '../Settings/RegExpPatterns.mjs';
 import * as Text from '../util/text.mjs';
 import { clean } from '../util/util.mjs';
@@ -34,15 +33,25 @@ export function lineValidatorFactory(sDict, options) {
     function isWordIgnored(word) {
         return dictCol.isNoSuggestWord(word);
     }
+    function getSuggestions(word) {
+        return dictCol.getPreferredSuggestions(word);
+    }
     function isWordFlagged(word) {
         const isIgnored = isWordIgnored(word.text);
         const isFlagged = !isIgnored && testForFlaggedWord(word);
         return isFlagged;
     }
-    function checkFlagWords(word) {
+    function annotateIsFlagged(word) {
         word.isFlagged = isWordFlagged(word);
         return word;
     }
+    function annotateIssue(issue) {
+        const sugs = getSuggestions(issue.text);
+        if (sugs && sugs.length) {
+            issue.suggestionsEx = sugs;
+        }
+        return issue;
+    }
     function checkWord(word) {
         const isIgnored = isWordIgnored(word.text);
         const { isFlagged = !isIgnored && testForFlaggedWord(word) } = word;
@@ -58,7 +67,7 @@ export function lineValidatorFactory(sDict, options) {
             if (vr.isFlagged) {
                 return [vr];
             }
-            const codeWordResults = toArray(pipe(Text.extractWordsFromCodeTextOffset(vr), opFilter(filterAlreadyChecked), opMap((t) => ({ ...t, line: vr.line })), opMap(checkFlagWords), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opMap((wo) => (wo.isFlagged ? wo : checkWord(wo))), opFilter(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), opFilter(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
+            const codeWordResults = toArray(pipe(Text.extractWordsFromCodeTextOffset(vr), opFilter(filterAlreadyChecked), opMap((t) => ({ ...t, line: vr.line })), opMap(annotateIsFlagged), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opMap((wo) => (wo.isFlagged ? wo : checkWord(wo))), opFilter(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), opFilter(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
             // get back the original text.
             opMap((wo) => ({
                 ...wo,
@@ -79,18 +88,18 @@ export function lineValidatorFactory(sDict, options) {
                 };
                 return [vr];
             }
-            const mismatches = toArray(pipe(Text.extractWordsFromTextOffset(possibleWord), opFilter(filterAlreadyChecked), opMap((wo) => ({ ...wo, line: lineSegment.line })), opMap(checkFlagWords), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opConcatMap(checkFullWord)));
+            const mismatches = toArray(pipe(Text.extractWordsFromTextOffset(possibleWord), opFilter(filterAlreadyChecked), opMap((wo) => ({ ...wo, line: lineSegment.line })), opMap(annotateIsFlagged), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opConcatMap(checkFullWord)));
             if (mismatches.length) {
                 // Try the more expensive word splitter
                 const splitResult = 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 nonMatching.map((w) => ({ ...w, line: lineSegment.line })).map(annotateIsFlagged);
                 }
             }
             return mismatches;
         }
-        const checkedPossibleWords = genSequence(pipe(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), opFilter(filterAlreadyChecked), opConcatMap(checkPossibleWords)));
+        const checkedPossibleWords = pipe(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), opFilter(filterAlreadyChecked), opConcatMap(checkPossibleWords), opMap(annotateIssue));
         return checkedPossibleWords;
     };
     return { fn, dict: dictCol };
@@ -104,10 +113,10 @@ export function textValidatorFactory(dict, options) {
         const segment = { text, offset: 0 };
         const lineSegment = { line: segment, segment };
         function mapBackToOriginSimple(vr) {
-            const { text, offset, isFlagged, isFound } = vr;
+            const { text, offset, isFlagged, isFound, suggestionsEx } = vr;
             const r = mapRangeBackToOriginalPos([offset, offset + text.length], map);
             const range = [r[0] + srcOffset, r[1] + srcOffset];
-            return { text, range, isFlagged, isFound };
+            return { text, range, isFlagged, isFound, suggestionsEx };
         }
         return [...lineValidatorFn(lineSegment)].map(mapBackToOriginSimple);
     }

package/dist/esm/textValidation/textValidator.d.mts

@@ -1,5 +1,4 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
-import type { Sequence } from 'gensequence';
 import type { ValidationResult } from '../Models/ValidationResult.mjs';
 import * as TextRange from '../util/TextRange.mjs';
 import type { IncludeExcludeOptions, LineSegment, ValidationOptions } from './ValidationTypes.mjs';
@@ -7,7 +6,7 @@ import type { IncludeExcludeOptions, LineSegment, ValidationOptions } from './Va
  * @deprecated
  * @deprecation Use spellCheckDocument
  */
-export declare function validateText(text: string, dict: SpellingDictionary, options: ValidationOptions): Sequence<ValidationResult>;
+export declare function validateText(text: string, dict: SpellingDictionary, options: ValidationOptions): Iterable<ValidationResult>;
 export declare function calcTextInclusionRanges(text: string, options: IncludeExcludeOptions): TextRange.MatchRange[];
 /**
  * Returns a mapper function that will segment a TextOffset based upon the includeRanges.

package/dist/esm/textValidation/textValidator.mjs

@@ -1,5 +1,4 @@
 import { opConcatMap, opFilter, opTake, pipe } from '@cspell/cspell-pipe/sync';
-import { genSequence } from 'gensequence';
 import * as Text from '../util/text.mjs';
 import * as TextRange from '../util/TextRange.mjs';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.mjs';
@@ -22,7 +21,7 @@ export function validateText(text, dict, options) {
         // Filter out if there is too many
         return n <= maxDuplicateProblems;
     }), opTake(maxNumberOfProblems));
-    return genSequence(iter);
+    return iter;
 }
 export function calcTextInclusionRanges(text, options) {
     const { ignoreRegExpList = [], includeRegExpList = [] } = options;

package/dist/esm/util/textRegex.mjs

@@ -3,12 +3,12 @@ export const regExUpperSOrIng = /([\p{Lu}\p{M}]+\\?['’]?(?:s|ing|ies|es|ings|e
 export const regExSplitWords = /(\p{Ll}\p{M}?)(\p{Lu})/gu;
 export const regExSplitWords2 = /(\p{Lu}\p{M}?)(\p{Lu}\p{M}?\p{Ll})/gu;
 export const regExWords = /\p{L}\p{M}?(?:(?:\\?['’])?\p{L}\p{M}?)*/gu;
-export const regExWordsAndDigits = /(?:\d+)?[\p{L}\p{M}_'’-](?:(?:\\?['’])?[\p{L}\p{M}\w'’-])*/gu;
+export const regExWordsAndDigits = /(?:\d+)?[\p{L}\p{M}_'’-](?:(?:\\?['’])?[\p{L}\p{M}\w'’.-])*/gu;
 export const regExIgnoreCharacters = /[\p{sc=Hiragana}\p{sc=Han}\p{sc=Katakana}\u30A0-\u30FF\p{sc=Hangul}]/gu;
 export const regExFirstUpper = /^\p{Lu}\p{M}?\p{Ll}+$/u;
 export const regExAllUpper = /^(?:\p{Lu}\p{M}?)+$/u;
 export const regExAllLower = /^(?:\p{Ll}\p{M}?)+$/u;
-export const regExPossibleWordBreaks = /[-_’']/g;
+export const regExPossibleWordBreaks = /[-_’'.]/g;
 export const regExMatchRegExParts = /^\s*\/([\s\S]*?)\/([gimuxy]*)\s*$/;
 export const regExAccents = /\p{M}/gu;
 export const regExEscapeCharacters = /(?<=\\)[anrvtbf]/gi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.29.2",
+  "version": "6.30.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "commonjs",
   "main": "dist/cjs/index.js",
@@ -57,19 +57,19 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "6.29.2",
-    "@cspell/cspell-pipe": "6.29.2",
-    "@cspell/cspell-types": "6.29.2",
-    "@cspell/strong-weak-map": "6.29.2",
+    "@cspell/cspell-bundled-dicts": "6.30.0",
+    "@cspell/cspell-pipe": "6.30.0",
+    "@cspell/cspell-types": "6.30.0",
+    "@cspell/strong-weak-map": "6.30.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^8.1.0",
-    "cspell-dictionary": "6.29.2",
-    "cspell-glob": "6.29.2",
-    "cspell-grammar": "6.29.2",
-    "cspell-io": "6.29.2",
-    "cspell-trie-lib": "6.29.2",
+    "cspell-dictionary": "6.30.0",
+    "cspell-glob": "6.30.0",
+    "cspell-grammar": "6.30.0",
+    "cspell-io": "6.30.0",
+    "cspell-trie-lib": "6.30.0",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "gensequence": "^5.0.2",
@@ -92,12 +92,12 @@
     "@cspell/dict-nl-nl": "^2.2.8",
     "@cspell/dict-python": "^4.0.2",
     "@types/configstore": "^5.0.1",
-    "@types/jest": "^29.4.0",
+    "@types/jest": "^29.4.4",
     "cspell-dict-nl-nl": "^1.1.2",
     "expect": "^29.5.0",
     "jest": "^29.5.0",
     "lorem-ipsum": "^2.0.8",
     "ts-jest": "^29.0.5"
   },
-  "gitHead": "fae497508ec03795dfe0e0b70ea80cdf3d7be5a5"
+  "gitHead": "9af8c211fdeeb58e2d7a2be0e72405a23fe954cc"
 }