@larsgw/formica 0.8.5 → 0.8.7

package/src/resources/parse-name.ts

@@ -1,3 +1,12 @@
+export class RecoverableSyntaxError<Result> extends SyntaxError {
+    result: Result
+
+    constructor (message: string, result: Result) {
+        super(message)
+        this.result = result
+    }
+}
+
 export const RANKS: Rank[] = [
     'phylum',
     'subphylum',
@@ -138,10 +147,8 @@ function getSynonymRank (name: string, rank: Rank): Rank {
     const rankPrefix = rest.match(/^(?: |^)(st|r|ab|f|var|ssp|subsp)\. /)
     if (rankPrefix) {
         return RANK_LABELS_REVERSE[rankPrefix[1]] as string
-    } else if (SUBGENUS_PATTERN.test(name)) {
-        return 'subgenus'
     } else if (!BINAME_PATTERN.test(name)) {
-        return rank
+        return SUBGENUS_PATTERN.test(name) ? 'subgenus' : rank
     } else if (/^ (?!sensu)[a-z0-9-]+($| )/.test(rest)) {
         return 'subspecies'
     } else {
@@ -280,29 +287,32 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
     item.scientificNameAuthorship = capitalizeAuthors(citation)
     item.taxonRemarks = notes
     item.taxonRank = rank
+    item.genericName = undefined
+    item.infragenericEpithet = undefined
+    item.specificEpithet = undefined
+    item.infraspecificEpithet = undefined
 
-    // @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: "${taxon}"`)
+        throw new RecoverableSyntaxError(`Taxon name contains unexpected characters: "${taxon}"`, item)
     }
 
     // Validate names and recompose binomial and trinomial names
     if (compareRanks('genus', rank) > 0) {
         item.scientificName = capitalize(taxon)
         if (taxon[0].toUpperCase() !== taxon[0]) {
-            throw new Error(`Taxon name (${rank}) should be capitalized: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Taxon name (${rank}) should be capitalized: "${taxon}"`, item)
         }
     } else if (rank === 'genus') {
         item.scientificName = capitalizeGenericName(taxon)
         if (taxon[0].toUpperCase() !== taxon[0] || (taxon[0] === HYBRID_SIGN && taxon[1].toUpperCase() !== taxon[1])) {
-            throw new Error(`Generic epithet should be capitalized: "${taxon}"`)
+            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 Error(`Infrageneric epithet should be capitalized: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Infrageneric epithet should be capitalized: "${taxon}"`, item)
         }
     } else if (rank === 'group') {
         item.genericName = parentContext.genus
@@ -310,8 +320,7 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         const specificEpithet = taxon.toLowerCase().replace(/(-group)?$/, '')
         item.scientificName = `${item.genericName} ${specificEpithet}-group`
         if (taxon.toLowerCase() !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Group name should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Group name should be lowercase: "${taxon}"`, item)
         }
     } else if (rank === 'subgroup') {
         item.genericName = parentContext.genus
@@ -319,8 +328,7 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         const specificEpithet = taxon.toLowerCase().replace(/(-subgroup)?$/, '')
         item.scientificName = `${item.genericName} ${specificEpithet}-subgroup`
         if (taxon.toLowerCase() !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Subgroup name should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Subgroup name should be lowercase: "${taxon}"`, item)
         }
     } else if (compareRanks('species', rank) > 0) {
         item.genericName = parentContext.genus
@@ -328,15 +336,13 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         const specificEpithet = taxon.toLowerCase()
         item.scientificName = `${item.genericName} ${specificEpithet}`
         if (specificEpithet !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Subgroup name should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Taxon name should be lowercase: "${taxon}"`, item)
         }
     } else if (rank === 'species') {
         item.genericName = parentContext.genus
         item.infragenericEpithet = parentContext.subgenus
         if (taxon.toLowerCase() !== taxon && !/^[A-Z][a-z]+ [a-z]+\xD7[A-Z][a-z]+ [a-z]+$/.test(taxon)) {
-            console.log(item, taxon)
-            throw new Error(`Specific epithet should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Specific epithet should be lowercase: "${taxon}"`, item)
         }
         item.specificEpithet = taxon
         item.scientificName = `${item.genericName} ${item.specificEpithet}`
@@ -359,8 +365,7 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         item.scientificName = nameParts.join(' ')
 
         if (item.infraspecificEpithet !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Infraspecific epithet should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Infraspecific epithet should be lowercase: "${taxon}"`, item)
         }
     }
 
@@ -371,4 +376,4 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
     }
 
     return item
-}
+}

package/src/resources/parse-text.ts

@@ -1,7 +1,7 @@
 import * as yaml from 'js-yaml'
 import { WorkResource } from './resource'
 import { createDiff, ResourceDiffType } from './diff-resource'
-import { parseName, RANKS } from './parse-name'
+import { parseName, RANKS, RecoverableSyntaxError } from './parse-name'
 
 const MAIN_RANKS: Rank[] = [
     'kingdom',
@@ -144,7 +144,7 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
     let lineNumber = offsetLine
 
     const parents: Array<TaxonId | null> = []
-    const previous = { id: '', indent: 0, group: { isLeaf: false, indent: 0 } }
+    const previous = { id: '', indent: 0, group: { isLeaf: false, indent: 0 }, errors: <SyntaxError[]>[] }
 
     for (const line of content) {
         const hasOriginalId = line.type !== ResourceDiffType.Added && !/^\s*(\[indet\]|> )/.test(line.original ?? line.text as string)
@@ -170,7 +170,6 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
             continue
         } else if (lineIndent <= previous.group.indent && (data[previous.id] && !previous.group.isLeaf)) {
             errors.push(makeParseError('Missing leaf taxon', lineNumber - 1))
-            continue
         }
 
         // Update parentage
@@ -198,20 +197,28 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         // Do not process "indet" lines further, as they only serve to indicate
         // that subtaxa are explicitely omitted
         if (name.startsWith('[indet]')) {
+            errors.push(...previous.errors)
+            previous.errors.length = 0
             previous.group.isLeaf = lineIndent / INDENT >= leafTaxonIndex
             continue
         }
 
         const parentId = parents.reduce((grandparent, parent) => parent ?? grandparent, null)
         const parent = parentId === null ? {} as WorkingTaxon : data[parentId]
-        const rank = resource.metadata.levels[parents.length]
         let item
+        const itemErrors = []
 
         try {
+            const rank = resource.metadata.levels[parents.length]
             item = parseName(name, rank, parent)
         } catch (error) {
-            errors.push(makeParseError(error.message, lineNumber))
-            continue
+            if (error instanceof RecoverableSyntaxError) {
+                itemErrors.push(makeParseError(error.message, lineNumber))
+                item = error.result
+            } else {
+                errors.push(makeParseError(error.message, lineNumber))
+                continue
+            }
         }
 
         // Add higher classification info
@@ -236,12 +243,31 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
 
         // Amend "parent" with corrections, exit
         if (item.taxonomicStatus === 'incorrect') {
+            if (parent.taxonomicStatus !== 'accepted') {
+                // Remove corrected synonym from parentage
+                parents[parents.length - 1] = null
+            }
+
+            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 = { ...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
         }
 
@@ -267,6 +293,8 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         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
@@ -274,6 +302,7 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         }
     }
 
+    errors.push(...previous.errors)
     if (errors.length) {
         throw mergeParserErrors(errors)
     }

package/test/resources.js

@@ -3,8 +3,8 @@ const assert = require('assert')
 
 const { catalog, resources } = require('../lib')
 
-suite('catalog', async (t) => {
-    await test('reports missing required fields', (t) => {
+suite('catalog', () => {
+    test('reports missing required fields', () => {
         const errors = catalog.loadData(`id
 B1`, 'catalog').validate()
         assert.deepStrictEqual(errors, [
@@ -18,8 +18,8 @@ B1`, 'catalog').validate()
     })
 })
 
-suite('resources', async (t) => {
-    await test('parses author with initials', (t) => {
+suite('resources', () => {
+    test('parses author with initials', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [family, genus, species]
 ---
@@ -33,32 +33,7 @@ Sphecidae A. Costa, 1886
         assert.deepStrictEqual(Object.values(resource.taxa).map(taxon => taxon.scientificNameAuthorship), Array(3).fill('A. Costa, 1886'))
     })
 
-    await test('does not validate name with correction', (t) => {
-        const [resource] = resources.parseTextFile(`---
-levels: [species]
----
-
-Clytochrysus lapidarius (Panzer, 1804)
-  = Crabo chrysostomus Lepeletier & Brullé, 1835
-    > Crabro chrysostomus Lepeletier & Brullé, 1835
-`, 'T1')
-        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Clytochrysus lapidarius (Panzer, 1804)')
-    })
-
-    await test('errors for missing leaf taxa', (t) => {
-        assert.throws(() => {
-            resources.parseTextFile(`---
-levels: [family, genus, species]
----
-
-Cydnidae
-Cydnidae
-  Legnotus
-    limbosus`, 'T1')
-        })
-    })
-
-    await test('parses synonyms starting with intraspecific ranks', (t) => {
+    test('parses synonyms starting with intraspecific ranks', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [species]
 ---
@@ -69,7 +44,7 @@ Lygaeus equestris (Linnaeus, 1758)
         assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Lygaeus equestris f. lactans Horváth, 1899')
     })
 
-    await test('parses accepted taxa starting with intraspecific ranks', (t) => {
+    test('parses accepted taxa starting with intraspecific ranks', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [species, form]
 ---
@@ -80,18 +55,7 @@ Lygaeus equestris (Linnaeus, 1758)
         assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Lygaeus equestris f. lactans Horváth, 1899')
     })
 
-    await test('does not validate "indet." lines', (t) => {
-        const [resource] = resources.parseTextFile(`---
-levels: [genus, species]
----
-
-Drymus
-  [indet]
-`, 'T1')
-        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Drymus')
-    })
-
-    await test('parses names containing non-ASCII characters', (t) => {
+    test('parses names containing non-ASCII characters', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [species]
 ---
@@ -101,7 +65,7 @@ Nematus fåhraei Thomson
         assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Nematus fåhraei Thomson')
     })
 
-    await test('parses synonyms in different genera', (t) => {
+    test('parses synonyms in different genera', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [species]
 ---
@@ -113,7 +77,7 @@ Katamenes arbustorum subsp. burlinii
         assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Eumenes arbustorum var. burlinii')
     })
 
-    await test('parses species without generic names', (t) => {
+    test('parses species without generic names', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [genus, subgenus, species]
 ---
@@ -125,7 +89,7 @@ Microdynerus Thomson, 1874
         assert.strictEqual(resource.taxa['T1:1:3'].scientificName, 'Microdynerus microdynerus (Dalla Torre, 1889)')
     })
 
-    await test('parses hybrids', (t) => {
+    test('parses hybrids', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [species]
 ---
@@ -137,20 +101,7 @@ Tilia x vulgaris
         assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Tilia ×vulgaris')
     })
 
-    await test('outputs corrected generic names', (t) => {
-        const [resource] = resources.parseTextFile(`---
-levels: [genus, species]
----
-
-Bogdania Kerzhner, 1964
-  > Bogdiana Kerzhner, 1964
-  myrmica Kerzhner, 1964
-`, 'T1')
-        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Bogdiana Kerzhner, 1964')
-        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Bogdiana myrmica Kerzhner, 1964')
-    })
-
-    await test('parses cross-genus hybrids', (t) => {
+    test('parses cross-genus hybrids', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [genus, species]
 ---
@@ -165,7 +116,7 @@ x Festulpia
         assert.strictEqual(resource.taxa['T1:1:3'].scientificName, '×Festulpia Festuca rubra×Vulpia bromoides')
     })
 
-    await test('parses cross-genus hybrids without parent context', (t) => {
+    test('parses cross-genus hybrids without parent context', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [species]
 ---
@@ -176,7 +127,7 @@ x Festulpia Festuca_rubra x Vulpia_bromoides
         assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, '× Festulpia Festuca rubra × Vulpia bromoides')
     })
 
-    await test('handles skips in ranks', (t) => {
+    test('handles skips in ranks', () => {
         const [resource] = resources.parseTextFile(`---
 levels: [family, genus, species]
 ---
@@ -189,8 +140,59 @@ Apidae
         assert.strictEqual(resource.taxa['T1:1:2'].taxonRank, 'species')
     })
 
-    await test('synonyms do not break recognition of missing leaf taxa (1)', (t) => {
+    test('parses genera with subgenus-rank synonyms', () => {
         const [resource] = resources.parseTextFile(`---
+levels: [genus]
+---
+
+Ectemnius Dahlbom
+  = Crabro (Ectemnius) Dahlbom
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:2'].taxonRank, 'subgenus')
+        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Ectemnius Dahlbom')
+        assert.strictEqual(resource.taxa['T1:1:2'].genericName, 'Crabro')
+    })
+
+    test('parses genera with like-name subgenera', () => {
+        const [resource] = resources.parseTextFile(`---
+levels: [genus, subgenus]
+---
+
+Polistes Latreille, 1802
+  Polistes Latreille, 1802
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:2'].taxonRank, 'subgenus')
+        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Polistes Latreille, 1802')
+        assert.strictEqual(resource.taxa['T1:1:2'].genericName, 'Polistes')
+    })
+
+    suite('leaf taxa checks', () => {
+        test('errors for missing leaf taxa', () => {
+            assert.throws(() => {
+                resources.parseTextFile(`---
+levels: [family, genus, species]
+---
+
+Cydnidae
+Cydnidae
+  Legnotus
+    limbosus`, 'T1')
+            })
+        })
+
+        test('does not validate "indet." lines', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [genus, species]
+---
+
+Drymus
+  [indet]
+`, 'T1')
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Drymus')
+        })
+
+        test('synonyms do not break recognition of missing leaf taxa (1)', () => {
+            const [resource] = resources.parseTextFile(`---
 levels: [genus, subgenus, species]
 ---
 
@@ -199,12 +201,12 @@ Bombus
   Bombus
     pascuorum
 `, 'T1')
-        assert.strictEqual(resource.taxa['T1:1:4'].scientificName, 'Bombus pascuorum')
-    })
+            assert.strictEqual(resource.taxa['T1:1:4'].scientificName, 'Bombus pascuorum')
+        })
 
-    await test('synonyms do not break recognition of missing leaf taxa (2)', (t) => {
-        assert.throws(() => {
-          resources.parseTextFile(`---
+        test('synonyms do not break recognition of missing leaf taxa (2)', () => {
+            assert.throws(() => {
+            resources.parseTextFile(`---
 levels: [genus, subgenus, species]
 ---
 
@@ -214,12 +216,12 @@ Bombus
   Bombus
     pascuorum
 `, 'T1')
+            })
         })
-    })
 
-    await test('synonyms do not break recognition of missing leaf taxa (3)', (t) => {
-        assert.throws(() => {
-            resources.parseTextFile(`---
+        test('synonyms do not break recognition of missing leaf taxa (3)', () => {
+            assert.throws(() => {
+                resources.parseTextFile(`---
 levels: [family, genus, species]
 ---
 
@@ -229,32 +231,123 @@ Cydnidae
   Legnotus
     limbosus
 `, 'T1')
+            })
         })
     })
 
-    await test('parses genera with subgenus-rank synonyms', (t) => {
-        const [resource] = resources.parseTextFile(`---
-levels: [genus]
+    suite('corrections', () => {
+        test('outputs corrected generic names', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [genus, species]
 ---
 
-Ectemnius Dahlbom
-  = Crabro (Ectemnius) Dahlbom
+Bogdania Kerzhner, 1964
+  > Bogdiana Kerzhner, 1964
+  myrmica Kerzhner, 1964
 `, 'T1')
-        assert.strictEqual(resource.taxa['T1:1:2'].taxonRank, 'subgenus')
-        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Ectemnius Dahlbom')
-        assert.strictEqual(resource.taxa['T1:1:2'].genericName, 'Crabro')
-    })
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Bogdiana Kerzhner, 1964')
+            assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Bogdiana myrmica Kerzhner, 1964')
+        })
 
-    await test('parses genera with like-name subgenera', (t) => {
-        const [resource] = resources.parseTextFile(`---
-levels: [genus, subgenus]
+        test('does not validate name with correction', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [species]
 ---
 
-Polistes Latreille, 1802
-  Polistes Latreille, 1802
+Clytochrysus lapidarius (Panzer, 1804)
+  = Crabo chrysostomus Lepeletier & Brullé, 1835
+    > Crabro chrysostomus Lepeletier & Brullé, 1835
 `, 'T1')
-        assert.strictEqual(resource.taxa['T1:1:2'].taxonRank, 'subgenus')
-        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Polistes Latreille, 1802')
-        assert.strictEqual(resource.taxa['T1:1:2'].genericName, 'Polistes')
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Clytochrysus lapidarius (Panzer, 1804)')
+        })
+
+        test('parses invalid but corrected name', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Crabro Kiesenwetteri A. Morawitz. 1866
+  > Crabro kiesenwetteri A. Morawitz. 1866
+`, 'T1')
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Crabro kiesenwetteri A. Morawitz. 1866')
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificNameAuthorship, 'A. Morawitz. 1866')
+            assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, 'Crabro Kiesenwetteri A. Morawitz. 1866')
+        })
+
+        test('parses children of invalid but corrected name', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [genus, species]
+---
+
+Pirus L.
+  > Pyrus L.
+  aucuparia Gaertn.
+  Pirus domestica Sm.
+  Pirus aria Ehrh.
+    > Pyrus aria Ehrh.
+`, 'T1')
+            assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Pyrus aucuparia Gaertn.')
+            assert.strictEqual(resource.taxa['T1:1:3'].scientificName, 'Pyrus domestica Sm.')
+            assert.strictEqual(resource.taxa['T1:1:4'].scientificName, 'Pyrus aria Ehrh.')
+        })
+
+        test('does not keep parts of invalid but corrected name', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Scolia 5-punctata FABRICIUS, 1781
+  > Scolia quinquepunctata FABRICIUS, 1781
+`, 'T1')
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Scolia quinquepunctata Fabricius, 1781')
+            assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, 'Scolia 5-punctata FABRICIUS, 1781')
+        })
+
+        test('make correct diff when last line changes', () => {
+            const newText = `---
+levels: [species]
+---
+
+Bittacus Hageni Brauer
+  > Bittacus hageni Brauer
+`
+            const oldText = `---
+levels: [genus, species]
+---
+
+Bittacus hageni Brauer
+`
+
+            const [resource] = resources.parseTextFile(newText, 'T1', { txt: oldText, dwc: [[null, ['T:1:1'], ['T:1:2']]] })
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Bittacus hageni Brauer')
+            assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, 'Bittacus Hageni Brauer')
+        })
+
+        test('corrections of synonyms are correctly applied', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [genus, subgenus, species]
+---
+
+Lasius F.
+  = Domisthorpea Mor. & Drnt., 1915
+    > Donisthorpea Mor. & Drnt., 1915
+    fuliginosus Latr.
+`, 'T1')
+            assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Donisthorpea Mor. & Drnt., 1915')
+            assert.strictEqual(resource.taxa['T1:1:3'].scientificName, 'Lasius fuliginosus Latr.')
+        })
+
+        test('corrections are correctly applied', () => {
+            const [resource] = resources.parseTextFile(`---
+levels: [genus, species]
+---
+
+Neopachygaster Austin, 1901
+  > Neopachygaster Austen, 1901
+  meromelas (Dufour, 1841)
+`, 'T1')
+            assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Neopachygaster Austen, 1901')
+            assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Neopachygaster meromelas (Dufour, 1841)')
+        })
     })
 })

package/tsconfig.json

@@ -1,11 +1,14 @@
 {
   "compilerOptions": {
     "outDir": "./lib",
-    "target": "es5",
+    "target": "es6",
 
     "noImplicitAny": true,
     "strictNullChecks": true,
     "noImplicitThis": true,
+
+    "module": "commonjs",
+    "moduleResolution": "node10",
     "esModuleInterop": true
   },
   "include": ["./src/**/*"]