@larsgw/formica 0.8.3 → 0.8.5

package/lib/resources/parse-text.js

@@ -49,37 +49,7 @@ 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 parse_name_1 = require("./parse-name");
 var MAIN_RANKS = [
     'kingdom',
     'phylum',
@@ -105,285 +75,14 @@ var FLAGS = [
     '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();
+var RESOURCE_DELIMITER = '\n\n===\n\n';
+var INDENT = 2;
+function makeParseError(message, line, column) {
+    if (column === void 0) { column = 1; }
+    return new SyntaxError("[".concat(line, ":").concat(column, "] ").concat(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(function (error) { return error.message; }).join('\n'));
 }
 function parseHeader(header) {
     var config = yaml.load(header);
@@ -409,7 +108,7 @@ function parseHeader(header) {
         throw new SyntaxError('Resource contains no taxa');
     }
     // Invalid taxon ranks
-    var invalidTaxonRanks = levels.filter(function (rank) { return !RANKS.includes(rank); });
+    var invalidTaxonRanks = levels.filter(function (rank) { return !parse_name_1.RANKS.includes(rank); });
     if (invalidTaxonRanks.length) {
         throw new SyntaxError("\"levels\" contains invalid values: ".concat(invalidTaxonRanks.join(', ')));
     }
@@ -459,66 +158,61 @@ function parseHeader(header) {
     }
     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^"));
+function parseResource(resource) {
+    var _a = resource.content.split(/(\n---\n+)/), header = _a[0], _ = _a[1], rest = _a.slice(2);
+    var config;
+    try {
+        config = parseHeader(header);
     }
-    // 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^"));
-        }
+    catch (error) {
+        throw makeParseError(error.message, resource.offsetLine + 1);
     }
-}
-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;
+    var offsetLine = resource.offsetLine + (header + _).split('\n').length - 1;
+    return [config, { content: content, offsetLine: offsetLine }];
 }
-function isIndetLine(line, indent) {
-    if (indent === undefined) {
-        indent = getIndentation(line);
-    }
-    line = line.slice(indent);
-    return line.startsWith('[indet]');
-}
-function parseResourceContent(content, resource, oldIds) {
-    var idBase = "".concat(resource.id, ":");
+function parseResourceContent(content, resource, oldIds, offsetLine) {
+    var _a, _b;
+    var leafTaxonIndex = resource.metadata.levels.reduce(function (last, rank, i) { return MAIN_RANKS.includes(rank) ? i : last; }, 0);
     var data = resource.taxa;
+    var errors = [];
     var id = 0;
+    var newId = Math.max.apply(Math, oldIds);
+    var lineNumber = offsetLine;
     var parents = [];
-    var groupIndent = 0;
-    var previousId = '';
-    var newIdOffset = Math.max.apply(Math, oldIds);
+    var previous = { id: '', indent: 0, group: { isLeaf: false, indent: 0 } };
     for (var _i = 0, content_1 = content; _i < content_1.length; _i++) {
         var line = content_1[_i];
+        var 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++;
+        }
+        var _c = line.text.match(/^(\s*)(.*)/).slice(1), indentation = _c[0], name_1 = _c[1];
+        var 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_1)) {
+            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));
+            continue;
+        }
+        // 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_1.startsWith('> ')) {
+                parents.push(previous.id);
             }
             else {
                 parents.push(null);
@@ -527,38 +221,36 @@ 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 (var 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_1.startsWith('[indet]')) {
+            previous.group.isLeaf = lineIndent / INDENT >= leafTaxonIndex;
             continue;
         }
-        var parentId = parents.reduce(function (grandparent, parent) { return parent || grandparent; }, null);
+        var parentId = parents.reduce(function (grandparent, parent) { return parent !== null && parent !== void 0 ? 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';
+        var rank = resource.metadata.levels[parents.length];
+        var item = void 0;
+        try {
+            item = (0, parse_name_1.parseName)(name_1, rank, parent_1);
+        }
+        catch (error) {
+            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];
+        for (var _d = 0, DWC_RANKS_1 = DWC_RANKS; _d < DWC_RANKS_1.length; _d++) {
+            var rank_1 = DWC_RANKS_1[_d];
             itemAsObject[rank_1] = undefined;
             if (parentAsObject[rank_1]) {
                 itemAsObject[rank_1] = parentAsObject[rank_1];
@@ -573,16 +265,7 @@ 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) {
@@ -592,37 +275,54 @@ function parseResourceContent(content, resource, oldIds) {
             }
             continue;
         }
-        // Set identifiers
-        if (line.type === diff_resource_1.ResourceDiffType.Added) {
-            newIdOffset++;
-            item.scientificNameID = idBase + newIdOffset.toString();
+        // Add more classification info
+        var isSynonym = item.taxonomicStatus !== 'accepted';
+        if (isSynonym) {
+            item.higherClassification = parent_1.higherClassification;
         }
-        else if (line.type === diff_resource_1.ResourceDiffType.Modified && isIndetLine(line.original)) {
-            newIdOffset++;
-            item.scientificNameID = idBase + newIdOffset.toString();
+        else if (parent_1.higherClassification) {
+            item.higherClassification = parent_1.higherClassification + " | ".concat(parent_1.scientificNameOnly);
         }
-        else {
-            id++;
-            item.scientificNameID = idBase + (oldIds[id - 1] || id).toString();
+        else if (parentId) {
+            item.higherClassification = parent_1.scientificNameOnly;
         }
-        previousId = item.scientificNameID;
+        // Set identifiers
+        item.scientificNameID = "".concat(resource.id, ":").concat(hasOriginalId ? ((_b = oldIds[id - 1]) !== null && _b !== void 0 ? _b : id) : ++newId);
         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);
+        item.collectionCode = resource.id;
         data[item.scientificNameID] = item;
+        // Update loop state
+        previous.id = item.scientificNameID;
+        if (item.taxonomicStatus === 'accepted') {
+            previous.group.indent = previous.indent;
+            previous.group.isLeaf = lineIndent / INDENT >= leafTaxonIndex;
+        }
+    }
+    if (errors.length) {
+        throw mergeParserErrors(errors);
     }
     return resource;
 }
 function splitResources(file) {
-    return file.split('\n\n===\n\n');
+    var resources = [];
+    var offsetLine = 0;
+    for (var _i = 0, _a = file.split(RESOURCE_DELIMITER); _i < _a.length; _i++) {
+        var content = _a[_i];
+        resources.push({ content: content, offsetLine: 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 newResources = splitResources(file);
+    var resources = [];
+    var errors = [];
+    for (var index = 0; index < newResources.length; index++) {
+        var _a = parseResource(newResources[index]), config = _a[0], content = _a[1];
         var template = {
             id: "".concat(id, ":").concat(index + 1),
             file: "".concat(id, "-").concat(index + 1),
@@ -630,14 +330,14 @@ function parseFile(file, id, old) {
             metadata: config,
             taxa: {}
         };
-        var diff;
+        var diff = void 0;
         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 !== ''; });
         }
         else {
-            diff = (0, diff_resource_1.createDiff)(content, content);
+            diff = (0, diff_resource_1.createDiff)(content.content, content.content);
         }
         var oldIds = [];
         if (old) {
@@ -646,8 +346,17 @@ function parseFile(file, id, old) {
                 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]; });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larsgw/formica",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "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": {