@larsgw/formica 0.8.5 → 0.8.7

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,11 +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 parse_name_1 = require("./parse-name");
-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',
@@ -59,7 +48,7 @@ var MAIN_RANKS = [
     'genus',
     'species'
 ];
-var DWC_RANKS = [
+const DWC_RANKS = [
     'kingdom',
     'phylum',
     'class',
@@ -69,28 +58,27 @@ var DWC_RANKS = [
     'genus',
     'subgenus'
 ];
-var FLAGS = [
+const FLAGS = [
     'MISSING_TAXA',
     'MISSING_PARENT_TAXA',
     'MISSING_SYNONYMS',
     'MISSING_AUTHORSHIP'
 ];
-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));
+const RESOURCE_DELIMITER = '\n\n===\n\n';
+const INDENT = 2;
+function makeParseError(message, line, column = 1) {
+    return new SyntaxError(`[${line}:${column}] ${message}`);
 }
 function mergeParserErrors(errors) {
-    return new SyntaxError(errors.map(function (error) { return error.message; }).join('\n'));
+    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 = [];
     }
@@ -108,18 +96,18 @@ function parseHeader(header) {
         throw new SyntaxError('Resource contains no taxa');
     }
     // Invalid taxon ranks
-    var invalidTaxonRanks = levels.filter(function (rank) { return !parse_name_1.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();
             }
@@ -127,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);
         }
     }
@@ -150,40 +132,39 @@ 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 parseResource(resource) {
-    var _a = resource.content.split(/(\n---\n+)/), header = _a[0], _ = _a[1], rest = _a.slice(2);
-    var config;
+    const [header, _, ...rest] = resource.content.split(/(\n---\n+)/);
+    let config;
     try {
         config = parseHeader(header);
     }
     catch (error) {
         throw makeParseError(error.message, resource.offsetLine + 1);
     }
-    var content = rest.join('');
-    var offsetLine = resource.offsetLine + (header + _).split('\n').length - 1;
-    return [config, { content: content, offsetLine: offsetLine }];
+    const content = rest.join('');
+    const offsetLine = resource.offsetLine + (header + _).split('\n').length - 1;
+    return [config, { content, offsetLine }];
 }
 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 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);
+    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++;
         }
@@ -193,25 +174,24 @@ function parseResourceContent(content, resource, oldIds, offsetLine) {
         else {
             lineNumber++;
         }
-        var _c = line.text.match(/^(\s*)(.*)/).slice(1), indentation = _c[0], name_1 = _c[1];
-        var lineIndent = indentation.length;
+        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_1)) {
+        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));
-            continue;
         }
         // Update parentage
         if (lineIndent > previous.indent) {
             // Do not count synonyms as parents (unless this is correcting a typo in the synonym)
-            if (data[previous.id] && data[previous.id].taxonomicStatus === 'accepted' || name_1.startsWith('> ')) {
+            if (data[previous.id] && data[previous.id].taxonomicStatus === 'accepted' || name.startsWith('> ')) {
                 parents.push(previous.id);
             }
             else {
@@ -221,7 +201,7 @@ function parseResourceContent(content, resource, oldIds, offsetLine) {
             // e.g. if a certain genus has only species
             // whereas other genera in the same key also
             // have subgenera
-            for (var i = previous.indent + INDENT; i < lineIndent; i += INDENT) {
+            for (let i = previous.indent + INDENT; i < lineIndent; i += INDENT) {
                 parents.push(null);
             }
         }
@@ -231,32 +211,40 @@ function parseResourceContent(content, resource, oldIds, offsetLine) {
         previous.indent = lineIndent;
         // Do not process "indet" lines further, as they only serve to indicate
         // that subtaxa are explicitely omitted
-        if (name_1.startsWith('[indet]')) {
+        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 !== null && parent !== void 0 ? parent : grandparent; }, null);
-        var parent_1 = parentId === null ? {} : data[parentId];
-        var rank = resource.metadata.levels[parents.length];
-        var item = void 0;
+        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 {
-            item = (0, parse_name_1.parseName)(name_1, rank, parent_1);
+            const rank = resource.metadata.levels[parents.length];
+            item = (0, parse_name_1.parseName)(name, rank, parent);
         }
         catch (error) {
-            errors.push(makeParseError(error.message, lineNumber));
-            continue;
+            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 _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];
+        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) {
@@ -267,82 +255,99 @@ function parseResourceContent(content, resource, oldIds, offsetLine) {
         }
         // Amend "parent" with corrections, exit
         if (item.taxonomicStatus === 'incorrect') {
-            parent_1.incorrect = __assign({}, parent_1);
-            for (var key in item) {
+            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 = 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;
         }
         // Add more classification info
-        var isSynonym = item.taxonomicStatus !== 'accepted';
+        const isSynonym = item.taxonomicStatus !== 'accepted';
         if (isSynonym) {
-            item.higherClassification = parent_1.higherClassification;
+            item.higherClassification = parent.higherClassification;
         }
-        else if (parent_1.higherClassification) {
-            item.higherClassification = parent_1.higherClassification + " | ".concat(parent_1.scientificNameOnly);
+        else if (parent.higherClassification) {
+            item.higherClassification = parent.higherClassification + ` | ${parent.scientificNameOnly}`;
         }
         else if (parentId) {
-            item.higherClassification = parent_1.scientificNameOnly;
+            item.higherClassification = parent.scientificNameOnly;
         }
         // 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.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) {
-    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 });
+    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) : [];
-    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),
+    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 = void 0;
+        let diff;
         if (oldResources[index]) {
             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, 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]));
             }
         }
@@ -359,5 +364,5 @@ function parseFile(file, id, old) {
     return resources;
 }
 function parseFileHeader(file) {
-    return splitResources(file).map(function (resource) { return parseResource(resource)[0]; });
+    return splitResources(file).map(resource => parseResource(resource)[0]);
 }

package/lib/resources/resource.js

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

package/lib/taxon-names/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larsgw/formica",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "SDK and tools for data from the Library of Identification Resources",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/resources/diff-resource.ts

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