cspell-lib 10.3.4 → 10.3.6

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/spellCheckFile.js

@@ -123,15 +123,14 @@ async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
     const docValOptions = options;
     const docValidator = await DocumentValidator.create(doc, docValOptions, settingsOrConfigFile).finally(() => timerPrepare.end());
     Object.assign(perf, Object.fromEntries(Object.entries(docValidator.perfTiming).map(([k, v]) => ['_' + k, v])));
-    const prep = docValidator._getPreparations();
     if (docValidator.errors.length) {
-        const settingsUsed = prep?.localConfig ||
+        const settingsUsed = docValidator._getLocalConfig() ||
             (satisfiesCSpellConfigFile(settingsOrConfigFile) ? settingsOrConfigFile.settings : settingsOrConfigFile);
         return {
             document,
             options,
             settingsUsed,
-            localConfigFilepath: prep?.localConfigFilepath,
+            localConfigFilepath: docValidator._getLocalConfigFilepath(),
             issues: [],
             checked: false,
             errors: docValidator.errors,
@@ -148,7 +147,7 @@ async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
         document,
         options,
         settingsUsed: docValidator.getFinalizedDocSettings(),
-        localConfigFilepath: prep?.localConfigFilepath,
+        localConfigFilepath: docValidator._getLocalConfigFilepath(),
         issues,
         checked: docValidator.shouldCheckDocument(),
         errors: undefined,

package/dist/lib/textValidation/checkText.js

@@ -1,4 +1,3 @@
-import assert from 'node:assert';
 import { resolveDocumentToTextDocument } from '../Document/resolveDocument.js';
 import { isTextDocument } from '../Models/TextDocument.js';
 import * as Settings from '../Settings/index.js';
@@ -57,8 +56,6 @@ export async function genCheckText(docValidator) {
     docValidator.recordCheckedRanges = true;
     await docValidator.prepare();
     const issues = docValidator.checkDocument(true);
-    const preparations = docValidator._getPreparations();
-    assert(preparations);
     return genResult(docValidator.document.text, issues, docValidator.getRangesChecked());
 }
 function genResult(text, issues, includeRanges) {

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

@@ -1,13 +1,12 @@
-import type { CSpellUserSettings, MappedText, ParsedText } from '@cspell/cspell-types';
+import type { CSpellUserSettings, ParsedText } from '@cspell/cspell-types';
 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 { CSpellSettingsInternal, CSpellSettingsInternalFinalized, ImportFileRefWithError } from '../Settings/index.js';
-import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
+import type { CSpellSettingsInternal, ImportFileRefWithError } from '../Settings/index.js';
 import type { WordSuggestion } from '../suggestions.js';
-import type { MatchRange, SimpleRange, TextTransformer } from '../Transform/index.js';
-import type { TextValidationFactoryOptions, TextValidator } from './lineValidatorFactory.js';
+import type { MatchRange, SimpleRange } from '../Transform/index.js';
+import type { Preparations } from './docValidatorPreparations.js';
 import type { TraceResult } from './traceWord.js';
 import type { ValidateTextOptions } from './ValidateTextOptions.js';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
@@ -117,8 +116,20 @@ export declare class DocumentValidator {
     shouldCheckDocument(): boolean;
     /**
      * Internal `cspell-lib` use.
+     * @deprecated Will be removed in a future major version. Use {@link _getLocalConfig} and
+     * {@link _getLocalConfigFilepath} instead.
      */
     _getPreparations(): Preparations | undefined;
+    /**
+     * Internal `cspell-lib` use.
+     * @returns the config file found for the document, if any.
+     */
+    _getLocalConfig(): CSpellUserSettings | undefined;
+    /**
+     * Internal `cspell-lib` use.
+     * @returns the path of the config file found for the document, if any.
+     */
+    _getLocalConfigFilepath(): string | undefined;
     /**
      * Get the calculated ranges of text that should be included in the spell checking.
      *
@@ -132,22 +143,6 @@ export declare class DocumentValidator {
     set recordCheckedRanges(value: boolean);
 }
 declare function sanitizeSuggestion(sug: WordSuggestion): ExtendedSuggestion;
-interface Preparations {
-    /** loaded config */
-    config: CSpellSettingsInternal;
-    dictionary: SpellingDictionaryCollection;
-    /** configuration after applying in-doc settings */
-    docSettings: CSpellSettingsInternal;
-    finalSettings: CSpellSettingsInternalFinalized;
-    includeRanges: MatchRange[];
-    textValidator: TextValidator;
-    segmenter: (texts: MappedText) => Iterable<MappedText>;
-    shouldCheck: boolean;
-    validateOptions: TextValidationFactoryOptions;
-    localConfig: CSpellUserSettings | undefined;
-    localConfigFilepath: string | undefined;
-    transformer: TextTransformer;
-}
 interface ShouldCheckDocumentResult {
     /** possible errors found while loading configuration. */
     errors: Error[];

package/dist/lib/textValidation/docValidator.js

@@ -10,13 +10,14 @@ import { extractImportErrors, finalizeSettings, loadConfig, mergeSettings, resol
 import { validateInDocumentSettings } from '../Settings/InDocSettings.js';
 import { getDictionaryInternal } from '../SpellingDictionary/index.js';
 import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
-import { chainTransformers, createIntlSegmentTextTransformer, createMappedTextSegmenter, createSoftWordBreakTextTransformer, createSubstitutionTransformer, } from '../Transform/index.js';
+import { chainTransformers, createIntlSegmentTextTransformer, createSoftWordBreakTextTransformer, createSubstitutionTransformer, } from '../Transform/index.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
 import { cleanValidationIssue } from './cleanValidationIssue.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
+import { DocumentValidatorPreparations } from './docValidatorPreparations.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
 import { settingsToValidateOptions } from './settingsToValidateOptions.js';
 import { calcTextInclusionRanges } from './textValidator.js';
@@ -108,22 +109,18 @@ export class DocumentValidator {
         recShouldCheckTime();
         const recFinalizeTime = recordPerfTime(this.perfTiming, '_finalizeSettings');
         const finalSettings = finalizeSettings(docSettings);
-        const { transformer, validateOptions, includeRanges, segmenter, textValidator } = this.#calcSharedPrep(finalSettings, dict);
+        const { transformer, validateOptions, calcIncludeRanges, textValidator } = this.#calcSharedPrep(finalSettings, dict);
         recFinalizeTime();
-        this._preparations = {
-            config,
+        this._preparations = new DocumentValidatorPreparations(config, localConfig, localConfig?.__importRef?.filename, {
             dictionary: dict,
             docSettings,
             finalSettings,
             shouldCheck,
             validateOptions,
-            includeRanges,
-            segmenter,
             textValidator,
-            localConfig,
-            localConfigFilepath: localConfig?.__importRef?.filename,
             transformer,
-        };
+            calcIncludeRanges,
+        });
         this._ready = true;
         this._preparationTime = timer.elapsed;
         this.perfTiming.prepTime = this._preparationTime;
@@ -138,19 +135,17 @@ export class DocumentValidator {
         const stopMeasure = measurePerf('DocumentValidator._updatePrep');
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = finalizeSettings(docSettings);
-        const { transformer, validateOptions, includeRanges, segmenter, textValidator } = this.#calcSharedPrep(finalSettings, dict);
-        this._preparations = {
-            ...prep,
+        const { transformer, validateOptions, calcIncludeRanges, textValidator } = this.#calcSharedPrep(finalSettings, dict);
+        prep.update({
             dictionary: dict,
             docSettings,
             finalSettings,
             shouldCheck,
             validateOptions,
-            includeRanges,
-            segmenter,
             textValidator,
             transformer,
-        };
+            calcIncludeRanges,
+        });
         this._preparationTime = timer.elapsed;
         stopMeasure();
     }
@@ -169,10 +164,10 @@ export class DocumentValidator {
         const validateOptions = { ...settingsToValidateOptions(finalSettings), transformer };
         // Avoid excluding text ranges that have a full substitution applied.
         const rangeTransformer = finalSettings.substitutions?.length ? sub.transformer : undefined;
-        const includeRanges = calcTextInclusionRanges(this._document.text, validateOptions, rangeTransformer);
-        const segmenter = createMappedTextSegmenter(includeRanges);
+        const text = this._document.text;
+        const calcIncludeRanges = () => calcTextInclusionRanges(text, validateOptions, rangeTransformer);
         const textValidator = textValidatorFactory(dict, validateOptions);
-        return { segmenter, textValidator, includeRanges, validateOptions, transformer };
+        return { textValidator, calcIncludeRanges, validateOptions, transformer };
     }
     /**
      * The amount of time in ms to prepare for validation.
@@ -415,10 +410,26 @@ export class DocumentValidator {
     }
     /**
      * Internal `cspell-lib` use.
+     * @deprecated Will be removed in a future major version. Use {@link _getLocalConfig} and
+     * {@link _getLocalConfigFilepath} instead.
      */
     _getPreparations() {
         return this._preparations;
     }
+    /**
+     * Internal `cspell-lib` use.
+     * @returns the config file found for the document, if any.
+     */
+    _getLocalConfig() {
+        return this._preparations?.localConfig;
+    }
+    /**
+     * Internal `cspell-lib` use.
+     * @returns the path of the config file found for the document, if any.
+     */
+    _getLocalConfigFilepath() {
+        return this._preparations?.localConfigFilepath;
+    }
     /**
      * Get the calculated ranges of text that should be included in the spell checking.
      *
@@ -509,11 +520,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/docValidatorPreparations.d.ts

@@ -0,0 +1,74 @@
+import type { CSpellUserSettings, MappedText } from '@cspell/cspell-types';
+import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Settings/index.js';
+import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
+import type { MatchRange, TextTransformer } from '../Transform/index.js';
+import type { TextValidationFactoryOptions, TextValidator } from './lineValidatorFactory.js';
+/**
+ * What a `DocumentValidator` needs to spell check its document.
+ */
+export interface Preparations {
+    /** loaded config */
+    config: CSpellSettingsInternal;
+    dictionary: SpellingDictionaryCollection;
+    /** configuration after applying in-doc settings */
+    docSettings: CSpellSettingsInternal;
+    finalSettings: CSpellSettingsInternalFinalized;
+    includeRanges: MatchRange[];
+    textValidator: TextValidator;
+    segmenter: (texts: MappedText) => Iterable<MappedText>;
+    shouldCheck: boolean;
+    validateOptions: TextValidationFactoryOptions;
+    localConfig: CSpellUserSettings | undefined;
+    localConfigFilepath: string | undefined;
+    transformer: TextTransformer;
+}
+/**
+ * The preparations that depend on the document's settings. They are replaced when the document changes.
+ */
+export interface DocumentSettingsPreparations {
+    dictionary: SpellingDictionaryCollection;
+    /** configuration after applying in-doc settings */
+    docSettings: CSpellSettingsInternal;
+    finalSettings: CSpellSettingsInternalFinalized;
+    shouldCheck: boolean;
+    validateOptions: TextValidationFactoryOptions;
+    textValidator: TextValidator;
+    transformer: TextTransformer;
+    /**
+     * Runs every ignore pattern over the whole document, so it is only called once the include ranges are needed.
+     */
+    calcIncludeRanges: () => MatchRange[];
+}
+/**
+ * The include ranges, and the segmenter built from them, are calculated on first use. A document that
+ * is never checked never pays for them.
+ */
+export declare class DocumentValidatorPreparations implements Preparations {
+    #private;
+    readonly config: CSpellSettingsInternal;
+    readonly localConfig: CSpellUserSettings | undefined;
+    readonly localConfigFilepath: string | undefined;
+    dictionary: SpellingDictionaryCollection;
+    /** configuration after applying in-doc settings */
+    docSettings: CSpellSettingsInternal;
+    finalSettings: CSpellSettingsInternalFinalized;
+    shouldCheck: boolean;
+    validateOptions: TextValidationFactoryOptions;
+    textValidator: TextValidator;
+    transformer: TextTransformer;
+    /**
+     * @param config - loaded config
+     * @param localConfig - the config file found for the document, if any.
+     * @param localConfigFilepath - the path of `localConfig`.
+     * @param prep - the preparations that depend on the document's settings.
+     */
+    constructor(config: CSpellSettingsInternal, localConfig: CSpellUserSettings | undefined, localConfigFilepath: string | undefined, prep: DocumentSettingsPreparations);
+    /**
+     * Replace the preparations that depend on the document's settings. The include ranges are
+     * calculated again on next use.
+     */
+    update(prep: DocumentSettingsPreparations): void;
+    get includeRanges(): MatchRange[];
+    get segmenter(): (texts: MappedText) => Iterable<MappedText>;
+}
+//# sourceMappingURL=docValidatorPreparations.d.ts.map

package/dist/lib/textValidation/docValidatorPreparations.js

@@ -0,0 +1,63 @@
+import { createMappedTextSegmenter } from '../Transform/index.js';
+/**
+ * The include ranges, and the segmenter built from them, are calculated on first use. A document that
+ * is never checked never pays for them.
+ */
+export class DocumentValidatorPreparations {
+    config;
+    localConfig;
+    localConfigFilepath;
+    dictionary;
+    /** configuration after applying in-doc settings */
+    docSettings;
+    finalSettings;
+    shouldCheck;
+    validateOptions;
+    textValidator;
+    transformer;
+    #calcIncludeRanges;
+    #includeRanges;
+    #segmenter;
+    /**
+     * @param config - loaded config
+     * @param localConfig - the config file found for the document, if any.
+     * @param localConfigFilepath - the path of `localConfig`.
+     * @param prep - the preparations that depend on the document's settings.
+     */
+    constructor(config, localConfig, localConfigFilepath, prep) {
+        this.config = config;
+        this.localConfig = localConfig;
+        this.localConfigFilepath = localConfigFilepath;
+        this.dictionary = prep.dictionary;
+        this.docSettings = prep.docSettings;
+        this.finalSettings = prep.finalSettings;
+        this.shouldCheck = prep.shouldCheck;
+        this.validateOptions = prep.validateOptions;
+        this.textValidator = prep.textValidator;
+        this.transformer = prep.transformer;
+        this.#calcIncludeRanges = prep.calcIncludeRanges;
+    }
+    /**
+     * Replace the preparations that depend on the document's settings. The include ranges are
+     * calculated again on next use.
+     */
+    update(prep) {
+        this.dictionary = prep.dictionary;
+        this.docSettings = prep.docSettings;
+        this.finalSettings = prep.finalSettings;
+        this.shouldCheck = prep.shouldCheck;
+        this.validateOptions = prep.validateOptions;
+        this.textValidator = prep.textValidator;
+        this.transformer = prep.transformer;
+        this.#calcIncludeRanges = prep.calcIncludeRanges;
+        this.#includeRanges = undefined;
+        this.#segmenter = undefined;
+    }
+    get includeRanges() {
+        return (this.#includeRanges ??= this.#calcIncludeRanges());
+    }
+    get segmenter() {
+        return (this.#segmenter ??= createMappedTextSegmenter(this.includeRanges));
+    }
+}
+//# sourceMappingURL=docValidatorPreparations.js.map

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

@@ -1,15 +1,35 @@
 {
   "name": "cspell-lib",
+  "version": "10.3.6",
+  "description": "A library of useful functions used across various cspell tools.",
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
-  "version": "10.3.4",
-  "description": "A library of useful functions used across various cspell tools.",
-  "type": "module",
+  "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/streetsidesoftware/cspell.git",
+    "directory": "packages/cspell-lib"
+  },
+  "bugs": {
+    "url": "https://github.com/streetsidesoftware/cspell/issues?q=is%3Aissue%20state%3Aopen%20label%3Acspell-lib"
+  },
+  "keywords": [
+    "spell",
+    "checker",
+    "code",
+    "camel",
+    "case",
+    "spelling",
+    "spell checker",
+    "spelling checker",
+    "lint"
+  ],
+  "license": "MIT",
+  "author": "Jason Dent",
   "sideEffects": false,
-  "types": "dist/index.d.ts",
-  "module": "dist/index.js",
+  "type": "module",
   "exports": {
     ".": {
       "import": "./dist/index.js"
@@ -27,6 +47,8 @@
       "import": "./dist/cspell-rpc/client.js"
     }
   },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "!**/*.tsbuildInfo",
@@ -38,59 +60,37 @@
     "!**/*.map"
   ],
   "scripts": {
-    "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
-    "clean-build": "pnpm clean && pnpm build",
     "build": "tsc -p . && pnpm run build:api",
     "build:api": "tsdown",
-    "watch": "tsc -p . --watch",
+    "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
+    "clean-build": "pnpm clean && pnpm build",
     "coverage": "vitest run --coverage --pool=forks",
-    "test-watch": "vitest",
     "prepublishOnly": "pnpm run clean-build",
     "test": "vitest run --pool=forks",
-    "test:update-snapshot": "vitest run -u",
     "test:perf": "NODE_ENV=production insight --file \"**/*.perf.{mjs,js}\"",
+    "test:perf:prof": "NODE_ENV=production node --cpu-prof ../../node_modules/perf-insight/bin.mjs --file \"dist/**/*.perf.{mjs,js}\" -t 1000",
     "test:perf:ts": "NODE_ENV=production insight --file \"**/*.perf.{mts,ts}\" ",
-    "test:perf:prof": "NODE_ENV=production node --cpu-prof ../../node_modules/perf-insight/bin.mjs --file \"dist/**/*.perf.{mjs,js}\" -t 1000"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/streetsidesoftware/cspell.git",
-    "directory": "packages/cspell-lib"
-  },
-  "keywords": [
-    "spell",
-    "checker",
-    "code",
-    "camel",
-    "case",
-    "spelling",
-    "spell checker",
-    "spelling checker",
-    "lint"
-  ],
-  "author": "Jason Dent",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/streetsidesoftware/cspell/labels/cspell-lib"
+    "test:update-snapshot": "vitest run -u",
+    "test-watch": "vitest",
+    "watch": "tsc -p . --watch"
   },
-  "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "10.3.4",
-    "@cspell/cspell-performance-monitor": "10.3.4",
-    "@cspell/cspell-pipe": "10.3.4",
-    "@cspell/cspell-resolver": "10.3.4",
-    "@cspell/cspell-types": "10.3.4",
-    "@cspell/dynamic-import": "10.3.4",
-    "@cspell/filetypes": "10.3.4",
-    "@cspell/rpc": "10.3.4",
-    "@cspell/strong-weak-map": "10.3.4",
-    "@cspell/url": "10.3.4",
-    "cspell-config-lib": "10.3.4",
-    "cspell-dictionary": "10.3.4",
-    "cspell-glob": "10.3.4",
-    "cspell-grammar": "10.3.4",
-    "cspell-io": "10.3.4",
-    "cspell-trie-lib": "10.3.4",
+    "@cspell/cspell-bundled-dicts": "10.3.6",
+    "@cspell/cspell-performance-monitor": "10.3.6",
+    "@cspell/cspell-pipe": "10.3.6",
+    "@cspell/cspell-resolver": "10.3.6",
+    "@cspell/cspell-types": "10.3.6",
+    "@cspell/dynamic-import": "10.3.6",
+    "@cspell/filetypes": "10.3.6",
+    "@cspell/rpc": "10.3.6",
+    "@cspell/strong-weak-map": "10.3.6",
+    "@cspell/url": "10.3.6",
+    "cspell-config-lib": "10.3.6",
+    "cspell-dictionary": "10.3.6",
+    "cspell-glob": "10.3.6",
+    "cspell-grammar": "10.3.6",
+    "cspell-io": "10.3.6",
+    "cspell-trie-lib": "10.3.6",
     "env-paths": "^4.0.0",
     "gensequence": "^8.0.8",
     "import-fresh": "^4.0.0",
@@ -99,11 +99,7 @@
     "vscode-uri": "^3.2.0",
     "xdg-basedir": "^5.1.0"
   },
-  "engines": {
-    "node": ">=22.18.0"
-  },
   "devDependencies": {
-    "@cspell/cspell-tools": "10.3.4",
     "@cspell/dict-cpp": "^7.1.0",
     "@cspell/dict-csharp": "^4.0.8",
     "@cspell/dict-css": "^4.1.2",
@@ -123,5 +119,8 @@
     "lorem-ipsum": "^3.0.0",
     "perf-insight": "^2.0.1"
   },
-  "gitHead": "7bb5c4750ece7c732edbf920c0cea910d9b4d717"
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "gitHead": "8559198ccfcac2f745911db1ffe2ee62c17cba49"
 }