@fpw/en-wiktionary-la-modules 0.2.2 → 0.3.2

package/dist/modules/headword/HeadwordParser.js

@@ -1,452 +1,456 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeadwordParser = void 0;
-/**
- * This is based on https://en.wiktionary.org/wiki/Module:la-headword developed by Benwing2.
- * It was converted from Lua to TypeScript by Folke Will <folko@solhost.org>.
- *
- * Original source: https://en.wiktionary.org/wiki/Module:la-headword
- *
- * Lua idioms, function and variable names kept as in the original in order to easily
- * backport later changes to this implementation.
- *
- * For that reason, it's suggested to add a type-aware wrapper around this class and leave
- * this code unchanged instead of improving the types and use of idioms in this class.
- *
- */
-const common_1 = require("../common");
-const LaVerb_1 = require("../conjugation/LaVerb");
-const VerbForm_1 = require("../conjugation/VerbForm");
-const NominalForm_1 = require("../declination/NominalForm");
-const HeadWord_1 = require("./HeadWord");
-class HeadwordParser {
-    constructor(nominal, conj, logger) {
-        this.templateParsers = new Map([
-            // these are parsed by la-ndecl
-            ["la-noun", args => this.parseNominalHead(args, HeadWord_1.NominalType.Noun)],
-            ["la-num-noun", args => this.parseNominalHead(args, HeadWord_1.NominalType.Numeral)],
-            ["la-suffix-noun", args => this.parseNominalHead(args, HeadWord_1.NominalType.Suffix)],
-            ["la-proper noun", args => this.parseNominalHead(args, HeadWord_1.NominalType.ProperNoun)],
-            ["la-prop", args => this.parseNominalHead(args, HeadWord_1.NominalType.ProperNoun)],
-            // these are parsed by la-adecl
-            ["la-adj", args => this.parseAdjectivalHead(args, HeadWord_1.AdjectivalType.Adjective)],
-            ["la-num-adj", args => this.parseAdjectivalHead(args, HeadWord_1.AdjectivalType.Numeral)],
-            ["la-suffix-adj", args => this.parseAdjectivalHead(args, HeadWord_1.AdjectivalType.Suffix)],
-            ["la-pronoun", args => this.parseAdjectivalHead(args, HeadWord_1.AdjectivalType.Pronoun)],
-            ["la-det", args => this.parseAdjectivalHead(args, HeadWord_1.AdjectivalType.Determiner)],
-            ["la-part", args => this.parseAdjectivalHead(args, HeadWord_1.AdjectivalType.Participle)],
-            // these are parsed by la-verb
-            ["la-verb", args => this.parseVerbalHead(args, HeadWord_1.VerbalType.Verb)],
-            ["la-suffix-verb", args => this.parseVerbalHead(args, HeadWord_1.VerbalType.Suffix)],
-            // these are all custom
-            ["la-gerund", (args, lemma) => this.parseGerund(args)],
-            ["la-adj-comp", (args, lemma) => this.parseComparativeAdj(args, lemma)],
-            ["la-adj-sup", (args, lemma) => this.parseSuperlativeAdj(args, lemma)],
-            ["la-adv", (args, lemma) => this.parseAdverb(args, HeadWord_1.AdverbType.Adverb)],
-            ["la-adv-comp", (args, lemma) => this.parseAdverbCompSup(args, HeadWord_1.AdverbType.Comparative)],
-            ["la-adv-sup", (args, lemma) => this.parseAdverbCompSup(args, HeadWord_1.AdverbType.Superlative)],
-            ["la-suffix-adv", (args, lemma) => this.parseAdverb(args, HeadWord_1.AdverbType.Suffix)],
-            ["la-num-adv", (args, lemma) => this.parseAdverbNumeral(args)],
-            ["la-prep", (args, lemma) => this.parsePreposition(args, lemma)],
-            ["la-letter", (args, lemma) => this.parseLetter(args, lemma)],
-            ["la-interj", (args, lemma) => this.parseInterjection(args, lemma)],
-            ["la-phrase", (args, lemma) => this.parsePhrase(args, lemma)],
-            ["head", (args, lemma) => this.parseHead(args, lemma)],
-            // forms only
-            ["la-adj-form", (args, lemma) => this.parseForm(args, lemma, "adjectives")],
-            ["la-noun-form", (args, lemma) => this.parseForm(args, lemma, "nouns")],
-            ["la-proper noun-form", (args, lemma) => this.parseForm(args, lemma, "proper nouns")],
-            ["la-num-form", (args, lemma) => this.parseForm(args, lemma, "numerals")],
-            ["la-pronoun-form", (args, lemma) => this.parseForm(args, lemma, "pronouns")],
-            ["la-part-form", (args, lemma) => this.parseForm(args, lemma, "participles")],
-            ["la-verb-form", (args, lemma) => this.parseForm(args, lemma, "verbs")],
-            ["la-gerund-form", (args, lemma) => this.parseForm(args, lemma, "gerunds")],
-            ["la-suffix-form", (args, lemma) => this.parseForm(args, lemma, "suffixes")],
-            ["la-det-form", (args, lemma) => this.parseForm(args, lemma, "determiners")],
-        ]);
-        this.nominal = nominal;
-        this.conj = conj;
-        this.logger = logger;
-    }
-    isHeadwordTemplate(template) {
-        const args = (0, common_1.parse_template)(template);
-        const templateName = args.get("0");
-        if (!templateName) {
-            throw Error(`Invalid template string: ${template}`);
-        }
-        return this.templateParsers.has(templateName);
-    }
-    parse(template, lemma) {
-        const args = (0, common_1.parse_template)(template);
-        const templateName = args.get("0") || "nil";
-        const parseFunc = this.templateParsers.get(templateName);
-        if (!parseFunc) {
-            throw Error(`Not a headword template: ${template}`);
-        }
-        const data = parseFunc(args, lemma);
-        if (data.heads.length == 0) {
-            throw Error(`No heads for ${template} in ${lemma}`);
-        }
-        return data;
-    }
-    log(msg) {
-        if (this.logger) {
-            this.logger(msg);
-        }
-    }
-    parseNominalHead(args, pos) {
-        const overridePos = args.get("pos") || pos;
-        const decl = this.nominal.do_generate_noun_forms(args, overridePos, true, args.get("lemma"));
-        const isNum = (pos == "numerals");
-        let lemmata = decl.overriding_lemma;
-        const lemmaNum = (decl.num == "pl" ? "pl" : "sg");
-        if (lemmata.length == 0) {
-            lemmata = (0, NominalForm_1.getNominalForm)(decl.forms, `linked_nom_${lemmaNum}`) || [];
-        }
-        let genders = decl.overriding_genders || [];
-        if (genders.length == 0) {
-            if (decl.gender) {
-                genders = [decl.gender.toLowerCase()];
-            }
-            else if (!isNum) {
-                throw Error("Couldn't infer gender");
-            }
-        }
-        return {
-            templateType: "headword",
-            headType: "nominal",
-            partOfSpeech: pos,
-            indeclinable: args.has("indecl"),
-            data: decl,
-            heads: lemmata,
-            genders: genders,
-        };
-    }
-    parseAdjectivalHead(args, pos) {
-        const overridePos = args.get("pos") || pos;
-        const decl = this.nominal.do_generate_adj_forms(args, overridePos, true);
-        let lemmata = decl.overriding_lemma;
-        const lemmaNum = (decl.num == "pl" ? "pl" : "sg");
-        if (lemmata.length == 0) {
-            lemmata = (0, NominalForm_1.getNominalForm)(decl.forms, `linked_nom_${lemmaNum}_m`) || [];
-        }
-        return {
-            templateType: "headword",
-            headType: "adjectival",
-            partOfSpeech: pos,
-            indeclinable: args.has("indecl"),
-            data: decl,
-            heads: lemmata,
-            comparatives: decl.comp,
-            superlatives: decl.sup,
-            adverbs: decl.adv,
-        };
-    }
-    parseVerbalHead(args, pos) {
-        const conj = this.conj.make_data(args);
-        let lemma_forms = conj.data.overriding_lemma;
-        if (lemma_forms.length == 0) {
-            lemma_forms = LaVerb_1.LaVerb.get_lemma_forms(conj.data, true);
-        }
-        const infinitives = (0, VerbForm_1.getVerbForm)(conj.data.forms, "pres_actv_inf") || [];
-        return {
-            templateType: "headword",
-            headType: "verbal",
-            data: conj,
-            partOfSpeech: pos,
-            heads: lemma_forms,
-            infinitives: infinitives,
-        };
-    }
-    parseGerund(args) {
-        const gerund = args.get("1") || "";
-        const match = gerund.match(/^(.*)um$/);
-        if (!match) {
-            throw Error(`Unrecognized gerund ending in: ${gerund}`);
-        }
-        const stem = match[1];
-        const a2 = args.get("2") || "";
-        let gerundive;
-        if (a2 == "-") {
-            gerundive = undefined;
-        }
-        else {
-            gerundive = a2 || (stem + "us");
-        }
-        return {
-            templateType: "headword",
-            headType: "gerund",
-            heads: [gerund],
-            gerundive: gerundive,
-        };
-    }
-    parseComparativeAdj(args, lemma) {
-        const a1 = args.get("1");
-        const a2 = args.get("2");
-        const is_lemma = args.get("is_lemma");
-        const heads = (0, common_1.read_list)(args, "head");
-        const positive = (0, common_1.read_list)(args, "pos");
-        if (heads.length == 0) {
-            if (a1) {
-                heads.push(a1);
-            }
-            else {
-                heads.push(lemma);
-            }
-        }
-        if (positive.length == 0) {
-            if (a2) {
-                positive.push(a2);
-            }
-        }
-        const n = [];
-        for (const head of heads) {
-            if (!head.endsWith("or")) {
-                this.log(`Strange comparative head ${head} in ${lemma}`);
-            }
-            const neuter = head.replace(/or$/, "us");
-            n.push(neuter);
-        }
-        return {
-            templateType: "headword",
-            headType: "comparative",
-            isLemma: is_lemma ? true : false,
-            heads: heads,
-            neuter: n,
-            positive: positive,
-        };
-    }
-    parseSuperlativeAdj(args, lemma) {
-        const a1 = args.get("1");
-        const a2 = args.get("2");
-        const is_lemma = args.get("is_lemma");
-        const heads = (0, common_1.read_list)(args, "head");
-        const positive = (0, common_1.read_list)(args, "pos");
-        if (heads.length == 0) {
-            if (a1) {
-                heads.push(a1);
-            }
-            else {
-                heads.push(lemma);
-            }
-        }
-        if (positive.length == 0) {
-            if (a2) {
-                positive.push(a2);
-            }
-        }
-        const n = [];
-        const f = [];
-        for (const head of heads) {
-            if (!head.endsWith("us")) {
-                this.log(`Skpping invalid superlative head ${head} in ${lemma}`);
-                continue;
-            }
-            const stem = head.replace(/us$/, "");
-            f.push(stem + "a");
-            n.push(stem + "um");
-        }
-        return {
-            templateType: "headword",
-            headType: "superlative",
-            isLemma: is_lemma ? true : false,
-            heads: heads,
-            neuter: n,
-            feminine: f,
-            positive: positive,
-        };
-    }
-    parseAdverb(args, pos) {
-        const a1 = args.get("1");
-        const a2 = args.get("2");
-        const a3 = args.get("3");
-        const heads = (0, common_1.read_list)(args, "head");
-        let comp = (0, common_1.read_list)(args, "comp");
-        let sup = (0, common_1.read_list)(args, "sup");
-        if (a1) {
-            heads.push(a1);
-        }
-        if (a2) {
-            comp.push(a2);
-        }
-        if (a3) {
-            sup.push(a3);
-        }
-        if (comp.length > 0 && comp[0] == "-") {
-            sup = ["-"];
-        }
-        if (comp.length == 0 || sup.length == 0) {
-            const default_comp = [];
-            const default_sup = [];
-            for (const head of heads) {
-                let stem;
-                for (let suff of ["iter", "nter", "ter", "er", "iē", "ē", "im", "ō"]) {
-                    const match = head.match(new RegExp(`(.*)${suff}$`));
-                    if (match) {
-                        stem = match[1];
-                        if (suff == "nter") {
-                            stem = stem + "nt";
-                            suff = "er";
-                        }
-                        default_comp.push(stem + "ius");
-                        default_sup.push(stem + "issimē");
-                        break;
-                    }
-                }
-                if (!stem) {
-                    throw Error("Unrecognized adverb type");
-                }
-            }
-            if (comp.length == 0) {
-                comp = default_comp;
-            }
-            if (sup.length == 0) {
-                sup = default_sup;
-            }
-        }
-        if (comp.length > 0 && comp[0] == "-") {
-            comp = [];
-        }
-        if (sup.length > 0 && sup[0] == "-") {
-            sup = [];
-        }
-        return {
-            templateType: "headword",
-            headType: "adverb",
-            partOfSpeech: pos,
-            heads: heads,
-            comparatives: comp,
-            superlatives: sup,
-        };
-    }
-    parseAdverbNumeral(args) {
-        const a1 = args.get("1") || "";
-        const numType = args.get("type") || "";
-        return {
-            templateType: "headword",
-            headType: "numeral_adverb",
-            heads: [a1],
-            numType: numType,
-        };
-    }
-    parseAdverbCompSup(args, pos) {
-        const head = args.get("1");
-        let heads;
-        if (head) {
-            heads = [head];
-        }
-        return {
-            templateType: "headword",
-            headType: "adverb",
-            partOfSpeech: pos,
-            heads: heads || [],
-            comparatives: [],
-            superlatives: [],
-        };
-    }
-    parseLetter(args, lemma) {
-        const upper = (0, common_1.read_list)(args, "upper");
-        const lower = (0, common_1.read_list)(args, "lower");
-        const mixed = (0, common_1.read_list)(args, "mixed");
-        const sc = args.get("sc") || "";
-        if (upper.length == 0 && lower.length == 0 && mixed.length == 0) {
-            this.log(`No parameters for letter ${lemma}`);
-            upper.push(lemma);
-        }
-        return {
-            templateType: "headword",
-            headType: "letter",
-            heads: upper.concat(lower).concat(mixed),
-            upper: upper,
-            lower: lower,
-            mixed: mixed,
-            scriptCode: sc,
-        };
-    }
-    parsePreposition(args, lemma) {
-        let genitive = false;
-        let ablative = false;
-        let accusative = false;
-        const heads = (0, common_1.read_list)(args, "head");
-        for (const [key, value] of args) {
-            if (value == "genitive") {
-                genitive = true;
-            }
-            else if (value == "ablative") {
-                ablative = true;
-            }
-            else if (value == "accusative") {
-                accusative = true;
-            }
-            else {
-                if (key != "0") {
-                    heads.push(value);
-                }
-            }
-        }
-        if (heads.length == 0) {
-            heads.push(lemma);
-        }
-        return {
-            templateType: "headword",
-            headType: "preposition",
-            heads: heads,
-            genitive: genitive,
-            accusative: accusative,
-            ablative: ablative,
-        };
-    }
-    parseInterjection(args, lemma) {
-        const head = args.get("head");
-        let interj = head || args.get("1");
-        if (!interj) {
-            interj = lemma;
-        }
-        return {
-            templateType: "headword",
-            headType: "interjection",
-            heads: [interj],
-        };
-    }
-    parsePhrase(args, lemma) {
-        let phrase = args.get("1");
-        if (!phrase) {
-            phrase = lemma;
-        }
-        return {
-            templateType: "headword",
-            headType: "phrase",
-            heads: [phrase],
-        };
-    }
-    parseHead(args, lemma) {
-        const pos = args.get("2");
-        const heads = (0, common_1.read_list)(args, "head");
-        if (!pos) {
-            throw Error(`la-head without pos: ${lemma}`);
-        }
-        if (heads.length == 0) {
-            heads.push(lemma);
-        }
-        return {
-            templateType: "headword",
-            headType: "particle",
-            partOfSpeech: pos,
-            heads: heads,
-        };
-    }
-    parseForm(args, lemma, pos) {
-        let form = args.get("1");
-        if (!form) {
-            form = lemma;
-        }
-        return {
-            templateType: "headword",
-            headType: "form",
-            partOfSpeech: pos,
-            heads: [form],
-        };
-    }
-}
-exports.HeadwordParser = HeadwordParser;
-//# sourceMappingURL=HeadwordParser.js.map
+/**
+ * This is based on https://en.wiktionary.org/wiki/Module:la-headword developed by Benwing2.
+ * It was converted from Lua to TypeScript by Folke Will <folko@solhost.org>.
+ *
+ * Original source: https://en.wiktionary.org/wiki/Module:la-headword
+ *
+ * Lua idioms, function and variable names kept as in the original in order to easily
+ * backport later changes to this implementation.
+ *
+ * For that reason, it's suggested to add a type-aware wrapper around this class and leave
+ * this code unchanged instead of improving the types and use of idioms in this class.
+ *
+ */
+import { parse_template, read_list } from "../common.js";
+import { LaVerb } from "../conjugation/LaVerb.js";
+import { getVerbForm } from "../conjugation/VerbForm.js";
+import { getNominalForm } from "../declination/NominalForm.js";
+import { AdjectivalType, AdverbType, NominalPosType, VerbalType } from "./HeadWord.js";
+export class HeadwordParser {
+    templateParsers = new Map([
+        // these are parsed by la-ndecl
+        ["la-noun", args => this.parseNominalHead(args, NominalPosType.Noun)],
+        ["la-num-noun", args => this.parseNominalHead(args, NominalPosType.Numeral)],
+        ["la-suffix-noun", args => this.parseNominalHead(args, NominalPosType.Suffix)],
+        ["la-proper noun", args => this.parseNominalHead(args, NominalPosType.ProperNoun)],
+        ["la-prop", args => this.parseNominalHead(args, NominalPosType.ProperNoun)],
+        // these are parsed by la-adecl
+        ["la-adj", args => this.parseAdjectivalHead(args, AdjectivalType.Adjective)],
+        ["la-num-adj", args => this.parseAdjectivalHead(args, AdjectivalType.Numeral)],
+        ["la-suffix-adj", args => this.parseAdjectivalHead(args, AdjectivalType.Suffix)],
+        ["la-pronoun", args => this.parseAdjectivalHead(args, AdjectivalType.Pronoun)],
+        ["la-det", args => this.parseAdjectivalHead(args, AdjectivalType.Determiner)],
+        ["la-part", args => this.parseAdjectivalHead(args, AdjectivalType.Participle)],
+        // these are parsed by la-verb
+        ["la-verb", args => this.parseVerbalHead(args, VerbalType.Verb)],
+        ["la-suffix-verb", args => this.parseVerbalHead(args, VerbalType.Suffix)],
+        // these are all custom
+        ["la-gerund", (args, lemma) => this.parseGerund(args)],
+        ["la-adj-comp", (args, lemma) => this.parseComparativeAdj(args, lemma)],
+        ["la-adj-sup", (args, lemma) => this.parseSuperlativeAdj(args, lemma)],
+        ["la-adv", (args, lemma) => this.parseAdverb(args, AdverbType.Adverb)],
+        ["la-adv-comp", (args, lemma) => this.parseAdverbCompSup(args, AdverbType.Comparative)],
+        ["la-adv-sup", (args, lemma) => this.parseAdverbCompSup(args, AdverbType.Superlative)],
+        ["la-suffix-adv", (args, lemma) => this.parseAdverb(args, AdverbType.Suffix)],
+        ["la-num-adv", (args, lemma) => this.parseAdverbNumeral(args)],
+        ["la-prep", (args, lemma) => this.parsePreposition(args, lemma)],
+        ["la-letter", (args, lemma) => this.parseLetter(args, lemma)],
+        ["la-interj", (args, lemma) => this.parseInterjection(args, lemma)],
+        ["la-phrase", (args, lemma) => this.parsePhrase(args, lemma)],
+        ["head", (args, lemma) => this.parseHead(args, lemma)],
+        // forms only
+        ["la-adj-form", (args, lemma) => this.parseForm(args, lemma, "adjectives")],
+        ["la-noun-form", (args, lemma) => this.parseForm(args, lemma, "nouns")],
+        ["la-proper noun-form", (args, lemma) => this.parseForm(args, lemma, "proper nouns")],
+        ["la-num-form", (args, lemma) => this.parseForm(args, lemma, "numerals")],
+        ["la-pronoun-form", (args, lemma) => this.parseForm(args, lemma, "pronouns")],
+        ["la-part-form", (args, lemma) => this.parseForm(args, lemma, "participles")],
+        ["la-verb-form", (args, lemma) => this.parseForm(args, lemma, "verbs")],
+        ["la-gerund-form", (args, lemma) => this.parseForm(args, lemma, "gerunds")],
+        ["la-suffix-form", (args, lemma) => this.parseForm(args, lemma, "suffixes")],
+        ["la-det-form", (args, lemma) => this.parseForm(args, lemma, "determiners")],
+    ]);
+    nominal;
+    conj;
+    logger;
+    constructor(nominal, conj, logger) {
+        this.nominal = nominal;
+        this.conj = conj;
+        this.logger = logger;
+    }
+    isHeadwordTemplate(template) {
+        const args = parse_template(template);
+        const templateName = args.get("0");
+        if (!templateName) {
+            throw Error(`Invalid template string: ${template}`);
+        }
+        return this.templateParsers.has(templateName);
+    }
+    parse(template, lemma) {
+        const args = parse_template(template);
+        const templateName = args.get("0") || "nil";
+        const parseFunc = this.templateParsers.get(templateName);
+        if (!parseFunc) {
+            throw Error(`Not a headword template: ${template}`);
+        }
+        const data = parseFunc(args, lemma);
+        if (data.heads.length == 0) {
+            throw Error(`No heads for ${template} in ${lemma}`);
+        }
+        return data;
+    }
+    log(msg) {
+        if (this.logger) {
+            this.logger(msg);
+        }
+    }
+    parseNominalHead(args, pos) {
+        const overridePos = args.get("pos") || pos;
+        const decl = this.nominal.do_generate_noun_forms(args, overridePos, true, args.get("lemma"));
+        const isNum = (pos == "numerals");
+        let lemmata = decl.overriding_lemma;
+        const lemmaNum = (decl.num == "pl" ? "pl" : "sg");
+        if (lemmata.length == 0) {
+            lemmata = getNominalForm(decl.forms, `linked_nom_${lemmaNum}`) || [];
+        }
+        let genders = decl.overriding_genders || [];
+        if (genders.length == 0) {
+            if (decl.gender) {
+                genders = [decl.gender.toLowerCase()];
+            }
+            else if (!isNum) {
+                throw Error("Couldn't infer gender");
+            }
+        }
+        return {
+            templateType: "headword",
+            headType: "nominal",
+            partOfSpeech: pos,
+            indeclinable: args.has("indecl"),
+            data: decl,
+            heads: lemmata,
+            genders: genders,
+        };
+    }
+    parseAdjectivalHead(args, pos) {
+        const overridePos = args.get("pos") || pos;
+        const decl = this.nominal.do_generate_adj_forms(args, overridePos, true);
+        let lemmata = decl.overriding_lemma;
+        const lemmaNum = (decl.num == "pl" ? "pl" : "sg");
+        if (lemmata.length == 0) {
+            lemmata = getNominalForm(decl.forms, `linked_nom_${lemmaNum}_m`) || [];
+            if (lemmata.length == 0) {
+                lemmata = getNominalForm(decl.forms, `linked_nom_${lemmaNum}_n`) || [];
+            }
+            if (lemmata.length == 0) {
+                lemmata = getNominalForm(decl.forms, `linked_nom_${lemmaNum}_f`) || [];
+            }
+        }
+        return {
+            templateType: "headword",
+            headType: "adjectival",
+            partOfSpeech: pos,
+            indeclinable: args.has("indecl"),
+            data: decl,
+            heads: lemmata,
+            comparatives: decl.comp,
+            superlatives: decl.sup,
+            adverbs: decl.adv,
+        };
+    }
+    parseVerbalHead(args, pos) {
+        const conj = this.conj.make_data(args);
+        let lemma_forms = conj.data.overriding_lemma;
+        if (lemma_forms.length == 0) {
+            lemma_forms = LaVerb.get_lemma_forms(conj.data, true);
+        }
+        const infinitives = getVerbForm(conj.data.forms, "pres_actv_inf") || [];
+        return {
+            templateType: "headword",
+            headType: "verbal",
+            data: conj,
+            partOfSpeech: pos,
+            heads: lemma_forms,
+            infinitives: infinitives,
+        };
+    }
+    parseGerund(args) {
+        const gerund = args.get("1") || "";
+        const match = gerund.match(/^(.*)um$/);
+        if (!match) {
+            throw Error(`Unrecognized gerund ending in: ${gerund}`);
+        }
+        const stem = match[1];
+        const a2 = args.get("2") || "";
+        let gerundive;
+        if (a2 == "-") {
+            gerundive = undefined;
+        }
+        else {
+            gerundive = a2 || (stem + "us");
+        }
+        return {
+            templateType: "headword",
+            headType: "gerund",
+            heads: [gerund],
+            gerundive: gerundive,
+        };
+    }
+    parseComparativeAdj(args, lemma) {
+        const a1 = args.get("1");
+        const a2 = args.get("2");
+        const is_lemma = args.get("is_lemma");
+        const heads = read_list(args, "head");
+        const positive = read_list(args, "pos");
+        if (heads.length == 0) {
+            if (a1) {
+                heads.push(a1);
+            }
+            else {
+                heads.push(lemma);
+            }
+        }
+        if (positive.length == 0) {
+            if (a2) {
+                positive.push(a2);
+            }
+        }
+        const n = [];
+        for (const head of heads) {
+            if (!head.endsWith("or")) {
+                this.log(`Strange comparative head ${head} in ${lemma}`);
+            }
+            const neuter = head.replace(/or$/, "us");
+            n.push(neuter);
+        }
+        return {
+            templateType: "headword",
+            headType: "comparative",
+            isLemma: is_lemma ? true : false,
+            heads: heads,
+            neuter: n,
+            positive: positive,
+        };
+    }
+    parseSuperlativeAdj(args, lemma) {
+        const a1 = args.get("1");
+        const a2 = args.get("2");
+        const is_lemma = args.get("is_lemma");
+        const heads = read_list(args, "head");
+        const positive = read_list(args, "pos");
+        if (heads.length == 0) {
+            if (a1) {
+                heads.push(a1);
+            }
+            else {
+                heads.push(lemma);
+            }
+        }
+        if (positive.length == 0) {
+            if (a2) {
+                positive.push(a2);
+            }
+        }
+        const n = [];
+        const f = [];
+        for (const head of heads) {
+            if (!head.endsWith("us")) {
+                this.log(`Skpping invalid superlative head ${head} in ${lemma}`);
+                continue;
+            }
+            const stem = head.replace(/us$/, "");
+            f.push(stem + "a");
+            n.push(stem + "um");
+        }
+        return {
+            templateType: "headword",
+            headType: "superlative",
+            isLemma: is_lemma ? true : false,
+            heads: heads,
+            neuter: n,
+            feminine: f,
+            positive: positive,
+        };
+    }
+    parseAdverb(args, pos) {
+        const a1 = args.get("1");
+        const a2 = args.get("2");
+        const a3 = args.get("3");
+        const heads = read_list(args, "head");
+        let comp = read_list(args, "comp");
+        let sup = read_list(args, "sup");
+        if (a1) {
+            heads.push(a1);
+        }
+        if (a2) {
+            comp.push(a2);
+        }
+        if (a3) {
+            sup.push(a3);
+        }
+        if (comp.length > 0 && comp[0] == "-") {
+            sup = ["-"];
+        }
+        if (comp.length == 0 || sup.length == 0) {
+            const default_comp = [];
+            const default_sup = [];
+            for (const head of heads) {
+                let stem;
+                for (let suff of ["iter", "nter", "ter", "er", "iē", "ē", "im", "ō"]) {
+                    const match = head.match(new RegExp(`(.*)${suff}$`));
+                    if (match) {
+                        stem = match[1];
+                        if (suff == "nter") {
+                            stem = stem + "nt";
+                            suff = "er";
+                        }
+                        default_comp.push(stem + "ius");
+                        default_sup.push(stem + "issimē");
+                        break;
+                    }
+                }
+                if (!stem) {
+                    throw Error("Unrecognized adverb type");
+                }
+            }
+            if (comp.length == 0) {
+                comp = default_comp;
+            }
+            if (sup.length == 0) {
+                sup = default_sup;
+            }
+        }
+        if (comp.length > 0 && comp[0] == "-") {
+            comp = [];
+        }
+        if (sup.length > 0 && sup[0] == "-") {
+            sup = [];
+        }
+        return {
+            templateType: "headword",
+            headType: "adverb",
+            partOfSpeech: pos,
+            heads: heads,
+            comparatives: comp,
+            superlatives: sup,
+        };
+    }
+    parseAdverbNumeral(args) {
+        const a1 = args.get("1") || "";
+        const numType = args.get("type") || "";
+        return {
+            templateType: "headword",
+            headType: "numeral_adverb",
+            heads: [a1],
+            numType: numType,
+        };
+    }
+    parseAdverbCompSup(args, pos) {
+        const head = args.get("1");
+        let heads;
+        if (head) {
+            heads = [head];
+        }
+        return {
+            templateType: "headword",
+            headType: "adverb",
+            partOfSpeech: pos,
+            heads: heads || [],
+            comparatives: [],
+            superlatives: [],
+        };
+    }
+    parseLetter(args, lemma) {
+        const upper = read_list(args, "upper");
+        const lower = read_list(args, "lower");
+        const mixed = read_list(args, "mixed");
+        const sc = args.get("sc") || "";
+        if (upper.length == 0 && lower.length == 0 && mixed.length == 0) {
+            this.log(`No parameters for letter ${lemma}`);
+            upper.push(lemma);
+        }
+        return {
+            templateType: "headword",
+            headType: "letter",
+            heads: upper.concat(lower).concat(mixed),
+            upper: upper,
+            lower: lower,
+            mixed: mixed,
+            scriptCode: sc,
+        };
+    }
+    parsePreposition(args, lemma) {
+        let genitive = false;
+        let ablative = false;
+        let accusative = false;
+        const heads = read_list(args, "head");
+        for (const [key, value] of args) {
+            if (value == "genitive") {
+                genitive = true;
+            }
+            else if (value == "ablative") {
+                ablative = true;
+            }
+            else if (value == "accusative") {
+                accusative = true;
+            }
+            else {
+                if (key != "0") {
+                    heads.push(value);
+                }
+            }
+        }
+        if (heads.length == 0) {
+            heads.push(lemma);
+        }
+        return {
+            templateType: "headword",
+            headType: "preposition",
+            heads: heads,
+            genitive: genitive,
+            accusative: accusative,
+            ablative: ablative,
+        };
+    }
+    parseInterjection(args, lemma) {
+        const head = args.get("head");
+        let interj = head || args.get("1");
+        if (!interj) {
+            interj = lemma;
+        }
+        return {
+            templateType: "headword",
+            headType: "interjection",
+            heads: [interj],
+        };
+    }
+    parsePhrase(args, lemma) {
+        let phrase = args.get("1");
+        if (!phrase) {
+            phrase = lemma;
+        }
+        return {
+            templateType: "headword",
+            headType: "phrase",
+            heads: [phrase],
+        };
+    }
+    parseHead(args, lemma) {
+        const pos = args.get("2");
+        const heads = read_list(args, "head");
+        if (!pos) {
+            throw Error(`la-head without pos: ${lemma}`);
+        }
+        if (heads.length == 0) {
+            heads.push(lemma);
+        }
+        return {
+            templateType: "headword",
+            headType: "particle",
+            partOfSpeech: pos,
+            heads: heads,
+        };
+    }
+    parseForm(args, lemma, pos) {
+        let form = args.get("1");
+        if (!form) {
+            form = lemma;
+        }
+        return {
+            templateType: "headword",
+            headType: "form",
+            partOfSpeech: pos,
+            heads: [form],
+        };
+    }
+}