cspell-lib 6.24.0 → 6.26.0

package/dist/LanguageIds.js

@@ -233,6 +233,7 @@ exports.languageExtensionDefinitions = [
     { id: 'jar', extensions: ['.jar'], format: 'Binary' },
     { id: 'spv', extensions: ['.spv'], format: 'Binary', description: 'SPSS Output Document' },
     { id: 'mdb', extensions: ['.mdb'], format: 'Binary', description: 'Microsoft Access DB' },
+    { id: 'webm', extensions: ['.webm'], format: 'Binary', description: 'WebM is an audiovisual media file format.' },
 ];
 const binaryFormatIds = exports.languageExtensionDefinitions.filter((d) => d.format === 'Binary').map((d) => d.id);
 exports.binaryLanguages = new Set(['binary', 'image', 'video', 'fonts'].concat(binaryFormatIds));

package/dist/Models/CSpellSettingsInternalDef.d.ts

@@ -32,6 +32,7 @@ export interface DictionaryFileDefinitionInternalWithSource extends DictionaryFi
 export type DictionaryDefinitionInternalWithSource = DictionaryDefinitionInternal & {
     readonly __source: string;
 };
+export declare function cleanCSpellSettingsInternal(parts?: OptionalOrUndefined<Partial<CSpellSettingsInternal>>): CSpellSettingsInternal;
 export declare function createCSpellSettingsInternal(parts?: OptionalOrUndefined<Partial<CSpellSettingsInternal>>): CSpellSettingsInternal;
 export declare function isCSpellSettingsInternal(cs: CSpellSettingsInternal | CSpellSettingsWithSourceTrace | OptionalOrUndefined<CSpellSettingsInternal | CSpellSettingsWithSourceTrace>): cs is CSpellSettingsInternal;
 export declare function isDictionaryDefinitionInlineInternal(def: DictionaryDefinitionInternal | DictionaryDefinitionInline | DictionaryDefinition): def is DictionaryDefinitionInlineInternal;

package/dist/Models/CSpellSettingsInternalDef.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDictionaryDefinitionInlineInternal = exports.isCSpellSettingsInternal = exports.createCSpellSettingsInternal = exports.SymbolCSpellSettingsInternal = void 0;
+exports.isDictionaryDefinitionInlineInternal = exports.isCSpellSettingsInternal = exports.createCSpellSettingsInternal = exports.cleanCSpellSettingsInternal = exports.SymbolCSpellSettingsInternal = void 0;
 const util_1 = require("../util/util");
 exports.SymbolCSpellSettingsInternal = Symbol('CSpellSettingsInternal');
+function cleanCSpellSettingsInternal(parts = {}) {
+    const csi = (0, util_1.clean)(parts);
+    Object.assign(csi, { [exports.SymbolCSpellSettingsInternal]: true });
+    return csi;
+}
+exports.cleanCSpellSettingsInternal = cleanCSpellSettingsInternal;
 function createCSpellSettingsInternal(parts = {}) {
     return (0, util_1.clean)({
         ...parts,
@@ -18,7 +24,7 @@ function isDictionaryDefinitionInlineInternal(def) {
     if (def.path)
         return false;
     const defInline = def;
-    return !!(defInline.words || defInline.flagWords || defInline.ignoreWords);
+    return !!(defInline.words || defInline.flagWords || defInline.ignoreWords || defInline.suggestWords);
 }
 exports.isDictionaryDefinitionInlineInternal = isDictionaryDefinitionInlineInternal;
 //# sourceMappingURL=CSpellSettingsInternalDef.js.map

package/dist/Settings/CSpellSettingsServer.js

@@ -63,6 +63,11 @@ function mergeList(left, right) {
 }
 const emptyWords = [];
 Object.freeze(emptyWords);
+const cachedMerges = new WeakMap();
+function _mergeWordsCached(left, right) {
+    const map = (0, AutoResolve_1.autoResolveWeak)(cachedMerges, left, () => new WeakMap());
+    return (0, AutoResolve_1.autoResolveWeak)(map, right, () => left.concat(right));
+}
 function mergeWordsCached(left, right) {
     if (left === undefined)
         return !right || right.length ? right : emptyWords;
@@ -72,7 +77,7 @@ function mergeWordsCached(left, right) {
         return !right || right.length ? right : emptyWords;
     if (!right.length)
         return !left || left.length ? left : emptyWords;
-    return left.concat(right);
+    return _mergeWordsCached(left, right);
 }
 function mergeObjects(left, right) {
     if (left === undefined)
@@ -115,22 +120,21 @@ function merge(left, right) {
     if (doesLeftHaveRightAncestor(_left, _right)) {
         return _left;
     }
-    const leftId = _left.id || _left.languageId || '';
-    const rightId = _right.id || _right.languageId || '';
     const includeRegExpList = takeRightOtherwiseLeft(_left.includeRegExpList, _right.includeRegExpList);
     const optionals = includeRegExpList?.length ? { includeRegExpList } : {};
     const version = max(_left.version, _right.version);
-    const settings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
+    const settings = (0, CSpellSettingsInternalDef_1.cleanCSpellSettingsInternal)({
         ..._left,
         ..._right,
         ...optionals,
         version,
-        id: [leftId, rightId].join('|'),
-        name: [_left.name || '', _right.name || ''].join('|'),
+        id: undefined,
+        name: undefined,
         words: mergeWordsCached(_left.words, _right.words),
         userWords: mergeWordsCached(_left.userWords, _right.userWords),
         flagWords: mergeWordsCached(_left.flagWords, _right.flagWords),
         ignoreWords: mergeWordsCached(_left.ignoreWords, _right.ignoreWords),
+        suggestWords: mergeWordsCached(_left.suggestWords, _right.suggestWords),
         enabledLanguageIds: replaceIfNotEmpty(_left.enabledLanguageIds, _right.enabledLanguageIds),
         enableFiletypes: mergeList(_left.enableFiletypes, _right.enableFiletypes),
         ignoreRegExpList: mergeListUnique(_left.ignoreRegExpList, _right.ignoreRegExpList),
@@ -240,7 +244,7 @@ function toInternalSettings(settings) {
     const { dictionaryDefinitions: defs, ...rest } = settings;
     const dictionaryDefinitions = (0, DictionarySettings_1.mapDictDefsToInternal)(defs, filenameToDirectory(settings.source?.filename) || resolveCwd());
     const setting = dictionaryDefinitions ? { ...rest, dictionaryDefinitions } : rest;
-    return (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)(setting);
+    return (0, CSpellSettingsInternalDef_1.cleanCSpellSettingsInternal)(setting);
 }
 exports.toInternalSettings = toInternalSettings;
 function filenameToDirectory(filename) {
@@ -259,10 +263,8 @@ function checkFilenameMatchesGlob(filename, globs) {
 }
 exports.checkFilenameMatchesGlob = checkFilenameMatchesGlob;
 function mergeSources(left, right) {
-    const { source: a = { name: 'left' } } = left;
-    const { source: b = { name: 'right' } } = right;
     return {
-        name: [left.name || a.name, right.name || b.name].join('|'),
+        name: 'merged',
         sources: [left, right],
     };
 }

package/dist/Settings/Controller/configLoader/normalizeRawSettings.d.ts

@@ -26,6 +26,7 @@ export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDef
         words?: string[];
         flagWords?: string[];
         ignoreWords?: string[];
+        suggestWords?: string[];
         parser?: string;
     }>[] | undefined;
 }>;

package/dist/Settings/InDocSettings.d.ts

@@ -1,4 +1,4 @@
-import type { CSpellUserSettings } from '@cspell/cspell-types';
+import type { CSpellUserSettings, DictionaryDefinitionInline } from '@cspell/cspell-types';
 import type { Sequence } from 'gensequence';
 import type { ExtendedSuggestion } from '../Models/Suggestion';
 export type CSpellUserSettingsKeys = keyof CSpellUserSettings;
@@ -26,6 +26,7 @@ declare function parseIgnoreWords(match: string): CSpellUserSettings;
 declare function parseIgnoreRegExp(match: string): CSpellUserSettings;
 declare function getPossibleInDocSettings(text: string): Sequence<RegExpExecArray>;
 declare function getWordsFromDocument(text: string): string[];
+export declare function extractInDocDictionary(settings: CSpellUserSettings): DictionaryDefinitionInline | undefined;
 export declare function getIgnoreWordsFromDocument(text: string): string[];
 export declare function getIgnoreRegExpFromDocument(text: string): (string | RegExp)[];
 /**
@@ -38,6 +39,7 @@ export declare const internal: {
     parseCompoundWords: typeof parseCompoundWords;
     parseIgnoreRegExp: typeof parseIgnoreRegExp;
     parseIgnoreWords: typeof parseIgnoreWords;
+    staticInDocumentDictionaryName: string;
 };
 export {};
 //# sourceMappingURL=InDocSettings.d.ts.map

package/dist/Settings/InDocSettings.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.internal = exports.getIgnoreRegExpFromDocument = exports.getIgnoreWordsFromDocument = exports.regExSpellingGuardLine = exports.regExSpellingGuardNext = exports.regExSpellingGuardBlock = exports.validateInDocumentSettings = exports.getInDocumentSettings = void 0;
+exports.internal = exports.getIgnoreRegExpFromDocument = exports.getIgnoreWordsFromDocument = exports.extractInDocDictionary = exports.regExSpellingGuardLine = exports.regExSpellingGuardNext = exports.regExSpellingGuardBlock = exports.validateInDocumentSettings = exports.getInDocumentSettings = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const gensequence_1 = require("gensequence");
 const SpellingDictionary_1 = require("../SpellingDictionary");
@@ -92,12 +92,35 @@ const dictInDocSettings = (0, SpellingDictionary_1.createSpellingDictionary)(all
 });
 const EmptyWords = [];
 Object.freeze(EmptyWords);
+const staticInDocumentDictionaryName = `[in-document-dict]`;
 function getInDocumentSettings(text) {
-    const settings = getPossibleInDocSettings(text)
+    const collectedSettings = getPossibleInDocSettings(text)
         .concatMap((a) => parseSettingMatch(a))
         .reduce((s, setting) => {
         return (0, CSpellSettingsServer_1.mergeInDocSettings)(s, setting);
     }, { id: 'in-doc-settings' });
+    const { words, flagWords, ignoreWords, suggestWords, dictionaries = [], dictionaryDefinitions = [], ...rest } = collectedSettings;
+    const dict = (words || flagWords || ignoreWords || suggestWords) &&
+        (0, util_1.clean)({
+            name: staticInDocumentDictionaryName,
+            words,
+            flagWords,
+            ignoreWords,
+            suggestWords,
+        });
+    const dictSettings = dict
+        ? {
+            dictionaries: dictionaries.concat(staticInDocumentDictionaryName),
+            dictionaryDefinitions: dictionaryDefinitions.concat(dict),
+        }
+        : (0, util_1.clean)({
+            dictionaries: dictionaries.length ? dictionaries : undefined,
+            dictionaryDefinitions: dictionaryDefinitions.length ? dictionaryDefinitions : undefined,
+        });
+    const settings = {
+        ...rest,
+        ...dictSettings,
+    };
     // console.log('InDocSettings: %o', settings);
     return settings;
 }
@@ -124,6 +147,7 @@ const settingParsers = [
 exports.regExSpellingGuardBlock = /(\bc?spell(?:-?checker)?::?)\s*disable(?!-line|-next)\b[\s\S]*?((?:\1\s*enable\b)|$)/gi;
 exports.regExSpellingGuardNext = /\bc?spell(?:-?checker)?::?\s*disable-next\b.*\s\s?.*/gi;
 exports.regExSpellingGuardLine = /^.*\bc?spell(?:-?checker)?::?\s*disable-line\b.*/gim;
+const emptySettings = Object.freeze({});
 const issueMessages = {
     unknownDirective: 'Unknown CSpell directive',
 };
@@ -183,11 +207,11 @@ function parseSettingMatch(matchArray) {
 }
 function parseCompoundWords(match) {
     const allowCompoundWords = /enable/i.test(match);
-    return { id: 'in-doc-allowCompoundWords', allowCompoundWords };
+    return { allowCompoundWords };
 }
 function parseCaseSensitive(match) {
     const caseSensitive = /enable/i.test(match);
-    return { id: 'in-doc-caseSensitive', caseSensitive };
+    return { caseSensitive };
 }
 function parseWords(match) {
     const words = match
@@ -195,20 +219,22 @@ function parseWords(match) {
         .split(/[,\s;]+/g)
         .slice(1)
         .filter((a) => !!a);
-    return { id: 'in-doc-words', words };
+    return { words };
 }
 function parseLocale(match) {
     const parts = match.trim().split(/[\s,]+/);
     const language = parts.slice(1).join(',');
-    return language ? { id: 'in-doc-local', language } : {};
+    return language ? { language } : emptySettings;
 }
 function parseIgnoreWords(match) {
     const wordsSetting = parseWords(match);
-    return (0, util_1.clean)({ id: 'in-doc-ignore', ignoreWords: wordsSetting.words });
+    const ignoreWords = wordsSetting.words;
+    return ignoreWords && ignoreWords.length ? { ignoreWords } : emptySettings;
 }
 function parseFlagWords(match) {
     const wordsSetting = parseWords(match);
-    return (0, util_1.clean)({ id: 'in-doc-forbid', flagWords: wordsSetting.words });
+    const flagWords = wordsSetting.words;
+    return flagWords && flagWords.length ? { flagWords } : emptySettings;
 }
 function parseRegEx(match) {
     const patterns = [match.replace(/^[^\s]+\s+/, '')].map((a) => {
@@ -222,22 +248,22 @@ function parseRegEx(match) {
 }
 function parseIgnoreRegExp(match) {
     const ignoreRegExpList = parseRegEx(match);
-    return { id: 'in-doc-ignoreRegExp', ignoreRegExpList };
+    return { ignoreRegExpList };
 }
 function parseIncludeRegExp(match) {
     const includeRegExpList = parseRegEx(match);
-    return { id: 'in-doc-includeRegExp', includeRegExpList };
+    return { includeRegExpList };
 }
 function parseDictionaries(match) {
     const dictionaries = match.split(/[,\s]+/g).slice(1);
-    return { id: 'in-doc-dictionaries', dictionaries };
+    return { dictionaries };
 }
 function getPossibleInDocSettings(text) {
     return (0, gensequence_1.genSequence)(regExInFileSettings).concatMap((regexp) => Text.match(regexp, text));
 }
 function getWordsFromDocument(text) {
-    const { words = EmptyWords } = getInDocumentSettings(text);
-    return words;
+    const dict = extractInDocDictionary(getInDocumentSettings(text));
+    return dict?.words || EmptyWords;
 }
 function parseEnable(_match) {
     // Do nothing. Enable / Disable is handled in a different way.
@@ -247,9 +273,15 @@ function parseDisable(_match) {
     // Do nothing. Enable / Disable is handled in a different way.
     return {};
 }
+function extractInDocDictionary(settings) {
+    const inDocDicts = settings.dictionaryDefinitions?.filter((def) => def.name === staticInDocumentDictionaryName);
+    const dict = inDocDicts?.[0];
+    return dict;
+}
+exports.extractInDocDictionary = extractInDocDictionary;
 function getIgnoreWordsFromDocument(text) {
-    const { ignoreWords = EmptyWords } = getInDocumentSettings(text);
-    return ignoreWords;
+    const dict = extractInDocDictionary(getInDocumentSettings(text));
+    return dict?.ignoreWords || EmptyWords;
 }
 exports.getIgnoreWordsFromDocument = getIgnoreWordsFromDocument;
 function getIgnoreRegExpFromDocument(text) {
@@ -267,5 +299,6 @@ exports.internal = {
     parseCompoundWords,
     parseIgnoreRegExp,
     parseIgnoreWords,
+    staticInDocumentDictionaryName,
 };
 //# sourceMappingURL=InDocSettings.js.map

package/dist/SpellingDictionary/Dictionaries.js

@@ -29,7 +29,7 @@ function getDictionaryInternalSync(settings) {
 }
 exports.getDictionaryInternalSync = getDictionaryInternalSync;
 function _getDictionaryInternal(settings, spellDictionaries) {
-    const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
+    const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords, suggestWords = emptyWords, } = settings;
     const settingsWordsDictionary = (0, cspell_dictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
@@ -42,12 +42,14 @@ function _getDictionaryInternal(settings, spellDictionaries) {
         : undefined;
     const ignoreWordsDictionary = (0, cspell_dictionary_1.createIgnoreWordsDictionary)(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`');
     const flagWordsDictionary = (0, cspell_dictionary_1.createForbiddenWordsDictionary)(flagWords, '[flagWords]', 'From Settings `flagWords`');
+    const suggestWordsDictionary = (0, cspell_dictionary_1.createSuggestDictionary)(suggestWords, '[suggestWords]', 'From Settings `suggestWords`');
     const dictionaries = [
         ...spellDictionaries,
         settingsWordsDictionary,
         settingsUserWordsDictionary,
         ignoreWordsDictionary,
         flagWordsDictionary,
+        suggestWordsDictionary,
     ].filter(util_1.isDefined);
     return (0, cspell_dictionary_1.createCollection)(dictionaries, 'dictionary collection');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.24.0",
+  "version": "6.26.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,19 +48,19 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "6.24.0",
-    "@cspell/cspell-pipe": "6.24.0",
-    "@cspell/cspell-types": "6.24.0",
-    "@cspell/strong-weak-map": "6.24.0",
+    "@cspell/cspell-bundled-dicts": "6.26.0",
+    "@cspell/cspell-pipe": "6.26.0",
+    "@cspell/cspell-types": "6.26.0",
+    "@cspell/strong-weak-map": "6.26.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^8.0.0",
-    "cspell-dictionary": "6.24.0",
-    "cspell-glob": "6.24.0",
-    "cspell-grammar": "6.24.0",
-    "cspell-io": "6.24.0",
-    "cspell-trie-lib": "6.24.0",
+    "cspell-dictionary": "6.26.0",
+    "cspell-glob": "6.26.0",
+    "cspell-grammar": "6.26.0",
+    "cspell-io": "6.26.0",
+    "cspell-trie-lib": "6.26.0",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "gensequence": "^4.0.3",
@@ -89,8 +89,8 @@
     "jest": "^29.4.2",
     "lorem-ipsum": "^2.0.8",
     "rollup": "^3.15.0",
-    "rollup-plugin-dts": "^5.1.1",
+    "rollup-plugin-dts": "^5.2.0",
     "ts-jest": "^29.0.5"
   },
-  "gitHead": "0d1e8bf9426cd0bfb814df4f61da12d8aee57ddd"
+  "gitHead": "a72f603f4f1afbe237f938b1a23d7cbe2a07d86f"
 }