@natlibfi/marc-record-validators-melinda 10.8.0 → 10.8.1-alpha.1

package/dist/mergeRelatorTermFields.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _clone = _interopRequireDefault(require("clone"));
+var _punctuation = require("./punctuation2");
+var _utils = require("./utils");
+var _sortSubfields = require("./sortSubfields");
+var _sortRelatorTerms = require("./sortRelatorTerms");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Merge author/agent fields
+//
+// Rationale: Same author can appear in one 1XX and multiple 7XX fields having only different $e subfields.
+// These fields can be merged (and $e-subfields can then be sorted)...
+//
+// Author(s): Nicholas Volk
+
+//import createDebugLogger from 'debug';
+/*
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:mergeRelatorTermFields');
+//const debugData = debug.extend('data');
+*/
+function _default() {
+  return {
+    description: 'Merge author fields that only differ in $e relator terms',
+    validate,
+    fix
+  };
+  function fix(record) {
+    const msg = mergeRelatorTermFields(record, true);
+    const res = {
+      message: msg,
+      fix: msg,
+      valid: true
+    };
+    return res;
+  }
+  function validate(record) {
+    const msg = mergeRelatorTermFields(record, false);
+    const res = {
+      message: msg
+    };
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+}
+function createNormalizedClone(field) {
+  const clonedField = (0, _clone.default)(field);
+  // Normalize
+  (0, _punctuation.fieldStripPunctuation)(clonedField);
+  return clonedField;
+}
+function createNormalizedCloneWithoutRelatorTerms(field) {
+  const clonedField = createNormalizedClone(field);
+  // Remove relator terms $e subfi:
+  clonedField.subfields = clonedField.subfields.filter(sf => sf.code !== 'e'); // eslint-disable-line functional/immutable-data
+  return clonedField;
+}
+function fieldToRelatorTermSubfieldCode(field) {
+  if (['100', '110', '700', '710', '720', '751', '752'].includes(field.tag)) {
+    return 'e';
+  }
+  if (field.tag === '111' || field.tag === '711') {
+    return 'j';
+  }
+  return '?'; // No need to complain. Nothing is found.
+}
+
+function getRelatorTermStrings(relatorTermSubfieldCode, field) {
+  return field.subfields.filter(sf => sf.code === relatorTermSubfieldCode).map(sf => sf.value);
+}
+function extractAddableRelatorTerms(fromField, toField) {
+  const relatorTermSubfieldCode = fieldToRelatorTermSubfieldCode(fromField);
+  const normalizedFromFieldRelatorTerms = getRelatorTermStrings(relatorTermSubfieldCode, fromField);
+  if (normalizedFromFieldRelatorTerms.length === 0) {
+    return [];
+  }
+  // Remove values that already exist:
+  const normalizedToFieldRelatorTerms = getRelatorTermStrings(relatorTermSubfieldCode, toField);
+  return normalizedFromFieldRelatorTerms.filter(str => !normalizedToFieldRelatorTerms.includes(str));
+}
+function copyRelatorSubfields(fromField, toField) {
+  const relatorTermSubfieldCode = fieldToRelatorTermSubfieldCode(fromField);
+  const newRelatorTerms = extractAddableRelatorTerms(fromField, toField);
+  newRelatorTerms.forEach(term => toField.subfields.push({
+    code: relatorTermSubfieldCode,
+    value: term
+  })); // eslint-disable-line functional/immutable-data
+}
+
+function mergeRelatorTermFields(record, fix = false) {
+  /* eslint-disable */
+  // NV: 111/711, 751 and 752 where so rare that I did not add them here
+  let fields = record.get('(?:[17][01]0|720)');
+  let result = [];
+  const comparisonFieldsAsString = fields.map(f => (0, _utils.fieldToString)(createNormalizedCloneWithoutRelatorTerms(f)));
+  (0, _utils.nvdebug)(`mergeRelatorTermFields(): ${fields.length} cand field(s) found`);
+  for (let i = 0; i < fields.length - 1; i++) {
+    let currField = fields[i];
+    if (currField.deleted) {
+      continue;
+    }
+    (0, _utils.nvdebug)(`RT: Trying to pair ${comparisonFieldsAsString[i]}/${i}`);
+    for (let j = i + 1; j < fields.length; j++) {
+      (0, _utils.nvdebug)(` Compare with ${comparisonFieldsAsString[j]}/${j}`);
+      let mergableField = fields[j];
+      // Skip 1/7 from 1XX/7XX for similarity check:
+      if (comparisonFieldsAsString[i].substring(1) !== comparisonFieldsAsString[j].substring(1)) {
+        (0, _utils.nvdebug)("  NOT PAIR");
+        continue;
+      }
+      if (mergableField.deleted) {
+        (0, _utils.nvdebug)("  DELETED");
+        continue;
+      }
+      const str = `MERGE RELATOR TERM FIELD: ${(0, _utils.fieldToString)(mergableField)}`;
+      (0, _utils.nvdebug)(str);
+      if (!result.includes(str)) {
+        result.push(str);
+      }
+      if (fix) {
+        mergableField.deleted = 1;
+        copyRelatorSubfields(mergableField, currField);
+        (0, _punctuation.fieldFixPunctuation)(currField);
+        (0, _sortSubfields.sortAdjacentSubfields)(currField); // Put the added $e subfield to proper places.
+        (0, _sortRelatorTerms.sortAdjacentESubfields)(currField); // Sort $e subfields with each other
+        (0, _punctuation.fieldFixPunctuation)(currField);
+      }
+    }
+  }
+  if (!fix) {
+    fields.forEach(f => delete f.deleted);
+  }
+  record.fields = record.fields.filter(f => !f.deleted);
+  /* eslint-enable */
+  return result;
+}
+//# sourceMappingURL=mergeRelatorTermFields.js.map

package/dist/mergeRelatorTermFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeRelatorTermFields.js","names":["_clone","_interopRequireDefault","require","_punctuation","_utils","_sortSubfields","_sortRelatorTerms","obj","__esModule","default","_default","description","validate","fix","record","msg","mergeRelatorTermFields","res","message","valid","length","createNormalizedClone","field","clonedField","clone","fieldStripPunctuation","createNormalizedCloneWithoutRelatorTerms","subfields","filter","sf","code","fieldToRelatorTermSubfieldCode","includes","tag","getRelatorTermStrings","relatorTermSubfieldCode","map","value","extractAddableRelatorTerms","fromField","toField","normalizedFromFieldRelatorTerms","normalizedToFieldRelatorTerms","str","copyRelatorSubfields","newRelatorTerms","forEach","term","push","fields","get","result","comparisonFieldsAsString","f","fieldToString","nvdebug","i","currField","deleted","j","mergableField","substring","fieldFixPunctuation","sortAdjacentSubfields","sortAdjacentESubfields"],"sources":["../src/mergeRelatorTermFields.js"],"sourcesContent":["// Merge author/agent fields\n//\n// Rationale: Same author can appear in one 1XX and multiple 7XX fields having only different $e subfields.\n// These fields can be merged (and $e-subfields can then be sorted)...\n//\n// Author(s): Nicholas Volk\n\n\nimport clone from 'clone';\nimport {fieldFixPunctuation, fieldStripPunctuation} from './punctuation2';\nimport {fieldToString, nvdebug} from './utils';\nimport {sortAdjacentSubfields} from './sortSubfields';\nimport {sortAdjacentESubfields} from './sortRelatorTerms';\n//import createDebugLogger from 'debug';\n/*\n//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:mergeRelatorTermFields');\n//const debugData = debug.extend('data');\n*/\n\nexport default function () {\n\n  return {\n    description: 'Merge author fields that only differ in $e relator terms',\n    validate, fix\n  };\n\n  function fix(record) {\n    const msg = mergeRelatorTermFields(record, true);\n    const res = {message: msg, fix: msg, valid: true};\n    return res;\n  }\n\n  function validate(record) {\n    const msg = mergeRelatorTermFields(record, false);\n    const res = {message: msg};\n\n    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data\n    return res;\n  }\n}\n\nfunction createNormalizedClone(field) {\n  const clonedField = clone(field);\n  // Normalize\n  fieldStripPunctuation(clonedField);\n  return clonedField;\n}\n\nfunction createNormalizedCloneWithoutRelatorTerms(field) {\n  const clonedField = createNormalizedClone(field);\n  // Remove relator terms $e subfi:\n  clonedField.subfields = clonedField.subfields.filter(sf => sf.code !== 'e'); // eslint-disable-line functional/immutable-data\n  return clonedField;\n}\n\nfunction fieldToRelatorTermSubfieldCode(field) {\n  if (['100', '110', '700', '710', '720', '751', '752'].includes(field.tag)) {\n    return 'e';\n  }\n  if (field.tag === '111' || field.tag === '711') {\n    return 'j';\n  }\n  return '?'; // No need to complain. Nothing is found.\n}\n\nfunction getRelatorTermStrings(relatorTermSubfieldCode, field) {\n  return field.subfields.filter(sf => sf.code === relatorTermSubfieldCode).map(sf => sf.value);\n\n}\n\nfunction extractAddableRelatorTerms(fromField, toField) {\n  const relatorTermSubfieldCode = fieldToRelatorTermSubfieldCode(fromField);\n  const normalizedFromFieldRelatorTerms = getRelatorTermStrings(relatorTermSubfieldCode, fromField);\n  if (normalizedFromFieldRelatorTerms.length === 0) {\n    return [];\n  }\n  // Remove values that already exist:\n  const normalizedToFieldRelatorTerms = getRelatorTermStrings(relatorTermSubfieldCode, toField);\n  return normalizedFromFieldRelatorTerms.filter(str => !normalizedToFieldRelatorTerms.includes(str));\n}\n\n\nfunction copyRelatorSubfields(fromField, toField) {\n  const relatorTermSubfieldCode = fieldToRelatorTermSubfieldCode(fromField);\n  const newRelatorTerms = extractAddableRelatorTerms(fromField, toField);\n\n  newRelatorTerms.forEach(term => toField.subfields.push({code: relatorTermSubfieldCode, value: term})); // eslint-disable-line functional/immutable-data\n\n}\n\nfunction mergeRelatorTermFields(record, fix = false) {\n  /* eslint-disable */\n  // NV: 111/711, 751 and 752 where so rare that I did not add them here\n  let fields = record.get('(?:[17][01]0|720)'); \n  let result = [];\n  const comparisonFieldsAsString = fields.map(f => fieldToString(createNormalizedCloneWithoutRelatorTerms(f)));\n\n  nvdebug(`mergeRelatorTermFields(): ${fields.length} cand field(s) found`);\n  for(let i=0; i < fields.length-1; i++) {\n    let currField = fields[i];\n    if (currField.deleted) {\n      continue;\n    }\n    nvdebug(`RT: Trying to pair ${comparisonFieldsAsString[i]}/${i}`);\n    for (let j=i+1; j < fields.length; j++) {\n      nvdebug(` Compare with ${comparisonFieldsAsString[j]}/${j}`);\n      let mergableField = fields[j];\n      // Skip 1/7 from 1XX/7XX for similarity check:\n      if ( comparisonFieldsAsString[i].substring(1) !== comparisonFieldsAsString[j].substring(1)) {\n        nvdebug(\"  NOT PAIR\");\n        continue;\n      }\n      if (mergableField.deleted) {\n        nvdebug(\"  DELETED\");\n        continue;\n      }\n      const str = `MERGE RELATOR TERM FIELD: ${fieldToString(mergableField)}`;\n      nvdebug(str);\n\n      if(!result.includes(str)) {\n        result.push(str)\n      }\n\n      if (fix) {\n        mergableField.deleted = 1;\n        copyRelatorSubfields(mergableField, currField);\n        fieldFixPunctuation(currField);\n        sortAdjacentSubfields(currField); // Put the added $e subfield to proper places.\n        sortAdjacentESubfields(currField); // Sort $e subfields with each other\n        fieldFixPunctuation(currField);\n\n      }\n    }\n  }\n\n  if(!fix) {\n    fields.forEach(f => delete f.deleted);\n  }\n\n  record.fields = record.fields.filter(f => !f.deleted);\n  /* eslint-enable */\n  return result;\n}\n"],"mappings":"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"}

package/dist/mergeRelatorTermFields.spec.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _chai = require("chai");
+var _marcRecord = require("@natlibfi/marc-record");
+var _mergeRelatorTermFields = _interopRequireDefault(require("./mergeRelatorTermFields"));
+var _fixura = require("@natlibfi/fixura");
+var _fixugen = _interopRequireDefault(require("@natlibfi/fixugen"));
+var _debug = _interopRequireDefault(require("debug"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+(0, _fixugen.default)({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mergeRelatorTermFields'],
+  useMetadataFile: true,
+  recurse: true,
+  fixura: {
+    reader: _fixura.READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = (0, _debug.default)('@natlibfi/marc-record-validators-melinda/mergeRelatorTermFields:test');
+async function testValidatorFactory() {
+  const validator = await (0, _mergeRelatorTermFields.default)();
+  (0, _chai.expect)(validator).to.be.an('object').that.has.any.keys('description', 'validate');
+  (0, _chai.expect)(validator.description).to.be.a('string');
+  (0, _chai.expect)(validator.validate).to.be.a('function');
+}
+async function callback({
+  getFixture,
+  enabled = true,
+  fix = false
+}) {
+  if (enabled === false) {
+    debug('TEST SKIPPED!');
+    return;
+  }
+  const validator = await (0, _mergeRelatorTermFields.default)();
+  const record = new _marcRecord.MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    (0, _chai.expect)(result).to.eql(expectedResult);
+    return;
+  }
+  await validator.fix(record);
+  (0, _chai.expect)(record).to.eql(expectedResult);
+}
+//# sourceMappingURL=mergeRelatorTermFields.spec.js.map

package/dist/mergeRelatorTermFields.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeRelatorTermFields.spec.js","names":["_chai","require","_marcRecord","_mergeRelatorTermFields","_interopRequireDefault","_fixura","_fixugen","_debug","obj","__esModule","default","generateTests","callback","path","__dirname","useMetadataFile","recurse","fixura","reader","READERS","JSON","mocha","before","testValidatorFactory","debug","createDebugLogger","validator","validatorFactory","expect","to","be","an","that","has","any","keys","description","a","validate","getFixture","enabled","fix","record","MarcRecord","expectedResult","result","eql"],"sources":["../src/mergeRelatorTermFields.spec.js"],"sourcesContent":["import {expect} from 'chai';\nimport {MarcRecord} from '@natlibfi/marc-record';\nimport validatorFactory from './mergeRelatorTermFields';\nimport {READERS} from '@natlibfi/fixura';\nimport generateTests from '@natlibfi/fixugen';\nimport createDebugLogger from 'debug';\n\ngenerateTests({\n  callback,\n  path: [__dirname, '..', 'test-fixtures', 'mergeRelatorTermFields'],\n  useMetadataFile: true,\n  recurse: true,\n  fixura: {\n    reader: READERS.JSON\n  },\n  mocha: {\n    before: () => testValidatorFactory()\n  }\n});\nconst debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/mergeRelatorTermFields:test');\n\nasync function testValidatorFactory() {\n  const validator = await validatorFactory();\n\n  expect(validator)\n    .to.be.an('object')\n    .that.has.any.keys('description', 'validate');\n\n  expect(validator.description).to.be.a('string');\n  expect(validator.validate).to.be.a('function');\n}\n\nasync function callback({getFixture, enabled = true, fix = false}) {\n  if (enabled === false) {\n    debug('TEST SKIPPED!');\n    return;\n  }\n\n  const validator = await validatorFactory();\n  const record = new MarcRecord(getFixture('record.json'));\n  const expectedResult = getFixture('expectedResult.json');\n  // console.log(expectedResult); // eslint-disable-line\n\n  if (!fix) {\n    const result = await validator.validate(record);\n    expect(result).to.eql(expectedResult);\n    return;\n  }\n\n  await validator.fix(record);\n  expect(record).to.eql(expectedResult);\n}\n"],"mappings":";;AAAA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,uBAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,QAAA,GAAAF,sBAAA,CAAAH,OAAA;AACA,IAAAM,MAAA,GAAAH,sBAAA,CAAAH,OAAA;AAAsC,SAAAG,uBAAAI,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAEtC,IAAAG,gBAAa,EAAC;EACZC,QAAQ;EACRC,IAAI,EAAE,CAACC,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,wBAAwB,CAAC;EAClEC,eAAe,EAAE,IAAI;EACrBC,OAAO,EAAE,IAAI;EACbC,MAAM,EAAE;IACNC,MAAM,EAAEC,eAAO,CAACC;EAClB,CAAC;EACDC,KAAK,EAAE;IACLC,MAAM,EAAEA,CAAA,KAAMC,oBAAoB,CAAC;EACrC;AACF,CAAC,CAAC;AACF,MAAMC,KAAK,GAAG,IAAAC,cAAiB,EAAC,sEAAsE,CAAC;AAEvG,eAAeF,oBAAoBA,CAAA,EAAG;EACpC,MAAMG,SAAS,GAAG,MAAM,IAAAC,+BAAgB,EAAC,CAAC;EAE1C,IAAAC,YAAM,EAACF,SAAS,CAAC,CACdG,EAAE,CAACC,EAAE,CAACC,EAAE,CAAC,QAAQ,CAAC,CAClBC,IAAI,CAACC,GAAG,CAACC,GAAG,CAACC,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC;EAE/C,IAAAP,YAAM,EAACF,SAAS,CAACU,WAAW,CAAC,CAACP,EAAE,CAACC,EAAE,CAACO,CAAC,CAAC,QAAQ,CAAC;EAC/C,IAAAT,YAAM,EAACF,SAAS,CAACY,QAAQ,CAAC,CAACT,EAAE,CAACC,EAAE,CAACO,CAAC,CAAC,UAAU,CAAC;AAChD;AAEA,eAAezB,QAAQA,CAAC;EAAC2B,UAAU;EAAEC,OAAO,GAAG,IAAI;EAAEC,GAAG,GAAG;AAAK,CAAC,EAAE;EACjE,IAAID,OAAO,KAAK,KAAK,EAAE;IACrBhB,KAAK,CAAC,eAAe,CAAC;IACtB;EACF;EAEA,MAAME,SAAS,GAAG,MAAM,IAAAC,+BAAgB,EAAC,CAAC;EAC1C,MAAMe,MAAM,GAAG,IAAIC,sBAAU,CAACJ,UAAU,CAAC,aAAa,CAAC,CAAC;EACxD,MAAMK,cAAc,GAAGL,UAAU,CAAC,qBAAqB,CAAC;EACxD;;EAEA,IAAI,CAACE,GAAG,EAAE;IACR,MAAMI,MAAM,GAAG,MAAMnB,SAAS,CAACY,QAAQ,CAACI,MAAM,CAAC;IAC/C,IAAAd,YAAM,EAACiB,MAAM,CAAC,CAAChB,EAAE,CAACiB,GAAG,CAACF,cAAc,CAAC;IACrC;EACF;EAEA,MAAMlB,SAAS,CAACe,GAAG,CAACC,MAAM,CAAC;EAC3B,IAAAd,YAAM,EAACc,MAAM,CAAC,CAACb,EAAE,CAACiB,GAAG,CAACF,cAAc,CAAC;AACvC"}

package/dist/punctuation2.js

@@ -17,6 +17,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 *
 * NOTE #1: https://www.kiwi.fi/display/kumea/Loppupisteohje is implemented via another validator/fixer.(ending-punctuation)
 * NOTE #2: Validator/fixer punctuation does similar stuff, but focuses on X00 fields.
+* NOTE #3: As of 2023-06-05 control subfields ($0...$9) are obsolete. Don't use them in rules.
+*          (They are jumped over when looking for next (non-controlfield subfield)
 */
 
 // import createDebugLogger from 'debug';
@@ -52,12 +54,18 @@ function _default() {
     return res;
   }
 }
+function isControlSubfield(subfield) {
+  return ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].includes(subfield.code);
+}
+function getNextRelevantSubfield(field, currSubfieldIndex) {
+  return field.subfields.find((subfield, index) => index > currSubfieldIndex && !isControlSubfield(subfield));
+}
 function fieldGetFixedString(field) {
   const cloneField = (0, _clone.default)(field);
   cloneField.subfields.forEach((sf, i) => {
     // NB! instead of next subfield, we should actually get next *non-control-subfield*!!!
     // (In plain English: We should skip $0 - $9 at least, maybe $w as well...)
-    subfieldFixPunctuation(cloneField.tag, sf, i + 1 < cloneField.subfields.length ? cloneField.subfields[i + 1] : null);
+    subfieldFixPunctuation(cloneField, sf, getNextRelevantSubfield(cloneField, i));
   });
   return (0, _utils.fieldToString)(cloneField);
 }
@@ -92,7 +100,7 @@ const removeColons = {
 };
 const removeX00Comma = {
   'code': 'abcqde',
-  'followedBy': 'abcqde#01459',
+  'followedBy': 'abcqde#',
   'context': /.,$/u,
   'remove': /,$/u
 };
@@ -105,7 +113,7 @@ const cleanRHS = {
 };
 const cleanX00dCommaOrDot = {
   'code': 'd',
-  'followedBy': 'et#01459',
+  'followedBy': 'et#',
   'context': /[0-9]-[,.]$/u,
   'remove': /[,.]$/u
 };
@@ -122,7 +130,7 @@ const cleanCorruption = {
 // These $e dot removals are tricky: before removing the comma, we should know that it ain't an abbreviation such as "esitt."...
 const cleanX00eDot = {
   'code': 'e',
-  'followedBy': 'egj#059',
+  'followedBy': 'egj#',
   'context': /(?:[ai]ja|jä)[.,]$/u,
   'remove': /\.$/u
 };
@@ -155,7 +163,7 @@ const addX00aComma2 = {
 const addX00aDot = {
   'add': '.',
   'code': 'abcde',
-  'followedBy': '#tu0159',
+  'followedBy': '#tu',
   'context': defaultNeedsPuncAfter
 };
 const addX10bDot = {
@@ -175,7 +183,7 @@ const addX10Dot = {
   'name': 'Add X10 final dot',
   'add': '.',
   'code': 'abe',
-  'followedBy': '#0159',
+  'followedBy': '#',
   'context': defaultNeedsPuncAfter
 };
 const addLanguageComma = {
@@ -272,13 +280,13 @@ const cleanLegalX00Comma = {
 // Accept upper case letters in X00$b, since they are probably Roman numerals.
 const cleanLegalX00bDot = {
   'code': 'b',
-  'followedBy': 't#01459',
+  'followedBy': 't#',
   context: /^[IVXLCDM]+\.$/u,
   'remove': /\.$/u
 };
 const cleanLegalX00Dot = {
   'code': 'abcdetvl',
-  'followedBy': 'tu#01459',
+  'followedBy': 'tu#',
   'context': /(?:[a-z0-9)]|å|ä|ö)\.$/u,
   'remove': /\.$/u
 };
@@ -300,7 +308,7 @@ const cleanLegalX10Comma = {
 const cleanLegalX10Dot = {
   'name': 'X10dot',
   'code': 'ab',
-  'followedBy': 'b#059',
+  'followedBy': 'b#',
   'context': /.\.$/u,
   'remove': /\.$/u
 };
@@ -418,6 +426,13 @@ const cleanValidPunctuationRules = {
     'code': 'p',
     'followedBy': 'c',
     'remove': /:$/u
+  }],
+  // Experimental, MET366-ish (end punc in internationally valid, but we don't use it here in Finland):
+  '648': [{
+    'code': 'a',
+    'content': /^[0-9]+\.$/u,
+    'ind2': ['4'],
+    'remove': /\.$/u
   }]
 };
 
@@ -550,6 +565,18 @@ function ruleAppliesToSubfieldCode(targetSubfieldCodes, currSubfieldCode) {
   }
   return targetSubfieldCodes.includes(currSubfieldCode);
 }
+function ruleAppliesToField(rule, field) {
+  if ('ind1' in rule && field.ind1.includes(rule.ind1)) {
+    return false;
+  }
+  if ('ind2' in rule && field.ind2.includes(rule.ind2)) {
+    return false;
+  }
+
+  // If we want to check, say, $2, it should be implemented here!
+
+  return true;
+}
 function ruleAppliesToCurrentSubfield(rule, subfield) {
   if (!ruleAppliesToSubfieldCode(rule.code, subfield.code)) {
     return false;
@@ -566,7 +593,7 @@ function ruleAppliesToNextSubfield(rule, nextSubfield) {
     return true;
   }
   // The '#' existence check applies only to the RHS field. LHS always exists.
-  if (nextSubfield === null) {
+  if (!nextSubfield) {
     const negation = rule.followedBy.includes('!');
     if (negation) {
       return !rule.followedBy.includes('#');
@@ -582,16 +609,20 @@ function ruleAppliesToNextSubfield(rule, nextSubfield) {
   }
   return true;
 }
-function checkRule(rule, subfield1, subfield2) {
+function checkRule(rule, field, subfield1, subfield2) {
+  if (!ruleAppliesToField(rule, field)) {
+    (0, _utils.nvdebug)(`FAIL ON WHOLE FIELD: '${(0, _utils.fieldToString)(field)}`);
+    return false;
+  }
   //const name = rule.name || 'UNNAMED';
   if (!ruleAppliesToCurrentSubfield(rule, subfield1)) {
-    //nvdebug(`${name}: FAIL ON LHS FIELD: '$${subfield1.code} ${subfield1.value}', SF=${rule.code}`, debug);
+    //nvdebug(`${name}: FAIL ON LHS SUBFIELD: '$${subfield1.code} ${subfield1.value}', SF=${rule.code}`, debug);
     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 FIELD '${subfield2.code}' not in [${rule.followedBy}]` : `${name}: FAIL ON RHS FIELD`;
+    //const msg = subfield2 ? `${name}: FAIL ON RHS SUBFIELD '${subfield2.code}' not in [${rule.followedBy}]` : `${name}: FAIL ON RHS FIELD`;
     //nvdebug(msg, debug);
     return false;
   }
@@ -599,14 +630,14 @@ function checkRule(rule, subfield1, subfield2) {
   //nvdebug(`${name}: ACCEPT ${rule.code}/${subfield1.code}, SF2=${rule.followedBy}/${subfield2 ? subfield2.code : '#'}`, debug);
   return true;
 }
-function applyPunctuationRules(tag, subfield1, subfield2, ruleArray = null, operation = NONE) {
+function applyPunctuationRules(field, subfield1, subfield2, ruleArray = null, operation = NONE) {
   /*
   if (ruleArray === null || operation === NONE) {
     debug(`applyPunctuation(): No rules to apply!`);
     return;
   }
   */
-  if (!(`${tag}` in ruleArray) || ruleArray === null || operation === NONE) {
+  if (!(`${field.tag}` in ruleArray) || ruleArray === null || operation === NONE) {
     /*
     if (!['020', '650'].includes(tag) || !isControlSubfieldCode(subfield1.code)) { // eslint-disable-line functional/no-conditional-statements
       nvdebug(`No punctuation rules found for ${tag} (looking for: ‡${subfield1.code})`, debug);
@@ -616,7 +647,7 @@ function applyPunctuationRules(tag, subfield1, subfield2, ruleArray = null, oper
   }
 
   //nvdebug(`OP=${operation} ${tag}: '${subfield1.code}: ${subfield1.value}' ??? '${subfield2 ? subfield2.code : '#'}'`, debug);
-  const activeRules = ruleArray[tag].filter(rule => checkRule(rule, subfield1, subfield2));
+  const activeRules = ruleArray[field.tag].filter(rule => checkRule(rule, field, subfield1, subfield2));
   activeRules.forEach(rule => {
     const originalValue = subfield1.value;
     if (rule.remove && [REMOVE, REMOVE_AND_ADD].includes(operation) && subfield1.value.match(rule.remove)) {
@@ -637,9 +668,9 @@ function applyPunctuationRules(tag, subfield1, subfield2, ruleArray = null, oper
     }
   });
 }
-function subfieldFixPunctuation(tag, subfield1, subfield2) {
-  applyPunctuationRules(tag, subfield1, subfield2, cleanCrappyPunctuationRules, REMOVE);
-  applyPunctuationRules(tag, subfield1, subfield2, addPairedPunctuationRules, ADD);
+function subfieldFixPunctuation(field, subfield1, subfield2) {
+  applyPunctuationRules(field, subfield1, subfield2, cleanCrappyPunctuationRules, REMOVE);
+  applyPunctuationRules(field, subfield1, subfield2, addPairedPunctuationRules, ADD);
 }
 function fieldStripPunctuation(field) {
   if (!field.subfields) {
@@ -647,9 +678,9 @@ function fieldStripPunctuation(field) {
   }
   field.subfields.forEach((sf, i) => {
     (0, _utils.nvdebug)(`FSP1: '${sf.value}'`);
-    applyPunctuationRules(field.tag, sf, i + 1 < field.subfields.length ? field.subfields[i + 1] : null, cleanValidPunctuationRules, REMOVE);
+    applyPunctuationRules(field, sf, i + 1 < field.subfields.length ? field.subfields[i + 1] : null, cleanValidPunctuationRules, REMOVE);
     (0, _utils.nvdebug)(`FSP2: '${sf.value}'`);
-    applyPunctuationRules(field.tag, sf, i + 1 < field.subfields.length ? field.subfields[i + 1] : null, cleanCrappyPunctuationRules, REMOVE);
+    applyPunctuationRules(field, sf, i + 1 < field.subfields.length ? field.subfields[i + 1] : null, cleanCrappyPunctuationRules, REMOVE);
     (0, _utils.nvdebug)(`FSP3: '${sf.value}'`);
   });
   return field;
@@ -662,7 +693,7 @@ function fieldFixPunctuation(field) {
   field.subfields.forEach((sf, i) => {
     // NB! instead of next subfield, we should actually get next *non-control-subfield*!!!
     // (In plain English: We should skip $0 - $9 at least, maybe $w as well...)
-    subfieldFixPunctuation(field.tag, sf, i + 1 < field.subfields.length ? field.subfields[i + 1] : null);
+    subfieldFixPunctuation(field, sf, getNextRelevantSubfield(field, i));
   });
 
   // Use shared code for final punctuation (sadly this does not fix intermediate punc):