@natlibfi/marc-record-validators-melinda 12.0.7 → 12.0.8

package/src/merge-fields/counterpartField.js

@@ -217,7 +217,7 @@ function getUnbalancedPairedSubfieldCode(field1, field2) {
   // (I'm not saying that 100$b/c/d/q  are in 'paired' contraint, I'm just illustrating the issue here)
   const pairable = pairableIdentifier(field1, field2, '(FIN11)');
   const subfieldString = pairable ? removeNameRelatedSubfieldCodes(fullSubfieldString, field1.tag) : fullSubfieldString;
-  debug(`CHECK ${pairable ? 'PAIRABLE ' : ''}${field1.tag} PAIRS: '${fullSubfieldString}' => '${subfieldString}'`);
+  nvdebug(`CHECK ${pairable ? 'PAIRABLE ' : ''}${field1.tag} PAIRS: '${fullSubfieldString}' => '${subfieldString}'`, debugDev);
 
   if (subfieldString === '') {
     return false;
@@ -229,7 +229,7 @@ function getUnbalancedPairedSubfieldCode(field1, field2) {
 
 function syntacticallyMergablePair(baseField, sourceField, config) {
   // Indicators must typically be equal (there are exceptions such as non-filing characters though):
-  nvdebug("CHECK SYNTAX");
+  nvdebug("CHECK SYNTAX", debugDev);
   if (!mergableIndicator1(baseField, sourceField, config)) {
     nvdebug(`non-mergable (reason: indicator1): ${JSON.stringify(config)}`, debugDev);
     return false;
@@ -310,7 +310,7 @@ function removeNameRelatedSubfieldCodes(codestring, tag) {
 
 function pairableIdentifier(field1, field2, prefix) {
   const normalizedPrefix = prefix;
-  nvdebug(`PREF '${prefix}' => '${normalizedPrefix}'`);
+  nvdebug(`PREF '${prefix}' => '${normalizedPrefix}'`, debugDev);
 
   const prefixLength = normalizedPrefix.length;
   const identifiers1 = getIdentifiers(field1);
@@ -378,8 +378,8 @@ function pairableValueInArray(tag, subfieldCode, val, arr) {
 
 
 function tightSubfieldMatch(field1, field2, subfieldCode, mustHave = false) {
-  nvdebug(`${subfieldCode} F1: ${fieldToString(field1)}`);
-  nvdebug(`${subfieldCode} F2: ${fieldToString(field2)}`);
+  nvdebug(`${subfieldCode} F1: ${fieldToString(field1)}`, debugDev);
+  nvdebug(`${subfieldCode} F2: ${fieldToString(field2)}`, debugDev);
   const values1 = getRelevantSubfieldValues(field1, subfieldCode);
   const values2 = getRelevantSubfieldValues(field2, subfieldCode);
 
@@ -393,7 +393,7 @@ function tightSubfieldMatch(field1, field2, subfieldCode, mustHave = false) {
     return false;
   }
 
-  nvdebug(`Compare $${subfieldCode} contents:\n  '${values1.join("'\n  '")}' vs\n  '${values2.join("'\n  '")}'`);
+  nvdebug(`Compare $${subfieldCode} contents:\n  '${values1.join("'\n  '")}' vs\n  '${values2.join("'\n  '")}'`, debugDev);
   return values1.every(v => pairableValueInArray(field1.tag, subfieldCode, v, values2)) && values2.every(v => pairableValueInArray(field1.tag, subfieldCode, v, values1));
 }
 
@@ -443,25 +443,25 @@ function semanticallyMergablePair(baseField, sourceField) {
   const allRequired = mergeConstraints[0].required || ''; // getMergeConstraintsForTag(field1.tag, 'required') || '';
   const reallyRequired = asteriMatch ? removeNameRelatedSubfieldCodes(allRequired, field1.tag) : allRequired;
 
-  //nvdebug(`WP1: '${allRequired}' => ${reallyRequired}`);
+  //nvdebug(`WP1: '${allRequired}' => ${reallyRequired}`, debugDev);
   if (!reallyRequired.split('').every(c => tightSubfieldMatch(field1, field2, c, true))) {
     return false;
   }
 
   const allPaired = mergeConstraints[0].paired || ''; // getMergeConstraintsForTag(field1.tag, 'paired') || '';
   const reallyPaired = asteriMatch ? removeNameRelatedSubfieldCodes(allPaired, field1.tag) : allPaired;
-  //nvdebug(`WP2: '${allPaired}' => ${reallyPaired}`);
+  //nvdebug(`WP2: '${allPaired}' => ${reallyPaired}`, debugDev);
   if (!reallyPaired.split('').every(c => tightSubfieldMatch(field1, field2, c, false))) {
     return false;
   }
 
   const allKeys = mergeConstraints[0].key || ''; // getMergeConstraintsForTag(field1.tag, 'key') || '';
   const relevantKeys = asteriMatch ? removeNameRelatedSubfieldCodes(allKeys, field1.tag) : allKeys
-  //nvdebug(`WP3: keys='${allKeys}' => ${relevantKeys}`);
+  //nvdebug(`WP3: keys='${allKeys}' => ${relevantKeys}`, debugDev);
   if (!relevantKeys.split('').every(c => looseSubfieldMatch(field1, field2, c))) {
     return false;
   }
-  //nvdebug('WP4');
+  //nvdebug('WP4', debugDev);
 
   // required/paired/keys checks did not fail. Now check that did they really succeed
   if (allRequired.length > 0) { // I think we should use all here

package/src/merge-fields/mergableIndicator.js

@@ -1,11 +1,11 @@
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 import {marc21GetTagsLegalInd1Value, marc21GetTagsLegalInd2Value} from '../utils.js';
 
 // Specs: https://workgroups.helsinki.fi/x/K1ohCw (though we occasionally differ from them)...
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:merge-fields:mergableIndicator');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:merge-fields:mergableIndicator');
 //const debugData = debug.extend('data');
-const debugDev = debug.extend('dev');
+//const debugDev = debug.extend('dev');
 
 const ind1NonFilingChars = ['130', '630', '730', '740'];
 const ind2NonFilingChars = ['222', '240', '242', '243', '245', '830'];

package/src/merge-fields/worldKnowledge.js

@@ -1,7 +1,12 @@
 //import {nvdebug} from '../utils.js';
+//import createDebugLogger from 'debug';
 
 // NB! This file (or at least synonyms) should eventually be moved away from merge to '..'.
 
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:worldKnowledge');
+//const debugData = debug.extend('data');
+//const debugDev = debug.extend('dev');
+
 
 export function valueCarriesMeaning(tag, subfieldCode, value) {
   // Some data is pretty meaningless and as meaningless is pretty close to nothing, this meaningless data should no prevent merge.
@@ -36,20 +41,20 @@ export function getSynonyms(term, tag = undefined, subfieldCode = undefined, pre
   if (!term) {
     return [];
   }
-  //nvdebug(`WP1 CANDS: ${synonyms.length} FOR '${term}'`);
+  //nvdebug(`WP1 CANDS: ${synonyms.length} FOR '${term}'`, debugDev);
   const relevantLanguges = relevantLanguagesString.split(/\s+/u);
   const normalizedTerm = ignoreCase ? term.toLowerCase() : term;
   const synonymsWithTag = tag ? synonyms.filter(s => s.tags.includes(tag)) : synonyms;
   if (synonymsWithTag.length === 0) {
     return [];
   }
-  //nvdebug(`WP2 (FILTER ${tag}) CANDS: ${synonymsWithTag.length}`);
+  //nvdebug(`WP2 (FILTER ${tag}) CANDS: ${synonymsWithTag.length}`, debugDev);
   const synonymsWithTagAndCode = subfieldCode ? synonymsWithTag.filter(s => s.code === subfieldCode) : synonymsWithTag;
-  //nvdebug(`WP3 (FILTER $${subfieldCode}) CANDS: ${synonymsWithTagAndCode.length}:\n${JSON.stringify(synonymsWithTagAndCode)}`);
+  //nvdebug(`WP3 (FILTER $${subfieldCode}) CANDS: ${synonymsWithTagAndCode.length}:\n${JSON.stringify(synonymsWithTagAndCode)}`, debugDev);
   const matchingSynonyms = synonymsWithTagAndCode.filter(s => termAndLangMatch(s));
 
   if (preferredLanguage && matchingSynonyms.length > 0) {
-    //console.log(`USING PREFERRED LANG '${preferredLanguage}' for TERM '${term}':\n${JSON.stringify(matchingSynonyms)}`);
+    //console.log(`USING PREFERRED LANG '${preferredLanguage}' for TERM '${term}':\n${JSON.stringify(matchingSynonyms)}`, debugDev);
     return matchingSynonyms.map(s => s[preferredLanguage]);
   }
   return matchingSynonyms;
@@ -79,7 +84,7 @@ export function getSynonyms(term, tag = undefined, subfieldCode = undefined, pre
 export function getSynonym(tag, subfieldCode, originalValue) {
   const finnishForm = getSynonyms(originalValue, tag, subfieldCode, 'fin');
   if (finnishForm.length === 1) {
-    //nvdebug(`FINNISH FORM FOR ${tag}$${subfieldCode}: '${finnishForm[0]}'`);
+    //nvdebug(`FINNISH FORM FOR ${tag}$${subfieldCode}: '${finnishForm[0]}'`, debugDev);
     return finnishForm[0];
   }
   return originalValue;
@@ -90,7 +95,7 @@ export function normalizeForSamenessCheck(tag, subfieldCode, originalValue) {
   // Repeatable subfields are currently handled in mergeSubfields.js. Only non-repeatable subfields block field merge,
   // (This split is suboptiomal... Minimum fix: make this distinction cleaner...)
 
-  //nvdebug(`TRYING TO DO ${tag}$${subfieldCode} '${originalValue}'`);
+  //nvdebug(`TRYING TO DO ${tag}$${subfieldCode} '${originalValue}'`, debugDev);
   originalValue = getSynonym(tag, subfieldCode, originalValue);
 
   if (subfieldCode === 'a' && ['100', '600', '700', '800'].includes(tag)) { // "Etunimi Sukunimi"...

package/src/mergeRelatorTermFields.js

@@ -11,11 +11,12 @@ import {fieldFixPunctuation, fieldStripPunctuation} from './punctuation2.js';
 import {fieldToString, nvdebug} from './utils.js';
 import {sortAdjacentSubfields} from './sortSubfields.js';
 import {sortAdjacentRelatorTerms, tagToRelatorTermSubfieldCode} from './sortRelatorTerms.js';
-//import createDebugLogger from 'debug';
-/*
-//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:mergeRelatorTermFields');
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:mergeRelatorTermFields');
 //const debugData = debug.extend('data');
-*/
+const debugDev = debug.extend('dev');
+
 
 export default function () {
 
@@ -80,31 +81,31 @@ function copyRelatorSubfields(fromField, toField) {
 
 function mergeRelatorTermFields(record, fix = false) {
   // NV: 111/711, 751 and 752 where so rare that I did not add them here. Can't remember why I skipped 6XX and 8XX...
-  let fields = record.get('(?:[17][01]0|720)'); 
+  let fields = record.get('(?:[17][01]0|720)');
   let result = [];
   const comparisonFieldsAsString = fields.map(f => fieldToString(createNormalizedCloneWithoutRelatorTerms(f)));
 
-  nvdebug(`mergeRelatorTermFields(): ${fields.length} cand field(s) found`);
+  nvdebug(`mergeRelatorTermFields(): ${fields.length} cand field(s) found`, debugDev);
   for(let i=0; i < fields.length-1; i++) {
     let currField = fields[i];
     if (currField.deleted) {
       continue;
     }
-    nvdebug(`RT: Trying to pair ${comparisonFieldsAsString[i]}/${i}`);
+    nvdebug(`RT: Trying to pair ${comparisonFieldsAsString[i]}/${i}`, debugDev);
     for (let j=i+1; j < fields.length; j++) {
-      nvdebug(` Compare with ${comparisonFieldsAsString[j]}/${j}`);
+      nvdebug(` Compare with ${comparisonFieldsAsString[j]}/${j}`, debugDev);
       let mergableField = fields[j];
       // Skip 1/7 from 1XX/7XX for similarity check:
       if ( comparisonFieldsAsString[i].substring(1) !== comparisonFieldsAsString[j].substring(1)) {
-        nvdebug("  NOT PAIR");
+        nvdebug("  NOT PAIR", debugDev);
         continue;
       }
       if (mergableField.deleted) {
-        nvdebug("  DELETED");
+        nvdebug("  DELETED", debugDev);
         continue;
       }
       const str = `MERGE RELATOR TERM FIELD: ${fieldToString(mergableField)}`;
-      nvdebug(str);
+      nvdebug(str, debugDev);
 
       if(!result.includes(str)) {
         result.push(str)

package/src/normalize-dashes.js

@@ -1,7 +1,13 @@
-//import createDebugLogger from 'debug';
 import clone from 'clone';
 import {fieldToString, isContentSubfieldCode, nvdebug} from './utils.js';
 
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normaliza-dashes');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+
 // Author(s): Nicholas Volk
 export default function () {
 
@@ -11,7 +17,7 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug(`FIX ME`);
+    nvdebug(`FIX ME`, debugDev);
     record.fields.forEach(field => {
       fixDashes(field);
     });
@@ -23,7 +29,7 @@ export default function () {
   function validate(record) {
     const res = {message: []};
 
-    nvdebug(`VALIDATE ME`);
+    nvdebug(`VALIDATE ME`, debugDev);
     record.fields?.forEach(field => {
       validateField(field, res);
     });
@@ -34,7 +40,7 @@ export default function () {
 
   function validateField(field, res) {
     const orig = fieldToString(field);
-    nvdebug(` VALIDATE FIELD '${orig}'`);
+    nvdebug(` VALIDATE FIELD '${orig}'`, debugDev);
 
     const normalizedField = fixDashes(clone(field));
     const mod = fieldToString(normalizedField);
@@ -52,7 +58,7 @@ function fixDashes(field) {
     return field;
   }
 
-  nvdebug(`Dashing ${fieldToString(field)}`);
+  nvdebug(`Dashing ${fieldToString(field)}`, debugDev);
 
   field.subfields.forEach(sf => subfieldFixDashes(sf));
 

package/src/normalize-identifiers.js

@@ -1,17 +1,10 @@
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
-//import createDebugLogger from 'debug';
 import clone from 'clone';
-import {fieldToString} from './utils.js';
-//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normalize-identifiers');
+import {fieldToString, /*nvdebug*/} from './utils.js';
 
-/*
-function nvdebug(message, func) {
-  if (func) {
-    func(message);
-  }
-  console.info(message); // eslint-disable-line no-console
-}
-*/
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normalize-identifiers');
+//const debugData = debug.extend('data');
+//const debugDev = debug.extend('dev');
 
 export default function () {
 
@@ -32,9 +25,9 @@ export default function () {
       }
       */
 
-    //nvdebug(`NORMALIZE CONTROL NUMBER FIX`, debug);
+    //nvdebug(`NORMALIZE CONTROL NUMBER FIX`, debugDev);
     record.fields.forEach(field => {
-      //nvdebug(` NORMALIZE CONTROL NUMBER FIX ${fieldToString(field)}`, debug);
+      //nvdebug(` NORMALIZE CONTROL NUMBER FIX ${fieldToString(field)}`, debugDev);
 
       fieldNormalizeControlNumbers(field);
       //validateField(field, true, message);
@@ -46,7 +39,7 @@ export default function () {
 
   function validate(record) {
     const res = {message: []};
-    //nvdebug(`NORMALIZE CONTROL NUMBER VALIDATE`, debug);
+    //nvdebug(`NORMALIZE CONTROL NUMBER VALIDATE`, debugDev);
     // Actual parsing of all fields
     /*
       if (!record.fields) {
@@ -55,7 +48,7 @@ export default function () {
       */
 
     record.fields.forEach(field => {
-      //nvdebug(` NORMALIZE CONTROL NUMBER VALIDATE ${fieldToString(field)}`, debug);
+      //nvdebug(` NORMALIZE CONTROL NUMBER VALIDATE ${fieldToString(field)}`, debugDev);
       validateField(field, res);
     });
 
@@ -126,8 +119,8 @@ function normalizeNineDigitIDs(value, targetFormat = 'ALEPH_INTERNAL') {
   const currPrefix = value.slice(0, -9);
 
   if (currPrefix in mappings) {
-    //nvdebug(`${currPrefix}, TF:${targetFormat}...`);
-    //nvdebug(`${JSON.stringify(mappings[currPrefix])}`);
+    //nvdebug(`${currPrefix}, TF:${targetFormat}...`, debugDev);
+    //nvdebug(`${JSON.stringify(mappings[currPrefix])}`, debugDev);
     return `${mappings[currPrefix][targetFormat]}${nineDigitTail}`;
   }
   return value;
@@ -167,7 +160,7 @@ export function normalizeControlSubfieldValue(value = '', targetFormat = 'ALEPH_
 
 //export function normalizableSubfieldPrefix(tag, sf) {
 export function normalizeAs(tag, subfieldCode) {
-  //nvdebug(`nAs ${tag}, ${subfieldCode}`);
+  //nvdebug(`nAs ${tag}, ${subfieldCode}`, debugDev);
   if (subfieldCode === '0' || subfieldCode === '1' || subfieldCode === 'w') {
     return 'ALEPH_INTERNAL';
   }
@@ -189,7 +182,7 @@ export function fieldNormalizeControlNumbers(field) {
   field.subfields.forEach(sf => {
     const targetFormat = normalizeAs(field.tag, sf.code);
     if (targetFormat !== undefined) {
-      //nvdebug(`NORMALIZE SUBFIELD $${sf.code} IN FIELD: '${fieldToString(field)}' TO ${targetFormat}`);
+      //nvdebug(`NORMALIZE SUBFIELD $${sf.code} IN FIELD: '${fieldToString(field)}' TO ${targetFormat}`, debugDev);
       sf.value = normalizeControlSubfieldValue(sf.value, targetFormat);
       return;
     }

package/src/normalize-utf8-diacritics.js

@@ -1,12 +1,15 @@
 //import createDebugLogger from 'debug';
 import clone from 'clone';
 import {convert as nongenericNormalization} from './unicode-decomposition.js';
-import {fieldToString} from './utils.js';
+import {fieldToString /*, nvdebug */} from './utils.js';
 
 // Note that https://github.com/NatLibFi/marc-record-validators-melinda/blob/master/src/unicode-decomposition.js contains
 // similar functionalities. It's less generic and lacks diacritic removal but has it advantages as well.
 
 //const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/normalize-utf-diacritics');
+//const debugData = debug.extend('data');
+//const debugDev = debug.extend('dev');
+
 
 // See also https://github.com/NatLibFi/marc-record-validators-melinda/blob/master/src/unicode-decomposition.js .
 // It uses a list of convertable characters whilst this uses a generic stuff as well.
@@ -111,13 +114,13 @@ export function fieldFixComposition(field) {
     return field;
   }
   //const originalValue = fieldToString(field);
-  //nvdebug(`fFC: '${originalValue}'`, debug);
+  //nvdebug(`fFC: '${originalValue}'`, debugDev);
   field.subfields.forEach((subfield, index) => {
     field.subfields[index].value = fixComposition(subfield.value);
   });
   //const newValue = fieldToString(field);
   //if (originalValue !== newValue) {
-  //  debug(`FIXCOMP: '${originalValue}' => '${newValue}'`);
+  //  nvdebug(`FIXCOMP: '${originalValue}' => '${newValue}'`, debugDev);
   //}
   return field;
 }

package/src/normalizeFieldForComparison.js

@@ -185,7 +185,7 @@ function normalizeISBN(field) {
     return;
   }
 
-  //nvdebug(`ISBN-field? ${fieldToString(field)}`);
+  //nvdebug(`ISBN-field? ${fieldToString(field)}`, debugDev);
   const relevantSubfields = field.subfields.filter(sf => tagAndSubfieldCodeReferToIsbn(field.tag, sf.code) && looksLikeIsbn(sf.value));
   relevantSubfields.forEach(sf => normalizeIsbnSubfield(sf));
 
@@ -193,7 +193,7 @@ function normalizeISBN(field) {
     if (valuelessSubfield(sf)) {
       return;
     }
-    //nvdebug(` ISBN-subfield? ${subfieldToString(sf)}`);
+    //nvdebug(` ISBN-subfield? ${subfieldToString(sf)}`, debugDev);
     sf.value = sf.value.replace(/-/ug, '');
     sf.value = sf.value.replace(/x/u, 'X');
   }

package/src/normalizeSubfieldValueForComparison.js

@@ -105,8 +105,8 @@ export function partsAgree(value1, value2, tag, subfieldCode) {
   }
   const [partType1, partYear1, partNumber1] = splitAndNormalizePartData(value1);
   const [partType2, partYear2, partNumber2] = splitAndNormalizePartData(value2);
-  //nvdebug(`P1: ${partType1} | ${partYear1} | ${partNumber1}`);
-  //nvdebug(`P2: ${partType2} | ${partYear2} | ${partNumber2}`);
+  //nvdebug(`P1: ${partType1} | ${partYear1} | ${partNumber1}`, debugDev);
+  //nvdebug(`P2: ${partType2} | ${partYear2} | ${partNumber2}`, debugDev);
   if (partNumber1 !== partNumber2) {
     return false;
   }

package/src/punctuation2.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 /*
 * punctuation.js -- try and fix a marc field punctuation
 *
@@ -12,11 +13,13 @@
 import {validateSingleField} from './ending-punctuation.js';
 import {tagToDataProvenanceSubfieldCode} from './dataProvenanceUtils.js';
 import {fieldGetUnambiguousTag} from './subfield6Utils.js';
-//import createDebugLogger from 'debug';
+import createDebugLogger from 'debug';
 import {fieldToString, isContentSubfieldCode, nvdebug} from './utils.js';
 import clone from 'clone';
 
-//const debug = createDebugLogger('debug/punctuation2');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:punctuation2');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 const descriptionString = 'Remove invalid and add valid punctuation to data fields';
 export default function () {
@@ -26,14 +29,14 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug(`${descriptionString}: fixer`);
+    nvdebug(`${descriptionString}: fixer`, debugDev);
     const res = {message: [], fix: [], valid: true};
     record.fields.forEach(f => fieldFixPunctuation(f));
     return res;
   }
 
   function validate(record) {
-    nvdebug(`${descriptionString}: validate`);
+    nvdebug(`${descriptionString}: validate`, debugDev);
 
     const fieldsNeedingModification = record.fields.filter(f => fieldNeedsModification(f, true));
 
@@ -396,19 +399,19 @@ const addPairedPunctuationRules = {
 
 /*
 function debugRule(rule) {
-  //nvdebug('');
-  nvdebug(`NAME ${rule.name ? rule.name : '<unnamed>'}`);
-  nvdebug(`SUBFIELD CODE '${rule.code}' FOLLOWED BY SUBFIELD CODE '${rule.followedBy}'`);
+  //nvdebug('', debugDev);
+  nvdebug(`NAME ${rule.name ? rule.name : '<unnamed>'}`, debugDev);
+  nvdebug(`SUBFIELD CODE '${rule.code}' FOLLOWED BY SUBFIELD CODE '${rule.followedBy}'`, debugDev);
   if ('add' in rule) {
-    nvdebug(`ADD '${rule.add}'`);
+    nvdebug(`ADD '${rule.add}'`, debugDev);
   }
   if ('remove' in rule) {
-    nvdebug(`REMOVE '${rule.remove}'`);
+    nvdebug(`REMOVE '${rule.remove}'`, debugDev);
   }
   if ('context' in rule) {
-    nvdebug(`CONTEXT '${rule.context.toString()}'`);
+    nvdebug(`CONTEXT '${rule.context.toString()}'`, debugDev);
   }
-  //nvdebug('');
+  //nvdebug('', debugDev);
 }
 */
 
@@ -440,19 +443,19 @@ function ruleAppliesToField(rule, field) {
 
 
 function ruleAppliesToCurrentSubfield(rule, subfield) {
-  //nvdebug(`  Apply rule on LHS?`);
+  //nvdebug(`  Apply rule on LHS?`, debugDev);
   if (!ruleAppliesToSubfieldCode(rule.code, subfield.code)) {
-    //nvdebug(`  Reject rule!`);
+    //nvdebug(`  Reject rule!`, debugDev);
     return false;
   }
   if ('context' in rule) {
-    //nvdebug(`  Check '${subfield.value}' versus '${rule.context.toString()}'`);
+    //nvdebug(`  Check '${subfield.value}' versus '${rule.context.toString()}'`, debugDev);
     if (!subfield.value.match(rule.context)) { // njsscan-ignore: regex_injection_dos
-      //nvdebug(`  Reject rule!`);
+      //nvdebug(`  Reject rule!`, debugDev);
       return false;
     }
   }
-  //nvdebug(`  Apply rule!`);
+  //nvdebug(`  Apply rule!`, debugDev);
   return true;
 }
 
@@ -480,23 +483,24 @@ function ruleAppliesToNextSubfield(rule, nextSubfield) {
 
 function checkRule(rule, field, subfield1, subfield2) {
   if (!ruleAppliesToField(rule, field)) {
-    //nvdebug(`FAIL ON WHOLE FIELD: '${fieldToString(field)}`);
+    //nvdebug(`FAIL ON WHOLE FIELD: '${fieldToString(field)}`, debugDev);
     return false;
   }
   //const name = rule.name || 'UNNAMED';
   if (!ruleAppliesToCurrentSubfield(rule, subfield1)) {
-    //nvdebug(`${name}: FAIL ON LHS SUBFIELD: '$${subfield1.code} ${subfield1.value}', SF=${rule.code}`, debug);
+    //nvdebug(`${name}: FAIL ON LHS SUBFIELD: '$${subfield1.code} ${subfield1.value}', SF=${rule.code}`, debugDev);
     return false;
   }
 
   // NB! This is not a perfect solution. We might have $e$0$e where $e$0 punctuation should actually be based on $e$e rules
   if (!ruleAppliesToNextSubfield(rule, subfield2)) {
     //const msg = subfield2 ? `${name}: FAIL ON RHS SUBFIELD '${subfield2.code}' not in [${rule.followedBy}]` : `${name}: FAIL ON RHS FIELD`;
-    //nvdebug(msg, debug);
+    //nvdebug(msg, debugDev);
     return false;
   }
 
-  //nvdebug(`${rule.name ? rule.name : '<unnamed>'}: ACCEPT ${rule.code} (${subfield1.code}), SF2=${rule.followedBy} (${subfield2 ? subfield2.code : '#'})`, debug);
+   
+  //nvdebug(`${rule.name ? rule.name : '<unnamed>'}: ACCEPT ${rule.code} (${subfield1.code}), SF2=${rule.followedBy} (${subfield2 ? subfield2.code : '#'})`, debugDev);
   return true;
 }
 
@@ -513,9 +517,9 @@ function applyPunctuationRules(field, subfield1, subfield2, ruleArray = null, op
     return;
   }
 
-  //nvdebug(`PUNCTUATE ${field.tag}/${tag2} '${subfieldToString(subfield1)}' XXX '${subfield2 ? subfieldToString(subfield2) : '#'} }`);
+  //nvdebug(`PUNCTUATE ${field.tag}/${tag2} '${subfieldToString(subfield1)}' XXX '${subfield2 ? subfieldToString(subfield2) : '#'} }`, debugDev);
 
-  //nvdebug(`OP=${operation} ${tag2}: '${subfield1.code}: ${subfield1.value}' ??? '${subfield2 ? subfield2.code : '#'}'`);
+  //nvdebug(`OP=${operation} ${tag2}: '${subfield1.code}: ${subfield1.value}' ??? '${subfield2 ? subfield2.code : '#'}'`, debugDev);
   const candRules = ruleArray[tag2];
   candRules.every(rule => { // uses "every", not "forEach", so that only one rule is applies to the given subfields
     //debugRule(rule);
@@ -525,20 +529,20 @@ function applyPunctuationRules(field, subfield1, subfield2, ruleArray = null, op
 
     //const originalValue = subfield1.value;
     if (rule.remove && [REMOVE, REMOVE_AND_ADD].includes(operation) && subfield1.value.match(rule.remove)) {
-      //nvdebug(`    PUNC REMOVAL TO BE PERFORMED FOR $${subfield1.code} '${subfield1.value}'`, debug);
+      //nvdebug(`    PUNC REMOVAL TO BE PERFORMED FOR $${subfield1.code} '${subfield1.value}'`, debugDev);
       subfield1.value = subfield1.value.replace(rule.remove, '');
-      //nvdebug(`    PUNC REMOVAL PERFORMED FOR '${subfield1.value}'`);
+      //nvdebug(`    PUNC REMOVAL PERFORMED FOR '${subfield1.value}'`, debugDev);
       return false;
     }
     if (rule.add && [ADD, REMOVE_AND_ADD].includes(operation)) {
       subfield1.value += rule.add;
-      //nvdebug(`    ADDED '${rule.add}' TO FORM '${subfield1.value}' USING RULE ${rule.name}`);
+      //nvdebug(`    ADDED '${rule.add}' TO FORM '${subfield1.value}' USING RULE ${rule.name}`, debugDev);
       return false;
     }
 
     /*
     if (subfield1.value !== originalValue) {
-      nvdebug(` PROCESS PUNC: '‡${subfield1.code} ${originalValue}' => '‡${subfield1.code} ${subfield1.value}'`, debug);
+      nvdebug(` PROCESS PUNC: '‡${subfield1.code} ${originalValue}' => '‡${subfield1.code} ${subfield1.value}'`, debugDev);
     }
     */
 
@@ -552,11 +556,11 @@ function subfieldFixPunctuation(field, subfield1, subfield2) {
 }
 
 function subfieldStripPunctuation(field, subfield1, subfield2) {
-  //nvdebug(`FSP1: '${subfield1.value}'`);
+  //nvdebug(`FSP1: '${subfield1.value}'`, debugDev);
   applyPunctuationRules(field, subfield1, subfield2, cleanValidPunctuationRules, REMOVE);
-  //nvdebug(`FSP2: '${subfield1.value}'`);
+  //nvdebug(`FSP2: '${subfield1.value}'`, debugDev);
   applyPunctuationRules(field, subfield1, subfield2, cleanCrappyPunctuationRules, REMOVE);
-  //nvdebug(`FSP3: '${subfield1.value}'`);
+  //nvdebug(`FSP3: '${subfield1.value}'`, debugDev);
 
 }
 
@@ -578,7 +582,7 @@ export function fieldFixPunctuation(field) {
   if (!field.subfields) {
     return field;
   }
-  //nvdebug(`################### fieldFixPunctuation() TEST ${fieldToString(field)}`);
+  //nvdebug(`################### fieldFixPunctuation() TEST ${fieldToString(field)}`, debugDev);
 
   field.subfields.forEach((sf, i) => {
     // NB! instead of next subfield, we should actually get next *non-control-subfield*!!!