cmpstr 3.1.1 → 3.2.0

package/dist/CmpStr.esm.js

@@ -1,74 +1,105 @@
 /**
- * CmpStr v3.1.1 build-a140f52-260119
+ * CmpStr v3.2.0 build-6929b12-260122
  * 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
  */
-const parse = (p) =>
-  p
-    .replace(/\[(\d+)]/g, '.$1')
+const BRACKET_PATTERN = /\[(\d+)]/g;
+const PATH_CACHE = new Map();
+function parse(p) {
+  let cached = PATH_CACHE.get(p);
+  if (cached) return cached;
+  const parsed = p
+    .replace(BRACKET_PATTERN, '.$1')
     .split('.')
-    .map((s) => (/^\d+$/.test(s) ? +s : s));
-function get(t, path, fallback) {
-  return parse(path).reduce((o, k) => o?.[k] ?? fallback, t);
+    .map((s) => {
+      const n = Number(s);
+      return Number.isInteger(n) && String(n) === s ? n : s;
+    });
+  PATH_CACHE.set(p, parsed);
+  return parsed;
+}
+function get(t, path, fb) {
+  let o = t;
+  for (const k of parse(path)) {
+    if (o == null || !(k in o)) return fb;
+    o = o[k];
+  }
+  return o;
 }
 function has(t, path) {
-  return (
-    parse(path).reduce((o, k) => (o && k in o ? o[k] : undefined), t) !==
-    undefined
-  );
+  let o = t;
+  for (const k of parse(path)) {
+    if (o == null || !(k in o)) return false;
+    o = o[k];
+  }
+  return true;
 }
 function set(t, path, value) {
   if (path === '') return value;
-  const [k, ...r] = parse(path);
+  const keys = parse(path);
   if (t !== undefined && (typeof t !== 'object' || t === null))
-    throw Error(`Cannot set property <${k}> of <${JSON.stringify(t)}>`);
-  return Object.assign(
-    t ?? (typeof k === 'number' ? [] : Object.create(null)),
-    { [k]: set(t?.[k], r.join('.'), value) }
-  );
+    throw Error(`Cannot set property <${keys[0]}> of <${JSON.stringify(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)}>`
+      );
+    if (n == null)
+      n = cur[k] = typeof keys[i + 1] === 'number' ? [] : Object.create(null);
+    cur = n;
+  }
+  cur[keys[keys.length - 1]] = value;
+  return root;
 }
 function merge(
   t = Object.create(null),
   o = Object.create(null),
   mergeUndefined = false
 ) {
-  return (
-    Object.keys(o).forEach((k) => {
-      const val = o[k];
-      if (!mergeUndefined && val === undefined) return;
-      if (k === '__proto__' || k === 'constructor') return;
-      t[k] =
-        typeof val === 'object' && !Array.isArray(val)
-          ? merge(
-              typeof t[k] === 'object' && !Array.isArray(t[k])
-                ? t[k]
-                : Object.create(null),
-              val
-            )
-          : val;
-    }),
-    t
-  );
+  const target = t ?? Object.create(null);
+  Object.keys(o).forEach((k) => {
+    const val = o[k];
+    if (!mergeUndefined && val === undefined) return;
+    if (k === '__proto__' || k === 'constructor') return;
+    if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
+      const existing = target[k];
+      target[k] = merge(
+        existing !== null &&
+          typeof existing === 'object' &&
+          !Array.isArray(existing)
+          ? existing
+          : Object.create(null),
+        val,
+        mergeUndefined
+      );
+    } else target[k] = val;
+  });
+  return target;
 }
 function rmv(t, path, preserveEmpty = false) {
-  const r = (o, k, i = 0) => {
-    const key = k[i];
-    if (!o || typeof o !== 'object') return false;
-    if (i === k.length - 1) return delete o[key];
-    if (!r(o[key], k, i + 1)) return false;
+  const keys = parse(path);
+  const remove = (obj, i = 0) => {
+    const key = keys[i];
+    if (!obj || typeof obj !== 'object') return false;
+    if (i === keys.length - 1) return delete obj[key];
+    if (!remove(obj[key], i + 1)) return false;
     if (!preserveEmpty) {
-      const val = o[key];
+      const val = obj[key];
       if (
         typeof val === 'object' &&
         ((Array.isArray(val) && val.every((v) => v == null)) ||
           (!Array.isArray(val) && Object.keys(val).length === 0))
       )
-        delete o[key];
+        delete obj[key];
     }
     return true;
   };
-  r(t, parse(path));
+  remove(t);
   return t;
 }
 
@@ -81,272 +112,6 @@ var DeepMerge = /*#__PURE__*/ Object.freeze({
   set: set
 });
 
-class Profiler {
-  static ENV;
-  static instance;
-  store = new Set();
-  totalTime = 0;
-  totalMem = 0;
-  active;
-  static detectEnv() {
-    if (typeof process !== 'undefined') Profiler.ENV = 'nodejs';
-    else if (typeof performance !== 'undefined') Profiler.ENV = 'browser';
-    else Profiler.ENV = 'unknown';
-  }
-  static getInstance(enable) {
-    if (!Profiler.ENV) Profiler.detectEnv();
-    if (!Profiler.instance) Profiler.instance = new Profiler(enable);
-    return Profiler.instance;
-  }
-  constructor(enable) {
-    this.active = enable ?? false;
-  }
-  now() {
-    switch (Profiler.ENV) {
-      case 'nodejs':
-        return Number(process.hrtime.bigint()) / 1e6;
-      case 'browser':
-        return performance.now();
-      default:
-        return Date.now();
-    }
-  }
-  mem() {
-    switch (Profiler.ENV) {
-      case 'nodejs':
-        return process.memoryUsage().heapUsed;
-      case 'browser':
-        return performance.memory?.usedJSHeapSize ?? 0;
-      default:
-        return 0;
-    }
-  }
-  enable() {
-    this.active = true;
-  }
-  disable() {
-    this.active = false;
-  }
-  clear() {
-    this.store.clear();
-    this.totalTime = 0;
-    this.totalMem = 0;
-  }
-  run(fn, meta = {}) {
-    if (!this.active) return fn();
-    const startTime = this.now(),
-      startMem = this.mem();
-    const res = fn();
-    const deltaTime = this.now() - startTime;
-    const deltaMem = this.mem() - startMem;
-    this.store.add({ time: deltaTime, mem: deltaMem, res, meta });
-    ((this.totalTime += deltaTime), (this.totalMem += deltaMem));
-    return res;
-  }
-  async runAsync(fn, meta = {}) {
-    if (!this.active) return await fn();
-    const startTime = this.now(),
-      startMem = this.mem();
-    const res = await fn();
-    const deltaTime = this.now() - startTime;
-    const deltaMem = this.mem() - startMem;
-    this.store.add({ time: deltaTime, mem: deltaMem, res, meta });
-    ((this.totalTime += deltaTime), (this.totalMem += deltaMem));
-    return res;
-  }
-  getAll() {
-    return [...this.store];
-  }
-  getLast() {
-    return this.getAll().pop();
-  }
-  getTotal() {
-    return { time: this.totalTime, mem: this.totalMem };
-  }
-  services = {
-    enable: this.enable.bind(this),
-    disable: this.disable.bind(this),
-    clear: this.clear.bind(this),
-    report: this.getAll.bind(this),
-    last: this.getLast.bind(this),
-    total: this.getTotal.bind(this)
-  };
-}
-
-class TextAnalyzer {
-  text;
-  words = [];
-  sentences = [];
-  charFrequency = new Map();
-  wordHistogram = new Map();
-  syllableCache = new Map();
-  constructor(input) {
-    this.text = input.trim();
-    this.tokenize();
-    this.computeFrequencies();
-  }
-  tokenize() {
-    ((this.words = []), (this.sentences = []));
-    const text = this.text;
-    const wordRegex = /\p{L}+/gu;
-    let match;
-    while ((match = wordRegex.exec(text)) !== null) {
-      this.words.push(match[0].toLowerCase());
-    }
-    this.sentences = text.split(/(?<=[.!?])\s+/).filter(Boolean);
-  }
-  computeFrequencies() {
-    for (const char of this.text)
-      this.charFrequency.set(char, (this.charFrequency.get(char) ?? 0) + 1);
-    for (const word of this.words)
-      this.wordHistogram.set(word, (this.wordHistogram.get(word) ?? 0) + 1);
-  }
-  estimateSyllables(word) {
-    if (this.syllableCache.has(word)) return this.syllableCache.get(word);
-    const clean = word.toLowerCase().replace(/[^a-zäöüß]/g, '');
-    const matches = clean.match(/[aeiouyäöü]+/g);
-    const count = matches ? matches.length : 1;
-    this.syllableCache.set(word, count);
-    return count;
-  }
-  getLength() {
-    return this.text.length;
-  }
-  getWordCount() {
-    return this.words.length;
-  }
-  getSentenceCount() {
-    return this.sentences.length;
-  }
-  getAvgWordLength() {
-    let totalLen = 0;
-    for (const w of this.words) totalLen += w.length;
-    return this.words.length ? totalLen / this.words.length : 0;
-  }
-  getAvgSentenceLength() {
-    return this.sentences.length
-      ? this.words.length / this.sentences.length
-      : 0;
-  }
-  getWordHistogram() {
-    return Object.fromEntries(this.wordHistogram);
-  }
-  getMostCommonWords(limit = 5) {
-    return [...this.wordHistogram.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, limit)
-      .map((e) => e[0]);
-  }
-  getHapaxLegomena() {
-    return [...this.wordHistogram.entries()]
-      .filter(([, c]) => c === 1)
-      .map((e) => e[0]);
-  }
-  hasNumbers() {
-    return /\d/.test(this.text);
-  }
-  getUpperCaseRatio() {
-    let upper = 0,
-      letters = 0;
-    for (let i = 0, len = this.text.length; i < len; i++) {
-      const c = this.text[i];
-      if (/[A-Za-zÄÖÜäöüß]/.test(c)) {
-        letters++;
-        if (/[A-ZÄÖÜ]/.test(c)) upper++;
-      }
-    }
-    return letters ? upper / letters : 0;
-  }
-  getCharFrequency() {
-    return Object.fromEntries(this.charFrequency);
-  }
-  getUnicodeStats() {
-    const result = {};
-    for (const [char, count] of this.charFrequency) {
-      const block = char
-        .charCodeAt(0)
-        .toString(16)
-        .padStart(4, '0')
-        .toUpperCase();
-      result[block] = (result[block] ?? 0) + count;
-    }
-    return result;
-  }
-  getLongWordRatio(len = 7) {
-    let long = 0;
-    for (const w of this.words) if (w.length >= len) long++;
-    return this.words.length ? long / this.words.length : 0;
-  }
-  getShortWordRatio(len = 3) {
-    let short = 0;
-    for (const w of this.words) if (w.length <= len) short++;
-    return this.words.length ? short / this.words.length : 0;
-  }
-  getSyllablesCount() {
-    let count = 0;
-    for (const w of this.words) count += this.estimateSyllables(w);
-    return count;
-  }
-  getMonosyllabicWordCount() {
-    let count = 0;
-    for (const w of this.words) if (this.estimateSyllables(w) === 1) count++;
-    return count;
-  }
-  getMinSyllablesWordCount(min) {
-    let count = 0;
-    for (const w of this.words) if (this.estimateSyllables(w) >= min) count++;
-    return count;
-  }
-  getMaxSyllablesWordCount(max) {
-    let count = 0;
-    for (const w of this.words) if (this.estimateSyllables(w) <= max) count++;
-    return count;
-  }
-  getHonoresR() {
-    return (
-      (100 * Math.log(this.words.length)) /
-      (1 - this.getHapaxLegomena().length / (this.wordHistogram.size ?? 1))
-    );
-  }
-  getReadingTime(wpm = 200) {
-    return Math.max(1, this.words.length / (wpm ?? 1));
-  }
-  getReadabilityScore(metric = 'flesch') {
-    const w = this.words.length || 1;
-    const s = this.sentences.length || 1;
-    const y = this.getSyllablesCount() || 1;
-    const asl = w / s;
-    const asw = y / w;
-    switch (metric) {
-      case 'flesch':
-        return 206.835 - 1.015 * asl - 84.6 * asw;
-      case 'fleschde':
-        return 180 - asl - 58.5 * asw;
-      case 'kincaid':
-        return 0.39 * asl + 11.8 * asw - 15.59;
-    }
-  }
-  getLIXScore() {
-    const w = this.words.length || 1;
-    const s = this.sentences.length || 1;
-    const l = this.getLongWordRatio() * w;
-    return w / s + (l / w) * 100;
-  }
-  getWSTFScore() {
-    const w = this.words.length || 1;
-    const h = (this.getMinSyllablesWordCount(3) / w) * 100;
-    const s = this.getAvgSentenceLength();
-    const l = this.getLongWordRatio() * 100;
-    const m = (this.getMonosyllabicWordCount() / w) * 100;
-    return [
-      0.1935 * h + 0.1672 * s + 0.1297 * l - 0.0327 * m - 0.875,
-      0.2007 * h + 0.1682 * s + 0.1373 * l - 2.779,
-      0.2963 * h + 0.1905 * s - 1.1144,
-      0.2744 * h + 0.2656 * s - 1.693
-    ];
-  }
-}
-
 class DiffChecker {
   a;
   b;
@@ -377,8 +142,7 @@ class DiffChecker {
     return { linesA, linesB, maxLen: Math.max(linesA.length, linesB.length) };
   }
   tokenize(input) {
-    const { mode } = this.options;
-    switch (mode) {
+    switch (this.options.mode) {
       case 'line':
         return [input];
       case 'word':
@@ -386,20 +150,15 @@ class DiffChecker {
     }
   }
   concat(input) {
-    const { mode } = this.options;
-    return input.join(mode === 'word' ? ' ' : '');
+    return input.join(this.options.mode === 'word' ? ' ' : '');
   }
   computeDiff() {
-    if (!this.diffRun) {
-      const { linesA, linesB, maxLen } = this.text2lines();
-      for (let i = 0; i < maxLen; i++) {
-        const a = linesA[i] || '';
-        const b = linesB[i] || '';
-        this.lineDiff(a, b, i);
-      }
-      this.findGroups();
-      this.diffRun = true;
-    }
+    if (this.diffRun) return;
+    const { linesA, linesB, maxLen } = this.text2lines();
+    for (let i = 0; i < maxLen; i++)
+      this.lineDiff(linesA[i] || '', linesB[i] || '', i);
+    this.findGroups();
+    this.diffRun = true;
   }
   lineDiff(a, b, line) {
     const { mode, caseInsensitive } = this.options;
@@ -410,24 +169,27 @@ class DiffChecker {
     let diffs = [];
     let delSize = 0,
       insSize = 0;
-    if (mode === 'line') {
-      if (A !== B) {
-        diffs.push({
-          posA: 0,
-          posB: 0,
-          del: a,
-          ins: b,
-          size: b.length - a.length
-        });
-        delSize = a.length;
-        insSize = b.length;
-      }
-    } else {
-      diffs = this.preciseDiff(a, A, b, B);
-      for (const d of diffs)
-        ((delSize += d.del.length), (insSize += d.ins.length));
+    switch (mode) {
+      case 'line':
+        if (A !== B) {
+          diffs.push({
+            posA: 0,
+            posB: 0,
+            del: a,
+            ins: b,
+            size: b.length - a.length
+          });
+          delSize = a.length;
+          insSize = b.length;
+        }
+        break;
+      case 'word':
+        diffs = this.preciseDiff(a, A, b, B);
+        for (const d of diffs)
+          ((delSize += d.del.length), (insSize += d.ins.length));
+        break;
     }
-    if (diffs.length) {
+    if (diffs.length)
       this.entries.push({
         line,
         diffs,
@@ -437,7 +199,6 @@ class DiffChecker {
         totalSize: insSize - delSize,
         magnitude: this.magnitude(delSize, insSize, baseLen)
       });
-    }
   }
   preciseDiff(a, A, b, B) {
     const posIndex = (t) =>
@@ -640,43 +401,102 @@ class DiffChecker {
     }
     return out.join(lineBreak);
   }
-  getStructuredDiff() {
-    return this.entries;
+  getStructuredDiff = () => this.entries;
+  getGroupedDiff = () => this.grouped;
+  getASCIIDiff = () => this.output(false);
+  getCLIDiff = () => this.output(true);
+}
+
+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;
+  }
+  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;
   }
-  getGroupedDiff() {
-    return this.grouped;
+  static remove(hook, id) {
+    Filter.pipeline.delete(hook);
+    const filter = Filter.filters.get(hook);
+    return filter ? filter.delete(id) : false;
   }
-  getASCIIDiff() {
-    return this.output(false);
+  static pause(hook, id) {
+    Filter.pipeline.delete(hook);
+    const f = Filter.filters.get(hook)?.get(id);
+    return !!(f && ((f.active = false), true));
   }
-  getCLIDiff() {
-    return this.output(true);
+  static resume(hook, id) {
+    Filter.pipeline.delete(hook);
+    const f = Filter.filters.get(hook)?.get(id);
+    return !!(f && ((f.active = true), true));
+  }
+  static list(hook, active = false) {
+    const filter = Filter.filters.get(hook);
+    if (!filter) return [];
+    const out = [];
+    for (const f of filter.values()) if (!active || f.active) out.push(f.id);
+    return out;
+  }
+  static apply(hook, input) {
+    const fn = Filter.getPipeline(hook);
+    return Array.isArray(input) ? input.map(fn) : fn(input);
+  }
+  static async applyAsync(hook, input) {
+    const fn = Filter.getPipeline(hook);
+    return Array.isArray(input)
+      ? Promise.all(input.map(fn))
+      : Promise.resolve(fn(input));
+  }
+  static clear(hook) {
+    if (hook) Filter.filters.delete(hook);
+    else Filter.filters.clear();
   }
 }
 
 class Hasher {
   static FNV_PRIME = 0x01000193;
   static HASH_OFFSET = 0x811c9dc5;
-  static fnv1a(str) {
+  static fastFNV1a(str) {
     const len = str.length;
     let hash = this.HASH_OFFSET;
     const chunks = Math.floor(len / 4);
     for (let i = 0; i < chunks; i++) {
       const pos = i * 4;
-      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);
+      const chunk =
+        str.charCodeAt(pos) |
+        (str.charCodeAt(pos + 1) << 8) |
+        (str.charCodeAt(pos + 2) << 16) |
+        (str.charCodeAt(pos + 3) << 24);
       hash ^= chunk;
-      hash *= this.FNV_PRIME;
+      hash = Math.imul(hash, this.FNV_PRIME);
     }
     const remaining = len % 4;
     if (remaining > 0) {
       const pos = chunks * 4;
       for (let i = 0; i < remaining; i++) {
         hash ^= str.charCodeAt(pos + i);
-        hash *= this.FNV_PRIME;
+        hash = Math.imul(hash, this.FNV_PRIME);
       }
     }
     hash ^= hash >>> 16;
@@ -688,73 +508,74 @@ class Hasher {
   }
 }
 class HashTable {
+  LRU;
   static MAX_LEN = 2048;
   static TABLE_SIZE = 10_000;
   table = new Map();
-  key(label, strs, sorted = false) {
-    for (const str of strs) {
-      if (str.length > HashTable.MAX_LEN) return false;
-    }
-    const hashes = strs.map((s) => Hasher.fnv1a(s));
-    if (sorted) hashes.sort();
-    return [label, ...hashes].join('-');
+  constructor(LRU = true) {
+    this.LRU = LRU;
   }
-  has(key) {
-    return this.table.has(key);
-  }
-  get(key) {
-    return this.table.get(key);
+  key(label, strs, sorted = false) {
+    for (const str of strs) if (str.length > HashTable.MAX_LEN) return false;
+    const hashes = strs.map((s) => Hasher.fastFNV1a(s));
+    return [label, ...(sorted ? hashes.sort() : hashes)].join('-');
   }
+  has = (key) => this.table.has(key);
+  get = (key) => this.table.get(key);
   set(key, entry, update = true) {
-    if (
-      this.table.size < HashTable.TABLE_SIZE &&
-      (update || !this.table.has(key))
-    ) {
-      this.table.set(key, entry);
-      return true;
+    if (!update && this.table.has(key)) return false;
+    while (!this.table.has(key) && this.table.size >= HashTable.TABLE_SIZE) {
+      if (!this.LRU) return false;
+      this.table.delete(this.table.keys().next().value);
     }
-    return false;
-  }
-  delete(key) {
-    this.table.delete(key);
-  }
-  clear() {
-    this.table.clear();
-  }
-  size() {
-    return this.table.size;
+    this.table.set(key, entry);
+    return true;
   }
+  delete = (key) => this.table.delete(key);
+  clear = () => this.table.clear();
+  size = () => this.table.size;
 }
 
 class Normalizer {
   static pipeline = new Map();
   static cache = new HashTable();
+  static REGEX = {
+    whitespace: /\s+/g,
+    doubleChars: /(.)\1+/g,
+    specialChars: /[^\p{L}\p{N}\s]/gu,
+    nonLetters: /[^\p{L}]/gu,
+    nonNumbers: /\p{N}/gu
+  };
+  static canonicalFlags(flags) {
+    return Array.from(new Set(flags)).sort().join('');
+  }
   static getPipeline(flags) {
     if (Normalizer.pipeline.has(flags)) return Normalizer.pipeline.get(flags);
-    const steps = [];
-    if (flags.includes('d')) steps.push((str) => str.normalize('NFD'));
-    if (flags.includes('u')) steps.push((str) => str.normalize('NFC'));
-    if (flags.includes('x')) steps.push((str) => str.normalize('NFKC'));
-    if (flags.includes('w')) steps.push((str) => str.replace(/\s+/g, ' '));
-    if (flags.includes('t')) steps.push((str) => str.trim());
-    if (flags.includes('r')) steps.push((str) => str.replace(/(.)\1+/g, '$1'));
-    if (flags.includes('s'))
-      steps.push((str) => str.replace(/[^\p{L}\p{N}\s]/gu, ''));
-    if (flags.includes('k')) steps.push((str) => str.replace(/[^\p{L}]/gu, ''));
-    if (flags.includes('n')) steps.push((str) => str.replace(/\p{N}/gu, ''));
-    if (flags.includes('i')) steps.push((str) => str.toLowerCase());
-    const compiled = (input) => {
-      let res = input;
-      for (const step of steps) res = step(res);
-      return res;
-    };
-    Normalizer.pipeline.set(flags, compiled);
-    return compiled;
+    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;
   }
   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));
-    if (!flags || typeof flags !== 'string' || !input) return input;
     const key = Normalizer.cache.key(flags, [input]);
     if (key && Normalizer.cache.has(key)) return Normalizer.cache.get(key);
     const res = Normalizer.getPipeline(flags)(input);
@@ -772,76 +593,135 @@ class Normalizer {
   }
 }
 
-class Filter {
-  static filters = new Map();
-  static find(hook, id) {
-    return Filter.filters.get(hook)?.find((f) => f.id === id);
+class Profiler {
+  active;
+  static ENV;
+  static instance;
+  nowFn;
+  memFn;
+  store = new Set();
+  totalTime = 0;
+  totalMem = 0;
+  static detectEnv() {
+    if (typeof process !== 'undefined') Profiler.ENV = 'nodejs';
+    else if (typeof performance !== 'undefined') Profiler.ENV = 'browser';
+    else Profiler.ENV = 'unknown';
   }
-  static add(hook, id, fn, opt = {}) {
-    const { priority = 10, active = true, overrideable = true } = opt;
-    const filter = Filter.filters.get(hook) ?? [];
-    const index = filter.findIndex((f) => f.id === id);
-    if (index >= 0) {
-      const f = filter[index];
-      if (!f.overrideable) return false;
-      filter.splice(index, 1);
-    }
-    filter.push({ id, fn, priority, active, overrideable });
-    filter.sort((a, b) => a.priority - b.priority);
-    Filter.filters.set(hook, filter);
-    return true;
+  static getInstance(enable) {
+    if (!Profiler.ENV) Profiler.detectEnv();
+    return (Profiler.instance ||= new Profiler(enable));
   }
-  static remove(hook, id) {
-    const filter = Filter.filters.get(hook);
-    if (!filter) return false;
-    const index = filter.findIndex((f) => f.id === id);
-    if (index >= 0) {
-      filter.splice(index, 1);
-      return true;
+  constructor(active = false) {
+    this.active = active;
+    switch (Profiler.ENV) {
+      case 'nodejs':
+        this.nowFn = () => Number(process.hrtime.bigint()) / 1e6;
+        this.memFn = () => process.memoryUsage().heapUsed;
+        break;
+      case 'browser':
+        this.nowFn = () => performance.now();
+        this.memFn = () => performance.memory?.usedJSHeapSize ?? 0;
+        break;
+      default:
+        this.nowFn = () => Date.now();
+        this.memFn = () => 0;
+        break;
     }
-    return false;
-  }
-  static pause(hook, id) {
-    const f = Filter.find(hook, id);
-    if (!f) return false;
-    f.active = false;
-    return true;
-  }
-  static resume(hook, id) {
-    const f = Filter.find(hook, id);
-    if (!f) return false;
-    f.active = true;
-    return true;
   }
-  static list(hook, active = false) {
-    const filter = Filter.filters.get(hook) ?? [];
-    const list = [];
-    for (const f of filter) if (!active || f.active) list.push(f.id);
-    return list;
+  now = () => this.nowFn();
+  mem = () => this.memFn();
+  profile(fn, meta) {
+    const startTime = this.now(),
+      startMem = this.mem();
+    const res = fn();
+    const deltaTime = this.now() - startTime,
+      deltaMem = this.mem() - startMem;
+    this.store.add({ time: deltaTime, mem: deltaMem, res, meta });
+    ((this.totalTime += deltaTime), (this.totalMem += deltaMem));
+    return res;
   }
-  static apply(hook, input) {
-    const filter = Filter.filters.get(hook);
-    if (!filter || filter.every((f) => !f.active)) return input;
-    const applyOne = (s) => {
-      for (const f of filter) if (f.active) s = f.fn(s);
-      return s;
-    };
-    return Array.isArray(input) ? input.map(applyOne) : applyOne(input);
+  enable = () => {
+    this.active = true;
+  };
+  disable = () => {
+    this.active = false;
+  };
+  clear() {
+    this.store.clear();
+    this.totalTime = 0;
+    this.totalMem = 0;
   }
-  static async applyAsync(hook, input) {
-    const filter = Filter.filters.get(hook);
-    if (!filter || filter.every((f) => !f.active)) return input;
-    const applyOne = async (s) => {
-      for (const f of filter) if (f.active) s = await Promise.resolve(f.fn(s));
-      return s;
-    };
-    return Array.isArray(input)
-      ? Promise.all(input.map(applyOne))
-      : applyOne(input);
+  run(fn, meta = {}) {
+    return this.active ? this.profile(fn, meta) : fn();
   }
-  static clear(hook) {
-    if (hook) Filter.filters.delete(hook);
-    else Filter.filters.clear();
+  async runAsync(fn, meta = {}) {
+    return this.active
+      ? this.profile(async () => await fn(), meta)
+      : await fn();
+  }
+  getAll = () => [...this.store];
+  getLast = () => this.getAll().pop();
+  getTotal = () => ({ time: this.totalTime, mem: this.totalMem });
+  services = Object.freeze({
+    enable: this.enable.bind(this),
+    disable: this.disable.bind(this),
+    clear: this.clear.bind(this),
+    report: this.getAll.bind(this),
+    last: this.getLast.bind(this),
+    total: this.getTotal.bind(this)
+  });
+}
+
+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`
+    );
+  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`
+        );
+      classes[name] = cls;
+    },
+    remove(name) {
+      delete classes[name];
+    },
+    has(name) {
+      return name in classes;
+    },
+    list() {
+      return Object.keys(classes);
+    },
+    get(name) {
+      if (!(name in classes))
+        throw new Error(`Class <${name}> not registered for <${reg}>`);
+      return classes[name];
+    }
+  });
+  registry[reg] = service;
+  factory[reg] = (cls, ...args) => createFromRegistry(reg, cls, ...args);
+  return service;
+}
+function resolveCls(reg, cls) {
+  if (!(reg in registry))
+    throw new ReferenceError(`Registry <${reg}> does not exist`);
+  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
+    });
   }
 }
 
@@ -855,22 +735,20 @@ class RingPool {
   acquire(minSize, allowOversize) {
     const len = this.buffers.length;
     for (let i = 0; i < len; i++) {
-      const idx = (this.pointer + i) % len;
+      const idx = (this.pointer + i) & (len - 1);
       const item = this.buffers[idx];
-      if (item.size >= minSize) {
-        this.pointer = (idx + 1) % len;
-        return allowOversize || item.size === minSize ? item : null;
+      if (item.size >= minSize && (allowOversize || item.size === minSize)) {
+        this.pointer = (idx + 1) & (len - 1);
+        return item;
       }
     }
     return null;
   }
   release(item) {
-    if (this.buffers.length < this.maxSize) {
-      this.buffers.push(item);
-    } else {
-      this.buffers[this.pointer] = item;
-      this.pointer = (this.pointer + 1) % this.maxSize;
-    }
+    if (this.buffers.length < this.maxSize)
+      return void [this.buffers.push(item)];
+    this.buffers[this.pointer] = item;
+    this.pointer = (this.pointer + 1) % this.maxSize;
   }
   clear() {
     this.buffers = [];
@@ -879,8 +757,8 @@ class RingPool {
 }
 class Pool {
   static CONFIG = {
-    uint16: {
-      type: 'uint16',
+    int32: {
+      type: 'int32',
       maxSize: 64,
       maxItemSize: 2048,
       allowOversize: true
@@ -901,7 +779,7 @@ class Pool {
     map: { type: 'map', maxSize: 8, maxItemSize: 0, allowOversize: false }
   };
   static POOLS = {
-    uint16: new RingPool(64),
+    int32: new RingPool(64),
     'number[]': new RingPool(16),
     'string[]': new RingPool(2),
     set: new RingPool(8),
@@ -909,8 +787,8 @@ class Pool {
   };
   static allocate(type, size) {
     switch (type) {
-      case 'uint16':
-        return new Uint16Array(size);
+      case 'int32':
+        return new Int32Array(size);
       case 'number[]':
         return new Float64Array(size);
       case 'string[]':
@@ -925,28 +803,25 @@ class Pool {
     const CONFIG = this.CONFIG[type];
     if (size > CONFIG.maxItemSize) return this.allocate(type, size);
     const item = this.POOLS[type].acquire(size, CONFIG.allowOversize);
-    if (item) {
-      return type === 'uint16' ? item.buffer.subarray(0, size) : item.buffer;
-    }
+    if (item)
+      return type === 'int32' ? item.buffer.subarray(0, size) : item.buffer;
     return this.allocate(type, size);
   }
   static acquireMany(type, sizes) {
     return sizes.map((size) => this.acquire(type, size));
   }
   static release(type, buffer, size) {
-    const CONFIG = this.CONFIG[type];
-    if (size <= CONFIG.maxItemSize) {
+    if (size <= this.CONFIG[type].maxItemSize)
       this.POOLS[type].release({ buffer, size });
-    }
   }
 }
 
 class StructuredData {
+  data;
+  key;
   static create(data, key) {
     return new StructuredData(data, key);
   }
-  data;
-  key;
   constructor(data, key) {
     this.data = data;
     this.key = key;
@@ -959,9 +834,7 @@ class StructuredData {
     }
     return result;
   }
-  extract() {
-    return this.extractFrom(this.data, this.key);
-  }
+  extract = () => this.extractFrom(this.data, this.key);
   isMetricResult(v) {
     return (
       typeof v === 'object' && v !== null && 'a' in v && 'b' in v && 'res' in v
@@ -981,7 +854,7 @@ class StructuredData {
     const first = results[0];
     let normalized = [];
     if (this.isMetricResult(first)) normalized = results;
-    else if (this.isCmpStrResult(first)) {
+    else if (this.isCmpStrResult(first))
       normalized = results.map((r) => ({
         metric: 'unknown',
         a: r.source,
@@ -989,7 +862,10 @@ class StructuredData {
         res: r.match,
         raw: r.raw
       }));
-    }
+    else
+      throw new TypeError(
+        'Unsupported result format for StructuredData normalization.'
+      );
     return normalized.map((r, idx) => ({ ...r, __idx: idx }));
   }
   rebuild(results, sourceData, extractedStrings, removeZero, objectsOnly) {
@@ -1027,118 +903,258 @@ class StructuredData {
           ...(result.raw ? { raw: result.raw } : null)
         };
     }
-    output.length = out;
-    return output;
+    output.length = out;
+    return output;
+  }
+  sort(results, sort) {
+    if (!sort || results.length <= 1) return results;
+    const asc = sort === 'asc';
+    return results.sort((a, b) => (asc ? a.res - b.res : b.res - a.res));
+  }
+  finalizeLookup(results, extractedStrings, opt) {
+    return this.rebuild(
+      this.sort(this.normalizeResults(results), opt?.sort),
+      this.data,
+      extractedStrings,
+      opt?.removeZero,
+      opt?.objectsOnly
+    );
+  }
+  performLookup(fn, extractedStrings, opt) {
+    return this.finalizeLookup(fn(), extractedStrings, opt);
+  }
+  async performLookupAsync(fn, extractedStrings, opt) {
+    return this.finalizeLookup(await fn(), extractedStrings, opt);
+  }
+  lookup(fn, query, opt) {
+    const b = this.extract();
+    try {
+      return this.performLookup(() => fn(query, b, opt), b, opt);
+    } finally {
+      Pool.release('string[]', b, b.length);
+    }
+  }
+  async lookupAsync(fn, query, opt) {
+    const b = this.extract();
+    try {
+      return await this.performLookupAsync(() => fn(query, b, opt), b, opt);
+    } finally {
+      Pool.release('string[]', b, b.length);
+    }
+  }
+  lookupPairs(fn, other, otherKey, opt) {
+    const a = this.extract();
+    const b = this.extractFrom(other, otherKey);
+    try {
+      return this.performLookup(() => fn(a, b, opt), a, opt);
+    } finally {
+      Pool.release('string[]', a, a.length);
+      Pool.release('string[]', b, b.length);
+    }
+  }
+  async lookupPairsAsync(fn, other, otherKey, opt) {
+    const a = this.extract();
+    const b = this.extractFrom(other, otherKey);
+    try {
+      return await this.performLookupAsync(() => fn(a, b, opt), a, opt);
+    } finally {
+      Pool.release('string[]', a, a.length);
+      Pool.release('string[]', b, b.length);
+    }
+  }
+}
+
+class TextAnalyzer {
+  static REGEX = {
+    number: /\d/,
+    sentence: /(?<=[.!?])\s+/,
+    word: /\p{L}+/gu,
+    nonWord: /[^\p{L}]/gu,
+    vowelGroup: /[aeiouy]+/g,
+    letter: /\p{L}/gu,
+    ucLetter: /\p{Lu}/gu
+  };
+  text;
+  words = [];
+  sentences = [];
+  charFrequency = new Map();
+  wordHistogram = new Map();
+  syllableCache = new Map();
+  syllableStats;
+  constructor(input) {
+    this.text = input.trim();
+    this.tokenize();
+    this.computeFrequencies();
+  }
+  tokenize() {
+    let match;
+    const lcText = this.text.toLowerCase();
+    while ((match = TextAnalyzer.REGEX.word.exec(lcText)) !== null)
+      this.words.push(match[0]);
+    this.sentences = this.text
+      .split(TextAnalyzer.REGEX.sentence)
+      .filter(Boolean);
+  }
+  computeFrequencies() {
+    for (const char of this.text)
+      this.charFrequency.set(char, (this.charFrequency.get(char) ?? 0) + 1);
+    for (const word of this.words)
+      this.wordHistogram.set(word, (this.wordHistogram.get(word) ?? 0) + 1);
+  }
+  estimateSyllables(word) {
+    const clean = word
+      .normalize('NFC')
+      .toLowerCase()
+      .replace(TextAnalyzer.REGEX.nonWord, '');
+    if (this.syllableCache.has(clean)) return this.syllableCache.get(clean);
+    const matches = clean.match(TextAnalyzer.REGEX.vowelGroup);
+    const count = matches ? matches.length : 1;
+    this.syllableCache.set(clean, count);
+    return count;
+  }
+  computeSyllableStats() {
+    return (this.syllableStats ||= (() => {
+      const perWord = this.words
+        .map((w) => this.estimateSyllables(w))
+        .sort((a, b) => a - b);
+      const total = perWord.reduce((sum, s) => sum + s, 0);
+      const mono = perWord.filter((s) => s === 1).length;
+      const median = !perWord.length
+        ? 0
+        : perWord.length % 2 === 0
+          ? (perWord[perWord.length / 2 - 1] + perWord[perWord.length / 2]) / 2
+          : perWord[Math.floor(perWord.length / 2)];
+      return {
+        total,
+        mono,
+        perWord,
+        avg: perWord.length ? total / perWord.length : 0,
+        median
+      };
+    })());
+  }
+  getLength = () => this.text.length;
+  getWordCount = () => this.words.length;
+  getSentenceCount = () => this.sentences.length;
+  getAvgWordLength() {
+    return this.words.length
+      ? this.words.join('').length / this.words.length
+      : 0;
+  }
+  getAvgSentenceLength() {
+    return this.sentences.length
+      ? this.words.length / this.sentences.length
+      : 0;
+  }
+  getWordHistogram() {
+    return Object.fromEntries(this.wordHistogram);
+  }
+  getMostCommonWords(limit = 5) {
+    return [...this.wordHistogram.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit)
+      .map((e) => e[0]);
+  }
+  getHapaxLegomena() {
+    return [...this.wordHistogram.entries()]
+      .filter(([, c]) => c === 1)
+      .map((e) => e[0]);
+  }
+  hasNumbers = () => TextAnalyzer.REGEX.number.test(this.text);
+  getUpperCaseRatio() {
+    const matches = this.text.match(TextAnalyzer.REGEX.letter) || [];
+    const upper = this.text.match(TextAnalyzer.REGEX.ucLetter)?.length || 0;
+    return matches.length ? upper / matches.length : 0;
+  }
+  getCharFrequency() {
+    return Object.fromEntries(this.charFrequency);
+  }
+  getUnicodeCodepoints() {
+    const result = {};
+    for (const [char, count] of this.charFrequency) {
+      const block = char
+        .charCodeAt(0)
+        .toString(16)
+        .padStart(4, '0')
+        .toUpperCase();
+      result[block] = (result[block] || 0) + count;
+    }
+    return result;
   }
-  sort(results, sort) {
-    if (!sort || results.length <= 1) return results;
-    const asc = sort === 'asc';
-    return results.sort((a, b) => (asc ? a.res - b.res : b.res - a.res));
+  getLongWordRatio(len = 7) {
+    let long = 0;
+    for (const w of this.words) if (w.length >= len) long++;
+    return this.words.length ? long / this.words.length : 0;
   }
-  performLookup(fn, extractedStrings, opt) {
-    return this.rebuild(
-      this.sort(this.normalizeResults(fn()), opt?.sort),
-      this.data,
-      extractedStrings,
-      opt?.removeZero,
-      opt?.objectsOnly
-    );
+  getShortWordRatio(len = 3) {
+    let short = 0;
+    for (const w of this.words) if (w.length <= len) short++;
+    return this.words.length ? short / this.words.length : 0;
   }
-  async performLookupAsync(fn, extractedStrings, opt) {
-    return this.rebuild(
-      this.sort(this.normalizeResults(await fn()), opt?.sort),
-      this.data,
-      extractedStrings,
-      opt?.removeZero,
-      opt?.objectsOnly
-    );
+  getSyllablesCount() {
+    return this.computeSyllableStats().total;
   }
-  lookup(fn, query, opt) {
-    const b = this.extract();
-    try {
-      return this.performLookup(() => fn(query, b, opt), b, opt);
-    } finally {
-      Pool.release('string[]', b, b.length);
-    }
+  getMonosyllabicWordCount() {
+    return this.computeSyllableStats().mono;
   }
-  lookupPairs(fn, other, otherKey, opt) {
-    const a = this.extract();
-    const b = this.extractFrom(other, otherKey);
-    try {
-      return this.performLookup(() => fn(a, b, opt), a, opt);
-    } finally {
-      Pool.release('string[]', a, a.length);
-      Pool.release('string[]', b, b.length);
-    }
+  getMinSyllablesWordCount(min) {
+    return this.computeSyllableStats().perWord.filter((w) => w >= min).length;
   }
-  async lookupAsync(fn, query, opt) {
-    const b = this.extract();
-    try {
-      return await this.performLookupAsync(() => fn(query, b, opt), b, opt);
-    } finally {
-      Pool.release('string[]', b, b.length);
-    }
+  getMaxSyllablesWordCount(max) {
+    return this.computeSyllableStats().perWord.filter((w) => w <= max).length;
   }
-  async lookupPairsAsync(fn, other, otherKey, opt) {
-    const a = this.extract();
-    const b = this.extractFrom(other, otherKey);
+  getAvgSyllablesPerWord() {
+    return this.computeSyllableStats().avg;
+  }
+  getMedianSyllablesPerWord() {
+    return this.computeSyllableStats().median;
+  }
+  getHonoresR() {
     try {
-      return await this.performLookupAsync(() => fn(a, b, opt), a, opt);
-    } finally {
-      Pool.release('string[]', a, a.length);
-      Pool.release('string[]', b, b.length);
+      return (
+        (100 * Math.log(this.words.length)) /
+        (1 - this.getHapaxLegomena().length / (this.wordHistogram.size ?? 1))
+      );
+    } catch {
+      return 0;
     }
   }
-}
-
-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`
-    );
-  const classes = Object.create(null);
-  const service = {
-    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`
-        );
-      classes[name] = cls;
-    },
-    remove(name) {
-      delete classes[name];
-    },
-    has(name) {
-      return name in classes;
-    },
-    list() {
-      return Object.keys(classes);
-    },
-    get(name) {
-      if (!(name in classes))
-        throw new Error(`Class <${name}> not registered for <${reg}>`);
-      return classes[name];
+  getReadingTime(wpm = 200) {
+    return this.words.length / (wpm ?? 1);
+  }
+  getReadabilityScore(metric = 'flesch') {
+    const w = this.words.length || 1;
+    const s = this.sentences.length || 1;
+    const y = this.getSyllablesCount() || 1;
+    const asl = w / s;
+    const asw = y / w;
+    switch (metric) {
+      case 'flesch':
+        return 206.835 - 1.015 * asl - 84.6 * asw;
+      case 'fleschde':
+        return 180 - asl - 58.5 * asw;
+      case 'kincaid':
+        return 0.39 * asl + 11.8 * asw - 15.59;
     }
-  };
-  registry[reg] = service;
-  factory[reg] = (cls, ...args) => createFromRegistry(reg, cls, ...args);
-  return service;
-}
-function resolveCls(reg, cls) {
-  if (!(reg in registry))
-    throw new ReferenceError(`Registry <${reg}> does not exist`);
-  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}>`, { cause: err });
+  }
+  getLIXScore() {
+    const w = this.words.length || 1;
+    const s = this.sentences.length || 1;
+    const l = this.getLongWordRatio() * w;
+    return w / s + (l / w) * 100;
+  }
+  getWSTFScore() {
+    const w = this.words.length || 1;
+    const h = (this.getMinSyllablesWordCount(3) / w) * 100;
+    const s = this.getAvgSentenceLength();
+    const l = this.getLongWordRatio() * 100;
+    const m = (this.getMonosyllabicWordCount() / w) * 100;
+    return [
+      0.1935 * h + 0.1672 * s + 0.1297 * l - 0.0327 * m - 0.875,
+      0.2007 * h + 0.1682 * s + 0.1373 * l - 2.779,
+      0.2963 * h + 0.1905 * s - 1.1144,
+      0.2744 * h + 0.2656 * s - 1.693
+    ];
   }
 }
 
@@ -1151,17 +1167,12 @@ class Metric {
   origA = [];
   origB = [];
   options;
+  optKey;
   symmetric;
   results;
-  static clear() {
-    this.cache.clear();
-  }
-  static swap(a, b, m, n) {
-    return m > n ? [b, a, n, m] : [a, b, m, n];
-  }
-  static clamp(res) {
-    return Math.max(0, Math.min(1, res));
-  }
+  static clear = () => this.cache.clear();
+  static swap = (a, b, m, n) => (m > n ? [b, a, n, m] : [a, b, m, n]);
+  static clamp = (res) => Math.max(0, Math.min(1, res));
   constructor(metric, a, b, opt = {}, symmetric = false) {
     this.metric = metric;
     this.a = Array.isArray(a) ? a : [a];
@@ -1169,6 +1180,9 @@ class Metric {
     if (this.a.length === 0 || this.b.length === 0)
       throw new Error(`Inputs <a> and <b> must not be empty`);
     this.options = opt;
+    this.optKey = Hasher.fastFNV1a(
+      JSON.stringify(opt, Object.keys(opt).sort())
+    ).toString();
     this.symmetric = symmetric;
   }
   preCompute(a, b, m, n) {
@@ -1189,11 +1203,12 @@ class Metric {
     let result = this.preCompute(A, B, m, n);
     if (!result) {
       result = profiler$2.run(() => {
-        const key = Metric.cache.key(this.metric, [A, B], this.symmetric);
+        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 || '') ??
           (() => {
-            if (this.symmetric) [A, B, m, n] = Metric.swap(A, B, m, n);
             const res = this.compute(A, B, m, n, Math.max(m, n));
             if (key) Metric.cache.set(key, res);
             return res;
@@ -1241,12 +1256,8 @@ class Metric {
     if (b) this.origB = Array.isArray(b) ? b : [b];
     return this;
   }
-  isBatch() {
-    return this.a.length > 1 || this.b.length > 1;
-  }
-  isSingle() {
-    return !this.isBatch();
-  }
+  isBatch = () => this.a.length > 1 || this.b.length > 1;
+  isSingle = () => !this.isBatch();
   isPairwise(safe = false) {
     return this.isBatch() && this.a.length === this.b.length
       ? true
@@ -1255,15 +1266,9 @@ class Metric {
             throw new Error(`Mode <pairwise> requires arrays of equal length`);
           })();
   }
-  isSymmetrical() {
-    return this.symmetric;
-  }
-  whichMode(mode) {
-    return mode ?? this.options?.mode ?? 'default';
-  }
-  clear() {
-    this.results = undefined;
-  }
+  isSymmetrical = () => this.symmetric;
+  whichMode = (mode) => mode ?? this.options?.mode ?? 'default';
+  clear = () => (this.results = undefined);
   run(mode, clear = true) {
     if (clear) this.clear();
     switch (this.whichMode(mode)) {
@@ -1306,9 +1311,7 @@ class Metric {
         throw new Error(`Unsupported async mode <${mode}>`);
     }
   }
-  getMetricName() {
-    return this.metric;
-  }
+  getMetricName = () => this.metric;
   getResults() {
     if (this.results === undefined)
       throw new Error(`run() must be called before getResult()`);
@@ -1331,26 +1334,26 @@ class CosineSimilarity extends Metric {
     const { delimiter = ' ' } = this.options;
     const termsA = this._termFreq(a, delimiter);
     const termsB = this._termFreq(b, delimiter);
-    let dotProduct = 0,
-      magnitudeA = 0,
-      magnitudeB = 0;
-    for (const [term, freqA] of termsA) {
-      const freqB = termsB.get(term) || 0;
-      dotProduct += freqA * freqB;
-      magnitudeA += freqA * freqA;
+    try {
+      let dotP = 0,
+        magA = 0,
+        magB = 0;
+      for (const [term, freqA] of termsA) {
+        const freqB = termsB.get(term) || 0;
+        dotP += freqA * freqB;
+        magA += freqA * freqA;
+      }
+      for (const freqB of termsB.values()) magB += freqB * freqB;
+      magA = Math.sqrt(magA);
+      magB = Math.sqrt(magB);
+      return {
+        res: magA && magB ? Metric.clamp(dotP / (magA * magB)) : 0,
+        raw: { dotProduct: dotP, magnitudeA: magA, magnitudeB: magB }
+      };
+    } finally {
+      Pool.release('map', termsA, termsA.size);
+      Pool.release('map', termsB, termsB.size);
     }
-    for (const freqB of termsB.values()) magnitudeB += freqB * freqB;
-    magnitudeA = Math.sqrt(magnitudeA);
-    magnitudeB = Math.sqrt(magnitudeB);
-    Pool.release('map', termsA, termsA.size);
-    Pool.release('map', termsB, termsB.size);
-    return {
-      res:
-        magnitudeA && magnitudeB
-          ? Metric.clamp(dotProduct / (magnitudeA * magnitudeB))
-          : 0,
-      raw: { dotProduct, magnitudeA, magnitudeB }
-    };
   }
 }
 MetricRegistry.add('cosine', CosineSimilarity);
@@ -1361,36 +1364,38 @@ class DamerauLevenshteinDistance extends Metric {
   }
   compute(a, b, m, n, maxLen) {
     const len = m + 1;
-    const [test, prev, curr] = Pool.acquireMany('uint16', [len, len, len]);
-    for (let i = 0; i <= m; i++) prev[i] = i;
-    for (let j = 1; j <= n; j++) {
-      curr[0] = j;
-      const cb = b.charCodeAt(j - 1);
-      for (let i = 1; i <= m; i++) {
-        const ca = a.charCodeAt(i - 1);
-        const cost = ca === cb ? 0 : 1;
-        let val = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
-        if (
-          i > 1 &&
-          j > 1 &&
-          ca === b.charCodeAt(j - 2) &&
-          cb === a.charCodeAt(i - 2)
-        ) {
-          val = Math.min(val, test[i - 2] + cost);
+    const [test, prev, curr] = Pool.acquireMany('int32', [len, len, len]);
+    try {
+      for (let i = 0; i <= m; i++) prev[i] = i;
+      for (let j = 1; j <= n; j++) {
+        curr[0] = j;
+        const cb = b.charCodeAt(j - 1);
+        for (let i = 1; i <= m; i++) {
+          const ca = a.charCodeAt(i - 1);
+          const cost = ca === cb ? 0 : 1;
+          let val = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+          if (
+            i > 1 &&
+            j > 1 &&
+            ca === b.charCodeAt(j - 2) &&
+            cb === a.charCodeAt(i - 2)
+          )
+            val = Math.min(val, test[i - 2] + cost);
+          curr[i] = val;
         }
-        curr[i] = val;
+        test.set(prev);
+        prev.set(curr);
       }
-      test.set(prev);
-      prev.set(curr);
+      const dist = prev[m];
+      return {
+        res: maxLen === 0 ? 1 : Metric.clamp(1 - dist / maxLen),
+        raw: { dist, maxLen }
+      };
+    } finally {
+      Pool.release('int32', test, len);
+      Pool.release('int32', prev, len);
+      Pool.release('int32', curr, len);
     }
-    const dist = prev[m];
-    Pool.release('uint16', test, len);
-    Pool.release('uint16', prev, len);
-    Pool.release('uint16', curr, len);
-    return {
-      res: maxLen === 0 ? 1 : Metric.clamp(1 - dist / maxLen),
-      raw: { dist, maxLen }
-    };
   }
 }
 MetricRegistry.add('damerau', DamerauLevenshteinDistance);
@@ -1406,19 +1411,22 @@ class DiceSorensenCoefficient extends Metric {
     return bigrams;
   }
   compute(a, b) {
-    const setA = this._bigrams(a);
-    const setB = this._bigrams(b);
-    let intersection = 0;
-    for (const bigram of setA) if (setB.has(bigram)) intersection++;
+    const setA = this._bigrams(a),
+      setB = this._bigrams(b);
     const sizeA = setA.size,
       sizeB = setB.size;
-    const size = sizeA + sizeB;
-    Pool.release('set', setA, sizeA);
-    Pool.release('set', setB, sizeB);
-    return {
-      res: size === 0 ? 1 : Metric.clamp((2 * intersection) / size),
-      raw: { intersection, size }
-    };
+    try {
+      let intersection = 0;
+      for (const bigram of setA) if (setB.has(bigram)) intersection++;
+      const size = sizeA + sizeB;
+      return {
+        res: size === 0 ? 1 : Metric.clamp((2 * intersection) / size),
+        raw: { intersection, size }
+      };
+    } finally {
+      Pool.release('set', setA, sizeA);
+      Pool.release('set', setB, sizeB);
+    }
   }
 }
 MetricRegistry.add('dice', DiceSorensenCoefficient);
@@ -1440,7 +1448,7 @@ class HammingDistance extends Metric {
         );
     }
     let dist = 0;
-    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) dist++;
+    for (let i = 0; i < m; i++) if (a[i] !== b[i]) dist++;
     return { res: m === 0 ? 1 : Metric.clamp(1 - dist / m), raw: { dist } };
   }
 }
@@ -1452,71 +1460,76 @@ class JaccardIndex extends Metric {
   }
   compute(a, b, m, n) {
     const [setA, setB] = Pool.acquireMany('set', [m, n]);
-    for (const A of a) setA.add(A);
-    for (const B of b) setB.add(B);
-    let intersection = 0;
-    for (const c of setA) if (setB.has(c)) intersection++;
-    const union = setA.size + setB.size - intersection;
-    Pool.release('set', setA, m);
-    Pool.release('set', setB, n);
-    return {
-      res: union === 0 ? 1 : Metric.clamp(intersection / union),
-      raw: { intersection, union }
-    };
+    try {
+      for (const A of a) setA.add(A);
+      for (const B of b) setB.add(B);
+      let intersection = 0;
+      for (const c of setA) if (setB.has(c)) intersection++;
+      const union = setA.size + setB.size - intersection;
+      return {
+        res: union === 0 ? 1 : Metric.clamp(intersection / union),
+        raw: { intersection, union }
+      };
+    } finally {
+      Pool.release('set', setA, m);
+      Pool.release('set', setB, n);
+    }
   }
 }
 MetricRegistry.add('jaccard', JaccardIndex);
 
 class JaroWinklerDistance extends Metric {
   constructor(a, b, opt = {}) {
-    super('jaro-winkler', a, b, opt, true);
+    super('jaroWinkler', a, b, opt, true);
   }
   compute(a, b, m, n) {
-    const matchWindow = Math.max(0, Math.floor(n / 2) - 1);
-    const matchA = Pool.acquire('uint16', m);
-    const matchB = Pool.acquire('uint16', n);
-    for (let i = 0; i < m; i++) matchA[i] = 0;
-    for (let i = 0; i < n; i++) matchB[i] = 0;
-    let matches = 0;
-    for (let i = 0; i < m; i++) {
-      const start = Math.max(0, i - matchWindow);
-      const end = Math.min(i + matchWindow + 1, n);
-      for (let j = start; j < end; j++) {
-        if (!matchB[j] && a[i] === b[j]) {
-          matchA[i] = 1;
-          matchB[j] = 1;
-          matches++;
-          break;
-        }
-      }
-    }
-    let transpos = 0,
-      jaro = 0,
-      prefix = 0,
-      res = 0;
-    if (matches > 0) {
-      let k = 0;
+    const [matchA, matchB] = Pool.acquireMany('int32', [m, n]);
+    try {
+      for (let i = 0; i < m; i++) matchA[i] = 0;
+      for (let i = 0; i < n; i++) matchB[i] = 0;
+      const matchWindow = Math.max(0, Math.floor(n / 2) - 1);
+      let matches = 0;
       for (let i = 0; i < m; i++) {
-        if (matchA[i]) {
-          while (!matchB[k]) k++;
-          if (a[i] !== b[k]) transpos++;
-          k++;
+        const start = Math.max(0, i - matchWindow);
+        const end = Math.min(i + matchWindow + 1, n);
+        for (let j = start; j < end; j++) {
+          if (!matchB[j] && a[i] === b[j]) {
+            matchA[i] = 1;
+            matchB[j] = 1;
+            matches++;
+            break;
+          }
         }
       }
-      transpos /= 2;
-      jaro = (matches / m + matches / n + (matches - transpos) / matches) / 3;
-      for (let i = 0; i < Math.min(4, m, n); i++) {
-        if (a[i] === b[i]) prefix++;
-        else break;
+      let transpos = 0,
+        jaro = 0,
+        prefix = 0,
+        res = 0;
+      if (matches > 0) {
+        let k = 0;
+        for (let i = 0; i < m; i++) {
+          if (matchA[i]) {
+            while (!matchB[k]) k++;
+            if (a[i] !== b[k]) transpos++;
+            k++;
+          }
+        }
+        transpos /= 2;
+        jaro = (matches / m + matches / n + (matches - transpos) / matches) / 3;
+        for (let i = 0; i < Math.min(4, m, n); i++) {
+          if (a[i] === b[i]) prefix++;
+          else break;
+        }
+        res = jaro + prefix * 0.1 * (1 - jaro);
       }
-      res = jaro + prefix * 0.1 * (1 - jaro);
+      return {
+        res: Metric.clamp(res),
+        raw: { matchWindow, matches, transpos, jaro, prefix }
+      };
+    } finally {
+      Pool.release('int32', matchA, m);
+      Pool.release('int32', matchB, n);
     }
-    Pool.release('uint16', matchA, m);
-    Pool.release('uint16', matchB, n);
-    return {
-      res: Metric.clamp(res),
-      raw: { matchWindow, matches, transpos, jaro, prefix }
-    };
   }
 }
 MetricRegistry.add('jaroWinkler', JaroWinklerDistance);
@@ -1527,24 +1540,27 @@ class LCSMetric extends Metric {
   }
   compute(a, b, m, n, maxLen) {
     const len = m + 1;
-    const [prev, curr] = Pool.acquireMany('uint16', [len, len]);
-    for (let i = 0; i <= m; i++) prev[i] = 0;
-    for (let j = 1; j <= n; j++) {
-      curr[0] = 0;
-      const cb = b.charCodeAt(j - 1);
-      for (let i = 1; i <= m; i++) {
-        if (a.charCodeAt(i - 1) === cb) curr[i] = prev[i - 1] + 1;
-        else curr[i] = Math.max(prev[i], curr[i - 1]);
+    const [prev, curr] = Pool.acquireMany('int32', [len, len]);
+    try {
+      for (let i = 0; i <= m; i++) prev[i] = 0;
+      for (let j = 1; j <= n; j++) {
+        curr[0] = 0;
+        const cb = b.charCodeAt(j - 1);
+        for (let i = 1; i <= m; i++) {
+          if (a.charCodeAt(i - 1) === cb) curr[i] = prev[i - 1] + 1;
+          else curr[i] = Math.max(prev[i], curr[i - 1]);
+        }
+        prev.set(curr);
       }
-      prev.set(curr);
+      const lcs = prev[m];
+      return {
+        res: maxLen === 0 ? 1 : Metric.clamp(lcs / maxLen),
+        raw: { lcs, maxLen }
+      };
+    } finally {
+      Pool.release('int32', prev, len);
+      Pool.release('int32', curr, len);
     }
-    const lcs = prev[m];
-    Pool.release('uint16', prev, len);
-    Pool.release('uint16', curr, len);
-    return {
-      res: maxLen === 0 ? 1 : Metric.clamp(lcs / maxLen),
-      raw: { lcs, maxLen }
-    };
   }
 }
 MetricRegistry.add('lcs', LCSMetric);
@@ -1555,24 +1571,27 @@ class LevenshteinDistance extends Metric {
   }
   compute(a, b, m, n, maxLen) {
     const len = m + 1;
-    const [prev, curr] = Pool.acquireMany('uint16', [len, len]);
-    for (let i = 0; i <= m; i++) prev[i] = i;
-    for (let j = 1; j <= n; j++) {
-      curr[0] = j;
-      const cb = b.charCodeAt(j - 1);
-      for (let i = 1; i <= m; i++) {
-        const cost = a.charCodeAt(i - 1) === cb ? 0 : 1;
-        curr[i] = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+    const [prev, curr] = Pool.acquireMany('int32', [len, len]);
+    try {
+      for (let i = 0; i <= m; i++) prev[i] = i;
+      for (let j = 1; j <= n; j++) {
+        curr[0] = j;
+        const cb = b.charCodeAt(j - 1);
+        for (let i = 1; i <= m; i++) {
+          const cost = a.charCodeAt(i - 1) === cb ? 0 : 1;
+          curr[i] = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+        }
+        prev.set(curr);
       }
-      prev.set(curr);
+      const dist = prev[m];
+      return {
+        res: maxLen === 0 ? 1 : Metric.clamp(1 - dist / maxLen),
+        raw: { dist, maxLen }
+      };
+    } finally {
+      Pool.release('int32', prev, len);
+      Pool.release('int32', curr, len);
     }
-    const dist = prev[m];
-    Pool.release('uint16', prev, len);
-    Pool.release('uint16', curr, len);
-    return {
-      res: maxLen === 0 ? 1 : Metric.clamp(1 - dist / maxLen),
-      raw: { dist, maxLen }
-    };
   }
 }
 MetricRegistry.add('levenshtein', LevenshteinDistance);
@@ -1584,37 +1603,40 @@ class NeedlemanWunschDistance extends Metric {
   compute(a, b, m, n, maxLen) {
     const { match = 1, mismatch = -1, gap = -1 } = this.options;
     const len = m + 1;
-    const [prev, curr] = Pool.acquireMany('uint16', [len, len]);
-    prev[0] = 0;
-    for (let i = 1; i <= m; i++) prev[i] = prev[i - 1] + gap;
-    for (let j = 1; j <= n; j++) {
-      curr[0] = prev[0] + gap;
-      const cb = b.charCodeAt(j - 1);
-      for (let i = 1; i <= m; i++) {
-        const score = a.charCodeAt(i - 1) === cb ? match : mismatch;
-        curr[i] = Math.max(
-          prev[i - 1] + score,
-          prev[i] + gap,
-          curr[i - 1] + gap
-        );
+    const [prev, curr] = Pool.acquireMany('int32', [len, len]);
+    try {
+      prev[0] = 0;
+      for (let i = 1; i <= m; i++) prev[i] = prev[i - 1] + gap;
+      for (let j = 1; j <= n; j++) {
+        curr[0] = prev[0] + gap;
+        const cb = b.charCodeAt(j - 1);
+        for (let i = 1; i <= m; i++) {
+          const score = a.charCodeAt(i - 1) === cb ? match : mismatch;
+          curr[i] = Math.max(
+            prev[i - 1] + score,
+            prev[i] + gap,
+            curr[i - 1] + gap
+          );
+        }
+        prev.set(curr);
       }
-      prev.set(curr);
+      const score = prev[m];
+      const denum = maxLen * match;
+      return {
+        res: denum === 0 ? 0 : Metric.clamp(score / denum),
+        raw: { score, denum }
+      };
+    } finally {
+      Pool.release('int32', prev, len);
+      Pool.release('int32', curr, len);
     }
-    const score = prev[m];
-    Pool.release('uint16', prev, len);
-    Pool.release('uint16', curr, len);
-    const denum = maxLen * match;
-    return {
-      res: denum === 0 ? 0 : Metric.clamp(score / denum),
-      raw: { score, denum }
-    };
   }
 }
 MetricRegistry.add('needlemanWunsch', NeedlemanWunschDistance);
 
 class QGramSimilarity extends Metric {
   constructor(a, b, opt = {}) {
-    super('qgram', a, b, opt, true);
+    super('qGram', a, b, opt, true);
   }
   _qGrams(str, q) {
     const len = Math.max(0, str.length - q + 1);
@@ -1624,19 +1646,22 @@ class QGramSimilarity extends Metric {
   }
   compute(a, b) {
     const { q = 2 } = this.options;
-    const setA = this._qGrams(a, q);
-    const setB = this._qGrams(b, q);
-    let intersection = 0;
-    for (const gram of setA) if (setB.has(gram)) intersection++;
+    const setA = this._qGrams(a, q),
+      setB = this._qGrams(b, q);
     const sizeA = setA.size,
       sizeB = setB.size;
-    const size = Math.max(sizeA, sizeB);
-    Pool.release('set', setA, sizeA);
-    Pool.release('set', setB, sizeB);
-    return {
-      res: size === 0 ? 1 : Metric.clamp(intersection / size),
-      raw: { intersection, size }
-    };
+    try {
+      let intersection = 0;
+      for (const gram of setA) if (setB.has(gram)) intersection++;
+      const size = Math.max(sizeA, sizeB);
+      return {
+        res: size === 0 ? 1 : Metric.clamp(intersection / size),
+        raw: { intersection, size }
+      };
+    } finally {
+      Pool.release('set', setA, sizeA);
+      Pool.release('set', setB, sizeB);
+    }
   }
 }
 MetricRegistry.add('qGram', QGramSimilarity);
@@ -1648,31 +1673,34 @@ class SmithWatermanDistance extends Metric {
   compute(a, b, m, n) {
     const { match = 2, mismatch = -1, gap = -2 } = this.options;
     const len = m + 1;
-    const [prev, curr] = Pool.acquireMany('uint16', [len, len]);
-    for (let i = 0; i <= m; i++) prev[i] = 0;
+    const [prev, curr] = Pool.acquireMany('int32', [len, len]);
     let maxScore = 0;
-    for (let j = 1; j <= n; j++) {
-      curr[0] = 0;
-      const cb = b.charCodeAt(j - 1);
-      for (let i = 1; i <= m; i++) {
-        const score = a.charCodeAt(i - 1) === cb ? match : mismatch;
-        curr[i] = Math.max(
-          0,
-          prev[i - 1] + score,
-          prev[i] + gap,
-          curr[i - 1] + gap
-        );
-        if (curr[i] > maxScore) maxScore = curr[i];
+    try {
+      for (let i = 0; i <= m; i++) prev[i] = 0;
+      for (let j = 1; j <= n; j++) {
+        curr[0] = 0;
+        const cb = b.charCodeAt(j - 1);
+        for (let i = 1; i <= m; i++) {
+          const score = a.charCodeAt(i - 1) === cb ? match : mismatch;
+          curr[i] = Math.max(
+            0,
+            prev[i - 1] + score,
+            prev[i] + gap,
+            curr[i - 1] + gap
+          );
+          if (curr[i] > maxScore) maxScore = curr[i];
+        }
+        prev.set(curr);
       }
-      prev.set(curr);
+      const denum = Math.min(m * match, n * match);
+      return {
+        res: denum === 0 ? 0 : Metric.clamp(maxScore / denum),
+        raw: { score: maxScore, denum }
+      };
+    } finally {
+      Pool.release('int32', prev, len);
+      Pool.release('int32', curr, len);
     }
-    Pool.release('uint16', prev, len);
-    Pool.release('uint16', curr, len);
-    const denum = Math.min(m * match, n * match);
-    return {
-      res: denum === 0 ? 0 : Metric.clamp(maxScore / denum),
-      raw: { score: maxScore, denum }
-    };
   }
 }
 MetricRegistry.add('smithWaterman', SmithWatermanDistance);
@@ -1683,10 +1711,9 @@ class Phonetic {
   static default;
   algo;
   options;
+  optKey;
   map;
-  static clear() {
-    this.cache.clear();
-  }
+  static clear = () => this.cache.clear();
   constructor(algo, opt = {}) {
     const defaults = this.constructor.default ?? {};
     const mapId = opt.map ?? defaults.map;
@@ -1695,6 +1722,9 @@ class Phonetic {
     if (map === undefined)
       throw new Error(`Requested mapping <${mapId}> is not declared`);
     this.options = merge(merge(defaults, map.options ?? {}), opt);
+    this.optKey = Hasher.fastFNV1a(
+      JSON.stringify(this.options, Object.keys(this.options).sort())
+    ).toString();
     this.algo = algo;
     this.map = map;
   }
@@ -1716,7 +1746,8 @@ class Phonetic {
     for (const rule of ruleset) {
       if (rule.char && rule.char !== char) continue;
       if (rule.position === 'start' && i !== 0) continue;
-      if (rule.position === 'middle' && i > 0 && i < charLen) continue;
+      if (rule.position === 'middle' && (i === 0 || i === charLen - 1))
+        continue;
       if (rule.position === 'end' && i !== charLen) continue;
       if (rule.prev && !rule.prev.includes(prev)) continue;
       if (rule.prevNot && rule.prevNot.includes(prev)) continue;
@@ -1770,9 +1801,7 @@ class Phonetic {
       ? input
       : (input + pad.repeat(length)).slice(0, length);
   }
-  word2Chars(word) {
-    return word.toLowerCase().split('');
-  }
+  word2Chars = (word) => word.toLowerCase().split('');
   exitEarly(code, i) {
     const { length = -1 } = this.options;
     return length > 0 && code.length >= length;
@@ -1783,7 +1812,7 @@ class Phonetic {
   loop(words) {
     const index = [];
     for (const word of words) {
-      const key = Phonetic.cache.key(this.algo, [word]);
+      const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
       const code =
         Phonetic.cache.get(key || '') ??
         (() => {
@@ -1798,14 +1827,20 @@ class Phonetic {
   async loopAsync(words) {
     const index = [];
     for (const word of words) {
-      const code = await Promise.resolve(this.encode(word));
+      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;
   }
-  getAlgoName() {
-    return this.algo;
-  }
+  getAlgoName = () => this.algo;
   getIndex(input) {
     const { delimiter = ' ' } = this.options;
     return profiler$1.run(() =>
@@ -1825,7 +1860,7 @@ const PhoneticRegistry = Registry('phonetic', Phonetic);
 const PhoneticMappingRegistry = (() => {
   const mappings = Object.create(null);
   const maps = (algo) => (mappings[algo] ||= Object.create(null));
-  return {
+  return Object.freeze({
     add(algo, id, map, update = false) {
       const mappings = maps(algo);
       if (!update && id in mappings)
@@ -1846,10 +1881,11 @@ const PhoneticMappingRegistry = (() => {
     list(algo) {
       return Object.keys(maps(algo));
     }
-  };
+  });
 })();
 
 class Caverphone extends Phonetic {
+  static REGEX = { uppercase: /[^A-Z]/gi };
   static default = {
     map: 'en2',
     delimiter: ' ',
@@ -1861,15 +1897,11 @@ class Caverphone extends Phonetic {
     super('caverphone', opt);
   }
   encode(word) {
-    word = word.replace(/[^A-Z]/gi, '').toLowerCase();
+    word = word.replace(Caverphone.REGEX.uppercase, '').toLowerCase();
     return super.encode(word);
   }
-  mapChar(char) {
-    return char;
-  }
-  adjustCode(code) {
-    return code.toUpperCase();
-  }
+  mapChar = (char) => char;
+  adjustCode = (code) => code.toUpperCase();
 }
 PhoneticRegistry.add('caverphone', Caverphone);
 PhoneticMappingRegistry.add('caverphone', 'en1', {
@@ -2028,6 +2060,7 @@ PhoneticMappingRegistry.add('cologne', 'default', {
 });
 
 class Metaphone extends Phonetic {
+  static REGEX = { adjacent: /([A-BD-Z])\1+/gi, vowel: /[AEIOU]/g };
   static default = {
     map: 'en90',
     delimiter: ' ',
@@ -2039,11 +2072,13 @@ class Metaphone extends Phonetic {
     super('metaphone', opt);
   }
   encode(word) {
-    word = word.replace(/([A-BD-Z])\1+/gi, (m, c) => (c === 'C' ? m : c));
+    word = word.replace(Metaphone.REGEX.adjacent, (m, c) =>
+      c === 'C' ? m : c
+    );
     return super.encode(word);
   }
   adjustCode(code) {
-    return code.slice(0, 1) + code.slice(1).replace(/[AEIOU]/g, '');
+    return code.slice(0, 1) + code.slice(1).replace(Metaphone.REGEX.vowel, '');
   }
 }
 PhoneticRegistry.add('metaphone', Metaphone);
@@ -2202,6 +2237,7 @@ PhoneticMappingRegistry.add('soundex', 'de', {
 const profiler = Profiler.getInstance();
 class CmpStr {
   static filter = {
+    has: Filter.has,
     add: Filter.add,
     remove: Filter.remove,
     pause: Filter.pause,
@@ -2233,12 +2269,8 @@ class CmpStr {
     metric: Metric.clear,
     phonetic: Phonetic.clear
   };
-  static analyze(input) {
-    return new TextAnalyzer(input);
-  }
-  static diff(a, b, opt) {
-    return new DiffChecker(a, b, opt);
-  }
+  static analyze = (input) => new TextAnalyzer(input);
+  static diff = (a, b, opt) => new DiffChecker(a, b, opt);
   static create(opt) {
     return new CmpStr(opt);
   }
@@ -2295,7 +2327,7 @@ class CmpStr {
   }
   index(input, { algo, opt }) {
     this.assert('phonetic', algo);
-    const phonetic = factory.phonetic(algo, opt);
+    const phonetic = factory['phonetic'](algo, opt);
     const delimiter = opt?.delimiter ?? ' ';
     return Array.isArray(input)
       ? input.map((s) => phonetic.getIndex(s).join(delimiter))
@@ -2318,7 +2350,7 @@ class CmpStr {
     ) {
       return [];
     }
-    const metric = factory.metric(resolved.metric, A, B, resolved.opt);
+    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);
@@ -2331,9 +2363,7 @@ class CmpStr {
         ? result.map((r) => ({ source: r.a, target: r.b, match: r.res }))
         : { source: result.a, target: result.b, match: result.res };
   }
-  clone() {
-    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
-  }
+  clone = () => Object.assign(Object.create(Object.getPrototypeOf(this)), this);
   reset() {
     for (const k in this.options) delete this.options[k];
     return this;
@@ -2358,33 +2388,15 @@ class CmpStr {
     rmv(this.options, path);
     return this;
   }
-  setRaw(enable) {
-    return this.setOption('raw', enable);
-  }
-  setMetric(name) {
-    return this.setOption('metric', name);
-  }
-  setFlags(flags) {
-    return this.setOption('flags', flags);
-  }
-  rmvFlags() {
-    return this.rmvOption('flags');
-  }
-  setProcessors(opt) {
-    return this.setOption('processors', opt);
-  }
-  rmvProcessors() {
-    return this.rmvOption('processors');
-  }
-  getOptions() {
-    return this.options;
-  }
-  getSerializedOptions() {
-    return JSON.stringify(this.options);
-  }
-  getOption(path) {
-    return get(this.options, path);
-  }
+  setRaw = (enable) => this.setOption('raw', enable);
+  setMetric = (name) => this.setOption('metric', name);
+  setFlags = (flags) => this.setOption('flags', flags);
+  rmvFlags = () => this.rmvOption('flags');
+  setProcessors = (opt) => this.setOption('processors', opt);
+  rmvProcessors = () => this.rmvOption('processors');
+  getOptions = () => this.options;
+  getSerializedOptions = () => JSON.stringify(this.options);
+  getOption = (path) => get(this.options, path);
   test(a, b, opt) {
     return this.compute(a, b, opt, 'single');
   }
@@ -2498,7 +2510,7 @@ class CmpStrAsync extends CmpStr {
   }
   async indexAsync(input, { algo, opt }) {
     this.assert('phonetic', algo);
-    const phonetic = factory.phonetic(algo, opt);
+    const phonetic = factory['phonetic'](algo, opt);
     const delimiter = opt?.delimiter ?? ' ';
     return Array.isArray(input)
       ? Promise.all(
@@ -2522,7 +2534,7 @@ class CmpStrAsync extends CmpStr {
     ) {
       return [];
     }
-    const metric = factory.metric(resolved.metric, A, B, resolved.opt);
+    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);
@@ -2632,6 +2644,7 @@ export {
   DiffChecker,
   Filter,
   HashTable,
+  Hasher,
   Metric,
   MetricRegistry,
   Normalizer,