cspell-lib 6.26.2 → 6.27.0

package/dist/textValidation/docValidator.js

@@ -3,11 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentValidator = void 0;
+exports.shouldCheckDocument = exports.DocumentValidator = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_types_1 = require("@cspell/cspell-types");
 const assert_1 = __importDefault(require("assert"));
 const cspell_glob_1 = require("cspell-glob");
+const path_1 = __importDefault(require("path"));
 const TextDocument_1 = require("../Models/TextDocument");
 const Settings_1 = require("../Settings");
 const configLoader_1 = require("../Settings/Controller/configLoader");
@@ -17,6 +18,7 @@ const suggestions_1 = require("../suggestions");
 const errors_1 = require("../util/errors");
 const simpleCache_1 = require("../util/simpleCache");
 const timer_1 = require("../util/timer");
+const Uri_1 = require("../util/Uri");
 const defaultConstants_1 = require("./defaultConstants");
 const determineTextDocumentSettings_1 = require("./determineTextDocumentSettings");
 const lineValidatorFactory_1 = require("./lineValidatorFactory");
@@ -24,6 +26,7 @@ const parsedText_1 = require("./parsedText");
 const settingsToValidateOptions_1 = require("./settingsToValidateOptions");
 const textValidator_1 = require("./textValidator");
 const ERROR_NOT_PREPARED = 'Validator Must be prepared before calling this function.';
+const skipValidation = false;
 class DocumentValidator {
     /**
      * @param doc - Document to validate
@@ -75,7 +78,7 @@ class DocumentValidator {
         const dict = (0, SpellingDictionary_1.getDictionaryInternalSync)(docSettings);
         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) && (docSettings.enabled ?? true);
+        const shouldCheck = !matcher.match((0, Uri_1.uriToFilePath)(uri)) && (docSettings.enabled ?? true);
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, settingsToValidateOptions_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
@@ -123,7 +126,7 @@ class DocumentValidator {
         const dict = await (0, SpellingDictionary_1.getDictionaryInternal)(docSettings);
         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) && (docSettings.enabled ?? true);
+        const shouldCheck = !matcher.match((0, Uri_1.uriToFilePath)(uri)) && (docSettings.enabled ?? true);
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
         const validateOptions = (0, settingsToValidateOptions_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
@@ -232,6 +235,8 @@ class DocumentValidator {
      * @returns the validation issues.
      */
     checkDocument(forceCheck = false) {
+        if (skipValidation)
+            return [];
         (0, assert_1.default)(this._ready);
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const spellingIssues = forceCheck || this.shouldCheckDocument() ? [...this._checkParsedText(this._parse())] : [];
@@ -375,12 +380,43 @@ async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
     const { uri } = document;
     if (uri.scheme !== 'file')
         return Promise.resolve(defaultConfig);
-    return (0, Settings_1.searchForConfig)(uri.fsPath, pnpSettings).then((s) => s || defaultConfig);
+    return (0, Settings_1.searchForConfig)(path_1.default.dirname((0, Uri_1.uriToFilePath)(uri)), pnpSettings).then((s) => s || defaultConfig);
 }
 function searchForDocumentConfigSync(document, defaultConfig, pnpSettings) {
     const { uri } = document;
     if (uri.scheme !== 'file')
         defaultConfig;
-    return (0, configLoader_1.searchForConfigSync)(uri.fsPath, pnpSettings) || defaultConfig;
+    return (0, configLoader_1.searchForConfigSync)((0, Uri_1.uriToFilePath)(uri), pnpSettings) || defaultConfig;
+}
+async function shouldCheckDocument(doc, options, settings) {
+    const errors = [];
+    function addPossibleError(error) {
+        if (!error)
+            return;
+        error = errors.push((0, errors_1.toError)(error));
+    }
+    function catchError(p) {
+        return p.catch((error) => {
+            addPossibleError(error);
+            return undefined;
+        });
+    }
+    async function shouldCheck() {
+        const useSearchForConfig = (!options.noConfigSearch && !settings.noConfigSearch) || options.noConfigSearch === false;
+        const pLocalConfig = options.configFile
+            ? catchError((0, Settings_1.loadConfig)(options.configFile, settings))
+            : useSearchForConfig
+                ? catchError(searchForDocumentConfig(doc, settings, settings))
+                : undefined;
+        const localConfig = (await pLocalConfig) || {};
+        addPossibleError(localConfig?.__importRef?.error);
+        const config = (0, Settings_1.mergeSettings)(settings, localConfig);
+        const matcher = new cspell_glob_1.GlobMatcher(localConfig?.ignorePaths || [], { root: process.cwd(), dot: true });
+        const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(doc, config);
+        const uri = doc.uri;
+        return !matcher.match((0, Uri_1.uriToFilePath)(uri)) && (docSettings.enabled ?? true);
+    }
+    return { errors, shouldCheck: await shouldCheck() };
 }
+exports.shouldCheckDocument = shouldCheckDocument;
 //# sourceMappingURL=docValidator.js.map

package/dist/textValidation/index.d.ts

@@ -3,7 +3,7 @@ export type { ValidationResult } from '../Models/ValidationResult';
 export type { CheckTextInfo, TextInfoItem } from './checkText';
 export { checkText, checkTextDocument, IncludeExcludeFlag } from './checkText';
 export type { DocumentValidatorOptions } from './docValidator';
-export { DocumentValidator } from './docValidator';
+export { DocumentValidator, shouldCheckDocument } from './docValidator';
 export type { Offset, SimpleRange } from './parsedText';
 export { calcTextInclusionRanges } from './textValidator';
 export type { ValidateTextOptions } from './ValidateTextOptions';

package/dist/textValidation/index.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateText = exports.calcTextInclusionRanges = exports.DocumentValidator = exports.IncludeExcludeFlag = exports.checkTextDocument = exports.checkText = void 0;
+exports.validateText = exports.calcTextInclusionRanges = exports.shouldCheckDocument = exports.DocumentValidator = exports.IncludeExcludeFlag = exports.checkTextDocument = exports.checkText = void 0;
 var checkText_1 = require("./checkText");
 Object.defineProperty(exports, "checkText", { enumerable: true, get: function () { return checkText_1.checkText; } });
 Object.defineProperty(exports, "checkTextDocument", { enumerable: true, get: function () { return checkText_1.checkTextDocument; } });
 Object.defineProperty(exports, "IncludeExcludeFlag", { enumerable: true, get: function () { return checkText_1.IncludeExcludeFlag; } });
 var docValidator_1 = require("./docValidator");
 Object.defineProperty(exports, "DocumentValidator", { enumerable: true, get: function () { return docValidator_1.DocumentValidator; } });
+Object.defineProperty(exports, "shouldCheckDocument", { enumerable: true, get: function () { return docValidator_1.shouldCheckDocument; } });
 var textValidator_1 = require("./textValidator");
 Object.defineProperty(exports, "calcTextInclusionRanges", { enumerable: true, get: function () { return textValidator_1.calcTextInclusionRanges; } });
 var validator_1 = require("./validator");

package/dist/util/AutoResolveLRUCache.d.ts

@@ -0,0 +1,54 @@
+interface LLNode<T> {
+    value: T;
+    n?: LLNode<T> | undefined;
+    p?: LLNode<T> | undefined;
+}
+interface LL<T> {
+    n?: LLNode<T> | undefined;
+    p?: LLNode<T> | undefined;
+}
+export declare class AutoResolveLRUCache<T, V> {
+    readonly maxSize: number;
+    readonly isEqual: (a: T, b: T) => boolean;
+    protected list: LL<{
+        p: T;
+        r: V;
+    }>;
+    private count;
+    private _misses;
+    private _hits;
+    private _added;
+    private _removed;
+    constructor(maxSize: number, isEqual: (a: T, b: T) => boolean);
+    get(params: T): V | undefined;
+    get(params: T, fn: (p: T) => V): V;
+    get(params: T, fn?: (p: T) => V): V | undefined;
+    get size(): number;
+    get hits(): number;
+    get misses(): number;
+    get added(): number;
+    get removed(): number;
+    clear(): void;
+    private addToHead;
+    stats(): {
+        size: number;
+        hits: number;
+        misses: number;
+        added: number;
+        removed: number;
+    };
+    toJSON(): {
+        size: number;
+        hits: number;
+        misses: number;
+        added: number;
+        removed: number;
+    };
+    static assertValid<T, V>(cache: AutoResolveLRUCache<T, V>): void;
+}
+export declare function assertValidateLL<T>(list: LL<T>): void;
+export declare class AutoResolveLastNCalls<Params extends unknown[], Result> extends AutoResolveLRUCache<Params, Result> {
+    constructor(maxSize: number);
+}
+export {};
+//# sourceMappingURL=AutoResolveLRUCache.d.ts.map

package/dist/util/AutoResolveLRUCache.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoResolveLastNCalls = exports.assertValidateLL = exports.AutoResolveLRUCache = void 0;
+const assert_1 = __importDefault(require("assert"));
+const util_1 = require("./util");
+class AutoResolveLRUCache {
+    constructor(maxSize, isEqual) {
+        this.maxSize = maxSize;
+        this.isEqual = isEqual;
+        this.list = {};
+        this.count = 0;
+        this._misses = 0;
+        this._hits = 0;
+        this._added = 0;
+        this._removed = 0;
+        (0, assert_1.default)(maxSize > 0);
+    }
+    get(params, fn) {
+        const isEqual = this.isEqual;
+        for (let n = this.list.n; n; n = n.n) {
+            if (isEqual(n.value.p, params)) {
+                this.addToHead(n);
+                ++this._hits;
+                return n.value.r;
+            }
+        }
+        ++this._misses;
+        if (!fn)
+            return undefined;
+        const value = {
+            p: params,
+            r: fn(params),
+        };
+        this.addToHead({ value, n: undefined, p: undefined });
+        return value.r;
+    }
+    get size() {
+        return this.count;
+    }
+    get hits() {
+        return this._hits;
+    }
+    get misses() {
+        return this._misses;
+    }
+    get added() {
+        return this._added;
+    }
+    get removed() {
+        return this._removed;
+    }
+    clear() {
+        this._added = 0;
+        this._hits = 0;
+        this._misses = 0;
+        this._removed = 0;
+        this.list.n = undefined;
+        this.list.p = undefined;
+        this.count = 0;
+    }
+    addToHead(n) {
+        if (!this.list.n) {
+            this.list.n = n;
+            this.list.p = n;
+            n.n = undefined;
+            n.p = undefined;
+            this.count = 1;
+            this._added = 1;
+            return;
+        }
+        if (this.list.n === n)
+            return;
+        if (this.list.p === n) {
+            this.list.p = n.p;
+        }
+        const isNew = !n.n && !n.p;
+        n.p && (n.p.n = n.n);
+        n.n && (n.n.p = n.p);
+        n.p = undefined;
+        n.n = this.list.n;
+        n.n && (n.n.p = n);
+        this.list.n = n;
+        const add = (isNew && 1) || 0;
+        this._added += add;
+        this.count += add;
+        if (this.count > this.maxSize) {
+            const prev = this.list.p?.p;
+            (0, assert_1.default)(prev);
+            prev.n = undefined;
+            this.list.p = prev;
+            ++this._removed;
+            --this.count;
+        }
+    }
+    stats() {
+        return { size: this.count, hits: this.hits, misses: this.misses, added: this.added, removed: this.removed };
+    }
+    toJSON() {
+        return this.stats();
+    }
+    static assertValid(cache) {
+        assertValidateLL(cache.list);
+    }
+}
+exports.AutoResolveLRUCache = AutoResolveLRUCache;
+function assertValidateLL(list) {
+    if (!list.n && !list.p)
+        return;
+    (0, assert_1.default)(list.n, 'Bad Next');
+    (0, assert_1.default)(list.p, 'Bad Prev');
+    const visited = new Set();
+    // validate forwards
+    let n = list;
+    for (; n.n; n = n.n) {
+        (0, assert_1.default)(!visited.has(n.n), 'Circular');
+        visited.add(n.n);
+    }
+    (0, assert_1.default)(list.p === n, 'Tail matches');
+    visited.clear();
+    // validate backwards
+    n = list;
+    for (; n.p; n = n.p) {
+        (0, assert_1.default)(!visited.has(n.p), 'Circular');
+        visited.add(n.p);
+    }
+    (0, assert_1.default)(list.n === n, 'Head matches');
+}
+exports.assertValidateLL = assertValidateLL;
+class AutoResolveLastNCalls extends AutoResolveLRUCache {
+    constructor(maxSize) {
+        super(maxSize, util_1.isArrayEqual);
+    }
+}
+exports.AutoResolveLastNCalls = AutoResolveLastNCalls;
+//# sourceMappingURL=AutoResolveLRUCache.js.map

package/dist/util/Uri.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+export interface Uri {
+    readonly scheme: string;
+    readonly path: string;
+    readonly authority?: string;
+    readonly fragment?: string;
+    readonly query?: string;
+}
+export interface UriInstance extends Uri {
+    toString(): string;
+}
+export declare function toUri(uriOrFile: string | Uri | URL): UriInstance;
+export declare function uriToFilePath(uri: Uri): string;
+export declare function fromFilePath(file: string): UriInstance;
+export declare function fromStdinFilePath(path?: string): UriInstance;
+export declare const file: typeof fromFilePath;
+export declare function parse(uri: string): UriInstance;
+export declare function normalizeDriveLetter(path: string): string;
+export declare function isUri(uri: unknown): uri is UriInstance;
+export declare function basename(uri: Uri): string;
+export declare function dirname(uri: Uri): UriInstance;
+export declare function extname(uri: Uri): string;
+export declare function joinPath(uri: Uri, ...paths: string[]): UriInstance;
+export declare function resolvePath(uri: Uri, ...paths: string[]): UriInstance;
+export declare function from(uri: Uri, ...parts: Partial<Uri>[]): UriInstance;
+declare class UriImpl implements UriInstance {
+    readonly scheme: string;
+    readonly authority?: string;
+    readonly path: string;
+    readonly query?: string;
+    readonly fragment?: string;
+    constructor(uri: PartialWithUndefined<Uri>);
+    toString(): string;
+    toJson(): PartialWithUndefined<Uri>;
+    with(change: Partial<Uri>): UriImpl;
+    static isUri(uri: unknown): uri is UriImpl;
+    static from(uri: Uri, ...parts: Partial<Uri>[]): UriImpl;
+    static parse(uri: string): UriImpl;
+    static file(filename: string): UriImpl;
+    static stdin(filePath?: string): UriImpl;
+}
+declare function normalizeFilePath(path: string): string;
+type PartialWithUndefined<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+export declare const __testing__: {
+    UriImpl: typeof UriImpl;
+    normalizeFilePath: typeof normalizeFilePath;
+};
+export {};
+//# sourceMappingURL=Uri.d.ts.map

package/dist/util/Uri.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.from = exports.resolvePath = exports.joinPath = exports.extname = exports.dirname = exports.basename = exports.isUri = exports.normalizeDriveLetter = exports.parse = exports.file = exports.fromStdinFilePath = exports.fromFilePath = exports.uriToFilePath = exports.toUri = void 0;
+const assert_1 = __importDefault(require("assert"));
+const vscode_uri_1 = require("vscode-uri");
+const isFile = /^(?:[a-zA-Z]:|[/\\])/;
+const isPossibleUri = /\w:\/\//;
+const isUrl = /^(file:|stdin:|https?:|s?ftp:)/;
+const STDIN_PROTOCOL = 'stdin:';
+function toUri(uriOrFile) {
+    if (UriImpl.isUri(uriOrFile))
+        return uriOrFile;
+    if (vscode_uri_1.URI.isUri(uriOrFile))
+        return UriImpl.from(uriOrFile);
+    if (uriOrFile instanceof URL)
+        return UriImpl.parse(uriOrFile.toString());
+    if (isUrlLike(uriOrFile))
+        return UriImpl.parse(uriOrFile.href);
+    if (isUri(uriOrFile))
+        return UriImpl.from(uriOrFile);
+    if (isUrl.test(uriOrFile))
+        return UriImpl.parse(uriOrFile);
+    return isFile.test(uriOrFile) && !isPossibleUri.test(uriOrFile)
+        ? UriImpl.file(normalizeDriveLetter(uriOrFile))
+        : UriImpl.parse(uriOrFile);
+}
+exports.toUri = toUri;
+const hasDriveLetter = /^[A-Z]:/i;
+function uriToFilePath(uri) {
+    const adj = uri.scheme === 'stdin' ? { scheme: 'file' } : {};
+    return normalizeDriveLetter(vscode_uri_1.URI.from(UriImpl.from(uri, adj)).fsPath);
+}
+exports.uriToFilePath = uriToFilePath;
+function fromFilePath(file) {
+    return UriImpl.file(file);
+}
+exports.fromFilePath = fromFilePath;
+function fromStdinFilePath(path) {
+    return UriImpl.stdin(path);
+}
+exports.fromStdinFilePath = fromStdinFilePath;
+exports.file = fromFilePath;
+function parse(uri) {
+    return UriImpl.parse(uri);
+}
+exports.parse = parse;
+function normalizeDriveLetter(path) {
+    return hasDriveLetter.test(path) ? path[0].toLowerCase() + path.slice(1) : path;
+}
+exports.normalizeDriveLetter = normalizeDriveLetter;
+function isUrlLike(url) {
+    return (!!url && typeof url === 'object' && typeof url.href === 'string') || false;
+}
+function isUri(uri) {
+    if (!uri || typeof uri !== 'object')
+        return false;
+    if (UriImpl.isUri(uri))
+        return true;
+    if (vscode_uri_1.URI.isUri(uri))
+        return true;
+    const u = uri;
+    return typeof u.path === 'string' && typeof u.scheme === 'string';
+}
+exports.isUri = isUri;
+function basename(uri) {
+    return vscode_uri_1.Utils.basename(vscode_uri_1.URI.from(uri));
+}
+exports.basename = basename;
+function dirname(uri) {
+    return UriImpl.from(vscode_uri_1.Utils.dirname(vscode_uri_1.URI.from(uri)));
+}
+exports.dirname = dirname;
+function extname(uri) {
+    return vscode_uri_1.Utils.extname(vscode_uri_1.URI.from(uri));
+}
+exports.extname = extname;
+function joinPath(uri, ...paths) {
+    return UriImpl.from(vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.from(uri), ...paths));
+}
+exports.joinPath = joinPath;
+function resolvePath(uri, ...paths) {
+    return UriImpl.from(vscode_uri_1.Utils.resolvePath(vscode_uri_1.URI.from(uri), ...paths));
+}
+exports.resolvePath = resolvePath;
+function from(uri, ...parts) {
+    return UriImpl.from(uri, ...parts);
+}
+exports.from = from;
+const keys = ['scheme', 'authority', 'path', 'query', 'fragment'];
+class UriImpl {
+    constructor(uri) {
+        this.scheme = uri.scheme || '';
+        uri.authority && (this.authority = uri.authority);
+        this.path = uri.path || '';
+        uri.query && (this.query = uri.query);
+        uri.fragment && (this.fragment = uri.fragment);
+    }
+    toString() {
+        const path = this.path;
+        const base = `${this.scheme}://${this.authority || ''}${path}`;
+        const query = (this.query && `?${this.query}`) || '';
+        const fragment = (this.fragment && `#${this.fragment}`) || '';
+        const url = base + query + fragment;
+        return encodeURI(url);
+    }
+    toJson() {
+        const { scheme, authority, path, query, fragment } = this;
+        return { scheme, authority, path, query, fragment };
+    }
+    with(change) {
+        const { scheme, authority, path, query, fragment } = this;
+        const u = { scheme, authority, path, query, fragment };
+        for (const key of keys) {
+            if (change[key] && typeof change[key] === 'string') {
+                u[key] = change[key];
+            }
+        }
+        return new UriImpl(u);
+    }
+    static isUri(uri) {
+        return uri instanceof UriImpl;
+    }
+    static from(uri, ...parts) {
+        let u = new UriImpl(uri);
+        for (const part of parts) {
+            u = u.with(part);
+        }
+        return u;
+    }
+    static parse(uri) {
+        if (uri.startsWith(STDIN_PROTOCOL)) {
+            return UriImpl.from(parseStdinUri(uri));
+        }
+        const u = vscode_uri_1.URI.parse(uri);
+        return UriImpl.from(u);
+    }
+    static file(filename) {
+        return UriImpl.from(vscode_uri_1.URI.file(normalizeFilePath(filename)));
+    }
+    static stdin(filePath = '') {
+        return UriImpl.from(UriImpl.file(filePath), { scheme: 'stdin' });
+    }
+}
+function normalizeFilePath(path) {
+    return normalizeDriveLetter(path.replace(/\\/g, '/'));
+}
+function parseStdinUri(uri) {
+    (0, assert_1.default)(uri.startsWith(STDIN_PROTOCOL));
+    const idxSlash = STDIN_PROTOCOL.length;
+    let idxSlashEnd = idxSlash;
+    for (; uri[idxSlashEnd] === '/'; ++idxSlashEnd) {
+        // empty
+    }
+    const pathStart = idxSlashEnd;
+    const iH = uri.indexOf('#', pathStart);
+    const idxHash = iH > 0 ? iH : uri.length;
+    const iQ = uri.indexOf('?', pathStart);
+    const idxQ = iQ > 0 && iQ < idxHash ? iQ : idxHash;
+    const pathEnd = idxQ;
+    const path = uri.slice(pathStart, pathEnd);
+    const query = idxQ < idxHash ? uri.slice(idxQ + 1, idxHash) : '';
+    const hash = uri.slice(idxHash + 1);
+    const pathPrefix = idxSlashEnd - idxSlash > 2 ? '/' : '';
+    return {
+        scheme: 'stdin',
+        path: pathPrefix + normalizeFilePath(decodeURI(path)),
+        query: decodeURI(query),
+        fragment: decodeURI(hash),
+    };
+}
+exports.__testing__ = {
+    UriImpl,
+    normalizeFilePath,
+};
+//# sourceMappingURL=Uri.js.map

package/dist/util/text.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="node" />
 import type { TextDocumentOffset, TextOffset } from '@cspell/cspell-types';
+import type { Uri } from './Uri';
 export { stringToRegExp } from './textRegex';
 export declare function splitCamelCaseWordWithOffset(wo: TextOffset): Array<TextOffset>;
 /**
@@ -39,7 +41,7 @@ export declare function camelToSnake(word: string): string;
 export declare function matchCase(example: string, word: string): string;
 export declare function textOffset(text: string, offset?: number): TextOffset;
 export declare function extractText(textOffset: TextOffset, startPos: number, endPos: number): string;
-export declare function calculateTextDocumentOffsets<T extends TextOffset>(uri: string, doc: string, wordOffsets: T[]): (TextDocumentOffset & T)[];
+export declare function calculateTextDocumentOffsets<T extends TextOffset>(uri: string | Uri | URL, doc: string, wordOffsets: T[]): (TextDocumentOffset & T)[];
 export declare function removeAccents(text: string): string;
 export declare const __testing__: {
     regExWords: RegExp;

package/dist/util/text.js

@@ -5,6 +5,7 @@ const sync_1 = require("@cspell/cspell-pipe/sync");
 const gensequence_1 = require("gensequence");
 const search_1 = require("./search");
 const textRegex_1 = require("./textRegex");
+const Uri_1 = require("./Uri");
 const util_1 = require("./util");
 var textRegex_2 = require("./textRegex");
 Object.defineProperty(exports, "stringToRegExp", { enumerable: true, get: function () { return textRegex_2.stringToRegExp; } });
@@ -186,9 +187,10 @@ function calculateTextDocumentOffsets(uri, doc, wordOffsets) {
         lastLine = r;
         return r;
     }
+    const _uri = (0, Uri_1.toUri)(uri).toString();
     return wordOffsets.map((wo) => {
         const [row, col] = findRowCol(wo.offset);
-        return { ...wo, row, col, doc, uri, line: calcLine(row) };
+        return { ...wo, row, col, doc, uri: _uri, line: calcLine(row) };
     });
 }
 exports.calculateTextDocumentOffsets = calculateTextDocumentOffsets;

package/dist/util/util.d.ts

@@ -14,8 +14,6 @@ export declare function clean<T extends object>(src: T): RemoveUndefined<T>;
 export declare function scanMap<T>(accFn: (acc: T, value: T) => T, init?: T): (value: T) => T;
 export declare function scanMap<T, U>(accFn: (acc: U, value: T) => U, init: U): (value: T) => U;
 export declare function isDefined<T>(v: T | undefined): v is T;
-export declare function flattenIterable<T>(values: Iterable<Iterable<T>> | T[][]): Iterable<T>;
-export declare function flatten<T>(values: Iterable<Iterable<T>> | T[][]): T[];
 export declare function asyncIterableToArray<T>(iter: Iterable<T> | AsyncIterable<T>): Promise<Awaited<T>[]>;
 /**
  * Shallow is Equal test.
@@ -31,4 +29,5 @@ export declare function isArrayEqual<K>(a: K[], b: K[]): boolean;
  * @returns true iff any element of `a` is in `b`
  */
 export declare function doSetsIntersect<T>(a: Set<T>, b: Set<T>): boolean;
+export declare function isRecordEqual<T extends Record<string, unknown>>(a: T | undefined, b: T | undefined): boolean;
 //# sourceMappingURL=util.d.ts.map

package/dist/util/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.doSetsIntersect = exports.isArrayEqual = exports.asyncIterableToArray = exports.flatten = exports.flattenIterable = exports.isDefined = exports.scanMap = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
+exports.isRecordEqual = exports.doSetsIntersect = exports.isArrayEqual = exports.asyncIterableToArray = exports.isDefined = exports.scanMap = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
 // alias for uniqueFilterFnGenerator
 exports.uniqueFn = uniqueFilterFnGenerator;
 function uniqueFilterFnGenerator(extractFn) {
@@ -50,16 +50,6 @@ function isDefined(v) {
     return v !== undefined;
 }
 exports.isDefined = isDefined;
-function* flattenIterable(values) {
-    for (const v of values) {
-        yield* v;
-    }
-}
-exports.flattenIterable = flattenIterable;
-function flatten(values) {
-    return [...flattenIterable(values)];
-}
-exports.flatten = flatten;
 async function asyncIterableToArray(iter) {
     const acc = [];
     for await (const t of iter) {
@@ -101,4 +91,20 @@ function doSetsIntersect(a, b) {
     return a.size <= b.size ? compare(a, b) : compare(b, a);
 }
 exports.doSetsIntersect = doSetsIntersect;
+function isRecordEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    for (const key of Object.keys(a)) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    for (const key of Object.keys(b)) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
+exports.isRecordEqual = isRecordEqual;
 //# sourceMappingURL=util.js.map