cspell-dictionary 6.9.0 → 6.10.1

package/dist/SpellingDictionary/ForbiddenWordsDictionary.d.ts

@@ -0,0 +1,11 @@
+import { SpellingDictionary } from './SpellingDictionary';
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param wordList - list of words
+ * @param name
+ * @param source
+ * @param options
+ * @returns
+ */
+export declare function createForbiddenWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
+//# sourceMappingURL=ForbiddenWordsDictionary.d.ts.map

package/dist/SpellingDictionary/ForbiddenWordsDictionary.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForbiddenWordsDictionary = void 0;
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
+const createSpellingDictionary_1 = require("./createSpellingDictionary");
+class ForbiddenWordsDictionary {
+    constructor(name, source, wordList) {
+        this.name = name;
+        this.source = source;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.type = 'forbidden';
+        this.isDictionaryCaseSensitive = true;
+        const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList, { stripCaseAndAccents: false });
+        const trie = (0, cspell_trie_lib_1.buildTrieFast)(words);
+        this.dict = new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, createSpellingDictionary_1.defaultOptions, source);
+    }
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param _word - the word
+     * @param _options - options
+     * @returns always false
+     */
+    has(_word, _options) {
+        return false;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, options) {
+        const r = this.dict.find(word, options);
+        if (!r || r.found === false || r.forbidden)
+            return undefined;
+        return { ...r, forbidden: true };
+    }
+    isForbidden(word) {
+        const r = this.find(word);
+        if (!r)
+            return false;
+        return r.forbidden && r.found !== false;
+    }
+    isNoSuggestWord(_word, _options) {
+        return false;
+    }
+    suggest() {
+        return [];
+    }
+    genSuggestions() {
+        return;
+    }
+    mapWord(word) {
+        return word;
+    }
+    get size() {
+        return this.dict.size;
+    }
+    getErrors() {
+        return [];
+    }
+}
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param wordList - list of words
+ * @param name
+ * @param source
+ * @param options
+ * @returns
+ */
+function createForbiddenWordsDictionary(wordList, name, source) {
+    return new ForbiddenWordsDictionary(name, source, wordList);
+}
+exports.createForbiddenWordsDictionary = createForbiddenWordsDictionary;
+//# sourceMappingURL=ForbiddenWordsDictionary.js.map

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -47,13 +47,18 @@ export interface FindResult {
 export declare type HasOptions = SearchOptions;
 export interface SpellingDictionaryOptions {
     repMap?: ReplaceMap;
-    useCompounds?: boolean;
     /**
      * The dictionary is case aware.
      */
     caseSensitive?: boolean;
+    /**
+     * This is a NO Suggest dictionary used for words to be ignored.
+     */
     noSuggest?: boolean;
-    weightMap?: WeightMap | undefined;
+    /**
+     * Extra dictionary information used in improving suggestions
+     * based upon locale.
+     */
     dictionaryInformation?: DictionaryInformation;
     /**
      * Strip Case and Accents to allow for case insensitive searches and
@@ -65,6 +70,15 @@ export interface SpellingDictionaryOptions {
      * @default true
      */
     supportNonStrictSearches?: boolean;
+    /**
+     * Turns on legacy word compounds.
+     * @deprecated
+     */
+    useCompounds?: boolean;
+    /**
+     * Optional WeightMap used to improve suggestions.
+     */
+    weightMap?: WeightMap | undefined;
 }
 export interface DictionaryInfo {
     /** The name of the dictionary */

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -32,5 +32,13 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     getErrors(): Error[];
 }
-export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+export declare function createSpellingDictionaryFromTrieFile(data: Iterable<string> | string, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
 //# sourceMappingURL=SpellingDictionaryFromTrie.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionaryTrie = exports.SpellingDictionaryFromTrie = void 0;
+exports.createSpellingDictionaryFromTrieFile = exports.SpellingDictionaryFromTrie = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const repMap_1 = require("../util/repMap");
 const clean_1 = require("../util/clean");
@@ -139,10 +139,19 @@ class SpellingDictionaryFromTrie {
 }
 exports.SpellingDictionaryFromTrie = SpellingDictionaryFromTrie;
 SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
-function createSpellingDictionaryTrie(data, name, source, options) {
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+function createSpellingDictionaryFromTrieFile(data, name, source, options) {
+    data = typeof data === 'string' ? data.split('\n') : data;
     const trieNode = (0, cspell_trie_lib_1.importTrie)(data);
     const trie = new cspell_trie_lib_1.Trie(trieNode);
     return new SpellingDictionaryFromTrie(trie, name, options, source);
 }
-exports.createSpellingDictionaryTrie = createSpellingDictionaryTrie;
+exports.createSpellingDictionaryFromTrieFile = createSpellingDictionaryFromTrieFile;
 //# sourceMappingURL=SpellingDictionaryFromTrie.js.map

package/dist/SpellingDictionary/createSpellingDictionary.d.ts

@@ -1,7 +1,15 @@
 import { IterableLike } from '../util/IterableLike';
-import { SpellingDictionary, SpellingDictionaryOptions, DictionaryInfo } from './SpellingDictionary';
-export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
-export declare function createForbiddenWordsDictionary(wordList: readonly string[], name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
+import type { DictionaryInfo, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary';
+export declare const defaultOptions: SpellingDictionaryOptions;
+/**
+ * Create a SpellingDictionary
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - dictionary options
+ * @returns a Spelling Dictionary
+ */
+export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
 export interface SpellingDictionaryLoadError extends Error {
     /** The Error Name */
     readonly name: string;
@@ -12,6 +20,5 @@ export interface SpellingDictionaryLoadError extends Error {
     /** Dictionary Information */
     readonly info: DictionaryInfo;
 }
-export declare function createFailedToLoadDictionary(error: SpellingDictionaryLoadError): SpellingDictionary;
-export declare function createSpellingDictionaryLoadError(errorName: string, message: string, info: DictionaryInfo, cause?: Error): SpellingDictionaryLoadError;
+export declare function createFailedToLoadDictionary(name: string, source: string, error: Error, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
 //# sourceMappingURL=createSpellingDictionary.d.ts.map

package/dist/SpellingDictionary/createSpellingDictionary.js

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionaryLoadError = exports.createFailedToLoadDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = void 0;
+exports.createFailedToLoadDictionary = exports.createSpellingDictionary = exports.defaultOptions = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const fast_equals_1 = require("fast-equals");
-const gensequence_1 = require("gensequence");
 const simpleCache_1 = require("../util/simpleCache");
 const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
-const defaultOptions = Object.freeze({
+exports.defaultOptions = Object.freeze({
     weightMap: undefined,
 });
 const cachedDictionaries = new simpleCache_1.AutoWeakCache(_createSpellingDictionary, 64);
 const maxSetSize = 3;
 const cachedParamsByWordList = new simpleCache_1.SimpleCache(64);
+/**
+ * Create a SpellingDictionary
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - dictionary options
+ * @returns a Spelling Dictionary
+ */
 function createSpellingDictionary(wordList, name, source, options) {
     const params = [wordList, name, source, options];
     if (!Array.isArray(wordList)) {
@@ -37,24 +44,14 @@ function _createSpellingDictionary(params) {
     const parseOptions = { stripCaseAndAccents: options?.supportNonStrictSearches ?? true };
     const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList, parseOptions);
     const trie = (0, cspell_trie_lib_1.buildTrieFast)(words);
-    const opts = { ...(options || defaultOptions) };
+    const opts = { ...(options || exports.defaultOptions) };
     if (opts.weightMap === undefined && opts.dictionaryInformation) {
         opts.weightMap = (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(opts.dictionaryInformation);
     }
     return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, opts, source);
 }
-function createForbiddenWordsDictionary(wordList, name, source, options) {
-    // console.log(`createSpellingDictionary ${name} ${source}`);
-    const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList.concat(wordList.map((a) => a.toLowerCase())), {
-        stripCaseAndAccents: !options?.noSuggest,
-    });
-    const forbidWords = gensequence_1.operators.map((w) => '!' + w)(words);
-    const trie = (0, cspell_trie_lib_1.buildTrieFast)(forbidWords);
-    return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, options || defaultOptions, source);
-}
-exports.createForbiddenWordsDictionary = createForbiddenWordsDictionary;
-function createFailedToLoadDictionary(error) {
-    const { name, source, options } = error.info;
+function createFailedToLoadDictionary(name, source, error, options) {
+    options = options || {};
     return {
         name,
         source,
@@ -76,16 +73,4 @@ function createFailedToLoadDictionary(error) {
     };
 }
 exports.createFailedToLoadDictionary = createFailedToLoadDictionary;
-function createSpellingDictionaryLoadError(errorName, message, info, cause) {
-    const err = {
-        name: errorName,
-        message,
-        info,
-        cause,
-    };
-    const stack = cause?.stack;
-    stack && (err.stack = stack);
-    return err;
-}
-exports.createSpellingDictionaryLoadError = createSpellingDictionaryLoadError;
 //# sourceMappingURL=createSpellingDictionary.js.map

package/dist/SpellingDictionary/index.d.ts

@@ -1,4 +1,6 @@
-export { createForbiddenWordsDictionary, createSpellingDictionary } from './createSpellingDictionary';
+export { createSpellingDictionary } from './createSpellingDictionary';
+export { createForbiddenWordsDictionary } from './ForbiddenWordsDictionary';
 export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
 export { createCollection } from './SpellingDictionaryCollection';
+export { createSpellingDictionaryFromTrieFile } from './SpellingDictionaryFromTrie';
 //# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/index.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCollection = exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = void 0;
+exports.createSpellingDictionaryFromTrieFile = exports.createCollection = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = void 0;
 var createSpellingDictionary_1 = require("./createSpellingDictionary");
-Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createForbiddenWordsDictionary; } });
 Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createSpellingDictionary; } });
+var ForbiddenWordsDictionary_1 = require("./ForbiddenWordsDictionary");
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return ForbiddenWordsDictionary_1.createForbiddenWordsDictionary; } });
 var SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
 Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionaryCollection_1.createCollection; } });
+var SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
+Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return SpellingDictionaryFromTrie_1.createSpellingDictionaryFromTrieFile; } });
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { createCollection, createForbiddenWordsDictionary, createSpellingDictionary } from './SpellingDictionary';
+export { createCollection, createForbiddenWordsDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from './SpellingDictionary';
 export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = exports.createCollection = void 0;
+exports.createSpellingDictionaryFromTrieFile = exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = exports.createCollection = void 0;
 var SpellingDictionary_1 = require("./SpellingDictionary");
 Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionary_1.createCollection; } });
 Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createForbiddenWordsDictionary; } });
 Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionaryFromTrieFile; } });
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.9.0",
+  "version": "6.10.1",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -37,11 +37,17 @@
   "engines": {
     "node": ">=14"
   },
+  "devDependencies": {
+    "@types/jest": "^29.0.3",
+    "jest": "^29.0.3",
+    "ts-jest": "^29.0.1"
+  },
   "dependencies": {
-    "@cspell/cspell-pipe": "workspace:^",
-    "@cspell/cspell-types": "workspace:^",
-    "cspell-trie-lib": "workspace:^",
+    "@cspell/cspell-pipe": "^6.10.1",
+    "@cspell/cspell-types": "^6.10.1",
+    "cspell-trie-lib": "^6.10.1",
     "fast-equals": "^4.0.3",
     "gensequence": "^4.0.2"
-  }
+  },
+  "gitHead": "03625a3f7ca4ef85f3549ccae73d90d2cd3ac0f0"
 }

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -1,9 +0,0 @@
-import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
-import { SpellingDictionary } from './SpellingDictionary';
-import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
-export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
-export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
-export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
-export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
-export declare function getDictionaryInternalSync(settings: CSpellSettingsInternal): SpellingDictionaryCollection;
-//# sourceMappingURL=Dictionaries.d.ts.map

package/dist/SpellingDictionary/Dictionaries.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
-const DictionarySettings_1 = require("../Settings/DictionarySettings");
-const util_1 = require("../util/util");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const DictionaryLoader_1 = require("./DictionaryLoader");
-const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
-function loadDictionaryDefs(defsToLoad) {
-    return defsToLoad.map(DictionaryLoader_1.loadDictionary);
-}
-exports.loadDictionaryDefs = loadDictionaryDefs;
-function loadDictionaryDefsSync(defsToLoad) {
-    return defsToLoad.map(DictionaryLoader_1.loadDictionarySync);
-}
-exports.loadDictionaryDefsSync = loadDictionaryDefsSync;
-function refreshDictionaryCache(maxAge) {
-    return (0, DictionaryLoader_1.refreshCacheEntries)(maxAge);
-}
-exports.refreshDictionaryCache = refreshDictionaryCache;
-const emptyWords = Object.freeze([]);
-async function getDictionaryInternal(settings) {
-    const spellDictionaries = await Promise.all(loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings)));
-    return _getDictionaryInternal(settings, spellDictionaries);
-}
-exports.getDictionaryInternal = getDictionaryInternal;
-function getDictionaryInternalSync(settings) {
-    const spellDictionaries = loadDictionaryDefsSync((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
-    return _getDictionaryInternal(settings, spellDictionaries);
-}
-exports.getDictionaryInternalSync = getDictionaryInternalSync;
-function _getDictionaryInternal(settings, spellDictionaries) {
-    const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
-    const settingsWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
-        caseSensitive: true,
-        weightMap: undefined,
-    });
-    const settingsUserWordsDictionary = userWords.length
-        ? (0, createSpellingDictionary_1.createSpellingDictionary)(userWords, '[userWords]', 'From Settings `userWords`', {
-            caseSensitive: true,
-            weightMap: undefined,
-        })
-        : undefined;
-    const ignoreWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`', {
-        caseSensitive: true,
-        noSuggest: true,
-        weightMap: undefined,
-    });
-    const flagWordsDictionary = (0, createSpellingDictionary_1.createForbiddenWordsDictionary)(flagWords, '[flagWords]', 'From Settings `flagWords`', {
-        weightMap: undefined,
-    });
-    const dictionaries = [
-        ...spellDictionaries,
-        settingsWordsDictionary,
-        settingsUserWordsDictionary,
-        ignoreWordsDictionary,
-        flagWordsDictionary,
-    ].filter(util_1.isDefined);
-    return (0, SpellingDictionaryCollection_1.createCollection)(dictionaries, 'dictionary collection');
-}
-//# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/SpellingDictionaryError.d.ts

@@ -1,10 +0,0 @@
-import { LoadOptions } from './DictionaryLoader';
-export declare class SpellingDictionaryLoadError extends Error {
-    readonly uri: string;
-    readonly options: LoadOptions;
-    readonly cause: Error;
-    readonly name: string;
-    constructor(uri: string, options: LoadOptions, cause: Error, message: string);
-}
-export declare function isSpellingDictionaryLoadError(e: Error): e is SpellingDictionaryLoadError;
-//# sourceMappingURL=SpellingDictionaryError.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryError.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSpellingDictionaryLoadError = exports.SpellingDictionaryLoadError = void 0;
-class SpellingDictionaryLoadError extends Error {
-    constructor(uri, options, cause, message) {
-        super(message);
-        this.uri = uri;
-        this.options = options;
-        this.cause = cause;
-        this.name = options.name;
-    }
-}
-exports.SpellingDictionaryLoadError = SpellingDictionaryLoadError;
-function isSpellingDictionaryLoadError(e) {
-    return e instanceof SpellingDictionaryLoadError;
-}
-exports.isSpellingDictionaryLoadError = isSpellingDictionaryLoadError;
-//# sourceMappingURL=SpellingDictionaryError.js.map

package/dist/util/Comparable.d.ts

@@ -1,20 +0,0 @@
-export declare type Comparable = number | string | boolean | undefined | null | Date;
-export declare type ComparableFilter<T> = T extends Comparable ? T : never;
-export declare type ComparablePropertyNames<T> = {
-    [K in keyof T]: T[K] extends Comparable ? K : never;
-}[keyof T];
-export declare type ComparableProperties<T> = Pick<T, ComparablePropertyNames<T>>;
-export declare type CompareArg<T> = ComparablePropertyNames<T> | ((t: T) => Comparable);
-export declare type CompareFn<T> = (a: T, b: T) => number;
-export declare function compareBy<T>(extract: CompareArg<T>, ...extractors: CompareArg<T>[]): CompareFn<T>;
-export declare function compareBy<T>(extract: CompareArg<T>): CompareFn<T>;
-export declare function compareBy<T>(extract1: CompareArg<T>, extract2: CompareArg<T>): CompareFn<T>;
-export declare function compareBy<T>(extract1: CompareArg<T>, extract2: CompareArg<T>, extract3: CompareArg<T>): CompareFn<T>;
-export declare function compareByRev<T>(extract: CompareArg<T>, ...extractors: CompareArg<T>[]): CompareFn<T>;
-export declare function compareByRev<T>(extract: CompareArg<T>): CompareFn<T>;
-export declare function compareByRev<T>(extract1: CompareArg<T>, extract2: CompareArg<T>): CompareFn<T>;
-export declare function compareByRev<T>(extract1: CompareArg<T>, extract2: CompareArg<T>, extract3: CompareArg<T>): CompareFn<T>;
-export declare function compareEach<T>(...compareFn: CompareFn<T>[]): CompareFn<T>;
-export declare function compare<T>(a: ComparableFilter<T>, b: ComparableFilter<T>): number;
-export declare function reverse<T>(fn: CompareFn<T>): CompareFn<T>;
-//# sourceMappingURL=Comparable.d.ts.map

package/dist/util/Comparable.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reverse = exports.compare = exports.compareEach = exports.compareByRev = exports.compareBy = void 0;
-function compareBy(extract, ...extractors) {
-    const compareFns = [extract, ...extractors]
-        .map((ex) => (typeof ex === 'function' ? ex : (t) => t[ex]))
-        .map((ex) => (a, b) => _compare(ex(a), ex(b)));
-    return compareEach(...compareFns);
-}
-exports.compareBy = compareBy;
-function compareByRev(extract, ...extractors) {
-    return reverse(compareBy(extract, ...extractors));
-}
-exports.compareByRev = compareByRev;
-function compareEach(...compareFn) {
-    return (a, b) => {
-        for (const fn of compareFn) {
-            const r = fn(a, b);
-            if (r) {
-                return r;
-            }
-        }
-        return 0;
-    };
-}
-exports.compareEach = compareEach;
-function _compare(a, b) {
-    if (a === b)
-        return 0;
-    if (a === undefined)
-        return 1;
-    if (b === undefined)
-        return -1;
-    if (a === null)
-        return 1;
-    if (b === null)
-        return -1;
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    return 0;
-}
-function compare(a, b) {
-    return _compare(a, b);
-}
-exports.compare = compare;
-function reverse(fn) {
-    return (a, b) => {
-        const r = fn(a, b);
-        return r ? -r : 0;
-    };
-}
-exports.reverse = reverse;
-//# sourceMappingURL=Comparable.js.map

package/dist/util/FreqCounter.d.ts

@@ -1,16 +0,0 @@
-import { IterableLike } from './IterableLike';
-export declare class FreqCounter<T> {
-    private _total;
-    readonly _counters: Map<T, number>;
-    get total(): number;
-    get counters(): Map<T, number>;
-    getCount(key: T): number | undefined;
-    getFreq(key: T): number;
-    addKeyCount(key: T, count: number): this;
-    addKey(key: T): this;
-    addKeys(keys: IterableLike<T>): void;
-    addKeyCounts(values: IterableLike<[T, number]>): void;
-    merge(...freqCounters: FreqCounter<T>[]): FreqCounter<T>;
-    static create<T>(values?: IterableLike<T>): FreqCounter<T>;
-}
-//# sourceMappingURL=FreqCounter.d.ts.map

package/dist/util/FreqCounter.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreqCounter = void 0;
-class FreqCounter {
-    constructor() {
-        this._total = 0;
-        this._counters = new Map();
-    }
-    get total() {
-        return this._total;
-    }
-    get counters() {
-        return this._counters;
-    }
-    getCount(key) {
-        return this._counters.get(key);
-    }
-    getFreq(key) {
-        return (this.getCount(key) || 0) / (this._total || 1);
-    }
-    addKeyCount(key, count) {
-        this._total += count;
-        this._counters.set(key, (this._counters.get(key) || 0) + count);
-        return this;
-    }
-    addKey(key) {
-        return this.addKeyCount(key, 1);
-    }
-    addKeys(keys) {
-        for (const key of keys) {
-            this.addKey(key);
-        }
-    }
-    addKeyCounts(values) {
-        for (const pair of values) {
-            this.addKeyCount(pair[0], pair[1]);
-        }
-    }
-    merge(...freqCounters) {
-        for (const fc of freqCounters) {
-            this.addKeyCounts(fc._counters);
-        }
-        return this;
-    }
-    static create(values) {
-        const fc = new FreqCounter();
-        fc.addKeys(values || []);
-        return fc;
-    }
-}
-exports.FreqCounter = FreqCounter;
-//# sourceMappingURL=FreqCounter.js.map