cspell-trie-lib 6.14.1 → 6.14.3

package/dist/lib/SimpleDictionaryParser.d.ts

@@ -65,4 +65,9 @@ export declare function createDictionaryLineParserMapper(options?: Partial<Parse
 export declare function parseDictionaryLines(lines: Iterable<string> | string, options?: Partial<ParseDictionaryOptions>): Iterable<string>;
 export declare function parseLinesToDictionary(lines: Iterable<string>, options?: Partial<ParseDictionaryOptions>): Trie;
 export declare function parseDictionary(text: string, options?: Partial<ParseDictionaryOptions>): Trie;
+declare function splitLine(line: string, regExp: RegExp | string): string[];
+export declare const __testing__: {
+    splitLine: typeof splitLine;
+};
+export {};
 //# sourceMappingURL=SimpleDictionaryParser.d.ts.map

package/dist/lib/SimpleDictionaryParser.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDictionary = exports.parseLinesToDictionary = exports.parseDictionaryLines = exports.createDictionaryLineParserMapper = exports.setOfCSpellDirectiveFlags = exports.cSpellToolDirective = exports.defaultParseDictionaryOptions = void 0;
+exports.__testing__ = exports.parseDictionary = exports.parseLinesToDictionary = exports.parseDictionaryLines = exports.createDictionaryLineParserMapper = exports.setOfCSpellDirectiveFlags = exports.cSpellToolDirective = exports.defaultParseDictionaryOptions = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const constants_1 = require("./constants");
 const trie_util_1 = require("./trie-util");
 const TrieBuilder_1 = require("./TrieBuilder");
-const RegExpSplit = /(?<!\\)[\s,;]/g;
+const RegExpSplit = /[\s,;]/g;
 const _defaultOptions = {
     commentCharacter: constants_1.LINE_COMMENT,
     optionalCompoundCharacter: constants_1.OPTIONAL_COMPOUND_FIX,
@@ -126,8 +126,8 @@ function createDictionaryLineParserMapper(options) {
                 const lineEscaped = line.indexOf('"') >= 0
                     ? line.replace(/".*?"/g, (quoted) => ' ' + quoted.replace(/(\s)/g, '\\$1') + ' ')
                     : line;
-                const words = lineEscaped.split(splitSeparator);
-                yield* words.map((escaped) => escaped.replace(/\\(\s)/g, '$1'));
+                const words = splitLine(lineEscaped, splitSeparator);
+                yield* words.map((escaped) => escaped.replace(/\\/g, ''));
                 if (!splitKeepBoth)
                     continue;
             }
@@ -180,4 +180,20 @@ function mergeOptions(base, ...partials) {
     }
     return opt;
 }
+const RegExpToEncode = /\\([\s,;])/g;
+const RegExpDecode = /<<(%[\da-f]{2})>>/gi;
+function encodeLine(line) {
+    return line.replace(RegExpToEncode, (_, v) => '<<' + encodeURIComponent(v) + '>>');
+}
+function decodeLine(line) {
+    return line.replace(RegExpDecode, (_, v) => '\\' + decodeURIComponent(v));
+}
+function splitLine(line, regExp) {
+    return encodeLine(line)
+        .split(regExp)
+        .map((line) => decodeLine(line));
+}
+exports.__testing__ = {
+    splitLine,
+};
 //# sourceMappingURL=SimpleDictionaryParser.js.map

package/dist/lib/TrieNode.d.ts

@@ -11,7 +11,7 @@ export interface TrieOptions {
     stripCaseAndAccentsPrefix: string;
     forbiddenWordPrefix: string;
 }
-export declare type PartialTrieOptions = PartialWithUndefined<TrieOptions> | undefined;
+export type PartialTrieOptions = PartialWithUndefined<TrieOptions> | undefined;
 export interface TrieRoot extends TrieOptions {
     c: ChildMap;
 }

package/dist/lib/compoundWalker.d.ts

@@ -9,7 +9,7 @@ export interface WalkItem {
     /** true iff compound edge */
     c: boolean;
 }
-export declare type WalkNext = boolean;
+export type WalkNext = boolean;
 /**
  *
  * Depth first walk of a compound trie.

package/dist/lib/distance/weightedMaps.d.ts

@@ -1,5 +1,5 @@
 import { SuggestionCostMapDef } from '../models/suggestionCostsDef';
-export declare type WeightedRepMapTrie = Record<string, WeightedRepTrieNode>;
+export type WeightedRepMapTrie = Record<string, WeightedRepTrieNode>;
 interface WeightedRepTrieNode {
     /** The nested Trie nodes */
     r?: WeightedRepMapTrie | undefined;

package/dist/lib/find.d.ts

@@ -1,20 +1,20 @@
 import { TrieNode, TrieRoot } from './TrieNode';
 import type { PartialWithUndefined } from './types';
-declare type Root = PartialWithUndefined<TrieRoot>;
+type Root = PartialWithUndefined<TrieRoot>;
 /**
  * No compounding allowed.
  */
-export declare type CompoundModeNone = 'none';
+export type CompoundModeNone = 'none';
 /**
  * Allow natural compounding in the dictionary
  * using compound prefixes
  */
-export declare type CompoundModesCompound = 'compound';
+export type CompoundModesCompound = 'compound';
 /**
  * Allow all possible compounds -- Very slow.
  */
-export declare type CompoundModesLegacy = 'legacy';
-export declare type CompoundModes = CompoundModeNone | CompoundModesCompound | CompoundModesLegacy;
+export type CompoundModesLegacy = 'legacy';
+export type CompoundModes = CompoundModeNone | CompoundModesCompound | CompoundModesLegacy;
 export interface FindOptions {
     matchCase: boolean;
     compoundMode: CompoundModes;
@@ -23,7 +23,7 @@ export interface FindOptions {
     caseInsensitivePrefix: string;
     legacyMinCompoundLength: number;
 }
-export declare type PartialFindOptions = PartialWithUndefined<FindOptions> | undefined;
+export type PartialFindOptions = PartialWithUndefined<FindOptions> | undefined;
 export interface FindNodeResult {
     node: TrieNode | undefined;
 }

package/dist/lib/io/importExportV3.js

@@ -141,7 +141,7 @@ function* toIterableIterator(iter) {
     yield* iter;
 }
 function importTrie(linesX) {
-    linesX = typeof linesX === 'string' ? linesX.split(/(?<=\n)/) : linesX;
+    linesX = typeof linesX === 'string' ? linesX.split(/^/m) : linesX;
     const root = (0, trie_util_1.trieNodeToRoot)({}, {});
     let radix = 16;
     const comment = /^\s*#/;

package/dist/lib/io/importExportV4.js

@@ -212,10 +212,10 @@ function buildReferenceMap(root, base) {
     return { refCounts: refs };
 }
 function importTrie(linesX) {
-    linesX = typeof linesX === 'string' ? linesX.split(/(?<=\n)/) : linesX;
+    linesX = typeof linesX === 'string' ? linesX.split(/^/m) : linesX;
     let radix = 10;
     const comment = /^\s*#/;
-    const iter = tapIterable((0, sync_1.pipe)(linesX, (0, sync_1.opConcatMap)((a) => a.split(/(?<=\n)(?!$)/))));
+    const iter = tapIterable((0, sync_1.pipe)(linesX, (0, sync_1.opConcatMap)((a) => a.split(/^/m))));
     function parseHeaderRows(headerRows) {
         const header = headerRows.slice(0, 2).join('\n');
         const headerReg = /^TrieXv[34]\nbase=(\d+)$/;
@@ -374,7 +374,10 @@ function parseStream(radix, iter) {
         function parser(acc, s) {
             json = json + s;
             if (s === REF_INDEX_END) {
-                refIndex = JSON.parse(json);
+                refIndex = json
+                    .replace(/[\s[\]]/g, '')
+                    .split(',')
+                    .map((n) => parseInt(n, radix));
                 return { ...acc, parser: undefined };
             }
             return acc;

package/dist/lib/mappers/mapCosts.d.ts

@@ -1,6 +1,6 @@
 import { HunspellCosts, EditCosts } from '../models/DictionaryInformation';
-export declare type EditCostsRequired = Required<EditCosts>;
-export declare type HunspellCostsRequired = Required<HunspellCosts>;
+export type EditCostsRequired = Required<EditCosts>;
+export type HunspellCostsRequired = Required<HunspellCosts>;
 export declare function mapHunspellCosts(costs?: HunspellCosts): HunspellCostsRequired;
 export declare function mapEditCosts(costs?: EditCosts): EditCostsRequired;
 //# sourceMappingURL=mapCosts.d.ts.map

package/dist/lib/models/DictionaryInformation.d.ts

@@ -1,8 +1,8 @@
 import type { DictionaryDefinitionAugmented } from '@cspell/cspell-types';
 export type { CharacterSet, CharacterSetCosts, EditCosts } from '@cspell/cspell-types';
-export declare type DictionaryInformation = Exclude<DictionaryDefinitionAugmented['dictionaryInformation'], undefined>;
-export declare type SuggestionEditCosts = Exclude<DictionaryInformation['suggestionEditCosts'], undefined>;
-export declare type HunspellInformation = Exclude<DictionaryInformation['hunspellInformation'], undefined>;
-export declare type HunspellCosts = Exclude<HunspellInformation['costs'], undefined>;
-export declare type HunspellAff = HunspellInformation['aff'];
+export type DictionaryInformation = Exclude<DictionaryDefinitionAugmented['dictionaryInformation'], undefined>;
+export type SuggestionEditCosts = Exclude<DictionaryInformation['suggestionEditCosts'], undefined>;
+export type HunspellInformation = Exclude<DictionaryInformation['hunspellInformation'], undefined>;
+export type HunspellCosts = Exclude<HunspellInformation['costs'], undefined>;
+export type HunspellAff = HunspellInformation['aff'];
 //# sourceMappingURL=DictionaryInformation.d.ts.map

package/dist/lib/models/locale/knownLocales.d.ts

@@ -1,3 +1,3 @@
-export declare type Entry = [string, string] | [string, string, string];
+export type Entry = [string, string] | [string, string, string];
 export declare const codes: Entry[];
 //# sourceMappingURL=knownLocales.d.ts.map

package/dist/lib/suggestions/genSuggestionsOptions.d.ts

@@ -21,7 +21,7 @@ export interface GenSuggestionOptionsStrict {
      */
     compoundSeparator?: string;
 }
-export declare type GenSuggestionOptions = Partial<GenSuggestionOptionsStrict>;
+export type GenSuggestionOptions = Partial<GenSuggestionOptionsStrict>;
 export interface SuggestionOptionsStrict extends GenSuggestionOptionsStrict {
     /**
      * Maximum number of suggestions to make.
@@ -46,7 +46,7 @@ export interface SuggestionOptionsStrict extends GenSuggestionOptionsStrict {
      */
     weightMap?: WeightMap;
 }
-export declare type SuggestionOptions = Partial<SuggestionOptionsStrict>;
+export type SuggestionOptions = Partial<SuggestionOptionsStrict>;
 export declare const defaultGenSuggestionOptions: GenSuggestionOptionsStrict;
 export declare const defaultSuggestionOptions: SuggestionOptionsStrict;
 /**

package/dist/lib/suggestions/suggestCollector.d.ts

@@ -2,8 +2,8 @@ import { WeightMap } from '..';
 import { RequireOptional } from '../types';
 import { GenSuggestionOptions, GenSuggestionOptionsStrict } from './genSuggestionsOptions';
 export declare const DEFAULT_COMPOUNDED_WORD_SEPARATOR = "\u2219";
-export declare type Cost = number;
-export declare type MaxCost = Cost;
+export type Cost = number;
+export type MaxCost = Cost;
 export interface SuggestionResultBase {
     /** The suggested word */
     word: string;
@@ -29,8 +29,8 @@ export interface Progress {
      */
     remaining: number;
 }
-export declare type GenerateNextParam = MaxCost | symbol | undefined;
-export declare type GenerateSuggestionResult = SuggestionResultBase | Progress | undefined;
+export type GenerateNextParam = MaxCost | symbol | undefined;
+export type GenerateSuggestionResult = SuggestionResultBase | Progress | undefined;
 /**
  * Ask for the next result.
  * maxCost - sets the max cost for following suggestions
@@ -39,9 +39,9 @@ export declare type GenerateSuggestionResult = SuggestionResultBase | Progress |
  *
  * The SuggestionIterator is generally the
  */
-export declare type SuggestionGenerator = Generator<GenerateSuggestionResult, void, GenerateNextParam>;
+export type SuggestionGenerator = Generator<GenerateSuggestionResult, void, GenerateNextParam>;
 export declare function compSuggestionResults(a: SuggestionResultBase, b: SuggestionResultBase): number;
-export declare type FilterWordFn = (word: string, cost: number) => boolean;
+export type FilterWordFn = (word: string, cost: number) => boolean;
 export interface SuggestionCollector {
     /**
      * Collection suggestions from a SuggestionIterator

package/dist/lib/suggestions/walker/hintedWalker.d.ts

@@ -5,7 +5,7 @@ import { CompoundWordsMethod, YieldResult } from './walkerTypes';
  * goDeeper of true tells the walker to go deeper in the Trie if possible. Default is true.
  * This can be used to limit the walker's depth.
  */
-export declare type HintedWalkerIterator = Generator<YieldResult, void, Hinting | undefined>;
+export type HintedWalkerIterator = Generator<YieldResult, void, Hinting | undefined>;
 export declare function hintedWalker(root: TrieRoot, ignoreCase: boolean, hint: string, compoundingMethod: CompoundWordsMethod | undefined, emitWordSeparator?: string): HintedWalkerIterator;
 /**
  * Walks the Trie and yields a value at each node.

package/dist/lib/suggestions/walker/walkerTypes.d.ts

@@ -20,5 +20,5 @@ export declare enum CompoundWordsMethod {
      */
     JOIN_WORDS = 2
 }
-export declare type WalkerIterator = Generator<YieldResult, void, boolean | undefined>;
+export type WalkerIterator = Generator<YieldResult, void, boolean | undefined>;
 //# sourceMappingURL=walkerTypes.d.ts.map

package/dist/lib/trie-util.d.ts

@@ -32,7 +32,7 @@ export declare function isCircular(root: TrieNode): boolean;
  * @param value
  * @param defaultValue
  */
-export declare function mergeDefaults<T>(value: PartialWithUndefined<T> | undefined, defaultValue: T): T;
+export declare function mergeDefaults<T extends object>(value: PartialWithUndefined<T> | undefined, defaultValue: T): T;
 export declare function trieNodeToRoot(node: TrieNode, options: PartialTrieOptions): TrieRoot;
 /**
  * Normalize word unicode.

package/dist/lib/trieRef.d.ts

@@ -1,4 +1,4 @@
-export declare type RefList = [string, number][];
+export type RefList = [string, number][];
 export interface TrieRefNode {
     f?: number | undefined;
     r?: RefList | undefined;

package/dist/lib/types.d.ts

@@ -1,70 +1,70 @@
 /**
  * Make all optional fields required.
  */
-export declare type RequireOptional<T> = {
+export type RequireOptional<T> = {
     [K in keyof Required<T>]: T[K];
 };
 /**
  * Make all properties in T optional and Possibly undefined
  */
-export declare type PartialWithUndefined<T> = {
+export type PartialWithUndefined<T> = {
     [P in keyof T]?: T[P] | undefined;
 };
 /**
  * Make all fields mandatory
  */
-export declare type Mandatory<T> = {
+export type Mandatory<T> = {
     [P in keyof T]-?: Exclude<T[P], undefined>;
 };
 /**
  * Union the fields
  */
-export declare type UnionFields<T, U> = {
+export type UnionFields<T, U> = {
     [K in keyof T | keyof U]: (K extends keyof T ? T[K] : undefined) | (K extends keyof U ? U[K] : undefined);
 };
 /**
  * The keys of an object where the values cannot be undefined.
  */
-export declare type RequiredKeys<T> = Exclude<{
+export type RequiredKeys<T> = Exclude<{
     [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? P : never;
 }[keyof T], undefined>;
 /**
  * The keys of an object where the values cannot be undefined.
  */
-export declare type OptionalOrUndefinedKeys<T> = Exclude<{
+export type OptionalOrUndefinedKeys<T> = Exclude<{
     [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? never : P;
 }[keyof T], undefined>;
 /**
  * Extract the fields that cannot be `undefined`
  */
-export declare type OnlyRequired<T> = {
+export type OnlyRequired<T> = {
     [P in RequiredKeys<T>]: T[P];
 };
 /**
  * The keys of an object where the values cannot be undefined.
  */
-export declare type NoUndefined<T> = {
+export type NoUndefined<T> = {
     [P in keyof T]: Exclude<T[P], undefined>;
 };
 /**
  * Extract the fields that can be `undefined`
  */
-export declare type OnlyOptionalOrUndefined<T> = {
+export type OnlyOptionalOrUndefined<T> = {
     [P in keyof T as P extends OptionalOrUndefinedKeys<T> ? P : never]: T[P];
 };
 /**
  * Make fields that can be `undefined` optional
  */
-export declare type MakeOptional<T> = OnlyRequired<T> & Partial<OnlyOptionalOrUndefined<T>>;
+export type MakeOptional<T> = OnlyRequired<T> & Partial<OnlyOptionalOrUndefined<T>>;
 /**
  * Like Required, but keeps the Optional.
  */
-export declare type RemoveUndefined<T> = {
+export type RemoveUndefined<T> = {
     [P in keyof T]: Exclude<T[P], undefined>;
 };
 /**
  * Make all `undefined` optional and removes the `undefined`
  */
-export declare type UndefinedToOptional<T> = RemoveUndefined<MakeOptional<T>>;
-export declare type ArrayItem<T extends Array<unknown>> = T extends Array<infer R> ? R : never;
+export type UndefinedToOptional<T> = RemoveUndefined<MakeOptional<T>>;
+export type ArrayItem<T extends Array<unknown>> = T extends Array<infer R> ? R : never;
 //# sourceMappingURL=types.d.ts.map

package/dist/lib/utils/PairingHeap.d.ts

@@ -16,7 +16,7 @@ export interface PairHeapNode<T> {
  * @param b - item b
  * @returns a number
  */
-export declare type CompareFn<T> = (a: T, b: T) => number;
+export type CompareFn<T> = (a: T, b: T) => number;
 export declare class PairingHeap<T> implements IterableIterator<T> {
     readonly compare: CompareFn<T>;
     private _heap;

package/dist/lib/utils/timer.d.ts

@@ -8,8 +8,8 @@ export interface Timer {
     elapsed(): number;
 }
 export declare function createTimer(hrTimeFn?: HRTimeFn): Timer;
-export declare type HRTimeFn = (time?: HRTime) => HRTime;
-export declare type HRTime = [number, number];
+export type HRTimeFn = (time?: HRTime) => HRTime;
+export type HRTime = [number, number];
 export declare function toMilliseconds(t: HRTime): number;
 export declare function polyHrTime(time?: HRTime): HRTime;
 //# sourceMappingURL=timer.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-trie-lib",
-  "version": "6.14.1",
+  "version": "6.14.3",
   "description": "Trie Data Structure to support cspell.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,8 +37,8 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "6.14.1",
-    "@cspell/cspell-types": "6.14.1",
+    "@cspell/cspell-pipe": "6.14.3",
+    "@cspell/cspell-types": "6.14.3",
     "fs-extra": "^10.1.0",
     "gensequence": "^4.0.2"
   },
@@ -50,8 +50,8 @@
     "@cspell/dict-es-es": "^2.2.2",
     "@types/fs-extra": "^9.0.13",
     "@types/node": "^18.11.9",
-    "jest": "^29.2.2",
+    "jest": "^29.3.1",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "35db1ed216cd9aaf479429d3268482f30d824e70"
+  "gitHead": "df0efdbb0dc7b084579130ba5fe97441c0ab67ca"
 }