@natlibfi/marc-record-validators-melinda 11.6.7 → 12.0.0-alpha.12

package/src/cyrillux.js

@@ -1,15 +1,14 @@
 //import createDebugLogger from 'debug';
 import clone from 'clone';
-import {fieldHasSubfield, fieldToString, fieldsToString, isControlSubfieldCode, nvdebug} from './utils';
-import * as iso9 from 'iso9_1995';
-import {fieldGetMaxSubfield6OccurrenceNumberAsInteger, fieldGetOccurrenceNumberPairs, fieldGetUnambiguousOccurrenceNumber, intToOccurrenceNumberString, recordGetMaxSubfield6OccurrenceNumberAsInteger, resetSubfield6Tag} from './subfield6Utils';
-
 import XRegExp from 'xregexp';
+import * as iso9 from '@natlibfi/iso9-1995';
 import * as sfs4900 from '@natlibfi/sfs-4900';
-import {default as sortFields} from './sortFields';
-import {default as reindexSubfield6OccurenceNumbers} from './reindexSubfield6OccurenceNumbers';
-import {fieldStripPunctuation} from './punctuation2';
-import {getLanguageCode} from './addMissingField041';
+import {fieldHasSubfield, fieldToString, fieldsToString, isControlSubfieldCode, nvdebug} from './utils.js';
+import {fieldGetMaxSubfield6OccurrenceNumberAsInteger, fieldGetOccurrenceNumberPairs, fieldGetUnambiguousOccurrenceNumber, intToOccurrenceNumberString, recordGetMaxSubfield6OccurrenceNumberAsInteger, resetSubfield6Tag} from './subfield6Utils.js';
+import {default as sortFields} from './sortFields.js';
+import {default as reindexSubfield6OccurenceNumbers} from './reindexSubfield6OccurenceNumbers.js';
+import {fieldStripPunctuation} from './punctuation2.js';
+import {getLanguageCode} from './addMissingField041.js';
 
 const iso9Trans = 'ISO9 <TRANS>';
 const cyrillicTrans = 'CYRILLIC <TRANS>';
@@ -158,16 +157,24 @@ export default function (config = {}) {
     if (!subfieldRequiresTransliteration(subfield)) {
       return {code: subfield.code, value: subfield.value}; // just clone
     }
-    const value = iso9.convertToLatin(subfield.value);
 
-    return {code: subfield.code, value};
+    const conversionResult = iso9.convertToLatin(subfield.value);
+
+    return {code: subfield.code, value: conversionResult.result};
   }
 
   function mapSubfieldToSfs4900(subfield, lang = 'rus') {
     const inputLang = lang === 'ukr' ? 'ukr' : 'rus'; // Support 'ukr' and 'rus', default to 'rus'
-    const value = subfieldRequiresTransliteration(subfield) ? sfs4900.convertToLatin(subfield.value, inputLang).result : subfield.value;
+    if (!subfieldRequiresTransliteration(subfield)) {
+      return {code: subfield.code, value: subfield.value};
+    }
+    const conversionResult = sfs4900.convertToLatin(subfield.value, inputLang);
+
+    console.log(JSON.stringify(conversionResult));
+    const result = conversionResult.result;
+    console.log(JSON.stringify(result));
     //console.log(`VAL: ${subfield.value} => ${value} using ${lang}`); // eslint-disable-line no-console
-    return {code: subfield.code, value};
+    return {code: subfield.code, value: result};
   }
 
   function mapField(field, occurrenceNumber, iso9 = true, lang = 'rus') {

package/src/{cyrillux.spec.js → cyrillux.test.js}

@@ -1,32 +1,31 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './cyrillux';
+import validatorFactory from './cyrillux.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'cyrillux'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'cyrillux'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
-  expect(validator.fix).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
+  assert.equal(typeof validator.fix, 'function');
 }
 
 async function callback({getFixture, fix = false, config = {}}) {
@@ -37,10 +36,10 @@ async function callback({getFixture, fix = false, config = {}}) {
 
   if (!fix) {
     const result = await validator.validate(record);
-    expect(result).to.eql(expectedResult);
+    assert.deepEqual(result, expectedResult);
     return;
   }
 
   await validator.fix(record);
-  expect(record).to.eql(expectedResult);
+  assert.deepEqual(record, expectedResult);
 }

package/src/disambiguateSeriesStatements.js

@@ -1,10 +1,10 @@
 import createDebugLogger from 'debug';
-import {fieldToString, nvdebug, subfieldToString} from './utils';
+import {fieldToString, nvdebug, subfieldToString} from './utils.js';
 import {MARCXML} from '@natlibfi/marc-record-serializers';
 import {Error} from '@natlibfi/melinda-commons';
 import clone from 'clone';
 import {default as createNatlibfiSruClient} from '@natlibfi/sru-client';
-import {fieldFixPunctuation} from './punctuation2';
+import {fieldFixPunctuation} from './punctuation2.js';
 
 //const {default: createNatlibfiSruClient} = natlibfiSruClient;
 

package/src/{disambiguateSeriesStatements.spec.js → disambiguateSeriesStatements.test.js}

@@ -1,20 +1,22 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './disambiguateSeriesStatements';
+import validatorFactory from './disambiguateSeriesStatements.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'disambiguate-series-statements'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'disambiguate-series-statements'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/disambiguateSeriesStatements:test');
@@ -22,12 +24,9 @@ const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/disamb
 async function testValidatorFactory() {
   const validator = await validatorFactory();
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
 }
 
 async function callback({getFixture, enabled = true, fix = false}) {
@@ -43,10 +42,10 @@ async function callback({getFixture, enabled = true, fix = false}) {
 
   if (!fix) {
     const result = await validator.validate(record);
-    expect(result).to.eql(expectedResult);
+    assert.deepEqual(result, expectedResult);
     return;
   }
 
   await validator.fix(record);
-  expect(record).to.eql(expectedResult);
+  assert.deepEqual(record, expectedResult);
 }

package/src/double-commas.js

@@ -6,7 +6,7 @@ export default function () {
         .get(/^700$/u)
         .some(f => f.subfields.every(sf => sf.code === 'e' && (/,,/u).test(sf.value)))
     }),
-    fix: record => record.get(/^700$/u).forEach(f => f.subfields.filter(sf => sf.code === 'e').forEach(sf => { // eslint-disable-line array-callback-return
+    fix: record => record.get(/^700$/u).forEach(f => f.subfields.filter(sf => sf.code === 'e').forEach(sf => {
       sf.value = sf.value.replace(/,,/u, ',');
     }))
   };

package/src/{double-commas.spec.js → double-commas.test.js}

@@ -1,17 +1,15 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/double-commas';
+import validatorFactory from './double-commas.js';
+import {describe, it} from 'node:test';
 
 describe('double-commas', () => {
   it('Creates a validator', async () => {
     const validator = await validatorFactory();
 
-    expect(validator)
-      .to.be.an('object')
-      .that.has.any.keys('description', 'validate');
-
-    expect(validator.description).to.be.a('string');
-    expect(validator.validate).to.be.a('function');
+    assert.equal(typeof validator, 'object');
+    assert.equal(typeof validator.description, 'string');
+    assert.equal(typeof validator.validate, 'function');
   });
 
   describe('#validate', () => {
@@ -22,7 +20,7 @@ describe('double-commas', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: true});
+      assert.deepEqual(result, {valid: true});
     });
     it('Finds the record invalid', async () => {
       const validator = await validatorFactory();
@@ -31,7 +29,7 @@ describe('double-commas', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
   });
 
@@ -43,7 +41,7 @@ describe('double-commas', () => {
       });
       await validator.fix(record);
 
-      expect(record.fields).to.eql([
+      assert.deepEqual(record.fields, [
         {
           tag: '700',
           ind1: ' ',

package/src/duplicates-ind1.js

@@ -20,7 +20,7 @@ export default function (tagPattern) {
     iterateFields(record)
       .filter(item => item.validation === false)
       .map(({validation, ...item}) => item) // eslint-disable-line no-unused-vars
-      .forEach(({obj}) => record.removeField(obj)); // eslint-disable-line array-callback-return
+      .forEach(({obj}) => record.removeField(obj));
   }
 
   function iterateFields(record) {

package/src/{duplicates-ind1.spec.js → duplicates-ind1.test.js}

@@ -1,6 +1,6 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './duplicates-ind1';
+import validatorFactory from './duplicates-ind1.js';
 
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
@@ -8,14 +8,16 @@ import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'duplicates-ind1'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'duplicates-ind1'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
 
@@ -24,12 +26,9 @@ const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/duplic
 async function testValidatorFactory() {
   const validator = await validatorFactory(/^500$/u);
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
 }
 
 async function callback({getFixture, tagPattern, fix = false}) {
@@ -39,10 +38,10 @@ async function callback({getFixture, tagPattern, fix = false}) {
 
   if (!fix) {
     const result = await validator.validate(record);
-    return expect(result).to.eql(expectedResult);
+    return assert.deepEqual(result, expectedResult);
   }
 
   const fixedRecord = await validator.fix(record);
   debug(fixedRecord);
-  expect(record.fields).to.eql(expectedResult);
+  assert.deepEqual(record.fields, expectedResult);
 }

package/src/{empty-fields.spec.js → empty-fields.test.js}

@@ -1,6 +1,7 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/empty-fields';
+import validatorFactory from './empty-fields.js';
+import {after, before, describe, it} from 'node:test';
 
 before(() => {
   MarcRecord.setValidationOptions({subfields: false, subfieldValues: false});
@@ -14,12 +15,9 @@ describe('empty-fields', () => {
   it('Creates a validator', async () => {
     const validator = await validatorFactory();
 
-    expect(validator)
-      .to.be.an('object')
-      .that.has.any.keys('description', 'validate');
-
-    expect(validator.description).to.be.a('string');
-    expect(validator.validate).to.be.a('function');
+    assert.equal(typeof validator, 'object');
+    assert.equal(typeof validator.description, 'string');
+    assert.equal(typeof validator.validate, 'function');
   });
 
   describe('#validate', () => {
@@ -38,7 +36,7 @@ describe('empty-fields', () => {
         ]
       });
       const result = await validator.validate(record);
-      expect(result).to.to.have.property('valid', true);
+      assert.deepEqual(result.valid, true);
     });
 
     it('Finds a missing subfield value', async () => {
@@ -57,7 +55,7 @@ describe('empty-fields', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: false, messages: ['Field 245 has missing subfield values: a']});
+      assert.deepEqual(result, {valid: false, messages: ['Field 245 has missing subfield values: a']});
     });
 
     it('Finds an empty subfield array', async () => {
@@ -72,7 +70,7 @@ describe('empty-fields', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: false, messages: ['Field 500 has no subfields']});
+      assert.deepEqual(result, {valid: false, messages: ['Field 500 has no subfields']});
     });
   });
 
@@ -97,7 +95,7 @@ describe('empty-fields', () => {
       });
       await validator.fix(record);
 
-      expect(record.fields).to.eql([
+      assert.deepEqual(record.fields, [
         {
           tag: '245',
           ind1: ' ',
@@ -128,7 +126,7 @@ describe('empty-fields', () => {
       });
       await validator.fix(record);
 
-      expect(record.fields).to.eql([
+      assert.deepEqual(record.fields, [
         {
           tag: '001',
           value: '1234567'

package/src/ending-punctuation-conf.js

@@ -1,10 +1,11 @@
 // Const finnishTerms = ['ysa', 'yso', 'kassu', 'seko', 'valo', 'kulo', 'puho', 'oiko', 'mero', 'liito', 'fast', 'allars', 'kaunokki'];
 const finnishTerms = [
   /^(?:allars|bella|fast|juho|jupo|kassu|kauno|kaunokki|keko|koko|kulo|liiko|liito|local|mero|mts|musa|oiko|puho|seko|woto|valo|ysa|yso)$/u,
-  /^(?:kauno|slm|yso)\//u
+  /^(?:kauno|slm|yso)\//u // <= yso/* etc
 ];
 
-const validPuncMarks = '?"-!,)]';
+const validPuncMarks = '?-!.'; // NB! ')' and ']' are only valid for some fields!
+const validQuoteChars = "\"'";
 // Configuration specification
 const confSpec = [
   { // 010-035 EI
@@ -500,7 +501,7 @@ const confSpec = [
     index: null,
     punc: false,
     special: {
-      termField: '2',
+      termSubfieldCode: '2',
       finnishTerms,
       else: true
     }
@@ -516,7 +517,7 @@ const confSpec = [
     index: null,
     punc: false,
     special: {
-      termField: '2',
+      termSubfieldCode: '2',
       finnishTerms,
       else: true
     }
@@ -666,4 +667,4 @@ const confSpec = [
   }
 ];
 
-export {finnishTerms, validPuncMarks, confSpec};
+export {finnishTerms, validPuncMarks, validQuoteChars, confSpec};

package/src/ending-punctuation.js

@@ -27,7 +27,7 @@
 */
 
 // Import {validPuncMarks, finnishTerms, confSpec} from './ending-punctuation-conf.js';
-import {validPuncMarks, finnishTerms, confSpec} from './ending-punctuation-conf';
+import {validPuncMarks, validQuoteChars, finnishTerms, confSpec} from './ending-punctuation-conf.js';
 import createDebugLogger from 'debug';
 
 const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/ending-punctuation');
@@ -65,40 +65,65 @@ export default function () {
 
 // Field validation with punctuation rules for normal and special cases in subfunction (to reduce complexity to please travisci)
 function validateField(field, linkedTag, fix, message) {
-  // This is used to find last subfield that should have punctuation
-  function findLastSubfield(field) {
-    const subfields = field.subfields.filter(sf => isNaN(sf.code) && 'value' in sf);
-    return subfields.slice(-1).shift();
+  function getDefaultPuncMarks(tag) {
+    if (tag.match(/^[1678](?:00|10|11|30)/u) || tag === '740') { // As defined in Loppupisteohje
+      return `${validPuncMarks})`;
+    }
+    // We don't want ').' here either. However, Loppupisteohje is a bit iffy here.
+    // BUG: Note that our generic rules will remove dot from Finnish terms such as https://finto.fi/yso-aika/fi/page/p1069910600
+    if (['647', '648', '650', '651', '654', '655', '656', '657', '658', '662'].includes(tag)) {
+       return `${validPuncMarks})`;
+    }
+    if(['260'].includes(tag)) {
+      return `${validPuncMarks})]`;
+    }
+    return validPuncMarks;
   }
 
   // Punctuation rule (Boolean), Check no ending dot strict (Boolean)
   function normalPuncRules(subfield, punc, tag, checkEnd, overrideValidPuncMarks) {
-    const puncMarks = overrideValidPuncMarks || validPuncMarks;
-    const lastPuncMark = puncMarks.includes(subfield.value.slice(-1)); // If string ends to punctuation char
-    const lastPuncDot = '.'.includes(subfield.value.slice(-1)); // If string ends to dot
+    const puncMarks = overrideValidPuncMarks || getDefaultPuncMarks(tag);
+    const lastChar = subfield.value.slice(-1);
+    const lastPuncMark = puncMarks.includes(lastChar); // If string ends to punctuation char
+    const lastPuncDot = '.'.includes(lastChar); // If string ends to dot
+    const penultimateCharacter = subfield.value.length >= 2 ? subfield.value.charAt(subfield.value.length - 2) : undefined;
+    const antePenultimateCharacter = subfield.value.length >= 3 ? subfield.value.charAt(subfield.value.length - 3) : undefined;
+
 
-    // Last char should be punc, but its not one of marks nor dot
+    // Last char should be punc, but it's not one of listed punctuation marks nor dot
     if (punc && !(lastPuncMark || lastPuncDot)) {
-      // Console.log("1. Invalid punctuation - missing")
-      message.message.push(`Field ${tag} has invalid ending punctuation`);
-      if (fix) {
-        subfield.value = subfield.value.concat('.');
-        message.fix.push(`Field ${tag} - Added punctuation to $${subfield.code}`);
+      //console.log(puncMarks)
+      if (penultimateCharacter && validQuoteChars.includes(lastChar) && puncMarks.includes(penultimateCharacter)) {
+        // Exception: do nothing! Ending in punc+quote combo is all right, and does not imply a missing punc
+      }
+      else {
+        // Console.log("1. Invalid punctuation - missing")
+        message.message.push(`Field ${tag} requires ending punctuation, ends in '${lastChar}'`);
+        if (fix) {
+          subfield.value = subfield.value.concat('.');
+          message.fix.push(`Field ${tag} - Added punctuation to $${subfield.code}`);
+        }
       }
 
       // Last char is dot, but previous char is one of punc marks, like 'Question?.'
-    } else if (lastPuncDot && subfield.value.length > 1 && puncMarks.includes(subfield.value.charAt(subfield.value.length - 2))) {
+    } else if (lastPuncDot && penultimateCharacter && puncMarks.includes(penultimateCharacter)) {
       // Console.log("2. Invalid punctuation - duplicate, like '?.'")
-      message.message.push(`Field ${tag} has invalid ending punctuation`);
+      message.message.push(`Field ${tag} has an extra dot after '${penultimateCharacter}'`);
       if (fix) {
         subfield.value = subfield.value.slice(0, -1);
-        message.fix.push(`Field ${tag} - Removed double punctuation from $${subfield.code}`);
+        message.fix.push(`Field ${tag} - Removed dot after punctuation from $${subfield.code}`);
+      }
+      // Last char is dot, but previous two cars are punc+quote, like 'Lorum "Ipsum.".'
+    } else if (lastPuncDot && antePenultimateCharacter && validQuoteChars.includes(penultimateCharacter) && puncMarks.includes(antePenultimateCharacter)) {
+      message.message.push(`Field ${tag} has an extra dot in '${antePenultimateCharacter}${penultimateCharacter}${lastChar}'`);
+      if (fix) {
+        subfield.value = subfield.value.slice(0, -1);
+        message.fix.push(`Field ${tag} - Removed '${lastChar}' after '${antePenultimateCharacter}${penultimateCharacter}'`);
       }
-
       // Last char shouldn't be dot !! This is behind checkEnd boolean, because of dots at end of abbreviations, so this is checked only in special cases !!//
     } else if (checkEnd && (!punc && lastPuncDot)) {
       // Console.log("3. Invalid punctuation - Shouldn't be dot, is")
-      message.message.push(`Field ${tag} has invalid ending punctuation`);
+      message.message.push(`Field ${tag} has unwanted ending punctuation '${lastChar}'`);
       if (fix) {
         subfield.value = subfield.value.slice(0, -1);
         message.fix.push(`Field ${tag} - Removed punctuation from $${subfield.code}`);
@@ -136,7 +161,7 @@ function validateField(field, linkedTag, fix, message) {
         if (res.special.ifInd2 && res.special.ifInd2.includes(field.ind2)) {
           normalPuncRules(lastSubField, res.special.ifBoth, tag, true, res.special.ifLastCharNot);
 
-          // Matches execption to special rule, noPuncIfInd2 (likely with value 4, that indicates copyright mark)
+          // Matches exception to special rule, noPuncIfInd2 (likely with value 4, that indicates copyright mark)
         } else if (res.special.noPuncIfInd2 && field.ind2 && res.special.noPuncIfInd2.includes(field.ind2)) {
           normalPuncRules(lastSubField, !res.special.ifBoth, tag, true, res.special.ifLastCharNot);
 
@@ -158,12 +183,17 @@ function validateField(field, linkedTag, fix, message) {
       normalPuncRules(lastSubField, res.punc, tag, false, false);
 
       // Search for Finnish terms
-    } else if (res.special.termField) {
+    } else if (res.special.termSubfieldCode) {
       lastSubField = findLastSubfield(field);
 
       if (lastSubField) {
-        const languageField = field.subfields.find(({code}) => code === res.special.termField);
-        if (languageField && languageField.value && finnishTerms.some(p => p.test(languageField.value))) {
+        const lexicon = getLexicon(field, res.special.termSubfieldCode);
+        const proceed = !finnishException(field, res.special.termSubfieldCode, false);
+
+
+        //const languageField = field.subfields.find(({code}) => code === res.special.termSubfieldCode);
+        //if (languageField && languageField.value && finnishTerms.some(p => p.test(languageField.value))) {
+        if (lexicon && finnishTerms.some(p => p.test(lexicon)) && proceed) {
           // If (languageField && languageField.value && finnishTerms.indexOf(languageField.value) > -1) {
           normalPuncRules(lastSubField, res.punc, tag, true, false);
         } else {
@@ -199,6 +229,15 @@ function validateField(field, linkedTag, fix, message) {
 
       validateField(field, linkedTag, fix, message);
     }
+    // fallback
+    else {
+      debug(`special is definedm but no rule applies`);
+      const lastSubField = findLastSubfield(field);
+
+      if (lastSubField) {
+        normalPuncRules(lastSubField, res.punc, field.tag, false, false, fix, message);
+      }
+    }
   }
 
   let res = null;
@@ -232,8 +271,12 @@ function validateField(field, linkedTag, fix, message) {
     return;
   }
 
+  const forceNormal = res.special ? finnishException(field, res.special.termSubfieldCode, true) : false;
   // Normal rules
-  if (typeof res.special === 'undefined' || res.special === null) {
+  if (typeof res.special === 'undefined' || res.special === null || forceNormal) {
+    if (forceNormal) {
+      console.info("EXCEPTION. SKIP FINNISH RULES");
+    }
     lastSubField = findLastSubfield(field);
 
     if (lastSubField) {
@@ -260,3 +303,51 @@ export function validateSingleField(field, linkedTag, fix) {
   return message;
 }
 
+function getLexicon(field, subfieldCode) {
+  const languageSubfield = field.subfields.find(({code}) => code === subfieldCode); // res.special.termSubfieldCode);
+  if (!languageSubfield || !languageSubfield.value) {
+    return undefined;
+  }
+  if (finnishTerms.find(p => p.test(languageSubfield.value))) {
+    return languageSubfield.value;
+  }
+  return undefined;
+}
+
+function finnishException(field, termSubfieldCode, hasDot = true) {
+  const lexicon = getLexicon(field, termSubfieldCode);
+  if (!lexicon) {
+    return false;
+  }
+
+  const lastSubfield = findLastSubfield(field);
+  if (!lastSubfield || !lastSubfield.value) {
+    return false;
+  }
+  // Some terms can end in '.' that we want to keep
+  if (field.tag === '648') { // Yso-aika checks
+    //console.log(`Finnish Exception? '${lastSubfield.value}', '${lexicon}', '${field.tag}'`);
+    if (lexicon === 'yso/fin') { // 'eaa.' appears in prefLAbels and 'eKr.' in altLabels
+      if (hasDot) {
+        return lastSubfield.value.match(/ (?:eaa|[ej]Kr|jaa)\.$/u); // Finnish term from which the dot is not to be removed
+      }
+      return lastSubfield.value.match(/ (?:eaa|[ej]Kr)|jaa$/u); // Finnish word that needs a dot
+    }
+
+    if (lexicon === 'yso/swe') {
+      if (hasDot) {
+        return lastSubfield.value.match(/ (?:[ef]\.Kr|f\.v\.t)\.$/u);
+      }
+      return lastSubfield.value.match(/ (?:[ef]\.Kr|f\.v\.t)$/u);
+    }
+  }
+  // yso has 'MODEL.LA.' and 'Corel R.A.V.E.' but these are so rare I'm not listing them
+
+  return false;
+}
+
+  // This is used to find last subfield that should have punctuation
+  function findLastSubfield(field) {
+    const subfields = field.subfields.filter(sf => isNaN(sf.code) && 'value' in sf);
+    return subfields.slice(-1).shift();
+  }