cspell-lib 10.3.1-alpha.1 → 10.3.1

package/README.md

@@ -6,13 +6,11 @@
 
 <!--- @@inject: ../../static/sponsor.md --->
 
-[![GitHub Sponsors](https://img.shields.io/badge/-Street_Side_Software-black?style=for-the-badge&logo=githubsponsors&label=GitHub%20Sponsor%3A)](https://github.com/sponsors/streetsidesoftware)
+If our spell checkers save you time, please consider supporting their development.
 
-[![Open Collective](https://img.shields.io/badge/-CSpell-black?style=for-the-badge&logo=opencollective&label=Open%20Collective%3A)](https://opencollective.com/cspell)
-
-[![Street Side Software](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fstreetsidesoftware%2Fcspell%2Frefs%2Fheads%2Fmain%2Fstatic%2Fcspell-badge.json)](https://streetsidesoftware.com/sponsor/)
-
-[![PayPal](https://img.shields.io/badge/-Street_Side_Software-black?style=for-the-badge&logo=paypal&label=PayPal%20Donate%3A)](https://www.paypal.com/donate/?hosted_button_id=26LNBP2Q6MKCY)
+<p align="left">
+  <a href="https://github.com/sponsors/streetsidesoftware" title="GitHub Sponsor"><picture><source media="(prefers-color-scheme: dark)" srcset="https://cspell.org/img/sponsor/github-sponsor-dark.png" /><img alt="GitHub Sponsor" src="https://cspell.org/img/sponsor/github-sponsor.png" width="180" /></picture></a> &nbsp; <a href="https://www.paypal.com/donate/?hosted_button_id=26LNBP2Q6MKCY" title="PayPal"><picture><source media="(prefers-color-scheme: dark)" srcset="https://cspell.org/img/sponsor/paypal-dark.png" /><img alt="PayPal" src="https://cspell.org/img/sponsor/paypal.png" width="180" /></picture></a> &nbsp; <a href="https://opencollective.com/cspell" title="Open Collective"><picture><source media="(prefers-color-scheme: dark)" srcset="https://cspell.org/img/sponsor/open-collective-dark.png" /><img alt="Open Collective" src="https://cspell.org/img/sponsor/open-collective.png" width="180" /></picture></a> &nbsp; <a href="https://streetsidesoftware.com/sponsor/" title="Street Side Software"><picture><source media="(prefers-color-scheme: dark)" srcset="https://cspell.org/img/sponsor/cspell-dark.png" /><img alt="CSpell" src="https://cspell.org/img/sponsor/cspell.png" width="180" /></picture></a>
+</p>
 
 <!--- @@inject-end: ../../static/sponsor.md --->
 

package/dist/lib/Settings/patterns.js

@@ -1,4 +1,4 @@
-import { stringToRegExp } from '../util/textRegex.js';
+import { stringToRegExpOrUndefined } from '../util/textRegex.js';
 import { isDefined } from '../util/util.js';
 import { CalcLeftRightResultWeakCache } from './mergeCache.js';
 const emptyRegExpList = [];
@@ -34,6 +34,6 @@ function _resolvePatterns(regExpList, patternDefinitions) {
     return result;
 }
 function toRegExp(pattern) {
-    return pattern instanceof RegExp ? new RegExp(pattern) : stringToRegExp(pattern, 'gim', 'g');
+    return pattern instanceof RegExp ? new RegExp(pattern) : stringToRegExpOrUndefined(pattern, 'gim', 'g');
 }
 //# sourceMappingURL=patterns.js.map

package/dist/lib/Transform/IntlSegmentTextTransformer.d.ts

@@ -1,6 +1,5 @@
 import type { MappedText } from '@cspell/cspell-types';
 import type { TextTransformer } from './Transformer.js';
-export declare const softHyphen = "\u00AD";
 export declare class IntlSegmentTextTransformer implements TextTransformer {
     #private;
     constructor(locale: string | string[]);

package/dist/lib/Transform/IntlSegmentTextTransformer.js

@@ -1,7 +1,6 @@
 import { normalizeLocaleIntl } from '../Settings/LanguageSettings.js';
 import { applyEditsToMappedText } from './TextMapEdit.js';
-import { toMappedText } from './Transformer.js';
-export const softHyphen = '\u00AD';
+import { softHyphen, toMappedText } from './Transformer.js';
 const regExSplitWordCharacters = /(?<=[\p{L}\p{M}])[\p{L}\p{M}]/uy;
 export class IntlSegmentTextTransformer {
     #locale;

package/dist/lib/Transform/Transformer.d.ts

@@ -1,5 +1,6 @@
 import type { MappedText } from '@cspell/cspell-types';
 import type { Range } from '@cspell/cspell-types/Parser';
+export declare const softHyphen = "\u00AD";
 export interface TextTransformer {
     transform(text: string | MappedText): MappedText;
     transformAll(src: Iterable<string | MappedText>): Iterable<MappedText>;

package/dist/lib/Transform/Transformer.js

@@ -1,3 +1,4 @@
+export const softHyphen = '\u00AD';
 export function toMappedText(text) {
     if (typeof text === 'string') {
         return { text, range: [0, text.length], rawText: text };

package/dist/lib/Transform/WordBreakTextTransformer.d.ts

@@ -0,0 +1,10 @@
+import type { MappedText, WordSegmentationSettings } from '@cspell/cspell-types';
+import type { TextTransformer } from './Transformer.js';
+export declare class SoftWordBreakTextTransformer implements TextTransformer {
+    #private;
+    constructor(settings: WordSegmentationSettings);
+    transform(text: string | MappedText): MappedText;
+    transformAll(src: Iterable<string | MappedText>): Iterable<MappedText>;
+}
+export declare function createSoftWordBreakTextTransformer(settings: WordSegmentationSettings): TextTransformer;
+//# sourceMappingURL=WordBreakTextTransformer.d.ts.map

package/dist/lib/Transform/WordBreakTextTransformer.js

@@ -0,0 +1,114 @@
+import { escapeRegEx } from '../util/regexHelper.js';
+import { regExMatchRegExParts, stringToRegExpOrUndefined } from '../util/textRegex.js';
+import { applyEditsToMappedText } from './TextMapEdit.js';
+import { softHyphen, toMappedText } from './Transformer.js';
+export class SoftWordBreakTextTransformer {
+    #patterns;
+    constructor(settings) {
+        this.#patterns = compileSoftWordBreakPatterns(settings);
+    }
+    transform(text) {
+        const mText = toMappedText(text);
+        if (!this.#patterns.length)
+            return mText;
+        return applySoftWordBreaks(mText, this.#patterns);
+    }
+    *transformAll(src) {
+        for (const item of src) {
+            yield this.transform(item);
+        }
+    }
+}
+export function createSoftWordBreakTextTransformer(settings) {
+    return new SoftWordBreakTextTransformer(settings);
+}
+function compileSoftWordBreakPatterns(settings) {
+    const enabled = settings.softWordBreaks;
+    const definitions = settings.softWordBreakDefinitions;
+    if (!enabled || !definitions)
+        return [];
+    const patterns = [];
+    for (const name of Object.keys(enabled)) {
+        if (!enabled[name])
+            continue;
+        const rule = definitions[name];
+        if (!rule)
+            continue;
+        for (const part of Array.isArray(rule) ? rule : [rule]) {
+            patterns.push(compileSoftWordBreak(part));
+        }
+    }
+    return patterns;
+}
+function compileSoftWordBreak(rule) {
+    if (rule instanceof RegExp) {
+        return new RegExp(rule, rule.flags.includes('g') ? rule.flags : rule.flags + 'g');
+    }
+    if (regExMatchRegExParts.test(rule)) {
+        const regex = stringToRegExpOrUndefined(rule);
+        if (!regex) {
+            throw new Error(`Invalid soft word break regular expression: "${rule}"`);
+        }
+        return regex;
+    }
+    return compileSoftWordBreakPattern(rule);
+}
+/**
+ * Compiles a `SoftWordBreakPattern` string, e.g. `"^ptr|"` or `"before|after$"`, into a
+ * zero-width RegExp using lookbehind/lookahead so the matched break position can be located
+ * without consuming the surrounding text.
+ */
+function compileSoftWordBreakPattern(pattern) {
+    const pipeIndex = pattern.indexOf('|');
+    if (pipeIndex < 0) {
+        throw new Error(`Invalid soft word break pattern: "${pattern}"`);
+    }
+    let before = pattern.slice(0, pipeIndex);
+    let after = pattern.slice(pipeIndex + 1);
+    const startAnchored = before.startsWith('^');
+    if (startAnchored) {
+        before = before.slice(1);
+    }
+    const endAnchored = after.endsWith('$');
+    if (endAnchored) {
+        after = after.slice(0, -1);
+    }
+    const lookbehind = startAnchored ? `\\b${escapeRegEx(before)}` : escapeRegEx(before);
+    const lookahead = endAnchored ? `${escapeRegEx(after)}\\b` : escapeRegEx(after);
+    return new RegExp(`(?<=${lookbehind})(?=${lookahead})`, 'gu');
+}
+function applySoftWordBreaks(mText, patterns) {
+    const text = mText.text;
+    const edits = [];
+    for (const pattern of patterns) {
+        // Use a fresh RegExp per scan so unrelated calls don't share `lastIndex` state.
+        const reg = new RegExp(pattern.source, pattern.flags);
+        for (const m of text.matchAll(reg)) {
+            const index = m.index;
+            const match = m[0];
+            const range = [index, index + match.length];
+            const editText = match ? softHyphen + match + softHyphen : softHyphen;
+            edits.push({ text: editText, range });
+        }
+    }
+    if (!edits.length)
+        return mText;
+    return applyEditsToMappedText(mText, mergeEdits(edits));
+}
+function mergeEdits(edits) {
+    edits.sort((a, b) => a.range[0] - b.range[0] || a.range[1] - b.range[1]);
+    const merged = [];
+    let lastStart = -1;
+    let lastEnd = -1;
+    for (const edit of edits) {
+        if (edit.range[0] < lastEnd)
+            continue;
+        if (edit.range[0] === lastStart && edit.range[1] === lastEnd)
+            continue;
+        merged.push(edit);
+        lastStart = edit.range[0];
+        lastEnd = edit.range[1];
+    }
+    return merged;
+}
+//# sourceMappingURL=WordBreakTextTransformer.js.map

package/dist/lib/Transform/index.d.ts

@@ -9,4 +9,5 @@ export { excludeRanges, extractRangeText, findMatchingRanges, findMatchingRanges
 export type { TextTransformer } from './Transformer.js';
 export { chainTransformers } from './Transformer.js';
 export type { Offset, SimpleRange } from './types.js';
+export { createSoftWordBreakTextTransformer } from './WordBreakTextTransformer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/Transform/index.js

@@ -4,4 +4,5 @@ export { createSourceMapCursor } from './SourceMap.js';
 export { createSubstitutionTransformer, SubstitutionTransformer } from './SubstitutionTransformer.js';
 export { excludeRanges, extractRangeText, findMatchingRanges, findMatchingRangesForPatterns } from './TextRange.js';
 export { chainTransformers } from './Transformer.js';
+export { createSoftWordBreakTextTransformer } from './WordBreakTextTransformer.js';
 //# sourceMappingURL=index.js.map

package/dist/lib/exclusionHelper.d.ts

@@ -17,7 +17,6 @@ export declare function generateExclusionFunctionForUri(globs: Glob[], root: str
  * @todo Support multi root globs.
  * @param globs - glob patterns
  * @param root - root directory
- * @param allowedSchemes - allowed schemas
  */
 export declare function generateExclusionFunctionForFiles(globs: Glob[], root: string): FileExclusionFunction;
 //# sourceMappingURL=exclusionHelper.d.ts.map

package/dist/lib/exclusionHelper.js

@@ -42,7 +42,6 @@ export function generateExclusionFunctionForUri(globs, root, allowedSchemes = de
  * @todo Support multi root globs.
  * @param globs - glob patterns
  * @param root - root directory
- * @param allowedSchemes - allowed schemas
  */
 export function generateExclusionFunctionForFiles(globs, root) {
     const matcher = new GlobMatcher(globs, { root, dot: true });

package/dist/lib/spellCheckFile.d.ts

@@ -71,21 +71,21 @@ export interface SpellCheckFileResultRPC {
  * Spell Check a file
  * @param file - absolute path to file to read and check.
  * @param options - options to control checking
- * @param settings - default settings to use.
+ * @param settingsOrConfigFile - default settings to use.
  */
 export declare function spellCheckFile(file: string | Uri | URL, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
 /**
  * Spell Check a Document.
  * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
  * @param options - options to control checking
- * @param settings - default settings to use.
+ * @param settingsOrConfigFile - default settings to use.
  */
 export declare function spellCheckDocument(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
 /**
  * Spell Check a Document.
  * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
  * @param options - options to control checking
- * @param settings - default settings to use.
+ * @param settingsOrConfigFile - default settings to use.
  */
 export declare function spellCheckDocumentRPC(document: Document | DocumentWithText, options: SpellCheckFileOptionsRPC, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResultRPC>;
 export interface DetermineFinalDocumentSettingsResult {

package/dist/lib/spellCheckFile.js

@@ -12,7 +12,7 @@ import { toUri } from './util/Uri.js';
  * Spell Check a file
  * @param file - absolute path to file to read and check.
  * @param options - options to control checking
- * @param settings - default settings to use.
+ * @param settingsOrConfigFile - default settings to use.
  */
 export function spellCheckFile(file, options, settingsOrConfigFile) {
     const doc = {
@@ -24,7 +24,7 @@ export function spellCheckFile(file, options, settingsOrConfigFile) {
  * Spell Check a Document.
  * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
  * @param options - options to control checking
- * @param settings - default settings to use.
+ * @param settingsOrConfigFile - default settings to use.
  */
 export async function spellCheckDocument(document, options, settingsOrConfigFile) {
     const settingsUsed = satisfiesCSpellConfigFile(settingsOrConfigFile)
@@ -78,7 +78,7 @@ export async function spellCheckDocument(document, options, settingsOrConfigFile
  * Spell Check a Document.
  * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
  * @param options - options to control checking
- * @param settings - default settings to use.
+ * @param settingsOrConfigFile - default settings to use.
  */
 export async function spellCheckDocumentRPC(document, options, settingsOrConfigFile) {
     const { issues, checked, errors, configErrors, dictionaryErrors, perf } = await spellCheckDocument(document, options, settingsOrConfigFile);

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

@@ -52,7 +52,8 @@ export declare class DocumentValidator {
     static create(doc: TextDocument, options: DocumentValidatorOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<DocumentValidator>;
     /**
      * @param doc - Document to validate
-     * @param config - configuration to use (not finalized).
+     * @param options - options controlling how the document is validated.
+     * @param settings - configuration to use (not finalized).
      */
     constructor(doc: TextDocument, options: DocumentValidatorOptions, settings: CSpellUserSettings);
     get ready(): boolean;

package/dist/lib/textValidation/docValidator.js

@@ -10,7 +10,7 @@ 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, createSubstitutionTransformer, } from '../Transform/index.js';
+import { chainTransformers, createIntlSegmentTextTransformer, createMappedTextSegmenter, 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';
@@ -44,7 +44,8 @@ export class DocumentValidator {
     }
     /**
      * @param doc - Document to validate
-     * @param config - configuration to use (not finalized).
+     * @param options - options controlling how the document is validated.
+     * @param settings - configuration to use (not finalized).
      */
     constructor(doc, options, settings) {
         this.settings = settings;
@@ -152,9 +153,13 @@ export class DocumentValidator {
         if (sub.missing) {
             this.addPossibleError(`Missing substitutions: ${sub.missing.join(', ')}`);
         }
-        const transformer = finalSettings.useIntlWordSegmentation
-            ? chainTransformers(sub.transformer, createIntlSegmentTextTransformer(finalSettings.language || ''))
-            : sub.transformer;
+        let transformer = sub.transformer;
+        if (finalSettings.useIntlWordSegmentation) {
+            transformer = chainTransformers(transformer, createIntlSegmentTextTransformer(finalSettings.language || ''));
+        }
+        if (finalSettings.softWordBreaks) {
+            transformer = chainTransformers(transformer, createSoftWordBreakTextTransformer(finalSettings));
+        }
         const validateOptions = { ...settingsToValidateOptions(finalSettings), transformer };
         // Avoid excluding text ranges that have a full substitution applied.
         const rangeTransformer = finalSettings.substitutions?.length ? sub.transformer : undefined;

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

@@ -1,8 +1,7 @@
-type Console = typeof console;
 export interface Logger {
-    log: Console['log'];
-    warn: Console['warn'];
-    error: Console['error'];
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
 }
 /**
  * See `Console.error`
@@ -27,5 +26,4 @@ export declare function setLogger(logger: Logger): Logger;
  * @returns the current logger.
  */
 export declare function getLogger(): Logger;
-export {};
 //# sourceMappingURL=logger.d.ts.map

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

@@ -1,6 +1,6 @@
 import type { TextDocumentOffset, TextOffset } from '@cspell/cspell-types';
 import type { Uri } from './IUri.js';
-export { stringToRegExp } from './textRegex.js';
+export { stringToRegExpOrUndefined as stringToRegExp } from './textRegex.js';
 export declare function splitCamelCaseWordWithOffset(wo: TextOffset): TextOffset[];
 /**
  * Split camelCase words into an array of strings.

package/dist/lib/util/text.js

@@ -2,7 +2,7 @@ import { opConcatMap, opMap, pipe } from '@cspell/cspell-pipe/sync';
 import { binarySearch } from './search.js';
 import { regExAccents, regExAllLower, regExAllUpper, regExFirstUpper, regExIgnoreCharacters, regExpCamelCaseWordBreaksWithEnglishSuffix, regExWords, regExWordsAndDigits, } from './textRegex.js';
 import { toUri } from './Uri.js';
-export { stringToRegExp } from './textRegex.js';
+export { stringToRegExpOrUndefined as stringToRegExp } from './textRegex.js';
 // CSpell:ignore ings ning gimuy tsmerge
 export function splitCamelCaseWordWithOffset(wo) {
     return splitWordWithOffset(wo, regExpCamelCaseWordBreaksWithEnglishSuffix);

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

@@ -19,5 +19,6 @@ export declare const regExDanglingQuote: RegExp;
 /** Match tailing endings after CAPS words */
 export declare const regExTrailingEndings: RegExp;
 export declare const regExNumericLiteral: RegExp;
-export declare function stringToRegExp(pattern: string | RegExp, defaultFlags?: string, forceFlags?: string): RegExp | undefined;
+export declare function stringToRegExpOrUndefined(pattern: string | RegExp, defaultFlags?: string, forceFlags?: string): RegExp | undefined;
+export declare function stringToRegExp(pattern: string | RegExp, defaultFlags?: string, forceFlags?: string): RegExp;
 //# sourceMappingURL=textRegex.d.ts.map

package/dist/lib/util/textRegex.js

@@ -21,28 +21,29 @@ export const regExDanglingQuote = /(?<=(?:^|(?!\p{M})\P{L})(?:\p{L}\p{M}?)?)[']/
 /** Match tailing endings after CAPS words */
 export const regExTrailingEndings = /(?<=(?:\p{Lu}\p{M}?){2})['’]?(?:s|d|ings?|ies|e[ds]?|ning|th|nth)(?!\p{Ll})/gu;
 export const regExNumericLiteral = /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?$/;
-export function stringToRegExp(pattern, defaultFlags = 'gimu', forceFlags = 'g') {
-    if (pattern instanceof RegExp) {
-        return pattern;
-    }
+export function stringToRegExpOrUndefined(pattern, defaultFlags = 'gimu', forceFlags = 'g') {
     try {
-        const [, pat, flag] = [
-            ...(pattern.match(regExMatchRegExParts) || ['', pattern.trim(), defaultFlags]),
-            forceFlags,
-        ];
-        if (pat) {
-            const regPattern = flag.includes('x') ? removeVerboseFromRegExp(pat) : pat;
-            // Make sure the flags are unique.
-            const flags = [...new Set(forceFlags + flag)].join('').replaceAll(/[^gimuy]/g, '');
-            const regex = new RegExp(regPattern, flags);
-            return regex;
-        }
+        return stringToRegExp(pattern, defaultFlags, forceFlags);
     }
     catch {
         /* empty */
     }
     return undefined;
 }
+export function stringToRegExp(pattern, defaultFlags = 'gimu', forceFlags = 'g') {
+    if (pattern instanceof RegExp) {
+        return pattern;
+    }
+    const [, pat, flag] = [...(pattern.match(regExMatchRegExParts) || ['', pattern.trim(), defaultFlags]), forceFlags];
+    if (!pat) {
+        throw new Error(`Invalid regular expression: "${pattern}"`);
+    }
+    const regPattern = flag.includes('x') ? removeVerboseFromRegExp(pat) : pat;
+    // Make sure the flags are unique.
+    const flags = [...new Set(forceFlags + flag)].join('').replaceAll(/[^gimuy]/g, '');
+    const regex = new RegExp(regPattern, flags);
+    return regex;
+}
 const SPACES = {
     ' ': true,
     '\n': true,

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "10.3.1-alpha.1",
+  "version": "10.3.1",
   "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.1-alpha.1",
-    "@cspell/cspell-performance-monitor": "10.3.1-alpha.1",
-    "@cspell/cspell-pipe": "10.3.1-alpha.1",
-    "@cspell/cspell-resolver": "10.3.1-alpha.1",
-    "@cspell/cspell-types": "10.3.1-alpha.1",
-    "@cspell/dynamic-import": "10.3.1-alpha.1",
-    "@cspell/filetypes": "10.3.1-alpha.1",
-    "@cspell/rpc": "10.3.1-alpha.1",
-    "@cspell/strong-weak-map": "10.3.1-alpha.1",
-    "@cspell/url": "10.3.1-alpha.1",
-    "cspell-config-lib": "10.3.1-alpha.1",
-    "cspell-dictionary": "10.3.1-alpha.1",
-    "cspell-glob": "10.3.1-alpha.1",
-    "cspell-grammar": "10.3.1-alpha.1",
-    "cspell-io": "10.3.1-alpha.1",
-    "cspell-trie-lib": "10.3.1-alpha.1",
+    "@cspell/cspell-bundled-dicts": "10.3.1",
+    "@cspell/cspell-performance-monitor": "10.3.1",
+    "@cspell/cspell-pipe": "10.3.1",
+    "@cspell/cspell-resolver": "10.3.1",
+    "@cspell/cspell-types": "10.3.1",
+    "@cspell/dynamic-import": "10.3.1",
+    "@cspell/filetypes": "10.3.1",
+    "@cspell/rpc": "10.3.1",
+    "@cspell/strong-weak-map": "10.3.1",
+    "@cspell/url": "10.3.1",
+    "cspell-config-lib": "10.3.1",
+    "cspell-dictionary": "10.3.1",
+    "cspell-glob": "10.3.1",
+    "cspell-grammar": "10.3.1",
+    "cspell-io": "10.3.1",
+    "cspell-trie-lib": "10.3.1",
     "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.1-alpha.1",
+    "@cspell/cspell-tools": "10.3.1",
     "@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": "aa0576e5b7e666a7e8645939871bcfe4fa2a7eb5"
+  "gitHead": "793953d1c2b4f1cab257389ff6ecb3ae2dd40230"
 }