cmpstr 3.2.1 → 3.2.2

package/dist/cjs/utils/Normalizer.cjs

@@ -1,6 +1,7 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
+var Errors = require('./Errors.cjs');
 var HashTable = require('./HashTable.cjs');
 
 class Normalizer {
@@ -17,42 +18,62 @@ class Normalizer {
     return Array.from(new Set(flags)).sort().join('');
   }
   static getPipeline(flags) {
-    if (Normalizer.pipeline.has(flags)) return Normalizer.pipeline.get(flags);
-    const { REGEX } = Normalizer;
-    const steps = [
-      ['d', (s) => s.normalize('NFD')],
-      ['i', (s) => s.toLowerCase()],
-      ['k', (s) => s.replace(REGEX.nonLetters, '')],
-      ['n', (s) => s.replace(REGEX.nonNumbers, '')],
-      ['r', (s) => s.replace(REGEX.doubleChars, '$1')],
-      ['s', (s) => s.replace(REGEX.specialChars, '')],
-      ['t', (s) => s.trim()],
-      ['u', (s) => s.normalize('NFC')],
-      ['w', (s) => s.replace(REGEX.whitespace, ' ')],
-      ['x', (s) => s.normalize('NFKC')]
-    ];
-    const pipeline = steps
-      .filter(([f]) => flags.includes(f))
-      .map(([, fn]) => fn);
-    const fn = (s) => pipeline.reduce((v, f) => f(v), s);
-    Normalizer.pipeline.set(flags, fn);
-    return fn;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        if (Normalizer.pipeline.has(flags))
+          return Normalizer.pipeline.get(flags);
+        const { REGEX } = Normalizer;
+        const steps = [
+          ['d', (s) => s.normalize('NFD')],
+          ['i', (s) => s.toLowerCase()],
+          ['k', (s) => s.replace(REGEX.nonLetters, '')],
+          ['n', (s) => s.replace(REGEX.nonNumbers, '')],
+          ['r', (s) => s.replace(REGEX.doubleChars, '$1')],
+          ['s', (s) => s.replace(REGEX.specialChars, '')],
+          ['t', (s) => s.trim()],
+          ['u', (s) => s.normalize('NFC')],
+          ['w', (s) => s.replace(REGEX.whitespace, ' ')],
+          ['x', (s) => s.normalize('NFKC')]
+        ];
+        const pipeline = steps
+          .filter(([f]) => flags.includes(f))
+          .map(([, fn]) => fn);
+        const fn = (s) => pipeline.reduce((v, f) => f(v), s);
+        Normalizer.pipeline.set(flags, fn);
+        return fn;
+      },
+      `Failed to create normalization pipeline for flags: ${flags}`,
+      { flags }
+    );
   }
   static normalize(input, flags) {
-    if (!flags || typeof flags !== 'string' || !input) return input;
-    flags = this.canonicalFlags(flags);
-    if (Array.isArray(input))
-      return input.map((s) => Normalizer.normalize(s, flags));
-    const key = Normalizer.cache.key(flags, [input]);
-    if (key && Normalizer.cache.has(key)) return Normalizer.cache.get(key);
-    const res = Normalizer.getPipeline(flags)(input);
-    if (key) Normalizer.cache.set(key, res);
-    return res;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        if (!flags || typeof flags !== 'string' || !input) return input;
+        flags = this.canonicalFlags(flags);
+        if (Array.isArray(input))
+          return input.map((s) => Normalizer.normalize(s, flags));
+        const key = Normalizer.cache.key(flags, [input]);
+        if (key && Normalizer.cache.has(key)) return Normalizer.cache.get(key);
+        const res = Normalizer.getPipeline(flags)(input);
+        if (key) Normalizer.cache.set(key, res);
+        return res;
+      },
+      `Failed to normalize input with flags: ${flags}`,
+      { input, flags }
+    );
   }
   static async normalizeAsync(input, flags) {
-    return await (Array.isArray(input)
-      ? Promise.all(input.map((s) => Normalizer.normalize(s, flags)))
-      : Promise.resolve(Normalizer.normalize(input, flags)));
+    return await Errors.ErrorUtil.wrapAsync(
+      async () => {
+        if (!flags || typeof flags !== 'string' || !input) return input;
+        return await (Array.isArray(input)
+          ? Promise.all(input.map((s) => Normalizer.normalize(s, flags)))
+          : Promise.resolve(Normalizer.normalize(input, flags)));
+      },
+      `Failed to asynchronously normalize input with flags: ${flags}`,
+      { input, flags }
+    );
   }
   static clear() {
     Normalizer.pipeline.clear();
@@ -61,4 +82,3 @@ class Normalizer {
 }
 
 exports.Normalizer = Normalizer;
-//# sourceMappingURL=Normalizer.cjs.map

package/dist/cjs/utils/Pool.cjs

@@ -1,6 +1,8 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
+var Errors = require('./Errors.cjs');
+
 class RingPool {
   maxSize;
   buffers = [];
@@ -9,22 +11,37 @@ class RingPool {
     this.maxSize = maxSize;
   }
   acquire(minSize, allowOversize) {
-    const len = this.buffers.length;
-    for (let i = 0; i < len; i++) {
-      const idx = (this.pointer + i) & (len - 1);
-      const item = this.buffers[idx];
-      if (item.size >= minSize && (allowOversize || item.size === minSize)) {
-        this.pointer = (idx + 1) & (len - 1);
-        return item;
-      }
-    }
-    return null;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        const len = this.buffers.length;
+        for (let i = 0; i < len; i++) {
+          const idx = (this.pointer + i) & (len - 1);
+          const item = this.buffers[idx];
+          if (
+            item.size >= minSize &&
+            (allowOversize || item.size === minSize)
+          ) {
+            this.pointer = (idx + 1) & (len - 1);
+            return item;
+          }
+        }
+        return null;
+      },
+      `Failed to acquire buffer of size >= ${minSize} from pool`,
+      { minSize, allowOversize }
+    );
   }
   release(item) {
-    if (this.buffers.length < this.maxSize)
-      return void [this.buffers.push(item)];
-    this.buffers[this.pointer] = item;
-    this.pointer = (this.pointer + 1) % this.maxSize;
+    Errors.ErrorUtil.wrap(
+      () => {
+        if (this.buffers.length < this.maxSize)
+          return void [this.buffers.push(item)];
+        this.buffers[this.pointer] = item;
+        this.pointer = (this.pointer + 1) % this.maxSize;
+      },
+      `Failed to release buffer back to pool`,
+      { item }
+    );
   }
   clear() {
     this.buffers = [];
@@ -77,6 +94,10 @@ class Pool {
   }
   static acquire(type, size) {
     const CONFIG = this.CONFIG[type];
+    if (!CONFIG)
+      throw new Errors.CmpStrUsageError(`Unsupported pool type <${type}>`, {
+        type
+      });
     if (size > CONFIG.maxItemSize) return this.allocate(type, size);
     const item = this.POOLS[type].acquire(size, CONFIG.allowOversize);
     if (item)
@@ -87,10 +108,13 @@ class Pool {
     return sizes.map((size) => this.acquire(type, size));
   }
   static release(type, buffer, size) {
-    if (size <= this.CONFIG[type].maxItemSize)
-      this.POOLS[type].release({ buffer, size });
+    const CONFIG = this.CONFIG[type];
+    if (!CONFIG)
+      throw new Errors.CmpStrUsageError(`Unsupported pool type <${type}>`, {
+        type
+      });
+    if (size <= CONFIG.maxItemSize) this.POOLS[type].release({ buffer, size });
   }
 }
 
 exports.Pool = Pool;
-//# sourceMappingURL=Pool.cjs.map

package/dist/cjs/utils/Profiler.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 class Profiler {
@@ -81,4 +81,3 @@ class Profiler {
 }
 
 exports.Profiler = Profiler;
-//# sourceMappingURL=Profiler.cjs.map

package/dist/cjs/utils/Registry.cjs

@@ -1,22 +1,39 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
+var Errors = require('./Errors.cjs');
+
 const registry = Object.create(null);
 const factory = Object.create(null);
 function Registry(reg, ctor) {
-  if (reg in registry || reg in factory)
-    throw new Error(
-      `Registry <${reg}> already exists / overwriting is forbidden`
-    );
+  Errors.ErrorUtil.assert(
+    !(reg in registry || reg in factory),
+    `Registry <${reg}> already exists / overwriting is forbidden`,
+    { registry: reg }
+  );
   const classes = Object.create(null);
   const service = Object.freeze({
     add(name, cls, update = false) {
-      if (!(cls.prototype instanceof ctor))
-        throw new TypeError(`Class must extend <${reg}>`);
-      if (!update && name in classes)
-        throw new Error(
-          `Entry <${name}> already exists / use <update=true> to overwrite`
-        );
+      Errors.ErrorUtil.assert(
+        typeof name === 'string' && name.length > 0,
+        `Class name must be a non-empty string`,
+        { registry: reg, name }
+      );
+      Errors.ErrorUtil.assert(
+        typeof cls === 'function',
+        `Class must be a constructor function`,
+        { registry: reg, class: cls }
+      );
+      Errors.ErrorUtil.assert(
+        cls.prototype instanceof ctor,
+        `Class must extend <${reg}>`,
+        { registry: reg, class: cls }
+      );
+      Errors.ErrorUtil.assert(
+        update || !(name in classes),
+        `Class <${name}> already exists / use <update=true> to overwrite`,
+        { registry: reg, name }
+      );
       classes[name] = cls;
     },
     remove(name) {
@@ -29,8 +46,16 @@ function Registry(reg, ctor) {
       return Object.keys(classes);
     },
     get(name) {
-      if (!(name in classes))
-        throw new Error(`Class <${name}> not registered for <${reg}>`);
+      Errors.ErrorUtil.assert(
+        typeof name === 'string' && name.length > 0,
+        `Class name must be a non-empty string`,
+        { registry: reg, name }
+      );
+      Errors.ErrorUtil.assert(
+        name in classes,
+        `Class <${name}> not registered for <${reg}>`,
+        { registry: reg, name }
+      );
       return classes[name];
     }
   });
@@ -40,18 +65,18 @@ function Registry(reg, ctor) {
 }
 function resolveCls(reg, cls) {
   if (!(reg in registry))
-    throw new ReferenceError(`Registry <${reg}> does not exist`);
+    throw new Errors.CmpStrNotFoundError(`Registry <${reg}> does not exist`, {
+      registry: reg
+    });
   return typeof cls === 'string' ? registry[reg]?.get(cls) : cls;
 }
 function createFromRegistry(reg, cls, ...args) {
   cls = resolveCls(reg, cls);
-  try {
-    return new cls(...args);
-  } catch (err) {
-    throw new Error(`Cannot instantiate class <${cls.name ?? cls}>`, {
-      cause: err
-    });
-  }
+  return Errors.ErrorUtil.wrap(
+    () => new cls(...args),
+    `Failed to create instance of class <${cls.name ?? cls}> from registry <${reg}>`,
+    { registry: reg, class: cls, args }
+  );
 }
 
 exports.Registry = Registry;
@@ -59,4 +84,3 @@ exports.createFromRegistry = createFromRegistry;
 exports.factory = factory;
 exports.registry = registry;
 exports.resolveCls = resolveCls;
-//# sourceMappingURL=Registry.cjs.map

package/dist/cjs/utils/StructuredData.cjs

@@ -1,6 +1,7 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
+var Errors = require('./Errors.cjs');
 var Pool = require('./Pool.cjs');
 
 class StructuredData {
@@ -50,7 +51,7 @@ class StructuredData {
         raw: r.raw
       }));
     else
-      throw new TypeError(
+      throw new Errors.CmpStrValidationError(
         'Unsupported result format for StructuredData normalization.'
       );
     return normalized.map((r, idx) => ({ ...r, __idx: idx }));
@@ -108,10 +109,18 @@ class StructuredData {
     );
   }
   performLookup(fn, extractedStrings, opt) {
-    return this.finalizeLookup(fn(), extractedStrings, opt);
+    return Errors.ErrorUtil.wrap(
+      () => this.finalizeLookup(fn(), extractedStrings, opt),
+      'StructuredData lookup failed',
+      { key: this.key }
+    );
   }
   async performLookupAsync(fn, extractedStrings, opt) {
-    return this.finalizeLookup(await fn(), extractedStrings, opt);
+    return await Errors.ErrorUtil.wrapAsync(
+      async () => this.finalizeLookup(await fn(), extractedStrings, opt),
+      'StructuredData async lookup failed',
+      { key: this.key }
+    );
   }
   lookup(fn, query, opt) {
     const b = this.extract();
@@ -152,4 +161,3 @@ class StructuredData {
 }
 
 exports.StructuredData = StructuredData;
-//# sourceMappingURL=StructuredData.cjs.map

package/dist/cjs/utils/TextAnalyzer.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 class TextAnalyzer {
@@ -196,4 +196,3 @@ class TextAnalyzer {
 }
 
 exports.TextAnalyzer = TextAnalyzer;
-//# sourceMappingURL=TextAnalyzer.cjs.map

package/dist/esm/CmpStr.mjs

@@ -1,6 +1,11 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { merge, set, rmv, get } from './utils/DeepMerge.mjs';
 import { DiffChecker } from './utils/DiffChecker.mjs';
+import {
+  CmpStrInternalError,
+  CmpStrNotFoundError,
+  ErrorUtil
+} from './utils/Errors.mjs';
 import { Filter } from './utils/Filter.mjs';
 import { Normalizer } from './utils/Normalizer.mjs';
 import { Profiler } from './utils/Profiler.mjs';
@@ -81,20 +86,22 @@ class CmpStr {
     switch (cond) {
       case 'metric':
         if (!CmpStr.metric.has(test))
-          throw new Error(
+          throw new CmpStrNotFoundError(
             `CmpStr <metric> must be set, call .setMetric(), ` +
-              `use CmpStr.metric.list() for available metrics`
+              `use CmpStr.metric.list() for available metrics`,
+            { metric: test }
           );
         break;
       case 'phonetic':
         if (!CmpStr.phonetic.has(test))
-          throw new Error(
+          throw new CmpStrNotFoundError(
             `CmpStr <phonetic> must be set, call .setPhonetic(), ` +
-              `use CmpStr.phonetic.list() for available phonetic algorithms`
+              `use CmpStr.phonetic.list() for available phonetic algorithms`,
+            { phonetic: test }
           );
         break;
       default:
-        throw new Error(`Cmpstr condition <${cond}> unknown`);
+        throw new CmpStrInternalError(`Cmpstr condition <${cond}> unknown`);
     }
   }
   assertMany(...cond) {
@@ -133,31 +140,42 @@ class CmpStr {
     return StructuredData.create(data, key);
   }
   compute(a, b, opt, mode, raw, skip) {
-    const resolved = this.resolveOptions(opt);
-    this.assert('metric', resolved.metric);
-    const A = skip ? a : this.prepare(a, resolved);
-    const B = skip ? b : this.prepare(b, resolved);
-    if (
-      resolved.safeEmpty &&
-      ((Array.isArray(A) && A.length === 0) ||
-        (Array.isArray(B) && B.length === 0) ||
-        A === '' ||
-        B === '')
-    ) {
-      return [];
-    }
-    const metric = factory['metric'](resolved.metric, A, B, resolved.opt);
-    if (resolved.output !== 'prep') metric.setOriginal(a, b);
-    metric.run(mode);
-    const result = this.postProcess(metric.getResults(), resolved);
-    return this.output(result, raw ?? resolved.raw);
+    return ErrorUtil.wrap(
+      () => {
+        const resolved = this.resolveOptions(opt);
+        this.assert('metric', resolved.metric);
+        const A = skip ? a : this.prepare(a, resolved);
+        const B = skip ? b : this.prepare(b, resolved);
+        if (
+          resolved.safeEmpty &&
+          ((Array.isArray(A) && A.length === 0) ||
+            (Array.isArray(B) && B.length === 0) ||
+            A === '' ||
+            B === '')
+        ) {
+          return [];
+        }
+        const metric = factory['metric'](resolved.metric, A, B, resolved.opt);
+        if (resolved.output !== 'prep') metric.setOriginal(a, b);
+        metric.run(mode);
+        const result = this.postProcess(metric.getResults(), resolved);
+        return this.output(result, raw ?? resolved.raw);
+      },
+      `Failed to compute metric <${opt?.metric ?? this.options.metric}> for the given inputs`,
+      { a, b, options: opt }
+    );
   }
   output(result, raw) {
-    return (raw ?? this.options.raw)
-      ? result
-      : Array.isArray(result)
-        ? result.map((r) => ({ source: r.a, target: r.b, match: r.res }))
-        : { source: result.a, target: result.b, match: result.res };
+    return ErrorUtil.wrap(
+      () =>
+        (raw ?? this.options.raw)
+          ? result
+          : Array.isArray(result)
+            ? result.map((r) => ({ source: r.a, target: r.b, match: r.res }))
+            : { source: result.a, target: result.b, match: result.res },
+      `Failed to resolve output format for the metric result`,
+      { result, raw }
+    );
   }
   clone = () => Object.assign(Object.create(Object.getPrototypeOf(this)), this);
   reset() {
@@ -173,8 +191,14 @@ class CmpStr {
     return this;
   }
   setSerializedOptions(opt) {
-    this.options = JSON.parse(opt);
-    return this;
+    return ErrorUtil.wrap(
+      () => {
+        this.options = JSON.parse(opt);
+        return this;
+      },
+      `Failed to parse serialized options, invalid JSON string`,
+      { opt }
+    );
   }
   setOption(path, value) {
     set(this.options, path, value);
@@ -284,4 +308,3 @@ class CmpStr {
 }
 
 export { CmpStr };
-//# sourceMappingURL=CmpStr.mjs.map

package/dist/esm/CmpStrAsync.mjs

@@ -1,4 +1,5 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
+import { ErrorUtil } from './utils/Errors.mjs';
 import { Filter } from './utils/Filter.mjs';
 import { Normalizer } from './utils/Normalizer.mjs';
 import { factory } from './utils/Registry.mjs';
@@ -38,24 +39,30 @@ class CmpStrAsync extends CmpStr {
       : phonetic.getIndexAsync(input).then((r) => r.join(delimiter));
   }
   async computeAsync(a, b, opt, mode, raw, skip) {
-    const resolved = this.resolveOptions(opt);
-    this.assert('metric', resolved.metric);
-    const A = skip ? a : await this.prepareAsync(a, resolved);
-    const B = skip ? b : await this.prepareAsync(b, resolved);
-    if (
-      resolved.safeEmpty &&
-      ((Array.isArray(A) && A.length === 0) ||
-        (Array.isArray(B) && B.length === 0) ||
-        A === '' ||
-        B === '')
-    ) {
-      return [];
-    }
-    const metric = factory['metric'](resolved.metric, A, B, resolved.opt);
-    if (resolved.output !== 'prep') metric.setOriginal(a, b);
-    await metric.runAsync(mode);
-    const result = this.postProcess(metric.getResults(), resolved);
-    return this.output(result, raw ?? resolved.raw);
+    return ErrorUtil.wrapAsync(
+      async () => {
+        const resolved = this.resolveOptions(opt);
+        this.assert('metric', resolved.metric);
+        const A = skip ? a : await this.prepareAsync(a, resolved);
+        const B = skip ? b : await this.prepareAsync(b, resolved);
+        if (
+          resolved.safeEmpty &&
+          ((Array.isArray(A) && A.length === 0) ||
+            (Array.isArray(B) && B.length === 0) ||
+            A === '' ||
+            B === '')
+        ) {
+          return [];
+        }
+        const metric = factory['metric'](resolved.metric, A, B, resolved.opt);
+        if (resolved.output !== 'prep') metric.setOriginal(a, b);
+        await metric.runAsync(mode);
+        const result = this.postProcess(metric.getResults(), resolved);
+        return this.output(result, raw ?? resolved.raw);
+      },
+      `Failed to compute metric <${opt?.metric ?? this.options.metric}> for the given inputs`,
+      { a, b, opt }
+    );
   }
   async testAsync(a, b, opt) {
     return this.computeAsync(a, b, opt, 'single');
@@ -155,4 +162,3 @@ class CmpStrAsync extends CmpStr {
 }
 
 export { CmpStrAsync };
-//# sourceMappingURL=CmpStrAsync.mjs.map

package/dist/esm/index.mjs

@@ -1,7 +1,6 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 export { CmpStr } from './CmpStr.mjs';
 export { CmpStrAsync } from './CmpStrAsync.mjs';
 export { DiffChecker } from './utils/DiffChecker.mjs';
 export { Normalizer } from './utils/Normalizer.mjs';
 export { TextAnalyzer } from './utils/TextAnalyzer.mjs';
-//# sourceMappingURL=index.mjs.map

package/dist/esm/metric/Cosine.mjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { Pool } from '../utils/Pool.mjs';
 import { MetricRegistry, Metric } from './Metric.mjs';
 
@@ -41,4 +41,3 @@ class CosineSimilarity extends Metric {
 MetricRegistry.add('cosine', CosineSimilarity);
 
 export { CosineSimilarity };
-//# sourceMappingURL=Cosine.mjs.map

package/dist/esm/metric/DamerauLevenshtein.mjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { Pool } from '../utils/Pool.mjs';
 import { MetricRegistry, Metric } from './Metric.mjs';
 
@@ -45,4 +45,3 @@ class DamerauLevenshteinDistance extends Metric {
 MetricRegistry.add('damerau', DamerauLevenshteinDistance);
 
 export { DamerauLevenshteinDistance };
-//# sourceMappingURL=DamerauLevenshtein.mjs.map

package/dist/esm/metric/DiceSorensen.mjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { Pool } from '../utils/Pool.mjs';
 import { MetricRegistry, Metric } from './Metric.mjs';
 
@@ -34,4 +34,3 @@ class DiceSorensenCoefficient extends Metric {
 MetricRegistry.add('dice', DiceSorensenCoefficient);
 
 export { DiceSorensenCoefficient };
-//# sourceMappingURL=DiceSorensen.mjs.map

package/dist/esm/metric/Hamming.mjs

@@ -1,5 +1,6 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { MetricRegistry, Metric } from './Metric.mjs';
+import { CmpStrUsageError } from '../utils/Errors.mjs';
 
 class HammingDistance extends Metric {
   constructor(a, b, opt = {}) {
@@ -12,9 +13,10 @@ class HammingDistance extends Metric {
         if (n < maxLen) b = b.padEnd(maxLen, this.options.pad);
         m = n = maxLen;
       } else
-        throw new Error(
+        throw new CmpStrUsageError(
           `Strings must be of equal length for Hamming Distance, a=${m} and b=${n} given, ` +
-            `use option.pad for automatic adjustment`
+            `use option.pad for automatic adjustment`,
+          { a: m, b: n }
         );
     }
     let dist = 0;
@@ -25,4 +27,3 @@ class HammingDistance extends Metric {
 MetricRegistry.add('hamming', HammingDistance);
 
 export { HammingDistance };
-//# sourceMappingURL=Hamming.mjs.map

package/dist/esm/metric/Jaccard.mjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { Pool } from '../utils/Pool.mjs';
 import { MetricRegistry, Metric } from './Metric.mjs';
 
@@ -27,4 +27,3 @@ class JaccardIndex extends Metric {
 MetricRegistry.add('jaccard', JaccardIndex);
 
 export { JaccardIndex };
-//# sourceMappingURL=Jaccard.mjs.map

package/dist/esm/metric/JaroWinkler.mjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 import { Pool } from '../utils/Pool.mjs';
 import { MetricRegistry, Metric } from './Metric.mjs';
 
@@ -59,4 +59,3 @@ class JaroWinklerDistance extends Metric {
 MetricRegistry.add('jaroWinkler', JaroWinklerDistance);
 
 export { JaroWinklerDistance };
-//# sourceMappingURL=JaroWinkler.mjs.map