@xyo-network/module-resolver 2.107.3 → 2.107.4

package/dist/neutral/index.js

@@ -1,2 +1,490 @@
-var S=Object.defineProperty;var n=(u,e)=>S(u,"name",{value:e,configurable:!0});import{assertEx as y}from"@xylabs/assert";import{Base as j,toJsonString as w}from"@xylabs/object";import{asModuleInstance as g,ObjectResolverPriority as H}from"@xyo-network/module-model";var c=class extends j{static{n(this,"AbstractModuleResolver")}get priority(){return this.params.priority??H.Normal}set priority(e){this.params.priority=e}get root(){return y(this.params.root,()=>"root is not set")}async resolve(e="*",t){if(e==="*"){let r=await this.resolveHandler(e,t);return y(Array.isArray(r),()=>"resolveHandler returned a non-array"),r.map(s=>g(s,()=>`resolveHandler returned invalid result (*) [${s?.constructor?.name}][${w(s)}]`))}switch(typeof e){case"string":{let[r]=await this.resolveHandler(e,t);return g(r,()=>`resolveHandler returned invalid result (string) [${r?.constructor?.name}][${w(r)}]`)}default:{let r=await this.resolveHandler(e,t);return y(Array.isArray(r),()=>"resolveHandler returned a non-array"),r.map(s=>g(s,()=>`resolveHandler returned invalid result (filter) [${s?.constructor?.name}][${w(s)}]`))}}}async resolvePrivate(e,t){if(e==="*")return await Promise.resolve([])}};import{assertEx as x}from"@xylabs/assert";import{exists as m}from"@xylabs/exists";import{duplicateModules as A,ObjectResolverPriority as _,ResolveHelper as P}from"@xyo-network/module-model";import{LRUCache as q}from"lru-cache";import{assertEx as f}from"@xylabs/assert";import{isAddress as M}from"@xylabs/hex";import{compact as R}from"@xylabs/lodash";import{isAddressModuleFilter as $,isModuleName as B,isNameModuleFilter as E,isQueryModuleFilter as T}from"@xyo-network/module-model";var h=class extends c{static{n(this,"SimpleModuleResolver")}modules={};nameToModule={};constructor(e){super(e)}get allowNameResolution(){return this.params.allowNameResolution??!0}add(e){if(Array.isArray(e))for(let t of e)this.addSingleModule(t);else this.addSingleModule(e);return this}addResolver(e){throw"Adding resolvers not supported"}remove(e){if(Array.isArray(e))for(let t of e)this.removeSingleModule(t);else this.removeSingleModule(e);return this}removeResolver(e){throw"Removing resolvers not supported"}resolveHandler(e="*",t){let r=(()=>{if(e)if(typeof e=="string"){if(e==="*")return Object.values(this.modules);let o=e,l=B(o)?o:void 0,i=M(o)?o:void 0;return f(l||i,()=>"module identifier must be a ModuleName or Address"),(l?this.resolveByName(Object.values(this.modules),[l]).pop():void 0)??(i?this.resolveByAddress(this.modules,[i]).pop():void 0)}else{let o=e;if($(o))return this.resolveByAddress(this.modules,o.address);if(E(o))return this.resolveByName(Object.values(this.modules),o.name);if(T(o))return this.resolveByQuery(Object.values(this.modules),o.query)}else return Object.values(this.modules)})(),s=t?.identity;return s?Array.isArray(r)?r?.filter(o=>s(o)):s(r)?[r]:[]:r?Array.isArray(r)?r:[r]:[]}resolveIdentifier(e,t){let r=this.nameToModule[e];if(r)return r.address;for(let s of Object.values(this.modules))if(s.address===e)return s.address}addSingleModule(e){if(e){let t=e.modName;t&&this.allowNameResolution&&(f(this.nameToModule[t]===void 0,()=>`Module with name ${t} already added`),this.nameToModule[t]=e),this.modules[e.address]=e}}removeSingleModule(e){f(M(e),()=>"Invalid address");let t=f(this.modules[e],()=>"Address not found in modules");delete this.modules[e];let r=t.modName;r&&delete this.nameToModule[r]}resolveByAddress(e,t){return R(t.map(r=>e[r]))}resolveByName(e,t){return R(t.map(r=>e.find(s=>s.modName===r)))}resolveByQuery(e,t){return R(e.filter(r=>t?.reduce((s,o)=>o.reduce((l,i)=>{let a=r.queries.includes(i);return l&&a},!0)||s,!1)))}};var N=n(u=>u?.split(":"),"moduleIdentifierParts"),D=class u extends c{static{n(this,"CompositeModuleResolver")}static defaultMaxDepth=3;_cache;resolvers=[];_allowAddResolver=!0;_localResolver;constructor(e){super(e);let t=new h({allowNameResolution:e.allowNameResolution,root:e.root});this.addResolver(t);let{max:r=100,ttl:s=1e3*5}=e.cache??{};this._cache=new q({max:r,ttl:s,...e.cache}),this._localResolver=t}get allowAddResolver(){return this._allowAddResolver}set allowAddResolver(e){this.resolvers=[this._localResolver],this._allowAddResolver=e}get allowNameResolution(){return this.params.allowNameResolution??!0}get moduleIdentifierTransformers(){return this.params.moduleIdentifierTransformers??P.transformers}add(e){if(Array.isArray(e))for(let t of e)this.addSingleModule(t);else this.addSingleModule(e);return this}addResolver(e){return this.allowAddResolver&&this.resolvers.push(e),this}remove(e){if(Array.isArray(e))for(let t of e)this.removeSingleModule(t);else this.removeSingleModule(e);return this}removeResolver(e){return this.resolvers=this.resolvers.filter(t=>t!==e),this}async resolveHandler(e="*",t={}){let r={...t,maxDepth:t?.maxDepth??u.defaultMaxDepth};if(e==="*"){let s=e;if(r.maxDepth<0)return[];if(r.maxDepth===0)return await this._localResolver.resolve(s,r)??[];let o={...r,maxDepth:r?.maxDepth-1};return(await Promise.all(this.resolvers.map(async a=>await a.resolve(s,o)))).flat().filter(m).filter(A)}if(typeof e=="string"){if(r.maxDepth<0)return[];if(N(e).length>1){let l=await this.resolveMultipartIdentifier(e);return l?Array.isArray(l)?l:[l]:[]}let o=await P.transformModuleIdentifier(e,this.moduleIdentifierTransformers);if(o){if(r.maxDepth<0)return[];let l=this._cache.get(o);if(l)if(l.status==="dead")this._cache.delete(o);else return[l];if(r.maxDepth===0){let d=await this._localResolver.resolve(e,r);return d?Array.isArray(d)?d:[d]:[]}let i=n(async d=>{let I=this.resolvers.filter(p=>p.priority===d),v=(await Promise.all(I.map(async p=>await p.resolve(o,r)))).filter(m).filter(m).findLast(A);return v?(this._cache.set(o,v),v):d===_.VeryLow?void 0:await i(d-1)},"resolvePriority"),a=await i(_.VeryHigh);return a?Array.isArray(a)?a:[a]:[]}}else if(typeof e=="object"){if(r.maxDepth<0)return[];let s=e;if(r.maxDepth===0)return await this._localResolver.resolve(s,r);let o={...r,maxDepth:r?.maxDepth-1};return(await Promise.all(this.resolvers.map(async a=>await a.resolve(s,o)))).flat().filter(m).filter(A)}return[]}async resolveIdentifier(e,t){if(e.split(":").length>1)return this.resolveComplexIdentifier(e);let s=(await Promise.all(this.resolvers.map(async l=>await l.resolveIdentifier(e)))).filter(m),o=s.shift();if(s.length>0)for(let l of s)x(l===o,()=>`Inconsistent results for ${e} [${o}][${l}]`);return o}resolveComplexIdentifier(e,t){throw new Error("Method not implemented.")}addSingleModule(e){e&&this._localResolver.add(e)}removeSingleModule(e){this._localResolver.remove(e)}async resolveMultipartIdentifier(e){let t=N(e);x(t.length>=2,()=>"Not a valid multipart identifier");let r=x(t.shift()),s=await this.resolve(r)??await this.resolvePrivate(r);return await s?.resolve(t.join(":"))??await s?.resolvePrivate(t.join(":"))}};import{PayloadDivinerQuerySchema as L}from"@xyo-network/diviner-payload-model";import{LRUCache as Q}from"lru-cache";var b=class{static{n(this,"NameRegistrarTransformer")}registrarDiviner;root;_cache;constructor(e,t){this.registrarDiviner=e,this.root=t,this._cache=new Q({max:1e3,ttl:1e3*5})}async transform(e){let r=e.split(":").shift(),s=r?.split(".");if(s?.length===2&&s[1]===this.root){let o=this._cache.get(e);if(o)return o;let l={domain:s[0],order:"desc",schema:L,tld:s[1]},a=(await this.registrarDiviner?.divine([l]))?.shift();if(!a)throw new Error(`Unable to resolve registrar name (failed) [${r}]`);if(a){let d=a.address?.shift();if(d)return this._cache.set(e,d),d}throw new Error(`Unable to resolve registrar name (not found) [${r}]`)}return e}};var U=n(u=>{let e=[],t=n((l,i)=>e.length===0?!1:(e.map(a=>a(i)),!0),"emit"),r=n((l,i)=>{t("moduleResolved",{filter:i,module:l})},"onModuleResolved"),{resolve:s}=u;function o(l){return s.bind(u)(l)}return n(o,"originalResolve"),{on:n((l,i)=>{e.push(i)},"on"),resolve:n(async l=>{let i=await o(l);return await Promise.allSettled(i.map(a=>r(a,l))),i},"resolve")}},"getMixin"),he=n(u=>{let e=U(u);return Object.assign(u,e)},"mixinResolverEventEmitter");export{c as AbstractModuleResolver,D as CompositeModuleResolver,b as NameRegistrarTransformer,h as SimpleModuleResolver,he as mixinResolverEventEmitter};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/AbstractModuleResolver.ts
+import { assertEx } from "@xylabs/assert";
+import { Base, toJsonString } from "@xylabs/object";
+import { asModuleInstance, ObjectResolverPriority } from "@xyo-network/module-model";
+var AbstractModuleResolver = class extends Base {
+  static {
+    __name(this, "AbstractModuleResolver");
+  }
+  get priority() {
+    return this.params.priority ?? ObjectResolverPriority.Normal;
+  }
+  set priority(value) {
+    this.params.priority = value;
+  }
+  get root() {
+    return assertEx(this.params.root, () => "root is not set");
+  }
+  async resolve(idOrFilter = "*", options) {
+    if (idOrFilter === "*") {
+      const values = await this.resolveHandler(idOrFilter, options);
+      assertEx(Array.isArray(values), () => "resolveHandler returned a non-array");
+      return values.map((value) => asModuleInstance(value, () => {
+        return `resolveHandler returned invalid result (*) [${value?.constructor?.name}][${toJsonString(value)}]`;
+      }));
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        const [value] = await this.resolveHandler(idOrFilter, options);
+        return asModuleInstance(value, () => (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          `resolveHandler returned invalid result (string) [${value?.constructor?.name}][${toJsonString(value)}]`
+        ));
+      }
+      default: {
+        const values = await this.resolveHandler(idOrFilter, options);
+        assertEx(Array.isArray(values), () => "resolveHandler returned a non-array");
+        return values.map((value) => asModuleInstance(value, () => {
+          return `resolveHandler returned invalid result (filter) [${value?.constructor?.name}][${toJsonString(value)}]`;
+        }));
+      }
+    }
+  }
+  async resolvePrivate(id, _options) {
+    if (id === "*") return await Promise.resolve([]);
+  }
+};
+
+// src/CompositeModuleResolver.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { exists } from "@xylabs/exists";
+import { duplicateModules, ObjectResolverPriority as ObjectResolverPriority2, ResolveHelper } from "@xyo-network/module-model";
+import { LRUCache } from "lru-cache";
+
+// src/SimpleModuleResolver.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { isAddress } from "@xylabs/hex";
+import { compact } from "@xylabs/lodash";
+import { isAddressModuleFilter, isModuleName, isNameModuleFilter, isQueryModuleFilter } from "@xyo-network/module-model";
+var SimpleModuleResolver = class extends AbstractModuleResolver {
+  static {
+    __name(this, "SimpleModuleResolver");
+  }
+  modules = {};
+  nameToModule = {};
+  constructor(params) {
+    super(params);
+  }
+  get allowNameResolution() {
+    return this.params.allowNameResolution ?? true;
+  }
+  add(mods) {
+    if (Array.isArray(mods)) {
+      for (const mod of mods) this.addSingleModule(mod);
+    } else {
+      this.addSingleModule(mods);
+    }
+    return this;
+  }
+  addResolver(_resolver) {
+    throw "Adding resolvers not supported";
+  }
+  remove(address) {
+    if (Array.isArray(address)) {
+      for (const addr of address) this.removeSingleModule(addr);
+    } else {
+      this.removeSingleModule(address);
+    }
+    return this;
+  }
+  removeResolver(_resolver) {
+    throw "Removing resolvers not supported";
+  }
+  resolveHandler(idOrFilter = "*", options) {
+    const unfiltered = (() => {
+      if (idOrFilter) {
+        if (typeof idOrFilter === "string") {
+          if (idOrFilter === "*") {
+            return Object.values(this.modules);
+          }
+          const id = idOrFilter;
+          const name = isModuleName(id) ? id : void 0;
+          const address = isAddress(id) ? id : void 0;
+          assertEx2(name || address, () => "module identifier must be a ModuleName or Address");
+          return (name ? this.resolveByName(Object.values(this.modules), [
+            name
+          ]).pop() : void 0) ?? (address ? this.resolveByAddress(this.modules, [
+            address
+          ]).pop() : void 0);
+        } else {
+          const filter = idOrFilter;
+          if (isAddressModuleFilter(filter)) {
+            return this.resolveByAddress(this.modules, filter.address);
+          } else if (isNameModuleFilter(filter)) {
+            return this.resolveByName(Object.values(this.modules), filter.name);
+          } else if (isQueryModuleFilter(filter)) {
+            return this.resolveByQuery(Object.values(this.modules), filter.query);
+          }
+        }
+      } else {
+        return Object.values(this.modules);
+      }
+    })();
+    const identity = options?.identity;
+    if (identity) {
+      return Array.isArray(unfiltered) ? unfiltered?.filter((module) => identity(module)) : identity(unfiltered) ? [
+        unfiltered
+      ] : [];
+    } else {
+      return unfiltered ? Array.isArray(unfiltered) ? unfiltered : [
+        unfiltered
+      ] : [];
+    }
+  }
+  resolveIdentifier(id, _options) {
+    const moduleFromName = this.nameToModule[id];
+    if (moduleFromName) {
+      return moduleFromName.address;
+    }
+    for (const module of Object.values(this.modules)) {
+      if (module.address === id) {
+        return module.address;
+      }
+    }
+  }
+  addSingleModule(mod) {
+    if (mod) {
+      const modName = mod.modName;
+      if (modName && this.allowNameResolution) {
+        assertEx2(this.nameToModule[modName] === void 0, () => `Module with name ${modName} already added`);
+        this.nameToModule[modName] = mod;
+      }
+      this.modules[mod.address] = mod;
+    }
+  }
+  removeSingleModule(address) {
+    assertEx2(isAddress(address), () => "Invalid address");
+    const mod = assertEx2(this.modules[address], () => "Address not found in modules");
+    delete this.modules[address];
+    const modName = mod.modName;
+    if (modName) {
+      delete this.nameToModule[modName];
+    }
+  }
+  resolveByAddress(modules, address) {
+    return compact(address.map((address2) => {
+      return modules[address2];
+    }));
+  }
+  resolveByName(modules, name) {
+    return compact(name.map((name2) => {
+      return modules.find((module) => module.modName === name2);
+    }));
+  }
+  resolveByQuery(modules, query) {
+    return compact(modules.filter((module) => query?.reduce((supported, queryList) => {
+      return (
+        // eslint-disable-next-line unicorn/no-array-reduce
+        queryList.reduce((supported2, query2) => {
+          const queryable = module.queries.includes(query2);
+          return supported2 && queryable;
+        }, true) || supported
+      );
+    }, false)));
+  }
+};
+
+// src/CompositeModuleResolver.ts
+var moduleIdentifierParts = /* @__PURE__ */ __name((moduleIdentifier) => {
+  return moduleIdentifier?.split(":");
+}, "moduleIdentifierParts");
+var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractModuleResolver {
+  static {
+    __name(this, "CompositeModuleResolver");
+  }
+  static defaultMaxDepth = 3;
+  _cache;
+  resolvers = [];
+  _allowAddResolver = true;
+  _localResolver;
+  constructor(params) {
+    super(params);
+    const localResolver = new SimpleModuleResolver({
+      allowNameResolution: params.allowNameResolution,
+      root: params.root
+    });
+    this.addResolver(localResolver);
+    const {
+      max = 100,
+      ttl = 1e3 * 5
+      /* five seconds */
+    } = params.cache ?? {};
+    this._cache = new LRUCache({
+      max,
+      ttl,
+      ...params.cache
+    });
+    this._localResolver = localResolver;
+  }
+  get allowAddResolver() {
+    return this._allowAddResolver;
+  }
+  set allowAddResolver(value) {
+    this.resolvers = [
+      this._localResolver
+    ];
+    this._allowAddResolver = value;
+  }
+  get allowNameResolution() {
+    return this.params.allowNameResolution ?? true;
+  }
+  get moduleIdentifierTransformers() {
+    return this.params.moduleIdentifierTransformers ?? ResolveHelper.transformers;
+  }
+  add(module) {
+    if (Array.isArray(module)) {
+      for (const mod of module) this.addSingleModule(mod);
+    } else {
+      this.addSingleModule(module);
+    }
+    return this;
+  }
+  addResolver(resolver) {
+    if (this.allowAddResolver) {
+      this.resolvers.push(resolver);
+    }
+    return this;
+  }
+  remove(addresses) {
+    if (Array.isArray(addresses)) {
+      for (const address of addresses) this.removeSingleModule(address);
+    } else {
+      this.removeSingleModule(addresses);
+    }
+    return this;
+  }
+  removeResolver(resolver) {
+    this.resolvers = this.resolvers.filter((item) => item !== resolver);
+    return this;
+  }
+  // eslint-disable-next-line complexity
+  async resolveHandler(idOrFilter = "*", options = {}) {
+    const mutatedOptions = {
+      ...options,
+      maxDepth: options?.maxDepth ?? _CompositeModuleResolver.defaultMaxDepth
+    };
+    if (idOrFilter === "*") {
+      const all = idOrFilter;
+      if (mutatedOptions.maxDepth < 0) {
+        return [];
+      }
+      if (mutatedOptions.maxDepth === 0) {
+        return await this._localResolver.resolve(all, mutatedOptions) ?? [];
+      }
+      const childOptions = {
+        ...mutatedOptions,
+        maxDepth: mutatedOptions?.maxDepth - 1
+      };
+      const result = await Promise.all(this.resolvers.map(async (resolver) => {
+        const result2 = await resolver.resolve(all, childOptions);
+        return result2;
+      }));
+      const flatResult = result.flat().filter(exists);
+      return flatResult.filter(duplicateModules);
+    }
+    if (typeof idOrFilter === "string") {
+      if (mutatedOptions.maxDepth < 0) {
+        return [];
+      }
+      const idParts = moduleIdentifierParts(idOrFilter);
+      if (idParts.length > 1) {
+        const mod = await this.resolveMultipartIdentifier(idOrFilter);
+        return mod ? Array.isArray(mod) ? mod : [
+          mod
+        ] : [];
+      }
+      const id = await ResolveHelper.transformModuleIdentifier(idOrFilter, this.moduleIdentifierTransformers);
+      if (id) {
+        if (mutatedOptions.maxDepth < 0) {
+          return [];
+        }
+        const cachedResult = this._cache.get(id);
+        if (cachedResult) {
+          if (cachedResult.status === "dead") {
+            this._cache.delete(id);
+          } else {
+            return [
+              cachedResult
+            ];
+          }
+        }
+        if (mutatedOptions.maxDepth === 0) {
+          const mod2 = await this._localResolver.resolve(idOrFilter, mutatedOptions);
+          return mod2 ? Array.isArray(mod2) ? mod2 : [
+            mod2
+          ] : [];
+        }
+        const resolvePriority = /* @__PURE__ */ __name(async (priority) => {
+          const resolvers = this.resolvers.filter((resolver) => resolver.priority === priority);
+          const results = (await Promise.all(resolvers.map(async (resolver) => {
+            const result2 = await resolver.resolve(id, mutatedOptions);
+            return result2;
+          }))).filter(exists);
+          const result = results.filter(exists).findLast(duplicateModules);
+          if (result) {
+            this._cache.set(id, result);
+            return result;
+          }
+          return priority === ObjectResolverPriority2.VeryLow ? void 0 : await resolvePriority(priority - 1);
+        }, "resolvePriority");
+        const mod = await resolvePriority(ObjectResolverPriority2.VeryHigh);
+        return mod ? Array.isArray(mod) ? mod : [
+          mod
+        ] : [];
+      }
+    } else if (typeof idOrFilter === "object") {
+      if (mutatedOptions.maxDepth < 0) {
+        return [];
+      }
+      const filter = idOrFilter;
+      if (mutatedOptions.maxDepth === 0) {
+        return await this._localResolver.resolve(filter, mutatedOptions);
+      }
+      const childOptions = {
+        ...mutatedOptions,
+        maxDepth: mutatedOptions?.maxDepth - 1
+      };
+      const result = await Promise.all(this.resolvers.map(async (resolver) => {
+        const result2 = await resolver.resolve(filter, childOptions);
+        return result2;
+      }));
+      const flatResult = result.flat().filter(exists);
+      return flatResult.filter(duplicateModules);
+    }
+    return [];
+  }
+  async resolveIdentifier(id, _options) {
+    const idParts = id.split(":");
+    if (idParts.length > 1) {
+      return this.resolveComplexIdentifier(id);
+    }
+    const results = (await Promise.all(this.resolvers.map(async (resolver) => {
+      const result2 = await resolver.resolveIdentifier(id);
+      return result2;
+    }))).filter(exists);
+    const result = results.shift();
+    if (results.length > 0) {
+      for (const altResult of results) {
+        assertEx3(altResult === result, () => `Inconsistent results for ${id} [${result}][${altResult}]`);
+      }
+    }
+    return result;
+  }
+  resolveComplexIdentifier(_id, _options) {
+    throw new Error("Method not implemented.");
+  }
+  addSingleModule(module) {
+    if (module) {
+      this._localResolver.add(module);
+    }
+  }
+  removeSingleModule(address) {
+    this._localResolver.remove(address);
+  }
+  async resolveMultipartIdentifier(moduleIdentifier) {
+    const idParts = moduleIdentifierParts(moduleIdentifier);
+    assertEx3(idParts.length >= 2, () => "Not a valid multipart identifier");
+    const id = assertEx3(idParts.shift());
+    const module = await this.resolve(id) ?? await this.resolvePrivate(id);
+    return await module?.resolve(idParts.join(":")) ?? await module?.resolvePrivate(idParts.join(":"));
+  }
+};
+
+// src/NameRegistrarTransformer.ts
+import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
+import { LRUCache as LRUCache2 } from "lru-cache";
+var NameRegistrarTransformer = class {
+  static {
+    __name(this, "NameRegistrarTransformer");
+  }
+  registrarDiviner;
+  root;
+  _cache;
+  constructor(registrarDiviner, root) {
+    this.registrarDiviner = registrarDiviner;
+    this.root = root;
+    this._cache = new LRUCache2({
+      max: 1e3,
+      ttl: 1e3 * 5
+    });
+  }
+  async transform(identifier) {
+    const parts = identifier.split(":");
+    const first = parts.shift();
+    const nameParts = first?.split(".");
+    if (nameParts?.length === 2 && nameParts[1] === this.root) {
+      const cachedResult = this._cache.get(identifier);
+      if (cachedResult) return cachedResult;
+      const query = {
+        domain: nameParts[0],
+        order: "desc",
+        schema: PayloadDivinerQuerySchema,
+        tld: nameParts[1]
+      };
+      const result = await this.registrarDiviner?.divine([
+        query
+      ]);
+      const resultPayload = result?.shift();
+      if (!resultPayload) {
+        throw new Error(`Unable to resolve registrar name (failed) [${first}]`);
+      }
+      if (resultPayload) {
+        const address = resultPayload.address?.shift();
+        if (address) {
+          this._cache.set(identifier, address);
+          return address;
+        }
+      }
+      throw new Error(`Unable to resolve registrar name (not found) [${first}]`);
+    }
+    return identifier;
+  }
+};
+
+// src/ResolverEventEmitter.ts
+var getMixin = /* @__PURE__ */ __name((resolver) => {
+  const listeners = [];
+  const emit = /* @__PURE__ */ __name((event, args) => {
+    if (listeners.length === 0) return false;
+    listeners.map((listener) => listener(args));
+    return true;
+  }, "emit");
+  const onModuleResolved = /* @__PURE__ */ __name((module, filter) => {
+    const args = {
+      filter,
+      module
+    };
+    emit("moduleResolved", args);
+  }, "onModuleResolved");
+  const { resolve } = resolver;
+  function originalResolve(filter) {
+    return resolve.bind(resolver)(filter);
+  }
+  __name(originalResolve, "originalResolve");
+  return {
+    on: /* @__PURE__ */ __name((event, listener) => {
+      listeners.push(listener);
+    }, "on"),
+    resolve: /* @__PURE__ */ __name(async (filter) => {
+      const modules = await originalResolve(filter);
+      await Promise.allSettled(modules.map((mod) => onModuleResolved(mod, filter)));
+      return modules;
+    }, "resolve")
+  };
+}, "getMixin");
+var mixinResolverEventEmitter = /* @__PURE__ */ __name((resolver) => {
+  const mixin = getMixin(resolver);
+  const ret = Object.assign(resolver, mixin);
+  return ret;
+}, "mixinResolverEventEmitter");
+export {
+  AbstractModuleResolver,
+  CompositeModuleResolver,
+  NameRegistrarTransformer,
+  SimpleModuleResolver,
+  mixinResolverEventEmitter
+};
 //# sourceMappingURL=index.js.map