@larsgw/formica 0.8.5 → 0.8.7

package/lib/resources/parse-name.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RANKS = void 0;
+exports.RANKS = exports.RecoverableSyntaxError = void 0;
 exports.parseName = parseName;
+class RecoverableSyntaxError extends SyntaxError {
+    constructor(message, result) {
+        super(message);
+        this.result = result;
+    }
+}
+exports.RecoverableSyntaxError = RecoverableSyntaxError;
 exports.RANKS = [
     'phylum',
     'subphylum',
@@ -33,12 +40,12 @@ exports.RANKS = [
     'race', // not ICZN
     'stirps' // not ICZN
 ];
-var TAXONOMIC_STATUS = {
+const TAXONOMIC_STATUS = {
     '>': 'incorrect',
     '+': 'heterotypic synonym',
     '=': 'synonym'
 };
-var RANK_LABELS = {
+const RANK_LABELS = {
     'subspecies': 'subsp.',
     'variety': 'var.',
     'form': 'f.',
@@ -46,7 +53,7 @@ var RANK_LABELS = {
     'race': 'r.',
     'stirps': 'st.'
 };
-var RANK_LABELS_REVERSE = {
+const RANK_LABELS_REVERSE = {
     'st': 'stirps',
     'r': 'race',
     'ab': 'aberration',
@@ -55,7 +62,7 @@ var RANK_LABELS_REVERSE = {
     'ssp': 'subspecies',
     'subsp': 'subspecies'
 };
-var HYBRID_SIGN = '\u00D7';
+const HYBRID_SIGN = '\u00D7';
 /**
  *   1. Any number of
  *      - capitalized words
@@ -66,9 +73,9 @@ var HYBRID_SIGN = '\u00D7';
  *   2. Followed by a capitalized word
  *   3. Optionally, followed by "et al."
  */
-var LOWERCASE_NAME_PARTICLES = ['y', 'der', 'den', 'de', 'van', 'von'].join('|');
-var SIMPLE_AUTHOR_PATTERN = '(?:(?:\\p{Lu}\\S*|&|in|ex|' + LOWERCASE_NAME_PARTICLES + ')\\s*)*\\p{Lu}\\S+(?:\\s+et\\s+al\\.)?';
-var NAME_PATTERN = new RegExp('^' +
+const LOWERCASE_NAME_PARTICLES = ['y', 'der', 'den', 'de', 'van', 'von'].join('|');
+const SIMPLE_AUTHOR_PATTERN = '(?:(?:\\p{Lu}\\S*|&|in|ex|' + LOWERCASE_NAME_PARTICLES + ')\\s*)*\\p{Lu}\\S+(?:\\s+et\\s+al\\.)?';
+const NAME_PATTERN = new RegExp('^' +
     // $1 main name part
     '(\\S+)' +
     // $2 optional author citation
@@ -93,7 +100,7 @@ var NAME_PATTERN = new RegExp('^' +
  *   $1 genus: ((?:x )?[A-Z]\S+)
  *   $2 subgenus: (?:\(([A-Z]\S+?)\) )?
  */
-var SUBGENUS_PATTERN = /^([A-Z]\S+) (?:\(([A-Z]\S+?)\))(?= |$)/;
+const SUBGENUS_PATTERN = /^([A-Z]\S+) (?:\(([A-Z]\S+?)\))(?= |$)/;
 /**
  * Structure
  *   $1 genus+subgenus (+ trailing space): (?:([A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?
@@ -104,7 +111,7 @@ var SUBGENUS_PATTERN = /^([A-Z]\S+) (?:\(([A-Z]\S+?)\))(?= |$)/;
  *     $2b hybrid: [a-z-][^\s.]+(?: x [a-z-]+)?
  *     $2c intergeneric hybrid: [A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+
  */
-var BINAME_PATTERN = /^(?:((?:x )?[A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?(x [a-z-]+|[a-z-][^\s.]+(?: x [a-z-]+)?|[A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+)(?= |$)/;
+const BINAME_PATTERN = /^(?:((?:x )?[A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?(x [a-z-]+|[a-z-][^\s.]+(?: x [a-z-]+)?|[A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+)(?= |$)/;
 function compareRanks(a, b) {
     return exports.RANKS.indexOf(a) - exports.RANKS.indexOf(b);
 }
@@ -121,16 +128,13 @@ function isUpperCase(name) {
     return name === name.toUpperCase();
 }
 function getSynonymRank(name, rank) {
-    var rest = name.replace(BINAME_PATTERN, '');
-    var rankPrefix = rest.match(/^(?: |^)(st|r|ab|f|var|ssp|subsp)\. /);
+    const rest = name.replace(BINAME_PATTERN, '');
+    const rankPrefix = rest.match(/^(?: |^)(st|r|ab|f|var|ssp|subsp)\. /);
     if (rankPrefix) {
         return RANK_LABELS_REVERSE[rankPrefix[1]];
     }
-    else if (SUBGENUS_PATTERN.test(name)) {
-        return 'subgenus';
-    }
     else if (!BINAME_PATTERN.test(name)) {
-        return rank;
+        return SUBGENUS_PATTERN.test(name) ? 'subgenus' : rank;
     }
     else if (/^ (?!sensu)[a-z0-9-]+($| )/.test(rest)) {
         return 'subspecies';
@@ -142,15 +146,15 @@ function getSynonymRank(name, rank) {
 function capitalizeAuthors(authors) {
     return authors
         .replace(/[^\x00-\x40\x5B-\x60\x7B-\x7F]+/g, // eslint-disable-line no-control-regex
-    function (// eslint-disable-line no-control-regex
-    name) { return isUpperCase(name) ? capitalize(name) : name; })
+    // eslint-disable-line no-control-regex
+    name => isUpperCase(name) ? capitalize(name) : name)
         .replace(/ Y /g, ' y ');
 }
 function parseName(name, rank, parent) {
     var _a, _b;
-    var item = {};
+    const item = {};
     // Synonyms have the accepted name usage as 'parent'.
-    var isSynonym = /^[+=>] /.test(name);
+    const isSynonym = /^[+=>] /.test(name);
     if (isSynonym) {
         item.taxonomicStatus = TAXONOMIC_STATUS[name[0]];
         name = name.replace(/^[+=>] (\? ?)?/, '');
@@ -170,7 +174,7 @@ function parseName(name, rank, parent) {
     // For parsing, it needs to match the current file. If relevant parents
     // (i.e. genus, species) had mistakes that were corrected, the uncorrected
     // genus and species names need to be used.
-    var parentContext = {
+    const parentContext = {
         genus: parent.genus,
         subgenus: parent.subgenus,
         specificEpithet: parent.specificEpithet,
@@ -184,7 +188,7 @@ function parseName(name, rank, parent) {
     // provide parts of the name (e.g. bare species without a genus parent, or
     // even subspecies without a species or genus parent).
     if (isSynonym || !parentContext.genus || (compareRanks('species', rank) < 0 && !parentContext.specificEpithet)) {
-        var _c = (_b = (_a = name.match(BINAME_PATTERN)) !== null && _a !== void 0 ? _a : name.match(SUBGENUS_PATTERN)) !== null && _b !== void 0 ? _b : [], genus = _c[1], subgenus = _c[2], species = _c[3];
+        const [, genus, subgenus, species] = (_b = (_a = name.match(BINAME_PATTERN)) !== null && _a !== void 0 ? _a : name.match(SUBGENUS_PATTERN)) !== null && _b !== void 0 ? _b : [];
         if (genus) {
             parentContext.incorrect.genus = genus;
             parentContext.genus = capitalizeGenericName(genus.replace(/(^| )x /, HYBRID_SIGN));
@@ -207,7 +211,7 @@ function parseName(name, rank, parent) {
     // further.
     if (compareRanks('group', rank) <= 0) {
         // Remove genus
-        var genus = parentContext.incorrect.genus || parentContext.genus || '';
+        const genus = parentContext.incorrect.genus || parentContext.genus || '';
         if (name[0] === genus[0] && name.toLowerCase().startsWith(genus.toLowerCase() + ' ')) {
             name = name.slice(genus.length + 1);
         }
@@ -216,7 +220,7 @@ function parseName(name, rank, parent) {
         // Infraspecific taxa
         if (compareRanks('species', rank) < 0) {
             // Remove specific epithet
-            var species = parentContext.incorrect.specificEpithet || parentContext.specificEpithet || '';
+            const species = parentContext.incorrect.specificEpithet || parentContext.specificEpithet || '';
             if (name.startsWith(species + ' ')) {
                 name = name.slice(species.length + 1);
             }
@@ -226,7 +230,7 @@ function parseName(name, rank, parent) {
     }
     else if (compareRanks('genus', rank) <= 0) {
         // Remove genus
-        var genus = parentContext.incorrect.genus || parentContext.genus || '';
+        const genus = parentContext.incorrect.genus || parentContext.genus || '';
         if (name[0] === genus[0] && name.toLowerCase().startsWith(genus.toLowerCase() + ' (')) {
             name = name.slice(genus.length + 1);
         }
@@ -242,9 +246,9 @@ function parseName(name, rank, parent) {
     }
     // Divide the name into the main scientific name (only the epithet for taxa
     // lower than genus), the authorship information, and optionally remarks
-    var nameParts = name.match(NAME_PATTERN);
+    const nameParts = name.match(NAME_PATTERN);
     if (!nameParts) {
-        throw new Error("Taxon \"".concat(name, "\" could not be parsed"));
+        throw new Error(`Taxon "${name}" could not be parsed`);
     }
     // To encode old names with spaces (e.g. "Orsillus pini canariensis Lindberg, 1953")
     // underscores are used, which are replaced here. This is also used for undescribed
@@ -253,25 +257,28 @@ function parseName(name, rank, parent) {
     if (nameParts[1].includes('_')) {
         nameParts[1] = nameParts[1].replace(/_/g, ' ');
     }
-    var _ = nameParts[0], taxon = nameParts[1], _d = nameParts[2], citation = _d === void 0 ? '' : _d, notes = nameParts[3];
+    const [_, taxon, citation = '', notes] = nameParts;
     item.scientificNameAuthorship = capitalizeAuthors(citation);
     item.taxonRemarks = notes;
     item.taxonRank = rank;
-    // @ts-expect-error TS1501: This regular expression flag is only available when targeting 'es6' or later.
+    item.genericName = undefined;
+    item.infragenericEpithet = undefined;
+    item.specificEpithet = undefined;
+    item.infraspecificEpithet = undefined;
     if (/[^\p{L}0-9\u{00D7}\- ]/u.test(taxon)) {
-        throw new Error("Taxon name contains unexpected characters: \"".concat(taxon, "\""));
+        throw new RecoverableSyntaxError(`Taxon name contains unexpected characters: "${taxon}"`, item);
     }
     // Validate names and recompose binomial and trinomial names
     if (compareRanks('genus', rank) > 0) {
         item.scientificName = capitalize(taxon);
         if (taxon[0].toUpperCase() !== taxon[0]) {
-            throw new Error("Taxon name (".concat(rank, ") should be capitalized: \"").concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Taxon name (${rank}) should be capitalized: "${taxon}"`, item);
         }
     }
     else if (rank === 'genus') {
         item.scientificName = capitalizeGenericName(taxon);
         if (taxon[0].toUpperCase() !== taxon[0] || (taxon[0] === HYBRID_SIGN && taxon[1].toUpperCase() !== taxon[1])) {
-            throw new Error("Generic epithet should be capitalized: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Generic epithet should be capitalized: "${taxon}"`, item);
         }
     }
     else if (compareRanks('group', rank) > 0) {
@@ -279,48 +286,44 @@ function parseName(name, rank, parent) {
         item.infragenericEpithet = parentContext.subgenus;
         item.scientificName = capitalize(taxon);
         if (taxon[0].toUpperCase() !== taxon[0]) {
-            throw new Error("Infrageneric epithet should be capitalized: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Infrageneric epithet should be capitalized: "${taxon}"`, item);
         }
     }
     else if (rank === 'group') {
         item.genericName = parentContext.genus;
         item.infragenericEpithet = parentContext.subgenus;
-        var specificEpithet = taxon.toLowerCase().replace(/(-group)?$/, '');
-        item.scientificName = "".concat(item.genericName, " ").concat(specificEpithet, "-group");
+        const specificEpithet = taxon.toLowerCase().replace(/(-group)?$/, '');
+        item.scientificName = `${item.genericName} ${specificEpithet}-group`;
         if (taxon.toLowerCase() !== taxon) {
-            console.log(item, taxon);
-            throw new Error("Group name should be lowercase: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Group name should be lowercase: "${taxon}"`, item);
         }
     }
     else if (rank === 'subgroup') {
         item.genericName = parentContext.genus;
         item.infragenericEpithet = parentContext.subgenus;
-        var specificEpithet = taxon.toLowerCase().replace(/(-subgroup)?$/, '');
-        item.scientificName = "".concat(item.genericName, " ").concat(specificEpithet, "-subgroup");
+        const specificEpithet = taxon.toLowerCase().replace(/(-subgroup)?$/, '');
+        item.scientificName = `${item.genericName} ${specificEpithet}-subgroup`;
         if (taxon.toLowerCase() !== taxon) {
-            console.log(item, taxon);
-            throw new Error("Subgroup name should be lowercase: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Subgroup name should be lowercase: "${taxon}"`, item);
         }
     }
     else if (compareRanks('species', rank) > 0) {
         item.genericName = parentContext.genus;
         item.infragenericEpithet = parentContext.subgenus;
-        var specificEpithet = taxon.toLowerCase();
-        item.scientificName = "".concat(item.genericName, " ").concat(specificEpithet);
+        const specificEpithet = taxon.toLowerCase();
+        item.scientificName = `${item.genericName} ${specificEpithet}`;
         if (specificEpithet !== taxon) {
-            console.log(item, taxon);
-            throw new Error("Subgroup name should be lowercase: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Taxon name should be lowercase: "${taxon}"`, item);
         }
     }
     else if (rank === 'species') {
         item.genericName = parentContext.genus;
         item.infragenericEpithet = parentContext.subgenus;
         if (taxon.toLowerCase() !== taxon && !/^[A-Z][a-z]+ [a-z]+\xD7[A-Z][a-z]+ [a-z]+$/.test(taxon)) {
-            console.log(item, taxon);
-            throw new Error("Specific epithet should be lowercase: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Specific epithet should be lowercase: "${taxon}"`, item);
         }
         item.specificEpithet = taxon;
-        item.scientificName = "".concat(item.genericName, " ").concat(item.specificEpithet);
+        item.scientificName = `${item.genericName} ${item.specificEpithet}`;
     }
     else if (compareRanks('species', rank) < 0) {
         item.genericName = parentContext.genus;
@@ -329,24 +332,23 @@ function parseName(name, rank, parent) {
         item.infraspecificEpithet = taxon.toLowerCase();
         // If possible, names below species should have abbreviations for ranks,
         // like "subsp."
-        var nameParts_1 = [
+        const nameParts = [
             item.genericName,
             item.specificEpithet,
             item.infraspecificEpithet
         ];
         if (item.taxonRank in RANK_LABELS) {
-            nameParts_1.splice(2, 0, RANK_LABELS[item.taxonRank]);
+            nameParts.splice(2, 0, RANK_LABELS[item.taxonRank]);
         }
-        item.scientificName = nameParts_1.join(' ');
+        item.scientificName = nameParts.join(' ');
         if (item.infraspecificEpithet !== taxon) {
-            console.log(item, taxon);
-            throw new Error("Infraspecific epithet should be lowercase: \"".concat(taxon, "\""));
+            throw new RecoverableSyntaxError(`Infraspecific epithet should be lowercase: "${taxon}"`, item);
         }
     }
     // Re-add authorship information
     item.scientificNameOnly = item.scientificName;
     if (item.scientificNameAuthorship) {
-        item.scientificName += " ".concat(item.scientificNameAuthorship);
+        item.scientificName += ` ${item.scientificNameAuthorship}`;
     }
     return item;
 }