@natlibfi/marc-record-validators-melinda 12.1.0-alpha.1 → 13.0.0

package/src/resolveOrphanedSubfield6s.js

@@ -1,10 +1,12 @@
 import createDebugLogger from 'debug';
-import {fieldHasSubfield, fieldToString, nvdebug, subfieldToString} from './utils.js';
+import {fieldHasSubfield, fieldToString, nvdebug /*, subfieldToString*/ } from './utils.js';
 import {fieldHasWantedTagAndOccurrenceNumber, isValidSubfield6, subfield6GetOccurrenceNumber, subfield6ResetOccurrenceNumber} from './subfield6Utils.js';
 
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:resolveOrphanedSubfield6s');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 export default function () {
   return {
@@ -13,7 +15,7 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug('Fix SF6 orphaned occurrence numbers');
+    nvdebug('Fix SF6 orphaned occurrence numbers', debugDev);
     const res = {message: [], fix: [], valid: true};
     //message.fix = [];
 
@@ -26,7 +28,7 @@ export default function () {
 
   function validate(record) {
     // Check max, and check number of different indexes
-    nvdebug('Validate SF6 orphaned occurrence numbers', debug);
+    nvdebug('Validate SF6 orphaned occurrence numbers', debugDev);
     const fieldsContainingSubfield6 = record.fields.filter(field => fieldHasSubfield(field, '6'));
 
     const orphanedFields = getOrphanedFields(fieldsContainingSubfield6);
@@ -77,7 +79,7 @@ function findPairForSubfield6OccurrenceNumber(subfield6, myTag, candPairFields)
   if (!isValidSubfield6(subfield6)) {
     return undefined;
   }
-  nvdebug(`LOOKING FOR PAIR: ${myTag} ${subfieldToString(subfield6)}`);
+  //nvdebug(`LOOKING FOR PAIR: ${myTag} ${subfieldToString(subfield6)}`, debugDev);
   candPairFields.forEach(field => fieldToString(field));
 
   // Only valid $6 value that fails to map to another field is iffy...
@@ -88,7 +90,7 @@ function findPairForSubfield6OccurrenceNumber(subfield6, myTag, candPairFields)
     return undefined;
   }
   const tagAndOccurrenceNumber = `${myTag}-${occurrenceNumber}`;
-  nvdebug(`Try to find occurrence number ${tagAndOccurrenceNumber} in field ${referredTag}...`);
+  //nvdebug(`Try to find occurrence number ${tagAndOccurrenceNumber} in field ${referredTag}...`, debugDev);
   //const relevantFields = fields.filter(field => field.tag === referredTag && field.subfields.some(sf => subfield6GetOccurrenceNumber(sf) === occurrenceNumber));
   const relevantFields = candPairFields.filter(field => field.tag === referredTag && fieldHasWantedTagAndOccurrenceNumber(field, tagAndOccurrenceNumber));
   if (relevantFields.length === 0) {

package/src/resolveOrphanedSubfield6s.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './resolveOrphanedSubfield6s.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -20,7 +20,7 @@ generateTests({
   }
 });
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/resolveOrphanedSubfield6s:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/resolveOrphanedSubfield6s:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -30,12 +30,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/sanitize-vocabulary-source-codes.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './sanitize-vocabulary-source-codes.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -19,7 +19,7 @@ generateTests({
     }
   }
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sanitize-vocabulary-source-codes:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sanitize-vocabulary-source-codes:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -29,12 +29,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
 
   const recordFixture = getFixture('record.json');

package/src/sortFields.js

@@ -211,7 +211,7 @@ export function fieldOrderComparator(fieldA, fieldB) {
 
   //const sorterFunctions = [sortByTag, sortByIndexTerms, sortAlphabetically, sortByRelatorTerm, sortByOccurrenceNumber, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
 
-  const sorterFunctions = [sortByTag, sortByIndexTerms, sortAlphabetically, sortByRelatorTerm, sortBySubfield6, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
+  const sorterFunctions = [sortByTag, sortByIndexTerms, sortAlphabetically, sortByRelatorTerm, sortBySubfield6, preferFenniKeep, sortByFieldLinkAndSequenceNumber, sortByHacks];
   //const sorterFunctions = [sortByIndexTerms, sortByRelatorTerm, sortByOccurrenceNumber, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
 
   return globalFieldOrderComparator(fieldA, fieldB, sorterFunctions);
@@ -390,6 +390,25 @@ function sortByFieldLinkAndSequenceNumber(fieldA, fieldB) { // Sort by subfield
   return -1;
 }
 
+function sortByHacks(fieldA, fieldB) {
+  // Place for various hackier rules
+
+  if (fieldA.tag === fieldB.tag) {
+    if (fieldA.tag === '041') {
+      // If we have multiple f041, we want to put the $2-less first; Values from $2 whatever can not be copied to 008/35-37. (See sync-language.js.)
+      const a2 = fieldA.subfields.some(sf => sf.code === '2');
+      const b2 = fieldB.subfields.some(sf => sf.code === '2');
+      if (a2 && !b2) {
+        return 1;
+      }
+      if (b2 && !a2) {
+        return -1;
+      }
+    }
+
+  }
+  return 0;
+}
 
 function sortBySubfield6(fieldA, fieldB) { // Sort by subfield $6, ex-sortByOccurrenceNumber...
   if (fieldA.tag !== '880' || fieldB.tag !== '880') {

package/src/sortFields.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './sortFields.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -19,7 +19,7 @@ generateTests({
     }
   }
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortFields:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortFields:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -29,12 +29,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = true}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = true}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('input.json'));
   const expectedResult = getFixture('result.json');

package/src/sortRelatorTerms.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './sortRelatorTerms.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -20,7 +20,7 @@ generateTests({
   }
 });
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortRelatorTerms:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortRelatorTerms:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -30,12 +30,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/sortSubfields.js

@@ -8,8 +8,8 @@ const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortSu
 //const debugData = debug.extend('data');
 const debugDev = debug.extend('dev');
 
-const defaultSortOrderStringFinns = '8673abcdefghijklmnopqrstuvwxyz420159'; // NB! We Finns like $2 before $0 in 6XX...
-const defaultSortOrderStringOthers = '8673abcdefghijklmnopqrstuvwxyz402159';
+const defaultSortOrderStringFinns = '863abcdefghijklmnopqrstuvwxyz4201759'; // NB! We Finns like $2 before $0 in 6XX...
+const defaultSortOrderStringOthers = '863abcdefghijklmnopqrstuvwxyz4021759'; // NB 760-788 have '7' in different position...
 
 const defaultSortOrderFinns = defaultSortOrderStringFinns.split('');
 const defaultSortOrderOthers = defaultSortOrderStringOthers.split('');
@@ -70,7 +70,7 @@ export default function (defaultTagPattern) {
 const sortOrderForX00 = ['i', 'a', 'b', 'q', 'c', 'd', 'e', 't', 'u', 'l', 'f', 'x', 'y', 'z', '0', '1', '5', '9']; // skip $g. Can't remember why, though...
 const sortOrderForX10 = ['i', 'a', 'b', 't', 'n', 'c', 'e', 'v', 'w', 'x', 'y', 'z', '0', '1', '5', '9']; // somewhat iffy
 const sortOrderForX11 = ['a', 'n', 'd', 'c', 'e', 'g', 'j', '0', '1', '5', '9'];
-const sortOrderFor7XX = ['8', '7', 'i', 'a', 's', 't', 'b', 'c', 'd', 'm', 'h', 'k', 'o', 'x', 'z', 'g', 'q', 'w'];
+const sortOrderFor7XXLinkingEntries = ['8', '7', 'i', 'a', 's', 't', 'b', 'c', 'd', 'm', 'h', 'k', 'o', 'x', 'z', 'g', 'q', 'w', '0', '1', 'l', '9', '5'];
 const sortOrderFor246 = ['i', 'a', 'b', 'n', 'p', 'f', '5', '9']; // Used by field 946 as well
 
 // List *only* exceptional order here. Otherwise default order is used.
@@ -79,7 +79,11 @@ const subfieldSortOrder = [
   {'tag': '028', 'sortOrder': ['b', 'a', 'q']}, // National convention
   //{'tag': '031', 'sortOrder': ['a', 'b', 'c', 'm', 'e', 'd']}, // utter guesswork
   {'tag': '040', 'sortOrder': ['8', 'a', 'b', 'e', 'c', 'd', 'x']},
-  {'tag': '041', 'sortOrder': ['8', 'a', 'd', 'j', 'p', 'h', 'e', 'g', 'm']}, // guesswork
+  // rda mus: 041: k < h < e < n < g < m < j (I think h<e is bad)
+  // rda: g < h, j < p < h, i < j, k < h
+  // loc: b < j, $m follows $b or $g
+  // NV: $a 
+  {'tag': '041', 'sortOrder': ['8', 'a', 'd', 'e', 'b', 'f',  'i', 'j', 'p', 'k', 'h', 'n', 'g', 'm']}, // guesswork
   {'tag': '048', 'sortOrder': ['8', 'b', 'a']},
   {'tag': '100', 'sortOrder': sortOrderForX00},
   {'tag': '110', 'sortOrder': sortOrderForX10},
@@ -103,22 +107,22 @@ const subfieldSortOrder = [
   {'tag': '700', 'sortOrder': sortOrderForX00},
   {'tag': '710', 'sortOrder': sortOrderForX10},
   {'tag': '711', 'sortOrder': sortOrderForX11},
-  {'tag': '760', 'sortOrder': sortOrderFor7XX},
-  {'tag': '762', 'sortOrder': sortOrderFor7XX},
-  {'tag': '765', 'sortOrder': sortOrderFor7XX},
-  {'tag': '767', 'sortOrder': sortOrderFor7XX},
-  {'tag': '770', 'sortOrder': sortOrderFor7XX},
-  {'tag': '772', 'sortOrder': sortOrderFor7XX},
-  {'tag': '773', 'sortOrder': sortOrderFor7XX},
-  {'tag': '774', 'sortOrder': sortOrderFor7XX},
-  {'tag': '775', 'sortOrder': sortOrderFor7XX},
-  {'tag': '776', 'sortOrder': sortOrderFor7XX},
-  {'tag': '777', 'sortOrder': sortOrderFor7XX},
-  {'tag': '780', 'sortOrder': sortOrderFor7XX},
-  {'tag': '785', 'sortOrder': sortOrderFor7XX},
-  {'tag': '786', 'sortOrder': sortOrderFor7XX},
-  {'tag': '787', 'sortOrder': sortOrderFor7XX},
-  {'tag': '788', 'sortOrder': sortOrderFor7XX},
+  {'tag': '760', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '762', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '765', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '767', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '770', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '772', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '773', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '774', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '775', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '776', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '777', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '780', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '785', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '786', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '787', 'sortOrder': sortOrderFor7XXLinkingEntries},
+  {'tag': '788', 'sortOrder': sortOrderFor7XXLinkingEntries},
   {'tag': '800', 'sortOrder': sortOrderForX00},
   {'tag': '810', 'sortOrder': sortOrderForX10},
   {'tag': '811', 'sortOrder': sortOrderForX11},
@@ -136,7 +140,9 @@ function getSubfieldSortOrder(field) {
     debugDev(`sort order for ${field.tag}: ${entry[0].sortOrder}`);
     return entry[0].sortOrder;
   }
-  nvdebug(`WARNING!\tNo subfield order found for ${field.tag}.`);
+  if (!['300'].includes(field.tag)) { // Lis tags which use normal $a...$z order here!
+    nvdebug(`WARNING!\tNo subfield order found for ${field.tag}.`, debugDev);
+  }
   return [];
 }
 
@@ -224,15 +230,15 @@ export function sortAdjacentSubfields(field, externalSortOrder = []) {
   swapSubfields(field, controlSubfieldOrder);
 
   const sortOrderForField = externalSortOrder.length > 0 ? externalSortOrder : getSubfieldSortOrder(field);
-  //nvdebug(`INTERMEDIATE SUBFIELD ORDER FOR ${field.tag}: ${sortOrderForField.join(', ')}`);
+  //nvdebug(`INTERMEDIATE SUBFIELD ORDER FOR ${field.tag}: ${sortOrderForField.join(', ')}`, debugDev);
 
   const defaultSortOrder = finnishWay ? defaultSortOrderFinns : defaultSortOrderOthers; // $2 vs $0
   const subfieldOrder = sortOrderForField.length > 0 ? sortOrderForField : defaultSortOrder;
-  //nvdebug(`FINAL SUBFIELD ORDER (FINNISH=${finnishWay}) FOR ${field.tag}: ${subfieldOrder.join(', ')}`);
+  //nvdebug(`FINAL SUBFIELD ORDER (FINNISH=${finnishWay}) FOR ${field.tag}: ${subfieldOrder.join(', ')}`, debugDev);
   //if (sortOrder === null) { return field; } //// Currently always sort..
-  //nvdebug(`IN:  ${fieldToString(field)}`);
+  //nvdebug(`IN:  ${fieldToString(field)}`, debugDev);
   swapSubfields(field, subfieldOrder);
-  //nvdebug(`OUT: ${fieldToString(field)}`);
+  //nvdebug(`OUT: ${fieldToString(field)}`, debugDev);
 
   return field;
 }

package/src/sortSubfields.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './sortSubfields.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -20,7 +20,7 @@ generateTests({
   }
 });
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortSubfields:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortSubfields:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -30,12 +30,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false, tagPattern = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false, tagPattern = false}) {
   const validator = await validatorFactory(tagPattern);
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/stripPunctuation.js

@@ -6,26 +6,31 @@
 */
 
 import {fieldGetFixedString, fieldNeedsModification, fieldStripPunctuation} from './punctuation2.js';
-// import createDebugLogger from 'debug';
+import createDebugLogger from 'debug';
+
 import {fieldToString, nvdebug} from './utils.js';
 
-// const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/punctuation2');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/punctuation2');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+const description =  'Strip punctuation in data fields';
 
 export default function () {
   return {
-    description: 'Strip punctuation to data fields',
+    description: description,
     validate, fix
   };
 
   function fix(record) {
-    nvdebug('Strip punctuation to data fields: fixer');
+    nvdebug(`${description}: fixer`, debugDev);
     const res = {message: [], fix: [], valid: true};
     record.fields.forEach(f => fieldStripPunctuation(f));
     return res;
   }
 
   function validate(record) {
-    nvdebug('Strip punctuation to data fields: validate');
+    nvdebug(`${description}: validate`, debugDev);
 
     const fieldsNeedingModification = record.fields.filter(f => fieldNeedsModification(f, false));
 

package/src/stripPunctuation.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './stripPunctuation.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -20,7 +20,7 @@ generateTests({
   }
 });
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/stripPunctuation:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/stripPunctuation:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -30,12 +30,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/subfield6Utils.js

@@ -1,8 +1,6 @@
 import createDebugLogger from 'debug';
-// const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield6Utils');
-
 import {add8s, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, isValidSubfield8} from './subfield8Utils.js';
-import {fieldHasSubfield, fieldToString, fieldsToString, nvdebug, subfieldToString} from './utils.js';
+import {fieldHasSubfield, fieldToString, /* fieldsToString, */ nvdebug, subfieldToString} from './utils.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:subfield6Utils');
 //const debugData = debug.extend('data');
@@ -41,7 +39,7 @@ export function subfield6GetOccurrenceNumberAsInteger(subfield) {
     return 0;
   }
   const result = parseInt(index, 10);
-  //nvdebug(`SF6: ${subfield.value} => ${index} => ${result}`, debug);
+  //nvdebug(`SF6: ${subfield.value} => ${index} => ${result}`, debugDev, debugDev);
   return result;
 }
 
@@ -52,7 +50,7 @@ export function subfield6ResetOccurrenceNumber(subfield, occurrenceNumber) {
   const occurrenceNumberAsString = typeof occurrenceNumber === 'number' ? intToOccurrenceNumberString(occurrenceNumber) : occurrenceNumber;
 
   const newValue = subfield.value.substring(0, 4) + occurrenceNumberAsString + subfield6GetTail(subfield);
-  //nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`);
+  //nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`, debugDev);
   subfield.value = newValue;
 }
 
@@ -71,7 +69,7 @@ export function subfield6HasWantedTagAndOccurrenceNumber(subfield, tagAndOccurre
   }
   // We could also use generic code and go getTag()+'-'+getIndex() instead of regexp...
   const key = subfield.value.replace(/^([0-9][0-9][0-9]-[0-9][0-9]+).*$/u, '$1');
-  nvdebug(` Compare '${key}' vs '${tagAndOccurrenceNumber}'`);
+  //nvdebug(` Compare '${key}' vs '${tagAndOccurrenceNumber}'`, debugDev);
   return key === tagAndOccurrenceNumber;
 }
 
@@ -94,7 +92,7 @@ export function fieldGetUnambiguousOccurrenceNumber(field) {
 }
 
 export function fieldHasOccurrenceNumber(field, occurrenceNumber) {
-  //nvdebug(`${occurrenceNumber} vs ${fieldToString(field)}`);
+  //nvdebug(`${occurrenceNumber} vs ${fieldToString(field)}`, debugDev);
   return field.subfields && field.subfields.some(sf => subfield6GetOccurrenceNumber(sf) === occurrenceNumber);
 }
 
@@ -119,13 +117,13 @@ export function intToOccurrenceNumberString(i) {
 
 export function fieldGetMaxSubfield6OccurrenceNumberAsInteger(field) {
   // used by reducer!
-  //nvdebug(`Checking subfields $6 from ${JSON.stringify(field)}`);
+  //nvdebug(`Checking subfields $6 from ${JSON.stringify(field)}`, debugDev);
   const sf6s = field.subfields ? field.subfields.filter(subfield => isValidSubfield6(subfield)) : [];
   if (sf6s.length === 0) {
     return 0;
   }
   // There should always be one, but here we check every subfield.
-  //nvdebug(`Got ${field.subfields} $6-subfield(s) from ${JSON.stringify(field)}`, debug);
+  //nvdebug(`Got ${field.subfields} $6-subfield(s) from ${JSON.stringify(field)}`, debugDev);
   const vals = sf6s.map(sf => subfield6GetOccurrenceNumberAsInteger(sf));
   return Math.max(...vals);
 }
@@ -155,20 +153,20 @@ export function fieldHasValidSubfield6(field) {
 
 export function isSubfield6Pair(field, otherField) {
   // No need to log this:
-  //nvdebug(`LOOK for $6-pair:\n ${fieldToString(field)}\n ${fieldToString(otherField)}`);
+  //nvdebug(`LOOK for $6-pair:\n ${fieldToString(field)}\n ${fieldToString(otherField)}`, debugDev);
   if (!fieldHasValidSubfield6(field) || !fieldHasValidSubfield6(otherField)) {
     return false;
   }
 
   if (!tagsArePairable6(field.tag, otherField.tag)) {
-    //nvdebug(` FAILED. REASON: TAGS NOT PAIRABLE!`);
+    //nvdebug(` FAILED. REASON: TAGS NOT PAIRABLE!`, debugDev);
     return false;
   }
 
 
   const fieldIndex = fieldGetUnambiguousOccurrenceNumber(field);
   if (fieldIndex === undefined || fieldIndex === '00') {
-    //nvdebug(` FAILED. REASON: NO INDEX FOUND`);
+    //nvdebug(` FAILED. REASON: NO INDEX FOUND`, debugDev);
     return false;
   }
 
@@ -176,12 +174,12 @@ export function isSubfield6Pair(field, otherField) {
 
 
   if (fieldIndex !== otherFieldIndex) {
-    //nvdebug(` FAILURE: INDEXES: ${fieldIndex} vs ${otherFieldIndex}`);
+    //nvdebug(` FAILURE: INDEXES: ${fieldIndex} vs ${otherFieldIndex}`, debugDev);
     return false;
   }
 
   if (fieldGetUnambiguousTag(field) !== otherField.tag || field.tag !== fieldGetUnambiguousTag(otherField)) {
-    //nvdebug(` FAILURE: TAG vs $6 TAG`);
+    //nvdebug(` FAILURE: TAG vs $6 TAG`, debugDev);
     return false;
   }
   return true;
@@ -219,11 +217,11 @@ export function fieldGetOccurrenceNumberPairs(field, candFields) {
   //nvdebug(`  Trying to finds pair for ${fieldToString(field)} in ${candFields.length} fields`);
   const pairs = candFields.filter(otherField => isSubfield6Pair(field, otherField));
   if (pairs.length === 0) {
-    nvdebug(`NO PAIRS FOUND FOR '${fieldToString(field)}'`);
+    //nvdebug(`NO PAIRS FOUND FOR '${fieldToString(field)}'`, debugDev);
     return pairs;
   }
-  nvdebug(`${pairs.length} PAIR(S) FOUND FOR '${fieldToString(field)}'`);
-  pairs.forEach(pairedField => nvdebug(`  '${fieldToString(pairedField)}'`));
+  //nvdebug(`${pairs.length} PAIR(S) FOUND FOR '${fieldToString(field)}'`, debugDev);
+  pairs.forEach(pairedField => nvdebug(`  '${fieldToString(pairedField)}'`, debugDev));
   return pairs;
 }
 
@@ -268,7 +266,7 @@ export function fieldGetSubfield6Pair(field, record) {
     return undefined;
   }
   // NB! It is theoretically possible to have multiple pairable 880 fields (one for each encoding)
-  nvdebug(`fieldGetSubfield6Pair(): ${fieldToString(field)} => ${fieldToString(pairedFields[0])}`);
+  nvdebug(`fieldGetSubfield6Pair(): ${fieldToString(field)} => ${fieldToString(pairedFields[0])}`, debugDev);
   return pairedFields[0];
 }
 */
@@ -357,7 +355,7 @@ function guessTargetLinkingNumber(fields, defaultTargetLinkingNumber) {
 export function fieldsToNormalizedString(fields, defaultTargetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTag = false) {
   const targetLinkingNumber = guessTargetLinkingNumber(fields, defaultTargetLinkingNumber);
 
-  nvdebug(`fieldsToNormalizedString: OCC: ${normalizeOccurrenceNumber}`);
+  //nvdebug(`fieldsToNormalizedString: OCC: ${normalizeOccurrenceNumber}`, debugDev);
   const strings = fields.map(field => fieldToNormalizedString(field, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTag));
   strings.sort();
   return strings.join('\t__SEPARATOR__\t');
@@ -369,32 +367,32 @@ export function fieldsToNormalizedString(fields, defaultTargetLinkingNumber = 0,
 export function removeField6IfNeeded(field, record, fieldsAsString) {
   const pairField = fieldGetSubfield6Pair(field, record);
   const asString = pairField ? fieldsToNormalizedString([field, pairField]) : fieldToNormalizedString(field);
-  nvdebug(`SOURCE: ${asString} -- REALITY: ${fieldToString(field)}`);
+  nvdebug(`SOURCE: ${asString} -- REALITY: ${fieldToString(field)}`, debugDev);
   const tmp = pairField ? fieldToString(pairField) : 'HUTI';
-  nvdebug(`PAIR: ${tmp}`);
-  nvdebug(`BASE:\n ${fieldsAsString.join('\n ')}`);
+  nvdebug(`PAIR: ${tmp}`, debugDev);
+  nvdebug(`BASE:\n ${fieldsAsString.join('\n ')}`, debugDev);
   if (!fieldsAsString.includes(asString)) {
     return;
   }
-  nvdebug(`Duplicate $6 removal: ${fieldToString(field)}`);
+  nvdebug(`Duplicate $6 removal: ${fieldToString(field)}`, debugDev);
   record.removeField(field);
 
   if (pairField === undefined) {
     return;
   }
-  nvdebug(`Duplicate $6 removal (pair): ${fieldToString(pairField)}`);
+  nvdebug(`Duplicate $6 removal (pair): ${fieldToString(pairField)}`, debugDev);
   record.removeField(pairField);
 }
 */
 
 function getFirstField(record, fields) {
   const fieldsAsStrings = fields.map(field => fieldToString(field));
-  //record.fields.forEach((field, i) => nvdebug(`${i}:\t${fieldToString(field)}`));
-  //nvdebug(`getFirstField: ${fieldsAsStrings.join('\t')}`);
+  //record.fields.forEach((field, i) => nvdebug(`${i}:\t${fieldToString(field)}`, debugDev));
+  //nvdebug(`getFirstField: ${fieldsAsStrings.join('\t')}`, debugDev);
   const i = record.fields.findIndex(field => fieldsAsStrings.includes(fieldToString(field)));
   if (i > -1) {
     const field = record.fields[i];
-    //nvdebug(`1st F: ${i + 1}/${record.fields.length} ${fieldToString(field)}`);
+    //nvdebug(`1st F: ${i + 1}/${record.fields.length} ${fieldToString(field)}`, debugDev);
     return field;
   }
   return undefined;
@@ -445,7 +443,7 @@ export function isFirstLinkedSubfield6Field(field, record) {
   }
   const chain = getAllLinkedSubfield6Fields(field, record);
   if (!isRelevantSubfield6Chain(chain)) {
-    nvdebug(`Rejected 6: ${fieldsToString(chain)}`);
+    //nvdebug(`Rejected 6: ${fieldsToString(chain)}`, debugDev);
     return false;
   }
 
@@ -472,13 +470,13 @@ export function get6s(field, candidateFields) { // NB! Convert field to fields!!
   if (sixes.length === 0) {
     return [field];
   }
-  nvdebug(`SIXES: ${sixes.length}`);
+  //nvdebug(`SIXES: ${sixes.length}`, debugDev);
   const occurrenceNumbers = sixes.map(sf => subfield6GetOccurrenceNumber(sf)).filter(value => value !== undefined && value !== '00');
-  nvdebug(occurrenceNumbers.join(' -- '));
+  //nvdebug(occurrenceNumbers.join(' -- '), debugDev);
 
   const relevantFields = candidateFields.filter(f => occurrenceNumbers.some(o => fieldHasOccurrenceNumber(f, o)));
-  nvdebug(`${fieldToString(field)}: $6-RELFIELDS FOUND: ${relevantFields.length}...`);
-  relevantFields.forEach(f => nvdebug(fieldToString(f)));
+  //nvdebug(`${fieldToString(field)}: $6-RELFIELDS FOUND: ${relevantFields.length}...`, debugDev);
+  //relevantFields.forEach(f => nvdebug(fieldToString(f), debugDev));
   return relevantFields;
 }
 
@@ -488,6 +486,6 @@ export function resetSubfield6Tag(subfield, tag) {
   }
   // NB! mainly for 1XX<->7XX transfers
   const newValue = `${tag}-${subfield.value.substring(4)}`;
-  nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`, debugDev);
+  //nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`, debugDevDev);
   subfield.value = newValue;
 }