@larsgw/formica 0.8.4 → 0.8.6

package/lib/resources/parse-text.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -46,41 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFile = parseFile;
 exports.parseFileHeader = parseFileHeader;
-var yaml = __importStar(require("js-yaml"));
-var resource_1 = require("./resource");
-var diff_resource_1 = require("./diff-resource");
-var 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 MAIN_RANKS = [
+const yaml = __importStar(require("js-yaml"));
+const resource_1 = require("./resource");
+const diff_resource_1 = require("./diff-resource");
+const parse_name_1 = require("./parse-name");
+const MAIN_RANKS = [
     'kingdom',
     'phylum',
     'class',
@@ -89,7 +48,7 @@ var MAIN_RANKS = [
     'genus',
     'species'
 ];
-var DWC_RANKS = [
+const DWC_RANKS = [
     'kingdom',
     'phylum',
     'class',
@@ -99,299 +58,27 @@ var DWC_RANKS = [
     'genus',
     'subgenus'
 ];
-var FLAGS = [
+const FLAGS = [
     'MISSING_TAXA',
     'MISSING_PARENT_TAXA',
     'MISSING_SYNONYMS',
     'MISSING_AUTHORSHIP'
 ];
-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+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 RANKS.indexOf(a) - 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();
+const RESOURCE_DELIMITER = '\n\n===\n\n';
+const INDENT = 2;
+function makeParseError(message, line, column = 1) {
+    return new SyntaxError(`[${line}:${column}] ${message}`);
 }
-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 (!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 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 _a = name.match(BINAME_PATTERN) || [], genus = _a[1], subgenus = _a[2], species = _a[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)\. /, '');
-        }
-    }
-    // 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], _b = nameParts[2], citation = _b === void 0 ? '' : _b, 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 (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.scientificName = capitalize(taxon);
-        if (taxon[0].toUpperCase() !== taxon[0]) {
-            throw new Error("Taxon name (".concat(rank, ") 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 (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;
+function mergeParserErrors(errors) {
+    return new SyntaxError(errors.map(error => error.message).join('\n'));
 }
 function parseHeader(header) {
-    var config = yaml.load(header);
+    const config = yaml.load(header);
     if (typeof config !== 'object' || Array.isArray(config) || config === null) {
         throw new SyntaxError('yaml header should be an object');
     }
     // Invalid configuration
-    var levels;
+    let levels;
     if (!('levels' in config)) {
         levels = [];
     }
@@ -409,18 +96,18 @@ function parseHeader(header) {
         throw new SyntaxError('Resource contains no taxa');
     }
     // Invalid taxon ranks
-    var invalidTaxonRanks = levels.filter(function (rank) { return !RANKS.includes(rank); });
+    const invalidTaxonRanks = levels.filter(rank => !parse_name_1.RANKS.includes(rank));
     if (invalidTaxonRanks.length) {
-        throw new SyntaxError("\"levels\" contains invalid values: ".concat(invalidTaxonRanks.join(', ')));
+        throw new SyntaxError(`"levels" contains invalid values: ${invalidTaxonRanks.join(', ')}`);
     }
-    var metadata = { levels: levels };
+    const metadata = { levels };
     if ('catalog' in config && typeof config.catalog === 'object' && config.catalog !== null) {
-        var catalog = {};
+        const catalog = {};
         if ('id' in config.catalog) {
             throw new SyntaxError('"catalog" should not contain id');
         }
-        for (var key in config.catalog) {
-            var value = config.catalog[key];
+        for (const key in config.catalog) {
+            const value = config.catalog[key];
             if (typeof value === 'number') {
                 catalog[key] = value.toString();
             }
@@ -428,22 +115,16 @@ function parseHeader(header) {
                 catalog[key] = value;
             }
             else {
-                throw new SyntaxError("\"catalog\" should contain only strings (\"".concat(key, "\")"));
+                throw new SyntaxError(`"catalog" should contain only strings ("${key}")`);
             }
         }
-        var work = new resource_1.WorkResource(catalog);
-        var errors = work.validate().filter(function (_a) {
-            var error = _a.error;
-            return error !== 'Value(s) required but missing';
-        });
+        const work = new resource_1.WorkResource(catalog);
+        const errors = work.validate().filter(({ error }) => error !== 'Value(s) required but missing');
         if (errors.length > 0) {
-            throw new SyntaxError("\"catalog\" contains errors: ".concat(errors.map(function (_a) {
-                var field = _a.field, error = _a.error;
-                return "[".concat(field, "] ").concat(error);
-            }).join('; ')));
+            throw new SyntaxError(`"catalog" contains errors: ${errors.map(({ field, error }) => `[${field}] ${error}`).join('; ')}`);
         }
         metadata.catalog = {};
-        for (var key in work.fields) {
+        for (const key in work.fields) {
             metadata.catalog[key] = work.get(key);
         }
     }
@@ -451,74 +132,67 @@ function parseHeader(header) {
         if (!Array.isArray(config.flags)) {
             throw new SyntaxError('"flags" should be an array if present');
         }
-        var invalidFlags = config.flags.filter(function (flag) { return !FLAGS.includes(flag); });
+        const invalidFlags = config.flags.filter(flag => !FLAGS.includes(flag));
         if (invalidFlags.length) {
-            throw new SyntaxError("\"flags\" contains invalid values: ".concat(invalidFlags.join(', ')));
+            throw new SyntaxError(`"flags" contains invalid values: ${invalidFlags.join(', ')}`);
         }
         metadata.flags = config.flags;
     }
     return metadata;
 }
-function validateResource(config, content) {
-    // Check for too much indentation
-    var longerIndent = new RegExp("^(  ){".concat(config.levels.length - 1, "}(?!  [+=>] |    > ) "), 'm');
-    var longerIndentMatch = content.match(longerIndent);
-    if (longerIndentMatch !== null) {
-        var offset = longerIndentMatch.index;
-        var line = (content.slice(0, offset).match(/\n/g) || []).length + 1;
-        throw new SyntaxError("Too much indentation at ".concat(line, ":0\n").concat(content.slice(offset).split('\n', 1), "\n^"));
-    }
-    // Check for missing leaf taxa
-    var leafTaxonRank = config.levels.filter(function (rank) { return MAIN_RANKS.includes(rank); }).pop();
-    var leafTaxonParentIndent = config.levels.indexOf(leafTaxonRank) - 1;
-    if (leafTaxonRank && leafTaxonParentIndent >= 0) {
-        var missingLeafTaxa = new RegExp("^((?:  ){0,".concat(leafTaxonParentIndent, "})(?![+=> ] ).*\\n(\\1(  )+[+=>].*\\n)*(?!\\1  )"), 'm');
-        var missingLeafTaxaMatch = content.match(missingLeafTaxa);
-        if (missingLeafTaxaMatch !== null) {
-            var offset = missingLeafTaxaMatch.index;
-            var line = (content.slice(0, offset).match(/\n/g) || []).length + 1;
-            throw new SyntaxError("Missing leaf taxon at ".concat(line, ":0\n").concat(content.slice(offset).split('\n', 1), "\n^"));
-        }
-    }
-}
 function parseResource(resource) {
-    var _a = resource.split(/(\n---\n+)/), header = _a[0], _ = _a[1], rest = _a.slice(2);
-    var config = parseHeader(header);
-    var content = rest.join('');
-    return [config, content];
-}
-function getIndentation(line) {
-    return line.match(/^ */)[0].length;
-}
-function isIndetLine(line, indent) {
-    if (indent === undefined) {
-        indent = getIndentation(line);
+    const [header, _, ...rest] = resource.content.split(/(\n---\n+)/);
+    let config;
+    try {
+        config = parseHeader(header);
+    }
+    catch (error) {
+        throw makeParseError(error.message, resource.offsetLine + 1);
     }
-    line = line.slice(indent);
-    return line.startsWith('[indet]');
+    const content = rest.join('');
+    const offsetLine = resource.offsetLine + (header + _).split('\n').length - 1;
+    return [config, { content, offsetLine }];
 }
-function parseResourceContent(content, resource, oldIds) {
-    var idBase = "".concat(resource.id, ":");
-    var data = resource.taxa;
-    var id = 0;
-    var parents = [];
-    var groupIndent = 0;
-    var previousId = '';
-    var newIdOffset = Math.max.apply(Math, oldIds);
-    for (var _i = 0, content_1 = content; _i < content_1.length; _i++) {
-        var line = content_1[_i];
+function parseResourceContent(content, resource, oldIds, offsetLine) {
+    var _a, _b;
+    const leafTaxonIndex = resource.metadata.levels.reduce((last, rank, i) => MAIN_RANKS.includes(rank) ? i : last, 0);
+    const data = resource.taxa;
+    const errors = [];
+    let id = 0;
+    let newId = Math.max(...oldIds);
+    let lineNumber = offsetLine;
+    const parents = [];
+    const previous = { id: '', indent: 0, group: { isLeaf: false, indent: 0 }, errors: [] };
+    for (const line of content) {
+        const hasOriginalId = line.type !== diff_resource_1.ResourceDiffType.Added && !/^\s*(\[indet\]|> )/.test((_a = line.original) !== null && _a !== void 0 ? _a : line.text);
+        if (hasOriginalId) {
+            id++;
+        }
         if (line.type === diff_resource_1.ResourceDiffType.Deleted) {
-            // Increase id counter for removed line unless it was an "indet line"
-            if (!isIndetLine(line.original)) {
-                id++;
-            }
             continue;
         }
-        var lineIndent = getIndentation(line.text);
-        if (lineIndent > groupIndent) {
+        else {
+            lineNumber++;
+        }
+        const [indentation, name] = line.text.match(/^(\s*)(.*)/).slice(1);
+        const lineIndent = indentation.length;
+        // Validate line
+        if (lineIndent % INDENT === 1) {
+            errors.push(makeParseError('Too much or little indentation', lineNumber));
+            continue;
+        }
+        else if (lineIndent / INDENT >= resource.metadata.levels.length && !/^[+=>] /.test(name)) {
+            errors.push(makeParseError('Too much indentation', lineNumber));
+            continue;
+        }
+        else if (lineIndent <= previous.group.indent && (data[previous.id] && !previous.group.isLeaf)) {
+            errors.push(makeParseError('Missing leaf taxon', lineNumber - 1));
+        }
+        // Update parentage
+        if (lineIndent > previous.indent) {
             // Do not count synonyms as parents (unless this is correcting a typo in the synonym)
-            if (data[previousId] && data[previousId].taxonomicStatus === 'accepted' || /^( {2})+> /.test(line.text)) {
-                parents.push(previousId);
+            if (data[previous.id] && data[previous.id].taxonomicStatus === 'accepted' || name.startsWith('> ')) {
+                parents.push(previous.id);
             }
             else {
                 parents.push(null);
@@ -527,44 +201,50 @@ function parseResourceContent(content, resource, oldIds) {
             // e.g. if a certain genus has only species
             // whereas other genera in the same key also
             // have subgenera
-            if ((lineIndent - groupIndent) > 2) {
-                var gap = (lineIndent - groupIndent - 2) / 2;
-                for (var i = 0; i < gap; i++) {
-                    parents.push(null);
-                }
+            for (let i = previous.indent + INDENT; i < lineIndent; i += INDENT) {
+                parents.push(null);
             }
-            groupIndent = lineIndent;
         }
-        else if (lineIndent < groupIndent) {
-            parents = parents.slice(0, lineIndent / 2);
-            groupIndent = lineIndent;
+        else if (lineIndent < previous.indent) {
+            parents.splice(lineIndent / INDENT);
         }
+        previous.indent = lineIndent;
         // Do not process "indet" lines further, as they only serve to indicate
         // that subtaxa are explicitely omitted
-        if (isIndetLine(line.text, lineIndent)) {
-            // If the line was previously not and ndet line, increase the id counter
-            if (line.type === diff_resource_1.ResourceDiffType.Modified && !isIndetLine(line.original)) {
-                id++;
-            }
+        if (name.startsWith('[indet]')) {
+            errors.push(...previous.errors);
+            previous.errors.length = 0;
+            previous.group.isLeaf = lineIndent / INDENT >= leafTaxonIndex;
             continue;
         }
-        var parentId = parents.reduce(function (grandparent, parent) { return parent || grandparent; }, null);
-        var parent_1 = parentId === null ? {} : data[parentId];
-        var name_1 = line.text.slice(groupIndent);
-        var rank = resource.metadata.levels[groupIndent / 2];
-        var item = parseName(name_1, rank, parent_1);
-        var isSynonym = item.taxonomicStatus !== 'accepted';
+        const parentId = parents.reduce((grandparent, parent) => parent !== null && parent !== void 0 ? parent : grandparent, null);
+        const parent = parentId === null ? {} : data[parentId];
+        let item;
+        const itemErrors = [];
+        try {
+            const rank = resource.metadata.levels[parents.length];
+            item = (0, parse_name_1.parseName)(name, rank, parent);
+        }
+        catch (error) {
+            if (error instanceof parse_name_1.RecoverableSyntaxError) {
+                itemErrors.push(makeParseError(error.message, lineNumber));
+                item = error.result;
+            }
+            else {
+                errors.push(makeParseError(error.message, lineNumber));
+                continue;
+            }
+        }
         // Add higher classification info
-        var itemAsObject = item;
-        var parentAsObject = parent_1;
-        for (var _a = 0, DWC_RANKS_1 = DWC_RANKS; _a < DWC_RANKS_1.length; _a++) {
-            var rank_1 = DWC_RANKS_1[_a];
-            itemAsObject[rank_1] = undefined;
-            if (parentAsObject[rank_1]) {
-                itemAsObject[rank_1] = parentAsObject[rank_1];
+        const itemAsObject = item;
+        const parentAsObject = parent;
+        for (const rank of DWC_RANKS) {
+            itemAsObject[rank] = undefined;
+            if (parentAsObject[rank]) {
+                itemAsObject[rank] = parentAsObject[rank];
             }
-            if (item.taxonRank === rank_1) {
-                itemAsObject[rank_1] = item.scientificNameOnly;
+            if (item.taxonRank === rank) {
+                itemAsObject[rank] = item.scientificNameOnly;
             }
         }
         if (item.genericName && !item.genus) {
@@ -573,82 +253,112 @@ function parseResourceContent(content, resource, oldIds) {
         if (item.infragenericEpithet && !item.subgenus) {
             item.subgenus = item.infragenericEpithet;
         }
-        if (isSynonym) {
-            item.higherClassification = parent_1.higherClassification;
-        }
-        else if (parent_1.higherClassification) {
-            item.higherClassification = parent_1.higherClassification + " | ".concat(parent_1.scientificNameOnly);
-        }
-        else if (parentId) {
-            item.higherClassification = parent_1.scientificNameOnly;
-        }
-        // Amend "parent" with corrections
+        // Amend "parent" with corrections, exit
         if (item.taxonomicStatus === 'incorrect') {
-            parent_1.incorrect = __assign({}, parent_1);
-            for (var key in item) {
+            if (parent.incorrect) {
+                errors.push(makeParseError('Cannot apply a correction to a previous correction', lineNumber));
+                continue;
+            }
+            else if (parentId === null) {
+                errors.push(makeParseError('Cannot apply a correction to nothing', lineNumber));
+                continue;
+            }
+            parent.incorrect = Object.assign({}, parent);
+            for (const key in item) {
                 if (key !== 'taxonomicStatus' && key !== 'verbatimIdentification') {
                     parentAsObject[key] = itemAsObject[key];
                 }
             }
+            // If "parent" is corrected, its errors can be dropped
+            previous.errors.length = 0;
+            // ...but errors associated with the corrected name are added immediately
+            errors.push(...itemErrors);
             continue;
         }
-        // Set identifiers
-        if (line.type === diff_resource_1.ResourceDiffType.Added) {
-            newIdOffset++;
-            item.scientificNameID = idBase + newIdOffset.toString();
+        // Add more classification info
+        const isSynonym = item.taxonomicStatus !== 'accepted';
+        if (isSynonym) {
+            item.higherClassification = parent.higherClassification;
         }
-        else if (line.type === diff_resource_1.ResourceDiffType.Modified && isIndetLine(line.original)) {
-            newIdOffset++;
-            item.scientificNameID = idBase + newIdOffset.toString();
+        else if (parent.higherClassification) {
+            item.higherClassification = parent.higherClassification + ` | ${parent.scientificNameOnly}`;
         }
-        else {
-            id++;
-            item.scientificNameID = idBase + (oldIds[id - 1] || id).toString();
+        else if (parentId) {
+            item.higherClassification = parent.scientificNameOnly;
         }
-        previousId = item.scientificNameID;
-        item.parentNameUsageID = isSynonym ? undefined : parent_1.scientificNameID;
-        item.parentNameUsage = isSynonym ? undefined : parent_1.scientificName;
-        item.acceptedNameUsageID = isSynonym ? parent_1.scientificNameID : undefined;
-        item.acceptedNameUsage = isSynonym ? parent_1.scientificName : undefined;
-        item.collectionCode = idBase.slice(0, -1);
+        // Set identifiers
+        item.scientificNameID = `${resource.id}:${hasOriginalId ? ((_b = oldIds[id - 1]) !== null && _b !== void 0 ? _b : id) : ++newId}`;
+        item.parentNameUsageID = isSynonym ? undefined : parent.scientificNameID;
+        item.parentNameUsage = isSynonym ? undefined : parent.scientificName;
+        item.acceptedNameUsageID = isSynonym ? parent.scientificNameID : undefined;
+        item.acceptedNameUsage = isSynonym ? parent.scientificName : undefined;
+        item.collectionCode = resource.id;
         data[item.scientificNameID] = item;
+        // Update loop state
+        errors.push(...previous.errors);
+        previous.errors = itemErrors;
+        previous.id = item.scientificNameID;
+        if (item.taxonomicStatus === 'accepted') {
+            previous.group.indent = previous.indent;
+            previous.group.isLeaf = lineIndent / INDENT >= leafTaxonIndex;
+        }
+    }
+    errors.push(...previous.errors);
+    if (errors.length) {
+        throw mergeParserErrors(errors);
     }
     return resource;
 }
 function splitResources(file) {
-    return file.split('\n\n===\n\n');
+    const resources = [];
+    let offsetLine = 0;
+    for (const content of file.split(RESOURCE_DELIMITER)) {
+        resources.push({ content, offsetLine });
+        offsetLine += (content + RESOURCE_DELIMITER).split('\n').length - 1;
+    }
+    return resources;
 }
 function parseFile(file, id, old) {
-    var oldResources = old ? splitResources(old.txt) : [];
-    return splitResources(file).map(function (resource, index) {
-        var _a = parseResource(resource), config = _a[0], content = _a[1];
-        validateResource(config, content);
-        var template = {
-            id: "".concat(id, ":").concat(index + 1),
-            file: "".concat(id, "-").concat(index + 1),
+    const oldResources = old ? splitResources(old.txt) : [];
+    const newResources = splitResources(file);
+    const resources = [];
+    const errors = [];
+    for (let index = 0; index < newResources.length; index++) {
+        const [config, content] = parseResource(newResources[index]);
+        const template = {
+            id: `${id}:${index + 1}`,
+            file: `${id}-${index + 1}`,
             workId: id,
             metadata: config,
             taxa: {}
         };
-        var diff;
+        let diff;
         if (oldResources[index]) {
-            diff = (0, diff_resource_1.createDiff)(content, parseResource(oldResources[index])[1]);
+            diff = (0, diff_resource_1.createDiff)(content.content, parseResource(oldResources[index])[1].content);
             // Ignore empty lines
-            diff = diff.filter(function (line) { return line.text !== ''; });
+            diff = diff.filter(line => line.text !== '');
         }
         else {
-            diff = (0, diff_resource_1.createDiff)(content, content);
+            diff = (0, diff_resource_1.createDiff)(content.content, content.content);
         }
-        var oldIds = [];
+        const oldIds = [];
         if (old) {
-            for (var _i = 0, _b = old.dwc[index].slice(1); _i < _b.length; _i++) {
-                var row = _b[_i];
+            for (const row of old.dwc[index].slice(1)) {
                 oldIds.push(parseInt(row[0].split(':')[2]));
             }
         }
-        return parseResourceContent(diff, template, oldIds);
-    });
+        try {
+            resources.push(parseResourceContent(diff, template, oldIds, content.offsetLine));
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length) {
+        throw mergeParserErrors(errors);
+    }
+    return resources;
 }
 function parseFileHeader(file) {
-    return splitResources(file).map(function (resource) { return parseResource(resource)[0]; });
+    return splitResources(file).map(resource => parseResource(resource)[0]);
 }