cspell-lib 9.6.4 → 9.8.0

package/dist/lib/Transform/TextMap.js

@@ -0,0 +1,86 @@
+import { calcOffsetInDst, calcOffsetInSrc, createSourceMapCursor, sliceSourceMapToSourceRange } from './SourceMap.js';
+/**
+ * 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 function extractTextMapRangeOrigin(textMap, extractRange) {
+    const { text: srcTxt, range: srcRange } = 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 (!textMap.map?.length) {
+        const text = srcTxt.slice(a, b);
+        return { text, range };
+    }
+    const rangeSrc = [a, b];
+    const [a1, b1] = calculateRangeInDest(textMap.map, rangeSrc);
+    const tm = {
+        text: srcTxt.slice(a1, b1),
+        range,
+    };
+    const sourceMap = sliceSourceMapToSourceRange(textMap.map, rangeSrc);
+    if (sourceMap?.length) {
+        tm.map = sourceMap;
+    }
+    return tm;
+}
+export function calculateRangeInDest(srcMap, rangeOrigin) {
+    const cursor = createSourceMapCursor(srcMap);
+    if (!cursor) {
+        return rangeOrigin;
+    }
+    const start = cursor.mapOffsetToDest(rangeOrigin[0]);
+    const end = cursor.mapOffsetToDest(rangeOrigin[1]);
+    return [start, end];
+}
+export function calculateRangeInSrc(srcMap, rangeOrigin) {
+    const cursor = createSourceMapCursor(srcMap);
+    if (!cursor) {
+        return rangeOrigin;
+    }
+    const start = cursor.mapOffsetToSrc(rangeOrigin[0]);
+    const end = cursor.mapOffsetToSrc(rangeOrigin[1]);
+    return [start, end];
+}
+export function calculateTextMapRangeDest(textMap, rangeOrigin) {
+    const { range: srcRange, map: srcMap } = textMap;
+    const [r0, r1] = srcRange;
+    const start = Math.min(Math.max(rangeOrigin[0], r0), r1) - r0;
+    const end = Math.min(Math.max(rangeOrigin[1], r0), r1) - r0;
+    const range = [start, end];
+    return calculateRangeInDest(srcMap, range);
+}
+/**
+ * Map an offset in the transformed text back to the original text.
+ * It will find the first matching position in the map.
+ *
+ * @param map - The source map to use for the mapping.
+ *   If undefined or empty, the input offset is returned, assuming it is a 1:1 mapping.
+ * @param offset - the offset in the transformed text to map back to the original text
+ */
+export function mapOffsetToSource(map, offset) {
+    const cursor = createSourceMapCursor(map);
+    return calcOffsetInSrc(cursor, offset);
+}
+/**
+ * Map an offset in the original text to the transformed text.
+ * It will find the first matching position in the map.
+ *
+ * @param map - The source map to use for the mapping.
+ *   If undefined or empty, the input offset is returned, assuming it is a 1:1 mapping.
+ * @param offset - the offset in the original text to map to the transformed text
+ */
+export function mapOffsetToDest(map, offset) {
+    const cursor = createSourceMapCursor(map);
+    return calcOffsetInDst(cursor, offset);
+}
+export function doesIntersect(textMap, rangeOrigin) {
+    const r = textMap.range;
+    return r[0] < rangeOrigin[1] && r[1] > rangeOrigin[0];
+}
+//# sourceMappingURL=TextMap.js.map

package/dist/lib/{util → Transform}/TextRange.js

@@ -1,11 +1,10 @@
 function toMatchRangeWithText(m) {
-    const index = m.index || 0;
-    const _text = m[0];
-    return {
-        startPos: index,
-        endPos: index + _text.length,
-        text: _text,
-    };
+    const range = m.indices?.[0];
+    const index = range?.[0] ?? (m.index || 0);
+    const text = m[0];
+    const startPos = index;
+    const endPos = range?.[1] ?? index + text.length;
+    return { startPos, endPos, text };
 }
 export function findMatchingRanges(pattern, text) {
     if (pattern.source === '.*') {

package/dist/lib/Transform/index.d.ts

@@ -0,0 +1,9 @@
+export { createMappedTextSegmenter, mapRangeBackToOriginalPos } from './parsedText.js';
+export type { SourceMapCursor } from './SourceMap.js';
+export { createSourceMapCursor } from './SourceMap.js';
+export type { SubstitutionInfo } from './SubstitutionTransformer.js';
+export { createSubstitutionTransformer, SubstitutionTransformer } from './SubstitutionTransformer.js';
+export type { MatchRange } from './TextRange.js';
+export { excludeRanges, extractRangeText, findMatchingRanges, findMatchingRangesForPatterns } from './TextRange.js';
+export type { Offset, SimpleRange } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Transform/index.js

@@ -0,0 +1,5 @@
+export { createMappedTextSegmenter, mapRangeBackToOriginalPos } from './parsedText.js';
+export { createSourceMapCursor } from './SourceMap.js';
+export { createSubstitutionTransformer, SubstitutionTransformer } from './SubstitutionTransformer.js';
+export { excludeRanges, extractRangeText, findMatchingRanges, findMatchingRangesForPatterns } from './TextRange.js';
+//# sourceMappingURL=index.js.map

package/dist/lib/{textValidation → Transform}/parsedText.d.ts

@@ -1,11 +1,10 @@
-import type { MappedText } from '@cspell/cspell-types';
+import type { MappedText, SourceMap } from '@cspell/cspell-types';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
-import type * as TextRange from '../util/TextRange.js';
-export type Offset = number;
-export type SimpleRange = readonly [Offset, Offset];
+import type * as TextRange from './TextRange.js';
+import type { SimpleRange } from './types.js';
 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;
+export declare function mapRangeBackToOriginalPos(offRange: SimpleRange, map: SourceMap | undefined): SimpleRange;
+export declare function mapRangeToLocal(rangeOrig: SimpleRange, map: SourceMap | 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.

package/dist/lib/{textValidation → Transform}/parsedText.js

@@ -1,6 +1,6 @@
-import { extractTextMapRangeOrigin } from '../util/TextMap.js';
+import { calculateRangeInDest, calculateRangeInSrc, extractTextMapRangeOrigin } from './TextMap.js';
 export function mapIssueBackToOriginalPos(mappedText, issue) {
-    if (!mappedText.map || mappedText.map.length === 0)
+    if (!mappedText.map?.length)
         return issue;
     const textOff = mapTextOffsetBackToOriginalPos(mappedText, issue);
     return {
@@ -9,7 +9,7 @@ export function mapIssueBackToOriginalPos(mappedText, issue) {
     };
 }
 function mapTextOffsetBackToOriginalPos(mappedText, textOff) {
-    if (!mappedText.map || !mappedText.map.length)
+    if (!mappedText.map?.length)
         return textOff;
     const off = textOff.offset - mappedText.range[0];
     const range = mapRangeBackToOriginalPos([off, off + (textOff.length ?? textOff.text.length)], mappedText.map);
@@ -22,40 +22,12 @@ function mapTextOffsetBackToOriginalPos(mappedText, textOff) {
 export function mapRangeBackToOriginalPos(offRange, map) {
     if (!map || !map.length)
         return offRange;
-    const [start, end] = offRange;
-    let i = 0, j = 0, p = 1;
-    while (p < map.length && map[p] < start) {
-        i = map[p - 1];
-        j = map[p];
-        p += 2;
-    }
-    const iA = start - j + i;
-    while (p < map.length && map[p] < end) {
-        i = map[p - 1];
-        j = map[p];
-        p += 2;
-    }
-    const iB = end - j + i;
-    return [iA, iB];
+    return calculateRangeInSrc(map, offRange);
 }
 export function mapRangeToLocal(rangeOrig, map) {
-    if (!map || !map.length)
+    if (!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];
+    return calculateRangeInDest(map, rangeOrig);
 }
 /**
  * Factory to create a segmentation function that will segment MappedText against a set of includeRanges.

package/dist/lib/Transform/types.d.ts

@@ -0,0 +1,5 @@
+import type { Range } from '@cspell/cspell-types';
+export type { MappedText, Range } from '@cspell/cspell-types';
+export type Offset = number;
+export type SimpleRange = Readonly<Range>;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/Transform/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/spellCheckFile.d.ts

@@ -1,6 +1,7 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings } from '@cspell/cspell-types';
 import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { Document, DocumentWithText } from './Document/index.js';
+import type { ValidationIssueRPC } from './Models/ValidationIssue.js';
 import type { ImportFileRefWithError } from './Settings/index.js';
 import type { Uri } from './util/IUri.js';
 import type { ValidateTextOptions, ValidationIssue } from './validator.js';
@@ -25,6 +26,9 @@ export interface SpellCheckFileOptions extends ValidateTextOptions, Pick<CSpellU
      */
     noConfigSearch?: boolean;
 }
+export interface SpellCheckFileOptionsRPC extends SpellCheckFileOptions {
+    measurePerf?: boolean;
+}
 export interface SpellCheckFilePerf extends Record<string, number | undefined> {
     loadTimeMs?: number;
     prepareTimeMs?: number;
@@ -43,6 +47,26 @@ export interface SpellCheckFileResult {
     dictionaryErrors?: Map<string, Error[]> | undefined;
     perf?: SpellCheckFilePerf;
 }
+interface DocumentReferenceRPC extends Pick<Document, 'uri'> {
+    text?: undefined;
+    languageId?: undefined;
+    locale?: undefined;
+}
+export interface SpellCheckFileResultRPC {
+    /**
+     * The document that was checked.
+     *
+     * **Note:** the text will be missing to avoid sending large amounts of text over the RPC channel.
+     * If the text is needed, the document should be reloaded using the URI.
+     */
+    document: DocumentReferenceRPC;
+    issues?: ValidationIssueRPC[] | undefined;
+    checked: boolean;
+    errors?: Error[] | undefined;
+    configErrors?: ImportFileRefWithError[] | undefined;
+    dictionaryErrors?: Map<string, Error[]> | undefined;
+    perf?: SpellCheckFilePerf | undefined;
+}
 /**
  * Spell Check a file
  * @param file - absolute path to file to read and check.
@@ -63,7 +87,7 @@ export declare function spellCheckDocument(document: Document | DocumentWithText
  * @param options - options to control checking
  * @param settings - default settings to use.
  */
-export declare function spellCheckDocumentRPC(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
+export declare function spellCheckDocumentRPC(document: Document | DocumentWithText, options: SpellCheckFileOptionsRPC, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResultRPC>;
 export interface DetermineFinalDocumentSettingsResult {
     document: DocumentWithText;
     settings: CSpellSettingsWithSourceTrace;
@@ -81,4 +105,5 @@ export interface DetermineFinalDocumentSettingsResult {
  * @param settings - The near final settings. Should already be the combination of all configuration files.
  */
 export declare function determineFinalDocumentSettings(document: DocumentWithText, settings: CSpellUserSettings): Promise<DetermineFinalDocumentSettingsResult>;
+export {};
 //# sourceMappingURL=spellCheckFile.d.ts.map

package/dist/lib/spellCheckFile.js

@@ -2,12 +2,11 @@ import { satisfiesCSpellConfigFile } from 'cspell-config-lib';
 import { isBinaryDoc } from './Document/isBinaryDoc.js';
 import { documentToTextDocument, resolveDocument } from './Document/resolveDocument.js';
 import { createTextDocument } from './Models/TextDocument.js';
+import { toValidationIssueRPC } from './Models/ValidationIssue.js';
 import { createPerfTimer } from './perf/index.js';
-import { cloneSettingsForExport } from './Settings/sanitizeSettings.js';
 import { determineTextDocumentSettings } from './textValidation/determineTextDocumentSettings.js';
 import { DocumentValidator } from './textValidation/index.js';
 import { isError } from './util/errors.js';
-import { memoizeLastCall } from './util/memoizeLastCall.js';
 import { toUri } from './util/Uri.js';
 /**
  * Spell Check a file
@@ -75,10 +74,6 @@ export async function spellCheckDocument(document, options, settingsOrConfigFile
         };
     }
 }
-const memoizedCloneSettingsForExport = memoizeLastCall(cloneSettingsForExport);
-function sanitizeSettingsForExport(settings) {
-    return settings ? memoizedCloneSettingsForExport(settings) : {};
-}
 /**
  * Spell Check a Document.
  * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
@@ -86,8 +81,26 @@ function sanitizeSettingsForExport(settings) {
  * @param settings - default settings to use.
  */
 export async function spellCheckDocumentRPC(document, options, settingsOrConfigFile) {
-    const result = { ...(await spellCheckDocument(document, options, settingsOrConfigFile)) };
-    result.settingsUsed = sanitizeSettingsForExport(result.settingsUsed);
+    const { issues, checked, errors, configErrors, dictionaryErrors, perf } = await spellCheckDocument(document, options, settingsOrConfigFile);
+    const result = {
+        document: { uri: document.uri },
+        checked,
+    };
+    if (issues.length) {
+        result.issues = issues.map(toValidationIssueRPC);
+    }
+    if (errors?.length) {
+        result.errors = errors;
+    }
+    if (configErrors?.length) {
+        result.configErrors = configErrors;
+    }
+    if (dictionaryErrors?.size) {
+        result.dictionaryErrors = dictionaryErrors;
+    }
+    if (perf && options.measurePerf) {
+        result.perf = perf;
+    }
     return result;
 }
 async function spellCheckFullDocument(document, options, settingsOrConfigFile) {

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

@@ -3,16 +3,13 @@ import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 import type { TextDocument, TextDocumentRef } from '../Models/TextDocument.js';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
-import type { ImportFileRefWithError } from '../Settings/index.js';
-import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Settings/index.js';
+import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized, ImportFileRefWithError } from '../Settings/index.js';
 import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
 import type { WordSuggestion } from '../suggestions.js';
-import type { MatchRange } from '../util/TextRange.js';
-import type { TextValidator } from './lineValidatorFactory.js';
-import type { SimpleRange } from './parsedText.js';
+import type { MatchRange, SimpleRange, SubstitutionTransformer } from '../Transform/index.js';
+import type { TextValidationFactoryOptions, TextValidator } from './lineValidatorFactory.js';
 import type { TraceResult } from './traceWord.js';
 import type { ValidateTextOptions } from './ValidateTextOptions.js';
-import type { ValidationOptions } from './ValidationTypes.js';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
     /**
      * Optional path to a configuration file.
@@ -129,9 +126,10 @@ interface Preparations {
     textValidator: TextValidator;
     segmenter: (texts: MappedText) => Iterable<MappedText>;
     shouldCheck: boolean;
-    validateOptions: ValidationOptions;
+    validateOptions: TextValidationFactoryOptions;
     localConfig: CSpellUserSettings | undefined;
     localConfigFilepath: string | undefined;
+    subTransformer: SubstitutionTransformer;
 }
 interface ShouldCheckDocumentResult {
     /** possible errors found while loading configuration. */

package/dist/lib/textValidation/docValidator.js

@@ -10,6 +10,7 @@ import { extractImportErrors, finalizeSettings, loadConfig, mergeSettings, resol
 import { validateInDocumentSettings } from '../Settings/InDocSettings.js';
 import { getDictionaryInternal } from '../SpellingDictionary/index.js';
 import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
+import { createMappedTextSegmenter, createSubstitutionTransformer } from '../Transform/index.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
@@ -17,7 +18,6 @@ import { cleanValidationIssue } from './cleanValidationIssue.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
-import { createMappedTextSegmenter } from './parsedText.js';
 import { settingsToValidateOptions } from './settingsToValidateOptions.js';
 import { calcTextInclusionRanges } from './textValidator.js';
 import { traceWord } from './traceWord.js';
@@ -101,7 +101,11 @@ export class DocumentValidator {
         recShouldCheckTime();
         const recFinalizeTime = recordPerfTime(this.perfTiming, '_finalizeSettings');
         const finalSettings = finalizeSettings(docSettings);
-        const validateOptions = settingsToValidateOptions(finalSettings);
+        const sub = createSubstitutionTransformer(finalSettings);
+        if (sub.missing) {
+            this.addPossibleError(`Missing substitutions: ${sub.missing.join(', ')}`);
+        }
+        const validateOptions = { ...settingsToValidateOptions(finalSettings), transformer: sub.transformer };
         const includeRanges = calcTextInclusionRanges(this._document.text, validateOptions);
         const segmenter = createMappedTextSegmenter(includeRanges);
         const textValidator = textValidatorFactory(dict, validateOptions);
@@ -118,6 +122,7 @@ export class DocumentValidator {
             textValidator,
             localConfig,
             localConfigFilepath: localConfig?.__importRef?.filename,
+            subTransformer: sub.transformer,
         };
         this._ready = true;
         this._preparationTime = timer.elapsed;
@@ -133,7 +138,11 @@ export class DocumentValidator {
         const stopMeasure = measurePerf('DocumentValidator._updatePrep');
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = finalizeSettings(docSettings);
-        const validateOptions = settingsToValidateOptions(finalSettings);
+        const sub = createSubstitutionTransformer(finalSettings);
+        if (sub.missing) {
+            this.addPossibleError(`Missing substitutions: ${sub.missing.join(', ')}`);
+        }
+        const validateOptions = { ...settingsToValidateOptions(finalSettings), transformer: sub.transformer };
         const includeRanges = calcTextInclusionRanges(this._document.text, validateOptions);
         const segmenter = createMappedTextSegmenter(includeRanges);
         const textValidator = textValidatorFactory(dict, validateOptions);
@@ -322,7 +331,7 @@ export class DocumentValidator {
     addPossibleError(error) {
         if (!error)
             return;
-        error = this.errors.push(toError(error));
+        this.errors.push(toError(error));
     }
     _parse() {
         assert(this._preparations, ERROR_NOT_PREPARED);
@@ -434,7 +443,7 @@ export async function shouldCheckDocument(doc, options, settings) {
     function addPossibleError(error) {
         if (!error)
             return undefined;
-        error = errors.push(toError(error));
+        errors.push(toError(error));
         return undefined;
     }
     async function shouldCheck() {

package/dist/lib/textValidation/index.d.ts

@@ -1,10 +1,10 @@
 export type { ValidationIssue } from '../Models/ValidationIssue.js';
 export type { ValidationResult } from '../Models/ValidationResult.js';
+export type { Offset, SimpleRange } from '../Transform/index.js';
 export type { CheckTextInfo, TextInfoItem } from './checkText.js';
 export { checkText, checkTextDocument, IncludeExcludeFlag } from './checkText.js';
 export type { DocumentValidatorOptions } from './docValidator.js';
 export { DocumentValidator, shouldCheckDocument } from './docValidator.js';
-export type { Offset, SimpleRange } from './parsedText.js';
 export { calcTextInclusionRanges } from './textValidator.js';
 export type { ValidateTextOptions } from './ValidateTextOptions.js';
 export type { CheckOptions, IncludeExcludeOptions, ValidationOptions } from './ValidationTypes.js';

package/dist/lib/textValidation/lineValidatorFactory.d.ts

@@ -1,4 +1,5 @@
 import type { CachingDictionary, SpellingDictionary } from 'cspell-dictionary';
+import type { SubstitutionTransformer } from '../Transform/index.js';
 import type { LineValidatorFn, TextValidatorFn, ValidationOptions } from './ValidationTypes.js';
 interface LineValidator {
     fn: LineValidatorFn;
@@ -9,6 +10,9 @@ export interface TextValidator {
     validate: TextValidatorFn;
     lineValidator: LineValidator;
 }
-export declare function textValidatorFactory(dict: SpellingDictionary, options: ValidationOptions): TextValidator;
+export interface TextValidationFactoryOptions extends ValidationOptions {
+    transformer: SubstitutionTransformer | undefined;
+}
+export declare function textValidatorFactory(dict: SpellingDictionary, options: TextValidationFactoryOptions): TextValidator;
 export {};
 //# sourceMappingURL=lineValidatorFactory.d.ts.map

package/dist/lib/textValidation/lineValidatorFactory.js

@@ -3,6 +3,7 @@ import { opConcatMap, opFilter, pipe } from '@cspell/cspell-pipe/sync';
 import { defaultCSpellSettings, unknownWordsChoices } from '@cspell/cspell-types';
 import { createCachingDictionary } from 'cspell-dictionary';
 import * as RxPat from '../Settings/RegExpPatterns.js';
+import { mapRangeBackToOriginalPos } from '../Transform/index.js';
 import { autoResolve } from '../util/AutoResolve.js';
 import { extractPossibleWordsFromTextOffset, extractText, extractWordsFromTextOffset, splitWordWithOffset, } from '../util/text.js';
 import { regExpCamelCaseWordBreaksWithEnglishSuffix } from '../util/textRegex.js';
@@ -10,7 +11,6 @@ import { split } from '../util/wordSplitter.js';
 import { defaultMinWordLength } from './defaultConstants.js';
 import { extractHexSequences, isRandomString } from './isRandomString.js';
 import { isWordValidWithEscapeRetry } from './isWordValid.js';
-import { mapRangeBackToOriginalPos } from './parsedText.js';
 const MIN_HEX_SEQUENCE_LENGTH = 8;
 export function lineValidatorFactory(sDict, options) {
     const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, unknownWords = unknownWordsChoices.ReportAll, numSuggestions, } = options;
@@ -355,8 +355,10 @@ export function lineValidatorFactory(sDict, options) {
 export function textValidatorFactory(dict, options) {
     const lineValidator = lineValidatorFactory(dict, options);
     const lineValidatorFn = lineValidator.fn;
+    const transformer = options.transformer;
     function validate(pText) {
-        const { text, range: srcRange, map } = pText;
+        const transformedText = transformer?.transform(pText) || pText;
+        const { text, range: srcRange, map } = transformedText;
         const srcOffset = srcRange[0];
         const segment = { text, offset: 0 };
         const lineSegment = { line: segment, segment };
@@ -379,7 +381,7 @@ function filterExcludedTextOffsets(issues, excluded) {
     const keep = [];
     let i = 0;
     let j = 0;
-    for (i = 0; i < issues.length && j < excluded.length; i++) {
+    for (; i < issues.length && j < excluded.length; i++) {
         const issue = issues[i];
         while (j < excluded.length && excluded[j].offset + excluded[j].text.length <= issue.offset) {
             j++;

package/dist/lib/textValidation/settingsToValidateOptions.js

@@ -1,9 +1,18 @@
 export function settingsToValidateOptions(settings) {
     const opt = {
-        ...settings,
+        allowCompoundWords: settings.allowCompoundWords,
+        flagWords: settings.flagWords,
         ignoreCase: !(settings.caseSensitive ?? false),
         ignoreRandomStrings: settings.ignoreRandomStrings,
+        ignoreRegExpList: settings.ignoreRegExpList,
+        includeRegExpList: settings.includeRegExpList,
+        maxDuplicateProblems: settings.maxDuplicateProblems,
+        maxNumberOfProblems: settings.maxNumberOfProblems,
         minRandomLength: settings.minRandomLength,
+        minWordLength: settings.minWordLength,
+        numSuggestions: settings.numSuggestions,
+        suggestionNumChanges: settings.suggestionNumChanges,
+        suggestionsTimeout: settings.suggestionsTimeout,
         unknownWords: settings.unknownWords || 'report-all',
     };
     return opt;

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

@@ -1,6 +1,6 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
 import type { ValidationResult } from '../Models/ValidationResult.js';
-import * as TextRange from '../util/TextRange.js';
+import * as TextRange from '../Transform/index.js';
 import type { IncludeExcludeOptions, LineSegment, ValidationOptions } from './ValidationTypes.js';
 /**
  * @deprecated

package/dist/lib/textValidation/textValidator.js

@@ -1,6 +1,6 @@
 import { opConcatMap, opFilter, opTake, pipe } from '@cspell/cspell-pipe/sync';
+import * as TextRange from '../Transform/index.js';
 import * as Text from '../util/text.js';
-import * as TextRange from '../util/TextRange.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { lineValidatorFactory } from './lineValidatorFactory.js';
 /**

package/dist/lib/util/fileReader.d.ts

@@ -1,3 +1,3 @@
-import { type TextEncoding } from 'cspell-io';
+import type { TextEncoding } from 'cspell-io';
 export declare function readLines(url: URL | string, encoding?: TextEncoding): Promise<IterableIterator<string>>;
 //# sourceMappingURL=fileReader.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.6.4",
+  "version": "9.8.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -46,7 +46,6 @@
     "coverage": "vitest run --coverage --pool=forks",
     "test-watch": "vitest",
     "prepublishOnly": "pnpm run clean-build",
-    "#test": "vitest run --reporter=hanging-process --reporter=default",
     "test": "vitest run --pool=forks",
     "test:update-snapshot": "vitest run -u",
     "test:perf": "NODE_ENV=production insight --file \"**/*.perf.{mjs,js}\"",
@@ -76,23 +75,23 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "9.6.4",
-    "@cspell/cspell-performance-monitor": "9.6.4",
-    "@cspell/cspell-pipe": "9.6.4",
-    "@cspell/cspell-resolver": "9.6.4",
-    "@cspell/cspell-types": "9.6.4",
-    "@cspell/dynamic-import": "9.6.4",
-    "@cspell/filetypes": "9.6.4",
-    "@cspell/rpc": "9.6.4",
-    "@cspell/strong-weak-map": "9.6.4",
-    "@cspell/url": "9.6.4",
+    "@cspell/cspell-bundled-dicts": "9.8.0",
+    "@cspell/cspell-performance-monitor": "9.8.0",
+    "@cspell/cspell-pipe": "9.8.0",
+    "@cspell/cspell-resolver": "9.8.0",
+    "@cspell/cspell-types": "9.8.0",
+    "@cspell/dynamic-import": "9.8.0",
+    "@cspell/filetypes": "9.8.0",
+    "@cspell/rpc": "9.8.0",
+    "@cspell/strong-weak-map": "9.8.0",
+    "@cspell/url": "9.8.0",
     "clear-module": "^4.1.2",
-    "cspell-config-lib": "9.6.4",
-    "cspell-dictionary": "9.6.4",
-    "cspell-glob": "9.6.4",
-    "cspell-grammar": "9.6.4",
-    "cspell-io": "9.6.4",
-    "cspell-trie-lib": "9.6.4",
+    "cspell-config-lib": "9.8.0",
+    "cspell-dictionary": "9.8.0",
+    "cspell-glob": "9.8.0",
+    "cspell-grammar": "9.8.0",
+    "cspell-io": "9.8.0",
+    "cspell-trie-lib": "9.8.0",
     "env-paths": "^4.0.0",
     "gensequence": "^8.0.8",
     "import-fresh": "^3.3.1",
@@ -105,23 +104,24 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@cspell/cspell-tools": "9.6.4",
+    "@cspell/cspell-tools": "9.8.0",
     "@cspell/dict-cpp": "^7.0.2",
     "@cspell/dict-csharp": "^4.0.8",
-    "@cspell/dict-css": "^4.0.19",
-    "@cspell/dict-en_us": "^4.4.28",
+    "@cspell/dict-css": "^4.1.1",
+    "@cspell/dict-en_us": "^4.4.33",
     "@cspell/dict-fa-ir": "^4.0.5",
     "@cspell/dict-fr-fr": "^2.3.2",
-    "@cspell/dict-html": "^4.0.14",
+    "@cspell/dict-html": "^4.0.15",
     "@cspell/dict-nl-nl": "^2.4.2",
-    "@cspell/dict-python": "^4.2.25",
+    "@cspell/dict-python": "^4.2.26",
+    "@cspell/dictionary-bundler-plugin": "",
     "@types/configstore": "^6.0.2",
-    "comment-json": "^4.5.1",
-    "configstore": "^7.1.0",
+    "comment-json": "^4.6.2",
+    "configstore": "^8.0.0",
     "cspell-dict-nl-nl": "^1.1.2",
     "leaked-handles": "^5.2.0",
     "lorem-ipsum": "^2.0.8",
     "perf-insight": "^2.0.1"
   },
-  "gitHead": "e126c7f5708d4258ada35ba1d29d18952d7f0886"
+  "gitHead": "c822013ce676dffb5fa5544567c25a3ae666718f"
 }

package/dist/lib/util/TextMap.d.ts

@@ -1,15 +0,0 @@
-import type { MappedText } from '@cspell/cspell-types';
-import type { 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