cspell-dictionary 6.27.0 → 6.29.0

package/dist/esm/util/repMap.mjs

@@ -0,0 +1,152 @@
+import { expandCharacterSet } from 'cspell-trie-lib';
+import { escapeRegEx } from './regexHelper.mjs';
+import { isDefined } from './util.mjs';
+export function createMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (a) => a;
+    repMap = repMap || [];
+    const charsetMap = charsetToRepMapRegEx(ignoreCharset);
+    if (charsetMap) {
+        repMap = repMap.concat(charsetMap);
+    }
+    const filteredMap = repMap.filter(([match, _]) => !!match);
+    if (!filteredMap.length) {
+        return (a) => a;
+    }
+    const regEx = createMapperRegExp(repMap);
+    const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
+    function resolve(m, ...matches) {
+        const index = matches.findIndex((a) => !!a);
+        return 0 <= index && index < values.length ? values[index] : m;
+    }
+    return function (s) {
+        return s.replace(regEx, resolve);
+    };
+}
+function charsetToRepMapRegEx(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .map((chars) => `[${chars.replace(/[\][\\]/g, '\\$&')}]`)
+        .map((map) => [map, replaceWith]);
+}
+function charsetToRepMap(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .flatMap((chars) => [...expandCharacterSet(chars)])
+        .map((char) => [char, replaceWith]);
+}
+function expandReplaceMap(repMap) {
+    return repMap.flatMap(([from, replaceWith]) => from.split('|').map((w) => [w, replaceWith]));
+}
+function createMapperRegExp(repMap) {
+    const filteredMap = repMap.filter(([match, _]) => !!match);
+    if (!filteredMap.length) {
+        return /$^/;
+    }
+    const regExStr = filteredMap
+        .map(([from, _]) => from)
+        // make sure it compiles into a regex
+        .map((s) => {
+        try {
+            // fix up any nested ()
+            const r = s.match(/\(/) ? s.replace(/\((?=.*\))/g, '(?:').replace(/\(\?:\?/g, '(?') : s;
+            new RegExp(r);
+            s = r;
+        }
+        catch (err) {
+            return escapeRegEx(s);
+        }
+        return s;
+    })
+        .map((s) => `(${s})`)
+        .join('|');
+    const regEx = new RegExp(regExStr, 'g');
+    return regEx;
+}
+export function createRepMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (word) => [word];
+    const trie = createTrie(repMap, ignoreCharset);
+    // const root = createTrie(repMap, ignoreCharset);
+    return (word) => {
+        const edits = calcAllEdits(trie, word);
+        return applyEdits(word, edits);
+    };
+}
+function applyEdits(word, edits) {
+    if (!edits.length)
+        return [word];
+    // Prepare
+    const letterEdits = [];
+    for (let i = 0; i < word.length; ++i) {
+        letterEdits[i] = { edits: [{ b: i, e: i + 1, r: word[i] }], suffixes: [] };
+    }
+    letterEdits[word.length] = { edits: [], suffixes: [''] };
+    // Add edits
+    for (const edit of edits) {
+        const le = letterEdits[edit.b];
+        le.edits.push(edit);
+    }
+    // Apply edits in reverse
+    for (let i = word.length - 1; i >= 0; --i) {
+        const le = letterEdits[i];
+        const sfx = le.suffixes;
+        for (const edit of le.edits) {
+            const pfx = edit.r;
+            const nSfx = letterEdits[edit.e].suffixes;
+            for (const s of nSfx) {
+                sfx.push(pfx + s);
+            }
+        }
+    }
+    const results = new Set(letterEdits[0].suffixes);
+    return [...results];
+}
+function calcAllEdits(root, word) {
+    const edits = [];
+    function walk(node, b, e) {
+        if (node.rep) {
+            node.rep.forEach((r) => edits.push({ b, e, r }));
+        }
+        if (e === word.length || !node.children)
+            return;
+        const n = node.children[word[e]];
+        if (!n)
+            return;
+        walk(n, b, e + 1);
+    }
+    for (let i = 0; i < word.length; ++i) {
+        walk(root, i, i);
+    }
+    return edits;
+}
+function createTrie(repMap, ignoreCharset) {
+    const combined = [repMap, charsetToRepMap(ignoreCharset)].filter(isDefined).flatMap((a) => a);
+    const expanded = expandReplaceMap(combined);
+    const trieRoot = Object.create(null);
+    expanded.forEach(([match, replaceWith]) => addToTrie(trieRoot, match, replaceWith));
+    return trieRoot;
+}
+function addToTrie(node, match, replaceWith) {
+    while (match) {
+        const children = node.children || (node.children = Object.create(null));
+        const k = match[0];
+        const childNode = children[k] || (children[k] = Object.create(null));
+        node = childNode;
+        match = match.slice(1);
+    }
+    const s = new Set(node.rep || []);
+    s.add(replaceWith);
+    node.rep = [...s];
+}
+export const __testing__ = {
+    charsetToRepMap: charsetToRepMapRegEx,
+    createMapperRegExp,
+    createTrie,
+    calcAllEdits,
+    applyEdits,
+};

package/dist/esm/util/simpleCache.d.mts

@@ -0,0 +1,46 @@
+export declare class SimpleWeakCache<K extends object, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    private sizeL0;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    private _set;
+    private caches;
+    private rotate;
+}
+export declare class AutoWeakCache<K extends object, T> extends SimpleWeakCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+/**
+ * This will cache between `size` and 3 x `size` items.
+ * It has three stashes, L0, L1, and L2. Each can contain `size` items.
+ * When L0 is full, its items are given to L1 and L1's are given to L2, and L2 is empties.
+ *
+ * The stashes are searched in order, L0...L2. If an item is found in L1, or L2, it is
+ * promoted to L0.
+ */
+export declare class SimpleCache<K, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    private _set;
+    private caches;
+    private rotate;
+}
+export declare class AutoCache<K, T> extends SimpleCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+//# sourceMappingURL=simpleCache.d.mts.map

package/dist/esm/util/simpleCache.mjs

@@ -0,0 +1,135 @@
+export class SimpleWeakCache {
+    constructor(size) {
+        this.size = size;
+        this.L0 = new WeakMap();
+        this.L1 = new WeakMap();
+        this.L2 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+    has(key) {
+        for (const c of this.caches()) {
+            if (c.has(key))
+                return true;
+        }
+        return false;
+    }
+    get(key) {
+        for (const c of this.caches()) {
+            const entry = c.get(key);
+            if (entry) {
+                if (c !== this.L0) {
+                    this._set(key, entry);
+                }
+                return entry.v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, entry);
+            return this;
+        }
+        if (this.sizeL0 >= this.size) {
+            this.rotate();
+        }
+        this.sizeL0 += 1;
+        this.L0.set(key, entry);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+}
+export class AutoWeakCache extends SimpleWeakCache {
+    constructor(factory, size) {
+        super(size);
+        this.factory = factory;
+    }
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        const val = this.factory(key);
+        this.set(key, val);
+        return val;
+    }
+}
+/**
+ * This will cache between `size` and 3 x `size` items.
+ * It has three stashes, L0, L1, and L2. Each can contain `size` items.
+ * When L0 is full, its items are given to L1 and L1's are given to L2, and L2 is empties.
+ *
+ * The stashes are searched in order, L0...L2. If an item is found in L1, or L2, it is
+ * promoted to L0.
+ */
+export class SimpleCache {
+    constructor(size) {
+        this.size = size;
+        this.L0 = new Map();
+        this.L1 = new Map();
+        this.L2 = new Map();
+    }
+    has(key) {
+        for (const c of this.caches()) {
+            if (c.has(key))
+                return true;
+        }
+        return false;
+    }
+    get(key) {
+        for (const c of this.caches()) {
+            const entry = c.get(key);
+            if (entry) {
+                if (c !== this.L0) {
+                    this._set(key, entry);
+                }
+                return entry.v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, entry);
+            return this;
+        }
+        if (this.L0.size >= this.size) {
+            this.rotate();
+        }
+        this.L0.set(key, entry);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new Map();
+    }
+}
+export class AutoCache extends SimpleCache {
+    constructor(factory, size) {
+        super(size);
+        this.factory = factory;
+    }
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        const val = this.factory(key);
+        this.set(key, val);
+        return val;
+    }
+}

package/dist/esm/util/text.d.mts

@@ -0,0 +1,10 @@
+export declare function isUpperCase(word: string): boolean;
+export declare function isLowerCase(word: string): boolean;
+export declare function isFirstCharacterUpper(word: string): boolean;
+export declare function isFirstCharacterLower(word: string): boolean;
+export declare function ucFirst(word: string): string;
+export declare function lcFirst(word: string): string;
+export declare function matchCase(example: string, word: string): string;
+export declare function removeAccents(text: string): string;
+export declare function removeUnboundAccents(text: string): string;
+//# sourceMappingURL=text.d.mts.map

package/dist/esm/util/text.mjs

@@ -0,0 +1,46 @@
+const regExFirstUpper = /^\p{Lu}\p{M}?\p{Ll}+$/u;
+const regExAllUpper = /^(?:\p{Lu}\p{M}?)+$/u;
+const regExAllLower = /^(?:\p{Ll}\p{M}?)+$/u;
+const regExAccents = /\p{M}/gu;
+export function isUpperCase(word) {
+    return !!word.match(regExAllUpper);
+}
+export function isLowerCase(word) {
+    return !!word.match(regExAllLower);
+}
+export function isFirstCharacterUpper(word) {
+    return isUpperCase(word.slice(0, 1));
+}
+export function isFirstCharacterLower(word) {
+    return isLowerCase(word.slice(0, 1));
+}
+export function ucFirst(word) {
+    return word.slice(0, 1).toUpperCase() + word.slice(1);
+}
+export function lcFirst(word) {
+    return word.slice(0, 1).toLowerCase() + word.slice(1);
+}
+export function matchCase(example, word) {
+    if (example.match(regExFirstUpper)) {
+        return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
+    }
+    if (example.match(regExAllLower)) {
+        return word.toLowerCase();
+    }
+    if (example.match(regExAllUpper)) {
+        return word.toUpperCase();
+    }
+    if (isFirstCharacterUpper(example)) {
+        return ucFirst(word);
+    }
+    if (isFirstCharacterLower(example)) {
+        return lcFirst(word);
+    }
+    return word;
+}
+export function removeAccents(text) {
+    return text.normalize('NFD').replace(regExAccents, '');
+}
+export function removeUnboundAccents(text) {
+    return text.replace(regExAccents, '');
+}

package/dist/esm/util/textMappers.d.mts

@@ -0,0 +1,3 @@
+export declare function mapperNormalizeNFC(words: Iterable<string>): Iterable<string>;
+export declare function mapperRemoveCaseAndAccents(words: Iterable<string>): Iterable<string>;
+//# sourceMappingURL=textMappers.d.mts.map

package/dist/esm/util/textMappers.mjs

@@ -0,0 +1,15 @@
+import { removeAccents } from './text.mjs';
+export function* mapperNormalizeNFC(words) {
+    for (const word of words) {
+        yield word.normalize('NFC');
+    }
+}
+export function* mapperRemoveCaseAndAccents(words) {
+    for (const word of words) {
+        const lc = word.toLowerCase();
+        yield lc;
+        const woAccents = removeAccents(lc);
+        if (lc !== woAccents)
+            yield woAccents;
+    }
+}

package/dist/esm/util/types.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Like Required, but keeps the Optional.
+ */
+export type RemoveUndefined<T> = {
+    [P in keyof T]: Exclude<T[P], undefined>;
+};
+//# sourceMappingURL=types.d.mts.map

package/dist/esm/util/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/util/util.d.mts

@@ -0,0 +1,2 @@
+export declare function isDefined<T>(v: T | undefined): v is T;
+//# sourceMappingURL=util.d.mts.map

package/dist/esm/util/util.mjs

@@ -0,0 +1,3 @@
+export function isDefined(v) {
+    return v !== undefined;
+}

package/package.json

@@ -1,25 +1,39 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.27.0",
+  "version": "6.29.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "type": "commonjs",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "module": "dist/esm/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js"
+    }
+  },
   "files": [
     "dist",
+    "!dist/esm/**/*.js",
+    "!dist/esm/**/*.ts",
+    "!**/*.tsbuildInfo",
     "!**/__mocks__",
+    "!**/test/**",
     "!**/*.test.*",
     "!**/*.spec.*",
     "!**/*.map"
   ],
   "scripts": {
-    "build": "tsc -p .",
-    "build-dev": "tsc -p tsconfig.dev.json",
-    "watch": "tsc -p . -w",
-    "clean": "shx rm -rf dist temp coverage .tsbuildinfo",
+    "clean": "shx rm -rf dist coverage .tsbuildinfo",
+    "build": "tsc -b . && ts2mjs dist/esm",
+    "build:esm": "tsc -p tsconfig.esm.json",
     "clean-build": "pnpm run clean && pnpm run build",
-    "coverage": "jest --coverage",
-    "test-watch": "jest --watch",
-    "test": "jest"
+    "coverage": "pnpm coverage:vitest && pnpm coverage:fix",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:fix": "nyc report --temp-dir \"$(pwd)/coverage\" --reporter lcov --report-dir \"$(pwd)/coverage\" --cwd ../..",
+    "test:watch": "vitest",
+    "test": "vitest run",
+    "watch": "tsc -b . -w"
   },
   "repository": {
     "type": "git",
@@ -37,17 +51,12 @@
   "engines": {
     "node": ">=14"
   },
-  "devDependencies": {
-    "@types/jest": "^29.4.0",
-    "jest": "^29.4.3",
-    "ts-jest": "^29.0.5"
-  },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.27.0",
-    "@cspell/cspell-types": "6.27.0",
-    "cspell-trie-lib": "6.27.0",
+    "@cspell/cspell-pipe": "6.29.0",
+    "@cspell/cspell-types": "6.29.0",
+    "cspell-trie-lib": "6.29.0",
     "fast-equals": "^4.0.3",
-    "gensequence": "^4.0.3"
+    "gensequence": "^5.0.2"
   },
-  "gitHead": "b0e31c7ba91ba467d5fd9c66f238bb5d899f4833"
+  "gitHead": "2eabb1c47c12c2a42eb95d30329be6f544ee2ffc"
 }

package/dist/SpellingDictionary/Typos/index.d.ts

@@ -1,4 +0,0 @@
-export type { TypoEntry, TyposDef } from './typos';
-export { parseTyposFile, parseTyposLine, processEntriesToTyposDef } from './typosParser';
-export { createTyposDef, extractAllSuggestions } from './util';
-//# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/createInlineSpellingDictionary.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInlineSpellingDictionary = void 0;
-const AutoResolve_1 = require("../util/AutoResolve");
-const util_1 = require("../util/util");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const FlagWordsDictionary_1 = require("./FlagWordsDictionary");
-const IgnoreWordsDictionary_1 = require("./IgnoreWordsDictionary");
-const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
-const SuggestDictionary_1 = require("./SuggestDictionary");
-const cache = (0, AutoResolve_1.createAutoResolveWeakCache)();
-function createInlineSpellingDictionary(inlineDict, source) {
-    return cache.get(inlineDict, () => {
-        const { words, flagWords, ignoreWords, suggestWords, name } = inlineDict;
-        const dictSources = [
-            words && (0, createSpellingDictionary_1.createSpellingDictionary)(words, name + '-words', source, inlineDict),
-            flagWords && (0, FlagWordsDictionary_1.createFlagWordsDictionary)(flagWords, name + '-flag-words', source),
-            ignoreWords && (0, IgnoreWordsDictionary_1.createIgnoreWordsDictionary)(ignoreWords, name + '-ignore-words', source),
-            suggestWords && (0, SuggestDictionary_1.createSuggestDictionary)(suggestWords, name + '-suggest', source),
-        ].filter(util_1.isDefined);
-        return (0, SpellingDictionaryCollection_1.createCollection)(dictSources, name, source);
-    });
-}
-exports.createInlineSpellingDictionary = createInlineSpellingDictionary;
-//# sourceMappingURL=createInlineSpellingDictionary.js.map

package/dist/util/repMap.d.ts

@@ -1,11 +0,0 @@
-import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
-export type ReplaceMapper = (src: string) => string;
-export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper;
-declare function charsetToRepMap(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
-declare function createMapperRegExp(repMap: ReplaceMap): RegExp;
-export declare const __testing__: {
-    charsetToRepMap: typeof charsetToRepMap;
-    createMapperRegExp: typeof createMapperRegExp;
-};
-export {};
-//# sourceMappingURL=repMap.d.ts.map

package/dist/util/repMap.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createMapper = void 0;
-const regexHelper_1 = require("./regexHelper");
-function createMapper(repMap, ignoreCharset) {
-    if (!repMap && !ignoreCharset)
-        return (a) => a;
-    repMap = repMap || [];
-    const charsetMap = charsetToRepMap(ignoreCharset);
-    if (charsetMap) {
-        repMap = repMap.concat(charsetMap);
-    }
-    const filteredMap = repMap.filter(([match, _]) => !!match);
-    if (!filteredMap.length) {
-        return (a) => a;
-    }
-    const regEx = createMapperRegExp(repMap);
-    const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
-    function resolve(m, ...matches) {
-        const index = matches.findIndex((a) => !!a);
-        return 0 <= index && index < values.length ? values[index] : m;
-    }
-    return function (s) {
-        return s.replace(regEx, resolve);
-    };
-}
-exports.createMapper = createMapper;
-function charsetToRepMap(charset, replaceWith = '') {
-    if (!charset)
-        return undefined;
-    return charset
-        .split('|')
-        .map((chars) => `[${chars.replace(/[\][\\]/g, '\\$&')}]`)
-        .map((map) => [map, replaceWith]);
-}
-function createMapperRegExp(repMap) {
-    const filteredMap = repMap.filter(([match, _]) => !!match);
-    if (!filteredMap.length) {
-        return /$^/;
-    }
-    const regExStr = filteredMap
-        .map(([from, _]) => from)
-        // make sure it compiles into a regex
-        .map((s) => {
-        try {
-            // fix up any nested ()
-            const r = s.match(/\(/) ? s.replace(/\((?=.*\))/g, '(?:').replace(/\(\?:\?/g, '(?') : s;
-            new RegExp(r);
-            s = r;
-        }
-        catch (err) {
-            return (0, regexHelper_1.escapeRegEx)(s);
-        }
-        return s;
-    })
-        .map((s) => `(${s})`)
-        .join('|');
-    const regEx = new RegExp(regExStr, 'g');
-    return regEx;
-}
-exports.__testing__ = {
-    charsetToRepMap,
-    createMapperRegExp,
-};
-//# sourceMappingURL=repMap.js.map