cmpstr 3.2.1 → 3.3.0

package/dist/esm/utils/Normalizer.mjs

@@ -1,4 +1,5 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+import { ErrorUtil } from './Errors.mjs';
 import { HashTable } from './HashTable.mjs';
 
 class Normalizer {
@@ -15,42 +16,91 @@ class Normalizer {
     return Array.from(new Set(flags)).sort().join('');
   }
   static getPipeline(flags) {
-    if (Normalizer.pipeline.has(flags)) return Normalizer.pipeline.get(flags);
-    const { REGEX } = Normalizer;
-    const steps = [
-      ['d', (s) => s.normalize('NFD')],
-      ['i', (s) => s.toLowerCase()],
-      ['k', (s) => s.replace(REGEX.nonLetters, '')],
-      ['n', (s) => s.replace(REGEX.nonNumbers, '')],
-      ['r', (s) => s.replace(REGEX.doubleChars, '$1')],
-      ['s', (s) => s.replace(REGEX.specialChars, '')],
-      ['t', (s) => s.trim()],
-      ['u', (s) => s.normalize('NFC')],
-      ['w', (s) => s.replace(REGEX.whitespace, ' ')],
-      ['x', (s) => s.normalize('NFKC')]
-    ];
-    const pipeline = steps
-      .filter(([f]) => flags.includes(f))
-      .map(([, fn]) => fn);
-    const fn = (s) => pipeline.reduce((v, f) => f(v), s);
-    Normalizer.pipeline.set(flags, fn);
-    return fn;
+    return ErrorUtil.wrap(
+      () => {
+        const cached = Normalizer.pipeline.get(flags);
+        if (cached) return cached;
+        const { REGEX } = Normalizer;
+        const steps = [];
+        for (let i = 0; i < flags.length; i++) {
+          switch (flags[i]) {
+            case 'd':
+              steps.push((s) => s.normalize('NFD'));
+              break;
+            case 'i':
+              steps.push((s) => s.toLowerCase());
+              break;
+            case 'k':
+              steps.push((s) => s.replace(REGEX.nonLetters, ''));
+              break;
+            case 'n':
+              steps.push((s) => s.replace(REGEX.nonNumbers, ''));
+              break;
+            case 'r':
+              steps.push((s) => s.replace(REGEX.doubleChars, '$1'));
+              break;
+            case 's':
+              steps.push((s) => s.replace(REGEX.specialChars, ''));
+              break;
+            case 't':
+              steps.push((s) => s.trim());
+              break;
+            case 'u':
+              steps.push((s) => s.normalize('NFC'));
+              break;
+            case 'w':
+              steps.push((s) => s.replace(REGEX.whitespace, ' '));
+              break;
+            case 'x':
+              steps.push((s) => s.normalize('NFKC'));
+              break;
+          }
+        }
+        const fn = (input) => {
+          let v = input;
+          for (let i = 0; i < steps.length; i++) v = steps[i](v);
+          return v;
+        };
+        Normalizer.pipeline.set(flags, fn);
+        return fn;
+      },
+      `Failed to create normalization pipeline for flags: ${flags}`,
+      { flags }
+    );
   }
-  static normalize(input, flags) {
-    if (!flags || typeof flags !== 'string' || !input) return input;
-    flags = this.canonicalFlags(flags);
-    if (Array.isArray(input))
-      return input.map((s) => Normalizer.normalize(s, flags));
-    const key = Normalizer.cache.key(flags, [input]);
-    if (key && Normalizer.cache.has(key)) return Normalizer.cache.get(key);
-    const res = Normalizer.getPipeline(flags)(input);
-    if (key) Normalizer.cache.set(key, res);
-    return res;
+  static normalize(input, flags, normalizedFlags) {
+    return ErrorUtil.wrap(
+      () => {
+        if (!flags || typeof flags !== 'string' || !input) return input;
+        flags = normalizedFlags ?? this.canonicalFlags(flags);
+        const pipeline = Normalizer.getPipeline(flags);
+        const normalizeOne = (s) => {
+          const key = Normalizer.cache.key(flags, [s]);
+          if (key && Normalizer.cache.has(key))
+            return Normalizer.cache.get(key);
+          const res = pipeline(s);
+          if (key) Normalizer.cache.set(key, res);
+          return res;
+        };
+        return Array.isArray(input)
+          ? input.map(normalizeOne)
+          : normalizeOne(input);
+      },
+      `Failed to normalize input with flags: ${flags}`,
+      { input, flags }
+    );
   }
   static async normalizeAsync(input, flags) {
-    return await (Array.isArray(input)
-      ? Promise.all(input.map((s) => Normalizer.normalize(s, flags)))
-      : Promise.resolve(Normalizer.normalize(input, flags)));
+    return await ErrorUtil.wrapAsync(
+      async () => {
+        if (!flags || typeof flags !== 'string' || !input) return input;
+        return await (Array.isArray(input)
+          ? Promise.all(input.map((s) => Normalizer.normalize(s, flags)))
+          : Promise.resolve(Normalizer.normalize(input, flags)));
+      },
+      `Failed to asynchronously normalize input with flags: ${flags}`,
+      { input, flags }
+    );
   }
   static clear() {
     Normalizer.pipeline.clear();
@@ -59,4 +109,3 @@ class Normalizer {
 }
 
 export { Normalizer };
-//# sourceMappingURL=Normalizer.mjs.map

package/dist/esm/utils/OptionsValidator.mjs

@@ -0,0 +1,210 @@
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+import { CmpStrValidationError } from './Errors.mjs';
+import '../metric/Cosine.mjs';
+import '../metric/DamerauLevenshtein.mjs';
+import '../metric/DiceSorensen.mjs';
+import '../metric/Hamming.mjs';
+import '../metric/Jaccard.mjs';
+import '../metric/JaroWinkler.mjs';
+import '../metric/LCS.mjs';
+import '../metric/Levenshtein.mjs';
+import '../metric/NeedlemanWunsch.mjs';
+import '../metric/QGram.mjs';
+import '../metric/SmithWaterman.mjs';
+import { MetricRegistry } from '../metric/Metric.mjs';
+import '../phonetic/Caverphone.mjs';
+import '../phonetic/Cologne.mjs';
+import '../phonetic/Metaphone.mjs';
+import '../phonetic/Soundex.mjs';
+import { PhoneticRegistry } from '../phonetic/Phonetic.mjs';
+
+class OptionsValidator {
+  static ALLOWED_FLAGS = new Set([
+    'd',
+    'u',
+    'x',
+    'w',
+    't',
+    'r',
+    's',
+    'k',
+    'n',
+    'i'
+  ]);
+  static ALLOWED_OUTPUT = new Set(['orig', 'prep']);
+  static ALLOWED_MODES = new Set(['default', 'batch', 'single', 'pairwise']);
+  static ALLOWED_SORT = new Set(['asc', 'desc']);
+  static PROCESSORS = {
+    phonetic: (opt) => {
+      if (!opt) return;
+      OptionsValidator.validatePhoneticName(opt.algo);
+      OptionsValidator.validatePhoneticOptions(opt.opt);
+    }
+  };
+  static METRIC_OPT_MAP = {
+    mode: (v) => OptionsValidator.validateMode(v),
+    delimiter: (v) => OptionsValidator.validateString(v, 'opt.delimiter'),
+    pad: (v) => OptionsValidator.validateString(v, 'opt.pad'),
+    q: (v) => OptionsValidator.validateNumber(v, 'opt.q'),
+    match: (v) => OptionsValidator.validateNumber(v, 'opt.match'),
+    mismatch: (v) => OptionsValidator.validateNumber(v, 'opt.mismatch'),
+    gap: (v) => OptionsValidator.validateNumber(v, 'opt.gap')
+  };
+  static PHONETIC_OPT_MAP = {
+    map: (v) =>
+      OptionsValidator.validateString(v, 'processors.phonetic.opt.map'),
+    delimiter: (v) =>
+      OptionsValidator.validateString(v, 'processors.phonetic.opt.delimiter'),
+    length: (v) =>
+      OptionsValidator.validateNumber(v, 'processors.phonetic.opt.length'),
+    pad: (v) =>
+      OptionsValidator.validateString(v, 'processors.phonetic.opt.pad'),
+    dedupe: (v) =>
+      OptionsValidator.validateBoolean(v, 'processors.phonetic.opt.dedupe'),
+    fallback: (v) =>
+      OptionsValidator.validateString(v, 'processors.phonetic.opt.fallback')
+  };
+  static CMPSTR_OPT_MAP = {
+    raw: (v) => OptionsValidator.validateBoolean(v, 'raw'),
+    removeZero: (v) => OptionsValidator.validateBoolean(v, 'removeZero'),
+    safeEmpty: (v) => OptionsValidator.validateBoolean(v, 'safeEmpty'),
+    flags: (v) => OptionsValidator.validateFlags(v),
+    metric: (v) => OptionsValidator.validateMetricName(v),
+    output: (v) => OptionsValidator.validateOutput(v),
+    opt: (v) => OptionsValidator.validateMetricOptions(v),
+    processors: (v) => OptionsValidator.validateProcessors(v),
+    sort: (v) => OptionsValidator.validateSort(v, 'sort'),
+    objectsOnly: (v) => OptionsValidator.validateBoolean(v, 'objectsOnly')
+  };
+  static set2string(set) {
+    return Array.from(set).join(' | ');
+  }
+  static validateType(value, name, type) {
+    if (value === undefined) return;
+    if (typeof value !== type || (type === 'number' && Number.isNaN(value))) {
+      throw new CmpStrValidationError(
+        `Invalid option <${name}>: expected ${type}`,
+        { name, value }
+      );
+    }
+  }
+  static validateEnum(value, name, set) {
+    if (value === undefined) return;
+    if (typeof value !== 'string' || !set.has(value)) {
+      throw new CmpStrValidationError(
+        `Invalid option <${name}>: expected ${OptionsValidator.set2string(set)}`,
+        { name, value }
+      );
+    }
+  }
+  static validateMap(opt, map) {
+    if (!opt) return;
+    for (const k in opt) {
+      const fn = map[k];
+      if (!fn)
+        throw new CmpStrValidationError(`Invalid option <${k}>`, {
+          option: k,
+          value: map[k]
+        });
+      fn(opt[k]);
+    }
+  }
+  static validateRegistryName(value, name, label, has, list) {
+    if (value === undefined) return;
+    if (typeof value !== 'string' || value.length === 0)
+      throw new CmpStrValidationError(
+        `Invalid option <${name}>: expected non-empty string`,
+        { name, value }
+      );
+    if (!has(value))
+      throw new CmpStrValidationError(`${label} <${value}> is not registered`, {
+        name,
+        value,
+        available: list()
+      });
+  }
+  static validateBoolean(value, name) {
+    OptionsValidator.validateType(value, name, 'boolean');
+  }
+  static validateNumber(value, name) {
+    OptionsValidator.validateType(value, name, 'number');
+  }
+  static validateString(value, name) {
+    OptionsValidator.validateType(value, name, 'string');
+  }
+  static validateFlags(value) {
+    if (value === undefined) return;
+    if (typeof value !== 'string')
+      throw new CmpStrValidationError(
+        `Invalid option <flags>: expected string`,
+        { flags: value }
+      );
+    for (let i = 0; i < value.length; i++) {
+      const ch = value[i];
+      if (!OptionsValidator.ALLOWED_FLAGS.has(ch))
+        throw new CmpStrValidationError(
+          `Invalid normalization flag <${ch}> in <flags>: expected ${OptionsValidator.set2string(OptionsValidator.ALLOWED_FLAGS)}`,
+          { flags: value, invalid: ch }
+        );
+    }
+  }
+  static validateOutput(value) {
+    OptionsValidator.validateEnum(
+      value,
+      'output',
+      OptionsValidator.ALLOWED_OUTPUT
+    );
+  }
+  static validateMode(value) {
+    OptionsValidator.validateEnum(
+      value,
+      'mode',
+      OptionsValidator.ALLOWED_MODES
+    );
+  }
+  static validateSort(value, name) {
+    if (value === undefined || typeof value === 'boolean') return;
+    OptionsValidator.validateEnum(value, name, OptionsValidator.ALLOWED_SORT);
+  }
+  static validateMetricName(value) {
+    OptionsValidator.validateRegistryName(
+      value,
+      'metric',
+      'Comparison metric',
+      MetricRegistry.has,
+      MetricRegistry.list
+    );
+  }
+  static validatePhoneticName(value) {
+    OptionsValidator.validateRegistryName(
+      value,
+      'phonetic',
+      'Phonetic algorithm',
+      PhoneticRegistry.has,
+      PhoneticRegistry.list
+    );
+  }
+  static validateMetricOptions(opt) {
+    OptionsValidator.validateMap(opt, OptionsValidator.METRIC_OPT_MAP);
+  }
+  static validatePhoneticOptions(opt) {
+    OptionsValidator.validateMap(opt, OptionsValidator.PHONETIC_OPT_MAP);
+  }
+  static validateProcessors(opt) {
+    if (!opt) return;
+    for (const key in opt) {
+      const fn = OptionsValidator.PROCESSORS[key];
+      if (!fn)
+        throw new CmpStrValidationError(
+          `Invalid processor type <${key}> in <processors>: expected ${Object.keys(OptionsValidator.PROCESSORS).join(' | ')}`,
+          { processors: opt, invalid: key }
+        );
+      fn(opt[key]);
+    }
+  }
+  static validateOptions(opt) {
+    OptionsValidator.validateMap(opt, OptionsValidator.CMPSTR_OPT_MAP);
+  }
+}
+
+export { OptionsValidator };

package/dist/esm/utils/Pool.mjs

@@ -1,4 +1,6 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+import { CmpStrUsageError, ErrorUtil } from './Errors.mjs';
+
 class RingPool {
   maxSize;
   buffers = [];
@@ -7,22 +9,39 @@ class RingPool {
     this.maxSize = maxSize;
   }
   acquire(minSize, allowOversize) {
-    const len = this.buffers.length;
-    for (let i = 0; i < len; i++) {
-      const idx = (this.pointer + i) & (len - 1);
-      const item = this.buffers[idx];
-      if (item.size >= minSize && (allowOversize || item.size === minSize)) {
-        this.pointer = (idx + 1) & (len - 1);
-        return item;
-      }
-    }
-    return null;
+    return ErrorUtil.wrap(
+      () => {
+        const buffers = this.buffers;
+        const len = buffers.length;
+        for (let i = 0; i < len; i++) {
+          const idx = (this.pointer + i) % len;
+          const item = buffers[idx];
+          const size = item.size;
+          if (size >= minSize && (allowOversize || size === minSize)) {
+            this.pointer = (idx + 1) % len;
+            return item;
+          }
+        }
+        return null;
+      },
+      `Failed to acquire buffer of size >= ${minSize} from pool`,
+      { minSize, allowOversize }
+    );
   }
   release(item) {
-    if (this.buffers.length < this.maxSize)
-      return void [this.buffers.push(item)];
-    this.buffers[this.pointer] = item;
-    this.pointer = (this.pointer + 1) % this.maxSize;
+    ErrorUtil.wrap(
+      () => {
+        const buffers = this.buffers;
+        if (buffers.length < this.maxSize) {
+          buffers.push(item);
+          return;
+        }
+        buffers[this.pointer] = item;
+        this.pointer = (this.pointer + 1) % this.maxSize;
+      },
+      `Failed to release buffer back to pool`,
+      { item }
+    );
   }
   clear() {
     this.buffers = [];
@@ -37,6 +56,12 @@ class Pool {
       maxItemSize: 2048,
       allowOversize: true
     },
+    'arr[]': {
+      type: 'arr[]',
+      maxSize: 4,
+      maxItemSize: 1024,
+      allowOversize: false
+    },
     'number[]': {
       type: 'number[]',
       maxSize: 16,
@@ -54,6 +79,7 @@ class Pool {
   };
   static POOLS = {
     int32: new RingPool(64),
+    'arr[]': new RingPool(4),
     'number[]': new RingPool(16),
     'string[]': new RingPool(2),
     set: new RingPool(8),
@@ -63,6 +89,8 @@ class Pool {
     switch (type) {
       case 'int32':
         return new Int32Array(size);
+      case 'arr[]':
+        return new Array(size);
       case 'number[]':
         return new Float64Array(size);
       case 'string[]':
@@ -75,6 +103,8 @@ class Pool {
   }
   static acquire(type, size) {
     const CONFIG = this.CONFIG[type];
+    if (!CONFIG)
+      throw new CmpStrUsageError(`Unsupported pool type <${type}>`, { type });
     if (size > CONFIG.maxItemSize) return this.allocate(type, size);
     const item = this.POOLS[type].acquire(size, CONFIG.allowOversize);
     if (item)
@@ -82,13 +112,17 @@ class Pool {
     return this.allocate(type, size);
   }
   static acquireMany(type, sizes) {
-    return sizes.map((size) => this.acquire(type, size));
+    const out = new Array(sizes.length);
+    for (let i = 0; i < sizes.length; i++)
+      out[i] = this.acquire(type, sizes[i]);
+    return out;
   }
   static release(type, buffer, size) {
-    if (size <= this.CONFIG[type].maxItemSize)
-      this.POOLS[type].release({ buffer, size });
+    const CONFIG = this.CONFIG[type];
+    if (!CONFIG)
+      throw new CmpStrUsageError(`Unsupported pool type <${type}>`, { type });
+    if (size <= CONFIG.maxItemSize) this.POOLS[type].release({ buffer, size });
   }
 }
 
 export { Pool };
-//# sourceMappingURL=Pool.mjs.map

package/dist/esm/utils/Profiler.mjs

@@ -1,15 +1,17 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 class Profiler {
   active;
   static ENV;
   static instance;
   nowFn;
   memFn;
-  store = new Set();
+  store = [];
+  last;
   totalTime = 0;
   totalMem = 0;
   static detectEnv() {
-    if (typeof process !== 'undefined') Profiler.ENV = 'nodejs';
+    if (typeof process !== 'undefined' && process.versions?.node)
+      Profiler.ENV = 'nodejs';
     else if (typeof performance !== 'undefined') Profiler.ENV = 'browser';
     else Profiler.ENV = 'unknown';
   }
@@ -21,7 +23,7 @@ class Profiler {
     this.active = active;
     switch (Profiler.ENV) {
       case 'nodejs':
-        this.nowFn = () => Number(process.hrtime.bigint()) / 1e6;
+        this.nowFn = () => Number(process.hrtime.bigint()) * 1e-6;
         this.memFn = () => process.memoryUsage().heapUsed;
         break;
       case 'browser':
@@ -34,40 +36,52 @@ class Profiler {
         break;
     }
   }
-  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;
+  storeRes(entry) {
+    this.store.push((this.last = entry));
+    this.totalTime += entry.time;
+    this.totalMem += entry.mem;
   }
-  enable = () => {
+  enable() {
     this.active = true;
-  };
-  disable = () => {
+  }
+  disable() {
     this.active = false;
-  };
+  }
   clear() {
-    this.store.clear();
+    this.store.length = 0;
+    this.last = undefined;
     this.totalTime = 0;
     this.totalMem = 0;
   }
   run(fn, meta = {}) {
-    return this.active ? this.profile(fn, meta) : fn();
+    if (!this.active) return fn();
+    const startTime = this.nowFn(),
+      startMem = this.memFn();
+    const res = fn();
+    const deltaTime = this.nowFn() - startTime,
+      deltaMem = this.memFn() - startMem;
+    this.storeRes({ time: deltaTime, mem: deltaMem, res, meta });
+    return res;
   }
   async runAsync(fn, meta = {}) {
-    return this.active
-      ? this.profile(async () => await fn(), meta)
-      : await fn();
+    if (!this.active) return fn();
+    const startTime = this.nowFn(),
+      startMem = this.memFn();
+    const res = await fn();
+    const deltaTime = this.nowFn() - startTime,
+      deltaMem = this.memFn() - startMem;
+    this.storeRes({ time: deltaTime, mem: deltaMem, res, meta });
+    return res;
+  }
+  getAll() {
+    return [...this.store];
+  }
+  getLast() {
+    return this.last;
+  }
+  getTotal() {
+    return { time: this.totalTime, mem: this.totalMem };
   }
-  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),
@@ -79,4 +93,3 @@ class Profiler {
 }
 
 export { Profiler };
-//# sourceMappingURL=Profiler.mjs.map

package/dist/esm/utils/Registry.mjs

@@ -1,20 +1,37 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+import { ErrorUtil, CmpStrNotFoundError } from './Errors.mjs';
+
 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`
-    );
+  ErrorUtil.assert(
+    !(reg in registry || reg in factory),
+    `Registry <${reg}> already exists / overwriting is forbidden`,
+    { registry: reg }
+  );
   const classes = Object.create(null);
   const service = Object.freeze({
     add(name, cls, update = false) {
-      if (!(cls.prototype instanceof ctor))
-        throw new TypeError(`Class must extend <${reg}>`);
-      if (!update && name in classes)
-        throw new Error(
-          `Entry <${name}> already exists / use <update=true> to overwrite`
-        );
+      ErrorUtil.assert(
+        typeof name === 'string' && name.length > 0,
+        `Class name must be a non-empty string`,
+        { registry: reg, name }
+      );
+      ErrorUtil.assert(
+        typeof cls === 'function',
+        `Class must be a constructor function`,
+        { registry: reg, class: cls }
+      );
+      ErrorUtil.assert(
+        cls.prototype instanceof ctor,
+        `Class must extend <${reg}>`,
+        { registry: reg, class: cls }
+      );
+      ErrorUtil.assert(
+        update || !(name in classes),
+        `Class <${name}> already exists / use <update=true> to overwrite`,
+        { registry: reg, name }
+      );
       classes[name] = cls;
     },
     remove(name) {
@@ -27,8 +44,16 @@ function Registry(reg, ctor) {
       return Object.keys(classes);
     },
     get(name) {
-      if (!(name in classes))
-        throw new Error(`Class <${name}> not registered for <${reg}>`);
+      ErrorUtil.assert(
+        typeof name === 'string' && name.length > 0,
+        `Class name must be a non-empty string`,
+        { registry: reg, name }
+      );
+      ErrorUtil.assert(
+        name in classes,
+        `Class <${name}> not registered for <${reg}>`,
+        { registry: reg, name }
+      );
       return classes[name];
     }
   });
@@ -38,19 +63,18 @@ function Registry(reg, ctor) {
 }
 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;
+    throw new CmpStrNotFoundError(`Registry <${reg}> does not exist`, {
+      registry: reg
+    });
+  return typeof cls === 'string' ? registry[reg].get(cls) : cls;
 }
 function createFromRegistry(reg, cls, ...args) {
-  cls = resolveCls(reg, cls);
-  try {
-    return new cls(...args);
-  } catch (err) {
-    throw new Error(`Cannot instantiate class <${cls.name ?? cls}>`, {
-      cause: err
-    });
-  }
+  const ctor = resolveCls(reg, cls);
+  return ErrorUtil.wrap(
+    () => new ctor(...args),
+    `Failed to create instance of class <${ctor.name ?? cls}> from registry <${reg}>`,
+    { registry: reg, class: cls, args }
+  );
 }
 
 export { Registry, createFromRegistry, factory, registry, resolveCls };
-//# sourceMappingURL=Registry.mjs.map