@larsgw/formica 0.8.4 → 0.8.6

package/lib/resources/resource.js

@@ -1,30 +1,12 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkResource = void 0;
-var work_1 = require("../catalog/tables/work");
-var WorkResource = /** @class */ (function (_super) {
-    __extends(WorkResource, _super);
-    function WorkResource(values) {
-        var _this = _super.call(this, values) || this;
-        _this.schema.version_of.format = /^B[1-9]\d*:[1-9]\d*$/;
-        _this.schema.duplicate_of.format = /^B[1-9]\d*:[1-9]\d*$/;
-        return _this;
+const work_1 = require("../catalog/tables/work");
+class WorkResource extends work_1.Work {
+    constructor(values) {
+        super(values);
+        this.schema.version_of.format = /^B[1-9]\d*:[1-9]\d*$/;
+        this.schema.duplicate_of.format = /^B[1-9]\d*:[1-9]\d*$/;
     }
-    return WorkResource;
-}(work_1.Work));
+}
 exports.WorkResource = WorkResource;

package/lib/taxon-names/index.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupNameMatches = groupNameMatches;
 exports.amendResource = amendResource;
-var MINIMUM_PREFIX_LENGTH = 3;
-var VALID_COMMON_PREFIXES = new Set([
+const MINIMUM_PREFIX_LENGTH = 3;
+const VALID_COMMON_PREFIXES = new Set([
     'Plantae|Tracheophyta',
     'Fungi',
     'Fungi|Ascomycota',
@@ -11,7 +11,7 @@ var VALID_COMMON_PREFIXES = new Set([
     'Fungi|Zygomycota'
 ]);
 function getCommonPrefix(a, b) {
-    for (var i = 0; i < Math.max(a.length, b.length); i++) {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
         if (a[i] !== b[i]) {
             return a.slice(0, i);
         }
@@ -19,17 +19,17 @@ function getCommonPrefix(a, b) {
     return a.slice();
 }
 function isValidPrefix(a, b) {
-    var prefix = getCommonPrefix(a, b);
+    const prefix = getCommonPrefix(a, b);
     return VALID_COMMON_PREFIXES.has(prefix.join('|')) || prefix.length >= MINIMUM_PREFIX_LENGTH;
 }
 function groupNameMatches(results) {
-    var prefixes = {};
-    for (var scientificNameID in results) {
-        var _loop_1 = function (result) {
+    const prefixes = {};
+    for (const scientificNameID in results) {
+        for (const result of results[scientificNameID]) {
             if (!prefixes[result.source]) {
                 prefixes[result.source] = [];
             }
-            var prefix = prefixes[result.source].find(function (prefix) { return isValidPrefix(prefix[0], result.classificationPath); });
+            let prefix = prefixes[result.source].find(prefix => isValidPrefix(prefix[0], result.classificationPath));
             if (!prefix) {
                 prefix = [result.classificationPath, {}];
                 prefixes[result.source].push(prefix);
@@ -38,21 +38,16 @@ function groupNameMatches(results) {
                 prefix[0] = getCommonPrefix(prefix[0], result.classificationPath);
             }
             if (scientificNameID in prefix[1]) {
-                return "continue";
+                continue;
             }
             prefix[1][scientificNameID] = result;
-        };
-        for (var _i = 0, _a = results[scientificNameID]; _i < _a.length; _i++) {
-            var result = _a[_i];
-            _loop_1(result);
         }
     }
-    var groupedNameMatches = {};
-    for (var source in prefixes) {
+    const groupedNameMatches = {};
+    for (const source in prefixes) {
         groupedNameMatches[source] = prefixes[source]
-            .sort(function (a, b) { return Object.keys(b[1]).length - Object.keys(a[1]).length; })
-            .reduce(function (map, _a) {
-            var prefix = _a[0], taxa = _a[1];
+            .sort((a, b) => Object.keys(b[1]).length - Object.keys(a[1]).length)
+            .reduce((map, [prefix, taxa]) => {
             map[prefix.join('|')] = taxa;
             return map;
         }, {});
@@ -60,8 +55,8 @@ function groupNameMatches(results) {
     return groupedNameMatches;
 }
 function amendResource(resource, source, matches) {
-    for (var id in matches) {
-        var match = matches[id];
+    for (const id in matches) {
+        const match = matches[id];
         if (source === '1') {
             resource.taxa[id].colTaxonID = match.id;
             if (match.currentId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larsgw/formica",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "SDK and tools for data from the Library of Identification Resources",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -9,6 +9,7 @@
     "loir-validate-resources": "./lib/bin/validate-resources-text.js",
     "loir-resources-process": "./lib/bin/process-resources.js",
     "loir-resources-index": "./lib/bin/process-resources-index.js",
+    "loir-generate-linked-data": "./lib/bin/generate-linked-data.js",
     "loir-catalog-clean-links": "./lib/bin/clean-links.js"
   },
   "scripts": {

package/src/bin/generate-linked-data.ts

@@ -58,6 +58,7 @@ const SCOPES: Record<string, [string, string]> = {
     // sex
     'females': ['dwciri:sex', 'http://rs.gbif.org/vocabulary/gbif/sex/female'],
     'males': ['dwciri:sex', 'http://rs.gbif.org/vocabulary/gbif/sex/male'],
+    'male': ['dwciri:sex', 'http://rs.gbif.org/vocabulary/gbif/sex/male'],
 
     // caste
     'queens': ['dwc:caste', 'queen'],
@@ -231,7 +232,7 @@ function makeLinkedDataForTaxon (taxon: catalog.Entity): NodeObject {
     const node: NodeObject = {
         '@id': `${PREFIX}taxon/${taxon.get('id')}`,
         '@type': 'dwc:Taxon',
-        'dwc:scientificName': taxon.get('display_name'),
+        'dwc:scientificName': taxon.get('name'),
     }
 
     if (taxon.has('rank')) {
@@ -362,12 +363,14 @@ function makeLinkedDataForResource (work: catalog.Entity, files: Catalog, resour
 
     const types = resource.get('key_type') ?? work.get('key_type') ?? []
 
-    if (types.includes('matrix')) {
+    if (types.includes('matrix') || types.includes('algorithm')) {
         node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Software' }
     } else if (types.includes('key') || types.includes('reference') || types.includes('supplement')) {
         node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Text' }
     } else if (types.includes('gallery') || types.includes('collection')) {
         node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Collection' }
+    } else if (types.includes('checklist')) {
+        node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Dataset' }
     }
 
     if (types.includes('key') || types.includes('matrix')) {
@@ -660,10 +663,10 @@ function makeLinkedDataForWorks (files: Catalog): NodeObject[] {
             }
             (node['dcterms:hasPart'] as NodeObject[]).push(resource)
 
-            if (!Array.isArray(resource['dcterms:isPartof'])) {
-                resource['dcterms:isPartof'] = []
+            if (!Array.isArray(resource['dcterms:isPartOf'])) {
+                resource['dcterms:isPartOf'] = []
             }
-            (resource['dcterms:isPartof'] as NodeObject[]).push({ '@id': node['@id'] })
+            (resource['dcterms:isPartOf'] as NodeObject[]).push({ '@id': node['@id'] })
         }
     }
 

package/src/bin/process-resources.ts

@@ -232,7 +232,7 @@ class ResourceProcessor {
             const { resources } = await import('../index')
             return resources.parseTextFile(file, id, old)
         } catch (error) {
-            console.log(error)
+            console.log(error.message)
             await prompt(`${id}: generating Darwin Core failed, retry? `)
 
             // Clear cache to re-import

package/src/bin/validate-resources-text.ts

@@ -14,7 +14,7 @@ async function main (args: string[]): Promise<void> {
         try {
             resources.parseTextFile(file, id)
         } catch (error) {
-            console.error(filePath + '\n    ' + error.message + '\n')
+            console.error(filePath + '\n' + error.message.replace(/^/gm, '    ') + '\n')
             exitStatus = 1
         }
     }

package/src/module.d.ts

@@ -27,7 +27,7 @@ type TaxonId = string
 type ResourceId = string
 type WorkId = string
 
-interface WorkingTaxon {
+interface TaxonBase {
     scientificNameID?: TaxonId,
     scientificName?: string,
     scientificNameAuthorship?: string,
@@ -56,13 +56,15 @@ interface WorkingTaxon {
     subgenus?: string,
     higherClassification?: string,
     verbatimIdentification?: string,
+}
 
+interface WorkingTaxon extends TaxonBase {
     // Non-standard
     scientificNameOnly?: string,
     incorrect?: WorkingTaxon
 }
 
-interface Taxon extends WorkingTaxon {
+interface Taxon extends TaxonBase {
     scientificNameID: TaxonId,
     scientificName: string,
     taxonRank: Rank,

package/src/resources/diff-resource.ts

@@ -189,34 +189,38 @@ function getWordTokensFromLines (lines: ResourceDiff): string[] {
     return lines.flatMap(change => tokenizeWords(change.text as string).concat('\n'))
 }
 
+type MultilineDiffPart = { added: ResourceDiff, deleted: ResourceDiff }
+
+function mergeDiffPart (diffPart: MultilineDiffPart): ResourceDiff {
+    if (diffPart.added.length && diffPart.deleted.length) {
+        return convertWordDiff(diffTokens(getWordTokensFromLines(diffPart.added), getWordTokensFromLines(diffPart.deleted)))
+    } else if (diffPart.added.length) {
+        return diffPart.added
+    } else if (diffPart.deleted.length) {
+        return diffPart.deleted.map(change => ({ text: undefined, original: change.text, type: change.type }))
+    } else {
+        return []
+    }
+}
+
 export function createDiff (a: string, b: string): ResourceDiff {
     const lines: ResourceDiff = diffTokens(tokenizeLines(a.trimEnd()), tokenizeLines(b.trimEnd()))
 
     const changes: ResourceDiff = []
-    const diffPart: Record<string, ResourceDiff> = { added: [], deleted: [] }
+    const diffPart: MultilineDiffPart = { added: [], deleted: [] }
     for (let i = 0; i < lines.length; i++) {
         if (lines[i].type === ResourceDiffType.Added) {
             diffPart.added.push(lines[i])
-            continue
         } else if (lines[i].type === ResourceDiffType.Deleted) {
             diffPart.deleted.push(lines[i])
-            continue
-        }
-
-        if (diffPart.added.length && diffPart.deleted.length) {
-            changes.push(...convertWordDiff(diffTokens(getWordTokensFromLines(diffPart.added), getWordTokensFromLines(diffPart.deleted))))
-            diffPart.added.length = 0
-            diffPart.deleted.length = 0
-        } else if (diffPart.added.length) {
-            changes.push(...diffPart.added)
+        } else {
+            changes.push(...mergeDiffPart(diffPart), lines[i])
             diffPart.added.length = 0
-        } else if (diffPart.deleted.length) {
-            changes.push(...diffPart.deleted.map(change => ({ text: undefined, original: change.text, type: change.type })))
             diffPart.deleted.length = 0
         }
-
-        changes.push(lines[i])
     }
 
+    changes.push(...mergeDiffPart(diffPart))
+
     return changes
 }

package/src/resources/parse-name.ts

@@ -0,0 +1,379 @@
+export class RecoverableSyntaxError<Result> extends SyntaxError {
+    result: Result
+
+    constructor (message: string, result: Result) {
+        super(message)
+        this.result = result
+    }
+}
+
+export const RANKS: Rank[] = [
+    'phylum',
+    'subphylum',
+    'class',
+    'infraclass',
+    'superorder',
+    'order',
+    'suborder',
+    'infraorder',
+    'superfamily',
+    'family',
+    'subfamily',
+    'tribe',
+    'subtribe',
+    'genus',
+    'subgenus',
+    'section', // not ICZN
+    'subsection', // not ICZN
+    'series', // not ICZN
+    'group',
+    'subgroup', // ...
+    'aggregate', // not ICZN
+    'complex', // not ICZN
+    'species',
+    'subspecies',
+    'variety',
+    'form',
+    'aberration', // not ICZN
+    'race', // not ICZN
+    'stirps' // not ICZN
+]
+
+const TAXONOMIC_STATUS: Record<string, TaxonStatus> = {
+    '>': 'incorrect',
+    '+': 'heterotypic synonym',
+    '=': 'synonym'
+}
+
+const RANK_LABELS: Record<Rank, string> = {
+    'subspecies': 'subsp.',
+    'variety': 'var.',
+    'form': 'f.',
+    'aberration': 'ab.',
+    'race': 'r.',
+    'stirps': 'st.'
+}
+
+const RANK_LABELS_REVERSE: Record<string, Rank> = {
+    'st': 'stirps',
+    'r': 'race',
+    'ab': 'aberration',
+    'f': 'form',
+    'var': 'variety',
+    'ssp': 'subspecies',
+    'subsp': 'subspecies'
+}
+
+const HYBRID_SIGN = '\u00D7'
+
+/**
+ *   1. Any number of
+ *      - capitalized words
+ *      - "&"
+ *      - " in "
+ *      - " ex "
+ *      - lowercase name particles
+ *   2. Followed by a capitalized word
+ *   3. Optionally, followed by "et al."
+ */
+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
+        '(?: ' +
+            // but not auct(t)., etc.
+            '(?!auctt?\\.|(?:syn|comb|sp|spec|nom|gen|subgen)\\. n(?:ov)?\\.|s(?:ens[.u]|\\.)|in part|partim)' +
+        '(' +
+            // $2.1 anything in parentheses, followed by optional revising author(s)
+            '\\(.+?\\)(?:\\s+' + SIMPLE_AUTHOR_PATTERN + ')?' +
+        '|' +
+            // $2.2 anything followed by a year
+            '.+?\\d{4}\\)?' +
+        '|' +
+            // $2.3 author(s)
+            SIMPLE_AUTHOR_PATTERN +
+        '))?' +
+        // $3 optional notes
+        '(?:,? (.+))?' +
+    '$',
+    'u'
+)
+
+/**
+ * Structure
+ *   $1 genus: ((?:x )?[A-Z]\S+)
+ *   $2 subgenus: (?:\(([A-Z]\S+?)\) )?
+ */
+const SUBGENUS_PATTERN = /^([A-Z]\S+) (?:\(([A-Z]\S+?)\))(?= |$)/
+
+/**
+ * Structure
+ *   $1 genus+subgenus (+ trailing space): (?:([A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?
+ *     $1.1 genus: ((?:x )?[A-Z]\S+)
+ *     $1.2 subgenus: (?:\(([A-Z]\S+?)\) )?
+ *   $2 species: (x [a-z-]+|[a-z-][^\s.]+(?: x [a-z-]+)?|[A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+)
+ *     $2a: x [a-z-]+
+ *     $2b hybrid: [a-z-][^\s.]+(?: x [a-z-]+)?
+ *     $2c intergeneric hybrid: [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: Rank, b: Rank): number {
+    return RANKS.indexOf(a) - RANKS.indexOf(b)
+}
+
+function capitalize (name: string): string {
+    return name[0].toUpperCase() + name.slice(1).toLowerCase()
+}
+
+function capitalizeGenericName (name: string): string {
+    if (name[0] === HYBRID_SIGN) {
+        return HYBRID_SIGN + capitalize(name.slice(1))
+    }
+
+    return capitalize(name)
+}
+
+function isUpperCase (name: string): boolean {
+    return name === name.toUpperCase()
+}
+
+function getSynonymRank (name: string, rank: Rank): Rank {
+    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]] as string
+    } else if (!BINAME_PATTERN.test(name)) {
+        return SUBGENUS_PATTERN.test(name) ? 'subgenus' : rank
+    } else if (/^ (?!sensu)[a-z0-9-]+($| )/.test(rest)) {
+        return 'subspecies'
+    } else {
+        return 'species'
+    }
+}
+
+function capitalizeAuthors (authors: string): string {
+    return authors
+        .replace(
+            /[^\x00-\x40\x5B-\x60\x7B-\x7F]+/g, // eslint-disable-line no-control-regex
+            name => isUpperCase(name) ? capitalize(name) : name
+        )
+        .replace(/ Y /g, ' y ')
+}
+
+export function parseName (name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxon {
+    const item = {} as WorkingTaxon
+
+    // Synonyms have the accepted name usage as 'parent'.
+    const isSynonym = /^[+=>] /.test(name)
+    if (isSynonym) {
+        item.taxonomicStatus = TAXONOMIC_STATUS[name[0]]
+        name = name.replace(/^[+=>] (\? ?)?/, '')
+        rank = getSynonymRank(name, parent.taxonRank as Rank)
+    } else {
+        item.taxonomicStatus = 'accepted'
+    }
+
+    // Clusters
+    if (/^\[(_|\d+)\] /.test(name)) {
+        name = name.replace(/^\[(_|\d+)\] /, '')
+    }
+
+    // Set verbatim identification after subsequent syntax is removed.
+    item.verbatimIdentification = name.replace(/(?<=^| )x(?=$| )/g, HYBRID_SIGN).replace(/_/g, ' ')
+
+    // Parent context is used for parsing and formatting binomial names.
+    // For formatting, it needs to match external databases (i.e. be correct).
+    // 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.
+    const parentContext = {
+        genus: parent.genus,
+        subgenus: parent.subgenus,
+        specificEpithet: parent.specificEpithet,
+        incorrect: {
+            genus: parent.incorrect && parent.incorrect.genus,
+            specificEpithet: parent.incorrect && parent.incorrect.specificEpithet
+        }
+    }
+
+    // Both contexts should be amended in the two cases where binomial names
+    // are fully used: (1) synonyms and (2) multinomial taxa without parents to
+    // 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)) {
+        const [, genus, subgenus, species] = name.match(BINAME_PATTERN) ?? name.match(SUBGENUS_PATTERN) ?? []
+        if (genus) {
+            parentContext.incorrect.genus = genus
+            parentContext.genus = capitalizeGenericName(genus.replace(/(^| )x /, HYBRID_SIGN))
+        }
+        if (subgenus) {
+            parentContext.subgenus = capitalize(subgenus)
+        } else if (genus) {
+            // If a genus is given but no subgenus, remove any existing subgenus
+            // from the parent context.
+            delete parentContext.subgenus
+        }
+        if (species && compareRanks('species', rank) < 0) {
+            parentContext.incorrect.specificEpithet = species
+            parentContext.specificEpithet = species.replace(/(^| )x /, HYBRID_SIGN)
+        }
+    }
+
+    // In taxa of group, species or lower, the name should just contain the
+    // (infra)specific epithet and the author information & remarks when processing
+    // further.
+    if (compareRanks('group', rank) <= 0) {
+        // Remove genus
+        const genus = parentContext.incorrect.genus || parentContext.genus || ''
+        if (name[0] === genus[0] && name.toLowerCase().startsWith(genus.toLowerCase() + ' ')) {
+            name = name.slice(genus.length + 1)
+        }
+
+        // Remove subgenus
+        name = name.replace(/^\(.*?\) /, '')
+
+        // Infraspecific taxa
+        if (compareRanks('species', rank) < 0) {
+            // Remove specific epithet
+            const species = parentContext.incorrect.specificEpithet || parentContext.specificEpithet || ''
+            if (name.startsWith(species + ' ')) {
+                name = name.slice(species.length + 1)
+            }
+
+            // Remove rank abbreviations
+            name = name.replace(/^(st|r|ab|f|var|ssp|subsp)\. /, '')
+        }
+    } else if (compareRanks('genus', rank) <= 0) {
+        // Remove genus
+        const genus = parentContext.incorrect.genus || parentContext.genus || ''
+        if (name[0] === genus[0] && name.toLowerCase().startsWith(genus.toLowerCase() + ' (')) {
+            name = name.slice(genus.length + 1)
+        }
+
+        // Remove subgenus parentheses
+        name = name.replace(/^\((.*?)\)/, '$1')
+    }
+
+    // Hybrids
+    if (rank === 'genus' && name.startsWith('x ')) {
+        name = HYBRID_SIGN + name.slice(2)
+    }
+
+    if (rank === 'species' && /(^| )x /.test(name)) {
+        name = name.replace(/(^| )x /, HYBRID_SIGN)
+    }
+
+    // Divide the name into the main scientific name (only the epithet for taxa
+    // lower than genus), the authorship information, and optionally remarks
+    const nameParts = name.match(NAME_PATTERN)
+    if (!nameParts) {
+        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
+    // species (e.g. "Leiobunum species A") and intergeneric hybrids (e.g. "×Festulpia
+    // Festuca rubra × Vulpia bromoides")
+    if (nameParts[1].includes('_')) {
+        nameParts[1] = nameParts[1].replace(/_/g, ' ')
+    }
+
+    const [_, taxon, citation = '', notes] = nameParts
+    item.scientificNameAuthorship = capitalizeAuthors(citation)
+    item.taxonRemarks = notes
+    item.taxonRank = rank
+    item.genericName = undefined
+    item.infragenericEpithet = undefined
+    item.specificEpithet = undefined
+    item.infraspecificEpithet = undefined
+
+    if (/[^\p{L}0-9\u{00D7}\- ]/u.test(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 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 RecoverableSyntaxError(`Generic epithet should be capitalized: "${taxon}"`, item)
+        }
+    } else if (compareRanks('group', rank) > 0) {
+        item.genericName = parentContext.genus
+        item.infragenericEpithet = parentContext.subgenus
+        item.scientificName = capitalize(taxon)
+        if (taxon[0].toUpperCase() !== taxon[0]) {
+            throw new RecoverableSyntaxError(`Infrageneric epithet should be capitalized: "${taxon}"`, item)
+        }
+    } else if (rank === 'group') {
+        item.genericName = parentContext.genus
+        item.infragenericEpithet = parentContext.subgenus
+        const specificEpithet = taxon.toLowerCase().replace(/(-group)?$/, '')
+        item.scientificName = `${item.genericName} ${specificEpithet}-group`
+        if (taxon.toLowerCase() !== taxon) {
+            throw new RecoverableSyntaxError(`Group name should be lowercase: "${taxon}"`, item)
+        }
+    } else if (rank === 'subgroup') {
+        item.genericName = parentContext.genus
+        item.infragenericEpithet = parentContext.subgenus
+        const specificEpithet = taxon.toLowerCase().replace(/(-subgroup)?$/, '')
+        item.scientificName = `${item.genericName} ${specificEpithet}-subgroup`
+        if (taxon.toLowerCase() !== 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
+        const specificEpithet = taxon.toLowerCase()
+        item.scientificName = `${item.genericName} ${specificEpithet}`
+        if (specificEpithet !== 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)) {
+            throw new RecoverableSyntaxError(`Specific epithet should be lowercase: "${taxon}"`, item)
+        }
+        item.specificEpithet = taxon
+        item.scientificName = `${item.genericName} ${item.specificEpithet}`
+    } else if (compareRanks('species', rank) < 0) {
+        item.genericName = parentContext.genus
+        item.infragenericEpithet = parentContext.subgenus
+        item.specificEpithet = parentContext.specificEpithet
+        item.infraspecificEpithet = taxon.toLowerCase()
+
+        // If possible, names below species should have abbreviations for ranks,
+        // like "subsp."
+        const nameParts = [
+            item.genericName,
+            item.specificEpithet,
+            item.infraspecificEpithet
+        ]
+        if (item.taxonRank in RANK_LABELS) {
+            nameParts.splice(2, 0, RANK_LABELS[item.taxonRank])
+        }
+        item.scientificName = nameParts.join(' ')
+
+        if (item.infraspecificEpithet !== taxon) {
+            throw new RecoverableSyntaxError(`Infraspecific epithet should be lowercase: "${taxon}"`, item)
+        }
+    }
+
+    // Re-add authorship information
+    item.scientificNameOnly = item.scientificName
+    if (item.scientificNameAuthorship) {
+        item.scientificName += ` ${item.scientificNameAuthorship}`
+    }
+
+    return item
+}