@larsgw/formica 0.8.3 → 0.8.5

package/.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [18.x, 20.x]
+        node-version: [20.x, 22.x]
 
     steps:
     - uses: actions/checkout@v3

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [0.8.5](https://github.com/identification-resources/formica/compare/v0.8.4...v0.8.5) (2025-10-28)
+
+
+### Bug Fixes
+
+* **catalog:** add mapping for typo 'male' in linked data ([a83d34e](https://github.com/identification-resources/formica/commit/a83d34e7aa57a78e410e2ea55adbf75e522d9028))
+* **catalog:** fix dcmitype: for algorithms, checklists ([68e353d](https://github.com/identification-resources/formica/commit/68e353d71d632e092e3e79254e6b4f575c004f1c))
+* **catalog:** fix typos in linked data generation ([9ad951f](https://github.com/identification-resources/formica/commit/9ad951f5c19978509c6aba7fd81470270707da99))
+* **resources:** add scientific name for complexes, aggregates ([843afc3](https://github.com/identification-resources/formica/commit/843afc39df1952dda4bb6339ee47f2619432bb74))
+* **resources:** omit generic error stack trace ([c831bc2](https://github.com/identification-resources/formica/commit/c831bc2a952ef17a9e57b012fe0568e2acc0c6ae))
+
+
+### Features
+
+* **resources:** handle subgenus synonyms of genera ([4e61336](https://github.com/identification-resources/formica/commit/4e61336e36054ffd6df57ebad5479e7ceebcb235)), closes [#16](https://github.com/identification-resources/formica/issues/16)
+* **resources:** rework parsing of resources ([cff7730](https://github.com/identification-resources/formica/commit/cff773000c5b9e3f990c619cdd45a76a18ee39a9)), closes [#15](https://github.com/identification-resources/formica/issues/15) [#7](https://github.com/identification-resources/formica/issues/7)
+
+
+
+## [0.8.4](https://github.com/identification-resources/formica/compare/v0.8.3...v0.8.4) (2025-09-19)
+
+
+### Bug Fixes
+
+* **catalog:** clearer error message when validating ([b1c34f0](https://github.com/identification-resources/formica/commit/b1c34f00ed9a262251d2d24b3e6c46fd17730405))
+* **resources:** optimize diffing algorithm ([0c86c49](https://github.com/identification-resources/formica/commit/0c86c49474754dced74c8423f3e6b7ed2fd2a78f)), closes [#6](https://github.com/identification-resources/formica/issues/6)
+
+
+### Features
+
+* **catalog:** map additional scope value ([80c6d26](https://github.com/identification-resources/formica/commit/80c6d269a7d5b03600991fb353280e81afcefb0e))
+
+
+
 ## [0.8.3](https://github.com/identification-resources/formica/compare/v0.8.2...v0.8.3) (2025-07-15)
 
 

package/lib/bin/generate-linked-data.js

@@ -115,6 +115,7 @@ var SCOPES = {
     'nymphs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
     'nypmhs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
     'nymphs (instar V)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'nymphs (instar IV)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
     'eggs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/embryo'],
     // plant life stage
     'flowering plants': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/adult'],
@@ -125,6 +126,7 @@ var SCOPES = {
     // 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'],
     'workers': ['dwc:caste', 'worker'],
@@ -277,7 +279,7 @@ function makeLinkedDataForTaxon(taxon) {
     var node = {
         '@id': "".concat(PREFIX, "taxon/").concat(taxon.get('id')),
         '@type': 'dwc:Taxon',
-        'dwc:scientificName': taxon.get('display_name'),
+        'dwc:scientificName': taxon.get('name'),
     };
     if (taxon.has('rank')) {
         node['dwc:taxonRank'] = makeTaxonRankUri(taxon.get('rank'));
@@ -371,7 +373,7 @@ function makeLinkedDataForResource(work, files, resourceId) {
     }
     var node = __assign(__assign({}, makeLinkedDataForWork(resource, files)), { '@id': "".concat(PREFIX, "resource/").concat(resourceId), '@type': 'bibo:DocumentPart' });
     var types = (_b = (_a = resource.get('key_type')) !== null && _a !== void 0 ? _a : work.get('key_type')) !== null && _b !== void 0 ? _b : [];
-    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')) {
@@ -380,6 +382,9 @@ function makeLinkedDataForResource(work, files, resourceId) {
     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')) {
         node['ac:subtype'] = { '@id': 'http://rs.tdwg.org/acsubtype/values/IdentificationKey' };
     }
@@ -636,10 +641,10 @@ function makeLinkedDataForWorks(files) {
                 node['dcterms:hasPart'] = [];
             }
             node['dcterms:hasPart'].push(resource);
-            if (!Array.isArray(resource['dcterms:isPartof'])) {
-                resource['dcterms:isPartof'] = [];
+            if (!Array.isArray(resource['dcterms:isPartOf'])) {
+                resource['dcterms:isPartOf'] = [];
             }
-            resource['dcterms:isPartof'].push({ '@id': node['@id'] });
+            resource['dcterms:isPartOf'].push({ '@id': node['@id'] });
         }
     };
     for (var _b = 0, _c = works.entities; _b < _c.length; _b++) {

package/lib/bin/process-resources.js

@@ -411,7 +411,7 @@ var ResourceProcessor = /** @class */ (function () {
                         return [2 /*return*/, resources.parseTextFile(file, id, old)];
                     case 10:
                         error_1 = _g.sent();
-                        console.log(error_1);
+                        console.log(error_1.message);
                         return [4 /*yield*/, (0, util_1.prompt)("".concat(id, ": generating Darwin Core failed, retry? "))
                             // Clear cache to re-import
                         ];

package/lib/bin/validate-catalog.js

@@ -84,17 +84,14 @@ function validateFile(arg) {
                 case 1:
                     file = _a.sent();
                     sheet = path.basename(filePath, '.csv');
-                    return [2 /*return*/, {
-                            filePath: filePath,
-                            errors: index_1.catalog.loadData(file, sheet).validate()
-                        }];
+                    return [2 /*return*/, index_1.catalog.loadData(file, sheet).validate()];
             }
         });
     });
 }
 function main(args) {
     return __awaiter(this, void 0, void 0, function () {
-        var exitStatus, results, _i, results_1, result;
+        var exitStatus, results, i, result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -102,16 +99,17 @@ function main(args) {
                     return [4 /*yield*/, Promise.allSettled(args.map(validateFile))];
                 case 1:
                     results = _a.sent();
-                    for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
-                        result = results_1[_i];
+                    for (i = 0; i < results.length; i++) {
+                        result = results[i];
                         if (result.status === 'rejected') {
+                            console.error("".concat(args[i], ":"));
                             console.error(result.reason);
                             console.error();
                             exitStatus = 1;
                         }
-                        else if (result.value.errors.length > 0) {
-                            console.error("".concat(result.value.filePath, ":"));
-                            console.table(result.value.errors);
+                        else if (result.value.length > 0) {
+                            console.error("".concat(args[i], ":"));
+                            console.table(result.value);
                             console.error();
                             exitStatus = 1;
                         }

package/lib/bin/validate-resources-text.js

@@ -94,7 +94,7 @@ function main(args) {
                         index_1.resources.parseTextFile(file, id);
                     }
                     catch (error) {
-                        console.error(filePath + '\n    ' + error.message + '\n');
+                        console.error(filePath + '\n' + error.message.replace(/^/gm, '    ') + '\n');
                         exitStatus = 1;
                     }
                     _a.label = 3;

package/lib/resources/diff-resource.d.ts

@@ -4,4 +4,4 @@ export declare enum ResourceDiffType {
     Modified = "~",
     Unchanged = "="
 }
-export declare function createDiff(a: string, b: string, tokenize?: ResourceDiffTokenizer): ResourceDiff;
+export declare function createDiff(a: string, b: string): ResourceDiff;

package/lib/resources/diff-resource.js

@@ -18,18 +18,32 @@ var ResourceDiffType;
     ResourceDiffType["Modified"] = "~";
     ResourceDiffType["Unchanged"] = "=";
 })(ResourceDiffType || (exports.ResourceDiffType = ResourceDiffType = {}));
+var Matrix = /** @class */ (function () {
+    function Matrix(m, n) {
+        this.values = Array(m * n).fill(0);
+        this.m = m;
+        this.n = n;
+    }
+    Matrix.prototype.getValue = function (i, j) {
+        return this.values[(i * this.n) + j];
+    };
+    Matrix.prototype.setValue = function (i, j, value) {
+        this.values[(i * this.n) + j] = value;
+    };
+    return Matrix;
+}());
 function LCS(X, Y) {
     var m = X.length;
     var n = Y.length;
     // Build matrix
-    var C = Array(m + 1).fill(0).map(function () { return Array(n + 1).fill(0); });
+    var C = new Matrix(m + 1, n + 1);
     for (var i_1 = 0; i_1 < m; i_1++) {
         for (var j_1 = 0; j_1 < n; j_1++) {
             if (X[i_1] === Y[j_1]) {
-                C[i_1 + 1][j_1 + 1] = C[i_1][j_1] + 1;
+                C.setValue(i_1 + 1, j_1 + 1, C.getValue(i_1, j_1) + 1);
             }
             else {
-                C[i_1 + 1][j_1 + 1] = Math.max(C[i_1][j_1 + 1], C[i_1 + 1][j_1]);
+                C.setValue(i_1 + 1, j_1 + 1, Math.max(C.getValue(i_1, j_1 + 1), C.getValue(i_1 + 1, j_1)));
             }
         }
     }
@@ -46,7 +60,7 @@ function LCS(X, Y) {
             i--;
             j--;
         }
-        else if (i !== 0 && (j === 0 || C[i - 1][j] > C[i][j - 1])) {
+        else if (i !== 0 && (j === 0 || C.getValue(i - 1, j) > C.getValue(i, j - 1))) {
             diff.unshift({
                 text: X[i - 1],
                 type: ResourceDiffType.Added
@@ -63,17 +77,16 @@ function LCS(X, Y) {
     }
     return diff;
 }
-function gitTokenize(text) {
+function tokenizeWords(text) {
     if (text.length === 0) {
         return [];
     }
     return text.match(/\S+|\n|[\r\t\f\v \u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/g);
 }
-function createDiff(a, b, tokenize) {
-    var _a, _b;
-    if (tokenize === void 0) { tokenize = gitTokenize; }
-    var X = tokenize(a.trimEnd());
-    var Y = tokenize(b.trimEnd());
+function tokenizeLines(text) {
+    return text.split('\n');
+}
+function diffTokens(X, Y) {
     // Remove common prefix
     var prefix = [];
     while (X.length && X[0] === Y[0]) {
@@ -94,12 +107,11 @@ function createDiff(a, b, tokenize) {
         X.pop();
         Y.pop();
     }
-    // Generate word from remains, combine with prefix and suffix, add trailing
-    // newline
-    var changes = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], prefix, true), LCS(X, Y), true), suffix, true), [
-        { text: '\n', type: ResourceDiffType.Unchanged }
-    ], false);
-    // Convert word diff to line diff
+    // Generate diff from remains, combine with prefix and suffix
+    return __spreadArray(__spreadArray(__spreadArray([], prefix, true), LCS(X, Y), true), suffix, true);
+}
+function convertWordDiff(changes) {
+    var _a, _b;
     var lines = [];
     var line = null;
     var deletedNewlines = 0;
@@ -156,3 +168,36 @@ function createDiff(a, b, tokenize) {
     }
     return lines;
 }
+function getWordTokensFromLines(lines) {
+    return lines.flatMap(function (change) { return tokenizeWords(change.text).concat('\n'); });
+}
+function createDiff(a, b) {
+    var lines = diffTokens(tokenizeLines(a.trimEnd()), tokenizeLines(b.trimEnd()));
+    var changes = [];
+    var diffPart = { added: [], deleted: [] };
+    for (var 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.apply(changes, convertWordDiff(diffTokens(getWordTokensFromLines(diffPart.added), getWordTokensFromLines(diffPart.deleted))));
+            diffPart.added.length = 0;
+            diffPart.deleted.length = 0;
+        }
+        else if (diffPart.added.length) {
+            changes.push.apply(changes, diffPart.added);
+            diffPart.added.length = 0;
+        }
+        else if (diffPart.deleted.length) {
+            changes.push.apply(changes, diffPart.deleted.map(function (change) { return ({ text: undefined, original: change.text, type: change.type }); }));
+            diffPart.deleted.length = 0;
+        }
+        changes.push(lines[i]);
+    }
+    return changes;
+}

package/lib/resources/parse-name.d.ts

@@ -0,0 +1,2 @@
+export declare const RANKS: Rank[];
+export declare function parseName(name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxon;

package/lib/resources/parse-name.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANKS = void 0;
+exports.parseName = parseName;
+exports.RANKS = [
+    '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
+];
+var TAXONOMIC_STATUS = {
+    '>': 'incorrect',
+    '+': 'heterotypic synonym',
+    '=': 'synonym'
+};
+var RANK_LABELS = {
+    'subspecies': 'subsp.',
+    'variety': 'var.',
+    'form': 'f.',
+    'aberration': 'ab.',
+    'race': 'r.',
+    'stirps': 'st.'
+};
+var RANK_LABELS_REVERSE = {
+    'st': 'stirps',
+    'r': 'race',
+    'ab': 'aberration',
+    'f': 'form',
+    'var': 'variety',
+    'ssp': 'subspecies',
+    'subsp': 'subspecies'
+};
+var 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."
+ */
+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('^' +
+    // $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+?)\) )?
+ */
+var 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-]+
+ */
+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-]+)(?= |$)/;
+function compareRanks(a, b) {
+    return exports.RANKS.indexOf(a) - exports.RANKS.indexOf(b);
+}
+function capitalize(name) {
+    return name[0].toUpperCase() + name.slice(1).toLowerCase();
+}
+function capitalizeGenericName(name) {
+    if (name[0] === HYBRID_SIGN) {
+        return HYBRID_SIGN + capitalize(name.slice(1));
+    }
+    return capitalize(name);
+}
+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)\. /);
+    if (rankPrefix) {
+        return RANK_LABELS_REVERSE[rankPrefix[1]];
+    }
+    else if (SUBGENUS_PATTERN.test(name)) {
+        return 'subgenus';
+    }
+    else if (!BINAME_PATTERN.test(name)) {
+        return rank;
+    }
+    else if (/^ (?!sensu)[a-z0-9-]+($| )/.test(rest)) {
+        return 'subspecies';
+    }
+    else {
+        return 'species';
+    }
+}
+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; })
+        .replace(/ Y /g, ' y ');
+}
+function parseName(name, rank, parent) {
+    var _a, _b;
+    var item = {};
+    // Synonyms have the accepted name usage as 'parent'.
+    var isSynonym = /^[+=>] /.test(name);
+    if (isSynonym) {
+        item.taxonomicStatus = TAXONOMIC_STATUS[name[0]];
+        name = name.replace(/^[+=>] (\? ?)?/, '');
+        rank = getSynonymRank(name, parent.taxonRank);
+    }
+    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.
+    var 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)) {
+        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];
+        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
+        var 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
+            var 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
+        var 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
+    var nameParts = name.match(NAME_PATTERN);
+    if (!nameParts) {
+        throw new Error("Taxon \"".concat(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, ' ');
+    }
+    var _ = nameParts[0], taxon = nameParts[1], _d = nameParts[2], citation = _d === void 0 ? '' : _d, notes = nameParts[3];
+    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.
+    if (/[^\p{L}0-9\u{00D7}\- ]/u.test(taxon)) {
+        throw new Error("Taxon name contains unexpected characters: \"".concat(taxon, "\""));
+    }
+    // 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, "\""));
+        }
+    }
+    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, "\""));
+        }
+    }
+    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 Error("Infrageneric epithet should be capitalized: \"".concat(taxon, "\""));
+        }
+    }
+    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");
+        if (taxon.toLowerCase() !== taxon) {
+            console.log(item, taxon);
+            throw new Error("Group name should be lowercase: \"".concat(taxon, "\""));
+        }
+    }
+    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");
+        if (taxon.toLowerCase() !== taxon) {
+            console.log(item, taxon);
+            throw new Error("Subgroup name should be lowercase: \"".concat(taxon, "\""));
+        }
+    }
+    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);
+        if (specificEpithet !== taxon) {
+            console.log(item, taxon);
+            throw new Error("Subgroup name should be lowercase: \"".concat(taxon, "\""));
+        }
+    }
+    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, "\""));
+        }
+        item.specificEpithet = taxon;
+        item.scientificName = "".concat(item.genericName, " ").concat(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."
+        var nameParts_1 = [
+            item.genericName,
+            item.specificEpithet,
+            item.infraspecificEpithet
+        ];
+        if (item.taxonRank in RANK_LABELS) {
+            nameParts_1.splice(2, 0, RANK_LABELS[item.taxonRank]);
+        }
+        item.scientificName = nameParts_1.join(' ');
+        if (item.infraspecificEpithet !== taxon) {
+            console.log(item, taxon);
+            throw new Error("Infraspecific epithet should be lowercase: \"".concat(taxon, "\""));
+        }
+    }
+    // Re-add authorship information
+    item.scientificNameOnly = item.scientificName;
+    if (item.scientificNameAuthorship) {
+        item.scientificName += " ".concat(item.scientificNameAuthorship);
+    }
+    return item;
+}