cspell-lib 10.3.4-alpha.0 → 10.3.5

package/dist/lib/Settings/CSpellSettingsServer.js

@@ -281,7 +281,13 @@ function resolveParser(settings) {
     assert(typeof parserName === 'string');
     const parsers = extractParsers(settings.plugins);
     const parser = parsers.get(parserName);
-    assert(parser, `Parser "${parserName}" not found.`);
+    try {
+        assert(parser);
+    }
+    catch {
+        // lazy assertion for better error message
+        assert(parser, `Parser "${parserName}" not found among available parsers: ${[...parsers.keys()].join(', ')}`);
+    }
     return parser;
 }
 function* parsers(plugins) {

package/dist/lib/Transform/SourceMap.js

@@ -335,9 +335,10 @@ function advanceCursors(cursor1, cursor2, target) {
     assert(cursor1.p1 === cursor2.p0, 'The shared edge must match between the two cursors.');
     if (cursor1.linear && cursor2.linear) {
         const p = Math.min(cursor1.end1, cursor2.end0);
+        // Both segments are linear, so all three positions advance by the same amount from the current position.
         const dB = p - cursor1.p1;
-        const pA = cursor1.begin0 + dB;
-        const pC = cursor2.begin1 + dB;
+        const pA = cursor1.p0 + dB;
+        const pC = cursor2.p1 + dB;
         const dA = pA - cursor1.p0;
         const dC = pC - cursor2.p1;
         cursor1.p0 = pA;

package/dist/lib/Transform/SubstitutionTransformer.js

@@ -95,9 +95,8 @@ function buildDefinitionMap(defs) {
  * @returns
  */
 export function createSubstitutionTransformer(info) {
-    const { subMap, missing } = info.substitutions && info.substitutionDefinitions
-        ? calcSubMap(info.substitutions, info.substitutionDefinitions)
-        : {};
+    const { substitutions, substitutionDefinitions } = info;
+    const { subMap, missing } = substitutions ? calcSubMap(substitutions, substitutionDefinitions ?? []) : {};
     return {
         transformer: new SubstitutionTransformer(subMap),
         missing: missing && missing.length > 0 ? missing : undefined,

package/dist/lib/spellCheckFile.d.ts

@@ -25,6 +25,10 @@ export interface SpellCheckFileOptions extends ValidateTextOptions, Pick<CSpellU
      * @defaultValue undefined
      */
     noConfigSearch?: boolean;
+    /**
+     * If true, the document will be checked even if it would normally be excluded.
+     */
+    forceCheck?: boolean;
 }
 export interface SpellCheckFileOptionsRPC extends SpellCheckFileOptions {
     measurePerf?: boolean;

package/dist/lib/textValidation/docValidator.js

@@ -509,11 +509,11 @@ export async function shouldCheckDocument(doc, options, settings) {
         const config = mergeSettings(settings, localConfig);
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
         // eslint-disable-next-line unicorn/prefer-regexp-test
-        if (matcher.match(uriToFilePath(doc.uri))) {
+        if (!options.forceCheck && matcher.match(uriToFilePath(doc.uri))) {
             return { errors, shouldCheck: false, settings: localConfig, reason: 'Excluded by ignorePaths.' };
         }
         const docSettings = await determineTextDocumentSettings(doc, config);
-        const shouldCheck = docSettings.enabled ?? true;
+        const shouldCheck = options.forceCheck || (docSettings.enabled ?? true);
         const reason = shouldCheck ? undefined : 'Excluded by overrides or languageSettings.';
         return { errors, shouldCheck, settings: docSettings, reason };
     }

package/dist/lib/textValidation/lineValidatorFactory.js

@@ -1,11 +1,10 @@
-import assert from 'node:assert';
 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 { extractPossibleWordsFromTextOffset, extractText, extractWordsFromTextOffset, numCharacters, splitWordWithOffset, } from '../util/text.js';
 import { regExpCamelCaseWordBreaksWithEnglishSuffix } from '../util/textRegex.js';
 import { split } from '../util/wordSplitter/index.js';
 import { defaultMinWordLength } from './defaultConstants.js';
@@ -131,22 +130,31 @@ export function lineValidatorFactory(sDict, options) {
         return issue;
     }
     const regExUpperCaseWithTrailingCommonEnglishSuffix = /^([\p{Lu}\p{M}]{2,})['’]?(?:s|ing|ies|es|ings|ize|ed|ning)$/u; // cspell:disable-line
-    const regExpIsLetter = /\p{L}/u;
+    // Sticky: test the text at `lastIndex` without creating substrings.
+    const regExpIsLetterBefore = /(?<=\p{L})/uy;
+    const regExpIsLetterAt = /\p{L}/uy;
     const fn = (lineSegment) => {
         const line = lineSegment.line;
+        /**
+         * A short word is ok if it stands alone in the line, i.e. it is not next to other letters.
+         */
         function isWordTooShort(word, ignoreSuffix = false) {
-            if (word.text.length >= minWordLength * 2 || [...word.text].length >= minWordLength)
+            const tLen = word.text.length;
+            const wLen = word.length ?? tLen;
+            if (tLen >= minWordLength * 2 || numCharacters(word.text) >= minWordLength)
+                return false;
+            // A word joined across soft hyphens does not stand alone in the line.
+            if (wLen !== tLen)
                 return false;
             const offset = word.offset - line.offset;
-            assert.equal(line.text.slice(offset, offset + word.text.length), word.text);
-            const prefix = [...line.text.slice(Math.max(0, offset - 2), offset)];
-            const hasLetterPrefix = !!prefix.length && regExpIsLetter.test(prefix[prefix.length - 1]);
+            regExpIsLetterBefore.lastIndex = offset;
+            const hasLetterPrefix = regExpIsLetterBefore.test(line.text);
             if (hasLetterPrefix)
                 return false;
             if (ignoreSuffix)
                 return true;
-            const suffix = [...line.text.slice(offset + word.text.length, offset + word.text.length + 2)];
-            const hasLetterSuffix = !!suffix.length && regExpIsLetter.test(suffix[0]);
+            regExpIsLetterAt.lastIndex = offset + wLen;
+            const hasLetterSuffix = regExpIsLetterAt.test(line.text);
             return !hasLetterSuffix;
         }
         function splitterIsValid(word) {
@@ -173,6 +181,9 @@ export function lineValidatorFactory(sDict, options) {
                 return false;
             if (check.isFound)
                 return true;
+            // A word joined across soft hyphens does not stand alone in the line.
+            if (tWord.length !== undefined && tWord.length !== tWord.text.length)
+                return false;
             if (isWordTooShort(v, true))
                 return true;
             return false;
@@ -374,8 +385,9 @@ export function textValidatorFactory(dict, options) {
         const segment = { text, offset: 0 };
         const lineSegment = { line: segment, segment };
         function mapBackToOriginSimple(vr) {
-            const { text, offset, isFlagged, isFound, suggestionsEx, hasPreferredSuggestions, hasSimpleSuggestions } = vr;
-            const r = mapRangeBackToOriginalPos([offset, offset + text.length], map);
+            const { text, length, offset, isFlagged, isFound, suggestionsEx, hasPreferredSuggestions, hasSimpleSuggestions, } = vr;
+            const wLen = length ?? text.length;
+            const r = mapRangeBackToOriginalPos([offset, offset + wLen], map);
             const range = [r[0] + srcOffset, r[1] + srcOffset];
             return {
                 text,

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

@@ -52,6 +52,13 @@ 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 | Uri | URL, doc: string, wordOffsets: T[]): (TextDocumentOffset & T)[];
 export declare function removeAccents(text: string): string;
+/**
+ * Count the number of characters (Unicode code points) in a string.
+ * Surrogate pairs count as one character. Same result as `[...text].length`, without creating an array.
+ * @param text - the string to count.
+ * @returns the number of characters.
+ */
+export declare function numCharacters(text: string): number;
 export declare const __testing__: {
     regExWords: RegExp;
     regExWordsAndDigits: RegExp;

package/dist/lib/util/text.js

@@ -204,6 +204,22 @@ export function removeAccents(text) {
     regExAccents.lastIndex = 0;
     return text.normalize('NFD').replace(regExAccents, '');
 }
+/**
+ * Count the number of characters (Unicode code points) in a string.
+ * Surrogate pairs count as one character. Same result as `[...text].length`, without creating an array.
+ * @param text - the string to count.
+ * @returns the number of characters.
+ */
+export function numCharacters(text) {
+    const len = text.length;
+    let n = 0;
+    for (let i = 0; i < len; ++i, ++n) {
+        // A code point above 0xFFFF is a surrogate pair, skip the second half.
+        if ((text.codePointAt(i) || 0) > 0xffff)
+            ++i;
+    }
+    return n;
+}
 export const __testing__ = {
     regExWords: regExWords,
     regExWordsAndDigits: regExWordsAndDigits,

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "10.3.4-alpha.0",
+  "version": "10.3.5",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -75,22 +75,22 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "10.3.4-alpha.0",
-    "@cspell/cspell-performance-monitor": "10.3.4-alpha.0",
-    "@cspell/cspell-pipe": "10.3.4-alpha.0",
-    "@cspell/cspell-resolver": "10.3.4-alpha.0",
-    "@cspell/cspell-types": "10.3.4-alpha.0",
-    "@cspell/dynamic-import": "10.3.4-alpha.0",
-    "@cspell/filetypes": "10.3.4-alpha.0",
-    "@cspell/rpc": "10.3.4-alpha.0",
-    "@cspell/strong-weak-map": "10.3.4-alpha.0",
-    "@cspell/url": "10.3.4-alpha.0",
-    "cspell-config-lib": "10.3.4-alpha.0",
-    "cspell-dictionary": "10.3.4-alpha.0",
-    "cspell-glob": "10.3.4-alpha.0",
-    "cspell-grammar": "10.3.4-alpha.0",
-    "cspell-io": "10.3.4-alpha.0",
-    "cspell-trie-lib": "10.3.4-alpha.0",
+    "@cspell/cspell-bundled-dicts": "10.3.5",
+    "@cspell/cspell-performance-monitor": "10.3.5",
+    "@cspell/cspell-pipe": "10.3.5",
+    "@cspell/cspell-resolver": "10.3.5",
+    "@cspell/cspell-types": "10.3.5",
+    "@cspell/dynamic-import": "10.3.5",
+    "@cspell/filetypes": "10.3.5",
+    "@cspell/rpc": "10.3.5",
+    "@cspell/strong-weak-map": "10.3.5",
+    "@cspell/url": "10.3.5",
+    "cspell-config-lib": "10.3.5",
+    "cspell-dictionary": "10.3.5",
+    "cspell-glob": "10.3.5",
+    "cspell-grammar": "10.3.5",
+    "cspell-io": "10.3.5",
+    "cspell-trie-lib": "10.3.5",
     "env-paths": "^4.0.0",
     "gensequence": "^8.0.8",
     "import-fresh": "^4.0.0",
@@ -103,7 +103,7 @@
     "node": ">=22.18.0"
   },
   "devDependencies": {
-    "@cspell/cspell-tools": "10.3.4-alpha.0",
+    "@cspell/cspell-tools": "10.3.5",
     "@cspell/dict-cpp": "^7.1.0",
     "@cspell/dict-csharp": "^4.0.8",
     "@cspell/dict-css": "^4.1.2",
@@ -123,5 +123,5 @@
     "lorem-ipsum": "^3.0.0",
     "perf-insight": "^2.0.1"
   },
-  "gitHead": "f52ee7e2f24189eaf8fb5139c0b029c8cb80fc57"
+  "gitHead": "f37a244a54b686fc1ac11272d6019b9a059b062a"
 }