@fpw/en-wiktionary-la-modules 0.1.1 → 0.1.4

package/dist/modules/declination/LaNominal.js

@@ -6,7 +6,7 @@ exports.LaNominal = exports.NumberTantum = exports.Gender = void 0;
  * 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=62391877
+ * Based on version: https://en.wiktionary.org/w/index.php?title=Module:la-nominal&oldid=68705587
  *
  * Lua idioms, function and variable names kept as in the original in order to easily
  * backport later changes to this implementation.
@@ -19,6 +19,7 @@ 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";
@@ -88,8 +89,9 @@ class LaNominal {
         ]);
         this.options = options || {};
     }
-    do_generate_noun_forms(args, pos = "nouns", from_headword = false) {
+    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");
@@ -134,8 +136,9 @@ class LaNominal {
         this.process_noun_forms_and_overrides(all_data, args);
         return all_data;
     }
-    do_generate_adj_forms(args, pos = "adjectives", from_headword = false) {
+    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+>" : "<+>");
@@ -178,6 +181,7 @@ class LaNominal {
             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
@@ -221,11 +225,13 @@ class LaNominal {
             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");
+            if (parsed_run.apparent_decl == "indecl") {
+                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) {
@@ -284,6 +290,9 @@ class LaNominal {
             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) {
@@ -459,7 +468,7 @@ class LaNominal {
             num: num,
             gender: gender,
             is_adj: is_adj,
-            propses: propses
+            propses: propses,
         };
     }
     parse_alternant(alternant) {
@@ -571,7 +580,7 @@ class LaNominal {
             loc: loc,
             num: num,
             gender: gender,
-            propses: propses
+            propses: propses,
         };
     }
     capturing_split(str, pattern) {
@@ -601,11 +610,13 @@ class LaNominal {
                     const begins_with_hypen = m2[1];
                     spec = m2[2];
                     spec = begins_with_hypen + spec.replace(/-/g, "_");
-                    types.add(spec);
+                    if (spec) {
+                        (0, NominalType_1.addNominalType)(types, spec);
+                    }
                 }
             }
         }
-        const orig_lemma = stems[0];
+        const orig_lemma = stems[0] || this.title;
         if (!orig_lemma) {
             throw Error("No lemma");
         }
@@ -630,8 +641,8 @@ class LaNominal {
                 headword_decl = decl + "+";
             }
             for (const subtype of detected_subtypes) {
-                if (types.has("-" + subtype)) {
-                    types.delete("-" + subtype);
+                if ((0, NominalType_1.hasNominalType)(types, "-" + subtype)) {
+                    (0, NominalType_1.delNominalType)(types, "-" + subtype);
                 }
                 else {
                     types.add(subtype);
@@ -648,44 +659,46 @@ class LaNominal {
                 headword_decl = decl;
             }
             for (const subtype of detected_subtypes) {
-                if (types.has("-" + subtype)) {
-                    types.delete("-" + subtype);
+                if ((0, NominalType_1.hasNominalType)(types, "-" + subtype)) {
+                    (0, NominalType_1.delNominalType)(types, "-" + subtype);
                 }
-                else if ((subtype == "M" || subtype == "F" || subtype == "N") && (types.has("M") || types.has("F") || types.has("N"))) {
+                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 == "sg" || subtype == "pl" || subtype == "both") && (types.has("sg") || types.has("pl") || types.has("both"))) {
+                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("pl") && !types.has("both") && lemma.match(/^[A-ZĀĒĪŌŪȲĂĔĬŎŬ]/)) {
-                types.add("sg");
+            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("loc")) {
+        if (types.has(NominalType_1.NominalType.Locative)) {
             loc = true;
-            types.delete("loc");
+            types.delete(NominalType_1.NominalType.Locative);
         }
         let gender;
-        if (types.has("M")) {
+        if (types.has(NominalType_1.NominalType.Masculine)) {
             gender = Gender.M;
         }
-        else if (types.has("F")) {
+        else if (types.has(NominalType_1.NominalType.Feminine)) {
             gender = Gender.F;
         }
-        else if (types.has("N")) {
+        else if (types.has(NominalType_1.NominalType.Neuter)) {
             gender = Gender.N;
         }
-        if (types.has("pl")) {
+        if (types.has(NominalType_1.NominalType.Plural)) {
             num = NumberTantum.Plural;
-            types.delete("pl");
+            types.delete(NominalType_1.NominalType.Plural);
         }
-        else if (types.has("sg")) {
+        else if (types.has(NominalType_1.NominalType.Singular)) {
             num = NumberTantum.Singular;
-            types.delete("sg");
+            types.delete(NominalType_1.NominalType.Singular);
         }
         const args = [base, stem2];
         return {
@@ -704,9 +717,9 @@ class LaNominal {
         };
     }
     detect_adj_type_and_subtype(lemma, stem2, typ, subtypes) {
-        if (!typ.match(/^[0123]/) && !typ.match(/^irreg/)) {
+        if (!typ.match(/^[0123]/) && !typ.match(/^irreg/) && typ) {
             subtypes = new Set(subtypes);
-            subtypes.add(typ);
+            (0, NominalType_1.addNominalType)(subtypes, typ);
             typ = "";
         }
         function base_as_stem2(base, stem2x) {
@@ -725,17 +738,17 @@ class LaNominal {
             ["us", "1&2", []],
             ["a", "1&2", []],
             ["um", "1&2", []],
-            ["ī", "1&2", ["pl"]],
-            ["ae", "1&2", ["pl"]],
-            ["a", "1&2", ["pl"]],
-            ["os", "1&2", ["greekA", "-greekE"]],
-            ["os", "1&2", ["greekE", "-greekA"]],
-            ["ē", "1&2", ["greekE", "-greekA"]],
-            ["on", "1&2", ["greekA", "-greekE"]],
-            ["on", "1&2", ["greekE", "-greekA"]],
-            ["^(.*er)$", "1&2", ["er"]],
-            ["^(.*ur)$", "1&2", ["er"]],
-            ["^(h)ic$", "1&2", ["ic"]],
+            ["ī", "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", []],
@@ -743,16 +756,16 @@ class LaNominal {
             ["e", "3-2", []],
             ["^(.*[ij])or$", "3-C", []],
             ["^(min)or$", "3-C", []],
-            ["^(.*ēs)$", "3-1", ["I"]],
-            ["^(.*ēs)$", "3-1", ["par"]],
-            ["^(.*[ij])ōrēs$", "3-C", ["pl"]],
-            ["^(min)ōrēs$", "3-C", ["pl"]],
-            ["ēs", "3-2", ["pl", "I"]],
-            ["ēs", "3-1", ["pl", "par"], base_as_stem2],
-            ["ia", "3-2", ["pl", "I"]],
-            ["a", "3-1", ["pl", "par"], base_as_stem2],
-            ["", "3-1", ["I"]],
-            ["", "3-1", ["par"]],
+            ["^(.*ē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);
@@ -775,30 +788,30 @@ class LaNominal {
         else if (typ == "1-1") {
             return this.get_adj_type_and_subtype_by_ending(lemma, stem2, typ, subtypes, [
                 ["a", "1-1", []],
-                ["ae", "1-1", ["pl"]]
+                ["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", ["pl"]],
-                ["a", "2-2", ["pl"]],
-                ["os", "2-2", ["greek"]],
-                ["on", "2-2", ["greek"]],
-                ["oe", "2-2", ["greek", "pl"]],
+                ["ī", "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", ["I"]],
-                ["^(.*ēs)$", "3-1", ["par"]],
-                ["ēs", "3-1", ["pl", "I"], base_as_stem2],
-                ["ēs", "3-1", ["pl", "par"], base_as_stem2],
-                ["ia", "3-1", ["pl", "I"], base_as_stem2],
-                ["a", "3-1", ["pl", "par"], base_as_stem2],
-                ["", "3-1", ["I"]],
-                ["", "3-1", ["par"]],
+                ["^(.*ē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") {
@@ -806,52 +819,52 @@ class LaNominal {
                 ["is", "3-2", []],
                 ["e", "3-2", []],
                 ["ēs", "3-2", []],
-                ["ēs", "3-2", ["pl"]],
-                ["ia", "3-2", ["pl"]],
+                ["ē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", ["pl"]],
-                ["^(min)ōrēs$", "3-C", ["pl"]],
+                ["^(.*[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, ["pl"]],
-                ["^(ambō)$", typ, ["pl"]],
-                ["^(mīll?ia)$", typ, ["N", "pl"], constant_base("mīlle")],
+                ["^(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, ["pl"], constant_base("is")],
-                ["^(eae?)$", typ, ["pl"], 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, ["pl"]],
-                ["^(eae?dem)$", typ, ["pl"], 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, ["pl"], (base, s2) => [base + "e", ""]],
-                ["^(i[lps][lst])ae?$", typ, ["pl"], (base, s2) => [base + "e", ""]],
+                ["^(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, ["pl"]],
+                ["^(quī)$", typ, [NominalType_1.NominalType.Plural]],
                 ["^(quae)$", typ, [], constant_base("quī")],
-                ["^(quae)$", typ, ["pl"], 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, ["pl"], constant_base("quisquis")],
-                ["^(quaequae)$", typ, ["pl"], 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, ["pl"], base_as_stem2],
-                ["ia", typ, ["pl"], base_as_stem2],
+                ["ēs", typ, [NominalType_1.NominalType.Plural], base_as_stem2],
+                ["ia", typ, [NominalType_1.NominalType.Plural], base_as_stem2],
                 ["", typ, []],
             ], decl3_stem2);
         }
@@ -859,17 +872,17 @@ class LaNominal {
     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("pl") && !subtypes.includes("pl")) {
+            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 (specified_subtypes.has("-" + subtype)) {
+                    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 && specified_subtypes.has(must_not_be_present[1])) {
+                    if (must_not_be_present && (0, NominalType_1.hasNominalType)(specified_subtypes, must_not_be_present[1])) {
                         not_this_subtype = true;
                         break;
                     }
@@ -918,49 +931,49 @@ class LaNominal {
     detect_noun_subtype(lemma, stem2, typ, subtypes) {
         if (typ == "1") {
             return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["ām", ["F", "am"]],
-                ["ās", ["M", "Greek", "Ma"]],
-                ["ēs", ["M", "Greek", "Me"]],
-                ["ē", ["F", "Greek"]],
-                ["ae", ["F", "pl"]],
-                ["a", ["F"]],
+                ["ā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)$", ["M", "er"]],
-                ["^(.*v)os$", ["M", "vos"]],
-                ["^(.*v)om$", ["N", "vom"]],
-                ["os", ["M", "Greek"]],
-                ["os", ["N", "Greek", "us"]],
-                ["on", ["N", "Greek"]],
-                ["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*)ius$", ["M", "ius", "voci", "sg"]],
-                ["ius", ["M", "ius"]],
-                ["ium", ["N", "ium"]],
-                ["us", ["M"]],
-                ["us", ["N", "us"]],
-                ["um", ["N"]],
-                ["iī", ["M", "ius", "pl"]],
-                ["ia", ["N", "ium", "pl"]],
-                ["ī", ["M", "pl"]],
-                ["ī", ["N", "us", "pl"]],
-                ["a", ["N", "pl"]],
+                ["^(.*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("pl")) {
-                if (subtypes.has("Greek")) {
+            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(["er"])];
+                        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(["on"])];
+                        return [match[1] + "ōn", match[1] + "ont", new Set([NominalType_1.NominalType.On])];
                     }
                     match = lemma.match(/^(.*)es$/);
                     if (match) {
@@ -970,11 +983,11 @@ class LaNominal {
                 }
                 match = lemma.match(/^(.*)ia$/);
                 if (match) {
-                    return ["foo", stem2 || match[1], new Set(["N", "I", "pure"])];
+                    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(["N"])];
+                    return ["foo", stem2 || match[1], new Set([NominalType_1.NominalType.Neuter])];
                 }
                 match = lemma.match(/^(.*)ēs$/);
                 if (match) {
@@ -986,46 +999,46 @@ class LaNominal {
             let detected_subtypes;
             let base;
             let tmp;
-            if (subtypes.has("Greek")) {
+            if (subtypes.has(NominalType_1.NominalType.Greek)) {
                 [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
-                    [["is", ""], ["I"]],
-                    ["ēr", ["er"]],
-                    ["ōn", ["on"]],
+                    [["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("N")) {
+            if (!subtypes.has(NominalType_1.NominalType.Neuter)) {
                 [base, tmp, detected_subtypes] = this.get_noun_subtype_by_ending(lemma, stem2, "", subtypes, [
-                    [["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*pol)is$", ""], ["F", "polis", "sg", "loc"]],
-                    [["tūdō", "tūdin"], ["F"]],
-                    [["tās", "tāt"], ["F"]],
-                    [["tūs", "tūt"], ["F"]],
-                    [["tiō", "tiōn"], ["F"]],
-                    [["siō", "siōn"], ["F"]],
-                    [["xiō", "xiōn"], ["F"]],
-                    [["gō", "gin"], ["F"]],
-                    [["or", "ōr"], ["M"]],
-                    [["trīx", "trīc"], ["F"]],
-                    [["trix", "trīc"], ["F"]],
-                    [["is", ""], ["I"]],
-                    [["^([a-zāēīōūȳăĕĭŏŭ].*)ēs$", ""], ["I"]],
+                    [["^([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"], ["N"]],
-                [["us", "er"], ["N"]],
-                [["ma", "mat"], ["N"]],
-                [["men", "min"], ["N"]],
-                [["^([A-ZĀĒĪŌŪȲĂĔĬŎŬ].*)e$", ""], ["N", "sg"]],
-                [["e", ""], ["N", "I", "pure"]],
-                [["al", "āl"], ["N", "I", "pure"]],
-                [["ar", "ār"], ["N", "I", "pure"]],
+                [["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];
@@ -1033,39 +1046,39 @@ class LaNominal {
             return [lemma, stem2, new Set()];
         }
         else if (typ == "4") {
-            if (subtypes.has("echo") || subtypes.has("argo") || subtypes.has("Callisto")) {
+            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("Callisto")) {
-                    return [base, "", new Set(["F", "sg"])];
+                if (subtypes.has(NominalType_1.NominalType.Callisto)) {
+                    return [base, "", new Set([NominalType_1.NominalType.Feminine, NominalType_1.NominalType.Singular])];
                 }
                 else {
-                    return [base, "", new Set(["F"])];
+                    return [base, "", new Set([NominalType_1.NominalType.Feminine])];
                 }
             }
             return this.get_noun_subtype_by_ending(lemma, stem2, typ, subtypes, [
-                ["us", ["M"]],
-                ["ū", ["N"]],
-                ["ūs", ["M", "pl"]],
-                ["ua", ["N", "pl"]],
+                ["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", ["F", "i"]],
-                ["iēs", ["F", "i", "pl"]],
-                ["ēs", ["F"]],
-                ["ēs", ["F", "pl"]],
+                ["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(["loc"])];
+            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(["sg"])];
+            return [lemma, "", new Set([NominalType_1.NominalType.Singular])];
         }
         else {
             return [lemma, "", new Set()];
@@ -1110,16 +1123,16 @@ class LaNominal {
             const ending = ending_and_subtype[0];
             const subtypes = ending_and_subtype[1];
             let not_this_subtype = false;
-            if (specified_subtypes.has("pl") && !subtypes.includes("pl")) {
+            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 (specified_subtypes.has("-" + subtype) ||
-                        (subtype == "N" && (specified_subtypes.has("M") || specified_subtypes.has("F"))) ||
-                        ((subtype == "M" || subtype == "F") && specified_subtypes.has("N")) ||
-                        (subtype == "sg" && specified_subtypes.has("pl")) ||
-                        (subtype == "pl" && specified_subtypes.has("sg"))) {
+                    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;
                     }
@@ -1157,6 +1170,7 @@ class LaNominal {
             categories: [],
             voc: true,
             noneut: false,
+            nomf: false,
         };
         for (const slot of this.iter_slots(is_adj)) {
             (0, NominalForm_1.setNominalForm)(declensions.forms, slot, [""]);
@@ -1180,8 +1194,10 @@ class LaNominal {
                         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,
@@ -1195,10 +1211,13 @@ class LaNominal {
                     if (data.noneut) {
                         declensions.noneut = true;
                     }
-                    if (data.types.has("sufn")) {
+                    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("not_sufn")) {
+                    else if (data.types.has(NominalType_1.NominalType.NotSuffixN)) {
                         data.subtitles.push(["without", " 'm' optionally → 'n' in compounds"]);
                     }
                     if (data.title) {
@@ -1264,12 +1283,13 @@ class LaNominal {
                         else {
                             throw Error(`Internal error! Don't recognize noun declension ${apparent_decl}`);
                         }
+                        parsed_run.apparent_decl = apparent_decl;
                         data.title = data.title + " noun";
                     }
-                    if (data.types.has("sufn")) {
+                    if (data.types.has(NominalType_1.NominalType.SuffixN)) {
                         data.subtitles.push(["with", " 'm' optionally → 'n' in compounds"]);
                     }
-                    else if (data.types.has("not_sufn")) {
+                    else if (data.types.has(NominalType_1.NominalType.NotSuffixN)) {
                         data.subtitles.push(["without", " 'm' optionally → 'n' in compounds"]);
                     }
                     declensions.orig_titles.push(data.title);
@@ -1304,10 +1324,10 @@ class LaNominal {
                         (0, NominalForm_1.setNominalForm)(data.forms, `linked_${slot}`, linked_forms);
                     }
                 }
-                if (seg.types.has("lig")) {
+                if (seg.types.has(NominalType_1.NominalType.Ligature)) {
                     this.apply_ligatures(data.forms, is_adj);
                 }
-                if (seg.types.has("sufn")) {
+                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);
@@ -1346,7 +1366,7 @@ class LaNominal {
                     (0, NominalForm_1.setNominalForm)(declensions.forms, slot, forms);
                     declensions.notes.set(slot, notes);
                 }
-                if (!seg.types.has("nocat") && (is_adj || !seg.is_adj)) {
+                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);
                     }
@@ -1401,7 +1421,7 @@ class LaNominal {
                             if (segment.type == "Segment" && segment.decl) {
                                 const neg_subtypes = this.set_difference(subtypeses, segment.types);
                                 for (const neg_subtype of neg_subtypes) {
-                                    segment.types.add("not_" + neg_subtype);
+                                    (0, NominalType_1.addNominalType)(segment.types, "not_" + neg_subtype);
                                 }
                             }
                         }
@@ -1418,6 +1438,9 @@ class LaNominal {
                     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")) ||
@@ -1752,6 +1775,7 @@ class LaNominal {
                         }
                         newval.push(form);
                     }
+                    (0, NominalForm_1.setNominalForm)(forms, slot, newval);
                 }
             }
         }