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

package/dist/subfield6Utils.js

@@ -1,131 +1,78 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fieldGetMaxSubfield6OccurrenceNumberAsInteger = fieldGetMaxSubfield6OccurrenceNumberAsInteger;
-exports.fieldGetOccurrenceNumberPairs = fieldGetOccurrenceNumberPairs;
-exports.fieldGetOccurrenceNumbers = fieldGetOccurrenceNumbers;
-exports.fieldGetUnambiguousOccurrenceNumber = fieldGetUnambiguousOccurrenceNumber;
-exports.fieldGetUnambiguousTag = fieldGetUnambiguousTag;
-exports.fieldHasOccurrenceNumber = fieldHasOccurrenceNumber;
-exports.fieldHasValidSubfield6 = fieldHasValidSubfield6;
-exports.fieldHasWantedTagAndOccurrenceNumber = fieldHasWantedTagAndOccurrenceNumber;
-exports.fieldIsFirstFieldInChain = fieldIsFirstFieldInChain;
-exports.fieldResetOccurrenceNumber = fieldResetOccurrenceNumber;
-exports.fieldSevenToOneOccurrenceNumber = fieldSevenToOneOccurrenceNumber;
-exports.fieldToNormalizedString = fieldToNormalizedString;
-exports.fieldsGetOccurrenceNumbers = fieldsGetOccurrenceNumbers;
-exports.fieldsToNormalizedString = fieldsToNormalizedString;
-exports.get6s = get6s;
-exports.getAllLinkedSubfield6Fields = getAllLinkedSubfield6Fields;
-exports.intToOccurrenceNumberString = intToOccurrenceNumberString;
-exports.is7XX = is7XX;
-exports.isFirstLinkedSubfield6Field = isFirstLinkedSubfield6Field;
-exports.isSubfield6Pair = isSubfield6Pair;
-exports.isValidSubfield6 = isValidSubfield6;
-exports.recordGetMaxSubfield6OccurrenceNumberAsInteger = recordGetMaxSubfield6OccurrenceNumberAsInteger;
-exports.recordGetSubfield6ChainHeads = recordGetSubfield6ChainHeads;
-exports.resetSubfield6Tag = resetSubfield6Tag;
-exports.subfield6GetOccurrenceNumber = subfield6GetOccurrenceNumber;
-exports.subfield6GetOccurrenceNumberAsInteger = subfield6GetOccurrenceNumberAsInteger;
-exports.subfield6GetTag = subfield6GetTag;
-exports.subfield6HasWantedTagAndOccurrenceNumber = subfield6HasWantedTagAndOccurrenceNumber;
-exports.subfield6ResetOccurrenceNumber = subfield6ResetOccurrenceNumber;
-var _debug = _interopRequireDefault(require("debug"));
-var _subfield8Utils = require("./subfield8Utils");
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield6Utils');
-
-const debug = (0, _debug.default)('@natlibfi/melinda-marc-record-merge-reducers:subfield6Utils');
-//const debugData = debug.extend('data');
-const debugDev = debug.extend('dev');
-
-// NB! Subfield 6 is non-repeatable and it should always comes first!
-// NB! Index size should always be 2 (preceding 0 required for 01..09) However, support for 100+ was added on 2023-02-27.
-// NB! Index value '00' are left as they are (is not paired/indexed/whatever.
+import createDebugLogger from "debug";
+import { add8s, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, isValidSubfield8 } from "./subfield8Utils.js";
+import { fieldHasSubfield, fieldToString, fieldsToString, nvdebug, subfieldToString } from "./utils.js";
+const debug = createDebugLogger("@natlibfi/melinda-marc-record-merge-reducers:subfield6Utils");
+const debugDev = debug.extend("dev");
 const sf6Regexp = /^[0-9][0-9][0-9]-(?:[0-9][0-9]|[1-9][0-9]+)(?:[^0-9].*)?$/u;
-function isValidSubfield6(subfield) {
-  if (subfield.code !== '6') {
+export function isValidSubfield6(subfield) {
+  if (subfield.code !== "6") {
     return false;
   }
   return subfield.value.match(sf6Regexp);
 }
-function subfield6GetTag(subfield) {
+export function subfield6GetTag(subfield) {
   if (isValidSubfield6(subfield)) {
     return subfield.value.substring(0, 3);
   }
-  return undefined;
+  return void 0;
 }
-function subfield6GetOccurrenceNumber(subfield) {
+export function subfield6GetOccurrenceNumber(subfield) {
   if (isValidSubfield6(subfield)) {
-    // Skip "TAG-" prefix. 2023-02-20: removed 2-digit requirement from here...
-    return subfield.value.substring(4).replace(/\D.*$/u, '');
+    return subfield.value.substring(4).replace(/\D.*$/u, "");
   }
-  return undefined;
+  return void 0;
 }
-function subfield6GetOccurrenceNumberAsInteger(subfield) {
+export function subfield6GetOccurrenceNumberAsInteger(subfield) {
   const index = subfield6GetOccurrenceNumber(subfield);
-  if (index === undefined || index === '00') {
+  if (index === void 0 || index === "00") {
     return 0;
   }
   const result = parseInt(index, 10);
-  //nvdebug(`SF6: ${subfield.value} => ${index} => ${result}`, debug);
   return result;
 }
-function subfield6ResetOccurrenceNumber(subfield, occurrenceNumber) {
+export function subfield6ResetOccurrenceNumber(subfield, occurrenceNumber) {
   if (!isValidSubfield6(subfield)) {
     return;
   }
-  const occurrenceNumberAsString = typeof occurrenceNumber === 'number' ? intToOccurrenceNumberString(occurrenceNumber) : 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}`);
   subfield.value = newValue;
 }
 function subfield6GetTail(subfield) {
   if (isValidSubfield6(subfield)) {
-    // Skip "TAG-" prefix. 2023-02-20: removed 2-digit requirement from here...
-    return subfield.value.replace(/^\d+-\d+/u, '');
+    return subfield.value.replace(/^\d+-\d+/u, "");
   }
-  return '';
+  return "";
 }
-function subfield6HasWantedTagAndOccurrenceNumber(subfield, tagAndOccurrenceNumber) {
-  if (subfield.code !== '6') {
+export function subfield6HasWantedTagAndOccurrenceNumber(subfield, tagAndOccurrenceNumber) {
+  if (subfield.code !== "6") {
     return false;
   }
-  // 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');
-  (0, _utils.nvdebug)(` Compare '${key}' vs '${tagAndOccurrenceNumber}'`);
+  const key = subfield.value.replace(/^([0-9][0-9][0-9]-[0-9][0-9]+).*$/u, "$1");
+  nvdebug(` Compare '${key}' vs '${tagAndOccurrenceNumber}'`);
   return key === tagAndOccurrenceNumber;
 }
-
-// <= SUBFIELD, FIELD =>
-
-function fieldGetUnambiguousTag(field) {
-  const tags = field.subfields.filter(sf => subfield6GetTag(sf));
+export function fieldGetUnambiguousTag(field) {
+  const tags = field.subfields.filter((sf) => subfield6GetTag(sf));
   if (tags.length === 1) {
     return subfield6GetTag(tags[0]);
   }
-  return undefined;
+  return void 0;
 }
-function fieldGetUnambiguousOccurrenceNumber(field) {
-  const occurrenceNumbers = field.subfields.filter(sf => subfield6GetOccurrenceNumber(sf));
+export function fieldGetUnambiguousOccurrenceNumber(field) {
+  const occurrenceNumbers = field.subfields.filter((sf) => subfield6GetOccurrenceNumber(sf));
   if (occurrenceNumbers.length === 1) {
     return subfield6GetOccurrenceNumber(occurrenceNumbers[0]);
   }
-  return undefined;
+  return void 0;
 }
-function fieldHasOccurrenceNumber(field, occurrenceNumber) {
-  //nvdebug(`${occurrenceNumber} vs ${fieldToString(field)}`);
-  return field.subfields && field.subfields.some(sf => subfield6GetOccurrenceNumber(sf) === occurrenceNumber);
+export function fieldHasOccurrenceNumber(field, occurrenceNumber) {
+  return field.subfields && field.subfields.some((sf) => subfield6GetOccurrenceNumber(sf) === occurrenceNumber);
 }
-function fieldResetOccurrenceNumber(field, newOccurrenceNumber, oldOccurrenceNumber = undefined) {
-  field.subfields.forEach(subfield => innerReset(subfield)); // eslint-disable-line array-callback-return
-
+export function fieldResetOccurrenceNumber(field, newOccurrenceNumber, oldOccurrenceNumber = void 0) {
+  field.subfields.forEach((subfield) => innerReset(subfield));
   function innerReset(subfield) {
-    // (Optional) Check that this is really the occurrence number we wan't to reseot
-    if (oldOccurrenceNumber !== undefined) {
+    if (oldOccurrenceNumber !== void 0) {
       const currOccurrenceNumber = subfield6GetOccurrenceNumber(subfield);
       if (currOccurrenceNumber !== oldOccurrenceNumber) {
         return;
@@ -134,170 +81,104 @@ function fieldResetOccurrenceNumber(field, newOccurrenceNumber, oldOccurrenceNum
     subfield6ResetOccurrenceNumber(subfield, newOccurrenceNumber);
   }
 }
-function intToOccurrenceNumberString(i) {
+export function intToOccurrenceNumberString(i) {
   return i < 10 ? `0${i}` : `${i}`;
 }
-function fieldGetMaxSubfield6OccurrenceNumberAsInteger(field) {
-  // used by reducer!
-  //nvdebug(`Checking subfields $6 from ${JSON.stringify(field)}`);
-  const sf6s = field.subfields ? field.subfields.filter(subfield => isValidSubfield6(subfield)) : [];
+export function fieldGetMaxSubfield6OccurrenceNumberAsInteger(field) {
+  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);
-  const vals = sf6s.map(sf => subfield6GetOccurrenceNumberAsInteger(sf));
+  const vals = sf6s.map((sf) => subfield6GetOccurrenceNumberAsInteger(sf));
   return Math.max(...vals);
 }
-function fieldHasWantedTagAndOccurrenceNumber(field, tagAndOccurrenceNumber) {
-  return field.subfields && field.subfields.some(sf => subfield6HasWantedTagAndOccurrenceNumber(sf, tagAndOccurrenceNumber));
+export function fieldHasWantedTagAndOccurrenceNumber(field, tagAndOccurrenceNumber) {
+  return field.subfields && field.subfields.some((sf) => subfield6HasWantedTagAndOccurrenceNumber(sf, tagAndOccurrenceNumber));
 }
-
-/*
-export function getFieldsWithGivenOccurrenceNumberSubfield6(record, occurrenceNumberAsString) {
-  const record.fields.filter(field => field
-
-  function fieldHasIndex(field, index) {
-    if (!field.subfields) {
-      return false;
-    }
-    return field.subfields.find(sf => isValidSubfield6(sf) && subfieldGetOccurrenceNumber6(sf) === index);
-  }
-}
-*/
-
-function fieldHasValidSubfield6(field) {
-  return field.subfields && field.subfields.some(sf => isValidSubfield6(sf));
+export function fieldHasValidSubfield6(field) {
+  return field.subfields && field.subfields.some((sf) => isValidSubfield6(sf));
 }
-function isSubfield6Pair(field, otherField) {
-  // No need to log this:
-  //nvdebug(`LOOK for $6-pair:\n ${fieldToString(field)}\n ${fieldToString(otherField)}`);
+export function isSubfield6Pair(field, otherField) {
   if (!fieldHasValidSubfield6(field) || !fieldHasValidSubfield6(otherField)) {
     return false;
   }
   if (!tagsArePairable6(field.tag, otherField.tag)) {
-    //nvdebug(` FAILED. REASON: TAGS NOT PAIRABLE!`);
     return false;
   }
   const fieldIndex = fieldGetUnambiguousOccurrenceNumber(field);
-  if (fieldIndex === undefined || fieldIndex === '00') {
-    //nvdebug(` FAILED. REASON: NO INDEX FOUND`);
+  if (fieldIndex === void 0 || fieldIndex === "00") {
     return false;
   }
   const otherFieldIndex = fieldGetUnambiguousOccurrenceNumber(otherField);
   if (fieldIndex !== otherFieldIndex) {
-    //nvdebug(` FAILURE: INDEXES: ${fieldIndex} vs ${otherFieldIndex}`);
     return false;
   }
   if (fieldGetUnambiguousTag(field) !== otherField.tag || field.tag !== fieldGetUnambiguousTag(otherField)) {
-    //nvdebug(` FAILURE: TAG vs $6 TAG`);
     return false;
   }
   return true;
   function tagsArePairable6(tag1, tag2) {
-    // How to do XOR operation in one line? Well, this is probably more readable...
-    if (tag1 === '880' && tag2 === '880') {
+    if (tag1 === "880" && tag2 === "880") {
       return false;
     }
-    if (tag1 !== '880' && tag2 !== '880') {
+    if (tag1 !== "880" && tag2 !== "880") {
       return false;
     }
     return true;
   }
 }
 function subfieldSevenToOneOccurrenceNumber(subfield) {
-  if (subfield.code !== '6' || subfield.value.substring(0, 1) !== '7') {
+  if (subfield.code !== "6" || subfield.value.substring(0, 1) !== "7") {
     return;
   }
   subfield.value = `1${subfield.value.substring(1)}`;
 }
-function fieldSevenToOneOccurrenceNumber(field) {
-  if (field.tag !== '880') {
+export function fieldSevenToOneOccurrenceNumber(field) {
+  if (field.tag !== "880") {
     return;
   }
-  field.subfields.forEach(sf => subfieldSevenToOneOccurrenceNumber(sf)); // eslint-disable-line array-callback-return
+  field.subfields.forEach((sf) => subfieldSevenToOneOccurrenceNumber(sf));
 }
-function fieldGetOccurrenceNumberPairs(field, candFields) {
-  // NB! TAG!=880 returns 880 fields, TAG==880 returns non-880 field
-  //nvdebug(`  Trying to finds pair for ${fieldToString(field)} in ${candFields.length} fields`);
-  const pairs = candFields.filter(otherField => isSubfield6Pair(field, otherField));
+export function fieldGetOccurrenceNumberPairs(field, candFields) {
+  const pairs = candFields.filter((otherField) => isSubfield6Pair(field, otherField));
   if (pairs.length === 0) {
-    (0, _utils.nvdebug)(`NO PAIRS FOUND FOR '${(0, _utils.fieldToString)(field)}'`);
+    nvdebug(`NO PAIRS FOUND FOR '${fieldToString(field)}'`);
     return pairs;
   }
-  (0, _utils.nvdebug)(`${pairs.length} PAIR(S) FOUND FOR '${(0, _utils.fieldToString)(field)}'`);
-  pairs.forEach(pairedField => (0, _utils.nvdebug)(`  '${(0, _utils.fieldToString)(pairedField)}'`)); // eslint-disable-line array-callback-return
+  nvdebug(`${pairs.length} PAIR(S) FOUND FOR '${fieldToString(field)}'`);
+  pairs.forEach((pairedField) => nvdebug(`  '${fieldToString(pairedField)}'`));
   return pairs;
 }
-function fieldGetOccurrenceNumbers(field) {
-  /* eslint-disable */
+export function fieldGetOccurrenceNumbers(field) {
   let occurrenceNumbers = [];
-  field.subfields?.forEach(sf => subfieldExtractOccurrenceNumber(sf));
+  field.subfields?.forEach((sf) => subfieldExtractOccurrenceNumber(sf));
   function subfieldExtractOccurrenceNumber(sf) {
     if (!isValidSubfield6(sf)) {
       return;
     }
     const occurrenceNumber = subfield6GetOccurrenceNumber(sf);
-    if (occurrenceNumber === '00' || occurrenceNumbers.includes(occurrenceNumber)) {
+    if (occurrenceNumber === "00" || occurrenceNumbers.includes(occurrenceNumber)) {
       return;
     }
     occurrenceNumbers.push(occurrenceNumber);
   }
-  /* eslint-enable */
   return occurrenceNumbers;
 }
-function fieldsGetOccurrenceNumbers(fields) {
-  /* eslint-disable */
+export function fieldsGetOccurrenceNumbers(fields) {
   let occurrenceNumbers = [];
-  fields.forEach(f => fieldProcessOccurrenceNumbers(f));
+  fields.forEach((f) => fieldProcessOccurrenceNumbers(f));
   function fieldProcessOccurrenceNumbers(f) {
     const newOccurrenceNumbers = fieldGetOccurrenceNumbers(f);
-    newOccurrenceNumbers.forEach(occurrenceNumber => {
+    newOccurrenceNumbers.forEach((occurrenceNumber) => {
       if (!occurrenceNumbers.includes(occurrenceNumber)) {
         occurrenceNumbers.push(occurrenceNumber);
       }
     });
   }
-  /* eslint-enable */
   return occurrenceNumbers;
 }
-
-/*
-export function fieldGetSubfield6Pair(field, record) {
-  const pairedFields = record.fields.filter(otherField => isSubfield6Pair(field, otherField));
-  if (pairedFields.length !== 1) {
-    return undefined;
-  }
-  // NB! It is theoretically possible to have multiple pairable 880 fields (one for each encoding)
-  nvdebug(`fieldGetSubfield6Pair(): ${fieldToString(field)} => ${fieldToString(pairedFields[0])}`);
-  return pairedFields[0];
-}
-*/
-
-/*
-export function pairAndStringify6(field, record) {
-  const pair6 = fieldGetSubfield6Pair(field, record);
-  if (!pair6) {
-    return fieldToNormalizedString(field);
-  }
-  return fieldsToNormalizedString([field, pair6]);
-}
-*/
-
-// Frequencly list for $6 subfields in 1XX/7XX fields:
-// 231115 100
-// 183832 700
-//  28773 710
-//   2047 711
-//    661 110
-//    341 111
-//    284 130
-//     63 730
-// Thus there's a real risk of ending up with, say, identical 100 vs 700 chains.
-// Semi-hackily support 1XX/7XX-version: 7XX can be deleted if corresponding 1XX exists:
-
-function is7XX(tag) {
-  return ['700', '710', '711', '730'].includes(tag);
+export function is7XX(tag) {
+  return ["700", "710", "711", "730"].includes(tag);
 }
 function normalizeEntryTag(tag) {
   if (tag.match(/^[17](?:00|10|11|30)$/u)) {
@@ -306,166 +187,123 @@ function normalizeEntryTag(tag) {
   return tag;
 }
 function subfieldToNormalizedString(sf, tag, targetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTagBoolean = false) {
-  // targetLinkingNumber refers to $8.
-  // normalizeEntryTagBoolean refers to 1XX/7XX tag values in subfield $6 value.
   if (isValidSubfield6(sf)) {
-    // && targetLinkingNumber === 0) {
-    // 1XX/7XX (entry tag) normalization:
     const tag2 = normalizeEntryTagBoolean ? normalizeEntryTag(tag) : tag;
-    const occurrenceNumber = normalizeOccurrenceNumber ? 'XX' : subfield6GetOccurrenceNumber(sf);
-    // If we are normalizing a $8 chain, don't normalize $6 occurrence number!
-    // Replace $6 occurrence number with XX:
-    return ` ‡${sf.code} ${tag2}-${occurrenceNumber}${subfield6GetTail(sf)}`;
+    const occurrenceNumber = normalizeOccurrenceNumber ? "XX" : subfield6GetOccurrenceNumber(sf);
+    return ` \u2021${sf.code} ${tag2}-${occurrenceNumber}${subfield6GetTail(sf)}`;
   }
-  if ((0, _subfield8Utils.isValidSubfield8)(sf)) {
-    const currLinkingNumber = (0, _subfield8Utils.getSubfield8LinkingNumber)(sf); //getSubfield8Index(sf);
+  if (isValidSubfield8(sf)) {
+    const currLinkingNumber = getSubfield8LinkingNumber(sf);
     if (targetLinkingNumber > 0 && currLinkingNumber === targetLinkingNumber) {
-      // For $8 we should only XX the index we are looking at...
-      const normVal = sf.value.replace(/^[0-9]+/u, 'XX');
-      return ` ‡${sf.code} ${normVal}`;
+      const normVal = sf.value.replace(/^[0-9]+/u, "XX");
+      return ` \u2021${sf.code} ${normVal}`;
     }
-    return ''; // Other $8 subfields are meaningless in this context
+    return "";
   }
-  return ` ${(0, _utils.subfieldToString)(sf)}`; // `‡${sf.code} ${sf.value}`;
+  return ` ${subfieldToString(sf)}`;
 }
-function fieldToNormalizedString(field, targetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTagBoolean = false) {
-  if ('subfields' in field) {
+export function fieldToNormalizedString(field, targetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTagBoolean = false) {
+  if ("subfields" in field) {
     const tag2 = normalizeEntryTagBoolean ? normalizeEntryTag(field.tag) : field.tag;
     return `${tag2} ${field.ind1}${field.ind2}${formatAndNormalizeSubfields(field)}`;
   }
   return `${field.tag}    ${field.value}`;
-  function formatAndNormalizeSubfields(field) {
-    return field.subfields.map(sf => subfieldToNormalizedString(sf, field.tag, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTagBoolean)).join('');
+  function formatAndNormalizeSubfields(field2) {
+    return field2.subfields.map((sf) => subfieldToNormalizedString(sf, field2.tag, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTagBoolean)).join("");
   }
 }
 function guessTargetLinkingNumber(fields, defaultTargetLinkingNumber) {
   if (defaultTargetLinkingNumber !== 0) {
     return defaultTargetLinkingNumber;
   }
-  const linkingNumbers = (0, _subfield8Utils.fieldsGetAllSubfield8LinkingNumbers)(fields);
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
   return linkingNumbers.length === 1 ? linkingNumbers[0] : 0;
 }
-function fieldsToNormalizedString(fields, defaultTargetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTag = false) {
+export function fieldsToNormalizedString(fields, defaultTargetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTag2 = false) {
   const targetLinkingNumber = guessTargetLinkingNumber(fields, defaultTargetLinkingNumber);
-  (0, _utils.nvdebug)(`fieldsToNormalizedString: OCC: ${normalizeOccurrenceNumber}`);
-  const strings = fields.map(field => fieldToNormalizedString(field, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTag));
+  nvdebug(`fieldsToNormalizedString: OCC: ${normalizeOccurrenceNumber}`);
+  const strings = fields.map((field) => fieldToNormalizedString(field, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTag2));
   strings.sort();
-  return strings.join('\t__SEPARATOR__\t');
-}
-
-/*
-
-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)}`);
-  const tmp = pairField ? fieldToString(pairField) : 'HUTI';
-  nvdebug(`PAIR: ${tmp}`);
-  nvdebug(`BASE:\n ${fieldsAsString.join('\n ')}`);
-  if (!fieldsAsString.includes(asString)) {
-    return;
-  }
-  nvdebug(`Duplicate $6 removal: ${fieldToString(field)}`);
-  record.removeField(field);
-
-  if (pairField === undefined) {
-    return;
-  }
-  nvdebug(`Duplicate $6 removal (pair): ${fieldToString(pairField)}`);
-  record.removeField(pairField);
+  return strings.join("	__SEPARATOR__	");
 }
-*/
-
 function getFirstField(record, fields) {
-  const fieldsAsStrings = fields.map(field => (0, _utils.fieldToString)(field));
-  //record.fields.forEach((field, i) => nvdebug(`${i}:\t${fieldToString(field)}`));
-  //nvdebug(`getFirstField: ${fieldsAsStrings.join('\t')}`);
-  const i = record.fields.findIndex(field => fieldsAsStrings.includes((0, _utils.fieldToString)(field)));
+  const fieldsAsStrings = fields.map((field) => fieldToString(field));
+  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)}`);
     return field;
   }
-  return undefined;
+  return void 0;
 }
 function isRelevantSubfield6Chain(fields) {
   if (fields.length < 2) {
-    // 1 non-880-field and 1+ 880 fields
     return false;
   }
-  const non880 = fields.filter(f => f.tag !== '880');
+  const non880 = fields.filter((f) => f.tag !== "880");
   if (non880.length !== 1) {
     return false;
   }
-  const linkingNumbers = (0, _subfield8Utils.fieldsGetAllSubfield8LinkingNumbers)(fields);
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
   if (linkingNumbers.length !== 0) {
     return false;
   }
-  return fields.every(f => (0, _utils.fieldHasSubfield)(f, '6'));
+  return fields.every((f) => fieldHasSubfield(f, "6"));
 }
-function fieldIsFirstFieldInChain(field, chain, record) {
-  // Interpretation of first: position of field in record (however, we might have a duplicate field. See tests...)
+export function fieldIsFirstFieldInChain(field, chain, record) {
   const firstField = getFirstField(record, chain);
   if (firstField) {
-    return (0, _utils.fieldToString)(field) === (0, _utils.fieldToString)(firstField);
+    return fieldToString(field) === fieldToString(firstField);
   }
   return false;
 }
-function getAllLinkedSubfield6Fields(field, record) {
+export function getAllLinkedSubfield6Fields(field, record) {
   const fields = get6s(field, record);
-  const moreFields = (0, _subfield8Utils.add8s)(fields, record);
-
-  // Currently we don't handle fields with more than one $6 and/or $8 subfield.
+  const moreFields = add8s(fields, record);
   if (moreFields.length > fields.length) {
-    return []; // Don't fix!
+    return [];
   }
   return moreFields;
 }
-function isFirstLinkedSubfield6Field(field, record) {
+export function isFirstLinkedSubfield6Field(field, record) {
   if (!field.subfields) {
-    // Is not a datafield
     return false;
   }
   const chain = getAllLinkedSubfield6Fields(field, record);
   if (!isRelevantSubfield6Chain(chain)) {
-    (0, _utils.nvdebug)(`Rejected 6: ${(0, _utils.fieldsToString)(chain)}`);
+    nvdebug(`Rejected 6: ${fieldsToString(chain)}`);
     return false;
   }
   return fieldIsFirstFieldInChain(field, chain, record);
 }
-function recordGetSubfield6ChainHeads(record) {
-  return record.fields.filter(field => isFirstLinkedSubfield6Field(field, record));
+export function recordGetSubfield6ChainHeads(record) {
+  return record.fields.filter((field) => isFirstLinkedSubfield6Field(field, record));
 }
-function recordGetMaxSubfield6OccurrenceNumberAsInteger(record) {
+export function recordGetMaxSubfield6OccurrenceNumberAsInteger(record) {
   if (record.fields.length === 0) {
     return 0;
   }
-  // Should we cache the value here?
-  const vals = record.fields.map(field => fieldGetMaxSubfield6OccurrenceNumberAsInteger(field));
+  const vals = record.fields.map((field) => fieldGetMaxSubfield6OccurrenceNumberAsInteger(field));
   return Math.max(...vals);
 }
-function get6s(field, candidateFields) {
-  // NB! Convert field to fields!!!
-  // Get all fields with given occurrence number
-  const sixes = field.subfields.filter(sf => isValidSubfield6(sf));
+export function get6s(field, candidateFields) {
+  const sixes = field.subfields.filter((sf) => isValidSubfield6(sf));
   if (sixes.length === 0) {
     return [field];
   }
-  (0, _utils.nvdebug)(`SIXES: ${sixes.length}`);
-  const occurrenceNumbers = sixes.map(sf => subfield6GetOccurrenceNumber(sf)).filter(value => value !== undefined && value !== '00');
-  (0, _utils.nvdebug)(occurrenceNumbers.join(' -- '));
-  const relevantFields = candidateFields.filter(f => occurrenceNumbers.some(o => fieldHasOccurrenceNumber(f, o)));
-  (0, _utils.nvdebug)(`${(0, _utils.fieldToString)(field)}: $6-RELFIELDS FOUND: ${relevantFields.length}...`);
-  relevantFields.forEach(f => (0, _utils.nvdebug)((0, _utils.fieldToString)(f))); // eslint-disable-line array-callback-return
+  nvdebug(`SIXES: ${sixes.length}`);
+  const occurrenceNumbers = sixes.map((sf) => subfield6GetOccurrenceNumber(sf)).filter((value) => value !== void 0 && value !== "00");
+  nvdebug(occurrenceNumbers.join(" -- "));
+  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)));
   return relevantFields;
 }
-function resetSubfield6Tag(subfield, tag) {
+export function resetSubfield6Tag(subfield, tag) {
   if (!isValidSubfield6(subfield)) {
     return;
   }
-  // NB! mainly for 1XX<->7XX transfers
   const newValue = `${tag}-${subfield.value.substring(4)}`;
-  (0, _utils.nvdebug)(`Set subfield $6 value from ${(0, _utils.subfieldToString)(subfield)} to ${newValue}`, debugDev);
+  nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`, debugDev);
   subfield.value = newValue;
 }
-//# sourceMappingURL=subfield6Utils.js.map
+//# sourceMappingURL=subfield6Utils.js.map