cspell-lib 6.0.0 → 6.1.1

package/dist/LanguageIds.js

@@ -24,7 +24,7 @@ exports.languageExtensionDefinitions = [
     { id: 'css', extensions: ['.css'] },
     { id: 'dhall', extensions: ['.dhall'] },
     { id: 'diff', extensions: ['.diff', '.patch', '.rej'] },
-    { id: 'dockerfile', extensions: ['.dockerfile'] },
+    { id: 'dockerfile', extensions: ['.dockerfile'], filenames: ['Dockerfile'] },
     { id: 'elixir', extensions: ['.ex', '.exs'] },
     { id: 'fsharp', extensions: ['.fs', '.fsi', '.fsx', '.fsscript'] },
     { id: 'go', extensions: ['.go'] },
@@ -46,7 +46,7 @@ exports.languageExtensionDefinitions = [
         extensions: ['.json', '.jsonc', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.webmanifest'],
     },
     { id: 'jsonc', extensions: ['.jsonc'] },
-    { id: 'jsonc', extensions: [], filenames: ['.code-workspace'] },
+    { id: 'jsonc', extensions: ['.code-workspace'], filenames: ['.code-workspace'] },
     { id: 'jungle', extensions: ['.jungle'] },
     { id: 'less', extensions: ['.less'] },
     { id: 'literate haskell', extensions: ['.lhs'] },

package/dist/Models/TextDocument.d.ts

@@ -44,6 +44,8 @@ export interface TextDocument {
     positionAt(offset: number): Position;
     offsetAt(position: Position): number;
     lineAt(offset: number): TextDocumentLine;
+    getLine(lineNum: number): TextDocumentLine;
+    getLines(): Iterable<TextDocumentLine>;
 }
 export interface CreateTextDocumentParams {
     uri: DocumentUri | string;
@@ -58,4 +60,5 @@ export interface TextDocumentContentChangeEvent {
 }
 export declare function createTextDocument({ uri, content, languageId, locale, version, }: CreateTextDocumentParams): TextDocument;
 export declare function updateTextDocument(doc: TextDocument, edits: TextDocumentContentChangeEvent[], version?: number): TextDocument;
+export declare const isTextDocument: (doc: TextDocument | unknown) => doc is TextDocument;
 //# sourceMappingURL=TextDocument.d.ts.map

package/dist/Models/TextDocument.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateTextDocument = exports.createTextDocument = void 0;
+exports.isTextDocument = exports.updateTextDocument = exports.createTextDocument = void 0;
 const LanguageIds_1 = require("../LanguageIds");
 const Uri = __importStar(require("./Uri"));
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
@@ -53,22 +53,43 @@ class TextDocumentImpl {
     }
     lineAt(offset) {
         const position = this.vsTextDoc.positionAt(offset);
-        position.character = 0;
-        const lineOffset = this.vsTextDoc.offsetAt(position);
+        return this.getLine(position.line);
+    }
+    getLine(lineNum) {
+        const position = { line: lineNum, character: 0 };
+        const end = { line: lineNum + 1, character: 0 };
         const range = {
             start: position,
-            end: { line: position.line + 1, character: 0 },
+            end,
         };
-        let _text;
-        const getText = () => this.vsTextDoc.getText(range);
+        const lineOffset = this.vsTextDoc.offsetAt(position);
+        const text = this.vsTextDoc.getText(range);
         return {
-            get text() {
-                return _text !== null && _text !== void 0 ? _text : (_text = getText());
-            },
+            text,
             offset: lineOffset,
             position,
         };
     }
+    /**
+     * Iterate over the lines of a document one-by-one.
+     * Changing the document between iterations can change the result
+     */
+    *getLines() {
+        const range = {
+            start: { line: 0, character: 0 },
+            end: { line: 1, character: 0 },
+        };
+        while (this.vsTextDoc.offsetAt(range.end) > this.vsTextDoc.offsetAt(range.start)) {
+            const offset = this.vsTextDoc.offsetAt(range.start);
+            yield {
+                text: this.vsTextDoc.getText(range),
+                offset,
+                position: range.start,
+            };
+            ++range.start.line;
+            ++range.end.line;
+        }
+    }
     /**
      * Apply edits to the text.
      * Note: the edits are applied one after the other.
@@ -99,8 +120,12 @@ function createTextDocument({ uri, content, languageId, locale, version, }) {
 }
 exports.createTextDocument = createTextDocument;
 function updateTextDocument(doc, edits, version) {
-    (0, assert_1.default)(doc instanceof TextDocumentImpl, 'Unknown TextDocument type');
+    (0, assert_1.default)(isTextDocumentImpl(doc), 'Unknown TextDocument type');
     return doc.update(edits, version);
 }
 exports.updateTextDocument = updateTextDocument;
+function isTextDocumentImpl(doc) {
+    return doc instanceof TextDocumentImpl;
+}
+exports.isTextDocument = isTextDocumentImpl;
 //# sourceMappingURL=TextDocument.js.map

package/dist/spellCheckFile.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileToDocument = exports.isBinaryFile = exports.isBinaryDoc = exports.determineFinalDocumentSettings = exports.spellCheckDocument = exports.spellCheckFile = void 0;
-const cspell_glob_1 = require("cspell-glob");
 const fs_extra_1 = require("fs-extra");
 const vscode_uri_1 = require("vscode-uri");
-const determineTextDocumentSettings_1 = require("./textValidation/determineTextDocumentSettings");
 const LanguageIds_1 = require("./LanguageIds");
 const TextDocument_1 = require("./Models/TextDocument");
-const Settings_1 = require("./Settings");
+const textValidation_1 = require("./textValidation");
+const determineTextDocumentSettings_1 = require("./textValidation/determineTextDocumentSettings");
 const errors_1 = require("./util/errors");
 const util_1 = require("./util/util");
-const validator_1 = require("./validator");
 const defaultEncoding = 'utf8';
 /**
  * Spell Check a file
@@ -61,64 +59,35 @@ async function spellCheckDocument(document, options, settings) {
 }
 exports.spellCheckDocument = spellCheckDocument;
 async function spellCheckFullDocument(document, options, settings) {
-    var _a, _b, _c, _d;
-    const errors = [];
-    function addPossibleError(error) {
-        if (!error)
-            return;
-        errors.push(error);
-    }
-    function catchError(p) {
-        return p.catch((error) => {
-            addPossibleError(error);
-            return undefined;
-        });
-    }
-    const useSearchForConfig = (!options.noConfigSearch && !settings.noConfigSearch) || options.noConfigSearch === false;
-    const pLocalConfig = options.configFile
-        ? catchError((0, Settings_1.loadConfig)(options.configFile, settings))
-        : useSearchForConfig
-            ? catchError(searchForDocumentConfig(document, settings, settings))
-            : undefined;
-    const localConfig = await pLocalConfig;
-    addPossibleError((_a = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _a === void 0 ? void 0 : _a.error);
-    if (errors.length) {
+    const { uri, text: content, languageId, locale } = document;
+    const doc = (0, TextDocument_1.createTextDocument)({ uri, content, languageId, locale });
+    const docValOptions = options;
+    const docValidator = new textValidation_1.DocumentValidator(doc, docValOptions, settings);
+    await docValidator.prepare();
+    const prep = docValidator._getPreparations();
+    if (docValidator.errors.length) {
         return {
             document,
             options,
-            settingsUsed: localConfig || settings,
-            localConfigFilepath: (_b = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _b === void 0 ? void 0 : _b.filename,
+            settingsUsed: (prep === null || prep === void 0 ? void 0 : prep.localConfig) || settings,
+            localConfigFilepath: prep === null || prep === void 0 ? void 0 : prep.localConfigFilepath,
             issues: [],
             checked: false,
-            errors,
+            errors: docValidator.errors,
         };
     }
-    const matcher = new cspell_glob_1.GlobMatcher((localConfig === null || localConfig === void 0 ? void 0 : localConfig.ignorePaths) || [], { root: process.cwd(), dot: true });
-    const config = localConfig ? (0, Settings_1.mergeSettings)(settings, localConfig) : settings;
-    const docSettings = determineFinalDocumentSettings(document, config);
-    const uri = vscode_uri_1.URI.parse(document.uri);
-    const shouldCheck = !matcher.match(uri.fsPath) && ((_c = docSettings.settings.enabled) !== null && _c !== void 0 ? _c : true);
-    const { generateSuggestions, numSuggestions } = options;
-    const validateOptions = (0, util_1.clean)({ generateSuggestions, numSuggestions });
-    const issues = shouldCheck ? await (0, validator_1.validateText)(document.text, docSettings.settings, validateOptions) : [];
+    const issues = docValidator.checkDocument();
     const result = {
         document,
         options,
-        settingsUsed: docSettings.settings,
-        localConfigFilepath: (_d = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _d === void 0 ? void 0 : _d.filename,
+        settingsUsed: docValidator.getFinalizedDocSettings(),
+        localConfigFilepath: prep === null || prep === void 0 ? void 0 : prep.localConfigFilepath,
         issues,
-        checked: shouldCheck,
+        checked: docValidator.shouldCheckDocument(),
         errors: undefined,
     };
     return result;
 }
-async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
-    const { uri } = document;
-    const u = vscode_uri_1.URI.parse(uri);
-    if (u.scheme !== 'file')
-        return Promise.resolve(defaultConfig);
-    return (0, Settings_1.searchForConfig)(u.fsPath, pnpSettings).then((s) => s || defaultConfig);
-}
 async function readDocument(filename, encoding = defaultEncoding) {
     const text = await (0, fs_extra_1.readFile)(filename, encoding);
     const uri = vscode_uri_1.URI.file(filename).toString();

package/dist/textValidation/docValidator.d.ts

@@ -1,5 +1,10 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
+import { CSpellSettingsInternal } 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 { ValidateTextOptions, ValidationIssue } from './validator';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
     /**
@@ -41,15 +46,44 @@ export declare class DocumentValidator {
      * The amount of time in ms to prepare for validation.
      */
     get prepTime(): number;
-    checkText(range: SimpleRange, _text: string, _scope: string[]): ValidationIssue[];
+    checkText(range: SimpleRange, _text: string, scope: string[]): ValidationIssue[];
+    check(parsedText: ParsedText): ValidationIssue[];
+    checkDocument(forceCheck?: boolean): ValidationIssue[];
     get document(): TextDocument;
     updateDocumentText(text: string): void;
+    private checkDocumentLines;
     private addPossibleError;
     private catchError;
     private errorCatcherWrapper;
     private suggest;
     private genSuggestions;
+    getFinalizedDocSettings(): CSpellSettingsInternal;
+    /**
+     * Returns true if the final result of the configuration calculation results
+     * in the document being enabled. Note: in some cases, checking the document
+     * might still make sense, for example, the `@cspell/eslint-plugin` relies on
+     * `eslint` configuration to make that determination.
+     * @returns true if the document settings have resolved to be `enabled`
+     */
+    shouldCheckDocument(): boolean;
+    /**
+     * Internal `cspell-lib` use.
+     */
+    _getPreparations(): Preparations | undefined;
+}
+interface Preparations {
+    /** loaded config */
+    config: CSpellSettingsInternal;
+    dictionary: SpellingDictionaryCollection;
+    /** configuration after applying in-doc settings */
+    docSettings: CSpellSettingsInternal;
+    includeRanges: MatchRange[];
+    lineValidator: LineValidator;
+    segmenter: (lineSegment: LineSegment) => LineSegment[];
+    shouldCheck: boolean;
+    validateOptions: ValidationOptions;
+    localConfig: CSpellUserSettings | undefined;
+    localConfigFilepath: string | undefined;
 }
-export declare type Offset = number;
-export declare type SimpleRange = readonly [Offset, Offset];
+export {};
 //# sourceMappingURL=docValidator.d.ts.map

package/dist/textValidation/docValidator.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentValidator = void 0;
 const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const assert_1 = __importDefault(require("assert"));
+const cspell_glob_1 = require("cspell-glob");
 const TextDocument_1 = require("../Models/TextDocument");
 const Settings_1 = require("../Settings");
 const configLoader_1 = require("../Settings/configLoader");
@@ -18,6 +19,7 @@ const util_1 = require("../util/util");
 const determineTextDocumentSettings_1 = require("./determineTextDocumentSettings");
 const textValidator_1 = require("./textValidator");
 const validator_1 = require("./validator");
+const ERROR_NOT_PREPARED = 'Validator Must be prepared before calling this function.';
 class DocumentValidator {
     /**
      * @param doc - Document to validate
@@ -37,7 +39,7 @@ class DocumentValidator {
         return this._ready;
     }
     prepareSync() {
-        var _a, _b;
+        var _a, _b, _c;
         // @todo
         // Determine doc settings.
         // Calc include ranges
@@ -57,7 +59,9 @@ class DocumentValidator {
         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 shouldCheck = (_b = docSettings.enabled) !== null && _b !== void 0 ? _b : true;
+        const matcher = new cspell_glob_1.GlobMatcher((localConfig === null || localConfig === void 0 ? void 0 : 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 finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
@@ -72,6 +76,8 @@ class DocumentValidator {
             includeRanges,
             segmenter,
             lineValidator,
+            localConfig,
+            localConfigFilepath: (_c = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _c === void 0 ? void 0 : _c.filename,
         };
         this._ready = true;
         this._preparationTime = timer.elapsed();
@@ -86,7 +92,7 @@ class DocumentValidator {
         return this._prepared;
     }
     async _prepareAsync() {
-        var _a, _b;
+        var _a, _b, _c;
         (0, assert_1.default)(!this._ready);
         const timer = (0, timer_1.createTimer)();
         const { options, settings } = this;
@@ -101,7 +107,9 @@ class DocumentValidator {
         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 shouldCheck = (_b = docSettings.enabled) !== null && _b !== void 0 ? _b : true;
+        const matcher = new cspell_glob_1.GlobMatcher((localConfig === null || localConfig === void 0 ? void 0 : 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 finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
@@ -116,16 +124,18 @@ class DocumentValidator {
             includeRanges,
             segmenter,
             lineValidator,
+            localConfig,
+            localConfigFilepath: (_c = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _c === void 0 ? void 0 : _c.filename,
         };
         this._ready = true;
         this._preparationTime = timer.elapsed();
     }
     _updatePrep() {
         var _a;
-        (0, assert_1.default)(this._preparations);
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const timer = (0, timer_1.createTimer)();
-        const { config } = this._preparations;
-        const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, config);
+        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 finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
@@ -134,7 +144,7 @@ class DocumentValidator {
         const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
         const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
         this._preparations = {
-            config,
+            ...prep,
             dictionary: dict,
             docSettings,
             shouldCheck,
@@ -151,16 +161,19 @@ class DocumentValidator {
     get prepTime() {
         return this._preparationTime;
     }
-    checkText(range, _text, _scope) {
+    checkText(range, _text, scope) {
+        const text = this._document.text.slice(range[0], range[1]);
+        return this.check({ text, range, scope });
+    }
+    check(parsedText) {
         (0, assert_1.default)(this._ready);
-        (0, assert_1.default)(this._preparations);
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
+        const { range, text } = parsedText;
         const { segmenter, lineValidator } = this._preparations;
         // Determine settings for text range
         // Slice text based upon include ranges
         // Check text against dictionaries.
         const offset = range[0];
-        const offsetEnd = range[1];
-        const text = this._document.text.slice(offset, offsetEnd);
         const line = this._document.lineAt(offset);
         const lineSeg = {
             line,
@@ -182,6 +195,11 @@ class DocumentValidator {
         });
         return withSugs;
     }
+    checkDocument(forceCheck = false) {
+        (0, assert_1.default)(this._ready);
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
+        return forceCheck || this.shouldCheckDocument() ? [...this.checkDocumentLines()] : [];
+    }
     get document() {
         return this._document;
     }
@@ -189,6 +207,26 @@ class DocumentValidator {
         (0, TextDocument_1.updateTextDocument)(this._document, [{ text }]);
         this._updatePrep();
     }
+    *checkDocumentLines() {
+        (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 })) {
+                const { text } = issue;
+                const n = (mapOfProblems.get(text) || 0) + 1;
+                mapOfProblems.set(text, n);
+                if (n > maxDuplicateProblems)
+                    continue;
+                yield issue;
+                if (++numProblems >= maxNumberOfProblems)
+                    return;
+            }
+        }
+    }
     addPossibleError(error) {
         if (!error)
             return;
@@ -214,7 +252,7 @@ class DocumentValidator {
     }
     genSuggestions(text) {
         var _a;
-        (0, assert_1.default)(this._preparations);
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const settings = this._preparations.docSettings;
         const dict = this._preparations.dictionary;
         const sugOptions = (0, util_1.clean)({
@@ -227,6 +265,28 @@ class DocumentValidator {
         });
         return dict.suggest(text, sugOptions).map((r) => r.word);
     }
+    getFinalizedDocSettings() {
+        (0, assert_1.default)(this._ready);
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
+        return this._preparations.docSettings;
+    }
+    /**
+     * Returns true if the final result of the configuration calculation results
+     * in the document being enabled. Note: in some cases, checking the document
+     * might still make sense, for example, the `@cspell/eslint-plugin` relies on
+     * `eslint` configuration to make that determination.
+     * @returns true if the document settings have resolved to be `enabled`
+     */
+    shouldCheckDocument() {
+        (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
+        return this._preparations.shouldCheck;
+    }
+    /**
+     * Internal `cspell-lib` use.
+     */
+    _getPreparations() {
+        return this._preparations;
+    }
 }
 exports.DocumentValidator = DocumentValidator;
 async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {

package/dist/textValidation/index.d.ts

@@ -4,4 +4,5 @@ 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';
 //# sourceMappingURL=index.d.ts.map

package/dist/textValidation/parsedText.d.ts

@@ -0,0 +1,21 @@
+import { ValidationIssue } from './validator';
+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;
+//# sourceMappingURL=parsedText.d.ts.map

package/dist/textValidation/parsedText.js

@@ -0,0 +1,46 @@
+"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)
+        return issue;
+    const textOff = mapTextOffsetBackToOriginalPos(parsedText, issue);
+    return {
+        ...issue,
+        ...textOff,
+    };
+}
+exports.mapIssueBackToOriginalPos = mapIssueBackToOriginalPos;
+function mapTextOffsetBackToOriginalPos(parsedText, textOff) {
+    var _a;
+    if (!parsedText.map || !parsedText.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);
+    return {
+        text: textOff.text,
+        offset: parsedText.range[0] + range[0],
+        length: range[1] - range[0],
+    };
+}
+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];
+}
+exports.mapRangeBackToOriginalPos = mapRangeBackToOriginalPos;
+//# sourceMappingURL=parsedText.js.map

package/dist/util/logger.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 declare type Console = typeof console;
 export interface Logger {
     log: Console['log'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.0.0",
+  "version": "6.1.1",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,24 +48,24 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^6.0.0",
-    "@cspell/cspell-pipe": "^6.0.0",
-    "@cspell/cspell-types": "^6.0.0",
+    "@cspell/cspell-bundled-dicts": "^6.1.1",
+    "@cspell/cspell-pipe": "^6.1.1",
+    "@cspell/cspell-types": "^6.1.1",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.2",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-glob": "^6.0.0",
-    "cspell-io": "^6.0.0",
-    "cspell-trie-lib": "^6.0.0",
-    "fast-equals": "^3.0.2",
+    "cspell-glob": "^6.1.1",
+    "cspell-io": "^6.1.1",
+    "cspell-trie-lib": "^6.1.1",
+    "fast-equals": "^3.0.3",
     "find-up": "^5.0.0",
     "fs-extra": "^10.1.0",
     "gensequence": "^3.1.1",
     "import-fresh": "^3.3.0",
     "resolve-from": "^5.0.0",
     "resolve-global": "^1.0.0",
-    "vscode-languageserver-textdocument": "^1.0.4",
+    "vscode-languageserver-textdocument": "^1.0.5",
     "vscode-uri": "^3.0.3"
   },
   "engines": {
@@ -83,14 +83,14 @@
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.5.1",
-    "@types/node": "^17.0.35",
+    "@types/node": "^17.0.36",
     "cspell-dict-nl-nl": "^1.1.2",
     "jest": "^28.1.0",
     "lorem-ipsum": "^2.0.4",
     "rimraf": "^3.0.2",
-    "rollup": "^2.74.1",
-    "rollup-plugin-dts": "^4.2.1",
-    "ts-jest": "^28.0.2"
+    "rollup": "^2.75.4",
+    "rollup-plugin-dts": "^4.2.2",
+    "ts-jest": "^28.0.3"
   },
-  "gitHead": "7fd3e4ff8738a84d0aa48b9a9d4581b5efe50bea"
+  "gitHead": "e871153bfebefa19b13754b431ce5e49a63da298"
 }