cmpstr 3.1.0 → 3.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023-2025 Paul Köhler (komed3)
+Copyright (c) 2023-2026 Paul Köhler (komed3)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -79,4 +79,4 @@ Try out or use CmpStr on the terminal. Install the **[cmpstr-cli](https://npmjs.
 
 The full documentation, API reference and advanced usage examples are available in the [GitHub Wiki](https://github.com/komed3/cmpstr/wiki).
 
-**LICENSE MIT © 2023-2025 PAUL KÖHLER (KOMED3)**
+**LICENSE MIT © 2023-2026 PAUL KÖHLER (KOMED3)**

package/dist/CmpStr.esm.js

@@ -1,5 +1,5 @@
 /**
- * CmpStr v3.1.0 build-76aadb9-260117
+ * CmpStr v3.1.1 build-a140f52-260119
  * This is a lightweight, fast and well performing library for calculating string similarity.
  * (c) 2023-2026 Paul Köhler @komed3 / MIT License
  * Visit https://github.com/komed3/cmpstr and https://npmjs.org/package/cmpstr
@@ -663,11 +663,11 @@ class Hasher {
     const chunks = Math.floor(len / 4);
     for (let i = 0; i < chunks; i++) {
       const pos = i * 4;
-      const chunk =
-        str.charCodeAt(pos) |
-        (str.charCodeAt(pos + 1) << 8) |
-        (str.charCodeAt(pos + 2) << 16) |
-        (str.charCodeAt(pos + 3) << 24);
+      const c0 = str.charCodeAt(pos);
+      const c1 = str.charCodeAt(pos + 1);
+      const c2 = str.charCodeAt(pos + 2);
+      const c3 = str.charCodeAt(pos + 3);
+      const chunk = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
       hash ^= chunk;
       hash *= this.FNV_PRIME;
     }
@@ -881,7 +881,7 @@ class Pool {
   static CONFIG = {
     uint16: {
       type: 'uint16',
-      maxSize: 32,
+      maxSize: 64,
       maxItemSize: 2048,
       allowOversize: true
     },
@@ -893,7 +893,7 @@ class Pool {
     },
     'string[]': {
       type: 'string[]',
-      maxSize: 4,
+      maxSize: 2,
       maxItemSize: 1024,
       allowOversize: false
     },
@@ -901,9 +901,9 @@ class Pool {
     map: { type: 'map', maxSize: 8, maxItemSize: 0, allowOversize: false }
   };
   static POOLS = {
-    uint16: new RingPool(32),
+    uint16: new RingPool(64),
     'number[]': new RingPool(16),
-    'string[]': new RingPool(4),
+    'string[]': new RingPool(2),
     set: new RingPool(8),
     map: new RingPool(8)
   };
@@ -912,7 +912,7 @@ class Pool {
       case 'uint16':
         return new Uint16Array(size);
       case 'number[]':
-        return new Array(size).fill(0);
+        return new Float64Array(size);
       case 'string[]':
         return new Array(size);
       case 'set':
@@ -979,39 +979,51 @@ class StructuredData {
   normalizeResults(results) {
     if (!Array.isArray(results) || results.length === 0) return [];
     const first = results[0];
-    if (this.isMetricResult(first)) return results;
-    if (this.isCmpStrResult(first))
-      return results.map((r) => ({
+    let normalized = [];
+    if (this.isMetricResult(first)) normalized = results;
+    else if (this.isCmpStrResult(first)) {
+      normalized = results.map((r) => ({
         metric: 'unknown',
         a: r.source,
         b: r.target,
         res: r.match,
         raw: r.raw
       }));
-    return [];
+    }
+    return normalized.map((r, idx) => ({ ...r, __idx: idx }));
   }
   rebuild(results, sourceData, extractedStrings, removeZero, objectsOnly) {
+    const stringToIndices = new Map();
+    for (let i = 0; i < extractedStrings.length; i++) {
+      const str = extractedStrings[i];
+      if (!stringToIndices.has(str)) stringToIndices.set(str, []);
+      stringToIndices.get(str).push(i);
+    }
     const output = new Array(results.length);
+    const occurrenceCount = new Map();
     let out = 0;
     for (let i = 0; i < results.length; i++) {
       const result = results[i];
       if (removeZero && result.res === 0) continue;
-      let dataIndex =
-        result.b && extractedStrings.length
-          ? extractedStrings.indexOf(result.b)
-          : i;
-      if (dataIndex < 0 || dataIndex >= sourceData.length) dataIndex = i;
+      const targetStr = result.b || '';
+      const indices = stringToIndices.get(targetStr);
+      let dataIndex;
+      if (indices && indices.length > 0) {
+        const occurrence = occurrenceCount.get(targetStr) ?? 0;
+        occurrenceCount.set(targetStr, occurrence + 1);
+        dataIndex = indices[occurrence % indices.length];
+      } else {
+        dataIndex = result.__idx ?? i;
+      }
+      if (dataIndex < 0 || dataIndex >= sourceData.length) continue;
       const sourceObj = sourceData[dataIndex];
+      const mappedTarget = extractedStrings[dataIndex] || targetStr;
       if (objectsOnly) output[out++] = sourceObj;
       else
         output[out++] = {
           obj: sourceObj,
           key: this.key,
-          result: {
-            source: result.a,
-            target: extractedStrings[dataIndex] || result.b,
-            match: result.res
-          },
+          result: { source: result.a, target: mappedTarget, match: result.res },
           ...(result.raw ? { raw: result.raw } : null)
         };
     }