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

package/dist/modules/declination/LaNominal.js

@@ -1,1804 +1,1884 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LaNominal = exports.NumberTantum = exports.Gender = void 0;
-/**
- * This is a complete re-implementation of Wiktionary's Module:la-nominal, 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-nominal
- * Based on version: https://en.wiktionary.org/w/index.php?title=Module:la-nominal&oldid=68766664
- *
- * 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 LaAdjData_1 = require("./LaAdjData");
-const LaNounData_1 = require("./LaNounData");
-const NominalForm_1 = require("./NominalForm");
-const NominalType_1 = require("./NominalType");
-var Gender;
-(function (Gender) {
-    Gender["M"] = "M";
-    Gender["F"] = "F";
-    Gender["N"] = "N";
-})(Gender = exports.Gender || (exports.Gender = {}));
-var NumberTantum;
-(function (NumberTantum) {
-    NumberTantum["Singular"] = "sg";
-    NumberTantum["Plural"] = "pl";
-    NumberTantum["Both"] = "both";
-})(NumberTantum = exports.NumberTantum || (exports.NumberTantum = {}));
-class LaNominal {
-    constructor(options) {
-        this.cases = ["nom", "gen", "dat", "acc", "abl", "voc", "loc"];
-        this.genders = ["m", "f", "n"];
-        this.nums = ["sg", "pl"];
-        this.linked_prefixes = ["", "linked_"];
-        this.potential_noun_lemma_slots = ["nom_sg", "nom_pl"];
-        this.potential_adj_lemma_slots = [
-            "nom_sg_m",
-            "nom_pl_m",
-            "nom_sg_f",
-            "nom_pl_f",
-            "nom_sg_n",
-            "nom_pl_n"
-        ];
-        this.irreg_adj_to_decl = new Map([
-            ["duo", "irreg+"],
-            ["ambō", "irreg+"],
-            ["mīlle", "3-1+"],
-            ["plūs", "3-1+"],
-            ["is", "1&2+"],
-            ["īdem", "1&2+"],
-            ["ille", "1&2+"],
-            ["ipse", "1&2+"],
-            ["iste", "1&2+"],
-            ["quis", "irreg+"],
-            ["quī", "irreg+"],
-            ["quisquis", "irreg+"],
-        ]);
-        this.irreg_noun_to_decl = new Map([
-            ["bōs", "3"],
-            ["cherub", "irreg"],
-            ["deus", "2"],
-            ["Deus", "2"],
-            ["domus", "4,2"],
-            ["Iēsus", "4"],
-            ["Jēsus", "4"],
-            ["Iēsūs", "4"],
-            ["Jēsūs", "4"],
-            ["iūgerum", "2,3"],
-            ["jūgerum", "2,3"],
-            ["sūs", "3"],
-            ["ēthos", "3"],
-            ["Athōs", "2"],
-            ["lexis", "3"],
-            ["vēnum", "4,2"],
-            ["vīs", "3"],
-        ]);
-        this.declension_to_english = new Map([
-            ["1", "first"],
-            ["2", "second"],
-            ["3", "third"],
-            ["4", "fourth"],
-            ["5", "fifth"],
-        ]);
-        this.options = options || {};
-    }
-    do_generate_noun_forms(args, pos = "nouns", from_headword = false, title) {
-        var _a;
-        this.title = title;
-        const parsed_run = this.parse_segment_run_allowing_alternants(((_a = args.get("1")) === null || _a === void 0 ? void 0 : _a.trim()) || "");
-        parsed_run.loc = parsed_run.loc || args.has("loc_sg") || args.has("loc_pl");
-        let num = args.get("num");
-        if (num !== undefined && !(0, common_1.is_enum_value)(NumberTantum, num)) {
-            num = undefined;
-        }
-        parsed_run.num = num || parsed_run.num;
-        const declensions = this.decline_segment_run(parsed_run, pos, false);
-        if (!parsed_run.loc) {
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_sg", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_pl", undefined);
-        }
-        declensions.title = [this.construct_title(args.get("title"), declensions.title.join(""), false, parsed_run)];
-        const all_data = {
-            templateType: "declension",
-            declensionType: "noun",
-            title: declensions.title.join(" "),
-            num: parsed_run.num,
-            gender: parsed_run.gender,
-            propses: parsed_run.propses,
-            forms: declensions.forms,
-            categories: declensions.categories,
-            notes: new Map(),
-            user_specified: new Set(),
-            pos: pos,
-            num_type: args.get("type"),
-            // only if headword
-            indecl: args.has("indecl"),
-            m: (0, common_1.read_list)(args, "m"),
-            f: (0, common_1.read_list)(args, "f"),
-            overriding_lemma: (0, common_1.read_list)(args, "lemma"),
-            overriding_genders: (0, common_1.read_list)(args, "g")
-        };
-        for (const slot of this.iter_noun_slots()) {
-            const noteses = declensions.notes.get(slot);
-            if (noteses) {
-                noteses.forEach((notes, index) => {
-                    all_data.notes.set(`${slot}${index + 1}`, notes);
-                });
-            }
-        }
-        this.process_noun_forms_and_overrides(all_data, args);
-        return all_data;
-    }
-    do_generate_adj_forms(args, pos = "adjectives", from_headword = false, title) {
-        var _a;
-        this.title = title;
-        let segment_run = ((_a = args.get("1")) === null || _a === void 0 ? void 0 : _a.trim()) || "";
-        if (!segment_run.match(/[<(]/)) {
-            segment_run = segment_run + (args.has("indecl") ? "<0+>" : "<+>");
-        }
-        const parsed_run = this.parse_segment_run_allowing_alternants(segment_run);
-        parsed_run.loc = parsed_run.loc || (args.has("loc_sg_m") || args.has("loc_sg_f") || args.has("loc_sg_n") || args.has("loc_pl_m") || args.has("loc_pl_f") || args.has("loc_pl_n"));
-        let num = args.get("num");
-        if (num !== undefined && !(0, common_1.is_enum_value)(NumberTantum, num)) {
-            num = undefined;
-        }
-        parsed_run.num = num || parsed_run.num;
-        const overriding_voc = (args.has("voc_sg_m") || args.has("voc_sg_f") || args.has("voc_sg_n") || args.has("voc_pl_m") || args.has("voc_pl_f") || args.has("voc_pl_n"));
-        const declensions = this.decline_segment_run(parsed_run, pos, true);
-        if (!parsed_run.loc) {
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_sg_m", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_sg_f", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_sg_n", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_pl_m", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_pl_f", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "loc_pl_n", undefined);
-        }
-        if (!overriding_voc && !declensions.voc) {
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "voc_sg_m", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "voc_sg_f", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "voc_sg_n", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "voc_pl_m", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "voc_pl_f", undefined);
-            (0, NominalForm_1.setNominalForm)(declensions.forms, "voc_pl_n", undefined);
-        }
-        declensions.title = [this.construct_title(args.get("title"), declensions.title.join(""), from_headword, parsed_run)];
-        const all_data = {
-            templateType: "declension",
-            declensionType: "adjective",
-            title: declensions.title.join(""),
-            num: parsed_run.num,
-            propses: parsed_run.propses,
-            forms: declensions.forms,
-            categories: declensions.categories,
-            notes: new Map(),
-            user_specified: new Set(),
-            voc: declensions.voc,
-            noneut: args.has("noneut") || declensions.noneut,
-            nomf: args.has("nomf") || declensions.nomf,
-            pos: pos,
-            num_type: args.get("type"),
-            // only if headword
-            overriding_lemma: (0, common_1.read_list)(args, "lemma"),
-            indecl: args.has("indecl"),
-            comp: (0, common_1.read_list)(args, "comp"),
-            sup: (0, common_1.read_list)(args, "sup"),
-            adv: (0, common_1.read_list)(args, "adv")
-        };
-        for (const slot of this.iter_adj_slots()) {
-            const noteses = declensions.notes.get(slot);
-            if (noteses) {
-                noteses.forEach((notes, index) => {
-                    all_data.notes.set(`${slot}${index + 1}`, notes);
-                });
-            }
-        }
-        this.process_adj_forms_and_overrides(all_data, args);
-        return all_data;
-    }
-    construct_title(args_title, declensions_title, from_headword, parsed_run) {
-        if (args_title) {
-            declensions_title = args_title.replace("<1>", "first declension");
-            declensions_title = declensions_title.replace("<1&2>", "first/second declension");
-            declensions_title = declensions_title.replace("<2>", "second declension");
-            declensions_title = declensions_title.replace("<3>", "third declension");
-            declensions_title = declensions_title.replace("<4>", "fourth declension");
-            declensions_title = declensions_title.replace("<5>", "fifth declension");
-            if (from_headword) {
-                declensions_title = declensions_title[0].toLowerCase() + declensions_title.replace(/\.$/, "").substr(1);
-            }
-            else {
-                if (declensions_title.startsWith(" ")) {
-                    declensions_title = declensions_title.substr(1);
-                }
-                declensions_title = declensions_title[0].toUpperCase() + declensions_title.substr(1);
-            }
-        }
-        else {
-            const post_text_parts = [];
-            if (parsed_run.loc) {
-                post_text_parts.push(", with locative");
-            }
-            if (parsed_run.num == "sg") {
-                post_text_parts.push(", singular only");
-            }
-            else if (parsed_run.num == "pl") {
-                post_text_parts.push(", plural only");
-            }
-            const post_text = post_text_parts.join("");
-            if (from_headword) {
-                declensions_title = declensions_title[0].toLowerCase() + declensions_title.substr(1) + post_text;
-            }
-            else {
-                if (declensions_title.length > 0) {
-                    declensions_title = declensions_title[0].toUpperCase() + declensions_title.substr(1) + post_text + ".";
-                }
-            }
-        }
-        return declensions_title;
-    }
-    process_noun_forms_and_overrides(data, args) {
-        var _a, _b;
-        const linked_to_non_linked_noun_slots = new Map();
-        for (const slot of this.potential_noun_lemma_slots) {
-            linked_to_non_linked_noun_slots.set("linked_" + slot, slot);
-        }
-        for (const slot of this.iter_noun_slots()) {
-            let val = [];
-            if (args.has(slot)) {
-                val = ((_a = args.get(slot)) === null || _a === void 0 ? void 0 : _a.split("/")) || [];
-                data.user_specified.add(slot);
-            }
-            else {
-                const non_linked_equiv_slot = linked_to_non_linked_noun_slots.get(slot);
-                if (non_linked_equiv_slot && args.has(non_linked_equiv_slot)) {
-                    val = ((_b = args.get(non_linked_equiv_slot)) === null || _b === void 0 ? void 0 : _b.split("/")) || [];
-                    data.user_specified.add(slot);
-                }
-                else {
-                    val = (0, NominalForm_1.getNominalForm)(data.forms, slot) || [];
-                }
-            }
-            if (val) {
-                if ((data.num == "pl" && slot.includes("sg")) || (data.num == "sg" && slot.includes("pl"))) {
-                    (0, NominalForm_1.setNominalForm)(data.forms, slot, [""]);
-                }
-                else if (val[0] == "" || val[0] == "-" || val[0] == "—") {
-                    (0, NominalForm_1.setNominalForm)(data.forms, slot, [LaNominal.EmptyForm]);
-                }
-                else {
-                    (0, NominalForm_1.setNominalForm)(data.forms, slot, val);
-                }
-            }
-        }
-    }
-    process_adj_forms_and_overrides(data, args) {
-        var _a;
-        const linked_to_non_linked_adj_slots = new Map();
-        for (const slot of this.potential_adj_lemma_slots) {
-            linked_to_non_linked_adj_slots.set("linked_" + slot, slot);
-        }
-        for (const slot of this.iter_adj_slots()) {
-            if (data.noneut && slot.match(/_n/)) {
-                (0, NominalForm_1.setNominalForm)(data.forms, slot, undefined);
-            }
-            if (data.nomf && (slot.match(/_m/) || slot.match(/_f/))) {
-                (0, NominalForm_1.setNominalForm)(data.forms, slot, undefined);
-            }
-            let val;
-            const ovr = args.get(slot);
-            if (ovr) {
-                val = ovr.split("/");
-                data.user_specified.add(slot);
-            }
-            else {
-                const non_linked_equiv_slot = linked_to_non_linked_adj_slots.get(slot);
-                if (non_linked_equiv_slot && args.has(non_linked_equiv_slot)) {
-                    val = ((_a = args.get(non_linked_equiv_slot)) === null || _a === void 0 ? void 0 : _a.split("/")) || [];
-                    data.user_specified.add(slot);
-                }
-                else {
-                    val = (0, NominalForm_1.getNominalForm)(data.forms, slot);
-                }
-            }
-            if (val) {
-                if ((data.num == "pl" && slot.match(/sg/)) || (data.num == "sg" && slot.match(/pl/))) {
-                    (0, NominalForm_1.setNominalForm)(data.forms, slot, undefined);
-                }
-                else if (val[0] == "" || val[0] == "-" || val[0] == "—") {
-                    (0, NominalForm_1.setNominalForm)(data.forms, slot, [LaNominal.EmptyForm]);
-                }
-                else {
-                    (0, NominalForm_1.setNominalForm)(data.forms, slot, val);
-                }
-            }
-        }
-        for (const gender of ["f", "n"]) {
-            let other_is_masc = true;
-            for (const cas of this.cases) {
-                for (const num of this.nums) {
-                    const genderForm = (0, NominalForm_1.getNominalForm)(data.forms, cas + "_" + num + "_" + gender);
-                    const amscForm = (0, NominalForm_1.getNominalForm)(data.forms, cas + "_" + num + "_m");
-                    if (!(0, common_1.array_equals)(genderForm, amscForm)) {
-                        other_is_masc = false;
-                        break;
-                    }
-                }
-                if (!other_is_masc) {
-                    break;
-                }
-            }
-            if (other_is_masc && !this.options.populateAllTerminations) {
-                for (const cas of this.cases) {
-                    for (const num of this.nums) {
-                        (0, NominalForm_1.setNominalForm)(data.forms, cas + "_" + num + "_" + gender, undefined);
-                    }
-                }
-            }
-        }
-    }
-    iter_slots(is_adj, overridable_only = false) {
-        if (is_adj) {
-            return this.iter_adj_slots(overridable_only);
-        }
-        else {
-            return this.iter_noun_slots(overridable_only);
-        }
-    }
-    iter_adj_slots(overridable_only = false) {
-        let cas = 1;
-        let num = 1;
-        let gen = 1;
-        let linked_variant = 0;
-        const entries = [];
-        while (true) {
-            linked_variant = linked_variant + 1;
-            let max_linked_variant;
-            if (overridable_only) {
-                max_linked_variant = 1;
-            }
-            else {
-                if (this.cases[cas - 1] == "nom" && this.genders[gen - 1] == "m") {
-                    max_linked_variant = 2;
-                }
-                else {
-                    max_linked_variant = 1;
-                }
-            }
-            if (linked_variant > max_linked_variant) {
-                linked_variant = 1;
-                gen++;
-                if (gen > this.genders.length) {
-                    gen = 1;
-                    num++;
-                    if (num > this.nums.length) {
-                        num = 1;
-                        cas++;
-                        if (cas > this.cases.length) {
-                            break;
-                        }
-                    }
-                }
-            }
-            entries.push(this.linked_prefixes[linked_variant - 1] + this.cases[cas - 1] + "_" + this.nums[num - 1] + "_" + this.genders[gen - 1]);
-        }
-        return entries;
-    }
-    iter_noun_slots(overridable_only = false) {
-        let cas = 1;
-        let num = 1;
-        let linked_variant = 0;
-        const entries = [];
-        while (true) {
-            linked_variant = linked_variant + 1;
-            let max_linked_variant = 1;
-            if (!overridable_only) {
-                if (this.cases[cas - 1] == "nom") {
-                    max_linked_variant = 2;
-                }
-            }
-            if (linked_variant > max_linked_variant) {
-                linked_variant = 1;
-                num++;
-                if (num > this.nums.length) {
-                    num = 1;
-                    cas++;
-                    if (cas > this.cases.length) {
-                        break;
-                    }
-                }
-            }
-            entries.push(this.linked_prefixes[linked_variant - 1] + this.cases[cas - 1] + "_" + this.nums[num - 1]);
-        }
-        return entries;
-    }
-    parse_segment_run_allowing_alternants(segment_run) {
-        const alternating_segments = this.capturing_split(segment_run, /(\(\(.*?\)\))/);
-        const parsed_segments = [];
-        let loc = false;
-        let num;
-        let gender;
-        let is_adj;
-        const propses = [];
-        for (let i = 0; i < alternating_segments.length; i++) {
-            const alternating_segment = alternating_segments[i];
-            let this_is_adj;
-            if (alternating_segment) {
-                if (i % 2 == 0) {
-                    const parsed_run = this.parse_segment_run(alternating_segment);
-                    for (const parsed_segment of parsed_run.segments) {
-                        parsed_segments.push(parsed_segment);
-                    }
-                    loc = loc || parsed_run.loc;
-                    num = num || parsed_run.num;
-                    gender = gender || parsed_run.gender;
-                    this_is_adj = parsed_run.is_adj;
-                    for (const prop of parsed_run.propses) {
-                        propses.push(prop);
-                    }
-                }
-                else {
-                    const parsed_alternating_segment = this.parse_alternant(alternating_segment);
-                    parsed_segments.push(parsed_alternating_segment);
-                    loc = loc || parsed_alternating_segment.loc;
-                    num = num || parsed_alternating_segment.num;
-                    gender = gender || parsed_alternating_segment.gender;
-                    this_is_adj = parsed_alternating_segment.is_adj;
-                    propses.push(...parsed_alternating_segment.propses);
-                }
-            }
-            if (is_adj === undefined) {
-                is_adj = this_is_adj;
-            }
-            else if (this_is_adj !== undefined) {
-                is_adj = is_adj && this_is_adj;
-            }
-        }
-        return {
-            segments: parsed_segments,
-            loc: loc,
-            num: num,
-            gender: gender,
-            is_adj: is_adj,
-            propses: propses,
-        };
-    }
-    parse_alternant(alternant) {
-        const parsed_alternants = [];
-        const alternant_spec = alternant.match(/^\(\((.*)\)\)$/);
-        let loc = false;
-        let num;
-        let gender;
-        let is_adj;
-        const propses = [];
-        if (!alternant_spec) {
-            throw Error(`Invalid alternant spec`);
-        }
-        const alternants = alternant_spec[1].split(",");
-        alternants.forEach((altr, i) => {
-            const parsed_run = this.parse_segment_run(altr);
-            parsed_alternants.push(parsed_run);
-            loc = loc || parsed_run.loc;
-            if (i == 0) {
-                num = parsed_run.num;
-            }
-            else if (num != parsed_run.num) {
-                num = NumberTantum.Both;
-            }
-            gender = gender || parsed_run.gender;
-            if (is_adj === undefined) {
-                is_adj = parsed_run.is_adj;
-            }
-            else if (parsed_run.is_adj !== undefined && parsed_run.is_adj !== is_adj) {
-                throw Error(`Saw both noun and adjective alternants; not allowed`);
-            }
-            propses.push(...parsed_run.propses);
-        });
-        return {
-            type: "Alternant",
-            alternants: parsed_alternants,
-            loc: loc,
-            num: num,
-            gender: gender,
-            is_adj: is_adj,
-            propses: propses,
-        };
-    }
-    parse_segment_run(segment_run) {
-        const is_suffix = segment_run.startsWith("-");
-        const segments = [];
-        const bracketed_segments = this.capturing_split(segment_run, /(\[\[[^\[\]]-\]\]<.*?>)/);
-        bracketed_segments.forEach((bracketed_segment, i) => {
-            if (i % 2 == 1) {
-                segments.push(bracketed_segment);
-            }
-            else {
-                let regex;
-                if (is_suffix) {
-                    regex = /([^<> ,]+<.*?>)/;
-                }
-                else {
-                    regex = /([^<> ,\-]+<.*?>)/;
-                }
-                for (const subsegment of this.capturing_split(bracketed_segment, regex)) {
-                    segments.push(subsegment);
-                }
-            }
-        });
-        let loc = false;
-        let num;
-        let gender;
-        let is_adj;
-        const propses = [];
-        const parsed_segments = [];
-        for (let i = 1; i < segments.length; i += 2) {
-            const parsed_segment = this.parse_segment(segments[i]);
-            loc = loc || parsed_segment.loc;
-            num = num || parsed_segment.num;
-            if (is_adj === undefined) {
-                is_adj = parsed_segment.is_adj;
-            }
-            else {
-                is_adj = is_adj && parsed_segment.is_adj;
-            }
-            gender = gender || parsed_segment.gender;
-            parsed_segment.orig_prefix = segments[i - 1];
-            parsed_segment.prefix = (0, common_1.remove_links)(segments[i - 1]);
-            parsed_segments.push(parsed_segment);
-            const props = {
-                decl: parsed_segment.decl,
-                headword_decl: parsed_segment.headword_decl,
-                types: parsed_segment.types,
-            };
-            propses.push(props);
-        }
-        if (segments[segments.length - 1]) {
-            parsed_segments.push({
-                type: "Segment",
-                args: [],
-                decl: "",
-                headword_decl: "",
-                is_adj: false,
-                lemma: "",
-                orig_lemma: "",
-                loc: false,
-                types: new Set(),
-                orig_prefix: segments[segments.length - 1],
-                prefix: (0, common_1.remove_links)(segments[segments.length - 1])
-            });
-        }
-        return {
-            segments: parsed_segments,
-            loc: loc,
-            num: num,
-            gender: gender,
-            propses: propses,
-        };
-    }
-    capturing_split(str, pattern) {
-        return str.split(pattern);
-    }
-    parse_segment(segment) {
-        const match = segment.match(/^(.*)<(.*?)>$/);
-        if (!match) {
-            throw Error("No match");
-        }
-        const stem_part = match[1];
-        const spec_part = match[2];
-        const stems = stem_part.split("/");
-        const specs = spec_part.split(".");
-        const types = new Set();
-        let num;
-        let loc = false;
-        let decl = "";
-        for (let j = 0; j < specs.length; j++) {
-            let spec = specs[j];
-            if (j == 0) {
-                decl = spec;
-            }
-            else {
-                const m2 = spec.match(/^(-?)(.*?)$/);
-                if (m2) {
-                    const begins_with_hypen = m2[1];
-                    spec = m2[2];
-                    spec = begins_with_hypen + spec.replace(/-/g, "_");
-                    if (spec) {
-                        (0, NominalType_1.addNominalType)(types, spec);
-                    }
-                }
-            }
-        }
-        const orig_lemma = stems[0] || this.title;
-        if (!orig_lemma) {
-            throw Error("No lemma");
-        }
-        const lemma = (0, common_1.remove_links)(orig_lemma);
-        let stem2 = stems[1];
-        if (stems.length > 2) {
-            throw Error(`Too many stems, at most 2 should be give: ${stem_part}`);
-        }
-        let is_adj = false;
-        let headword_decl;
-        let base;
-        let detected_subtypes;
-        if (decl.match(/\+/)) {
-            decl = decl.replace(/\+/g, "");
-            [base, stem2, decl, detected_subtypes] = this.detect_adj_type_and_subtype(lemma, stem2, decl, types);
-            is_adj = true;
-            const irreg = this.irreg_adj_to_decl.get(lemma);
-            if (irreg) {
-                headword_decl = `irreg/${irreg}`;
-            }
-            else {
-                headword_decl = decl + "+";
-            }
-            for (const subtype of detected_subtypes) {
-                if ((0, NominalType_1.hasNominalType)(types, "-" + subtype)) {
-                    (0, NominalType_1.delNominalType)(types, "-" + subtype);
-                }
-                else {
-                    types.add(subtype);
-                }
-            }
-        }
-        else {
-            [base, stem2, detected_subtypes] = this.detect_noun_subtype(lemma, stem2, decl, types);
-            const irreg = this.irreg_noun_to_decl.get(lemma);
-            if (irreg) {
-                headword_decl = `irreg/${irreg}`;
-            }
-            else {
-                headword_decl = decl;
-            }
-            for (const subtype of detected_subtypes) {
-                if ((0, NominalType_1.hasNominalType)(types, "-" + subtype)) {
-                    (0, NominalType_1.delNominalType)(types, "-" + subtype);
-                }
-                else if ((subtype == NominalType_1.NominalType.Masculine || subtype == NominalType_1.NominalType.Feminine || subtype == NominalType_1.NominalType.Neuter) &&
-                    (types.has(NominalType_1.NominalType.Masculine) || types.has(NominalType_1.NominalType.Feminine) || types.has(NominalType_1.NominalType.Neuter))) {
-                    // don't create conflicting gender specs
-                }
-                else if ((subtype == NominalType_1.NominalType.Singular || subtype == NominalType_1.NominalType.Plural || subtype == NominalType_1.NominalType.Both) &&
-                    (types.has(NominalType_1.NominalType.Singular) || types.has(NominalType_1.NominalType.Plural) || types.has(NominalType_1.NominalType.Both))) {
-                    // don't create conflicting number restrictions
-                }
-                else {
-                    types.add(subtype);
-                }
-            }
-            if (!types.has(NominalType_1.NominalType.Plural) && !types.has(NominalType_1.NominalType.Both) && lemma.match(/^[A-ZĀĒĪŌŪȲĂĔĬŎŬ]/)) {
-                types.add(NominalType_1.NominalType.Singular);
-            }
-        }
-        if (types.has(NominalType_1.NominalType.Locative)) {
-            loc = true;
-            types.delete(NominalType_1.NominalType.Locative);
-        }
-        let gender;
-        if (types.has(NominalType_1.NominalType.Masculine)) {
-            gender = Gender.M;
-        }
-        else if (types.has(NominalType_1.NominalType.Feminine)) {
-            gender = Gender.F;
-        }
-        else if (types.has(NominalType_1.NominalType.Neuter)) {
-            gender = Gender.N;
-        }
-        if (types.has(NominalType_1.NominalType.Plural)) {
-            num = NumberTantum.Plural;
-            types.delete(NominalType_1.NominalType.Plural);
-        }
-        else if (types.has(NominalType_1.NominalType.Singular)) {
-            num = NumberTantum.Singular;
-            types.delete(NominalType_1.NominalType.Singular);
-        }
-        const args = [base, stem2];
-        return {
-            type: "Segment",
-            decl: decl,
-            headword_decl: headword_decl,
-            is_adj: is_adj,
-            gender: gender,
-            orig_lemma: orig_lemma,
-            lemma: lemma,
-            stem2: stem2,
-            types: types,
-            num: num,
-            loc: loc,
-            args: args,
-        };
-    }
-    detect_adj_type_and_subtype(lemma, stem2, typ, subtypes) {
-        if (!typ.match(/^[0123]/) && !typ.match(/^irreg/) && typ) {
-            subtypes = new Set(subtypes);
-            (0, NominalType_1.addNominalType)(subtypes, typ);
-            typ = "";
-        }
-        function base_as_stem2(base, stem2x) {
-            return ["foo", base];
-        }
-        function constant_base(baseval) {
-            return (base, s2) => [baseval, ""];
-        }
-        function decl12_stem2(base) {
-            return base;
-        }
-        function decl3_stem2(base) {
-            return LaNominal.make_stem2(base);
-        }
-        const decl12_entries = [
-            ["us", "1&2", []],
-            ["a", "1&2", []],
-            ["um", "1&2", []],
-            ["ī", "1&2", [NominalType_1.NominalType.Plural]],
-            ["ae", "1&2", [NominalType_1.NominalType.Plural]],
-            ["a", "1&2", [NominalType_1.NominalType.Plural]],
-            ["os", "1&2", [NominalType_1.NominalType.GreekA, NominalType_1.NominalType.NoGreekE]],
-            ["os", "1&2", [NominalType_1.NominalType.GreekE, NominalType_1.NominalType.NoGreekA]],
-            ["ē", "1&2", [NominalType_1.NominalType.GreekE, NominalType_1.NominalType.NoGreekA]],
-            ["on", "1&2", [NominalType_1.NominalType.GreekA, NominalType_1.NominalType.NoGreekE]],
-            ["on", "1&2", [NominalType_1.NominalType.GreekE, NominalType_1.NominalType.NoGreekA]],
-            ["^(.*er)$", "1&2", [NominalType_1.NominalType.Er]],
-            ["^(.*ur)$", "1&2", [NominalType_1.NominalType.Er]],
-            ["^(h)ic$", "1&2", [NominalType_1.NominalType.Ic]],
-        ];
-        const decl3_entries = [
-            ["^(.*er)$", "3-3", []],
-            ["is", "3-2", []],
-            ["e", "3-2", []],
-            ["^(.*[ij])or$", "3-C", []],
-            ["^(min)or$", "3-C", []],
-            ["^(.*ēs)$", "3-1", [NominalType_1.NominalType.I]],
-            ["^(.*ēs)$", "3-1", [NominalType_1.NominalType.Par]],
-            ["^(.*[ij])ōrēs$", "3-C", [NominalType_1.NominalType.Plural]],
-            ["^(min)ōrēs$", "3-C", [NominalType_1.NominalType.Plural]],
-            ["ēs", "3-2", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.I]],
-            ["ēs", "3-1", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.Par], base_as_stem2],
-            ["ia", "3-2", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.I]],
-            ["a", "3-1", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.Par], base_as_stem2],
-            ["", "3-1", [NominalType_1.NominalType.I]],
-            ["", "3-1", [NominalType_1.NominalType.Par]],
-        ];
-        if (!typ) {
-            const [base, new_stem2, rettype, new_subtypes] = this.get_adj_type_and_subtype_by_ending(lemma, stem2, undefined, subtypes, decl12_entries, decl12_stem2);
-            if (base) {
-                return [base, new_stem2, rettype, new_subtypes];
-            }
-            else {
-                return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, decl3_entries, decl3_stem2);
-            }
-        }
-        else if (typ == "0") {
-            return [lemma, "", "0", []];
-        }
-        else if (typ == "3") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, decl3_entries, decl3_stem2);
-        }
-        else if (typ == "1&2") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, decl12_entries, decl12_stem2);
-        }
-        else if (typ == "1-1") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["a", "1-1", []],
-                ["ae", "1-1", [NominalType_1.NominalType.Plural]]
-            ]);
-        }
-        else if (typ == "2-2") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["us", "2-2", []],
-                ["um", "2-2", []],
-                ["ī", "2-2", [NominalType_1.NominalType.Plural]],
-                ["a", "2-2", [NominalType_1.NominalType.Plural]],
-                ["os", "2-2", [NominalType_1.NominalType.greek]],
-                ["on", "2-2", [NominalType_1.NominalType.greek]],
-                ["oe", "2-2", [NominalType_1.NominalType.greek, NominalType_1.NominalType.Plural]],
-            ]);
-        }
-        else if (typ == "3-1") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["^(.*ēs)$", "3-1", [NominalType_1.NominalType.I]],
-                ["^(.*ēs)$", "3-1", [NominalType_1.NominalType.Par]],
-                ["ēs", "3-1", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.I], base_as_stem2],
-                ["ēs", "3-1", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.Par], base_as_stem2],
-                ["ia", "3-1", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.I], base_as_stem2],
-                ["a", "3-1", [NominalType_1.NominalType.Plural, NominalType_1.NominalType.Par], base_as_stem2],
-                ["", "3-1", [NominalType_1.NominalType.I]],
-                ["", "3-1", [NominalType_1.NominalType.Par]],
-            ], decl3_stem2);
-        }
-        else if (typ == "3-2") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["is", "3-2", []],
-                ["e", "3-2", []],
-                ["ēs", "3-2", []],
-                ["ēs", "3-2", [NominalType_1.NominalType.Plural]],
-                ["ia", "3-2", [NominalType_1.NominalType.Plural]],
-            ], decl3_stem2);
-        }
-        else if (typ == "3-C") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["^(.*[ij])or$", "3-C", []],
-                ["^(min)or$", "3-C", []],
-                ["^(.*[ij])ōrēs$", "3-C", [NominalType_1.NominalType.Plural]],
-                ["^(min)ōrēs$", "3-C", [NominalType_1.NominalType.Plural]],
-            ], decl3_stem2);
-        }
-        else if (typ == "irreg") {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["^(duo)$", typ, [NominalType_1.NominalType.Plural]],
-                ["^(ambō)$", typ, [NominalType_1.NominalType.Plural]],
-                ["^(mīll?ia)$", typ, [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Plural], constant_base("mīlle")],
-                ["^(ea)$", typ, [], constant_base("is")],
-                ["^(id)$", typ, [], constant_base("is")],
-                ["^([ei]ī)$", typ, [NominalType_1.NominalType.Plural], constant_base("is")],
-                ["^(eae?)$", typ, [NominalType_1.NominalType.Plural], constant_base("is")],
-                ["^(eadem)$", typ, [], constant_base("īdem")],
-                ["^([īi]dem)$", typ, [], constant_base("īdem")],
-                ["^(īdem)$", typ, [NominalType_1.NominalType.Plural]],
-                ["^(eae?dem)$", typ, [NominalType_1.NominalType.Plural], constant_base("īdem")],
-                ["^(i[lps][lst])a$", typ, [], (base, s2) => [base + "e", ""]],
-                ["^(i[ls][lt])ud$", typ, [], (base, s2) => [base + "e", ""]],
-                ["^(ipsum)$", typ, [], constant_base("ipse")],
-                ["^(i[lps][lst])ī$", typ, [NominalType_1.NominalType.Plural], (base, s2) => [base + "e", ""]],
-                ["^(i[lps][lst])ae?$", typ, [NominalType_1.NominalType.Plural], (base, s2) => [base + "e", ""]],
-                ["^(quī)$", typ, []],
-                ["^(quī)$", typ, [NominalType_1.NominalType.Plural]],
-                ["^(quae)$", typ, [], constant_base("quī")],
-                ["^(quae)$", typ, [NominalType_1.NominalType.Plural], constant_base("quī")],
-                ["^(quid)$", typ, [], constant_base("quis")],
-                ["^(quod)$", typ, [], constant_base("quī")],
-                ["^(qui[cd]quid)$", typ, [], constant_base("quisquis")],
-                ["^(quīquī)$", typ, [NominalType_1.NominalType.Plural], constant_base("quisquis")],
-                ["^(quaequae)$", typ, [NominalType_1.NominalType.Plural], constant_base("quisquis")],
-                ["", typ, []],
-            ]);
-        }
-        else {
-            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["ēs", typ, [NominalType_1.NominalType.Plural], base_as_stem2],
-                ["ia", typ, [NominalType_1.NominalType.Plural], base_as_stem2],
-                ["", typ, []],
-            ], decl3_stem2);
-        }
-    }
-    get_adj_type_and_subtype_by_ending(lemma, stem2, decltype, specified_subtypes, endings_and_subtypes, process_stem2) {
-        for (const [ending, rettype, subtypes, process_retval] of endings_and_subtypes) {
-            let not_this_subtype = false;
-            if (specified_subtypes.has(NominalType_1.NominalType.Plural) && !subtypes.includes(NominalType_1.NominalType.Plural)) {
-                not_this_subtype = true;
-            }
-            else {
-                for (const subtype of subtypes) {
-                    if (!subtype.startsWith("-") && (0, NominalType_1.hasNominalType)(specified_subtypes, "-" + subtype)) {
-                        not_this_subtype = true;
-                        break;
-                    }
-                    const must_not_be_present = subtype.match(/^-(.*)$/);
-                    if (must_not_be_present && (0, NominalType_1.hasNominalType)(specified_subtypes, must_not_be_present[1])) {
-                        not_this_subtype = true;
-                        break;
-                    }
-                }
-            }
-            if (!not_this_subtype) {
-                let base;
-                if (typeof (ending) != "string") {
-                    const lemma_ending = ending[0];
-                    const stem2_ending = ending[1];
-                    base = (0, common_1.extract_base)(lemma, lemma_ending);
-                    if (base && base + stem2_ending != stem2) {
-                        base = undefined;
-                    }
-                }
-                else {
-                    base = (0, common_1.extract_base)(lemma, ending);
-                }
-                if (base !== undefined) {
-                    const new_subtypes = [];
-                    for (const subtype of subtypes) {
-                        if (!subtype.startsWith("-")) {
-                            new_subtypes.push(subtype);
-                        }
-                    }
-                    if (process_retval) {
-                        [base, stem2] = process_retval(base, stem2);
-                    }
-                    if (process_stem2) {
-                        stem2 = stem2 || process_stem2(base);
-                    }
-                    return [base, stem2, rettype, new_subtypes];
-                }
-            }
-        }
-        if (decltype === undefined) {
-            return ["", "", "", []];
-        }
-        else if (decltype == "") {
-            throw Error(`Unrecognized ending for adjective: ${lemma}`);
-        }
-        else {
-            throw Error(`Unrecognized ending for declension-${decltype} adjective: ${lemma}`);
-        }
-    }
-    detect_noun_subtype(lemma, stem2, typ, subtypes) {
-        if (typ == "1") {
-            return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["ām", [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Am]],
-                ["ās", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Greek, NominalType_1.NominalType.Ma]],
-                ["ēs", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Greek, NominalType_1.NominalType.Me]],
-                ["ē", [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Greek]],
-                ["ae", [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Plural]],
-                ["a", [NominalType_1.NominalType.Feminine]],
-            ]);
-        }
-        else if (typ == "2") {
-            let detected_subtypes;
-            [lemma, stem2, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["^(.*r)$", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Er]],
-                ["^(.*v)os$", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Vos]],
-                ["^(.*v)om$", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Vom]],
-                ["os", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Greek]],
-                ["os", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Greek, NominalType_1.NominalType.Us]],
-                ["on", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Greek]],
-                ["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*)ius$", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Ius, NominalType_1.NominalType.VocI, NominalType_1.NominalType.Singular]],
-                [NominalType_1.NominalType.Ius, [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Ius]],
-                [NominalType_1.NominalType.Ium, [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Ium]],
-                [NominalType_1.NominalType.Us, [NominalType_1.NominalType.Masculine]],
-                [NominalType_1.NominalType.Us, [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Us]],
-                ["um", [NominalType_1.NominalType.Neuter]],
-                ["iī", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Ius, NominalType_1.NominalType.Plural]],
-                ["ia", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Ium, NominalType_1.NominalType.Plural]],
-                ["ī", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Plural]],
-                ["ī", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Us, NominalType_1.NominalType.Plural]],
-                ["a", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Plural]],
-            ]);
-            stem2 = stem2 || lemma;
-            return [lemma, stem2, detected_subtypes];
-        }
-        else if (typ == "3") {
-            let match;
-            if (subtypes.has(NominalType_1.NominalType.Plural)) {
-                if (subtypes.has(NominalType_1.NominalType.Greek)) {
-                    match = lemma.match(/^(.*)erēs$/);
-                    if (match) {
-                        return [match[1] + "ēr", match[1] + "er", new Set([NominalType_1.NominalType.Er])];
-                    }
-                    match = lemma.match(/^(.*)ontēs$/);
-                    if (match) {
-                        return [match[1] + "ōn", match[1] + "ont", new Set([NominalType_1.NominalType.On])];
-                    }
-                    match = lemma.match(/^(.*)es$/);
-                    if (match) {
-                        return ["foo", stem2 || match[1], new Set()];
-                    }
-                    throw Error(`Unrecognized ending for declension-3 plural Greek noun: ${lemma}`);
-                }
-                match = lemma.match(/^(.*)ia$/);
-                if (match) {
-                    return ["foo", stem2 || match[1], new Set([NominalType_1.NominalType.Neuter, NominalType_1.NominalType.I, NominalType_1.NominalType.Pure])];
-                }
-                match = lemma.match(/^(.*)a$/);
-                if (match) {
-                    return ["foo", stem2 || match[1], new Set([NominalType_1.NominalType.Neuter])];
-                }
-                match = lemma.match(/^(.*)ēs$/);
-                if (match) {
-                    return ["foo", stem2 || match[1], new Set()];
-                }
-                throw Error(`Unrecognized ending for declension-3 plural noun: ${lemma}`);
-            }
-            stem2 = stem2 || LaNominal.make_stem2(lemma);
-            let detected_subtypes;
-            let base;
-            let tmp;
-            if (subtypes.has(NominalType_1.NominalType.Greek)) {
-                [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
-                    [["is", ""], [NominalType_1.NominalType.I]],
-                    ["ēr", [NominalType_1.NominalType.Er]],
-                    ["ōn", [NominalType_1.NominalType.On]],
-                ]);
-                if (base) {
-                    return [lemma, stem2, detected_subtypes];
-                }
-                return [lemma, stem2, new Set()];
-            }
-            if (!subtypes.has(NominalType_1.NominalType.Neuter)) {
-                [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
-                    [["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*pol)is$", ""], [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Polis, NominalType_1.NominalType.Singular, NominalType_1.NominalType.Locative]],
-                    [["tūdō", "tūdin"], [NominalType_1.NominalType.Feminine]],
-                    [["tās", "tāt"], [NominalType_1.NominalType.Feminine]],
-                    [["tūs", "tūt"], [NominalType_1.NominalType.Feminine]],
-                    [["tiō", "tiōn"], [NominalType_1.NominalType.Feminine]],
-                    [["siō", "siōn"], [NominalType_1.NominalType.Feminine]],
-                    [["xiō", "xiōn"], [NominalType_1.NominalType.Feminine]],
-                    [["gō", "gin"], [NominalType_1.NominalType.Feminine]],
-                    [["or", "ōr"], [NominalType_1.NominalType.Masculine]],
-                    [["trīx", "trīc"], [NominalType_1.NominalType.Feminine]],
-                    [["trix", "trīc"], [NominalType_1.NominalType.Feminine]],
-                    [["is", ""], [NominalType_1.NominalType.I]],
-                    [["^([a-zāēīōūȳăĕĭŏŭ].*)ēs$", ""], [NominalType_1.NominalType.I]],
-                ]);
-                if (base) {
-                    return [lemma, stem2, detected_subtypes];
-                }
-            }
-            [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
-                [["us", "or"], [NominalType_1.NominalType.Neuter]],
-                [["us", "er"], [NominalType_1.NominalType.Neuter]],
-                [["ma", "mat"], [NominalType_1.NominalType.Neuter]],
-                [["men", "min"], [NominalType_1.NominalType.Neuter]],
-                [["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*)e$", ""], [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Singular]],
-                [["e", ""], [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.I, NominalType_1.NominalType.Pure]],
-                [["al", "āl"], [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.I, NominalType_1.NominalType.Pure]],
-                [["ar", "ār"], [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.I, NominalType_1.NominalType.Pure]],
-            ]);
-            if (base) {
-                return [lemma, stem2, detected_subtypes];
-            }
-            return [lemma, stem2, new Set()];
-        }
-        else if (typ == "4") {
-            if (subtypes.has(NominalType_1.NominalType.Echo) || subtypes.has(NominalType_1.NominalType.argo) || subtypes.has(NominalType_1.NominalType.Callisto)) {
-                const match = lemma.match(/^(.*)ō$/);
-                if (!match) {
-                    throw Error(`Declension-4 noun of subtype .echo, .argo or .Callisto should end in -ō: ${lemma}`);
-                }
-                const base = match[1];
-                if (subtypes.has(NominalType_1.NominalType.Callisto)) {
-                    return [base, "", new Set([NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Singular])];
-                }
-                else {
-                    return [base, "", new Set([NominalType_1.NominalType.Feminine])];
-                }
-            }
-            return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["us", [NominalType_1.NominalType.Masculine]],
-                ["ū", [NominalType_1.NominalType.Neuter]],
-                ["ūs", [NominalType_1.NominalType.Masculine, NominalType_1.NominalType.Plural]],
-                ["ua", [NominalType_1.NominalType.Neuter, NominalType_1.NominalType.Plural]],
-            ]);
-        }
-        else if (typ == "5") {
-            return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["iēs", [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.i]],
-                ["iēs", [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.i, NominalType_1.NominalType.Plural]],
-                ["ēs", [NominalType_1.NominalType.Feminine]],
-                ["ēs", [NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Plural]],
-            ]);
-        }
-        else if (typ == "irreg" && lemma == "domus") {
-            return [lemma, "", new Set([NominalType_1.NominalType.Locative])];
-        }
-        else if (typ == "indecl" || (typ == "irreg" && (lemma == "Deus" || lemma == "Iēsus" || lemma == "Jēsus" || lemma == "Athōs" || lemma == "vēnum"))) {
-            return [lemma, "", new Set([NominalType_1.NominalType.Singular])];
-        }
-        else {
-            return [lemma, "", new Set()];
-        }
-    }
-    static make_stem2(stem) {
-        const patterns = [
-            ["tūdō", "tūdin"],
-            ["is", ""],
-            ["ēs", ""],
-            ["āns", "ant"],
-            ["ēns", "ent"],
-            ["ōns", "ont"],
-            ["ceps", "cipit"],
-            ["us", "or"],
-            ["ex", "ic"],
-            ["ma", "mat"],
-            ["e", ""],
-            ["al", "āl"],
-            ["ar", "ār"],
-            ["men", "min"],
-            ["er", "r"],
-            ["or", "ōr"],
-            ["gō", "gin"],
-            ["ō", "ōn"],
-            ["ps", "p"],
-            ["bs", "b"],
-            ["s", "t"],
-            ["x", "c"],
-        ];
-        for (const pattern of patterns) {
-            const key = pattern[0];
-            const val = pattern[1];
-            if (stem.match(new RegExp(key + "$"))) {
-                return stem.replace(new RegExp(key + "$"), val);
-            }
-        }
-        return stem;
-    }
-    get_noun_subtype_by_ending(lemma, stem2, decltype, specified_subtypes, endings_and_subtypes) {
-        for (const ending_and_subtype of endings_and_subtypes) {
-            const ending = ending_and_subtype[0];
-            const subtypes = ending_and_subtype[1];
-            let not_this_subtype = false;
-            if (specified_subtypes.has(NominalType_1.NominalType.Plural) && !subtypes.includes(NominalType_1.NominalType.Plural)) {
-                not_this_subtype = true;
-            }
-            else {
-                for (const subtype of subtypes) {
-                    if ((0, NominalType_1.hasNominalType)(specified_subtypes, "-" + subtype) ||
-                        (subtype == NominalType_1.NominalType.Neuter && (specified_subtypes.has(NominalType_1.NominalType.Masculine) || specified_subtypes.has(NominalType_1.NominalType.Feminine))) ||
-                        ((subtype == NominalType_1.NominalType.Masculine || subtype == NominalType_1.NominalType.Feminine) && specified_subtypes.has(NominalType_1.NominalType.Neuter)) ||
-                        (subtype == NominalType_1.NominalType.Singular && specified_subtypes.has(NominalType_1.NominalType.Plural)) ||
-                        (subtype == NominalType_1.NominalType.Plural && specified_subtypes.has(NominalType_1.NominalType.Singular))) {
-                        not_this_subtype = true;
-                        break;
-                    }
-                }
-            }
-            if (!not_this_subtype) {
-                if (Array.isArray(ending)) {
-                    const lemma_ending = ending[0];
-                    const stem2_ending = ending[1];
-                    const base = (0, common_1.extract_base)(lemma, lemma_ending);
-                    if (base && (base + stem2_ending) == stem2) {
-                        return [base, stem2, new Set(subtypes)];
-                    }
-                }
-                else {
-                    const base = (0, common_1.extract_base)(lemma, ending);
-                    if (base) {
-                        return [base, stem2, new Set(subtypes)];
-                    }
-                }
-            }
-        }
-        if (decltype) {
-            throw Error(`Unrecognized ending for declension-${decltype} noun: ${lemma}`);
-        }
-        return ["", "", new Set()];
-    }
-    decline_segment_run(parsed_run, pos, is_adj) {
-        const declensions = {
-            forms: new Map(),
-            notes: new Map(),
-            title: [],
-            subtitleses: [],
-            orig_titles: [],
-            categories: [],
-            voc: true,
-            noneut: false,
-            nomf: false,
-        };
-        for (const slot of this.iter_slots(is_adj)) {
-            (0, NominalForm_1.setNominalForm)(declensions.forms, slot, [""]);
-        }
-        for (const seg of parsed_run.segments) {
-            if (seg.type == "Segment" && seg.decl) {
-                seg.loc = parsed_run.loc;
-                seg.num = seg.num || parsed_run.num;
-                seg.gender = seg.gender || parsed_run.gender;
-                let data;
-                let potential_lemma_slots;
-                if (seg.is_adj) {
-                    const decline = LaAdjData_1.m_adj_decl.get(seg.decl);
-                    if (!decline) {
-                        throw Error(`Unrecognized declension '${seg.decl}'`);
-                    }
-                    potential_lemma_slots = this.potential_adj_lemma_slots;
-                    data = {
-                        declOpts: this.options,
-                        subtitles: [],
-                        footnote: "",
-                        num: seg.num,
-                        gender: seg.gender,
-                        loc: seg.loc,
-                        voc: true,
-                        noneut: false,
-                        nomf: false,
-                        pos: is_adj ? pos : "adjectives",
-                        forms: new Map(),
-                        types: seg.types,
-                        categories: [],
-                        notes: new Map(),
-                    };
-                    decline(data, seg.args);
-                    if (!data.voc) {
-                        declensions.voc = false;
-                    }
-                    if (data.noneut) {
-                        declensions.noneut = true;
-                    }
-                    if (data.nomf) {
-                        declensions.nomf = true;
-                    }
-                    if (data.types.has(NominalType_1.NominalType.SuffixN)) {
-                        data.subtitles.push(["with", " 'm' optionally → 'n' in compounds"]);
-                    }
-                    else if (data.types.has(NominalType_1.NominalType.NotSuffixN)) {
-                        data.subtitles.push(["without", " 'm' optionally → 'n' in compounds"]);
-                    }
-                    if (data.title) {
-                        declensions.orig_titles.push(data.title);
-                    }
-                    if (data.subtitles.length > 0) {
-                        const subtitles = [];
-                        for (const subtitle of data.subtitles) {
-                            if (typeof (subtitle) == "string") {
-                                subtitles.push(subtitle);
-                            }
-                            else {
-                                subtitles.push(subtitle.join(""));
-                            }
-                        }
-                        data.title = data.title + " (" + subtitles.join(", ") + ")";
-                    }
-                    for (const subtitle of data.subtitles) {
-                        declensions.subtitleses.push(subtitle);
-                    }
-                }
-                else {
-                    const decline = LaNounData_1.m_noun_decl.get(seg.decl);
-                    if (!decline) {
-                        throw Error(`Unrecognized declension '${seg.decl}'`);
-                    }
-                    potential_lemma_slots = this.potential_noun_lemma_slots;
-                    data = {
-                        declOpts: this.options,
-                        subtitles: [],
-                        footnote: "",
-                        num: seg.num,
-                        loc: seg.loc,
-                        pos: pos,
-                        forms: new Map(),
-                        types: seg.types,
-                        categories: [],
-                        notes: new Map(),
-                    };
-                    decline(data, seg.args);
-                    if (!data.title) {
-                        const match = seg.headword_decl.match(/^irreg\/(.*)$/);
-                        let apparent_decl;
-                        if (match) {
-                            apparent_decl = match[1];
-                            if (data.subtitles.length == 0) {
-                                data.subtitles.push("irregular");
-                            }
-                        }
-                        else {
-                            apparent_decl = seg.headword_decl;
-                        }
-                        const english = this.declension_to_english.get(apparent_decl);
-                        if (english) {
-                            data.title = `${english}-declension`;
-                        }
-                        else if (apparent_decl == "irreg") {
-                            data.title = "irregular";
-                        }
-                        else if (apparent_decl == "indecl" || apparent_decl == "0") {
-                            data.title = "indeclinable";
-                        }
-                        else {
-                            throw Error(`Internal error! Don't recognize noun declension ${apparent_decl}`);
-                        }
-                        data.title = data.title + " noun";
-                    }
-                    if (data.types.has(NominalType_1.NominalType.SuffixN)) {
-                        data.subtitles.push(["with", " 'm' optionally → 'n' in compounds"]);
-                    }
-                    else if (data.types.has(NominalType_1.NominalType.NotSuffixN)) {
-                        data.subtitles.push(["without", " 'm' optionally → 'n' in compounds"]);
-                    }
-                    declensions.orig_titles.push(data.title);
-                    if (data.subtitles.length > 0) {
-                        const subtitles = [];
-                        for (const subtitle of data.subtitles) {
-                            if (typeof (subtitle) == "string") {
-                                subtitles.push(subtitle);
-                            }
-                            else {
-                                subtitles.push(subtitle.join(""));
-                            }
-                        }
-                        data.title = data.title + ` (${subtitles.join(", ")})`;
-                    }
-                    for (const subtitle of data.subtitles) {
-                        declensions.subtitleses.push(subtitle);
-                    }
-                }
-                for (const slot of potential_lemma_slots) {
-                    const forms = (0, NominalForm_1.getNominalForm)(data.forms, slot);
-                    if (forms) {
-                        const linked_forms = [];
-                        for (const form of forms) {
-                            if (form == seg.lemma) {
-                                linked_forms.push(seg.orig_lemma);
-                            }
-                            else {
-                                linked_forms.push(form);
-                            }
-                        }
-                        (0, NominalForm_1.setNominalForm)(data.forms, `linked_${slot}`, linked_forms);
-                    }
-                }
-                if (seg.types.has(NominalType_1.NominalType.Ligature)) {
-                    this.apply_ligatures(data.forms, is_adj);
-                }
-                if (seg.types.has(NominalType_1.NominalType.SuffixN)) {
-                    this.apply_sufn(data.forms, is_adj);
-                }
-                this.propagate_number_restrictions(data.forms, seg.num, is_adj);
-                for (const slot of this.iter_slots(is_adj)) {
-                    let new_forms;
-                    if (is_adj) {
-                        if (!seg.is_adj) {
-                            throw Error(`Can't decline noun '${seg.lemma}' when overall term is an adjective`);
-                        }
-                        new_forms = (0, NominalForm_1.getNominalForm)(data.forms, slot);
-                        if (!new_forms && slot.match(/_[fn]$/)) {
-                            new_forms = (0, NominalForm_1.getNominalForm)(data.forms, slot.replace(/_[fn]$/, "_m"));
-                        }
-                    }
-                    else if (seg.is_adj) {
-                        if (!seg.gender) {
-                            throw Error(`Declining modifying adjective ${seg.lemma} but don't know gender of associated noun`);
-                        }
-                        new_forms = (0, NominalForm_1.getNominalForm)(data.forms, slot + "_" + seg.gender.toLowerCase()) ||
-                            (0, NominalForm_1.getNominalForm)(data.forms, slot + "_m");
-                    }
-                    else {
-                        new_forms = (0, NominalForm_1.getNominalForm)(data.forms, slot);
-                    }
-                    const new_notes = [];
-                    if (new_forms) {
-                        for (let j = 0; j < new_forms.length; j++) {
-                            const noteses = data.notes.get(`${slot}${j + 1}`);
-                            if (noteses) {
-                                new_notes[j] = [noteses];
-                            }
-                        }
-                    }
-                    const oldForms = (0, NominalForm_1.getNominalForm)(declensions.forms, slot);
-                    const [forms, notes] = this.append_form(oldForms, declensions.notes.get(slot), new_forms, new_notes, slot.includes("linked") ? seg.orig_prefix : seg.prefix);
-                    (0, NominalForm_1.setNominalForm)(declensions.forms, slot, forms);
-                    declensions.notes.set(slot, notes);
-                }
-                if (!seg.types.has(NominalType_1.NominalType.NoCategories) && (is_adj || !seg.is_adj)) {
-                    for (const cat of data.categories) {
-                        this.insert_if_not(declensions.categories, cat);
-                    }
-                }
-                if (seg.prefix != "" && seg.prefix != "-" && seg.prefix != " ") {
-                    declensions.title.push("indeclinable portion");
-                }
-                if (data.title) {
-                    declensions.title.push(data.title);
-                }
-            }
-            else if (seg.type == "Alternant") {
-                let seg_declensions;
-                const seg_titles = [];
-                const seg_subtitleses = [];
-                const seg_stems_seen = [];
-                const seg_categories = [];
-                let title_the_hard_way = false;
-                let alternant_decl = "";
-                let alternant_decl_title;
-                for (const this_parsed_run of seg.alternants) {
-                    let num_non_constant_segments = 0;
-                    for (const segment of (this_parsed_run.segments)) {
-                        if (segment.type == "Segment" && segment.decl) {
-                            if (!alternant_decl) {
-                                alternant_decl = segment.decl;
-                            }
-                            else if (alternant_decl != segment.decl) {
-                                title_the_hard_way = true;
-                                num_non_constant_segments = 500;
-                                break;
-                            }
-                            num_non_constant_segments++;
-                        }
-                    }
-                    if (num_non_constant_segments != 1) {
-                        title_the_hard_way = true;
-                    }
-                }
-                if (!title_the_hard_way) {
-                    const subtypeses = new Set();
-                    for (const this_parsed_run of seg.alternants) {
-                        for (const segment of this_parsed_run.segments) {
-                            if (segment.type == "Segment" && segment.decl) {
-                                segment.types.forEach(t => subtypeses.add(t));
-                                this.insert_if_not(seg_stems_seen, segment.stem2 || "");
-                            }
-                        }
-                    }
-                    for (const this_parsed_run of seg.alternants) {
-                        for (const segment of this_parsed_run.segments) {
-                            if (segment.type == "Segment" && segment.decl) {
-                                const neg_subtypes = this.set_difference(subtypeses, segment.types);
-                                for (const neg_subtype of neg_subtypes) {
-                                    (0, NominalType_1.addNominalType)(segment.types, "not_" + neg_subtype);
-                                }
-                            }
-                        }
-                    }
-                }
-                for (const this_parsed_run of seg.alternants) {
-                    this_parsed_run.loc = seg.loc;
-                    this_parsed_run.num = this_parsed_run.num || seg.num;
-                    this_parsed_run.gender = this_parsed_run.gender || seg.gender;
-                    const this_declensions = this.decline_segment_run(this_parsed_run, pos, is_adj);
-                    if (!this_declensions.voc) {
-                        declensions.voc = false;
-                    }
-                    if (this_declensions.noneut) {
-                        declensions.noneut = true;
-                    }
-                    if (this_declensions.nomf) {
-                        declensions.nomf = true;
-                    }
-                    if (this_parsed_run.num == "sg" || this_parsed_run.num == "pl") {
-                        for (const slot of (this.iter_slots(is_adj))) {
-                            if ((this_parsed_run.num == "sg" && slot.includes("pl")) ||
-                                (this_parsed_run.num == "pl" && slot.includes("sg"))) {
-                                (0, NominalForm_1.setNominalForm)(this_declensions.forms, slot, []);
-                                this_declensions.notes.set(slot, []);
-                            }
-                        }
-                    }
-                    if (!seg_declensions) {
-                        seg_declensions = this_declensions;
-                    }
-                    else {
-                        for (const slot of this.iter_slots(is_adj)) {
-                            const curforms = (0, NominalForm_1.getNominalForm)(seg_declensions.forms, slot) || [];
-                            const newforms = (0, NominalForm_1.getNominalForm)(this_declensions.forms, slot) || [];
-                            const newform_index_to_new_index = [];
-                            newforms.forEach((form, newj) => {
-                                let did_break = false;
-                                for (let j = 0; j < curforms.length; j++) {
-                                    if (curforms[j] == form) {
-                                        newform_index_to_new_index[newj] = j;
-                                        did_break = true;
-                                        break;
-                                    }
-                                }
-                                if (!did_break) {
-                                    curforms.push(form);
-                                    newform_index_to_new_index[newj] = curforms.length - 1;
-                                }
-                            });
-                            (0, NominalForm_1.setNominalForm)(seg_declensions.forms, slot, curforms);
-                            const curnotes = seg_declensions.notes.get(slot) || [];
-                            const newnotes = this_declensions.notes.get(slot);
-                            if (newnotes) {
-                                newnotes.forEach((notes, index) => {
-                                    const combined_index = newform_index_to_new_index[index];
-                                    if (!curnotes[combined_index]) {
-                                        curnotes[combined_index] = notes;
-                                    }
-                                    else {
-                                        const combined = Array.from(curnotes[combined_index]);
-                                        for (const note of newnotes) {
-                                            this.insert_if_not(combined, newnotes);
-                                        }
-                                        curnotes[combined_index] = combined;
-                                    }
-                                });
-                            }
-                        }
-                    }
-                    for (const cat of this_declensions.categories) {
-                        this.insert_if_not(seg_categories, cat);
-                    }
-                    this.insert_if_not(seg_titles, this_declensions.title.join(""));
-                    seg_subtitleses.push(this_declensions.subtitleses);
-                    if (!alternant_decl_title) {
-                        alternant_decl_title = this_declensions.orig_titles[0];
-                    }
-                }
-                if (!seg_declensions) {
-                    throw Error("No segment declensions");
-                }
-                this.propagate_number_restrictions(seg_declensions === null || seg_declensions === void 0 ? void 0 : seg_declensions.forms, parsed_run.num, is_adj);
-                for (const slot of this.iter_slots(is_adj)) {
-                    const declForms = (0, NominalForm_1.getNominalForm)(declensions.forms, slot);
-                    const segForms = (0, NominalForm_1.getNominalForm)(seg_declensions.forms, slot);
-                    const [newForms, notes] = this.append_form(declForms, declensions.notes.get(slot), segForms, seg_declensions.notes.get(slot), undefined);
-                    (0, NominalForm_1.setNominalForm)(declensions.forms, slot, newForms);
-                    declensions.notes.set(slot, notes);
-                }
-                if (is_adj || !seg.is_adj) {
-                    for (const cat of seg_categories) {
-                        this.insert_if_not(declensions.categories, cat);
-                    }
-                }
-                let title_to_insert;
-                if (title_the_hard_way) {
-                    title_to_insert = this.join_sentences(seg_titles, " or ");
-                }
-                else {
-                    const first = seg_subtitleses[0];
-                    if (typeof (first) == "string") {
-                        throw Error("Expected multi-title");
-                    }
-                    const first_subtitles = first;
-                    let num_common_subtitles = first_subtitles.length;
-                    for (let i = 1; i < seg_subtitleses.length; i++) {
-                        const this_subtitles = seg_subtitleses[i];
-                        for (let j = 0; j < num_common_subtitles; j++) {
-                            if (first_subtitles[j] != this_subtitles[j]) {
-                                num_common_subtitles = j;
-                                break;
-                            }
-                        }
-                    }
-                    const common_subtitles = [];
-                    for (let i = 0; i < num_common_subtitles; i++) {
-                        const entry = first_subtitles[i];
-                        if (typeof (entry) != "string") {
-                            common_subtitles.push(entry.join(""));
-                        }
-                        else {
-                            common_subtitles.push(entry);
-                        }
-                    }
-                    const common_subtitle_portion = common_subtitles.join(", ");
-                    let non_common_subtitle_portion;
-                    let common_prefix;
-                    let common_suffix;
-                    for (let i = 0; i < seg_subtitleses.length; i++) {
-                        const this_subtitles = seg_subtitleses[i];
-                        if (typeof (this_subtitles) == "string") {
-                            throw Error("Expected subtitles to be array");
-                        }
-                        if (this_subtitles.length != num_common_subtitles + 1 || typeof (this_subtitles[num_common_subtitles]) == "string" || this_subtitles[num_common_subtitles].length != 2) {
-                            break;
-                        }
-                        if (i == 0) {
-                            common_prefix = this_subtitles[num_common_subtitles][0];
-                            common_suffix = this_subtitles[num_common_subtitles][1];
-                        }
-                        else {
-                            const this_prefix = this_subtitles[num_common_subtitles][0];
-                            const this_suffix = this_subtitles[num_common_subtitles][1];
-                            if (this_prefix != common_prefix) {
-                                common_prefix = undefined;
-                            }
-                            if (this_suffix != common_suffix) {
-                                common_suffix = undefined;
-                            }
-                            if (!common_prefix && !common_suffix) {
-                                break;
-                            }
-                        }
-                    }
-                    if (common_prefix || common_suffix) {
-                        if (common_prefix && common_suffix) {
-                            throw Error("Something is wrong, first non-common subtitle is actually common to all segments");
-                        }
-                        if (common_prefix) {
-                            const non_common_parts = [];
-                            for (const subtitles of seg_subtitleses) {
-                                non_common_parts.push(subtitles[num_common_subtitles][1]);
-                            }
-                            non_common_subtitle_portion = common_prefix + non_common_parts.join(" or ");
-                        }
-                        else {
-                            const non_common_parts = [];
-                            for (const subtitles of seg_subtitleses) {
-                                non_common_parts.push(subtitles[num_common_subtitles][0]);
-                            }
-                            non_common_subtitle_portion = non_common_parts.join(" or ") + common_suffix;
-                        }
-                    }
-                    else {
-                        let saw_non_common_subtitles = false;
-                        const non_common_subtitles = [];
-                        for (const this_subtitles of seg_subtitleses) {
-                            const this_non_common_subtitles = [];
-                            for (let j = num_common_subtitles; j < this_subtitles.length; j++) {
-                                this_non_common_subtitles.push(this_subtitles[j]);
-                            }
-                            if (this_non_common_subtitles.length > 0) {
-                                non_common_subtitles.push(this_non_common_subtitles.join(", "));
-                                saw_non_common_subtitles = true;
-                            }
-                            else {
-                                non_common_subtitles.push("otherwise");
-                            }
-                        }
-                        non_common_subtitle_portion = saw_non_common_subtitles ? non_common_subtitles.join(" or ") : "";
-                    }
-                    const subtitle_portions = [];
-                    if (common_subtitle_portion) {
-                        subtitle_portions.push(common_subtitle_portion);
-                    }
-                    if (non_common_subtitle_portion) {
-                        subtitle_portions.push(non_common_subtitle_portion);
-                    }
-                    if (seg_stems_seen.length > 1) {
-                        const number_to_english = [
-                            "zero", "one", "two", "three", "four", "five"
-                        ];
-                        subtitle_portions.push((number_to_english[seg_stems_seen.length] || `${seg_stems_seen.length}`) + " different stems");
-                    }
-                    const subtitle_portion = subtitle_portions.join("; ");
-                    if (subtitle_portion) {
-                        title_to_insert = alternant_decl_title + " (" + subtitle_portion + ")";
-                    }
-                    else {
-                        title_to_insert = alternant_decl_title;
-                    }
-                }
-                if (title_to_insert) {
-                    declensions.title.push(title_to_insert);
-                }
-            }
-            else {
-                for (const slot of this.iter_slots(is_adj)) {
-                    const prefix = slot.includes("linked") ? seg.orig_prefix : seg.prefix;
-                    const [forms, notes] = this.append_form((0, NominalForm_1.getNominalForm)(declensions.forms, slot), declensions.notes.get(slot), [prefix || ""], undefined, undefined);
-                    (0, NominalForm_1.setNominalForm)(declensions.forms, slot, forms);
-                    declensions.notes.set(slot, notes);
-                }
-                declensions.title.push("indeclinable portion");
-            }
-        }
-        const titles = [];
-        declensions.title.forEach((title, i) => {
-            if (i == 0) {
-                titles.push(title[0].toUpperCase() + title.substr(1));
-            }
-            else {
-                titles.push(this.add_indefinite_article(title));
-            }
-        });
-        declensions.title = [titles.join(" with ")];
-        return declensions;
-    }
-    add_indefinite_article(text) {
-        if (text.match(/^[aeiou]/i)) {
-            return `an ${text}`;
-        }
-        else {
-            return `a ${text}`;
-        }
-    }
-    join_sentences(sentences, joiner) {
-        const sentences_to_join = [];
-        sentences.forEach((sentence, i) => {
-            if (i < sentences.length - 1) {
-                sentence = sentence.replace(/\.$/, "");
-            }
-            if (i > 0) {
-                sentence = sentence[0].toLowerCase() + sentence.substr(1);
-            }
-            sentences_to_join.push(sentence);
-        });
-        return sentences_to_join.join(joiner);
-    }
-    set_difference(a, b) {
-        const res = new Set();
-        for (const key of a.keys()) {
-            if (!b.has(key)) {
-                res.add(key);
-            }
-        }
-        return res;
-    }
-    append_form(forms, notes, new_forms, new_notes, prefix) {
-        forms = forms || [];
-        new_forms = new_forms || [];
-        notes = notes || [];
-        new_notes = new_notes || [];
-        prefix = prefix || "";
-        if (new_forms.length == 1) {
-            for (let i = 0; i < forms.length; i++) {
-                forms[i] = forms[i] + prefix + new_forms[0];
-                if (new_notes[0]) {
-                    if (!notes[i]) {
-                        notes[i] = new_notes[0];
-                    }
-                    else {
-                        const combined_notes = Array.from(notes[i]);
-                        for (const note of new_notes[0]) {
-                            combined_notes.push(note);
-                        }
-                        notes[i] = combined_notes;
-                    }
-                }
-            }
-            return [forms, notes];
-        }
-        else {
-            const ret_forms = [];
-            const ret_notes = [];
-            for (let i = 0; i < forms.length; i++) {
-                for (let j = 0; j < new_forms.length; j++) {
-                    ret_forms.push(forms[i] + prefix + new_forms[j]);
-                    if (new_notes[j]) {
-                        if (!notes[i]) {
-                            ret_notes[i * new_forms.length + j] = new_notes[j];
-                        }
-                        else {
-                            const combined_notes = Array.from(notes[i]);
-                            for (const note of new_notes[j]) {
-                                combined_notes.push(note);
-                            }
-                            ret_notes[i * new_forms.length + j] = combined_notes;
-                        }
-                    }
-                }
-            }
-            return [ret_forms, ret_notes];
-        }
-    }
-    apply_ligatures(forms, is_adj) {
-        for (const slot of this.iter_slots(is_adj)) {
-            const ffs = (0, NominalForm_1.getNominalForm)(forms, slot) || [];
-            for (let i = 0; i < ffs.length; i++) {
-                ffs[i] = ffs[i].replace(/Ae/g, "Æ");
-                ffs[i] = ffs[i].replace(/Oe/g, "Œ");
-                ffs[i] = ffs[i].replace(/ae/g, "æ");
-                ffs[i] = ffs[i].replace(/oe/g, "œ");
-            }
-            (0, NominalForm_1.setNominalForm)(forms, slot, ffs);
-        }
-    }
-    apply_sufn(forms, is_adj) {
-        for (const slot of this.iter_slots(is_adj)) {
-            const ffs = (0, NominalForm_1.getNominalForm)(forms, slot) || [];
-            if (ffs.length == 1 && !slot.includes("linked")) {
-                const form = ffs[0];
-                if (form.match(/m$/)) {
-                    (0, NominalForm_1.setNominalForm)(forms, slot, [form.replace(/m$/, "n"), ...ffs]);
-                }
-            }
-            else {
-                let final_m = false;
-                for (const form of (0, NominalForm_1.getNominalForm)(forms, slot) || []) {
-                    if (form.match(/m$/)) {
-                        final_m = true;
-                    }
-                }
-                if (final_m) {
-                    const newval = [];
-                    for (const form of (0, NominalForm_1.getNominalForm)(forms, slot) || []) {
-                        if (form.match(/m$/)) {
-                            const val = form.replace(/m$/, "n");
-                            newval.push(val);
-                        }
-                        newval.push(form);
-                    }
-                    (0, NominalForm_1.setNominalForm)(forms, slot, newval);
-                }
-            }
-        }
-    }
-    propagate_number_restrictions(forms, num, is_adj) {
-        if (num == "sg" || num == "pl") {
-            for (const slot of this.iter_slots(is_adj)) {
-                if (slot.match(num)) {
-                    const other_num_slot = (num == "sg") ? slot.replace("sg", "pl") : slot.replace("pl", "sg");
-                    (0, NominalForm_1.setNominalForm)(forms, other_num_slot, (0, NominalForm_1.getNominalForm)(forms, slot) || []);
-                }
-            }
-        }
-    }
-    insert_if_not(data, entry, pos = 0) {
-        if (data.includes(entry)) {
-            return;
-        }
-        if (pos == 0) {
-            data.push(entry);
-        }
-        else {
-            data.splice(pos - 1, 0, entry);
-        }
-    }
-}
-exports.LaNominal = LaNominal;
-LaNominal.EmptyForm = "—";
-//# sourceMappingURL=LaNominal.js.map
+/**
+ * This is a complete re-implementation of Wiktionary's Module:la-nominal, 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-nominal
+ * Based on version 2026-03-03
+ *
+ * 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 { array_equals, extract_base, is_enum_value, read_list, remove_links } from "../common.js";
+import { m_adj_decl } from "./LaAdjData.js";
+import { m_noun_decl } from "./LaNounData.js";
+import { getNominalForm, setNominalForm } from "./NominalForm.js";
+import { addNominalType, delNominalType, hasNominalType, NominalType } from "./NominalType.js";
+export var Gender;
+(function (Gender) {
+    Gender["M"] = "M";
+    Gender["F"] = "F";
+    Gender["N"] = "N";
+})(Gender || (Gender = {}));
+export var NumberTantum;
+(function (NumberTantum) {
+    NumberTantum["Singular"] = "sg";
+    NumberTantum["Plural"] = "pl";
+    NumberTantum["Both"] = "both";
+})(NumberTantum || (NumberTantum = {}));
+export class LaNominal {
+    static EmptyForm = "—";
+    options;
+    cases = ["nom", "gen", "acc", "dat", "abl", "voc", "loc"];
+    genders = ["m", "f", "n"];
+    nums = ["sg", "pl"];
+    linked_prefixes = ["", "linked_"];
+    potential_noun_lemma_slots = [
+        "nom_sg", "gen_sg", "acc_sg",
+        "nom_pl", "gen_pl", "acc_pl",
+    ];
+    potential_adj_lemma_slots = [
+        "nom_sg_m", "gen_sg_m", "acc_sg_m",
+        "nom_pl_m", "gen_pl_m", "acc_pl_m",
+        "nom_sg_f", "gen_sg_f", "acc_sg_f",
+        "nom_pl_f", "gen_pl_f", "acc_pl_f",
+        "nom_sg_n", "gen_sg_n", "acc_sg_n",
+        "nom_pl_n", "gen_pl_n", "acc_pl_n",
+    ];
+    irreg_noun_to_decl = new Map([
+        ["bōs", "3"],
+        ["cherub", "irreg"],
+        ["deus", "2"],
+        ["Deus", "2"],
+        ["domus", "4,2"],
+        ["iūgerum", "2,3"],
+        ["jūgerum", "2,3"],
+        ["sūs", "3"],
+        ["ēthos", "3"],
+        ["Athōs", "2"],
+        ["lexis", "3"],
+        ["vēnum", "4,2"],
+        ["vīs", "3"],
+    ]);
+    declension_to_english = new Map([
+        ["1", "first"],
+        ["2", "second"],
+        ["3", "third"],
+        ["4", "fourth"],
+        ["5", "fifth"],
+    ]);
+    title;
+    constructor(options) {
+        this.options = options || {};
+    }
+    do_generate_noun_forms(args, pos = "nouns", from_headword = false, title) {
+        this.title = title;
+        const parsed_run = this.parse_segment_run_allowing_alternants(args.get("1")?.trim() || "");
+        parsed_run.loc = parsed_run.loc || args.has("loc_sg") || args.has("loc_pl");
+        let num = args.get("num");
+        if (num !== undefined && !is_enum_value(NumberTantum, num)) {
+            num = undefined;
+        }
+        parsed_run.num = num || parsed_run.num;
+        const declensions = this.decline_segment_run(parsed_run, pos, false);
+        if (!parsed_run.loc) {
+            setNominalForm(declensions.forms, "loc_sg", undefined);
+            setNominalForm(declensions.forms, "loc_pl", undefined);
+        }
+        declensions.title = [this.construct_title(args.get("title"), declensions.title.join(""), false, parsed_run)];
+        const all_data = {
+            templateType: "declension",
+            declensionType: "noun",
+            title: declensions.title.join(" "),
+            num: parsed_run.num,
+            gender: parsed_run.gender,
+            propses: parsed_run.propses,
+            forms: declensions.forms,
+            categories: declensions.categories,
+            notes: new Map(),
+            user_specified: new Set(),
+            pos: pos,
+            num_type: args.get("type"),
+            // only if headword
+            indecl: args.has("indecl"),
+            m: read_list(args, "m"),
+            f: read_list(args, "f"),
+            overriding_lemma: read_list(args, "lemma"),
+            overriding_genders: read_list(args, "g")
+        };
+        for (const slot of this.iter_noun_slots()) {
+            const noteses = declensions.notes.get(slot);
+            if (noteses) {
+                noteses.forEach((notes, index) => {
+                    all_data.notes.set(`${slot}${index + 1}`, notes);
+                });
+            }
+        }
+        this.unattested_forms(args, false);
+        this.process_noun_forms_and_overrides(all_data, args);
+        return all_data;
+    }
+    do_generate_adj_forms(args, pos = "adjectives", from_headword = false, title) {
+        this.title = title;
+        let segment_run = args.get("1")?.trim() || "";
+        if (!segment_run.match(/[<(]/)) {
+            segment_run = segment_run + (args.has("indecl") ? "<0+>" : "<+>");
+        }
+        const parsed_run = this.parse_segment_run_allowing_alternants(segment_run);
+        parsed_run.loc = parsed_run.loc || (args.has("loc_sg_m") || args.has("loc_sg_f") || args.has("loc_sg_n") || args.has("loc_pl_m") || args.has("loc_pl_f") || args.has("loc_pl_n"));
+        let num = args.get("num");
+        if (num !== undefined && !is_enum_value(NumberTantum, num)) {
+            num = undefined;
+        }
+        parsed_run.num = num || parsed_run.num;
+        const overriding_voc = (args.has("voc_sg_m") || args.has("voc_sg_f") || args.has("voc_sg_n") || args.has("voc_pl_m") || args.has("voc_pl_f") || args.has("voc_pl_n"));
+        const declensions = this.decline_segment_run(parsed_run, pos, true);
+        if (!parsed_run.loc) {
+            setNominalForm(declensions.forms, "loc_sg_m", undefined);
+            setNominalForm(declensions.forms, "loc_sg_f", undefined);
+            setNominalForm(declensions.forms, "loc_sg_n", undefined);
+            setNominalForm(declensions.forms, "loc_pl_m", undefined);
+            setNominalForm(declensions.forms, "loc_pl_f", undefined);
+            setNominalForm(declensions.forms, "loc_pl_n", undefined);
+        }
+        if (!overriding_voc && !declensions.voc) {
+            setNominalForm(declensions.forms, "voc_sg_m", undefined);
+            setNominalForm(declensions.forms, "voc_sg_f", undefined);
+            setNominalForm(declensions.forms, "voc_sg_n", undefined);
+            setNominalForm(declensions.forms, "voc_pl_m", undefined);
+            setNominalForm(declensions.forms, "voc_pl_f", undefined);
+            setNominalForm(declensions.forms, "voc_pl_n", undefined);
+        }
+        declensions.title = [this.construct_title(args.get("title"), declensions.title.join(""), from_headword, parsed_run)];
+        const all_data = {
+            templateType: "declension",
+            declensionType: "adjective",
+            title: declensions.title.join(""),
+            num: parsed_run.num,
+            propses: parsed_run.propses,
+            forms: declensions.forms,
+            categories: declensions.categories,
+            notes: new Map(),
+            user_specified: new Set(),
+            voc: declensions.voc,
+            noneut: args.has("noneut") || declensions.noneut,
+            nomf: args.has("nomf") || declensions.nomf,
+            pos: pos,
+            num_type: args.get("type"),
+            // only if headword
+            overriding_lemma: read_list(args, "lemma"),
+            indecl: args.has("indecl"),
+            comp: read_list(args, "comp"),
+            sup: read_list(args, "sup"),
+            adv: read_list(args, "adv")
+        };
+        for (const slot of this.iter_adj_slots()) {
+            const noteses = declensions.notes.get(slot);
+            if (noteses) {
+                noteses.forEach((notes, index) => {
+                    all_data.notes.set(`${slot}${index + 1}`, notes);
+                });
+            }
+        }
+        // Expand genderless slots (e.g. gen_pl → gen_pl_m/f/n) to match Lua behaviour
+        this.unattested_forms(args, true);
+        for (const slot of this.iter_noun_slots(true)) {
+            const arg = args.get(slot);
+            if (arg !== undefined) {
+                for (const gender of this.genders) {
+                    const slotG = slot + "_" + gender;
+                    if (!args.has(slotG)) {
+                        args.set(slotG, arg);
+                    }
+                }
+                args.delete(slot);
+            }
+        }
+        this.process_adj_forms_and_overrides(all_data, args);
+        return all_data;
+    }
+    construct_title(args_title, declensions_title, from_headword, parsed_run) {
+        if (args_title) {
+            declensions_title = args_title.replace("<1>", "first declension");
+            declensions_title = declensions_title.replace("<1&2>", "first/second declension");
+            declensions_title = declensions_title.replace("<2>", "second declension");
+            declensions_title = declensions_title.replace("<3>", "third declension");
+            declensions_title = declensions_title.replace("<4>", "fourth declension");
+            declensions_title = declensions_title.replace("<5>", "fifth declension");
+            if (from_headword) {
+                declensions_title = declensions_title[0].toLowerCase() + declensions_title.replace(/\.$/, "").slice(1);
+            }
+            else {
+                if (declensions_title.startsWith(" ")) {
+                    declensions_title = declensions_title.slice(1);
+                }
+                declensions_title = this.uppercase_first_visible(declensions_title);
+            }
+        }
+        else {
+            const post_text_parts = [];
+            if (parsed_run.loc) {
+                post_text_parts.push(", with locative");
+            }
+            if (parsed_run.num == "sg") {
+                post_text_parts.push(", singular only");
+            }
+            else if (parsed_run.num == "pl") {
+                post_text_parts.push(", plural only");
+            }
+            const post_text = post_text_parts.join("");
+            if (from_headword) {
+                declensions_title = declensions_title[0].toLowerCase() + declensions_title.slice(1) + post_text;
+            }
+            else {
+                if (declensions_title.length > 0) {
+                    declensions_title = this.uppercase_first_visible(declensions_title) + post_text + ".";
+                }
+            }
+        }
+        return declensions_title;
+    }
+    process_noun_forms_and_overrides(data, args) {
+        const linked_to_non_linked_noun_slots = new Map();
+        for (const slot of this.potential_noun_lemma_slots) {
+            linked_to_non_linked_noun_slots.set("linked_" + slot, slot);
+        }
+        for (const slot of this.iter_noun_slots()) {
+            let val = [];
+            const slotArg = args.get(slot);
+            if (slotArg) {
+                val = slotArg.split("/") || [];
+                data.user_specified.add(slot);
+            }
+            else {
+                const non_linked_equiv_slot = linked_to_non_linked_noun_slots.get(slot);
+                const nonLinkedArg = non_linked_equiv_slot ? args.get(non_linked_equiv_slot) : undefined;
+                if (nonLinkedArg) {
+                    val = nonLinkedArg.split("/") || [];
+                    data.user_specified.add(slot);
+                }
+                else {
+                    val = getNominalForm(data.forms, slot) || [];
+                }
+            }
+            if (val) {
+                if ((data.num == "pl" && slot.includes("sg")) || (data.num == "sg" && slot.includes("pl"))) {
+                    setNominalForm(data.forms, slot, [""]);
+                }
+                else if (val[0] == "" || val[0] == "-" || val[0] == "—") {
+                    if (val[1] !== undefined) {
+                        throw Error(`Cannot specify additional forms for ${slot} if it has been cancelled with "-"`);
+                    }
+                    setNominalForm(data.forms, slot, [LaNominal.EmptyForm]);
+                }
+                else {
+                    setNominalForm(data.forms, slot, val);
+                }
+            }
+        }
+    }
+    unattested_forms(args, is_adj) {
+        for (const slot of this.iter_slots(is_adj)) {
+            const arg = args.get(slot);
+            if (arg !== undefined) {
+                const match = arg.match(/^\*(.*)$/);
+                if (match) {
+                    const stripped = match[1];
+                    if (stripped) {
+                        args.set(slot, stripped);
+                    }
+                    else {
+                        args.delete(slot);
+                    }
+                }
+            }
+        }
+    }
+    process_adj_forms_and_overrides(data, args) {
+        const linked_to_non_linked_adj_slots = new Map();
+        for (const slot of this.potential_adj_lemma_slots) {
+            linked_to_non_linked_adj_slots.set("linked_" + slot, slot);
+        }
+        for (const slot of this.iter_adj_slots()) {
+            if (data.noneut && slot.match(/_n$/)) {
+                setNominalForm(data.forms, slot, undefined);
+            }
+            if (data.nomf && (slot.match(/_m/) || slot.match(/_f/))) {
+                setNominalForm(data.forms, slot, undefined);
+            }
+            let val;
+            const ovr = args.get(slot);
+            if (ovr) {
+                val = ovr.split("/");
+                data.user_specified.add(slot);
+            }
+            else {
+                const non_linked_equiv_slot = linked_to_non_linked_adj_slots.get(slot);
+                const nonLinkedArg = non_linked_equiv_slot ? args.get(non_linked_equiv_slot) : undefined;
+                if (nonLinkedArg) {
+                    val = nonLinkedArg.split("/") || [];
+                    data.user_specified.add(slot);
+                }
+                else {
+                    val = getNominalForm(data.forms, slot);
+                }
+            }
+            if (val) {
+                if ((data.num == "pl" && slot.match(/sg/)) || (data.num == "sg" && slot.match(/pl/))) {
+                    setNominalForm(data.forms, slot, undefined);
+                }
+                else if (val[0] == "" || val[0] == "-" || val[0] == "—") {
+                    if (val[1] !== undefined) {
+                        throw Error(`Cannot specify additional forms for ${slot} if it has been cancelled with "-"`);
+                    }
+                    setNominalForm(data.forms, slot, [LaNominal.EmptyForm]);
+                }
+                else {
+                    setNominalForm(data.forms, slot, val);
+                }
+            }
+        }
+        for (const gender of ["f", "n"]) {
+            let other_is_masc = true;
+            for (const cas of this.cases) {
+                for (const num of this.nums) {
+                    const genderForm = getNominalForm(data.forms, cas + "_" + num + "_" + gender);
+                    const amscForm = getNominalForm(data.forms, cas + "_" + num + "_m");
+                    if (!array_equals(genderForm, amscForm)) {
+                        other_is_masc = false;
+                        break;
+                    }
+                }
+                if (!other_is_masc) {
+                    break;
+                }
+            }
+            if (other_is_masc && !this.options.populateAllTerminations) {
+                for (const cas of this.cases) {
+                    for (const num of this.nums) {
+                        setNominalForm(data.forms, cas + "_" + num + "_" + gender, undefined);
+                    }
+                }
+            }
+        }
+    }
+    iter_slots(is_adj, overridable_only = false) {
+        if (is_adj) {
+            return this.iter_adj_slots(overridable_only);
+        }
+        else {
+            return this.iter_noun_slots(overridable_only);
+        }
+    }
+    iter_adj_slots(overridable_only = false) {
+        let cas = 1;
+        let num = 1;
+        let gen = 1;
+        let linked_variant = 0;
+        const entries = [];
+        while (true) {
+            linked_variant = linked_variant + 1;
+            const max_linked_variant = (overridable_only || cas > 3) ? 1 : 2;
+            if (linked_variant > max_linked_variant) {
+                linked_variant = 1;
+                gen++;
+                if (gen > this.genders.length) {
+                    gen = 1;
+                    num++;
+                    if (num > this.nums.length) {
+                        num = 1;
+                        cas++;
+                        if (cas > this.cases.length) {
+                            break;
+                        }
+                    }
+                }
+            }
+            entries.push(this.linked_prefixes[linked_variant - 1] + this.cases[cas - 1] + "_" + this.nums[num - 1] + "_" + this.genders[gen - 1]);
+        }
+        return entries;
+    }
+    iter_noun_slots(overridable_only = false) {
+        let cas = 1;
+        let num = 1;
+        let linked_variant = 0;
+        const entries = [];
+        while (true) {
+            linked_variant = linked_variant + 1;
+            const max_linked_variant = (overridable_only || cas > 3) ? 1 : 2;
+            if (linked_variant > max_linked_variant) {
+                linked_variant = 1;
+                num++;
+                if (num > this.nums.length) {
+                    num = 1;
+                    cas++;
+                    if (cas > this.cases.length) {
+                        break;
+                    }
+                }
+            }
+            entries.push(this.linked_prefixes[linked_variant - 1] + this.cases[cas - 1] + "_" + this.nums[num - 1]);
+        }
+        return entries;
+    }
+    parse_segment_run_allowing_alternants(segment_run) {
+        const alternating_segments = this.capturing_split(segment_run, /(\(\(.*?\)\))/);
+        const parsed_segments = [];
+        let loc = false;
+        let num;
+        let gender;
+        let is_adj;
+        const propses = [];
+        for (let i = 0; i < alternating_segments.length; i++) {
+            const alternating_segment = alternating_segments[i];
+            let this_is_adj;
+            if (alternating_segment) {
+                if (i % 2 == 0) {
+                    const parsed_run = this.parse_segment_run(alternating_segment);
+                    for (const parsed_segment of parsed_run.segments) {
+                        parsed_segments.push(parsed_segment);
+                    }
+                    loc = loc || parsed_run.loc;
+                    num = num || parsed_run.num;
+                    gender = gender || parsed_run.gender;
+                    this_is_adj = parsed_run.is_adj;
+                    for (const prop of parsed_run.propses) {
+                        propses.push(prop);
+                    }
+                }
+                else {
+                    const parsed_alternating_segment = this.parse_alternant(alternating_segment);
+                    parsed_segments.push(parsed_alternating_segment);
+                    loc = loc || parsed_alternating_segment.loc;
+                    num = num || parsed_alternating_segment.num;
+                    gender = gender || parsed_alternating_segment.gender;
+                    this_is_adj = parsed_alternating_segment.is_adj;
+                    propses.push(...parsed_alternating_segment.propses);
+                }
+            }
+            if (is_adj === undefined) {
+                is_adj = this_is_adj;
+            }
+            else if (this_is_adj !== undefined) {
+                is_adj = is_adj && this_is_adj;
+            }
+        }
+        return {
+            segments: parsed_segments,
+            loc: loc,
+            num: num,
+            gender: gender,
+            is_adj: is_adj,
+            propses: propses,
+        };
+    }
+    parse_alternant(alternant) {
+        const parsed_alternants = [];
+        const alternant_spec = alternant.match(/^\(\((.*)\)\)$/);
+        let loc = false;
+        let num;
+        let gender;
+        let is_adj;
+        const propses = [];
+        if (!alternant_spec) {
+            throw Error("Invalid alternant spec");
+        }
+        const alternants = alternant_spec[1].split(",");
+        alternants.forEach((altr, i) => {
+            const parsed_run = this.parse_segment_run(altr);
+            parsed_alternants.push(parsed_run);
+            loc = loc || parsed_run.loc;
+            if (i == 0) {
+                num = parsed_run.num;
+            }
+            else if (num != parsed_run.num) {
+                num = NumberTantum.Both;
+            }
+            gender = gender || parsed_run.gender;
+            if (is_adj === undefined) {
+                is_adj = parsed_run.is_adj;
+            }
+            else if (parsed_run.is_adj !== undefined && parsed_run.is_adj !== is_adj) {
+                throw Error("Saw both noun and adjective alternants; not allowed");
+            }
+            propses.push(...parsed_run.propses);
+        });
+        return {
+            type: "Alternant",
+            alternants: parsed_alternants,
+            loc: loc,
+            num: num,
+            gender: gender,
+            is_adj: is_adj,
+            propses: propses,
+        };
+    }
+    parse_segment_run(segment_run) {
+        const is_suffix = segment_run.startsWith("-");
+        const segments = [];
+        const bracketed_segments = this.capturing_split(segment_run, /(\[\[[^\[\]]-\]\]<.*?>)/);
+        bracketed_segments.forEach((bracketed_segment, i) => {
+            if (i % 2 == 1) {
+                segments.push(bracketed_segment);
+            }
+            else {
+                let regex;
+                if (is_suffix) {
+                    regex = /([^<> ,]+<.*?>)/;
+                }
+                else {
+                    regex = /([^<> ,\-]+<.*?>)/;
+                }
+                for (const subsegment of this.capturing_split(bracketed_segment, regex)) {
+                    segments.push(subsegment);
+                }
+            }
+        });
+        let loc = false;
+        let num;
+        let gender;
+        let is_adj;
+        const propses = [];
+        const parsed_segments = [];
+        for (let i = 1; i < segments.length; i += 2) {
+            const parsed_segment = this.parse_segment(segments[i]);
+            loc = loc || parsed_segment.loc;
+            num = num || parsed_segment.num;
+            if (is_adj === undefined) {
+                is_adj = parsed_segment.is_adj;
+            }
+            else {
+                is_adj = is_adj && parsed_segment.is_adj;
+            }
+            gender = gender || parsed_segment.gender;
+            parsed_segment.orig_prefix = segments[i - 1];
+            parsed_segment.prefix = remove_links(segments[i - 1]);
+            parsed_segments.push(parsed_segment);
+            if (parsed_segment.props) {
+                propses.push(parsed_segment.props);
+            }
+        }
+        if (segments[segments.length - 1]) {
+            parsed_segments.push({
+                type: "Segment",
+                args: [],
+                decl: "",
+                is_adj: false,
+                lemma: "",
+                orig_lemma: "",
+                loc: false,
+                types: new Set(),
+                orig_prefix: segments[segments.length - 1],
+                prefix: remove_links(segments[segments.length - 1])
+            });
+        }
+        return {
+            segments: parsed_segments,
+            loc: loc,
+            num: num,
+            gender: gender,
+            propses: propses,
+        };
+    }
+    capturing_split(str, pattern) {
+        return str.split(pattern);
+    }
+    parse_segment(segment) {
+        const match = segment.match(/^(.*)<(.*?)>$/);
+        if (!match) {
+            throw Error("No match");
+        }
+        const stem_part = match[1];
+        const spec_part = match[2];
+        const stems = stem_part.split("/");
+        const specs = spec_part.split(".");
+        const types = new Set();
+        let num;
+        let loc = false;
+        let decl = "";
+        for (let j = 0; j < specs.length; j++) {
+            let spec = specs[j];
+            if (j == 0) {
+                decl = spec;
+            }
+            else {
+                const m2 = spec.match(/^(-?)(.*?)$/);
+                if (m2) {
+                    const begins_with_hypen = m2[1];
+                    spec = m2[2];
+                    spec = begins_with_hypen + spec.replace(/-/g, "_");
+                    if (is_enum_value(NominalType, spec)) {
+                        addNominalType(types, spec);
+                    }
+                }
+            }
+        }
+        const orig_lemma = stems[0] || this.title;
+        if (!orig_lemma) {
+            throw Error("No lemma");
+        }
+        const lemma = remove_links(orig_lemma);
+        let stem2 = stems[1];
+        if (stems.length > 2) {
+            throw Error(`Too many stems, at most 2 should be give: ${stem_part}`);
+        }
+        let is_adj = false;
+        let base;
+        let detected_subtypes;
+        if (decl.match(/\+/)) {
+            [base, stem2, decl, detected_subtypes] = this.detect_adj_type_and_subtype(lemma, stem2, decl, types);
+            is_adj = true;
+            for (const subtype of detected_subtypes) {
+                if (hasNominalType(types, "-" + subtype)) {
+                    delNominalType(types, "-" + subtype);
+                }
+                else {
+                    types.add(subtype);
+                }
+            }
+        }
+        else {
+            [base, stem2, detected_subtypes] = this.detect_noun_subtype(lemma, stem2, decl, types);
+            for (const subtype of detected_subtypes) {
+                if (hasNominalType(types, "-" + subtype)) {
+                    delNominalType(types, "-" + subtype);
+                }
+                else if ((subtype == NominalType.Masculine || subtype == NominalType.Feminine || subtype == NominalType.Neuter) &&
+                    (types.has(NominalType.Masculine) || types.has(NominalType.Feminine) || types.has(NominalType.Neuter))) {
+                    // don't create conflicting gender specs
+                }
+                else if ((subtype == NominalType.Singular || subtype == NominalType.Plural || subtype == NominalType.Both) &&
+                    (types.has(NominalType.Singular) || types.has(NominalType.Plural) || types.has(NominalType.Both) || types.has(NominalType.SingularFull) || types.has(NominalType.PluralFull))) {
+                    // don't create conflicting number restrictions
+                }
+                else {
+                    types.add(subtype);
+                }
+            }
+            if (!types.has(NominalType.Plural) && !types.has(NominalType.PluralFull) && !types.has(NominalType.Both) && !types.has(NominalType.SingularFull) && lemma.match(/^[A-ZĀĒĪŌŪȲĂĔĬŎŬÆŒ]/)) {
+                types.add(NominalType.Singular);
+            }
+        }
+        if (types.has(NominalType.Locative)) {
+            loc = true;
+            types.delete(NominalType.Locative);
+        }
+        let gender;
+        if (types.has(NominalType.Masculine)) {
+            gender = Gender.M;
+        }
+        else if (types.has(NominalType.Feminine)) {
+            gender = Gender.F;
+        }
+        else if (types.has(NominalType.Neuter)) {
+            gender = Gender.N;
+        }
+        if (types.has(NominalType.Plural)) {
+            num = NumberTantum.Plural;
+            types.delete(NominalType.Plural);
+        }
+        else if (types.has(NominalType.PluralFull)) {
+            num = NumberTantum.Plural;
+            // keep PluralFull in types (Lua keeps "plural" in types)
+        }
+        else if (types.has(NominalType.Singular)) {
+            num = NumberTantum.Singular;
+            types.delete(NominalType.Singular);
+        }
+        else if (types.has(NominalType.SingularFull)) {
+            num = NumberTantum.Singular;
+            // keep SingularFull in types (Lua keeps "singular" in types)
+        }
+        const args = [base, stem2];
+        const props = {
+            decl: decl,
+            types: types,
+        };
+        return {
+            type: "Segment",
+            decl: decl,
+            is_adj: is_adj,
+            gender: gender,
+            orig_lemma: orig_lemma,
+            lemma: lemma,
+            stem2: stem2,
+            types: types,
+            num: num,
+            loc: loc,
+            args: args,
+            props: props,
+        };
+    }
+    detect_adj_type_and_subtype(lemma, stem2, typ, subtypes) {
+        if (!typ.match(/^[0123]/) && !typ.match(/^irreg/) && typ && typ != "+" && typ != "0+" && typ != "indecl+") {
+            subtypes = new Set(subtypes);
+            addNominalType(subtypes, typ.replace(/\+$/, ""));
+            typ = "+";
+        }
+        function base_as_stem2(base, stem2x) {
+            return [base, base];
+        }
+        function constant_base(baseval) {
+            return (base, s2) => [baseval, ""];
+        }
+        function decl12_stem2(base) {
+            return base;
+        }
+        function decl3_stem2(base) {
+            return LaNominal.make_stem2(base);
+        }
+        const decl12_entries = [
+            ["us", "1&2+", []],
+            ["a", "1&2+", []],
+            ["um", "1&2+", []],
+            ["ī", "1&2+", [NominalType.Plural]],
+            ["ae", "1&2+", [NominalType.Plural]],
+            ["a", "1&2+", [NominalType.Plural]],
+            ["os", "1&2+", [NominalType.GreekA, NominalType.NoGreekE]],
+            ["os", "1&2+", [NominalType.GreekE, NominalType.NoGreekA]],
+            ["ē", "1&2+", [NominalType.GreekE, NominalType.NoGreekA]],
+            ["on", "1&2+", [NominalType.GreekA, NominalType.NoGreekE]],
+            ["on", "1&2+", [NominalType.GreekE, NominalType.NoGreekA]],
+            ["^(.*er)$", "1&2+", [NominalType.Er]],
+            ["^(.*ur)$", "1&2+", [NominalType.Er]],
+            ["^(h)ic$", "1&2+", [NominalType.Ic]],
+        ];
+        const decl3_entries = [
+            ["^(.*er)$", "3-3+", [NominalType.I]],
+            ["^(.*er)$", "3-3+", []],
+            ["is", "3-2+", [NominalType.I]],
+            ["is", "3-2+", []],
+            ["e", "3-2+", [NominalType.I]],
+            ["e", "3-2+", []],
+            ["^(.*[ij])or$", "3-C+", [NominalType.AblEI, NominalType.NoAblIE]],
+            ["^(.*[ij])or$", "3-C+", []],
+            ["^(min)or$", "3-C+", [NominalType.AblEI, NominalType.NoAblIE]],
+            ["^(min)or$", "3-C+", []],
+            ["^(.*trīx)$", "3-def+", [NominalType.Trix, NominalType.AblIE, NominalType.NoAblEI]],
+            ["^(.*trīx)$", "3-def+", [NominalType.Trix]],
+            ["^(.*tor)$", "3-def+", [NominalType.Tor, NominalType.AblIE, NominalType.NoAblEI]],
+            ["^(.*tor)$", "3-def+", [NominalType.Tor]],
+            ["^(.*ēs)$", "3-1+", [NominalType.I, NominalType.AblIE, NominalType.NoAblEI]],
+            ["^(.*ēs)$", "3-1+", [NominalType.I]],
+            ["^(.*ēs)$", "3-1+", [NominalType.Par, NominalType.AblIE, NominalType.NoAblEI]],
+            ["^(.*ēs)$", "3-1+", [NominalType.Par]],
+            ["^(.*[ij])ōrēs$", "3-C+", [NominalType.Plural]],
+            ["^(min)ōrēs$", "3-C+", [NominalType.Plural]],
+            ["ēs", "3-2+", [NominalType.Plural, NominalType.I], base_as_stem2],
+            ["ēs", "3-1+", [NominalType.Plural, NominalType.Par], base_as_stem2],
+            ["ia", "3-2+", [NominalType.Plural, NominalType.I], base_as_stem2],
+            ["a", "3-1+", [NominalType.Plural, NominalType.Par], base_as_stem2],
+            ["", "3-1+", [NominalType.I, NominalType.AblIE, NominalType.NoAblEI]],
+            ["", "3-1+", [NominalType.I]],
+            ["", "3-1+", [NominalType.Par, NominalType.AblIE, NominalType.NoAblEI]],
+            ["", "3-1+", [NominalType.Par]],
+        ];
+        if (!typ || typ == "+") {
+            const [base, new_stem2, rettype, new_subtypes] = this.get_adj_type_and_subtype_by_ending(lemma, stem2, undefined, subtypes, decl12_entries, decl12_stem2);
+            if (base) {
+                return [base, new_stem2, rettype, new_subtypes];
+            }
+            else {
+                return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, decl3_entries, decl3_stem2);
+            }
+        }
+        else if (typ == "indecl+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["", typ, [NominalType.Singular]],
+                ["", typ, [NominalType.Plural]],
+                ["", typ, [NominalType.Both]],
+            ], decl3_stem2);
+        }
+        else if (typ == "0+") {
+            return [lemma, "", "0+", []];
+        }
+        else if (typ == "1&2+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, decl12_entries, decl12_stem2);
+        }
+        else if (typ == "3+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, decl3_entries, decl3_stem2);
+        }
+        else if (typ == "1-1+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["a", "1-1+", []],
+                ["ae", "1-1+", [NominalType.Plural]]
+            ]);
+        }
+        else if (typ == "2-2+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["us", "2-2+", []],
+                ["um", "2-2+", []],
+                ["ī", "2-2+", [NominalType.Plural]],
+                ["a", "2-2+", [NominalType.Plural]],
+                ["os", "2-2+", [NominalType.greek]],
+                ["on", "2-2+", [NominalType.greek]],
+                ["oe", "2-2+", [NominalType.greek, NominalType.Plural]],
+            ]);
+        }
+        else if (typ == "3-1+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["^(.*ēs)$", "3-1+", [NominalType.I, NominalType.AblIE, NominalType.NoAblEI]],
+                ["^(.*ēs)$", "3-1+", [NominalType.I]],
+                ["^(.*ēs)$", "3-1+", [NominalType.Par, NominalType.AblIE, NominalType.NoAblEI]],
+                ["^(.*ēs)$", "3-1+", [NominalType.Par]],
+                ["ēs", "3-1+", [NominalType.Plural, NominalType.I], base_as_stem2],
+                ["ēs", "3-1+", [NominalType.Plural, NominalType.Par], base_as_stem2],
+                ["ia", "3-1+", [NominalType.Plural, NominalType.I], base_as_stem2],
+                ["a", "3-1+", [NominalType.Plural, NominalType.Par], base_as_stem2],
+                ["", "3-1+", [NominalType.I, NominalType.AblIE, NominalType.NoAblEI]],
+                ["", "3-1+", [NominalType.I]],
+                ["", "3-1+", [NominalType.Par, NominalType.AblIE, NominalType.NoAblEI]],
+                ["", "3-1+", [NominalType.Par]],
+            ], decl3_stem2);
+        }
+        else if (typ == "3-2+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["is", "3-2+", []],
+                ["e", "3-2+", []],
+                ["ēs", "3-2+", []],
+                ["ēs", "3-2+", [NominalType.Plural]],
+                ["ia", "3-2+", [NominalType.Plural]],
+            ], decl3_stem2);
+        }
+        else if (typ == "3-3+" || typ == "3-P+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["ēs", typ, [NominalType.Plural], base_as_stem2],
+                ["ia", typ, [NominalType.Plural], base_as_stem2],
+                ["", typ, []],
+            ], decl3_stem2);
+        }
+        else if (typ == "3-C+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["^(.*[ij])or$", "3-C+", [NominalType.AblEI, NominalType.NoAblIE]],
+                ["^(.*[ij])or$", "3-C+", []],
+                ["^(min)or$", "3-C+", [NominalType.AblEI, NominalType.NoAblIE]],
+                ["^(min)or$", "3-C+", []],
+                ["^(.*[ij])ōrēs$", "3-C+", [NominalType.Plural]],
+                ["^(min)ōrēs$", "3-C+", [NominalType.Plural]],
+            ], decl3_stem2);
+        }
+        else if (typ == "3-def+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["^(.*trīx)$", "3-def+", [NominalType.Trix, NominalType.AblIE, NominalType.NoAblEI]],
+                ["^(.*trīx)$", "3-def+", [NominalType.Trix]],
+                ["^(.*tor)$", "3-def+", [NominalType.Tor, NominalType.AblIE, NominalType.NoAblEI]],
+                ["^(.*tor)$", "3-def+", [NominalType.Tor]],
+                ["ēs", "3-def+", [NominalType.Plural], base_as_stem2],
+                ["ia", "3-def+", [NominalType.Plural], base_as_stem2],
+                ["", "3-def+", []],
+            ], decl3_stem2);
+        }
+        else if (typ == "irreg+") {
+            return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["^(duo)$", typ, [NominalType.Plural]],
+                ["^(ambō)$", typ, [NominalType.Plural]],
+                ["^(mīll?ia)$", typ, [NominalType.Neuter, NominalType.Plural], constant_base("mīlle")],
+                ["^(ea)$", typ, [], constant_base("is")],
+                ["^(id)$", typ, [], constant_base("is")],
+                ["^([ei]ī)$", typ, [NominalType.Plural], constant_base("is")],
+                ["^(eae?)$", typ, [NominalType.Plural], constant_base("is")],
+                ["^(eadem)$", typ, [], constant_base("īdem")],
+                ["^([īi]dem)$", typ, [], constant_base("īdem")],
+                ["^(īdem)$", typ, [NominalType.Plural]],
+                ["^(eae?dem)$", typ, [NominalType.Plural], constant_base("īdem")],
+                ["^(i[lps][lst])a$", typ, [], (base, s2) => [base + "e", ""]],
+                ["^(i[ls][lt])ud$", typ, [], (base, s2) => [base + "e", ""]],
+                ["^(ipsum)$", typ, [], constant_base("ipse")],
+                ["^(i[lps][lst])ī$", typ, [NominalType.Plural], (base, s2) => [base + "e", ""]],
+                ["^(i[lps][lst])ae?$", typ, [NominalType.Plural], (base, s2) => [base + "e", ""]],
+                ["^(quī)$", typ, []],
+                ["^(quī)$", typ, [NominalType.Plural]],
+                ["^(quae)$", typ, [], constant_base("quī")],
+                ["^(quae)$", typ, [NominalType.Plural], constant_base("quī")],
+                ["^(quid)$", typ, [], constant_base("quis")],
+                ["^(quod)$", typ, [], constant_base("quī")],
+                ["^(qui[cd]quid)$", typ, [], constant_base("quisquis")],
+                ["^(quīquī)$", typ, [NominalType.Plural], constant_base("quisquis")],
+                ["^(quaequae)$", typ, [NominalType.Plural], constant_base("quisquis")],
+                ["", typ, []],
+            ]);
+        }
+        else {
+            return [lemma, "", typ, []];
+        }
+    }
+    get_adj_type_and_subtype_by_ending(lemma, stem2, decltype, specified_subtypes, endings_and_subtypes, process_stem2) {
+        for (const [ending, rettype, subtypes, process_retval] of endings_and_subtypes) {
+            let not_this_subtype = false;
+            if (specified_subtypes.has(NominalType.Plural) && !subtypes.includes(NominalType.Plural)) {
+                not_this_subtype = true;
+            }
+            else {
+                for (const subtype of subtypes) {
+                    if (!subtype.startsWith("-") && hasNominalType(specified_subtypes, "-" + subtype)) {
+                        not_this_subtype = true;
+                        break;
+                    }
+                    const must_not_be_present = subtype.match(/^-(.*)$/);
+                    if (must_not_be_present && hasNominalType(specified_subtypes, must_not_be_present[1])) {
+                        not_this_subtype = true;
+                        break;
+                    }
+                }
+            }
+            if (!not_this_subtype) {
+                let base;
+                if (typeof (ending) != "string") {
+                    const lemma_ending = ending[0];
+                    const stem2_ending = ending[1];
+                    base = extract_base(lemma, lemma_ending);
+                    if (base && base + stem2_ending != stem2) {
+                        base = undefined;
+                    }
+                }
+                else {
+                    base = extract_base(lemma, ending);
+                }
+                if (base !== undefined) {
+                    const new_subtypes = [];
+                    for (const subtype of subtypes) {
+                        if (!subtype.startsWith("-")) {
+                            new_subtypes.push(subtype);
+                        }
+                    }
+                    if (process_retval) {
+                        [base, stem2] = process_retval(base, stem2);
+                    }
+                    if (process_stem2) {
+                        stem2 = stem2 || process_stem2(base);
+                    }
+                    return [base, stem2, rettype, new_subtypes];
+                }
+            }
+        }
+        if (decltype === undefined) {
+            return ["", "", "", []];
+        }
+        else if (decltype == "") {
+            throw Error(`Unrecognized ending for adjective: ${lemma}`);
+        }
+        else {
+            throw Error(`Unrecognized ending for declension-${decltype} adjective: ${lemma}`);
+        }
+    }
+    detect_noun_subtype(lemma, stem2, typ, subtypes) {
+        if (typ == "1") {
+            return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["ām", [NominalType.Feminine, NominalType.Am]],
+                ["ās", [NominalType.Masculine, NominalType.Greek, NominalType.Ma]],
+                ["ēs", [NominalType.Masculine, NominalType.Greek, NominalType.Me]],
+                ["ā", [NominalType.Feminine, NominalType.Greek, NominalType.Fa]],
+                ["ē", [NominalType.Feminine, NominalType.Greek]],
+                ["ae", [NominalType.Feminine, NominalType.Plural]],
+                ["a", [NominalType.Feminine]],
+                ["a", [NominalType.Neuter]],
+                ["a", [NominalType.Neuter, NominalType.Plural]],
+            ]);
+        }
+        else if (typ == "2") {
+            let detected_subtypes;
+            [lemma, stem2, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["^(.*r)$", [NominalType.Masculine, NominalType.Er]],
+                ["^(.*v)os$", [NominalType.Masculine, NominalType.Vos]],
+                ["^(.*v)om$", [NominalType.Neuter, NominalType.Vom]],
+                ["os", [NominalType.Masculine, NominalType.Greek]],
+                ["os", [NominalType.Neuter, NominalType.Greek, NominalType.Us]],
+                ["on", [NominalType.Neuter, NominalType.Greek]],
+                ["^([A-ZĀĒĪŌŪȲĂĔĬŎŬÆŒ].*)ius$", [NominalType.Masculine, NominalType.Ius, NominalType.VocI, NominalType.Singular]],
+                [NominalType.Ius, [NominalType.Masculine, NominalType.Ius]],
+                [NominalType.Ium, [NominalType.Neuter, NominalType.Ium]],
+                [NominalType.Us, [NominalType.Masculine]],
+                [NominalType.Us, [NominalType.Neuter, NominalType.Us]],
+                ["um", [NominalType.Neuter]],
+                ["iī", [NominalType.Masculine, NominalType.Ius, NominalType.Plural]],
+                ["ia", [NominalType.Neuter, NominalType.Ium, NominalType.Plural]],
+                ["ī", [NominalType.Masculine, NominalType.Plural]],
+                ["ī", [NominalType.Neuter, NominalType.Us, NominalType.Plural]],
+                ["oe", [NominalType.Masculine, NominalType.Greek, NominalType.Plural]],
+                ["a", [NominalType.Neuter, NominalType.Plural]],
+            ]);
+            stem2 = stem2 || lemma;
+            return [lemma, stem2, detected_subtypes];
+        }
+        else if (typ == "3") {
+            let match;
+            if (subtypes.has(NominalType.Plural)) {
+                if (subtypes.has(NominalType.Greek)) {
+                    match = lemma.match(/^(.*)erēs$/);
+                    if (match) {
+                        return [match[1] + "ēr", match[1] + "er", [NominalType.Er]];
+                    }
+                    match = lemma.match(/^(.*)ontēs$/);
+                    if (match) {
+                        return [match[1] + "ōn", match[1] + "ont", [NominalType.On]];
+                    }
+                    match = lemma.match(/^(.*)es$/);
+                    if (match) {
+                        return [match[1], stem2 || match[1], []];
+                    }
+                    throw Error(`Unrecognized ending for declension-3 plural Greek noun: ${lemma}`);
+                }
+                match = lemma.match(/^(.*)ia$/);
+                if (match) {
+                    return [match[1], stem2 || match[1], [NominalType.Neuter, NominalType.I, NominalType.Pure]];
+                }
+                match = lemma.match(/^(.*)a$/);
+                if (match) {
+                    return [match[1], stem2 || match[1], [NominalType.Neuter]];
+                }
+                match = lemma.match(/^(.*)ēs$/);
+                if (match) {
+                    return [match[1], stem2 || match[1], []];
+                }
+                throw Error(`Unrecognized ending for declension-3 plural noun: ${lemma}`);
+            }
+            stem2 = stem2 || LaNominal.make_stem2(lemma);
+            let detected_subtypes;
+            let base;
+            let tmp;
+            if (subtypes.has(NominalType.Greek)) {
+                [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
+                    [["is", ""], [NominalType.I]],
+                    ["ēr", [NominalType.Er]],
+                    ["ōn", [NominalType.On]],
+                ]);
+                if (base) {
+                    return [lemma, stem2, detected_subtypes];
+                }
+                return [lemma, stem2, []];
+            }
+            if (!subtypes.has(NominalType.Neuter)) {
+                [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
+                    [["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*pol)is$", ""], [NominalType.Feminine, NominalType.Polis, NominalType.Singular, NominalType.Locative]],
+                    [["tūdō", "tūdin"], [NominalType.Feminine]],
+                    [["tās", "tāt"], [NominalType.Feminine]],
+                    [["tūs", "tūt"], [NominalType.Feminine]],
+                    [["tiō", "tiōn"], [NominalType.Feminine]],
+                    [["siō", "siōn"], [NominalType.Feminine]],
+                    [["xiō", "xiōn"], [NominalType.Feminine]],
+                    [["gō", "gin"], [NominalType.Feminine]],
+                    [["or", "ōr"], [NominalType.Masculine]],
+                    [["trīx", "trīc"], [NominalType.Feminine]],
+                    [["trix", "trīc"], [NominalType.Feminine]],
+                    [["is", ""], [NominalType.I]],
+                    [["^([a-zāēīōūȳăĕĭŏŭ].*)ēs$", ""], [NominalType.I]],
+                ]);
+                if (base) {
+                    return [lemma, stem2, detected_subtypes];
+                }
+            }
+            [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
+                [["us", "or"], [NominalType.Neuter]],
+                [["us", "er"], [NominalType.Neuter]],
+                [["ma", "mat"], [NominalType.Neuter]],
+                [["men", "min"], [NominalType.Neuter]],
+                [["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*)e$", ""], [NominalType.Neuter, NominalType.Singular]],
+                [["e", ""], [NominalType.Neuter, NominalType.I, NominalType.Pure]],
+                [["al", "āl"], [NominalType.Neuter, NominalType.I, NominalType.Pure]],
+                [["ar", "ār"], [NominalType.Neuter, NominalType.I, NominalType.Pure]],
+            ]);
+            if (base) {
+                return [lemma, stem2, detected_subtypes];
+            }
+            return [lemma, stem2, []];
+        }
+        else if (typ == "4") {
+            if (subtypes.has(NominalType.Echo) || subtypes.has(NominalType.Callisto)) {
+                const match = lemma.match(/^(.*)ō$/);
+                if (!match) {
+                    throw Error(`Declension-4 noun of subtype .echo or .Callisto should end in -ō: ${lemma}`);
+                }
+                const base = match[1];
+                if (subtypes.has(NominalType.Callisto)) {
+                    return [base, "", [NominalType.Feminine, NominalType.Singular]];
+                }
+                else {
+                    return [base, "", [NominalType.Feminine]];
+                }
+            }
+            return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["us", [NominalType.Masculine]],
+                ["ū\u0306?", [NominalType.Neuter]],
+                ["ūs", [NominalType.Masculine, NominalType.Plural]],
+                ["ua", [NominalType.Neuter, NominalType.Plural]],
+            ]);
+        }
+        else if (typ == "5") {
+            return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
+                ["iēs", [NominalType.Feminine, NominalType.i]],
+                ["iēs", [NominalType.Feminine, NominalType.i, NominalType.Plural]],
+                ["ēs", [NominalType.Feminine]],
+                ["ēs", [NominalType.Feminine, NominalType.Plural]],
+            ]);
+        }
+        else if (typ == "irreg" && lemma == "domus") {
+            return [lemma, "", [NominalType.Locative]];
+        }
+        else if (typ == "sgpl") {
+            return [lemma, stem2, []];
+        }
+        else if (typ == "indecl" || (typ == "irreg" && (lemma == "Deus" || lemma == "Iēsus" || lemma == "Jēsus" || lemma == "Athōs" || lemma == "vēnum"))) {
+            return [lemma, "", [NominalType.Singular]];
+        }
+        else {
+            return [lemma, "", []];
+        }
+    }
+    static make_stem2(stem) {
+        const patterns = [
+            ["tūdō", "tūdin"],
+            ["is", ""],
+            ["ēs", ""],
+            ["āns", "ant"],
+            ["ēns", "ent"],
+            ["ōns", "ont"],
+            // Lua: ([āēīōūȳĀĒĪŌŪȲ]n)s → strip macron + "t"
+            ["[āīūȳĀĪŪȲ]ns", (m) => m.replace(/[āĀ]/g, "a").replace(/[īĪ]/g, "i").replace(/[ūŪ]/g, "u").replace(/[ȳȲ]/g, "y").replace(/s$/, "t")],
+            ["ceps", "cipit"],
+            ["us", "or"],
+            ["ex", "ic"],
+            ["ma", "mat"],
+            ["e", ""],
+            ["ol", "ōl"],
+            ["el", "ell"],
+            ["El", "Ell"],
+            ["al", "āl"],
+            ["ar", "ār"],
+            ["men", "min"],
+            ["er", "r"],
+            ["or", "ōr"],
+            ["gō", "gin"],
+            ["ō", "ōn"],
+            ["ps", "p"],
+            ["bs", "b"],
+            ["s", "t"],
+            ["x", "c"],
+        ];
+        for (const [key, val] of patterns) {
+            if (stem.match(new RegExp(key + "$"))) {
+                if (typeof val === "function") {
+                    return stem.replace(new RegExp(key + "$"), val);
+                }
+                return stem.replace(new RegExp(key + "$"), val);
+            }
+        }
+        return stem;
+    }
+    get_noun_subtype_by_ending(lemma, stem2, decltype, specified_subtypes, endings_and_subtypes) {
+        for (const ending_and_subtype of endings_and_subtypes) {
+            const ending = ending_and_subtype[0];
+            const subtypes = ending_and_subtype[1];
+            let not_this_subtype = false;
+            if (specified_subtypes.has(NominalType.Plural) && !subtypes.includes(NominalType.Plural)) {
+                not_this_subtype = true;
+            }
+            else {
+                for (const subtype of subtypes) {
+                    if (hasNominalType(specified_subtypes, "-" + subtype) ||
+                        (subtype == NominalType.Neuter && (specified_subtypes.has(NominalType.Masculine) || specified_subtypes.has(NominalType.Feminine))) ||
+                        ((subtype == NominalType.Masculine || subtype == NominalType.Feminine) && specified_subtypes.has(NominalType.Neuter)) ||
+                        (subtype == NominalType.Singular && specified_subtypes.has(NominalType.Plural)) ||
+                        (subtype == NominalType.Plural && specified_subtypes.has(NominalType.Singular))) {
+                        not_this_subtype = true;
+                        break;
+                    }
+                }
+            }
+            if (!not_this_subtype) {
+                if (Array.isArray(ending)) {
+                    const lemma_ending = ending[0];
+                    const stem2_ending = ending[1];
+                    const base = extract_base(lemma, lemma_ending);
+                    if (base && (base + stem2_ending) == stem2) {
+                        return [base, stem2, subtypes];
+                    }
+                }
+                else {
+                    const base = extract_base(lemma, ending);
+                    if (base) {
+                        return [base, stem2, subtypes];
+                    }
+                }
+            }
+        }
+        if (decltype) {
+            throw Error(`Unrecognized ending for declension-${decltype} noun: ${lemma}`);
+        }
+        return ["", "", []];
+    }
+    decline_segment_run(parsed_run, pos, is_adj) {
+        const declensions = {
+            forms: new Map(),
+            notes: new Map(),
+            title: [],
+            subtitleses: [],
+            orig_titles: [],
+            categories: [],
+            voc: true,
+            noneut: false,
+            nomf: false,
+        };
+        for (const slot of this.iter_slots(is_adj)) {
+            setNominalForm(declensions.forms, slot, [""]);
+        }
+        for (const seg of parsed_run.segments) {
+            if (seg.type == "Segment" && seg.decl) {
+                seg.loc = parsed_run.loc;
+                seg.num = seg.num || parsed_run.num;
+                seg.gender = seg.gender || parsed_run.gender;
+                let data;
+                let potential_lemma_slots;
+                if (seg.is_adj) {
+                    const decline = m_adj_decl.get(seg.decl);
+                    if (!decline) {
+                        throw Error(`Unrecognized declension '${seg.decl}'`);
+                    }
+                    potential_lemma_slots = this.potential_adj_lemma_slots;
+                    data = {
+                        declOpts: this.options,
+                        subtitles: [],
+                        footnote: "",
+                        num: seg.num,
+                        gender: seg.gender,
+                        loc: seg.loc,
+                        voc: true,
+                        noneut: false,
+                        nomf: false,
+                        pos: is_adj ? pos : "adjectives",
+                        forms: new Map(),
+                        types: seg.types,
+                        categories: [],
+                        notes: new Map(),
+                    };
+                    decline(data, seg.args);
+                    if (!data.voc) {
+                        declensions.voc = false;
+                    }
+                    if (data.noneut) {
+                        declensions.noneut = true;
+                    }
+                    if (data.nomf) {
+                        declensions.nomf = true;
+                    }
+                    if (data.types.has(NominalType.SuffixN)) {
+                        data.subtitles.push(["with", " 'm' optionally → 'n' in compounds"]);
+                    }
+                    else if (data.types.has(NominalType.NotSuffixN)) {
+                        data.subtitles.push(["without", " 'm' optionally → 'n' in compounds"]);
+                    }
+                    if (data.title) {
+                        declensions.orig_titles.push(data.title);
+                    }
+                    if (data.subtitles.length > 0) {
+                        const subtitles = [];
+                        for (const subtitle of data.subtitles) {
+                            if (typeof (subtitle) == "string") {
+                                subtitles.push(subtitle);
+                            }
+                            else {
+                                subtitles.push(subtitle.join(""));
+                            }
+                        }
+                        data.title = (data.title ?? "") + " (" + subtitles.join(", ") + ")";
+                    }
+                    for (const subtitle of data.subtitles) {
+                        declensions.subtitleses.push(subtitle);
+                    }
+                }
+                else {
+                    const decline = m_noun_decl.get(seg.decl);
+                    if (!decline) {
+                        throw Error(`Unrecognized declension '${seg.decl}'`);
+                    }
+                    potential_lemma_slots = this.potential_noun_lemma_slots;
+                    data = {
+                        declOpts: this.options,
+                        subtitles: [],
+                        footnote: "",
+                        num: seg.num,
+                        loc: seg.loc,
+                        pos: pos,
+                        forms: new Map(),
+                        types: seg.types,
+                        categories: [],
+                        notes: new Map(),
+                    };
+                    decline(data, seg.args);
+                    const apparent_decl = data.decl || this.irreg_noun_to_decl.get(seg.lemma) || seg.decl;
+                    if (seg.props) {
+                        seg.props.headword_decl = apparent_decl;
+                    }
+                    if (!data.title) {
+                        if (seg.decl == "irreg" && apparent_decl != "irreg" && data.subtitles.length == 0) {
+                            data.subtitles.push("[[Appendix:Glossary#irregular|irregular]]");
+                        }
+                        const english = this.declension_to_english.get(apparent_decl);
+                        if (english) {
+                            data.title = `${english}-declension`;
+                        }
+                        else if (apparent_decl == "irreg") {
+                            data.title = "irregular";
+                        }
+                        else if (apparent_decl == "indecl" || apparent_decl == "0" || apparent_decl == "sgpl") {
+                            data.title = "indeclinable";
+                        }
+                        else {
+                            throw Error(`Internal error! Don't recognize noun declension ${apparent_decl}`);
+                        }
+                        data.title = data.title + " noun";
+                    }
+                    if (data.types.has(NominalType.SuffixN)) {
+                        data.subtitles.push(["with", " 'm' optionally → 'n' in compounds"]);
+                    }
+                    else if (data.types.has(NominalType.NotSuffixN)) {
+                        data.subtitles.push(["without", " 'm' optionally → 'n' in compounds"]);
+                    }
+                    declensions.orig_titles.push(data.title);
+                    if (data.subtitles.length > 0) {
+                        const subtitles = [];
+                        for (const subtitle of data.subtitles) {
+                            if (typeof (subtitle) == "string") {
+                                subtitles.push(subtitle);
+                            }
+                            else {
+                                subtitles.push(subtitle.join(""));
+                            }
+                        }
+                        data.title = data.title + ` (${subtitles.join(", ")})`;
+                    }
+                    for (const subtitle of data.subtitles) {
+                        declensions.subtitleses.push(subtitle);
+                    }
+                }
+                for (const slot of potential_lemma_slots) {
+                    const forms = getNominalForm(data.forms, slot);
+                    if (forms) {
+                        const linked_forms = [];
+                        for (const form of forms) {
+                            if (form == seg.lemma) {
+                                linked_forms.push(seg.orig_lemma);
+                            }
+                            else {
+                                linked_forms.push(form);
+                            }
+                        }
+                        setNominalForm(data.forms, `linked_${slot}`, linked_forms);
+                    }
+                }
+                if (seg.types.has(NominalType.Ligature)) {
+                    this.apply_ligatures(data.forms, is_adj);
+                }
+                if (seg.types.has(NominalType.SuffixN)) {
+                    this.apply_sufn(data.forms, is_adj);
+                }
+                this.propagate_number_restrictions(data.forms, seg.num, is_adj);
+                for (const slot of this.iter_slots(is_adj)) {
+                    let new_forms;
+                    if (is_adj) {
+                        if (!seg.is_adj) {
+                            throw Error(`Can't decline noun '${seg.lemma}' when overall term is an adjective`);
+                        }
+                        new_forms = getNominalForm(data.forms, slot);
+                        if (!new_forms && slot.match(/_[fn]$/)) {
+                            new_forms = getNominalForm(data.forms, slot.replace(/_[fn]$/, "_m"));
+                        }
+                    }
+                    else if (seg.is_adj) {
+                        if (!seg.gender) {
+                            throw Error(`Declining modifying adjective ${seg.lemma} but don't know gender of associated noun`);
+                        }
+                        new_forms = getNominalForm(data.forms, slot + "_" + seg.gender.toLowerCase()) ||
+                            getNominalForm(data.forms, slot + "_m");
+                    }
+                    else {
+                        new_forms = getNominalForm(data.forms, slot);
+                    }
+                    const new_notes = [];
+                    if (new_forms) {
+                        for (let j = 0; j < new_forms.length; j++) {
+                            const noteses = data.notes.get(`${slot}${j + 1}`);
+                            if (noteses) {
+                                new_notes[j] = [noteses];
+                            }
+                        }
+                    }
+                    const oldForms = getNominalForm(declensions.forms, slot);
+                    const [forms, notes] = this.append_form(oldForms, declensions.notes.get(slot), new_forms, new_notes, slot.includes("linked") ? seg.orig_prefix : seg.prefix);
+                    setNominalForm(declensions.forms, slot, forms);
+                    declensions.notes.set(slot, notes);
+                }
+                if (!seg.types.has(NominalType.NoCategories) && (is_adj || !seg.is_adj)) {
+                    for (const cat of data.categories) {
+                        this.insert_if_not(declensions.categories, cat);
+                    }
+                }
+                if (seg.prefix != "" && seg.prefix != "-" && seg.prefix != " ") {
+                    declensions.title.push("[[Appendix:Glossary#indeclinable|indeclinable]] portion");
+                }
+                if (data.title) {
+                    declensions.title.push(data.title);
+                }
+            }
+            else if (seg.type == "Alternant") {
+                let seg_declensions;
+                const seg_titles = [];
+                const seg_subtitleses = [];
+                const seg_stems_seen = [];
+                const seg_categories = [];
+                let title_the_hard_way = false;
+                let alternant_decl = "";
+                let alternant_decl_title;
+                for (const this_parsed_run of seg.alternants) {
+                    let num_non_constant_segments = 0;
+                    for (const segment of (this_parsed_run.segments)) {
+                        if (segment.type == "Segment" && segment.decl) {
+                            if (!alternant_decl) {
+                                alternant_decl = segment.decl;
+                            }
+                            else if (alternant_decl != segment.decl) {
+                                title_the_hard_way = true;
+                                num_non_constant_segments = 500;
+                                break;
+                            }
+                            num_non_constant_segments++;
+                        }
+                    }
+                    if (num_non_constant_segments != 1) {
+                        title_the_hard_way = true;
+                    }
+                }
+                if (!title_the_hard_way) {
+                    const subtypeses = new Set();
+                    for (const this_parsed_run of seg.alternants) {
+                        for (const segment of this_parsed_run.segments) {
+                            if (segment.type == "Segment" && segment.decl) {
+                                segment.types.forEach(t => subtypeses.add(t));
+                                this.insert_if_not(seg_stems_seen, segment.stem2 || "");
+                            }
+                        }
+                    }
+                    for (const this_parsed_run of seg.alternants) {
+                        for (const segment of this_parsed_run.segments) {
+                            if (segment.type == "Segment" && segment.decl) {
+                                const neg_subtypes = this.set_difference(subtypeses, segment.types);
+                                for (const neg_subtype of neg_subtypes) {
+                                    addNominalType(segment.types, "not_" + neg_subtype);
+                                }
+                            }
+                        }
+                    }
+                }
+                for (const this_parsed_run of seg.alternants) {
+                    this_parsed_run.loc = seg.loc;
+                    this_parsed_run.num = this_parsed_run.num || seg.num;
+                    this_parsed_run.gender = this_parsed_run.gender || seg.gender;
+                    const this_declensions = this.decline_segment_run(this_parsed_run, pos, is_adj);
+                    if (!this_declensions.voc) {
+                        declensions.voc = false;
+                    }
+                    if (this_declensions.noneut) {
+                        declensions.noneut = true;
+                    }
+                    if (this_declensions.nomf) {
+                        declensions.nomf = true;
+                    }
+                    if (this_parsed_run.num == "sg" || this_parsed_run.num == "pl") {
+                        for (const slot of (this.iter_slots(is_adj))) {
+                            if ((this_parsed_run.num == "sg" && slot.includes("pl")) ||
+                                (this_parsed_run.num == "pl" && slot.includes("sg"))) {
+                                setNominalForm(this_declensions.forms, slot, []);
+                                this_declensions.notes.delete(slot);
+                            }
+                        }
+                    }
+                    if (!seg_declensions) {
+                        seg_declensions = this_declensions;
+                    }
+                    else {
+                        for (const slot of this.iter_slots(is_adj)) {
+                            const curforms = getNominalForm(seg_declensions.forms, slot) || [];
+                            const newforms = getNominalForm(this_declensions.forms, slot) || [];
+                            const newform_index_to_new_index = [];
+                            newforms.forEach((form, newj) => {
+                                let did_break = false;
+                                for (let j = 0; j < curforms.length; j++) {
+                                    if (curforms[j] == form) {
+                                        newform_index_to_new_index[newj] = j;
+                                        did_break = true;
+                                        break;
+                                    }
+                                }
+                                if (!did_break) {
+                                    curforms.push(form);
+                                    newform_index_to_new_index[newj] = curforms.length - 1;
+                                }
+                            });
+                            setNominalForm(seg_declensions.forms, slot, curforms);
+                            const curnotes = seg_declensions.notes.get(slot) || [];
+                            const newnotes = this_declensions.notes.get(slot);
+                            if (newnotes) {
+                                newnotes.forEach((notes, index) => {
+                                    const combined_index = newform_index_to_new_index[index];
+                                    if (!curnotes[combined_index]) {
+                                        curnotes[combined_index] = notes;
+                                    }
+                                    else {
+                                        const combined = Array.from(curnotes[combined_index]);
+                                        for (const note of notes) {
+                                            this.insert_if_not(combined, note);
+                                        }
+                                        curnotes[combined_index] = combined;
+                                    }
+                                });
+                                seg_declensions.notes.set(slot, curnotes);
+                            }
+                        }
+                    }
+                    for (const cat of this_declensions.categories) {
+                        this.insert_if_not(seg_categories, cat);
+                    }
+                    this.insert_if_not(seg_titles, this_declensions.title.join(""));
+                    seg_subtitleses.push(this_declensions.subtitleses);
+                    if (!alternant_decl_title) {
+                        alternant_decl_title = this_declensions.orig_titles[0];
+                    }
+                }
+                if (!seg_declensions) {
+                    throw Error("No segment declensions");
+                }
+                this.propagate_number_restrictions(seg_declensions?.forms, parsed_run.num, is_adj);
+                for (const slot of this.iter_slots(is_adj)) {
+                    const declForms = getNominalForm(declensions.forms, slot);
+                    const segForms = getNominalForm(seg_declensions.forms, slot);
+                    const [newForms, notes] = this.append_form(declForms, declensions.notes.get(slot), segForms, seg_declensions.notes.get(slot), undefined);
+                    setNominalForm(declensions.forms, slot, newForms);
+                    declensions.notes.set(slot, notes);
+                }
+                if (is_adj || !seg.is_adj) {
+                    for (const cat of seg_categories) {
+                        this.insert_if_not(declensions.categories, cat);
+                    }
+                }
+                let title_to_insert;
+                if (title_the_hard_way) {
+                    title_to_insert = this.join_sentences(seg_titles, " or ");
+                }
+                else {
+                    const first = seg_subtitleses[0];
+                    if (typeof (first) == "string") {
+                        throw Error("Expected multi-title");
+                    }
+                    const first_subtitles = first;
+                    let num_common_subtitles = first_subtitles.length;
+                    for (let i = 1; i < seg_subtitleses.length; i++) {
+                        const this_subtitles = seg_subtitleses[i];
+                        for (let j = 0; j < num_common_subtitles; j++) {
+                            if (first_subtitles[j] != this_subtitles[j]) {
+                                num_common_subtitles = j;
+                                break;
+                            }
+                        }
+                    }
+                    const common_subtitles = [];
+                    for (let i = 0; i < num_common_subtitles; i++) {
+                        const entry = first_subtitles[i];
+                        if (typeof (entry) != "string") {
+                            common_subtitles.push(entry.join(""));
+                        }
+                        else {
+                            common_subtitles.push(entry);
+                        }
+                    }
+                    const common_subtitle_portion = common_subtitles.join(", ");
+                    let non_common_subtitle_portion;
+                    let common_prefix;
+                    let common_suffix;
+                    for (let i = 0; i < seg_subtitleses.length; i++) {
+                        const this_subtitles = seg_subtitleses[i];
+                        if (typeof (this_subtitles) == "string") {
+                            throw Error("Expected subtitles to be array");
+                        }
+                        if (this_subtitles.length != num_common_subtitles + 1 || typeof (this_subtitles[num_common_subtitles]) == "string" || this_subtitles[num_common_subtitles].length != 2) {
+                            break;
+                        }
+                        if (i == 0) {
+                            common_prefix = this_subtitles[num_common_subtitles][0];
+                            common_suffix = this_subtitles[num_common_subtitles][1];
+                        }
+                        else {
+                            const this_prefix = this_subtitles[num_common_subtitles][0];
+                            const this_suffix = this_subtitles[num_common_subtitles][1];
+                            if (this_prefix != common_prefix) {
+                                common_prefix = undefined;
+                            }
+                            if (this_suffix != common_suffix) {
+                                common_suffix = undefined;
+                            }
+                            if (!common_prefix && !common_suffix) {
+                                break;
+                            }
+                        }
+                    }
+                    if (common_prefix || common_suffix) {
+                        if (common_prefix && common_suffix) {
+                            throw Error("Something is wrong, first non-common subtitle is actually common to all segments");
+                        }
+                        if (common_prefix) {
+                            const non_common_parts = [];
+                            for (const subtitles of seg_subtitleses) {
+                                non_common_parts.push(subtitles[num_common_subtitles][1]);
+                            }
+                            non_common_subtitle_portion = common_prefix + non_common_parts.join(" or ");
+                        }
+                        else {
+                            const non_common_parts = [];
+                            for (const subtitles of seg_subtitleses) {
+                                non_common_parts.push(subtitles[num_common_subtitles][0]);
+                            }
+                            non_common_subtitle_portion = non_common_parts.join(" or ") + (common_suffix ?? "");
+                        }
+                    }
+                    else {
+                        let saw_non_common_subtitles = false;
+                        const non_common_subtitles = [];
+                        for (const this_subtitles of seg_subtitleses) {
+                            const this_non_common_subtitles = [];
+                            for (let j = num_common_subtitles; j < this_subtitles.length; j++) {
+                                this_non_common_subtitles.push(this_subtitles[j]);
+                            }
+                            if (this_non_common_subtitles.length > 0) {
+                                non_common_subtitles.push(this_non_common_subtitles.join(", "));
+                                saw_non_common_subtitles = true;
+                            }
+                            else {
+                                non_common_subtitles.push("otherwise");
+                            }
+                        }
+                        non_common_subtitle_portion = saw_non_common_subtitles ? non_common_subtitles.join(" or ") : "";
+                    }
+                    const subtitle_portions = [];
+                    if (common_subtitle_portion) {
+                        subtitle_portions.push(common_subtitle_portion);
+                    }
+                    if (non_common_subtitle_portion) {
+                        subtitle_portions.push(non_common_subtitle_portion);
+                    }
+                    if (seg_stems_seen.length > 1) {
+                        const number_to_english = [
+                            "zero", "one", "two", "three", "four", "five"
+                        ];
+                        subtitle_portions.push((number_to_english[seg_stems_seen.length] || `${seg_stems_seen.length}`) + " different stems");
+                    }
+                    const subtitle_portion = subtitle_portions.join("; ");
+                    if (subtitle_portion) {
+                        title_to_insert = (alternant_decl_title ?? "") + " (" + subtitle_portion + ")";
+                    }
+                    else {
+                        title_to_insert = alternant_decl_title;
+                    }
+                }
+                if (title_to_insert) {
+                    declensions.title.push(title_to_insert);
+                }
+            }
+            else {
+                for (const slot of this.iter_slots(is_adj)) {
+                    const prefix = slot.includes("linked") ? seg.orig_prefix : seg.prefix;
+                    const [forms, notes] = this.append_form(getNominalForm(declensions.forms, slot), declensions.notes.get(slot), [prefix || ""], undefined, undefined);
+                    setNominalForm(declensions.forms, slot, forms);
+                    declensions.notes.set(slot, notes);
+                }
+                declensions.title.push("[[Appendix:Glossary#indeclinable|indeclinable]] portion");
+            }
+        }
+        const titles = [];
+        declensions.title.forEach((title, i) => {
+            if (i == 0) {
+                titles.push(this.uppercase_first_visible(title));
+            }
+            else {
+                titles.push(this.add_indefinite_article(title));
+            }
+        });
+        declensions.title = [titles.join(" with ")];
+        return declensions;
+    }
+    add_indefinite_article(text) {
+        // Determine the first visible character (display text of wikilink if present)
+        // to choose "a" vs "an". Do NOT lowercase: Lua's add_indefinite_article passes
+        // the text through unchanged and only prepends the article.
+        let first_visible = text;
+        const wikilink_match = text.match(/^\[\[[^\]]*\|([^\]]+)/);
+        if (wikilink_match) {
+            first_visible = wikilink_match[1];
+        }
+        if (first_visible.match(/^[aeiou]/i)) {
+            return `an ${text}`;
+        }
+        else {
+            return `a ${text}`;
+        }
+    }
+    uppercase_first_visible(text) {
+        // Handle titles that begin with a wikilink: [[...|text]]
+        if (text.match(/^\[\[[^\]]*\|[a-z]/)) {
+            return text.replace(/^(\[\[[^\]]*\|)([a-z])/, (_m, prefix, first) => `${prefix}${first.toUpperCase()}`);
+        }
+        if (text.match(/^[a-z]/)) {
+            return text[0].toUpperCase() + text.slice(1);
+        }
+        return text;
+    }
+    lowercase_first_visible(text) {
+        // Handle titles that begin with a wikilink: [[...|Text]]
+        if (text.match(/^\[\[[^\]]*\|[A-Z]/)) {
+            return text.replace(/^(\[\[[^\]]*\|)([A-Z])/, (_m, prefix, first) => `${prefix}${first.toLowerCase()}`);
+        }
+        if (text.match(/^[A-Z]/)) {
+            return text[0].toLowerCase() + text.slice(1);
+        }
+        return text;
+    }
+    join_sentences(sentences, joiner) {
+        const sentences_to_join = [];
+        sentences.forEach((sentence, i) => {
+            if (i < sentences.length - 1) {
+                sentence = sentence.replace(/\.$/, "");
+            }
+            if (i > 0) {
+                sentence = sentence[0].toLowerCase() + sentence.slice(1);
+            }
+            sentences_to_join.push(sentence);
+        });
+        return sentences_to_join.join(joiner);
+    }
+    set_difference(a, b) {
+        const res = new Set();
+        for (const key of a.keys()) {
+            if (!b.has(key)) {
+                res.add(key);
+            }
+        }
+        return res;
+    }
+    append_form(forms, notes, new_forms, new_notes, prefix) {
+        forms = forms || [];
+        new_forms = new_forms || [];
+        notes = notes || [];
+        new_notes = new_notes || [];
+        prefix = prefix || "";
+        if (new_forms.length == 1) {
+            for (let i = 0; i < forms.length; i++) {
+                const base = (forms[i] == LaNominal.EmptyForm && (prefix || (new_forms[0] && new_forms[0] != LaNominal.EmptyForm))) ? "-" : forms[i];
+                const suffix = (base && base != LaNominal.EmptyForm && new_forms[0] == LaNominal.EmptyForm) ? "-" : new_forms[0];
+                forms[i] = base + prefix + suffix;
+                if (new_notes[0]) {
+                    if (!notes[i]) {
+                        notes[i] = new_notes[0];
+                    }
+                    else {
+                        const combined_notes = Array.from(notes[i]);
+                        for (const note of new_notes[0]) {
+                            combined_notes.push(note);
+                        }
+                        notes[i] = combined_notes;
+                    }
+                }
+            }
+            return [forms, notes];
+        }
+        else {
+            const ret_forms = [];
+            const ret_notes = [];
+            for (let i = 0; i < forms.length; i++) {
+                for (let j = 0; j < new_forms.length; j++) {
+                    const base = (forms[i] == LaNominal.EmptyForm && (prefix || (new_forms[j] && new_forms[j] != LaNominal.EmptyForm))) ? "-" : forms[i];
+                    const suffix = (base && base != LaNominal.EmptyForm && new_forms[j] == LaNominal.EmptyForm) ? "-" : new_forms[j];
+                    ret_forms.push(base + prefix + suffix);
+                    if (new_notes[j]) {
+                        if (!notes[i]) {
+                            ret_notes[i * new_forms.length + j] = new_notes[j];
+                        }
+                        else {
+                            const combined_notes = Array.from(notes[i]);
+                            for (const note of new_notes[j]) {
+                                combined_notes.push(note);
+                            }
+                            ret_notes[i * new_forms.length + j] = combined_notes;
+                        }
+                    }
+                }
+            }
+            return [ret_forms, ret_notes];
+        }
+    }
+    apply_ligatures(forms, is_adj) {
+        for (const slot of this.iter_slots(is_adj)) {
+            const ffs = getNominalForm(forms, slot) || [];
+            for (let i = 0; i < ffs.length; i++) {
+                ffs[i] = ffs[i].replace(/Ae/g, "Æ");
+                ffs[i] = ffs[i].replace(/Oe/g, "Œ");
+                ffs[i] = ffs[i].replace(/ae/g, "æ");
+                ffs[i] = ffs[i].replace(/oe/g, "œ");
+            }
+            setNominalForm(forms, slot, ffs);
+        }
+    }
+    apply_sufn(forms, is_adj) {
+        for (const slot of this.iter_slots(is_adj)) {
+            const ffs = getNominalForm(forms, slot) || [];
+            if (ffs.length == 1 && !slot.includes("linked")) {
+                const form = ffs[0];
+                if (form.match(/m$/)) {
+                    const keep = this.options.suppressSufNM ? [] : ffs;
+                    setNominalForm(forms, slot, [form.replace(/m$/, "n"), ...keep]);
+                }
+            }
+            else {
+                let final_m = false;
+                for (const form of getNominalForm(forms, slot) || []) {
+                    if (form.match(/m$/)) {
+                        final_m = true;
+                    }
+                }
+                if (final_m) {
+                    const newval = [];
+                    for (const form of getNominalForm(forms, slot) || []) {
+                        if (form.match(/m$/)) {
+                            const val = form.replace(/m$/, "n");
+                            newval.push(val);
+                        }
+                        if (!this.options.suppressSufNM) {
+                            newval.push(form);
+                        }
+                    }
+                    setNominalForm(forms, slot, newval);
+                }
+            }
+        }
+    }
+    propagate_number_restrictions(forms, num, is_adj) {
+        if (num == "sg" || num == "pl") {
+            for (const slot of this.iter_slots(is_adj)) {
+                if (slot.match(num)) {
+                    const other_num_slot = (num == "sg") ? slot.replace("sg", "pl") : slot.replace("pl", "sg");
+                    setNominalForm(forms, other_num_slot, getNominalForm(forms, slot) || []);
+                }
+            }
+        }
+    }
+    insert_if_not(data, entry, pos = 0) {
+        if (data.includes(entry)) {
+            return;
+        }
+        if (pos == 0) {
+            data.push(entry);
+        }
+        else {
+            data.splice(pos - 1, 0, entry);
+        }
+    }
+}