@lwrjs/loader 0.24.2 → 0.24.3

package/build/cjs/modules/lwr/loader/hooks/resolveAndLoadHook.cjs

@@ -1,58 +1,58 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {get: all[name], enumerable: true});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/loader/src/modules/lwr/loader/hooks/resolveAndLoadHook.ts
-__markAsModule(exports);
-__export(exports, {
+var resolveAndLoadHook_exports = {};
+__export(resolveAndLoadHook_exports, {
   evaluateLoadHook: () => evaluateLoadHook,
   evaluateLoadHookResponse: () => evaluateLoadHookResponse,
   isCustomResponse: () => isCustomResponse,
   isFetchResponse: () => isFetchResponse,
   isResponseAPromise: () => isResponseAPromise
 });
-var import_messages = __toModule(require("../errors/messages.cjs"));
-var import_constants = __toModule(require("../constants/constants.cjs"));
-var import_dom = __toModule(require("../utils/dom.cjs"));
-var import_trusted_types = __toModule(require("@locker/trusted-types"));
+module.exports = __toCommonJS(resolveAndLoadHook_exports);
+var import_messages = require("../errors/messages.cjs");
+var import_constants = require("../constants/constants.cjs");
+var import_dom = require("../utils/dom.cjs");
+var import_trusted_types = require("@locker/trusted-types");
 var lastWindowError;
 if (import_dom.hasDocument) {
   globalThis.addEventListener("error", (evt) => {
     lastWindowError = evt.error;
   });
 }
-if (process.env.NODE_ENV !== "production") {
+function resetLastWindowError() {
+  lastWindowError = null;
+}
+if (true) {
   if (!import_dom.hasSetTimeout && import_dom.hasConsole) {
     console.warn("setTimeout API is not available, watchdog timer on load hook will not be set");
   }
 }
-function isCustomResponse(response) {
-  return Object.prototype.hasOwnProperty.call(response, "data") && !Object.prototype.hasOwnProperty.call(response, "blob");
+function isCustomResponse(response2) {
+  return Object.prototype.hasOwnProperty.call(response2, "data") && !Object.prototype.hasOwnProperty.call(response2, "blob");
 }
-function isFetchResponse(response) {
-  return typeof response.blob === "function";
+function isFetchResponse(response2) {
+  return typeof response2.blob === "function";
 }
-function isResponseAPromise(response) {
-  return !!(response && response.then);
+function isResponseAPromise(response2) {
+  return !!(response2 && response2.then);
 }
 async function evaluateLoadHookResponse(response, id) {
   return Promise.resolve().then(async () => {
@@ -76,34 +76,35 @@ async function evaluateLoadHookResponse(response, id) {
     }
     code = `${code}
 //# sourceURL=${id}`;
+    resetLastWindowError();
     try {
       eval(import_trusted_types.trusted.createScript(code));
     } catch (e) {
-      if (process.env.NODE_ENV !== "production" && import_dom.hasConsole) {
+      if (import_dom.hasConsole) {
         console.error(e);
       }
       throw new import_messages.LoaderError(import_messages.FAIL_LOAD, [`"${id}": ${e instanceof Error ? e.message : String(e)}`]);
     }
     if (lastWindowError) {
-      throw new import_messages.LoaderError(import_messages.FAIL_LOAD, [
-        `"${id}": window error ${lastWindowError instanceof Error ? lastWindowError.message : String(lastWindowError)}`
-      ]);
+      const message = lastWindowError instanceof Error ? lastWindowError.message : String(lastWindowError);
+      resetLastWindowError();
+      throw new import_messages.LoaderError(import_messages.FAIL_LOAD, [`"${id}": window error ${message}`]);
     }
     return true;
   });
 }
-async function evaluateLoadHook(id, hookPromise) {
+async function evaluateLoadHook(id2, hookPromise) {
   if (!import_dom.hasSetTimeout) {
     return hookPromise;
   }
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      reject(new import_messages.LoaderError(import_messages.MODULE_LOAD_TIMEOUT, [id]));
+      reject(new import_messages.LoaderError(import_messages.MODULE_LOAD_TIMEOUT, [id2]));
     }, import_constants.MODULE_LOAD_TIMEOUT_TIMER);
-    hookPromise.then((response) => {
-      resolve(response);
+    hookPromise.then((response2) => {
+      resolve(response2);
     }).catch(() => {
-      reject(new import_messages.LoaderError(import_messages.FAIL_HOOK_LOAD, [id]));
+      reject(new import_messages.LoaderError(import_messages.FAIL_HOOK_LOAD, [id2]));
     }).finally(() => {
       clearTimeout(timer);
     });

package/build/cjs/modules/lwr/loader/moduleRegistry/importMetadataResolver.cjs

@@ -1,38 +1,36 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {get: all[name], enumerable: true});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/loader/src/modules/lwr/loader/moduleRegistry/importMetadataResolver.ts
-__markAsModule(exports);
-__export(exports, {
+var importMetadataResolver_exports = {};
+__export(importMetadataResolver_exports, {
   ImportMetadataResolver: () => ImportMetadataResolver
 });
-var import_messages = __toModule(require("../errors/messages.cjs"));
-var import_url = __toModule(require("../utils/url.cjs"));
-var import_metrics = __toModule(require("lwr/metrics"));
+module.exports = __toCommonJS(importMetadataResolver_exports);
+var import_messages = require("../errors/messages.cjs");
+var import_url = require("../utils/url.cjs");
+var import_metrics = require("lwr/metrics");
 var ImportMetadataResolver = class {
   constructor(config, invalidationCallback) {
-    this.importURICache = new Map();
-    this.pendingURICache = new Map();
+    // Default to empty mappings
+    this.importURICache = /* @__PURE__ */ new Map();
+    this.pendingURICache = /* @__PURE__ */ new Map();
     this.loadMappingHooks = [];
     this.config = config;
     this.invalidationCallback = invalidationCallback;
@@ -92,9 +90,16 @@ var ImportMetadataResolver = class {
       });
     }
   }
+  /**
+   * Returns the raw URI stored for a specifier, or `undefined` if not yet mapped.
+   * Used by the runtime `importMap()` path to detect cross-call duplicates while
+   * allowing truly idempotent re-registrations (same specifier, same URI) to pass
+   * through silently.
+   */
   getMappingUri(specifier) {
     return this.importURICache.get(specifier)?.uri;
   }
+  // Get URL from the local cache or return undefiend
   getURI(specifier) {
     return this.importURICache && this.importURICache.has(specifier) ? (0, import_url.resolveUrl)(this.importURICache.get(specifier).uri, this.getBaseUrl()) : void 0;
   }
@@ -107,6 +112,16 @@ var ImportMetadataResolver = class {
     }
     return void 0;
   }
+  /**
+   *  Resolves a the URI for a specified module.  It will return the value in this order:
+   *
+   *  1) Mapping from local URI cache
+   *  2) The URI if a specifier is already an absolute URI
+   *  3) Mapping fetched from a registered loader hook
+   *  4)
+   *  @param specifier
+   *  @returns module URI
+   */
   async resolve(specifier) {
     let uri = this.getURI(specifier);
     if (uri) {
@@ -118,7 +133,7 @@ var ImportMetadataResolver = class {
       if (pending) {
         return pending;
       }
-      this.config.profiler.logOperationStart({id: import_metrics.MAPPINGS_FETCH, specifier});
+      this.config.profiler.logOperationStart({ id: import_metrics.MAPPINGS_FETCH, specifier });
       const fetchMappingService = this.hasMappingHooks() ? this.evaluateMappingHooks : this.fetchNewMappings;
       const promise = fetchMappingService.bind(this)(specifier).then((importMetadata) => {
         if (!importMetadata || !importMetadata.imports) {
@@ -129,7 +144,7 @@ var ImportMetadataResolver = class {
         if (!uri) {
           throw new import_messages.LoaderError(import_messages.UNRESOLVED, [specifier]);
         }
-        this.config.profiler.logOperationEnd({id: import_metrics.MAPPINGS_FETCH, specifier});
+        this.config.profiler.logOperationEnd({ id: import_metrics.MAPPINGS_FETCH, specifier });
         return uri;
       }).finally(() => {
         this.pendingURICache.delete(specifier);
@@ -141,13 +156,18 @@ var ImportMetadataResolver = class {
   hasMappingHooks() {
     return this.loadMappingHooks.length > 0;
   }
+  /**
+   *  Evaluates mapping hooks.  Returns first match. If all hooks return null call the mapping service.
+   *  @param specifier Request module identifier
+   *  @returns Import Metadata from the module root
+   */
   async evaluateMappingHooks(specifier) {
     const loadMappingHooks = this.loadMappingHooks;
     if (loadMappingHooks.length) {
       const knownModules = Array.from(this.importURICache.keys());
       for (let i = 0; i < loadMappingHooks.length; i++) {
         const loadMappingHook = loadMappingHooks[i];
-        const response = await loadMappingHook(specifier, {knownModules});
+        const response = await loadMappingHook(specifier, { knownModules });
         if (response || response === void 0) {
           return response;
         }
@@ -165,7 +185,7 @@ var ImportMetadataResolver = class {
     }
     return globalThis.fetch(uri).then((res) => {
       if (!res.ok) {
-        this.config.profiler.logOperationStart({id: import_metrics.MAPPINGS_ERROR, specifier});
+        this.config.profiler.logOperationStart({ id: import_metrics.MAPPINGS_ERROR, specifier });
         throw new import_messages.LoaderError(import_messages.UNRESOLVED, [specifier]);
       }
       return res.json().then((ret) => {

package/build/cjs/modules/lwr/loader/moduleRegistry/moduleRegistry.cjs

@@ -1,48 +1,51 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {get: all[name], enumerable: true});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/loader/src/modules/lwr/loader/moduleRegistry/moduleRegistry.ts
-__markAsModule(exports);
-__export(exports, {
+var moduleRegistry_exports = {};
+__export(moduleRegistry_exports, {
   ModuleRegistry: () => ModuleRegistry
 });
-var import_messages = __toModule(require("../errors/messages.cjs"));
-var import_url = __toModule(require("../utils/url.cjs"));
-var import_dom = __toModule(require("../utils/dom.cjs"));
-var import_scriptLoad = __toModule(require("./scriptLoad.cjs"));
-var import_importMetadataResolver = __toModule(require("./importMetadataResolver.cjs"));
-var import_moduleInvalidation = __toModule(require("../hooks/moduleInvalidation.cjs"));
-var import_resolveAndLoadHook = __toModule(require("../hooks/resolveAndLoadHook.cjs"));
-var import_metrics = __toModule(require("lwr/metrics"));
-var import_constants = __toModule(require("../constants/constants.cjs"));
+module.exports = __toCommonJS(moduleRegistry_exports);
+var import_messages = require("../errors/messages.cjs");
+var import_url = require("../utils/url.cjs");
+var import_dom = require("../utils/dom.cjs");
+var import_scriptLoad = require("./scriptLoad.cjs");
+var import_importMetadataResolver = require("./importMetadataResolver.cjs");
+var import_moduleInvalidation = require("../hooks/moduleInvalidation.cjs");
+var import_resolveAndLoadHook = require("../hooks/resolveAndLoadHook.cjs");
+var import_metrics = require("lwr/metrics");
+var import_constants = require("../constants/constants.cjs");
 var ModuleRegistry = class {
   constructor(config) {
     this.isAppMounted = false;
-    this.namedDefineRegistry = new Map();
-    this.moduleRegistry = new Map();
-    this.aliases = new Map();
+    // A registry for named AMD defines containing the *metadata* of AMD module
+    this.namedDefineRegistry = /* @__PURE__ */ new Map();
+    // The evaluated module registry where the module identifier (name or URL?) is the key
+    this.moduleRegistry = /* @__PURE__ */ new Map();
+    // Aliases of modules in the registry
+    this.aliases = /* @__PURE__ */ new Map();
     this.profiler = config.profiler;
-    this.resolver = new import_importMetadataResolver.ImportMetadataResolver(config, this.importMetadataInvalidationCallback.bind(this));
+    this.resolver = new import_importMetadataResolver.ImportMetadataResolver(
+      config,
+      this.importMetadataInvalidationCallback.bind(this)
+    );
     this.warnings = {
       [import_constants.MODULE_WARNING.MODULE_REDEFINE]: [],
       [import_constants.MODULE_WARNING.MODULE_ALREADY_LOADED]: [],
@@ -50,7 +53,7 @@ var ModuleRegistry = class {
     };
   }
   async load(id, importer) {
-    const metadata = importer ? {importer} : {};
+    const metadata = importer ? { importer } : {};
     this.profiler.logOperationStart({
       id: import_metrics.MODULE_DYNAMIC_LOAD,
       specifier: id,
@@ -75,7 +78,7 @@ var ModuleRegistry = class {
     if (resolveHooks) {
       for (let i = 0; i < resolveHooks.length; i++) {
         const resolveHook = resolveHooks[i];
-        const response = resolveHook(aliasedId, {parentUrl});
+        const response = resolveHook(aliasedId, { parentUrl });
         let result;
         if (response || response === null) {
           result = (0, import_resolveAndLoadHook.isResponseAPromise)(response) ? await response : response;
@@ -114,7 +117,9 @@ var ModuleRegistry = class {
       const resolvedUrl = this.resolver.resolveLocal(resolvedOrPlain);
       if (resolvedUrl) {
         if (this.namedDefineRegistry.has(resolvedOrPlain)) {
-          const namedDefineRecord = this.namedDefineRegistry.get(resolvedOrPlain);
+          const namedDefineRecord = this.namedDefineRegistry.get(
+            resolvedOrPlain
+          );
           if (namedDefineRecord.external || namedDefineRecord.defined) {
             const record = this.moduleRegistry.get(resolvedUrl);
             if (!record || !this.aliases.has(resolvedOrPlain)) {
@@ -149,7 +154,12 @@ var ModuleRegistry = class {
   define(name, dependencies, exporter) {
     const mod = this.namedDefineRegistry.get(name);
     if (mod && mod.defined) {
-      if (process.env.NODE_ENV !== "production" && import_dom.hasProcessEnv && process.env.MRT_HMR !== "true") {
+      if (
+        // note: we always expect process.env.NODE_ENV to be replaced at build time
+        // eslint-disable-next-line lwr/no-unguarded-apis
+        import_dom.hasProcessEnv && // eslint-disable-next-line lwr/no-unguarded-apis
+        process.env.MRT_HMR !== "true"
+      ) {
         if (!this.warnings[import_constants.MODULE_WARNING.MODULE_REDEFINE].includes(name)) {
           this.warnings[import_constants.MODULE_WARNING.MODULE_REDEFINE].push(name);
         }
@@ -169,10 +179,15 @@ var ModuleRegistry = class {
     if (mod && mod.external) {
       mod.external.resolveExternal(moduleDef);
     }
-    this.profiler.logOperationStart({id: import_metrics.MODULE_DEFINE, specifier: name});
+    this.profiler.logOperationStart({ id: import_metrics.MODULE_DEFINE, specifier: name });
     this.namedDefineRegistry.set(name, moduleDef);
     this.lastDefine = moduleDef;
   }
+  /**
+   * Marks modules as "externally" loaded/provided, so that the loader does not attempt to fetch them.
+   *
+   * @param modules - list of module identifiers
+   */
   registerExternalModules(modules) {
     modules.map((id) => {
       if (!this.namedDefineRegistry.has(id)) {
@@ -195,7 +210,7 @@ var ModuleRegistry = class {
           }
         };
         this.namedDefineRegistry.set(id, moduleDef);
-      } else if (process.env.NODE_ENV !== "production") {
+      } else if (true) {
         if (!this.warnings[import_constants.MODULE_WARNING.MODULE_ALREADY_LOADED].includes(id)) {
           this.warnings[import_constants.MODULE_WARNING.MODULE_ALREADY_LOADED].push(id);
         }
@@ -208,6 +223,18 @@ var ModuleRegistry = class {
   getImportMetadataResolver() {
     return this.resolver;
   }
+  /**
+   * Gets or creates a module record for the given resolved ID and original ID.
+   *
+   * This function handles the complex logic of module resolution and ensures that:
+   * 1. Modules loaded via different paths (aliases, direct specifiers, URLs) return the same instance
+   * 2. Bundle URLs are properly resolved to their final specifier names after instantiation
+   * 3. Alias mappings are maintained for future lookups
+   *
+   * @param resolvedId - The resolved module identifier (could be a URL or specifier)
+   * @param originalId - The original module specifer that was requested
+   * @returns Promise<ModuleRecord> - The module record for the module
+   */
   async getModuleRecord(resolvedId, originalId) {
     const existingRecord = this.moduleRegistry.get(resolvedId);
     if (existingRecord) {
@@ -253,12 +280,19 @@ var ModuleRegistry = class {
     });
     const newModuleRecord = {
       id: resolvedId,
+      // Use resolved ID as the record identifier
       originalId,
-      module: Object.create(null),
+      // Keep track of the original requested ID
+      module: /* @__PURE__ */ Object.create(null),
+      // Empty object for module exports
       dependencyRecords,
+      // Promise for dependency module records
       instantiation,
+      // Promise for module definition
       evaluated: false,
+      // Track if module has been evaluated
       evaluationPromise: null
+      // Promise for module evaluation
     };
     this.moduleRegistry.set(resolvedId, newModuleRecord);
     if (resolvedId !== originalId) {
@@ -270,7 +304,7 @@ var ModuleRegistry = class {
     if (aliasId !== resolvedId) {
       if (!this.aliases.has(aliasId)) {
         this.aliases.set(aliasId, resolvedId);
-      } else if (process.env.NODE_ENV !== "production" && import_dom.hasConsole) {
+      } else if (import_dom.hasConsole) {
         const currentResolvedId = this.aliases.get(aliasId);
         if (currentResolvedId !== resolvedId) {
           const warningMsg = `${aliasId}=>${currentResolvedId}, ${resolvedId}`;
@@ -295,6 +329,7 @@ var ModuleRegistry = class {
     }
     return this.getModuleRecord(resolvedDepId, dependency);
   }
+  // execute the "top-level code" (the code outside of functions) of a module
   async topLevelEvaluation(moduleRecord) {
     return this.evaluateModule(moduleRecord, {});
   }
@@ -304,26 +339,28 @@ var ModuleRegistry = class {
       evaluationMap[moduleRecord.id] = true;
       await this.evaluateModuleDependencies(dependencyModuleRecords, evaluationMap);
     }
-    const {exporter, dependencies} = await moduleRecord.instantiation;
-    const exports2 = {};
-    const depsMapped = dependencies ? await Promise.all(dependencies.map(async (dep) => {
-      if (dep === "exports") {
-        return exports2;
-      }
-      const resolvedDepId = await this.resolve(dep);
-      const moduleRecord2 = this.moduleRegistry.get(resolvedDepId);
-      if (!moduleRecord2) {
+    const { exporter, dependencies } = await moduleRecord.instantiation;
+    const exports = {};
+    const depsMapped = dependencies ? await Promise.all(
+      dependencies.map(async (dep) => {
+        if (dep === "exports") {
+          return exports;
+        }
+        const resolvedDepId = await this.resolve(dep);
+        const moduleRecord2 = this.moduleRegistry.get(resolvedDepId);
+        if (!moduleRecord2) {
+          throw new import_messages.LoaderError(import_messages.FAILED_DEP, [resolvedDepId]);
+        }
+        const module2 = moduleRecord2.module;
+        if (!moduleRecord2.evaluated) {
+          return this.getCircularDependencyWrapper(module2);
+        }
+        if (module2) {
+          return module2.__defaultInterop ? module2.default : module2;
+        }
         throw new import_messages.LoaderError(import_messages.FAILED_DEP, [resolvedDepId]);
-      }
-      const module2 = moduleRecord2.module;
-      if (!moduleRecord2.evaluated) {
-        return this.getCircularDependencyWrapper(module2);
-      }
-      if (module2) {
-        return module2.__defaultInterop ? module2.default : module2;
-      }
-      throw new import_messages.LoaderError(import_messages.FAILED_DEP, [resolvedDepId]);
-    })) : [];
+      })
+    ) : [];
     if (moduleRecord.evaluated) {
       return moduleRecord.module;
     }
@@ -334,14 +371,14 @@ var ModuleRegistry = class {
       throw new import_messages.LoaderError(import_messages.EXPORTER_ERROR, [moduleRecord.id, e.message || e]);
     }
     if (moduleDefault !== void 0) {
-      moduleDefault = {default: moduleDefault};
-      Object.defineProperty(moduleDefault, "__defaultInterop", {value: true});
+      moduleDefault = { default: moduleDefault };
+      Object.defineProperty(moduleDefault, "__defaultInterop", { value: true });
     } else {
-      if (this.isNamedExportDefaultOnly(exports2)) {
-        Object.defineProperty(exports2, "__useDefault", {value: true});
+      if (this.isNamedExportDefaultOnly(exports)) {
+        Object.defineProperty(exports, "__useDefault", { value: true });
       }
     }
-    const moduleExports = moduleDefault || exports2;
+    const moduleExports = moduleDefault || exports;
     for (const key in moduleExports) {
       Object.defineProperty(moduleRecord.module, key, {
         enumerable: true,
@@ -354,21 +391,24 @@ var ModuleRegistry = class {
       });
     }
     if (moduleExports.__useDefault) {
-      Object.defineProperty(moduleRecord.module, "__useDefault", {value: true});
+      Object.defineProperty(moduleRecord.module, "__useDefault", { value: true });
     }
     if (moduleExports.__defaultInterop) {
-      Object.defineProperty(moduleRecord.module, "__defaultInterop", {value: true});
+      Object.defineProperty(moduleRecord.module, "__defaultInterop", { value: true });
     }
     if (moduleExports.__esModule) {
-      Object.defineProperty(moduleRecord.module, "__esModule", {value: true});
+      Object.defineProperty(moduleRecord.module, "__esModule", { value: true });
     }
     moduleRecord.evaluated = true;
     Object.freeze(moduleRecord.module);
     return moduleRecord.module;
   }
-  isNamedExportDefaultOnly(exports2) {
-    return exports2 !== void 0 && Object.getOwnPropertyNames(exports2).length === 2 && Object.prototype.hasOwnProperty.call(exports2, "default") && Object.prototype.hasOwnProperty.call(exports2, "__esModule");
+  // Determines if named exports module has only default export
+  isNamedExportDefaultOnly(exports) {
+    return exports !== void 0 && Object.getOwnPropertyNames(exports).length === 2 && Object.prototype.hasOwnProperty.call(exports, "default") && Object.prototype.hasOwnProperty.call(exports, "__esModule");
   }
+  // Wrap the dependency in a function that can be called and detected by __circular__ property.
+  // The LWC engine checks for __circular__ to detect circular dependencies.
   getCircularDependencyWrapper(module2) {
     const tmp = () => {
       return module2.__useDefault || module2.__defaultInterop ? module2.default : module2;
@@ -397,14 +437,17 @@ var ModuleRegistry = class {
     }
     const parentUrl = this.resolver.getBaseUrl();
     const specifier = moduleName || originalId;
-    this.profiler.logOperationStart({id: import_metrics.MODULE_FETCH, specifier});
+    this.profiler.logOperationStart({ id: import_metrics.MODULE_FETCH, specifier });
     return Promise.resolve().then(async () => {
       const loadHooks = this.loadHook;
       if (loadHooks) {
         for (let i = 0; i < loadHooks.length; i++) {
           const loadHook = loadHooks[i];
           const response = loadHook(resolvedId, parentUrl);
-          const result = (0, import_resolveAndLoadHook.isResponseAPromise)(response) ? await (0, import_resolveAndLoadHook.evaluateLoadHook)(resolvedId, response) : response;
+          const result = (0, import_resolveAndLoadHook.isResponseAPromise)(response) ? (
+            // eslint-disable-next-line no-await-in-loop
+            await (0, import_resolveAndLoadHook.evaluateLoadHook)(resolvedId, response)
+          ) : response;
           if (result === void 0) {
             throw new import_messages.LoaderError(import_messages.INVALID_LOADER_SERVICE_RESPONSE);
           }
@@ -421,17 +464,20 @@ var ModuleRegistry = class {
     }).then(() => {
       moduleDef = moduleName && this.namedDefineRegistry.get(moduleName);
       if (!moduleDef) {
-        this.logMessage("warning", `${moduleName} not found, falling back to the last loader.define call`);
+        this.logMessage(
+          "warning",
+          `${moduleName} not found, falling back to the last loader.define call`
+        );
         moduleDef = this.lastDefine;
       }
       if (!moduleDef) {
         throw new import_messages.LoaderError(import_messages.FAIL_INSTANTIATE, [resolvedId]);
       }
-      this.profiler.logOperationEnd({id: import_metrics.MODULE_FETCH, specifier});
+      this.profiler.logOperationEnd({ id: import_metrics.MODULE_FETCH, specifier });
       return moduleDef;
     }).catch((e) => {
       if (!(e instanceof import_messages.LoaderError)) {
-        this.profiler.logOperationStart({id: import_metrics.MODULE_ERROR, specifier});
+        this.profiler.logOperationStart({ id: import_metrics.MODULE_ERROR, specifier });
       }
       throw e;
     });
@@ -440,7 +486,7 @@ var ModuleRegistry = class {
     if (typeof hooks !== "object") {
       throw new import_messages.LoaderError(import_messages.INVALID_HOOK);
     }
-    const {loadModule: loadHook, resolveModule: resolveHook, loadMapping} = hooks;
+    const { loadModule: loadHook, resolveModule: resolveHook, loadMapping } = hooks;
     if (resolveHook) {
       if (this.resolveHook) {
         this.resolveHook.push(resolveHook);
@@ -459,7 +505,7 @@ var ModuleRegistry = class {
       this.resolver.addLoadMappingHook(loadMapping);
     }
   }
-  importMetadataInvalidationCallback({name, oldUrl, newUrl}) {
+  importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
     const handleStaleModuleHooks = this.handleStaleModuleHook;
     if (handleStaleModuleHooks) {
       (0, import_moduleInvalidation.evaluateHandleStaleModuleHooks)(handleStaleModuleHooks, {
@@ -468,7 +514,7 @@ var ModuleRegistry = class {
         newUrl
       });
     } else {
-      if (process.env.NODE_ENV !== "production" && import_dom.hasConsole) {
+      if (import_dom.hasConsole) {
         console.warn(`stale module detected ${name}, current URL:${oldUrl}, new URL:${newUrl}`);
       }
     }
@@ -488,7 +534,9 @@ var ModuleRegistry = class {
     return this.warnings;
   }
   logMessage(logType, message) {
-    if (!import_dom.hasConsole || process.env.NODE_ENV === "production") {
+    if (!import_dom.hasConsole || // note: we always expect this to be replaced at build time
+    // eslint-disable-next-line lwr/no-unguarded-apis
+    false) {
       return;
     }
     if (logType == "warning") {