hunspell-reader 8.3.2 → 8.4.0

package/dist/affConstants.js

@@ -0,0 +1,50 @@
+/*
+ cspell:ignore KEEPCASE FORBIDDENWORD  NEEDAFFIX
+ cspell:ignore COMPOUNDBEGIN COMPOUNDMIDDLE COMPOUNDEND  COMPOUNDFORBIDFLAG
+ */
+export const affFlag = {
+    KEEPCASE: { isKeepCase: true },
+    WARN: { isWarning: true },
+    FORCEUCASE: { isForceUCase: true },
+    FORBIDDENWORD: { isForbiddenWord: true },
+    NOSUGGEST: { isNoSuggest: true },
+    NEEDAFFIX: { isNeedAffix: true },
+    COMPOUNDBEGIN: { canBeCompoundBegin: true },
+    COMPOUNDMIDDLE: { canBeCompoundMiddle: true },
+    COMPOUNDEND: { canBeCompoundEnd: true },
+    COMPOUNDFLAG: { isCompoundPermitted: true },
+    COMPOUNDPERMITFLAG: { isCompoundPermitted: true },
+    COMPOUNDFORBIDFLAG: { isCompoundForbidden: true },
+    ONLYINCOMPOUND: { isOnlyAllowedInCompound: true },
+};
+const _FlagToStringMap = {
+    isCompoundPermitted: 'C',
+    canBeCompoundBegin: 'B',
+    canBeCompoundMiddle: 'M',
+    canBeCompoundEnd: 'E',
+    isOnlyAllowedInCompound: 'O',
+    isWarning: 'W',
+    isKeepCase: 'K',
+    isForceUCase: 'U',
+    isForbiddenWord: 'F',
+    isNoSuggest: 'N',
+    isNeedAffix: 'A',
+    isCompoundForbidden: '-',
+};
+const _FlagToLongStringMap = {
+    isCompoundPermitted: 'CompoundPermitted',
+    canBeCompoundBegin: 'CompoundBegin',
+    canBeCompoundMiddle: 'CompoundMiddle',
+    canBeCompoundEnd: 'CompoundEnd',
+    isOnlyAllowedInCompound: 'OnlyInCompound',
+    isWarning: 'Warning',
+    isKeepCase: 'KeepCase',
+    isForceUCase: 'ForceUpperCase',
+    isForbiddenWord: 'Forbidden',
+    isNoSuggest: 'NoSuggest',
+    isNeedAffix: 'NeedAffix',
+    isCompoundForbidden: 'CompoundForbidden',
+};
+export const flagToStringMap = _FlagToStringMap;
+export const flagToLongStringMap = _FlagToLongStringMap;
+//# sourceMappingURL=affConstants.js.map

package/dist/affDef.d.ts

@@ -1,22 +1,25 @@
 export interface Fx {
-    type: string;
+    type: 'PFX' | 'SFX';
     id: string;
     combinable: boolean;
     substitutionSets: Substitutions;
+    substitutionsForRegExps: SubstitutionsForRegExp[];
     count?: string;
     extra?: string[];
 }
-export type Substitutions = Map<string, SubstitutionSet>;
+export type Substitutions = Map<string, SubstitutionsForRegExp>;
 export interface Substitution {
+    type: 'P' | 'S';
     remove: string;
     attach: string;
     attachRules?: string;
     replace: RegExp;
     extra?: string;
 }
-export interface SubstitutionSet {
+export interface SubstitutionsForRegExp {
     match: RegExp;
     substitutions: Substitution[];
+    substitutionsGroupedByRemove: Map<RegExp, Substitution[]>;
 }
 export interface Rep {
     match: string;
@@ -66,13 +69,23 @@ export interface AffInfo extends AffTransformFlags {
     PFX?: Map<string, Fx>;
     SFX?: Map<string, Fx>;
 }
-export interface Rule {
+export type Rule = FlagRule | PfxRule | SfxRule;
+interface RuleBase {
     id: string;
     type: string;
     flags?: AffWordFlags;
     pfx?: Fx;
     sfx?: Fx;
 }
+export interface FlagRule extends RuleBase {
+    flags: AffWordFlags;
+}
+export interface PfxRule extends RuleBase {
+    pfx: Fx;
+}
+export interface SfxRule extends RuleBase {
+    sfx: Fx;
+}
 /**
  * AffWordFlags are the flags applied to a word after the hunspell rules have been applied.
  * They are either `true` or `undefined`.
@@ -177,4 +190,5 @@ export interface AffWord {
     prefix: string;
     dic: string;
 }
+export {};
 //# sourceMappingURL=affDef.d.ts.map

package/dist/affLegacy.d.ts

@@ -0,0 +1,51 @@
+import type { AffInfo, AffWord, AffWordFlags, Fx, Rule } from './affDef.js';
+import { Converter } from './converter.js';
+/** The `word` field in a Converted AffWord has been converted using the OCONV mapping */
+export type ConvertedAffWord = AffWord;
+export declare class Aff {
+    #private;
+    readonly affInfo: AffInfo;
+    readonly filename?: string | undefined;
+    protected rules: Map<string, Rule>;
+    protected _oConv: Converter;
+    protected _iConv: Converter;
+    private _maxSuffixDepth;
+    private _mapRules;
+    constructor(affInfo: AffInfo, filename?: string | undefined);
+    get maxSuffixDepth(): number;
+    set maxSuffixDepth(value: number);
+    /**
+     * Takes a line from a hunspell.dic file and applies the rules found in the aff file.
+     * For performance reasons, only the `word` field is mapped with OCONV.
+     * @param {string} line - the line from the .dic file.
+     */
+    applyRulesToDicEntry(line: string, maxDepth?: number): ConvertedAffWord[];
+    /**
+     * @internal
+     */
+    applyRulesToWord(affWord: AffWord, remainingDepth: number): AffWord[];
+    applyAffixesToWord(affixRules: Fx[], affWord: AffWord, remainingDepth: number): AffWord[];
+    applyAffixToWord(affix: Fx, affWord: AffWord, combinableSfx: string): AffWord[];
+    getMatchingRules(rules: string): Rule[];
+    joinRules(rules: string[]): string;
+    separateRules(rules: string): string[];
+    get iConv(): Converter;
+    get oConv(): Converter;
+}
+declare function signature(aff: AffWord): string;
+export declare function processRules(affInfo: AffInfo): Map<string, Rule>;
+export declare function logAffWord(affWord: AffWord, message: string): AffWord;
+export declare function affWordToColoredString(affWord: AffWord): string;
+export declare function flagsToString(flags: AffWordFlags): string;
+export declare function asAffWord(word: string, rules?: string, flags?: AffWordFlags): AffWord;
+export declare function compareAff(a: AffWord, b: AffWord): 0 | 1 | -1;
+/**
+ * Returns a filter function that will filter adjacent AffWords
+ * It compares the word and the flags.
+ */
+export declare function filterAff(): (t: AffWord) => boolean;
+export declare const debug: {
+    signature: typeof signature;
+};
+export {};
+//# sourceMappingURL=affLegacy.d.ts.map

package/dist/affLegacy.js

@@ -0,0 +1,269 @@
+import * as GS from 'gensequence';
+import * as util from 'util';
+import { affFlag, flagToLongStringMap, flagToStringMap } from './affConstants.js';
+import { Converter } from './converter.js';
+import { filterOrderedList, isDefined } from './util.js';
+const log = false;
+const DefaultMaxDepth = 5;
+const regExpIsNumber = /^\d+$/;
+export class Aff {
+    affInfo;
+    filename;
+    rules;
+    _oConv;
+    _iConv;
+    _maxSuffixDepth = DefaultMaxDepth;
+    _mapRules = new Map();
+    constructor(affInfo, filename) {
+        this.affInfo = affInfo;
+        this.filename = filename;
+        this.rules = processRules(affInfo);
+        this._iConv = new Converter(affInfo.ICONV || []);
+        this._oConv = new Converter(affInfo.OCONV || []);
+    }
+    get maxSuffixDepth() {
+        return this._maxSuffixDepth;
+    }
+    set maxSuffixDepth(value) {
+        this._maxSuffixDepth = value;
+    }
+    /**
+     * Takes a line from a hunspell.dic file and applies the rules found in the aff file.
+     * For performance reasons, only the `word` field is mapped with OCONV.
+     * @param {string} line - the line from the .dic file.
+     */
+    applyRulesToDicEntry(line, maxDepth) {
+        const maxSuffixDepth = maxDepth ?? this.maxSuffixDepth;
+        const [lineLeft] = line.split(/\s+/, 1);
+        const [word, rules = ''] = lineLeft.split('/', 2);
+        const convert = this._oConv.convert;
+        const results = this.applyRulesToWord(asAffWord(word, rules), maxSuffixDepth).map((affWord) => ((affWord.word = convert(affWord.word)), affWord));
+        results.sort(compareAff);
+        const filtered = results.filter(filterAff());
+        return filtered;
+    }
+    /**
+     * @internal
+     */
+    applyRulesToWord(affWord, remainingDepth) {
+        const compoundMin = this.affInfo.COMPOUNDMIN ?? 3;
+        const { word, base, suffix, prefix, dic } = affWord;
+        const allRules = this.getMatchingRules(affWord.rules);
+        const { rulesApplied, flags } = reduceAffixRules(affWord, allRules);
+        const rules = this.joinRules(allRules.filter((rule) => !rule.flags).map((rule) => rule.id));
+        const affixRules = allRules.map((rule) => rule.sfx || rule.pfx).filter(isDefined);
+        const wordWithFlags = { word, flags, rulesApplied, rules: '', base, suffix, prefix, dic };
+        return [wordWithFlags, ...this.applyAffixesToWord(affixRules, { ...wordWithFlags, rules }, remainingDepth)]
+            .filter(({ flags }) => !flags.isNeedAffix)
+            .map((affWord) => adjustCompounding(affWord, compoundMin))
+            .map((affWord) => logAffWord(affWord, 'applyRulesToWord'));
+    }
+    applyAffixesToWord(affixRules, affWord, remainingDepth) {
+        if (remainingDepth <= 0) {
+            return [];
+        }
+        const combinableRules = affixRules
+            .filter((rule) => rule.type === 'SFX')
+            .filter((rule) => rule.combinable === true)
+            .map(({ id }) => id);
+        const combinableSfx = this.joinRules(combinableRules);
+        const r = affixRules
+            .flatMap((affix) => this.applyAffixToWord(affix, affWord, combinableSfx))
+            .flatMap((affWord) => this.applyRulesToWord(affWord, remainingDepth - 1));
+        return r;
+    }
+    applyAffixToWord(affix, affWord, combinableSfx) {
+        const { word } = affWord;
+        const combineRules = affix.type === 'PFX' && affix.combinable && !!combinableSfx ? combinableSfx : '';
+        const flags = affWord.flags.isNeedAffix ? removeNeedAffix(affWord.flags) : affWord.flags;
+        const matchingSubstitutions = affix.substitutionsForRegExps.filter((sub) => sub.match.test(word));
+        const partialAffWord = { ...affWord, flags, rules: combineRules };
+        return matchingSubstitutions
+            .flatMap((sub) => this.#applySubstitution(affix, partialAffWord, sub))
+            .map((affWord) => logAffWord(affWord, 'applyAffixToWord'));
+    }
+    #substituteAttach(affix, affWord, sub, stripped) {
+        const { word: origWord, rulesApplied, flags, dic } = affWord;
+        const rules = affWord.rules + (sub.attachRules || '');
+        let word;
+        let p = affWord.prefix.length;
+        let s = origWord.length - affWord.suffix.length;
+        if (sub.type === 'S') {
+            word = stripped + sub.attach;
+            s = Math.min(stripped.length, s);
+            p = Math.min(p, s);
+        }
+        else {
+            word = sub.attach + stripped;
+            const d = word.length - origWord.length;
+            p = Math.max(p, word.length - stripped.length);
+            s = Math.max(s + d, p);
+        }
+        const base = word.slice(p, s);
+        const prefix = word.slice(0, p);
+        const suffix = word.slice(s);
+        return {
+            word,
+            rulesApplied: rulesApplied + ' ' + affix.id,
+            rules,
+            flags,
+            base,
+            suffix,
+            prefix,
+            dic,
+        };
+    }
+    #applySubstitution(affix, affWord, subs) {
+        const results = [];
+        for (const [replace, substitutions] of subs.substitutionsGroupedByRemove) {
+            if (!replace.test(affWord.word))
+                continue;
+            const stripped = affWord.word.replace(replace, '');
+            for (const sub of substitutions) {
+                results.push(this.#substituteAttach(affix, affWord, sub, stripped));
+            }
+        }
+        return results;
+    }
+    getMatchingRules(rules) {
+        const { AF = [] } = this.affInfo;
+        const idx = regExpIsNumber.test(rules) ? parseInt(rules, 10) : -1;
+        const rulesToSplit = AF[idx] || rules;
+        return this.separateRules(rulesToSplit)
+            .map((key) => this.rules.get(key))
+            .filter(isDefined);
+    }
+    joinRules(rules) {
+        switch (this.affInfo.FLAG) {
+            case 'long':
+                return rules.join('');
+            case 'num':
+                return rules.join(',');
+        }
+        return rules.join('');
+    }
+    separateRules(rules) {
+        const found = this._mapRules.get(rules);
+        if (found)
+            return found;
+        const split = this.#separateRules(rules);
+        this._mapRules.set(rules, split);
+        return split;
+    }
+    #separateRules(rules) {
+        switch (this.affInfo.FLAG) {
+            case 'long':
+                return [...new Set(rules.replace(/(..)/g, '$1//').split('//').slice(0, -1))];
+            case 'num':
+                return [...new Set(rules.split(','))];
+        }
+        return [...new Set(rules.split(''))];
+    }
+    get iConv() {
+        return this._iConv;
+    }
+    get oConv() {
+        return this._oConv;
+    }
+}
+function signature(aff) {
+    const { word, flags } = aff;
+    const sig = Object.entries(flags)
+        .filter((e) => !!e[1])
+        .map((f) => flagToStringMap[f[0]])
+        .sort()
+        .join('');
+    return word + '|' + sig;
+}
+export function processRules(affInfo) {
+    const sfxRules = [...(affInfo.SFX || [])]
+        .map(([, sfx]) => sfx)
+        .map((sfx) => ({ id: sfx.id, type: 'sfx', sfx }));
+    const pfxRules = [...(affInfo.PFX || [])]
+        .map(([, pfx]) => pfx)
+        .map((pfx) => ({ id: pfx.id, type: 'pfx', pfx }));
+    const flagRules = [
+        ...GS.sequenceFromObject(affInfo)
+            .filter(([key, value]) => !!affFlag[key] && !!value)
+            .map(([key, value]) => ({ id: value, type: 'flag', flags: affFlag[key] })),
+    ];
+    const rules = [...sfxRules, ...pfxRules, ...flagRules].reduce((acc, rule) => {
+        acc.set(rule.id, rule);
+        return acc;
+    }, new Map());
+    return rules;
+}
+export function logAffWord(affWord, message) {
+    /* istanbul ignore if */
+    if (log) {
+        const dump = util.inspect(affWord, { showHidden: false, depth: 5, colors: true });
+        console.log(`${message}: ${dump}`);
+    }
+    return affWord;
+}
+/* istanbul ignore next */
+export function affWordToColoredString(affWord) {
+    return util
+        .inspect({ ...affWord, flags: flagsToString(affWord.flags) }, { showHidden: false, depth: 5, colors: true })
+        .replace(/(\s|\n|\r)+/g, ' ');
+}
+/* istanbul ignore next */
+export function flagsToString(flags) {
+    return [...Object.entries(flags)]
+        .filter(([, v]) => !!v)
+        .map(([k]) => flagToLongStringMap[k])
+        .sort()
+        .join(':');
+}
+export function asAffWord(word, rules = '', flags = {}) {
+    return {
+        word,
+        base: word,
+        prefix: '',
+        suffix: '',
+        rulesApplied: '',
+        rules,
+        flags,
+        dic: rules ? word + '/' + rules : word,
+    };
+}
+export function compareAff(a, b) {
+    if (a.word !== b.word) {
+        return a.word < b.word ? -1 : 1;
+    }
+    const sigA = signature(a);
+    const sigB = signature(b);
+    return sigA < sigB ? -1 : sigA > sigB ? 1 : 0;
+}
+function reduceAffixRules(affWord, allRules) {
+    return allRules
+        .filter((rule) => !!rule.flags)
+        .reduce((acc, rule) => ({
+        rulesApplied: [acc.rulesApplied, rule.id].join(' '),
+        flags: { ...acc.flags, ...rule.flags },
+    }), { rulesApplied: affWord.rulesApplied, flags: affWord.flags });
+}
+/**
+ * Returns a filter function that will filter adjacent AffWords
+ * It compares the word and the flags.
+ */
+export function filterAff() {
+    return filterOrderedList((a, b) => a.word !== b.word || signature(a) !== signature(b));
+}
+export const debug = {
+    signature,
+};
+function removeNeedAffix(flags) {
+    const newFlags = { ...flags };
+    delete newFlags.isNeedAffix;
+    return newFlags;
+}
+function adjustCompounding(affWord, minLength) {
+    if (!affWord.flags.isCompoundPermitted || affWord.word.length >= minLength) {
+        return affWord;
+    }
+    const { isCompoundPermitted: _, ...flags } = affWord.flags;
+    affWord.flags = flags;
+    return affWord;
+}
+//# sourceMappingURL=affLegacy.js.map

package/dist/affReader.d.ts

@@ -1,5 +1,6 @@
 import { Aff } from './aff.js';
 import type { AffInfo, Fx } from './affDef.js';
+import { Aff as AffLegacy } from './affLegacy.js';
 export interface ConvEntry {
     from: string;
     to: string;
@@ -21,6 +22,7 @@ declare function parseAffixRule(line: AffLine): AffixRule | undefined;
 export declare function parseAffFile(filename: string, encoding?: string): Promise<AffInfo>;
 export declare function parseAff(affFileContent: string, encoding?: string): AffInfo;
 export declare function parseAffFileToAff(filename: string, encoding?: string): Promise<Aff>;
+export declare function parseAffFileToAffLegacy(filename: string, encoding?: string): Promise<AffLegacy>;
 declare function parseLine(line: string): AffLine;
 export interface AffLine {
     option: string;

package/dist/affReader.js

@@ -1,8 +1,10 @@
 import assert from 'assert';
 import { readFile } from 'fs/promises';
+import { decode as decodeHtmlEntities } from 'html-entities';
 import pkgIconvLite from 'iconv-lite';
 import { Aff } from './aff.js';
-import { cleanObject, isDefined } from './util.js';
+import { Aff as AffLegacy } from './affLegacy.js';
+import { cleanObject, insertItemIntoGroupByField, isDefined } from './util.js';
 const { decode } = pkgIconvLite;
 const fixRegex = {
     SFX: { m: /$/, r: '$' },
@@ -99,18 +101,23 @@ function tablePfxOrSfx(fieldValue, line) {
         substitutionSets.set(ruleAsString, {
             match: rule.condition,
             substitutions: [],
+            substitutionsGroupedByRemove: new Map(),
         });
     }
     const substitutionSet = substitutionSets.get(ruleAsString);
     assert(substitutionSet);
     const [attachText, attachRules] = rule.affix.split('/', 2);
-    substitutionSet.substitutions.push({
+    const substitution = {
+        type: rule.type === 'SFX' ? 'S' : 'P',
         remove: rule.stripping,
         replace: rule.replace,
         attach: attachText,
         attachRules,
         extra: rule.extra,
-    });
+    };
+    substitutionSet.substitutions.push(substitution);
+    insertItemIntoGroupByField(substitutionSet.substitutionsGroupedByRemove, 'replace', substitution);
+    fixRuleSet.substitutionsForRegExps = [...substitutionSets.values()];
     return fieldValue;
 }
 /**
@@ -121,11 +128,12 @@ function parseAffixCreation(line) {
     const [flag, combinable, count, ...extra] = (line.value || '').split(spaceRegex);
     const fx = {
         id: flag,
-        type: line.option,
+        type: line.option === 'SFX' ? 'SFX' : 'PFX',
         combinable: !!combinable.match(yesRegex),
         count,
         extra,
         substitutionSets: new Map(),
+        substitutionsForRegExps: [],
     };
     return fx;
 }
@@ -158,10 +166,17 @@ function cleanAffixAttach(affix) {
     const attach = fix === '0' ? '' : fix;
     return attach + (rules ? '/' + rules : '');
 }
+const regexpCache = new Map();
 function fixMatch(type, match) {
+    const key = type + ':' + match;
+    const cached = regexpCache.get(key);
+    if (cached)
+        return cached;
     const exp = affixMatchToRegExpString(match);
     const fix = fixRegex[type];
-    return new RegExp(exp.replace(fix.m, fix.r));
+    const regexp = new RegExp(exp.replace(fix.m, fix.r));
+    regexpCache.set(key, regexp);
+    return regexp;
 }
 function affixMatchToRegExpString(match) {
     if (match === '0')
@@ -295,8 +310,11 @@ function collectionToAffInfo(affFieldCollectionTable, encoding) {
     };
     return cleanObject(result);
 }
+let htmlEntitiesFound = 0;
+let currentAffFilename = '';
 export async function parseAffFile(filename, encoding = UTF8) {
     const buffer = await readFile(filename);
+    currentAffFilename = filename;
     const file = decode(buffer, encoding);
     const affInfo = parseAff(file, encoding);
     if (affInfo.SET && affInfo.SET.toLowerCase() !== encoding.toLowerCase()) {
@@ -304,13 +322,31 @@ export async function parseAffFile(filename, encoding = UTF8) {
     }
     return affInfo;
 }
+function convertHtmlEntities(line, index) {
+    if (line.indexOf('&') < 0)
+        return line;
+    const fixed = decodeHtmlEntities(line);
+    if (fixed !== line) {
+        if (htmlEntitiesFound < 10) {
+            const foundInFile = currentAffFilename;
+            console.error('HTML Entities found in aff file at line %s:%i\n\t%o replaced with:\n\t%o', foundInFile, index + 1, line, fixed);
+        }
+        if (htmlEntitiesFound === 10) {
+            console.error('HTML Entities found in aff...');
+        }
+        ++htmlEntitiesFound;
+    }
+    return fixed;
+}
 export function parseAff(affFileContent, encoding = UTF8) {
+    htmlEntitiesFound = 0;
     const lines = affFileContent.split(/\r?\n/g);
     const affFieldCollectionTable = createAffFieldTable();
     affFieldCollectionTable.SET.addLine({ option: 'SET', value: encoding });
     lines
         .map((line) => line.trimStart())
         .map((line) => line.replace(commentRegex, ''))
+        .map(convertHtmlEntities)
         .filter((line) => line.trim() !== '')
         .map(parseLine)
         .forEach((line) => {
@@ -320,7 +356,14 @@ export function parseAff(affFileContent, encoding = UTF8) {
     return collectionToAffInfo(affFieldCollectionTable, encoding);
 }
 export function parseAffFileToAff(filename, encoding) {
-    return parseAffFile(filename, encoding).then((affInfo) => new Aff(affInfo));
+    return parseAffFile(filename, encoding).then((affInfo) => {
+        return new Aff(affInfo, filename);
+    });
+}
+export function parseAffFileToAffLegacy(filename, encoding) {
+    return parseAffFile(filename, encoding).then((affInfo) => {
+        return new AffLegacy(affInfo, filename);
+    });
 }
 function parseLine(line) {
     const result = line.match(affixLine) || ['', ''];

package/dist/commandWords.js

@@ -2,8 +2,8 @@
 import { Command } from 'commander';
 import { createWriteStream, openSync, writeSync } from 'fs';
 import { genSequence } from 'gensequence';
-import { asAffWord } from './aff.js';
-import { IterableHunspellReader } from './IterableHunspellReader.js';
+import { asAffWord } from './affLegacy.js';
+import { IterableHunspellReaderLegacy } from './IterableHunspellReaderLegacy.js';
 import { iterableToStream } from './iterableToStream.js';
 import { batch, uniqueFilter } from './util.js';
 const uniqueHistorySize = 500000;
@@ -109,7 +109,7 @@ async function actionPrime(hunspellDicFilename, options) {
     log(`Dic file: ${dicFile}`);
     log(`Aff file: ${affFile}`);
     log(`Generating Words...`);
-    const reader = await IterableHunspellReader.createFromFiles(affFile, dicFile);
+    const reader = await IterableHunspellReaderLegacy.createFromFiles(affFile, dicFile);
     if (max_depth && Number.parseInt(max_depth) >= 0) {
         reader.maxDepth = Number.parseInt(max_depth);
     }

package/dist/converter.d.ts

@@ -6,6 +6,6 @@ export declare class Converter {
     private _match;
     private _map;
     constructor(convList: ConvItem[]);
-    convert(input: string): string;
+    convert: (input: string) => string;
 }
 //# sourceMappingURL=converter.d.ts.map

package/dist/converter.js

@@ -11,10 +11,10 @@ export class Converter {
             return map;
         }, this._map);
     }
-    convert(input) {
+    convert = (input) => {
         return input.replace(this._match, (m) => {
             return this._map[m] || '';
         });
-    }
+    };
 }
 //# sourceMappingURL=converter.js.map

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export type { AffInfo, AffWord } from './affDef.js';
 export { parseAff, parseAffFile as readAffFile } from './affReader.js';
-export { createMatchingWordsFilter, type HunspellSrcData, IterableHunspellReader, type WordInfo, } from './IterableHunspellReader.js';
-export { IterableHunspellReader as HunspellReader } from './IterableHunspellReader.js';
+export { createMatchingWordsFilter, type HunspellSrcData, IterableHunspellReaderLegacy as IterableHunspellReader, IterableHunspellReaderLegacy, type WordInfo, } from './IterableHunspellReaderLegacy.js';
+export { IterableHunspellReaderLegacy as HunspellReader } from './IterableHunspellReaderLegacy.js';
 export { uniqueFilter } from './util.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,5 @@
 export { parseAff, parseAffFile as readAffFile } from './affReader.js';
-export { createMatchingWordsFilter, IterableHunspellReader, } from './IterableHunspellReader.js';
-export { IterableHunspellReader as HunspellReader } from './IterableHunspellReader.js';
+export { createMatchingWordsFilter, IterableHunspellReaderLegacy as IterableHunspellReader, IterableHunspellReaderLegacy, } from './IterableHunspellReaderLegacy.js';
+export { IterableHunspellReaderLegacy as HunspellReader } from './IterableHunspellReaderLegacy.js';
 export { uniqueFilter } from './util.js';
 //# sourceMappingURL=index.js.map

package/dist/util.d.ts

@@ -14,4 +14,6 @@ export declare function isDefined<T>(v: T | undefined): v is T;
  * @returns the same object.
  */
 export declare function cleanObject<T>(obj: T): T;
+export declare function groupByField<T, K extends keyof T>(i: Iterable<T>, field: K): Map<T[K], T[]>;
+export declare function insertItemIntoGroupByField<T, K extends keyof T>(map: Map<T[K], T[]>, field: K, item: T): void;
 //# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -65,4 +65,26 @@ export function cleanObject(obj) {
     }
     return obj;
 }
+export function groupByField(i, field) {
+    const r = new Map();
+    for (const t of i) {
+        const k = t[field];
+        let a = r.get(k);
+        if (!a) {
+            a = [];
+            r.set(k, a);
+        }
+        a.push(t);
+    }
+    return r;
+}
+export function insertItemIntoGroupByField(map, field, item) {
+    const k = item[field];
+    let a = map.get(k);
+    if (!a) {
+        a = [];
+        map.set(k, a);
+    }
+    a.push(item);
+}
 //# sourceMappingURL=util.js.map