hunspell-reader 8.3.2 → 8.4.0

package/dist/aff.js

@@ -1,19 +1,21 @@
-import * as GS from 'gensequence';
-import { genSequence as gs } from 'gensequence';
-import * as util from 'util';
+import assert from 'assert';
+import { affFlag } from './affConstants.js';
 import { Converter } from './converter.js';
-import { filterOrderedList, isDefined } from './util.js';
-const log = false;
+import { filterOrderedList, groupByField, isDefined } from './util.js';
+const debug = false;
+function logError(msg, ...args) {
+    debug && console.error(msg, ...args);
+}
 const DefaultMaxDepth = 5;
 export class Aff {
     affInfo;
-    rules;
+    affData;
     _oConv;
     _iConv;
     _maxSuffixDepth = DefaultMaxDepth;
-    constructor(affInfo) {
+    constructor(affInfo, filename) {
         this.affInfo = affInfo;
-        this.rules = processRules(affInfo);
+        this.affData = new AffData(affInfo, filename);
         this._iConv = new Converter(affInfo.ICONV || []);
         this._oConv = new Converter(affInfo.OCONV || []);
     }
@@ -29,12 +31,13 @@ export class Aff {
      * @param {string} line - the line from the .dic file.
      */
     applyRulesToDicEntry(line, maxDepth) {
+        const afWord = this.affData.dictLineToAffixWord(line);
         const maxSuffixDepth = maxDepth ?? this.maxSuffixDepth;
-        const [lineLeft] = line.split(/\s+/, 1);
-        const [word, rules = ''] = lineLeft.split('/', 2);
-        const results = this.applyRulesToWord(asAffWord(word, rules), maxSuffixDepth).map((affWord) => ({
+        const convert = this._oConv.convert;
+        const results = this.applyRulesToWord(afWord, maxSuffixDepth).map((affWord) => ({
             ...affWord,
-            word: this._oConv.convert(affWord.word),
+            word: convert(affWord.word),
+            originalWord: affWord.word,
         }));
         results.sort(compareAff);
         const filtered = results.filter(filterAff());
@@ -45,103 +48,72 @@ export class Aff {
      */
     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 } = 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 });
-        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) {
+        const { word, flags, dict, appliedRules } = affWord;
+        const wordWithFlags = { word, rules: undefined, flags, dict, appliedRules };
+        return [wordWithFlags, ...this.applyAffixesToWord(affWord, remainingDepth)]
+            .filter(({ flags }) => !(flags & AffixFlags.isNeedAffix))
+            .map((affWord) => adjustCompounding(affWord, compoundMin));
+    }
+    applyAffixesToWord(affWord, remainingDepth) {
+        if (remainingDepth <= 0 || !affWord.rules) {
             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
+        const rules = affWord.rules;
+        const combinableSfx = rules.filter((r) => r.type === 'S' && r.fx.combinable);
+        const r = affWord.rules
             .flatMap((affix) => this.applyAffixToWord(affix, affWord, combinableSfx))
             .flatMap((affWord) => this.applyRulesToWord(affWord, remainingDepth - 1));
         return r;
     }
-    applyAffixToWord(affix, affWord, combinableSfx) {
+    applyAffixToWord(rule, 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.substitutionSets.values()].filter((sub) => sub.match.test(word));
-        const partialAffWord = { ...affWord, flags, rules: combineRules };
-        return matchingSubstitutions
-            .flatMap((sub) => sub.substitutions)
-            .filter((sub) => sub.remove === '0' || sub.replace.test(word))
-            .map((sub) => this.substitute(affix, partialAffWord, sub))
-            .map((affWord) => logAffWord(affWord, 'applyAffixToWord'));
-    }
-    substitute(affix, affWord, sub) {
-        const { word: origWord, rulesApplied, flags, dic } = affWord;
-        const rules = affWord.rules + (sub.attachRules || '');
-        const word = origWord.replace(sub.replace, sub.attach);
-        const stripped = origWord.replace(sub.replace, '');
-        let p = affWord.prefix.length;
-        let s = origWord.length - affWord.suffix.length;
-        if (affix.type === 'SFX') {
-            s = Math.min(stripped.length, s);
-            p = Math.min(p, s);
+        const combineRules = rule.type === 'P' && rule.fx.combinable ? combinableSfx : [];
+        const flags = affWord.flags & ~AffixFlags.isNeedAffix;
+        const matchingSubstitutions = rule.fx.substitutionsForRegExps.filter((sub) => sub.match.test(word));
+        const source = {
+            dict: affWord.dict,
+            appliedRules: affWord.appliedRules ? [...affWord.appliedRules, rule.idx] : undefined,
+        };
+        const partialAffWord = this.affData.toAffixWord(source, word, flags, combineRules);
+        return matchingSubstitutions.flatMap((sub) => this.#applySubstitution(partialAffWord, sub));
+    }
+    #substituteAttach(affWord, sub, stripped) {
+        const { flags } = affWord;
+        const subRules = this.affData.getRulesForAffSubstitution(sub);
+        const rules = joinRules(affWord.rules, subRules);
+        let word;
+        if (sub.type === 'S') {
+            word = stripped + sub.attach;
         }
         else {
-            const d = word.length - origWord.length;
-            p = Math.max(p, word.length - stripped.length);
-            s = Math.max(s + d, p);
+            word = sub.attach + stripped;
         }
-        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,
-        };
-    }
-    getMatchingRules(rules) {
-        const { AF = [] } = this.affInfo;
-        const idx = parseInt(rules, 10);
-        const rulesToSplit = AF[idx] || rules;
-        return this.separateRules(rulesToSplit)
-            .map((key) => this.rules.get(key))
-            .filter(isDefined);
+        return this.affData.toAffixWord(affWord, word, flags, rules);
     }
-    joinRules(rules) {
-        switch (this.affInfo.FLAG) {
-            case 'long':
-                return rules.join('');
-            case 'num':
-                return rules.join(',');
+    #applySubstitution(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(affWord, sub, stripped));
+            }
         }
-        return rules.join('');
+        return results;
     }
-    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(''))];
+    getMatchingRules(flags) {
+        const rules = this.affData.getRules(flags);
+        return rules;
+    }
+    /**
+     * Convert the applied rule indexes to AFF Letters.
+     * Requires that the affixWord was generated with trace mode turned on.
+     * @param affixWord - the generated AffixWord.
+     */
+    getFlagsValuesForAffixWord(affixWord) {
+        const rules = this.affData.getRulesForIndexes(affixWord.appliedRules);
+        return rules?.map((r) => r.id);
     }
     get iConv() {
         return this._iConv;
@@ -149,143 +121,327 @@ export class Aff {
     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 = gs(affInfo.SFX || [])
-        .map(([, sfx]) => sfx)
-        .map((sfx) => ({ id: sfx.id, type: 'sfx', sfx }));
-    const pfxRules = gs(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
-        .concat(pfxRules)
-        .concat(flagRules)
-        .reduce((acc, rule) => {
-        acc.set(rule.id, rule);
-        return acc;
-    }, new Map());
-    return rules;
-}
-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',
-};
-const flagToStringMap = _FlagToStringMap;
-const flagToLongStringMap = _FlagToLongStringMap;
-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}`);
+    setTraceMode(value) {
+        this.affData.trace = value;
     }
-    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;
+    return a.word < b.word ? -1 : a.word > b.word ? 1 : a.flags - b.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 filterAff() {
+    return filterOrderedList((a, b) => a.word !== b.word || a.flags !== b.flags);
 }
 function adjustCompounding(affWord, minLength) {
-    if (!affWord.flags.isCompoundPermitted || affWord.word.length >= minLength) {
+    if (!(affWord.flags & AffixFlags.isCompoundPermitted) || affWord.word.length >= minLength) {
         return affWord;
     }
-    const { isCompoundPermitted: _, ...flags } = affWord.flags;
-    affWord.flags = flags;
+    affWord.flags &= ~AffixFlags.isCompoundPermitted;
     return affWord;
 }
+export var AffixFlags;
+(function (AffixFlags) {
+    AffixFlags[AffixFlags["none"] = 0] = "none";
+    /**
+     * COMPOUNDFLAG flag
+     *
+     * Words signed with COMPOUNDFLAG may be in compound words (except when word shorter than COMPOUNDMIN).
+     * Affixes with COMPOUNDFLAG also permits compounding of affixed words.
+     *
+     */
+    AffixFlags[AffixFlags["isCompoundPermitted"] = 1] = "isCompoundPermitted";
+    /**
+     * COMPOUNDBEGIN flag
+     *
+     * Words signed with COMPOUNDBEGIN (or with a signed affix) may be first elements in compound words.
+     *
+     */
+    AffixFlags[AffixFlags["canBeCompoundBegin"] = 2] = "canBeCompoundBegin";
+    /**
+     * COMPOUNDMIDDLE flag
+     *
+     * Words signed with COMPOUNDMIDDLE (or with a signed affix) may be middle elements in compound words.
+     *
+     */
+    AffixFlags[AffixFlags["canBeCompoundMiddle"] = 4] = "canBeCompoundMiddle";
+    /**
+     * COMPOUNDLAST flag
+     *
+     * Words signed with COMPOUNDLAST (or with a signed affix) may be last elements in compound words.
+     *
+     */
+    AffixFlags[AffixFlags["canBeCompoundEnd"] = 8] = "canBeCompoundEnd";
+    /**
+     * COMPOUNDPERMITFLAG flag
+     *
+     * Prefixes are allowed at the beginning of compounds, suffixes are allowed at the end of compounds by default.
+     * Affixes with COMPOUNDPERMITFLAG may be inside of compounds.
+     *
+     */
+    AffixFlags[AffixFlags["isOnlyAllowedInCompound"] = 16] = "isOnlyAllowedInCompound";
+    /**
+     * COMPOUNDFORBIDFLAG flag
+     *
+     * Suffixes with this flag forbid compounding of the affixed word.
+     *
+     */
+    AffixFlags[AffixFlags["isCompoundForbidden"] = 32] = "isCompoundForbidden";
+    /**
+     * WARN flag
+     *
+     * This flag is for rare words, which are also often spelling mistakes, see option -r of command line Hunspell and FORBIDWARN.
+     */
+    AffixFlags[AffixFlags["isWarning"] = 64] = "isWarning";
+    /**
+     * KEEPCASE flag
+     *
+     * Forbid uppercased and capitalized forms of words signed with KEEPCASE flags. Useful for special orthographies (measurements and
+     * currency often keep their case in uppercased texts) and writing systems (e.g. keeping lower case of IPA characters). Also valuable
+     * for words erroneously written in the wrong case.
+     */
+    AffixFlags[AffixFlags["isKeepCase"] = 128] = "isKeepCase";
+    /**
+     * FORCEUCASE flag
+     *
+     * Last word part of a compound with flag FORCEUCASE forces capitalization of the whole compound word.
+     * Eg. Dutch word "straat" (street) with FORCEUCASE flags will allowed only in capitalized compound forms,
+     * according to the Dutch spelling rules for proper names.
+     */
+    AffixFlags[AffixFlags["isForceUCase"] = 256] = "isForceUCase";
+    /**
+     * FORBIDDENWORD flag
+     *
+     * This flag signs forbidden word form. Because affixed forms are also forbidden, we can subtract a subset from set of the
+     * accepted affixed and compound words. Note: useful to forbid erroneous words, generated by the compounding mechanism.
+     */
+    AffixFlags[AffixFlags["isForbiddenWord"] = 512] = "isForbiddenWord";
+    /**
+     * NOSUGGEST flag
+     *
+     * Words signed with NOSUGGEST flag are not suggested (but still accepted when typed correctly). Proposed flag for vulgar
+     * and obscene words (see also SUBSTANDARD).
+     */
+    AffixFlags[AffixFlags["isNoSuggest"] = 1024] = "isNoSuggest";
+    // cspell:ignore pseudoroot
+    /**
+     * NEEDAFFIX flag
+     *
+     * This flag signs virtual stems in the dictionary, words only valid when affixed. Except, if the dictionary word has a homonym
+     * or a zero affix. NEEDAFFIX works also with prefixes and prefix + suffix combinations (see tests/pseudoroot5.*).
+     */
+    AffixFlags[AffixFlags["isNeedAffix"] = 2048] = "isNeedAffix";
+})(AffixFlags || (AffixFlags = {}));
+function toAffixFlags(flags) {
+    let result = 0;
+    for (const [key, value] of Object.entries(flags)) {
+        if (value) {
+            const flag = AffixFlags[key];
+            result |= flag;
+        }
+    }
+    return result;
+}
+class AffData {
+    affInfo;
+    filename;
+    rules = [];
+    mapToRuleIdx = new Map();
+    mapWordRulesToRuleIndexes = new Map();
+    mapWordRulesToRules = new Map();
+    affFlagType;
+    missingFlags = new Set();
+    _mapRuleIdxToRules = new WeakMap();
+    trace = false;
+    constructor(affInfo, filename) {
+        this.affInfo = affInfo;
+        this.filename = filename;
+        this.affFlagType = toAffFlagType(affInfo.FLAG);
+        this.#processAffInfo(affInfo);
+    }
+    dictLineToEntry(line) {
+        const [lineLeft] = line.split(/\s+/, 1);
+        const [word, rules = ''] = lineLeft.split('/', 2);
+        return { word, flags: rules, line };
+    }
+    dictLineToAffixWord(line) {
+        const entry = this.dictLineToEntry(line);
+        return this.toAffixWord({ dict: entry, appliedRules: this.trace ? [] : undefined }, entry.word, AffixFlags.none, this.getRules(entry.flags));
+    }
+    toAffixWord(source, word, flags, rules) {
+        const dict = source.dict;
+        let appliedRules = source.appliedRules;
+        if (!rules)
+            return { word, rules: undefined, flags, dict, appliedRules };
+        const fxRules = rules.filter((rule) => rule.type !== 'F');
+        if (appliedRules) {
+            appliedRules = [...appliedRules, ...rules.filter((r) => r.type === 'F').map((r) => r.idx)];
+        }
+        return {
+            word,
+            rules: fxRules.length ? fxRules : undefined,
+            flags: flags | this.rulesToFlags(rules),
+            appliedRules,
+            dict,
+        };
+    }
+    getRules(rules) {
+        const foundRules = this.mapWordRulesToRules.get(rules);
+        if (foundRules)
+            return foundRules;
+        const ruleIndexes = this.getRuleIndexes(rules);
+        const affRules = ruleIndexes.map((idx) => this.rules[idx]);
+        this.mapWordRulesToRules.set(rules, affRules);
+        return affRules;
+    }
+    getRuleIndexes(rules) {
+        const found = this.mapWordRulesToRuleIndexes.get(rules);
+        if (found)
+            return found;
+        const indexes = this.#getRuleIndexes(rules);
+        this.mapWordRulesToRuleIndexes.set(rules, indexes);
+        return indexes;
+    }
+    rulesToFlags(rules) {
+        return rules.reduce((acc, rule) => acc | rule.flags, AffixFlags.none);
+    }
+    getRulesForIndexes(indexes) {
+        if (!indexes)
+            return undefined;
+        let rules = this._mapRuleIdxToRules.get(indexes);
+        if (rules)
+            return rules;
+        rules = indexes.map((idx) => this.rules[idx]);
+        this._mapRuleIdxToRules.set(indexes, rules);
+        return rules;
+    }
+    getRulesForAffSubstitution(sub) {
+        return this.getRulesForIndexes(sub.attachRules);
+    }
+    #getRuleIndexes(rules) {
+        const flags = this.#splitRules(rules);
+        const indexes = flags
+            .flatMap((flag) => {
+            const found = this.mapToRuleIdx.get(flag);
+            if (found === undefined && !this.missingFlags.has(flag)) {
+                this.missingFlags.add(flag);
+                const filename = this.filename;
+                logError('Unable to resolve flag: %o, for file: %o', flag, filename);
+                // throw new Error('Unable to resolve flag');
+            }
+            return found;
+        })
+            .filter(isDefined);
+        return indexes;
+    }
+    #splitRules(rules) {
+        switch (this.affFlagType) {
+            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(''))];
+    }
+    #processAffInfo(affInfo) {
+        const { AF = [], SFX = [], PFX = [] } = affInfo;
+        const flags = objectToKvP(affInfo)
+            .filter(isValidFlagMember)
+            .map(([key, value]) => ({ id: value, flags: toAffixFlags(affFlag[key]) }));
+        const sfxRules = [...SFX].map(([, sfx]) => sfx).map((sfx) => ({ id: sfx.id, sfx }));
+        const pfxRules = [...PFX].map(([, pfx]) => pfx).map((pfx) => ({ id: pfx.id, pfx }));
+        const rules = [...flags, ...sfxRules, ...pfxRules];
+        rules.forEach((rule, idx) => {
+            const found = this.mapToRuleIdx.get(rule.id);
+            if (found) {
+                const filename = this.filename;
+                logError('Duplicate affix rule: %o, filename: %o', rule.id, filename);
+                const toAdd = Array.isArray(found) ? found : [found];
+                toAdd.push(idx);
+                this.mapToRuleIdx.set(rule.id, toAdd);
+                return;
+            }
+            this.mapToRuleIdx.set(rule.id, idx);
+        });
+        AF.forEach((af, idx) => {
+            if (!af)
+                return;
+            const indexes = this.#getRuleIndexes(af);
+            this.mapWordRulesToRuleIndexes.set(idx.toString(), indexes);
+        });
+        this.rules = rules.map((rule, idx) => this.#mapPartialRule(rule, idx));
+    }
+    #mapPartialRule(rule, index) {
+        const { id, flags, sfx, pfx } = rule;
+        const idx = this.mapToRuleIdx.get(id);
+        // if (index !== idx) {
+        //     const filename = this.affInfo.filename;
+        //     logError('Unexpected index: %o !== %o, rule %o, filename: %o', index, idx, rule, filename);
+        // }
+        assert(idx !== undefined && (idx === index || (Array.isArray(idx) && idx.includes(index))));
+        const fx = sfx || pfx;
+        if (fx) {
+            const affFx = this.#mapFx(fx);
+            if (affFx.type === 'P') {
+                return { id, idx: index, type: 'P', flags: 0, fx: affFx };
+            }
+            else {
+                return { id, idx: index, type: 'S', flags: 0, fx: affFx };
+            }
+        }
+        return { id, idx: index, type: 'F', flags: flags || 0 };
+    }
+    #mapFx(fx) {
+        const { id, combinable } = fx;
+        const substitutionsForRegExps = this.#mapSubstitutionsForRegExps(fx.substitutionsForRegExps);
+        return { type: fx.type === 'PFX' ? 'P' : 'S', id, combinable, substitutionsForRegExps };
+    }
+    #mapSubstitutionsForRegExps(substitutions) {
+        return substitutions.map((sub) => this.#mapSubstitutionsForRegExp(sub));
+    }
+    #mapSubstitutionsForRegExp(subForRegExp) {
+        const { match, substitutions: subs } = subForRegExp;
+        const substitutions = subs.map((sub) => this.#mapSubstitution(sub));
+        const substitutionsGroupedByRemove = groupByField(substitutions, 'replace');
+        return { match, substitutionsGroupedByRemove };
+    }
+    #mapSubstitution(sub) {
+        const { type, remove, attach, attachRules, replace } = sub;
+        const rules = attachRules ? this.getRuleIndexes(attachRules) : undefined;
+        return { type, remove, attach, attachRules: rules, replace };
+    }
+}
+function joinRules(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return [...a, ...b];
+}
+function objectToKvP(t) {
+    return Object.entries(t);
+}
+// type Defined<T> = Exclude<T, undefined>;
+function isValidFlagMember(t) {
+    const [key, value] = t;
+    return key in affFlag && !!value;
+}
+/**
+ *
+ * @param FLAG - the FLAG value from the aff file
+ * @returns the AffFlagType or throws
+ */
+export function toAffFlagType(FLAG) {
+    if (!FLAG)
+        return 'char';
+    switch (FLAG) {
+        case 'long':
+        case 'num':
+            return FLAG;
+        default:
+            throw new Error(`Unexpected FLAG value: ${FLAG}`);
+    }
+}
 //# sourceMappingURL=aff.js.map

package/dist/affConstants.d.ts

@@ -0,0 +1,6 @@
+import type { AffTransformFlags, AffWordFlags } from './affDef.js';
+import type { Mapping } from './types.js';
+export declare const affFlag: Mapping<AffTransformFlags, AffWordFlags>;
+export declare const flagToStringMap: Record<string, string | undefined>;
+export declare const flagToLongStringMap: Record<string, string | undefined>;
+//# sourceMappingURL=affConstants.d.ts.map