cmpstr 3.2.0 → 3.2.2

package/dist/cjs/metric/Metric.cjs

@@ -1,6 +1,7 @@
-// CmpStr v3.2.0 build-6929b12-260122 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('../utils/Errors.cjs');
 var HashTable = require('../utils/HashTable.cjs');
 var Profiler = require('../utils/Profiler.cjs');
 var Registry = require('../utils/Registry.cjs');
@@ -24,8 +25,11 @@ class Metric {
     this.metric = metric;
     this.a = Array.isArray(a) ? a : [a];
     this.b = Array.isArray(b) ? b : [b];
-    if (this.a.length === 0 || this.b.length === 0)
-      throw new Error(`Inputs <a> and <b> must not be empty`);
+    Errors.ErrorUtil.assert(
+      this.a.length > 0 && this.b.length > 0,
+      `Inputs <a> and <b> must not be empty`,
+      { a: this.a, b: this.b }
+    );
     this.options = opt;
     this.optKey = HashTable.Hasher.fastFNV1a(
       JSON.stringify(opt, Object.keys(opt).sort())
@@ -38,37 +42,46 @@ class Metric {
     return undefined;
   }
   compute(a, b, m, n, maxLen) {
-    throw new Error(`Method compute() must be overridden in a subclass`);
+    throw new Errors.CmpStrInternalError(
+      `Method compute() must be overridden in a subclass`
+    );
   }
   runSingle(i, j) {
-    let a = String(this.a[i]),
-      A = a;
-    let b = String(this.b[j]),
-      B = b;
-    let m = A.length,
-      n = B.length;
-    let result = this.preCompute(A, B, m, n);
-    if (!result) {
-      result = profiler.run(() => {
-        if (this.symmetric) [A, B, m, n] = Metric.swap(A, B, m, n);
-        const key =
-          Metric.cache.key(this.metric, [A, B], this.symmetric) + this.optKey;
-        return (
-          Metric.cache.get(key || '') ??
-          (() => {
-            const res = this.compute(A, B, m, n, Math.max(m, n));
-            if (key) Metric.cache.set(key, res);
-            return res;
-          })()
-        );
-      });
-    }
-    return {
-      metric: this.metric,
-      a: this.origA[i] ?? a,
-      b: this.origB[j] ?? b,
-      ...result
-    };
+    return Errors.ErrorUtil.wrap(
+      () => {
+        let a = String(this.a[i]),
+          A = a;
+        let b = String(this.b[j]),
+          B = b;
+        let m = A.length,
+          n = B.length;
+        let result = this.preCompute(A, B, m, n);
+        if (!result) {
+          result = profiler.run(() => {
+            if (this.symmetric) [A, B, m, n] = Metric.swap(A, B, m, n);
+            const key =
+              Metric.cache.key(this.metric, [A, B], this.symmetric) +
+              this.optKey;
+            return (
+              Metric.cache.get(key || '') ??
+              (() => {
+                const res = this.compute(A, B, m, n, Math.max(m, n));
+                if (key) Metric.cache.set(key, res);
+                return res;
+              })()
+            );
+          });
+        }
+        return {
+          metric: this.metric,
+          a: this.origA[i] ?? a,
+          b: this.origB[j] ?? b,
+          ...result
+        };
+      },
+      `Failed to compute metric for inputs at indices a[${i}] and b[${j}]`,
+      { i, j }
+    );
   }
   async runSingleAsync(i, j) {
     return Promise.resolve(this.runSingle(i, j));
@@ -110,7 +123,10 @@ class Metric {
       ? true
       : !safe &&
           (() => {
-            throw new Error(`Mode <pairwise> requires arrays of equal length`);
+            throw new Errors.CmpStrUsageError(
+              `Mode <pairwise> requires arrays of equal length`,
+              { a: this.a, b: this.b }
+            );
           })();
   }
   isSymmetrical = () => this.symmetric;
@@ -134,7 +150,7 @@ class Metric {
         if (this.isPairwise()) this.runPairwise();
         break;
       default:
-        throw new Error(`Unsupported mode <${mode}>`);
+        throw new Errors.CmpStrInternalError(`Unsupported mode <${mode}>`);
     }
   }
   async runAsync(mode, clear = true) {
@@ -155,13 +171,17 @@ class Metric {
         if (this.isPairwise()) await this.runPairwiseAsync();
         break;
       default:
-        throw new Error(`Unsupported async mode <${mode}>`);
+        throw new Errors.CmpStrInternalError(
+          `Unsupported async mode <${mode}>`
+        );
     }
   }
   getMetricName = () => this.metric;
   getResults() {
-    if (this.results === undefined)
-      throw new Error(`run() must be called before getResult()`);
+    Errors.ErrorUtil.assert(
+      this.results !== undefined,
+      `run() must be called before getResults()`
+    );
     return this.results;
   }
 }
@@ -169,4 +189,3 @@ const MetricRegistry = Registry.Registry('metric', Metric);
 
 exports.Metric = Metric;
 exports.MetricRegistry = MetricRegistry;
-//# sourceMappingURL=Metric.cjs.map

package/dist/cjs/metric/NeedlemanWunsch.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Pool = require('../utils/Pool.cjs');
@@ -43,4 +43,3 @@ class NeedlemanWunschDistance extends Metric.Metric {
 Metric.MetricRegistry.add('needlemanWunsch', NeedlemanWunschDistance);
 
 exports.NeedlemanWunschDistance = NeedlemanWunschDistance;
-//# sourceMappingURL=NeedlemanWunsch.cjs.map

package/dist/cjs/metric/QGram.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Pool = require('../utils/Pool.cjs');
@@ -37,4 +37,3 @@ class QGramSimilarity extends Metric.Metric {
 Metric.MetricRegistry.add('qGram', QGramSimilarity);
 
 exports.QGramSimilarity = QGramSimilarity;
-//# sourceMappingURL=QGram.cjs.map

package/dist/cjs/metric/SmithWaterman.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Pool = require('../utils/Pool.cjs');
@@ -44,4 +44,3 @@ class SmithWatermanDistance extends Metric.Metric {
 Metric.MetricRegistry.add('smithWaterman', SmithWatermanDistance);
 
 exports.SmithWatermanDistance = SmithWatermanDistance;
-//# sourceMappingURL=SmithWaterman.cjs.map

package/dist/cjs/phonetic/Caverphone.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Phonetic = require('./Phonetic.cjs');
@@ -116,4 +116,3 @@ Phonetic.PhoneticMappingRegistry.add('caverphone', 'en2', {
 });
 
 exports.Caverphone = Caverphone;
-//# sourceMappingURL=Caverphone.cjs.map

package/dist/cjs/phonetic/Cologne.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Phonetic = require('./Phonetic.cjs');
@@ -67,4 +67,3 @@ Phonetic.PhoneticMappingRegistry.add('cologne', 'default', {
 });
 
 exports.Cologne = Cologne;
-//# sourceMappingURL=Cologne.cjs.map

package/dist/cjs/phonetic/Metaphone.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Phonetic = require('./Phonetic.cjs');
@@ -97,4 +97,3 @@ Phonetic.PhoneticMappingRegistry.add('metaphone', 'en90', {
 });
 
 exports.Metaphone = Metaphone;
-//# sourceMappingURL=Metaphone.cjs.map

package/dist/cjs/phonetic/Phonetic.cjs

@@ -1,7 +1,8 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var DeepMerge = require('../utils/DeepMerge.cjs');
+var Errors = require('../utils/Errors.cjs');
 var HashTable = require('../utils/HashTable.cjs');
 var Profiler = require('../utils/Profiler.cjs');
 var Registry = require('../utils/Registry.cjs');
@@ -18,10 +19,17 @@ class Phonetic {
   constructor(algo, opt = {}) {
     const defaults = this.constructor.default ?? {};
     const mapId = opt.map ?? defaults.map;
-    if (!mapId) throw new Error(`No mapping specified for phonetic algorithm`);
+    if (!mapId)
+      throw new Errors.CmpStrNotFoundError(
+        `No mapping specified for phonetic algorithm`,
+        { algo }
+      );
     const map = PhoneticMappingRegistry.get(algo, mapId);
     if (map === undefined)
-      throw new Error(`Requested mapping <${mapId}> is not declared`);
+      throw new Errors.CmpStrNotFoundError(
+        `Requested mapping <${mapId}> is not declared`,
+        { algo, mapId }
+      );
     this.options = DeepMerge.merge(
       DeepMerge.merge(defaults, map.options ?? {}),
       opt
@@ -114,35 +122,47 @@ class Phonetic {
     return code;
   }
   loop(words) {
-    const index = [];
-    for (const word of words) {
-      const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
-      const code =
-        Phonetic.cache.get(key || '') ??
-        (() => {
-          const res = this.encode(word);
-          if (key) Phonetic.cache.set(key, res);
-          return res;
-        })();
-      if (code && code.length) index.push(this.equalLen(code));
-    }
-    return index;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        const index = [];
+        for (const word of words) {
+          const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
+          const code =
+            Phonetic.cache.get(key || '') ??
+            (() => {
+              const res = this.encode(word);
+              if (key) Phonetic.cache.set(key, res);
+              return res;
+            })();
+          if (code && code.length) index.push(this.equalLen(code));
+        }
+        return index;
+      },
+      `Failed to generate phonetic index`,
+      { algo: this.algo, words }
+    );
   }
   async loopAsync(words) {
-    const index = [];
-    for (const word of words) {
-      const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
-      const code = await Promise.resolve(
-        Phonetic.cache.get(key || '') ??
-          (() => {
-            const res = this.encode(word);
-            if (key) Phonetic.cache.set(key, res);
-            return res;
-          })()
-      );
-      if (code && code.length) index.push(this.equalLen(code));
-    }
-    return index;
+    return Errors.ErrorUtil.wrapAsync(
+      async () => {
+        const index = [];
+        for (const word of words) {
+          const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
+          const code = await Promise.resolve(
+            Phonetic.cache.get(key || '') ??
+              (() => {
+                const res = this.encode(word);
+                if (key) Phonetic.cache.set(key, res);
+                return res;
+              })()
+          );
+          if (code && code.length) index.push(this.equalLen(code));
+        }
+        return index;
+      },
+      `Failed to generate phonetic index asynchronously`,
+      { algo: this.algo, words }
+    );
   }
   getAlgoName = () => this.algo;
   getIndex(input) {
@@ -167,10 +187,11 @@ const PhoneticMappingRegistry = (() => {
   return Object.freeze({
     add(algo, id, map, update = false) {
       const mappings = maps(algo);
-      if (!update && id in mappings)
-        throw new Error(
-          `Entry <${id}> already exists / use <update=true> to overwrite`
-        );
+      Errors.ErrorUtil.assert(
+        !(!id || id in mappings) || update,
+        `Entry <${id}> already exists / use <update=true> to overwrite`,
+        { algo, id }
+      );
       mappings[id] = map;
     },
     remove(algo, id) {
@@ -191,4 +212,3 @@ const PhoneticMappingRegistry = (() => {
 exports.Phonetic = Phonetic;
 exports.PhoneticMappingRegistry = PhoneticMappingRegistry;
 exports.PhoneticRegistry = PhoneticRegistry;
-//# sourceMappingURL=Phonetic.cjs.map

package/dist/cjs/phonetic/Soundex.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Phonetic = require('./Phonetic.cjs');
@@ -86,4 +86,3 @@ Phonetic.PhoneticMappingRegistry.add('soundex', 'de', {
 });
 
 exports.Soundex = Soundex;
-//# sourceMappingURL=Soundex.cjs.map

package/dist/cjs/root.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var CmpStr = require('./CmpStr.cjs');
@@ -24,6 +24,7 @@ require('./phonetic/Metaphone.cjs');
 require('./phonetic/Soundex.cjs');
 var Phonetic = require('./phonetic/Phonetic.cjs');
 var DeepMerge = require('./utils/DeepMerge.cjs');
+var Errors = require('./utils/Errors.cjs');
 var Filter = require('./utils/Filter.cjs');
 var HashTable = require('./utils/HashTable.cjs');
 var Pool = require('./utils/Pool.cjs');
@@ -41,10 +42,10 @@ exports.Phonetic = Phonetic.Phonetic;
 exports.PhoneticMappingRegistry = Phonetic.PhoneticMappingRegistry;
 exports.PhoneticRegistry = Phonetic.PhoneticRegistry;
 exports.DeepMerge = DeepMerge;
+exports.CmpStrError = Errors;
 exports.Filter = Filter.Filter;
 exports.HashTable = HashTable.HashTable;
 exports.Hasher = HashTable.Hasher;
 exports.Pool = Pool.Pool;
 exports.Profiler = Profiler.Profiler;
 exports.StructuredData = StructuredData.StructuredData;
-//# sourceMappingURL=root.cjs.map

package/dist/cjs/utils/DeepMerge.cjs

@@ -1,6 +1,8 @@
-// CmpStr v3.2.0 build-6929b12-260122 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 BRACKET_PATTERN = /\[(\d+)]/g;
 const PATH_CACHE = new Map();
 function parse(p) {
@@ -36,15 +38,19 @@ function set(t, path, value) {
   if (path === '') return value;
   const keys = parse(path);
   if (t !== undefined && (typeof t !== 'object' || t === null))
-    throw Error(`Cannot set property <${keys[0]}> of <${JSON.stringify(t)}>`);
+    throw new Errors.CmpStrUsageError(
+      `Cannot set property <${keys[0]}> of <${JSON.stringify(t)}>`,
+      { path: keys[0], target: t }
+    );
   const root = t ?? (typeof keys[0] === 'number' ? [] : Object.create(null));
   let cur = root;
   for (let i = 0; i < keys.length - 1; i++) {
     const k = keys[i];
     let n = cur[k];
     if (n != null && typeof n !== 'object')
-      throw Error(
-        `Cannot set property <${keys[i + 1]}> of <${JSON.stringify(n)}>`
+      throw new Errors.CmpStrUsageError(
+        `Cannot set property <${keys[i + 1]}> of <${JSON.stringify(n)}>`,
+        { path: keys.slice(0, i + 2), value: n }
       );
     if (n == null)
       n = cur[k] = typeof keys[i + 1] === 'number' ? [] : Object.create(null);
@@ -105,4 +111,3 @@ exports.has = has;
 exports.merge = merge;
 exports.rmv = rmv;
 exports.set = set;
-//# sourceMappingURL=DeepMerge.cjs.map

package/dist/cjs/utils/DiffChecker.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 class DiffChecker {
@@ -297,4 +297,3 @@ class DiffChecker {
 }
 
 exports.DiffChecker = DiffChecker;
-//# sourceMappingURL=DiffChecker.cjs.map

package/dist/cjs/utils/Errors.cjs

@@ -0,0 +1,103 @@
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
+'use strict';
+
+class CmpStrError extends Error {
+  code;
+  meta;
+  cause;
+  when = new Date().toISOString();
+  constructor(code, message, meta, cause) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.meta = meta;
+    this.cause = cause;
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      meta: this.meta,
+      when: this.when,
+      cause:
+        this.cause instanceof Error
+          ? {
+              name: this.cause.name,
+              message: this.cause.message,
+              stack: this.cause.stack
+            }
+          : this.cause
+    };
+  }
+  toString(stack = false) {
+    const parts = [`${this.name} [${this.code}]`, this.message];
+    if (this.meta && Object.keys(this.meta).length) {
+      try {
+        parts.push(JSON.stringify(this.meta));
+      } catch {}
+    }
+    return (
+      parts.join(' - ') +
+      (stack && this.stack ? `\nStack Trace:\n${this.stack}` : '')
+    );
+  }
+}
+class CmpStrValidationError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_VALIDATION', message, meta, cause);
+  }
+}
+class CmpStrNotFoundError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_NOT_FOUND', message, meta, cause);
+  }
+}
+class CmpStrUsageError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_USAGE', message, meta, cause);
+  }
+}
+class CmpStrInternalError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_INTERNAL', message, meta, cause);
+  }
+}
+class ErrorUtil {
+  static assert(condition, message, meta) {
+    if (!condition) throw new CmpStrUsageError(message, meta);
+  }
+  static create(err, message, meta) {
+    if (err instanceof CmpStrError) throw err;
+    throw new CmpStrInternalError(message, meta, err);
+  }
+  static format(err) {
+    if (err instanceof CmpStrError) return err.toString();
+    if (err instanceof Error) return `${err.name}: ${err.message}`;
+    return String(err);
+  }
+  static wrap(fn, message, meta) {
+    try {
+      return fn();
+    } catch (err) {
+      throw new CmpStrInternalError(message, meta, err);
+    }
+  }
+  static async wrapAsync(fn, message, meta) {
+    try {
+      return await fn();
+    } catch (err) {
+      throw new CmpStrInternalError(message, meta, err);
+    }
+  }
+}
+
+exports.CmpStrError = CmpStrError;
+exports.CmpStrInternalError = CmpStrInternalError;
+exports.CmpStrNotFoundError = CmpStrNotFoundError;
+exports.CmpStrUsageError = CmpStrUsageError;
+exports.CmpStrValidationError = CmpStrValidationError;
+exports.ErrorUtil = ErrorUtil;

package/dist/cjs/utils/Filter.cjs

@@ -1,34 +1,48 @@
-// CmpStr v3.2.0 build-6929b12-260122 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 Filter {
   static filters = new Map();
   static pipeline = new Map();
   static getPipeline(hook) {
-    const cached = Filter.pipeline.get(hook);
-    if (cached) return cached;
-    const filter = Filter.filters.get(hook);
-    if (!filter) return (s) => s;
-    const pipeline = Array.from(filter.values())
-      .filter((f) => f.active)
-      .sort((a, b) => a.priority - b.priority)
-      .map((f) => f.fn);
-    const fn = (input) => pipeline.reduce((v, f) => f(v), input);
-    Filter.pipeline.set(hook, fn);
-    return fn;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        const cached = Filter.pipeline.get(hook);
+        if (cached) return cached;
+        const filter = Filter.filters.get(hook);
+        if (!filter) return (s) => s;
+        const pipeline = Array.from(filter.values())
+          .filter((f) => f.active)
+          .sort((a, b) => a.priority - b.priority)
+          .map((f) => f.fn);
+        const fn = (input) => pipeline.reduce((v, f) => f(v), input);
+        Filter.pipeline.set(hook, fn);
+        return fn;
+      },
+      `Error compiling filter pipeline for hook <${hook}>`,
+      { hook }
+    );
   }
   static has(hook, id) {
     return !!Filter.filters.get(hook)?.has(id);
   }
   static add(hook, id, fn, opt = {}) {
-    const { priority = 10, active = true, overrideable = true } = opt;
-    const filter = Filter.filters.get(hook) ?? new Map();
-    const index = filter.get(id);
-    if (index && !index.overrideable) return false;
-    filter.set(id, { id, fn, priority, active, overrideable });
-    Filter.filters.set(hook, filter);
-    Filter.pipeline.delete(hook);
-    return true;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        const { priority = 10, active = true, overrideable = true } = opt;
+        const filter = Filter.filters.get(hook) ?? new Map();
+        const index = filter.get(id);
+        if (index && !index.overrideable) return false;
+        filter.set(id, { id, fn, priority, active, overrideable });
+        Filter.filters.set(hook, filter);
+        Filter.pipeline.delete(hook);
+        return true;
+      },
+      `Error adding filter <${id}> to hook <${hook}>`,
+      { hook, id, opt }
+    );
   }
   static remove(hook, id) {
     Filter.pipeline.delete(hook);
@@ -53,20 +67,35 @@ class Filter {
     return out;
   }
   static apply(hook, input) {
-    const fn = Filter.getPipeline(hook);
-    return Array.isArray(input) ? input.map(fn) : fn(input);
+    return Errors.ErrorUtil.wrap(
+      () => {
+        const fn = Filter.getPipeline(hook);
+        return Array.isArray(input) ? input.map(fn) : fn(input);
+      },
+      `Error applying filters for hook <${hook}>`,
+      { hook, input }
+    );
   }
   static async applyAsync(hook, input) {
-    const fn = Filter.getPipeline(hook);
-    return Array.isArray(input)
-      ? Promise.all(input.map(fn))
-      : Promise.resolve(fn(input));
+    return Errors.ErrorUtil.wrapAsync(
+      async () => {
+        const fn = Filter.getPipeline(hook);
+        return Array.isArray(input)
+          ? Promise.all(input.map(fn))
+          : Promise.resolve(fn(input));
+      },
+      `Error applying filters for hook <${hook}>`,
+      { hook, input }
+    );
   }
   static clear(hook) {
+    Filter.pipeline.clear();
     if (hook) Filter.filters.delete(hook);
     else Filter.filters.clear();
   }
+  static clearPipeline() {
+    Filter.pipeline.clear();
+  }
 }
 
 exports.Filter = Filter;
-//# sourceMappingURL=Filter.cjs.map

package/dist/cjs/utils/HashTable.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.0 build-6929b12-260122 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.2.2 build-bb61120-260311 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 class Hasher {
@@ -65,4 +65,3 @@ class HashTable {
 
 exports.HashTable = HashTable;
 exports.Hasher = Hasher;
-//# sourceMappingURL=HashTable.cjs.map