@natlibfi/melinda-record-matching 2.0.1-alpha.1 → 2.0.7-alpha.1

package/src/match-detection/features/bib/standard-identifier-factory.js

@@ -1,10 +1,11 @@
+/* eslint-disable max-statements */
 /**
 *
 * @licstart  The following is the entire license notice for the JavaScript code in this file.
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *
@@ -27,58 +28,142 @@
 */
 
 import createDebugLogger from 'debug';
+import {extractSubfieldsFromField, uniqueSubfields} from '../../../matching-utils';
 
-const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers');
-const debugData = debug.extend('data');
+// Note about validity of standardIdentifiers:
+// We have three types of invalid standardIdentifiers:
+// 1. Formally invalid standardIdentifiers (ie. typos either in the resource or the record)
+// 2. Formally valid standardIdentifiers that are used in a wrong resource
+// 3. Canceled standardIdentifiers
+
+// Matcher could and should check that a standardIdentifier found in a subfield for a valid identifier is formally valid, and if it's not formally valid, handle it as an invalid standardIdentifier
+// Formally valid standardIdentifiers found in subfield for invalid identifier cannot be handled as valid standardIdentifiers, because they can be a case of type 2) or 3) invalid standardIdentifiers
+// We could also do a separate handling for formally valid an formally invalid standardIdentifiers
+
+export default ({pattern, subfieldCodes, identifier, validIdentifierSubfieldCodes = ['a'], invalidIdentifierSubfieldCodes = ['z'], validatorAndNormalizer = undefined}) => {
+  const debug = createDebugLogger(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:${identifier}`);
+  const debugData = debug.extend('data');
 
-export default ({pattern, subfieldCodes}) => {
   return {extract, compare};
 
-  function extract(record) {
-    const [field] = record.get(pattern);
+  function extract({record, recordExternal}) {
+    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+    const fields = record.get(pattern);
+    debugData(`${label}: ${fields.length} ${identifier}-fields `);
+
+    // extractIdentifierSubfield normalizes hyphens away from the subfield values
+    const identifiersFromFields = fields.map(field => extractSubfieldsFromField(field, subfieldCodes));
+    debugData(`${label}: IDs from fields (${identifiersFromFields.length}): ${JSON.stringify(identifiersFromFields)}`);
+    const allIdentifiers = identifiersFromFields.flat();
+    debugData(`${label}: Flat IDs from fields (${allIdentifiers.length}): ${JSON.stringify(allIdentifiers)}`);
+
+    const validatedAndNormalizedIdentifiers = validateAndNormalizeIdentifiers({identifierSubs: allIdentifiers, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes});
 
-    if (field) {
-      return field.subfields
-        .filter(({code}) => subfieldCodes.includes(code))
-        .map(({code, value}) => ({code, value: value.replace(/-/ug, '')}));
+    const identifiers = uniqueSubfields(validatedAndNormalizedIdentifiers);
+
+    debugData(`${label}: Unique IDs from fields (${identifiers.length}): ${JSON.stringify(identifiers)}`);
+    return identifiers;
+
+    function validateAndNormalizeIdentifiers({identifierSubs, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}) {
+      if (validatorAndNormalizer) {
+        return identifierSubs.map((idSub) => validateAndNormalizeIdentifier({idSub, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}));
+      }
+      return identifierSubs.map((idSub) => normalizeHyphens(idSub));
     }
 
-    return [];
+    function validateAndNormalizeIdentifier({idSub, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}) {
+      const {valid, value} = validatorAndNormalizer(idSub.value);
+      if (validIdentifierSubfieldCodes.includes(idSub.code) && valid === false) {
+        const [code] = invalidIdentifierSubfieldCodes;
+        return {code, value};
+      }
+      return {code: idSub.code, value};
+    }
+
+    function normalizeHyphens(idSub) {
+      return {code: idSub.code, value: idSub.value.replace(/-/ug, '')};
+    }
+
+
   }
 
   function compare(a, b) {
+    debug(`Comparing A and B`);
     if (a.length === 0 || b.length === 0) {
-      debugData(`No standardidentifiers to compare`);
+      debugData(`No standardidentifiers (${identifier}) to compare`);
       return 0;
     }
 
+    debugData(`A: ${JSON.stringify(a)}`);
+    debugData(`B: ${JSON.stringify(b)}`);
+
+
     if (bothHaveValidIdentifiers()) {
-      const {maxValues, matchingValues} = getValueCount(true);
-      return matchingValues / maxValues * 0.75;
-    }
+      // Compare only valid identifiers, if both have valid idenfiers
+      const {maxValues, possibleMatchValues, matchingValues} = getValueCount(true);
+      if (matchingValues < 1) {
+        debug(`Both have valid standardidentifiers (${identifier}), but none of these match.`);
+        return -0.75;
+      }
+      debug(`Both have valid standardidentifiers (${identifier}), ${matchingValues}/${possibleMatchValues} valid identifiers match.`);
+      // ignore non-matches if there is mismatching amount of values
+      debug(`Possible matches: ${possibleMatchValues}/${maxValues}`);
+      //we give some kind of penalty for mismatching amount of values instead of simple divide?
+      const penaltyForMissing = 0.1 * (maxValues - possibleMatchValues);
+      const penaltyForMisMatch = 0.2 * (possibleMatchValues - matchingValues);
+      debug(`\t points: penaltyForMissing: ${penaltyForMissing}`);
+      debug(`\t points: penaltyForMisMatch: ${penaltyForMisMatch}`);
 
+      return 0.75 - penaltyForMisMatch - penaltyForMissing;
+      //return matchingValues / possibleMatchValues * 0.75;
+    }
+    // If both do not have valid identifiers, compare all identifiers
     const {maxValues, matchingValues} = getValueCount();
+    debug(`Both do NOT have valid standardidentifiers (${identifier}), ${matchingValues}/${maxValues} valid/invalid identifiers match.`);
+
     return matchingValues / maxValues * 0.2;
 
     function bothHaveValidIdentifiers() {
-      const aValues = a.filter(({code}) => code === 'a');
-      const bValues = a.filter(({code}) => code === 'a');
+      const aValues = a.filter(({code}) => validIdentifierSubfieldCodes.includes(code));
+      const bValues = a.filter(({code}) => validIdentifierSubfieldCodes.includes(code));
+      debug(`A: ${aValues.length} valid ${identifier} identifiers`);
+      debug(`B: ${bValues.length} valid ${identifier} identifiers`);
       return aValues.length > 0 && bValues.length > 0;
     }
 
     function getValueCount(validOnly = false) {
-      const aValues = getIdentifiers(a);
-      const bValues = getIdentifiers(b);
+      const aValues = getIdentifiers(a, validOnly);
+      const bValues = getIdentifiers(b, validOnly);
+
+      const matchingValues = getMatchingValuesAmount(aValues, bValues);
 
       return {
         maxValues: aValues.length > bValues.length ? aValues.length : bValues.length,
-        matchingValues: aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length
+        // possibleMatchingValues: amount of identifiers in set of less identifiers (we cannot more values than these)
+        possibleMatchValues: aValues.length > bValues.length ? bValues.length : aValues.length,
+        matchingValues
       };
 
-      function getIdentifiers(values) {
+      function getMatchingValuesAmount(aValues, bValues) {
+        if (bValues.length > aValues.length) {
+          return aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;
+        }
+        if (aValues.length > bValues.length) {
+          return bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;
+        }
+
+        // If we have same amount of values, we'll check matches both ways, to avoid mixups in cases
+        // there would be duplicate values
+        const aToB = aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;
+        const bToA = bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;
+
+        return aToB < bToA ? aToB : bToA;
+      }
+
+      function getIdentifiers(values, validOnly) {
         if (validOnly) {
           return values
-            .filter(({code}) => code === 'a')
+            .filter(({code}) => validIdentifierSubfieldCodes.includes(code))
             .map(({value}) => value);
         }
 

package/src/match-detection/features/bib/title-version-original.js

@@ -0,0 +1,78 @@
+/**
+*
+* @licstart  The following is the entire license notice for the JavaScript code in this file.
+*
+* Melinda record matching modules for Javascript
+*
+* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+*
+* This file is part of melinda-record-matching-js
+*
+* melinda-record-matching-js program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as
+* published by the Free Software Foundation, either version 3 of the
+* License, or (at your option) any later version.
+*
+* melinda-record-matching-js is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* @licend  The above is the entire license notice
+* for the JavaScript code in this file.
+*
+*/
+
+import createDebugLogger from 'debug';
+import {LevenshteinDistance as leven} from 'natural';
+
+export default ({treshold = 10} = {}) => ({
+  name: 'titleVersionOriginal',
+  extract: ({record}) => {
+    const title = getTitle();
+
+    if (title) {
+      return [title.replace(/[^\p{Letter}\p{Number}]/gu, '').toLowerCase()];
+    }
+
+    return [];
+
+    function getTitle() {
+      const [field] = record.get(/^245$/u);
+
+      if (field) {
+        return field.subfields
+          .filter(({code}) => ['a', 'b'].includes(code))
+          .map(({value}) => value)
+          .join('');
+      }
+    }
+  },
+  compare: (a, b) => {
+    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/title-version-original');
+    const distance = leven(a[0], b[0]);
+
+    if (distance === 0) {
+      return 0.5;
+    }
+
+    const maxLength = getMaxLength();
+    const percentage = distance / maxLength * 100;
+
+    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);
+
+    if (percentage <= treshold) {
+      return 0.3;
+    }
+
+    return -0.5;
+
+    function getMaxLength() {
+      return a[0].length > b[0].length ? a[0].length : b[0].length;
+    }
+
+  }
+});

package/src/match-detection/features/bib/title.js

@@ -4,7 +4,7 @@
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *
@@ -26,29 +26,49 @@
 *
 */
 
-import createDebugLogger from 'debug';
+
 import {LevenshteinDistance as leven} from 'natural';
+import {testStringOrNumber} from '../../../matching-utils';
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:title');
+const debugData = debug.extend('data');
+
 
 export default ({treshold = 10} = {}) => ({
   name: 'Title',
-  extract: record => {
+  extract: ({record, recordExternal}) => {
+    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
     const title = getTitle();
+    debug(`${label} title: ${title}`);
 
-    if (title) {
-      return [title.replace(/[^\p{Letter}\p{Number}]/gu, '').toLowerCase()];
+    if (testStringOrNumber(title)) {
+      const titleAsNormalizedString = String(title)
+        // decompose unicode diacritics
+        .normalize('NFD')
+        // strip non-letters/numbers
+        // - note: combined with decomposing unicode diactics this normalizes both 'saa' and 'sää' as 'saa'
+        // - we could precompose the finnish letters back to avoid this
+        .replace(/[^\p{Letter}\p{Number}]/gu, '')
+        .toLowerCase();
+      debug(`${label} titleString: ${titleAsNormalizedString}`);
+      return [titleAsNormalizedString];
     }
 
     return [];
 
     function getTitle() {
       const [field] = record.get(/^245$/u);
+      debugData(`${label} titleField: ${JSON.stringify(field)}`);
 
       if (field) {
         return field.subfields
-          .filter(({code}) => ['a', 'b'].includes(code))
-          .map(({value}) => value)
+          // get also $n:s and $p:s here
+          .filter(({code}) => ['a', 'b', 'n', 'p'].includes(code))
+          .map(({value}) => testStringOrNumber(value) ? String(value) : '')
           .join('');
       }
+      return false;
     }
   },
   compare: (a, b) => {

package/src/match-detection/index.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 /**
 *
 * @licstart  The following is the entire license notice for the JavaScript code in this file.
@@ -32,40 +31,78 @@ import * as features from './features';
 
 export {features};
 
-// eslint-disable-next-line max-statements
-export default ({strategy, treshold = 0.9}) => (recordA, recordB) => {
+export default ({strategy, treshold = 0.9}, returnStrategy = false, localSettings = {}) => ({recordA, recordB, recordAExternal = {}, recordBExternal = {}}) => {
   const minProbabilityQuantifier = 0.5;
 
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection');
   const debugData = debug.extend('data');
-  const featuresA = extractFeatures(recordA);
-  const featuresB = extractFeatures(recordB);
 
-  debugData(`Features (a): ${JSON.stringify(featuresA)}`);
-  debugData(`Features (b): ${JSON.stringify(featuresB)}`);
+  debugData(`Strategy: ${JSON.stringify(strategy)}, Treshold: ${JSON.stringify(treshold)}, ReturnStrategy: ${JSON.stringify(returnStrategy)}`);
+  debugData(`Records: A: ${recordA}\nB: ${recordB}`);
+  debug(`Externals: A: ${JSON.stringify(recordAExternal)}, B: ${JSON.stringify(recordBExternal)}`);
+  // We could add here labels for records if we didn't get external labels
 
-  const featurePairs = generateFeaturePairs();
-  const similarityVector = generateSimilarityVector();
+  const featuresA = extractFeatures({record: recordA, recordExternal: recordAExternal, localSettings});
 
-  if (similarityVector.some(v => v >= minProbabilityQuantifier)) {
-    const probability = calculateprobability();
-    debug(`probability: ${probability} (Treshold: ${treshold})`);
-    return {match: probability >= treshold, probability};
+  debug(`We got an array of records: ${Array.isArray(recordB)}`);
+  const recordsB = Array.isArray(recordB) ? recordB : [recordB];
+  const recordsBExternal = Array.isArray(recordB) ? recordBExternal : [recordBExternal];
+
+  const detectionResults = recordsB.map((record, index) => actualDetection({featuresA, recordAExternal, record, recordExternal: recordsBExternal[index], index}));
+
+  // if we got array of records, we return an array of result
+  // if we got a singular record, we return a singular result
+  return Array.isArray(recordB) ? detectionResults : detectionResults[0];
+
+  function actualDetection({featuresA, record, recordExternal, index, localSettings}) {
+    const labelA = recordAExternal && recordAExternal.label ? recordAExternal.label : 'a';
+    const labelB = recordExternal && recordExternal.label ? recordExternal.label : 'b';
+
+
+    debug(`Actual detection for record ${index + 1} ${labelB}`);
+    const featuresB = extractFeatures({record, recordExternal, localSettings});
+
+    debugData(`Features (a: ${labelA}): ${JSON.stringify(featuresA)}`);
+    debugData(`Features (b: ${labelB}): ${JSON.stringify(featuresB)}`);
+
+    const featurePairs = generateFeaturePairs(featuresA, featuresB);
+    const similarityVector = generateSimilarityVector(featurePairs);
+
+    if (similarityVector.some(v => v >= minProbabilityQuantifier)) {
+      const probability = calculateProbability(similarityVector);
+      debug(`probability: ${probability} (Treshold: ${treshold})`);
+      return returnResult({match: probability >= treshold, probability});
+    }
+
+    debugData(`No feature yielded minimum probability amount of points (${minProbabilityQuantifier})`);
+    return returnResult({match: false, probability: 0.0});
   }
 
-  debugData(`No feature yielded minimum probability amount of points (${minProbabilityQuantifier})`);
-  return {match: false, probability: 0.0};
+  function extractFeatures({record, recordExternal}) {
+    return strategy.reduce((acc, {name, extract}) => acc.concat({name, value: extract({record, recordExternal})}), []);
+  }
 
-  function calculateprobability() {
-    const probability = similarityVector.reduce((acc, v) => acc + v, 0.0);
-    return probability > 1.0 ? 1.0 : probability;
+  function returnResult(result) {
+    if (returnStrategy) {
+      debug(`Returning detection strategy with the result`);
+      const resultWithStrategy = {match: result.match, probability: result.probability, strategy: formatStrategy(strategy), treshold};
+      debugData(`${JSON.stringify(resultWithStrategy)}`);
+      return resultWithStrategy;
+    }
+    return result;
   }
 
-  function extractFeatures(record) {
-    return strategy.reduce((acc, {name, extract}) => acc.concat({name, value: extract(record)}), []);
+  function formatStrategy(strategy) {
+    const strategyNames = strategy.map(element => element.name);
+    return strategyNames || [];
   }
 
-  function generateSimilarityVector() {
+  function calculateProbability(similarityVector) {
+    const probability = similarityVector.reduce((acc, v) => acc + v, 0.0);
+    return probability > 1.0 ? 1.0 : probability;
+  }
+
+  function generateSimilarityVector(featurePairs) {
     const compared = featurePairs.map(({name, a, b}) => {
       const {compare} = strategy.find(({name: featureName}) => name === featureName);
       const points = compare(a, b);
@@ -76,7 +113,7 @@ export default ({strategy, treshold = 0.9}) => (recordA, recordB) => {
     return compared.map(({points}) => points);
   }
 
-  function generateFeaturePairs() {
+  function generateFeaturePairs(featuresA, featuresB) {
     const pairs = generatePairs();
     const missingFeatures = findMissing();
 
@@ -105,4 +142,5 @@ export default ({strategy, treshold = 0.9}) => (recordA, recordB) => {
         .filter(v => pairs.some(({name}) => name === v) === false);
     }
   }
+
 };

package/src/match-detection/index.spec.js

@@ -32,6 +32,11 @@ import {expect} from 'chai';
 import {MarcRecord} from '@natlibfi/marc-record';
 import * as features from './features';
 import createDetectionInterface from '.';
+import {inspect} from 'util';
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:test');
+const debugData = debug.extend('data');
 
 describe('match-detection', () => {
   generateTests({
@@ -41,16 +46,25 @@ describe('match-detection', () => {
     fixura: {
       reader: READERS.JSON
     },
-    callback: ({getFixture, options, expectedResults, enabled = true}) => {
+    callback: ({getFixture, options, expectedResults, array, enabled = true}) => {
 
       if (!enabled) {
+        debug(`*** DISABLED TEST! ***`);
         return;
       }
 
       const detect = createDetectionInterface(formatOptions());
-      const recordA = new MarcRecord(getFixture('recordA.json'));
-      const recordB = new MarcRecord(getFixture('recordB.json'));
-      const results = detect(recordA, recordB);
+      const recordA = new MarcRecord(getFixture('recordA.json'), {subfieldValues: false});
+      debugData(inspect(recordA));
+
+      debug(`Our recordB is an array of records: ${array}`);
+      const recordB = array
+        ? getFixture('recordB.json').map(recordJson => new MarcRecord(recordJson, {subfieldValues: false}))
+        : new MarcRecord(getFixture('recordB.json'), {subfieldValues: false});
+      debugData(inspect(recordB));
+
+      const results = detect({recordA, recordB});
+      debugData(`${JSON.stringify(results)}`);
 
       expect(results).to.eql(expectedResults);
 

package/src/matching-utils.js

@@ -4,7 +4,7 @@
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *
@@ -31,7 +31,6 @@ import createDebugLogger from 'debug';
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:utils');
 const debugData = debug.extend('data');
 
-// eslint-disable-next-line max-statements
 export function getMelindaIdsF035(record) {
 
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:melinda-id');
@@ -58,8 +57,8 @@ export function getMelindaIdsF035(record) {
 
     return subfields
       .filter(sub => ['a', 'z'].includes(sub.code))
-      .filter(sub => melindaIdRegExp.test(sub.value))
-      .map(({value}) => value.replace(melindaIdRegExp, '$<id>'));
+      .filter(sub => testStringOrNumber(sub.value) && melindaIdRegExp.test(String(sub.value)))
+      .map(({value}) => testStringOrNumber(value) ? String(value).replace(melindaIdRegExp, '$<id>') : '');
 
   }
 }
@@ -81,6 +80,64 @@ function countSubfields(field, subfieldCode) {
 
 export function getSubfieldValues(field, subfieldCode) {
   debugData(`Get subfield(s) $${subfieldCode} from ${JSON.stringify(field)}`);
-  return field.subfields.filter(({code}) => code === subfieldCode).map(({value}) => value);
+  return field.subfields
+    .filter(({code}) => code === subfieldCode)
+    .map(({value}) => testStringOrNumber(value) ? String(value) : '')
+    .filter(value => value);
 }
 
+export function testStringOrNumber(value) {
+  if (typeof value === 'string' || typeof value === 'number') {
+    return true;
+  }
+  return false;
+}
+
+export function extractSubfieldsFromField(field, subfieldCodes) {
+  if (field === undefined || field.subfields === undefined) {
+    return [];
+  }
+  const resultSubfields = field.subfields
+    .filter(({code}) => subfieldCodes.includes(code))
+    .map(({code, value}) => ({code, value: testStringOrNumber(value) ? String(value) : ''}))
+    .filter(value => value);
+  return resultSubfields;
+}
+
+export function uniqueSubfields(subfields) {
+  return subfields.reduce((arr, e) => {
+    if (!arr.find(item => item.code === e.code && item.value === e.value)) {
+      const newArr = arr.concat(e);
+      return newArr;
+    }
+    return arr;
+  }, []);
+}
+
+export function getMatchCounts(aValues, bValues) {
+
+  const matchingValues = getMatchingValuesAmount(aValues, bValues);
+
+  return {
+    maxValues: aValues.length > bValues.length ? aValues.length : bValues.length,
+    // possibleMatchingValues: amount of identifiers in set of less identifiers (we cannot more values than these)
+    possibleMatchValues: aValues.length > bValues.length ? bValues.length : aValues.length,
+    matchingValues
+  };
+
+  function getMatchingValuesAmount(aValues, bValues) {
+    if (bValues.length > aValues.length) {
+      return aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;
+    }
+    if (aValues.length > bValues.length) {
+      return bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;
+    }
+
+    // If we have same amount of values, we'll check matches both ways, to avoid mixups in cases
+    // there would be duplicate values
+    const aToB = aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;
+    const bToA = bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;
+
+    return aToB < bToA ? aToB : bToA;
+  }
+}