@willwade/aac-processors 0.2.3 → 0.2.5

package/dist/utilities/analytics/morphology/grid3VerbsParser.d.ts

@@ -0,0 +1,36 @@
+import type { Grid3VerbFormsDetailed } from './types';
+export interface Grid3VerbForms {
+    locale: string;
+    verbs: Map<string, string[]>;
+}
+export declare class Grid3VerbsParser {
+    private parser;
+    parseXml(xmlContent: string, locale?: string): Grid3VerbForms;
+    parseXmlDetailed(xmlContent: string, locale?: string): Grid3VerbFormsDetailed;
+    parseXmlFileDetailed(filePath: string): Grid3VerbFormsDetailed;
+    parseZip(zipPath: string): Grid3VerbForms;
+    parseZipDetailed(zipPath: string): Grid3VerbFormsDetailed;
+    parseLocale(locale: string, grid3InstallPath?: string): Promise<Grid3VerbForms>;
+    parseInstalledLocales(grid3InstallPath?: string): Promise<Map<string, Grid3VerbForms>>;
+    /**
+     * Parse all locales from a custom directory.
+     *
+     * The directory should have the same structure as Grid 3's Locale folder:
+     *   customDir/en-GB/verbs/verbs.zip
+     *   customDir/nb-NO/verbs/verbs.zip
+     *   customDir/de-DE/verbs/verbs.zip
+     *
+     * This allows users to supply morphology data copied from any Grid 3
+     * installation without needing Grid 3 installed on this machine.
+     */
+    parseCustomDirectory(dirPath: string, detailed?: false): Map<string, Grid3VerbForms>;
+    parseCustomDirectory(dirPath: string, detailed: true): Map<string, import('./types').Grid3VerbFormsDetailed>;
+    private getDefaultInstallPath;
+    private parseRuleSets;
+    private parseVerbs;
+    private generateForms;
+    private generateFormsDetailed;
+    private buildContext;
+    private resolveTemplate;
+    private addIfSingleWord;
+}

package/dist/utilities/analytics/morphology/grid3VerbsParser.js

@@ -0,0 +1,485 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grid3VerbsParser = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const path_1 = require("path");
+class Grid3VerbsParser {
+    constructor() {
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            textNodeName: '#text',
+        });
+    }
+    parseXml(xmlContent, locale) {
+        const data = this.parser.parse(xmlContent);
+        const verbdata = data.verbdata || data.Verbdata;
+        if (!verbdata) {
+            return { locale: locale || 'unknown', verbs: new Map() };
+        }
+        const detectedLocale = verbdata['@_locale'] || verbdata.locale || locale || 'unknown';
+        const ruleSets = this.parseRuleSets(verbdata);
+        const verbs = this.parseVerbs(verbdata);
+        const result = new Map();
+        for (const verb of verbs) {
+            const forms = this.generateForms(verb, ruleSets);
+            if (forms.length > 0) {
+                result.set(verb.root, forms);
+            }
+        }
+        return { locale: detectedLocale, verbs: result };
+    }
+    parseXmlDetailed(xmlContent, locale) {
+        const data = this.parser.parse(xmlContent);
+        const verbdata = data.verbdata || data.Verbdata;
+        if (!verbdata) {
+            return { locale: locale || 'unknown', verbs: new Map() };
+        }
+        const detectedLocale = verbdata['@_locale'] || verbdata.locale || locale || 'unknown';
+        const ruleSets = this.parseRuleSets(verbdata);
+        const verbs = this.parseVerbs(verbdata);
+        const result = new Map();
+        for (const verb of verbs) {
+            const forms = this.generateFormsDetailed(verb, ruleSets);
+            if (forms.length > 0) {
+                result.set(verb.root, forms);
+            }
+        }
+        return { locale: detectedLocale, verbs: result };
+    }
+    /* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-argument */
+    parseXmlFileDetailed(filePath) {
+        const fs = require('fs');
+        const xml = fs.readFileSync(filePath, 'utf-8');
+        return this.parseXmlDetailed(xml);
+    }
+    /* eslint-enable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-argument */
+    parseZip(zipPath) {
+        const zip = new adm_zip_1.default(zipPath);
+        const entries = zip.getEntries();
+        const verbEntry = entries.find((e) => e.entryName.toLowerCase().endsWith('verbs.xml'));
+        if (!verbEntry) {
+            const locale = (0, path_1.basename)((0, path_1.dirname)(zipPath));
+            return { locale, verbs: new Map() };
+        }
+        const xml = verbEntry.getData().toString('utf-8');
+        return this.parseXml(xml);
+    }
+    parseZipDetailed(zipPath) {
+        const zip = new adm_zip_1.default(zipPath);
+        const entries = zip.getEntries();
+        const verbEntry = entries.find((e) => e.entryName.toLowerCase().endsWith('verbs.xml'));
+        if (!verbEntry) {
+            const locale = (0, path_1.basename)((0, path_1.dirname)(zipPath));
+            return { locale, verbs: new Map() };
+        }
+        const xml = verbEntry.getData().toString('utf-8');
+        return this.parseXmlDetailed(xml);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async parseLocale(locale, grid3InstallPath) {
+        const installPath = grid3InstallPath || this.getDefaultInstallPath();
+        if (!installPath) {
+            return { locale, verbs: new Map() };
+        }
+        const zipPath = (0, path_1.join)(installPath, 'Locale', locale, 'verbs', 'verbs.zip');
+        try {
+            return this.parseZip(zipPath);
+        }
+        catch {
+            return { locale, verbs: new Map() };
+        }
+    }
+    async parseInstalledLocales(grid3InstallPath) {
+        const installPath = grid3InstallPath || this.getDefaultInstallPath();
+        const results = new Map();
+        if (!installPath)
+            return results;
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const localeDir = (0, path_1.join)(installPath, 'Locale');
+        let locales;
+        try {
+            locales = fs
+                .readdirSync(localeDir)
+                .filter((d) => fs.statSync((0, path_1.join)(localeDir, d)).isDirectory());
+        }
+        catch {
+            return results;
+        }
+        for (const locale of locales) {
+            const verbsZip = (0, path_1.join)(localeDir, locale, 'verbs', 'verbs.zip');
+            try {
+                fs.accessSync(verbsZip, fs.constants.R_OK);
+                const forms = this.parseZip(verbsZip);
+                results.set(locale, forms);
+            }
+            catch {
+                // No verbs.zip for this locale
+            }
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    parseCustomDirectory(dirPath, detailed = false) {
+        /* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
+        const fs = require('fs');
+        let locales;
+        try {
+            locales = fs
+                .readdirSync(dirPath)
+                .filter((d) => fs.statSync((0, path_1.join)(dirPath, d)).isDirectory());
+        }
+        catch {
+            return new Map();
+        }
+        if (detailed) {
+            const results = new Map();
+            for (const locale of locales) {
+                const verbsZip = (0, path_1.join)(dirPath, locale, 'verbs', 'verbs.zip');
+                try {
+                    fs.accessSync(verbsZip, fs.constants.R_OK);
+                    results.set(locale, this.parseZipDetailed(verbsZip));
+                }
+                catch {
+                    // No verbs.zip for this locale
+                }
+            }
+            return results;
+        }
+        const results = new Map();
+        for (const locale of locales) {
+            const verbsZip = (0, path_1.join)(dirPath, locale, 'verbs', 'verbs.zip');
+            try {
+                fs.accessSync(verbsZip, fs.constants.R_OK);
+                results.set(locale, this.parseZip(verbsZip));
+            }
+            catch {
+                // No verbs.zip for this locale
+            }
+        }
+        return results;
+        /* eslint-enable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
+    }
+    getDefaultInstallPath() {
+        if (typeof process === 'undefined' || process.platform !== 'win32') {
+            return null;
+        }
+        const paths = [
+            'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+            'C:\\Program Files\\Smartbox\\Grid 3',
+        ];
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const fs = require('fs');
+            for (const p of paths) {
+                if (fs.existsSync(p))
+                    return p;
+            }
+        }
+        catch {
+            // Grid 3 not installed
+        }
+        return null;
+    }
+    /* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+    parseRuleSets(verbdata) {
+        const rulesMap = new Map();
+        const rulesList = verbdata.verbruleslist?.verbrules;
+        if (!rulesList)
+            return rulesMap;
+        const rulesArr = Array.isArray(rulesList) ? rulesList : [rulesList];
+        for (const rules of rulesArr) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            const id = rules.Id || rules.id || `rule_${rulesMap.size}`;
+            const placeholders = [];
+            const ph = rules.placeholders?.placeholder;
+            if (ph) {
+                const phArr = Array.isArray(ph) ? ph : [ph];
+                for (const p of phArr) {
+                    const val = typeof p === 'string' ? p : p['#text'] || p;
+                    if (val)
+                        placeholders.push(val);
+                }
+            }
+            const participleRules = new Map();
+            const pr = rules.participlerules?.participlerule;
+            if (pr) {
+                const prArr = Array.isArray(pr) ? pr : [pr];
+                for (const rule of prArr) {
+                    const type = rule['@_type'] || rule.type;
+                    const value = rule['@_value'] || rule.value;
+                    if (type && value) {
+                        participleRules.set(type, value);
+                    }
+                }
+            }
+            const conjugationRules = [];
+            const cr = rules.conjugationrules?.conjugationrule;
+            if (cr) {
+                const crArr = Array.isArray(cr) ? cr : [cr];
+                for (const rule of crArr) {
+                    const value = rule['@_value'] || rule.value;
+                    if (!value)
+                        continue;
+                    const conditions = new Map();
+                    for (const attr of [
+                        'time',
+                        'number',
+                        'person',
+                        'aspect',
+                        'mood',
+                        'voice',
+                        'tense',
+                        'polarity',
+                    ]) {
+                        const v = rule[`@_${attr}`] || rule[attr];
+                        if (v && v !== '*') {
+                            conditions.set(attr, String(v));
+                        }
+                    }
+                    conjugationRules.push({ value, conditions });
+                }
+            }
+            rulesMap.set(id, { id, placeholders, participleRules, conjugationRules });
+        }
+        return rulesMap;
+    }
+    /* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+    parseVerbs(verbdata) {
+        const verbs = [];
+        const verbsData = verbdata.verbs?.verb;
+        if (!verbsData)
+            return verbs;
+        const arr = Array.isArray(verbsData) ? verbsData : [verbsData];
+        for (const v of arr) {
+            const root = v['@_root'] || v.root;
+            if (!root)
+                continue;
+            const ruleId = v['@_ruleid'] || v.ruleid || undefined;
+            const placeholderValues = new Map();
+            const rphv = v.ruleplaceholdervalues?.ruleplaceholdervalue;
+            if (rphv) {
+                const rphvArr = Array.isArray(rphv) ? rphv : [rphv];
+                for (const ph of rphvArr) {
+                    const placeholder = ph['@_placeholder'] || ph.placeholder;
+                    const value = ph['@_value'] || ph.value;
+                    if (placeholder && value) {
+                        placeholderValues.set(placeholder, value);
+                    }
+                }
+            }
+            const participleOverrides = new Map();
+            const parts = v.participles?.participle;
+            if (parts) {
+                const partsArr = Array.isArray(parts) ? parts : [parts];
+                for (const p of partsArr) {
+                    const type = p['@_type'] || p.type;
+                    const value = p['@_value'] || p.value;
+                    if (type && value) {
+                        participleOverrides.set(type, value);
+                    }
+                }
+            }
+            const conjugationOverrides = [];
+            const conjs = v.conjugations?.conjugation;
+            if (conjs) {
+                const conjArr = Array.isArray(conjs) ? conjs : [conjs];
+                for (const c of conjArr) {
+                    const value = c['@_value'] || c.value;
+                    if (!value)
+                        continue;
+                    const conditions = new Map();
+                    const parts2 = c.part;
+                    if (parts2) {
+                        const pArr = Array.isArray(parts2) ? parts2 : [parts2];
+                        for (const p of pArr) {
+                            for (const attr of ['time', 'number', 'person', 'aspect', 'mood', 'voice']) {
+                                const pv = p[`@_${attr}`] || p[attr];
+                                if (pv && pv !== '*') {
+                                    conditions.set(attr, String(pv));
+                                }
+                            }
+                        }
+                    }
+                    conjugationOverrides.push({ value, conditions });
+                }
+            }
+            verbs.push({
+                root,
+                ruleId,
+                placeholderValues,
+                participleOverrides,
+                conjugationOverrides,
+            });
+        }
+        return verbs;
+    }
+    generateForms(verb, ruleSets) {
+        const forms = new Set();
+        const resolvedParticiples = new Map();
+        for (const [type, value] of verb.participleOverrides) {
+            resolvedParticiples.set(type, value);
+        }
+        let appliedRule;
+        if (verb.ruleId && ruleSets.has(verb.ruleId)) {
+            appliedRule = ruleSets.get(verb.ruleId);
+        }
+        else if (ruleSets.size > 0) {
+            appliedRule = ruleSets.values().next().value;
+        }
+        if (appliedRule) {
+            const context = this.buildContext(verb, resolvedParticiples);
+            for (const [type, template] of appliedRule.participleRules) {
+                if (!resolvedParticiples.has(type)) {
+                    const resolved = this.resolveTemplate(template, context);
+                    if (resolved) {
+                        resolvedParticiples.set(type, resolved);
+                    }
+                }
+            }
+            const fullContext = this.buildContext(verb, resolvedParticiples);
+            for (const conjRule of appliedRule.conjugationRules) {
+                const resolved = this.resolveTemplate(conjRule.value, fullContext);
+                this.addIfSingleWord(resolved, forms);
+            }
+        }
+        for (const [, value] of resolvedParticiples) {
+            this.addIfSingleWord(value, forms);
+        }
+        for (const conj of verb.conjugationOverrides) {
+            this.addIfSingleWord(conj.value, forms);
+        }
+        forms.delete(verb.root);
+        return Array.from(forms);
+    }
+    generateFormsDetailed(verb, ruleSets) {
+        const forms = new Map();
+        const resolvedParticiples = new Map();
+        for (const [type, value] of verb.participleOverrides) {
+            resolvedParticiples.set(type, value);
+        }
+        let appliedRule;
+        if (verb.ruleId && ruleSets.has(verb.ruleId)) {
+            appliedRule = ruleSets.get(verb.ruleId);
+        }
+        else if (ruleSets.size > 0) {
+            appliedRule = ruleSets.values().next().value;
+        }
+        if (appliedRule) {
+            const context = this.buildContext(verb, resolvedParticiples);
+            for (const [type, template] of appliedRule.participleRules) {
+                if (!resolvedParticiples.has(type)) {
+                    const resolved = this.resolveTemplate(template, context);
+                    if (resolved) {
+                        resolvedParticiples.set(type, resolved);
+                    }
+                }
+            }
+            const fullContext = this.buildContext(verb, resolvedParticiples);
+            for (const conjRule of appliedRule.conjugationRules) {
+                const resolved = this.resolveTemplate(conjRule.value, fullContext);
+                if (resolved && !resolved.includes(' ') && resolved !== '-') {
+                    const trimmed = resolved.trim();
+                    if (trimmed.length > 0 && trimmed !== verb.root) {
+                        const existing = forms.get(trimmed);
+                        if (existing) {
+                            for (const [k, v] of conjRule.conditions) {
+                                existing.set(k, v);
+                            }
+                        }
+                        else {
+                            forms.set(trimmed, new Map(conjRule.conditions));
+                        }
+                    }
+                }
+            }
+        }
+        for (const [type, value] of resolvedParticiples) {
+            if (!value.includes(' ') && value !== '-' && value.trim().length > 0 && value !== verb.root) {
+                const conditions = forms.get(value) || new Map();
+                conditions.set('participleType', type);
+                forms.set(value, conditions);
+            }
+        }
+        for (const conj of verb.conjugationOverrides) {
+            if (conj.value &&
+                !conj.value.includes(' ') &&
+                conj.value !== '-' &&
+                conj.value.trim().length > 0 &&
+                conj.value !== verb.root) {
+                const existing = forms.get(conj.value) || new Map();
+                for (const [k, v] of conj.conditions) {
+                    existing.set(k, v);
+                }
+                forms.set(conj.value, existing);
+            }
+        }
+        forms.delete(verb.root);
+        return Array.from(forms.entries()).map(([value, conditions]) => ({
+            value,
+            conditions,
+        }));
+    }
+    buildContext(verb, resolvedParticiples) {
+        const context = new Map();
+        context.set('{root}', verb.root);
+        for (const [key, value] of verb.placeholderValues) {
+            context.set(key, value);
+            if (!key.startsWith('{')) {
+                context.set(`{${key}}`, value);
+            }
+        }
+        for (const [type, value] of resolvedParticiples) {
+            context.set(`{${type}}`, value);
+        }
+        return context;
+    }
+    resolveTemplate(template, context) {
+        let result = template;
+        for (const [key, value] of context) {
+            const keyToReplace = key.startsWith('{') ? key : `{${key}}`;
+            result = result.split(keyToReplace).join(value);
+        }
+        return result;
+    }
+    addIfSingleWord(form, set) {
+        if (!form)
+            return;
+        if (form.includes(' '))
+            return;
+        if (form === '-')
+            return;
+        const trimmed = form.trim();
+        if (trimmed.length > 0) {
+            set.add(trimmed);
+        }
+    }
+}
+exports.Grid3VerbsParser = Grid3VerbsParser;

package/dist/utilities/analytics/morphology/index.d.ts

@@ -0,0 +1,5 @@
+export { MorphologyEngine } from './engine';
+export { Grid3VerbsParser } from './grid3VerbsParser';
+export { WordFormGenerator } from './wordFormGenerator';
+export type { MorphRuleSet, MorphRule, MorphWordForms, AstericsWordForm, VerbFormWithConditions, Grid3VerbFormsDetailed, } from './types';
+export type { Grid3VerbForms } from './grid3VerbsParser';

package/dist/utilities/analytics/morphology/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordFormGenerator = exports.Grid3VerbsParser = exports.MorphologyEngine = void 0;
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "MorphologyEngine", { enumerable: true, get: function () { return engine_1.MorphologyEngine; } });
+var grid3VerbsParser_1 = require("./grid3VerbsParser");
+Object.defineProperty(exports, "Grid3VerbsParser", { enumerable: true, get: function () { return grid3VerbsParser_1.Grid3VerbsParser; } });
+var wordFormGenerator_1 = require("./wordFormGenerator");
+Object.defineProperty(exports, "WordFormGenerator", { enumerable: true, get: function () { return wordFormGenerator_1.WordFormGenerator; } });

package/dist/utilities/analytics/morphology/types.d.ts

@@ -0,0 +1,40 @@
+export interface MorphRule {
+    match: string;
+    replace: string;
+}
+export interface MorphRuleSet {
+    locale: string;
+    version: number;
+    irregular: {
+        [pos: string]: {
+            [baseWord: string]: {
+                [slot: string]: string | string[];
+            };
+        };
+    };
+    regular: {
+        [pos: string]: {
+            [slot: string]: MorphRule[] | string;
+        };
+    };
+}
+export interface MorphWordForms {
+    base: string;
+    pos: string;
+    forms: string[];
+}
+export interface AstericsWordForm {
+    lang?: string;
+    tags: string[];
+    value: string;
+    pronunciation?: string;
+    base?: string;
+}
+export interface VerbFormWithConditions {
+    value: string;
+    conditions: Map<string, string>;
+}
+export interface Grid3VerbFormsDetailed {
+    locale: string;
+    verbs: Map<string, VerbFormWithConditions[]>;
+}

package/dist/utilities/analytics/morphology/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utilities/analytics/morphology/wordFormGenerator.d.ts

@@ -0,0 +1,10 @@
+import { MorphologyEngine } from './engine';
+import { Grid3VerbsParser } from './grid3VerbsParser';
+import type { AstericsWordForm, VerbFormWithConditions } from './types';
+export declare class WordFormGenerator {
+    generateFromEngineSlots(base: string, pos: string, engine: MorphologyEngine, lang?: string): AstericsWordForm[];
+    generateFromGrid3Conditions(base: string, formsWithConditions: VerbFormWithConditions[], lang?: string): AstericsWordForm[];
+    generateFromPos(base: string, pos: string, engine: MorphologyEngine, grid3Parser: Grid3VerbsParser, verbsZipPath?: string, lang?: string): AstericsWordForm[];
+    conditionsToTags(conditions: Map<string, string>): string[];
+    private deduplicate;
+}

package/dist/utilities/analytics/morphology/wordFormGenerator.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordFormGenerator = void 0;
+const SLOT_TAG_MAP = {
+    '3sg': ['3.PERS'],
+    past: ['PAST'],
+    pastPart: ['PAST', 'PARTICIPLE'],
+    presPart: ['GERUND'],
+    plural: ['PLURAL'],
+    comparative: ['COMPARATIVE'],
+    superlative: ['SUPERLATIVE'],
+};
+const CONDITION_TAG_MAP = {
+    person: { first: ['1.PERS'], second: ['2.PERS'], third: ['3.PERS'] },
+    number: { singular: [], plural: ['PLURAL'] },
+    time: { present: ['PRESENT'], past: ['PAST'], future: ['FUTURE'] },
+    aspect: { simple: [], continuous: ['CONTINUOUS'], perfect: ['PERFECT'] },
+    mood: {
+        imperative: ['IMPERATIVE'],
+        indicative: [],
+        conditional: ['CONDITIONAL'],
+    },
+    participleType: {
+        presentparticiple: ['GERUND'],
+        pastparticiple: ['PAST', 'PARTICIPLE'],
+        infinitive: ['BASE'],
+    },
+};
+class WordFormGenerator {
+    generateFromEngineSlots(base, pos, engine, lang = 'en') {
+        const forms = engine.inflectWithSlots(base, pos);
+        const result = [{ lang, tags: ['BASE'], value: base }];
+        for (const { slot, form } of forms) {
+            const tags = SLOT_TAG_MAP[slot] || [slot.toUpperCase()];
+            result.push({ lang, tags, value: form, base });
+        }
+        return result;
+    }
+    generateFromGrid3Conditions(base, formsWithConditions, lang = 'en') {
+        const result = [{ lang, tags: ['BASE'], value: base }];
+        for (const form of formsWithConditions) {
+            const tags = this.conditionsToTags(form.conditions);
+            result.push({ lang, tags, value: form.value, base });
+        }
+        return this.deduplicate(result);
+    }
+    generateFromPos(base, pos, engine, grid3Parser, verbsZipPath, lang = 'en') {
+        if (verbsZipPath) {
+            const detailed = grid3Parser.parseZipDetailed(verbsZipPath);
+            const forms = detailed.verbs.get(base) || detailed.verbs.get(base.toLowerCase());
+            if (forms && forms.length > 0) {
+                return this.generateFromGrid3Conditions(base, forms, lang);
+            }
+        }
+        return this.generateFromEngineSlots(base, pos, engine, lang);
+    }
+    conditionsToTags(conditions) {
+        const tags = [];
+        for (const [dim, value] of conditions) {
+            const mapped = CONDITION_TAG_MAP[dim]?.[value];
+            if (mapped) {
+                tags.push(...mapped);
+            }
+        }
+        return tags.length > 0 ? tags : ['UNKNOWN'];
+    }
+    deduplicate(forms) {
+        const seen = new Set();
+        return forms.filter((f) => {
+            const key = `${f.value}|${f.tags.sort().join(',')}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+}
+exports.WordFormGenerator = WordFormGenerator;