cspell-lib 8.11.0 → 8.13.0

package/dist/esm/Models/Suggestion.d.ts

@@ -11,5 +11,10 @@ export interface ExtendedSuggestion {
      * The suggested word adjusted to match the original case.
      */
     wordAdjustedToMatchCase?: string;
+    /**
+     * The cost of using this word.
+     * The lower the cost, the better the suggestion.
+     */
+    cost?: number;
 }
 //# sourceMappingURL=Suggestion.d.ts.map

package/dist/esm/Models/TextDocument.d.ts

@@ -1,5 +1,5 @@
 import * as Uri from '../util/Uri.js';
-export type DocumentUri = Uri.Uri;
+export type DocumentUri = Uri.Uri | URL | string;
 export interface Position {
     line: number;
     character: number;
@@ -82,4 +82,5 @@ export declare function createTextDocument({ uri, content, languageId, locale, v
 export declare function updateTextDocument(doc: TextDocument, edits: TextDocumentContentChangeEvent[], version?: number): TextDocument;
 export declare function loadTextDocument(filename: string | DocumentUri, languageId?: string): Promise<TextDocument>;
 export declare const isTextDocument: (doc: TextDocument | unknown) => doc is TextDocument;
+export declare function documentUriToURL(uri: DocumentUri): URL;
 //# sourceMappingURL=TextDocument.d.ts.map

package/dist/esm/Models/TextDocument.js

@@ -1,19 +1,20 @@
 import assert from 'node:assert';
+import { toFileURL, toURL } from '@cspell/url';
 import { TextDocument as VsTextDocument } from 'vscode-languageserver-textdocument';
 import { getFileSystem } from '../fileSystem.js';
 import { getLanguagesForBasename } from '../LanguageIds.js';
 import * as Uri from '../util/Uri.js';
 class TextDocumentImpl {
-    uri;
     languageId;
     locale;
     vsTextDoc;
+    uri;
     constructor(uri, text, languageId, locale, version) {
-        this.uri = uri;
         this.languageId = languageId;
         this.locale = locale;
         const primaryLanguageId = typeof languageId === 'string' ? languageId : languageId[0] || 'plaintext';
         this.vsTextDoc = VsTextDocument.create(uri.toString(), primaryLanguageId, version, text);
+        this.uri = documentUriToURL(uri);
     }
     get version() {
         return this.vsTextDoc.version;
@@ -108,4 +109,7 @@ export async function loadTextDocument(filename, languageId) {
     return createTextDocument({ uri, languageId, content: file.getText() });
 }
 export const isTextDocument = isTextDocumentImpl;
+export function documentUriToURL(uri) {
+    return toURL(uri instanceof URL ? uri : typeof uri === 'string' ? toFileURL(uri) : new URL(Uri.from(uri).toString()));
+}
 //# sourceMappingURL=TextDocument.js.map

package/dist/esm/Settings/RegExpPatterns.js

@@ -5,7 +5,7 @@ export const regExHRef = /\bhref\s*=\s*".*?"/gi;
 export const regExMatchCommonHexFormats = /(?:#[0-9a-f]{3,8})|(?:0x[0-9a-f]+)|(?:\\u[0-9a-f]{4})|(?:\\x\{[0-9a-f]{4}\})/gi;
 export const regExCommitHash = /\b(?![a-f]+\b)(?:0x)?[0-9a-f]{7,}\b/gi; // Match Commit Hashes that contain at least one digit.
 export const regExCommitHashLink = /\[[0-9a-f]{7,}\]/gi; // Match Commit Hash Markdown link: [abcdef0].
-export const regExCStyleHexValue = /\b0x[0-9a-f]+\b/gi;
+export const regExCStyleHexValue = /\b0x[0-9a-f_]+\b/gi;
 export const regExCSSHexValue = /#[0-9a-f]{3,8}\b/gi;
 export const regExUUID = /\b[0-9a-fx]{8}-[0-9a-fx]{4}-[0-9a-fx]{4}-[0-9a-fx]{4}-[0-9a-fx]{12}\b/gi; // x - represents placeholder values
 export const regExUnicodeRef = /\bU\+[0-9a-f]{4,5}(?:-[0-9a-f]{4,5})?/gi;

package/dist/esm/textValidation/docValidator.js

@@ -2,9 +2,9 @@ import assert from 'node:assert';
 import { pathToFileURL } from 'node:url';
 import { opConcatMap, opMap, pipeSync } from '@cspell/cspell-pipe/sync';
 import { IssueType } from '@cspell/cspell-types';
-import { toFileURL } from '@cspell/url';
+import { toFilePathOrHref, toFileURL } from '@cspell/url';
 import { getGlobMatcherForExcluding } from '../globs/getGlobMatcher.js';
-import { updateTextDocument } from '../Models/TextDocument.js';
+import { documentUriToURL, updateTextDocument } from '../Models/TextDocument.js';
 import { createPerfTimer } from '../perf/index.js';
 import { finalizeSettings, loadConfig, mergeSettings, resolveSettingsImports, searchForConfig, } from '../Settings/index.js';
 import { validateInDocumentSettings } from '../Settings/InDocSettings.js';
@@ -292,7 +292,7 @@ export class DocumentValidator {
         const parser = this._preparations.finalSettings.parserFn;
         if (typeof parser !== 'object')
             return this.defaultParser();
-        return parser.parse(this.document.text, this.document.uri.path).parsedTexts;
+        return parser.parse(this.document.text, toFilePathOrHref(documentUriToURL(this.document.uri))).parsedTexts;
     }
     getSuggestions(text) {
         return this._suggestions.get(text);
@@ -355,10 +355,15 @@ function sanitizeSuggestion(sug) {
     return { word };
 }
 async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
-    const { uri } = document;
-    if (uri.scheme !== 'file')
-        return defaultConfig;
-    return searchForConfig(uri.toString(), pnpSettings).then((s) => s || defaultConfig);
+    const url = documentUriToURL(document.uri);
+    try {
+        return await searchForConfig(url, pnpSettings).then((s) => s || defaultConfig);
+    }
+    catch (e) {
+        if (url.protocol !== 'file:')
+            return defaultConfig;
+        throw e;
+    }
 }
 function mapSug(sug) {
     return { cost: 999, ...sug };
@@ -383,9 +388,8 @@ export async function shouldCheckDocument(doc, options, settings) {
         const config = mergeSettings(settings, localConfig);
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
         const docSettings = await determineTextDocumentSettings(doc, config);
-        const uri = doc.uri;
         // eslint-disable-next-line unicorn/prefer-regexp-test
-        return !matcher.match(uriToFilePath(uri)) && (docSettings.enabled ?? true);
+        return !matcher.match(uriToFilePath(doc.uri)) && (docSettings.enabled ?? true);
     }
     return { errors, shouldCheck: await shouldCheck() };
 }

package/dist/esm/util/Uri.d.ts

@@ -1,4 +1,5 @@
 import { URI } from 'vscode-uri';
+import { DocumentUri } from '../Models/TextDocument.js';
 export interface Uri {
     readonly scheme: string;
     readonly path: string;
@@ -8,15 +9,16 @@ export interface Uri {
 }
 export interface UriInstance extends Uri {
     toString(): string;
+    toJSON(): unknown;
 }
 export declare function toUri(uriOrFile: string | Uri | URL): UriInstance;
-export declare function uriToFilePath(uri: Uri): string;
+export declare function uriToFilePath(uri: DocumentUri): 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 isUri(uri: unknown): uri is Uri;
 export declare function basename(uri: Uri): string;
 export declare function dirname(uri: Uri): UriInstance;
 export declare function extname(uri: Uri): string;
@@ -26,7 +28,7 @@ export declare function from(uri: Uri, ...parts: Partial<Uri>[]): UriInstance;
 declare class UriImpl extends URI implements UriInstance {
     constructor(uri: Uri);
     toString(): string;
-    toJson(): {
+    toJSON(): {
         scheme: string;
         authority: string;
         path: string;

package/dist/esm/util/Uri.js

@@ -1,8 +1,9 @@
 import assert from 'node:assert';
+import { pathToFileURL } from 'node:url';
+import { toFilePathOrHref, toFileURL } from '@cspell/url';
 import { isUrlLike } from 'cspell-io';
 import { URI, Utils } from 'vscode-uri';
-const isFile = /^(?:[a-zA-Z]:|[/\\])/;
-const isPossibleUri = /\w:\/\//;
+import { documentUriToURL } from '../Models/TextDocument.js';
 const STDIN_PROTOCOL = 'stdin:';
 export function toUri(uriOrFile) {
     if (UriImpl.isUri(uriOrFile))
@@ -17,14 +18,15 @@ export function toUri(uriOrFile) {
         return UriImpl.from(uriOrFile);
     if (isUrlLike(uriOrFile))
         return UriImpl.parse(uriOrFile);
-    return isFile.test(uriOrFile) && !isPossibleUri.test(uriOrFile)
-        ? UriImpl.file(normalizeDriveLetter(uriOrFile))
-        : UriImpl.parse(uriOrFile);
+    return UriImpl.file(normalizeDriveLetter(uriOrFile));
 }
-const hasDriveLetter = /^[A-Z]:/i;
+const isWindows = process.platform === 'win32';
+const hasDriveLetter = /^[a-zA-Z]:[\\/]/;
+const rootUrl = pathToFileURL('/');
 export function uriToFilePath(uri) {
-    const adj = uri.scheme === 'stdin' ? { scheme: 'file' } : {};
-    return normalizeDriveLetter(URI.from(UriImpl.from(uri, adj)).fsPath);
+    let url = documentUriToURL(uri);
+    url = url.protocol === 'stdin:' ? new URL(url.pathname, rootUrl) : url;
+    return toFilePathOrHref(url);
 }
 export function fromFilePath(file) {
     return UriImpl.file(file);
@@ -37,7 +39,7 @@ export function parse(uri) {
     return UriImpl.parse(uri);
 }
 export function normalizeDriveLetter(path) {
-    return hasDriveLetter.test(path) ? path[0].toLowerCase() + path.slice(1) : path;
+    return hasDriveLetter.test(path) ? path[0].toUpperCase() + path.slice(1) : path;
 }
 function isHRef(url) {
     return (!!url && typeof url === 'object' && typeof url.href === 'string') || false;
@@ -84,7 +86,7 @@ class UriImpl extends URI {
         const url = base + query + fragment;
         return url;
     }
-    toJson() {
+    toJSON() {
         const { scheme, authority, path, query, fragment } = this;
         return { scheme, authority, path, query, fragment };
     }
@@ -116,7 +118,11 @@ class UriImpl extends URI {
         return UriImpl.from(u);
     }
     static file(filename) {
-        return UriImpl.from(URI.file(normalizeFilePath(filename)));
+        if (!isWindows && hasDriveLetter.test(filename)) {
+            filename = '/' + filename.replaceAll('\\', '/');
+        }
+        const url = toFileURL(filename);
+        return UriImpl.parse(url.href);
     }
     static stdin(filePath = '') {
         return UriImpl.from(UriImpl.file(filePath), { scheme: 'stdin' });

package/dist/esm/util/text.js

@@ -1,5 +1,4 @@
 import { opConcatMap, opMap, pipe } from '@cspell/cspell-pipe/sync';
-import { sequenceFromRegExpMatch } from 'gensequence';
 import { binarySearch } from './search.js';
 import { regExAccents, regExAllLower, regExAllUpper, regExFirstUpper, regExIgnoreCharacters, regExSplitWords, regExSplitWords2, regExUpperSOrIng, regExWords, regExWordsAndDigits, } from './textRegex.js';
 import { toUri } from './Uri.js';
@@ -26,7 +25,10 @@ export function splitCamelCaseWord(word) {
  * This function lets you iterate over regular expression matches.
  */
 export function match(reg, text) {
-    return sequenceFromRegExpMatch(reg, text);
+    if (!text)
+        return [];
+    reg = reg.global ? reg : new RegExp(reg.source, reg.flags + 'g');
+    return text.matchAll(reg);
 }
 export function matchStringToTextOffset(reg, text) {
     return matchToTextOffset(reg, { text, offset: 0 });

package/dist/esm/util/url.js

@@ -28,7 +28,8 @@ export function toFileUrl(file) {
 export function fileURLOrPathToPath(filenameOrURL) {
     return toFilePathOrHref(filenameOrURL);
 }
+const regExpWindowsPathDriveLetter = /^([a-zA-Z]):[\\]/;
 export function windowsDriveLetterToUpper(absoluteFilePath) {
-    return absoluteFilePath.replace(/^([a-z]):\\/, (s) => s.toUpperCase());
+    return absoluteFilePath.replace(regExpWindowsPathDriveLetter, (s) => s.toUpperCase());
 }
 //# sourceMappingURL=url.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.11.0",
+  "version": "8.13.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -59,21 +59,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.11.0",
-    "@cspell/cspell-pipe": "8.11.0",
-    "@cspell/cspell-resolver": "8.11.0",
-    "@cspell/cspell-types": "8.11.0",
-    "@cspell/dynamic-import": "8.11.0",
-    "@cspell/strong-weak-map": "8.11.0",
-    "@cspell/url": "8.11.0",
+    "@cspell/cspell-bundled-dicts": "8.13.0",
+    "@cspell/cspell-pipe": "8.13.0",
+    "@cspell/cspell-resolver": "8.13.0",
+    "@cspell/cspell-types": "8.13.0",
+    "@cspell/dynamic-import": "8.13.0",
+    "@cspell/strong-weak-map": "8.13.0",
+    "@cspell/url": "8.13.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.4",
-    "cspell-config-lib": "8.11.0",
-    "cspell-dictionary": "8.11.0",
-    "cspell-glob": "8.11.0",
-    "cspell-grammar": "8.11.0",
-    "cspell-io": "8.11.0",
-    "cspell-trie-lib": "8.11.0",
+    "cspell-config-lib": "8.13.0",
+    "cspell-dictionary": "8.13.0",
+    "cspell-glob": "8.13.0",
+    "cspell-grammar": "8.13.0",
+    "cspell-io": "8.13.0",
+    "cspell-trie-lib": "8.13.0",
     "env-paths": "^3.0.0",
     "fast-equals": "^5.0.1",
     "gensequence": "^7.0.0",
@@ -87,19 +87,19 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@cspell/dict-cpp": "^5.1.10",
+    "@cspell/dict-cpp": "^5.1.12",
     "@cspell/dict-csharp": "^4.0.2",
     "@cspell/dict-css": "^4.0.12",
     "@cspell/dict-fa-ir": "^4.0.0",
     "@cspell/dict-fr-fr": "^2.2.2",
     "@cspell/dict-html": "^4.0.5",
     "@cspell/dict-nl-nl": "^2.3.0",
-    "@cspell/dict-python": "^4.2.1",
+    "@cspell/dict-python": "^4.2.3",
     "@types/configstore": "^6.0.2",
     "configstore": "^7.0.0",
     "cspell-dict-nl-nl": "^1.1.2",
     "leaked-handles": "^5.2.0",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "2b85b2b458b1117870a4f0aee18fb45ce991848d"
+  "gitHead": "2fd3fb430cc96a8a50543f57d96b288219a11923"
 }