@lwrjs/loader 0.10.0-alpha.2 → 0.10.0-alpha.20

package/build/assets/prod/lwr-loader-shim.bundle.js

@@ -4,7 +4,7 @@
 * SPDX-License-Identifier: MIT
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
 */
-/* LWR Module Loader Shim v0.10.0-alpha.2 */
+/* LWR Module Loader Shim v0.10.0-alpha.20 */
 (function () {
   'use strict';
 
@@ -12,11 +12,11 @@
   const BOOTSTRAP_PREFIX = 'lwr.bootstrap.';
   const BOOTSTRAP_ERROR = `${BOOTSTRAP_PREFIX}error`;
 
-  var Phase;
-  (function (Phase) {
+  var Phase = /*#__PURE__*/function (Phase) {
     Phase[Phase["Start"] = 0] = "Start";
     Phase[Phase["End"] = 1] = "End";
-  })(Phase || (Phase = {}));
+    return Phase;
+  }(Phase || {});
   // Attach a custom dispatcher
   let customDispatcher;
   function attachDispatcher(dispatcher) {
@@ -27,21 +27,46 @@
   // e.g. JSDom (used in Jest) doesn't implement these
   const perf = globalThis.performance;
   const isPerfSupported = typeof perf !== 'undefined' && typeof perf.mark === 'function' && typeof perf.clearMarks === 'function' && typeof perf.measure === 'function' && typeof perf.clearMeasures === 'function';
+  function getMeasureName(id, specifier) {
+    return specifier ? `${id}-${specifier}` : id;
+  }
+  function getMarkName(id, specifier, specifierIndex) {
+    const measureName = getMeasureName(id, specifier);
+    return specifier && specifierIndex ? `${measureName}_${specifierIndex}` : measureName;
+  }
+  function getDetail(specifier, metadata) {
+    const detail = specifier || metadata ? {
+      ...metadata
+    } : null;
+    if (detail && specifier) {
+      detail['specifier'] = specifier;
+    }
+    return detail;
+  }
 
   // For marking request metrics
   // Fallback to the Performance API if there is no custom dispatcher
   function logOperationStart({
     id,
-    specifier
+    specifier,
+    specifierIndex,
+    metadata
   }) {
     if (customDispatcher) {
       customDispatcher({
         id,
         phase: Phase.Start,
-        specifier
+        specifier,
+        metadata
+      });
+      return;
+    }
+    if (isPerfSupported) {
+      const markName = getMarkName(id, specifier, specifierIndex);
+      const detail = getDetail(specifier, metadata);
+      perf.mark(markName, {
+        detail
       });
-    } else if (isPerfSupported) {
-      perf.mark(id + (specifier ? `.${specifier}` : ''));
     }
   }
 
@@ -50,19 +75,25 @@
   /* istanbul ignore next */
   function logOperationEnd({
     id,
-    specifier
+    specifier,
+    specifierIndex,
+    metadata
   }) {
     if (customDispatcher) {
       customDispatcher({
         id,
         phase: Phase.End,
-        specifier
+        specifier,
+        metadata
       });
     } else if (isPerfSupported) {
-      const suffix = specifier ? `.${specifier}` : '';
-      const markName = id + suffix;
-      const measureName = `${id}.duration${suffix}`;
-      perf.measure(measureName, markName);
+      const markName = getMarkName(id, specifier, specifierIndex);
+      const measureName = getMeasureName(id, specifier);
+      const detail = getDetail(specifier, metadata);
+      perf.measure(measureName, {
+        start: markName,
+        detail
+      });
 
       // Clear the created mark and measure to avoid filling the performance entry buffer
       // Even if they get deleted, existing PerformanceObservers preserve copies of the entries
@@ -71,18 +102,26 @@
     }
   }
 
-  function createLoader(name, definition, config, externalModules) {
+  function createLoader(
+      name,
+      definition,
+      config,
+      externalModules,
+  ) {
       if (!definition || typeof definition[2] !== 'function') {
           throw new Error(`Expected loader with specifier "${name}" to be a module`);
       }
+
       // Create a Loader instance
       const exports = {};
       definition[2].call(null, exports);
       const { Loader } = exports;
       const loader = new Loader(config);
+
       if (externalModules && externalModules.length) {
           loader.registerExternalModules(externalModules);
       }
+
       // Define the loader module with public API: { define, load, services }
       const exporter = (exports) => {
           Object.assign(exports, {
@@ -92,10 +131,11 @@
           });
       };
       loader.define(name, ['exports'], exporter);
+
       return loader;
   }
 
-  const REQUIRED_MODULES_TIMEOUT = 300 * 1000;
+  const REQUIRED_MODULES_TIMEOUT = 60 * 1000; // 2m
 
   // Check for errors with autoBoot and customInit
   function validatePreInit(autoBoot, customInit) {
@@ -108,11 +148,18 @@
           throw new Error('The customInit hook must not be defined when autoBoot is true');
       }
   }
+
   // Process the customInit hook
-  function customInit(config, initializeApp, define, onBootstrapError) {
+  function customInit(
+      config,
+      initializeApp,
+      define,
+      onBootstrapError,
+  ) {
       // Validate config
       const { autoBoot, customInit } = config;
       validatePreInit(autoBoot, customInit);
+
       // Set up arguments and call the customInit hook, if available
       if (customInit) {
           const lwr = {
@@ -126,48 +173,74 @@
   }
 
   /* global document */
+
+
+
+
+
+
+
+
   /* eslint-disable lwr/no-unguarded-apis */
   const hasSetTimeout = typeof setTimeout === 'function';
   const hasConsole = typeof console !== 'undefined';
   /* eslint-enable lwr/no-unguarded-apis */
+
   class LoaderShim {
-      constructor(global) {
-          this.defineCache = {};
-          this.orderedDefs = [];
+      
+      
+      
+      
+       __init() {this.defineCache = {};}
+       __init2() {this.orderedDefs = [];}
+      
+       // eslint-disable-line no-undef, lwr/no-unguarded-apis
+
+      constructor(global) {LoaderShim.prototype.__init.call(this);LoaderShim.prototype.__init2.call(this);
           // Start watchdog timer
           if (hasSetTimeout) {
               this.watchdogTimerId = this.startWatchdogTimer();
           }
+
           // Parse configuration
           this.global = global;
-          this.config = global.LWR;
-          this.loaderSpecifier = 'lwr/loader/v/0_10_0-alpha_2';
+          this.config = global.LWR ;
+          this.loaderSpecifier = 'lwr/loader/v/0_10_0-alpha_20';
+
           // Set up error handler
           this.errorHandler = this.config.onError;
+
           // Set up the temporary LWR.define function and customInit hook
           const tempDefine = this.tempDefine.bind(this);
           global.LWR.define = tempDefine;
           this.bootReady = this.config.autoBoot;
+
           try {
               this.createProfilerModule(this.config);
-              customInit(Object.freeze(this.config), this.postCustomInit.bind(this), tempDefine, (e) => {
-                  // customInit handlers can overwrite
-                  // the error handler with onBootstrapError
-                  this.errorHandler = e;
-              });
-          }
-          catch (e) {
+              customInit(
+                  Object.freeze(this.config),
+                  this.postCustomInit.bind(this),
+                  tempDefine,
+                  (e) => {
+                      // customInit handlers can overwrite
+                      // the error handler with onBootstrapError
+                      this.errorHandler = e;
+                  },
+              );
+          } catch (e) {
               this.enterErrorState(e);
           }
       }
+
       // Return true if the app can be initialized
-      canInit() {
+       canInit() {
           // Initialize the app if:
           //  - bootReady: autoBoot is on OR customInit has finished
           //  - all required modules are defined
           const allDefined = this.config.requiredModules.every((m) => this.orderedDefs.includes(m));
           return this.bootReady && allDefined;
       }
+
       /**
        * Create a temporary LWR.define() function which captures all
        * calls that occur BEFORE the full loader module is available
@@ -177,7 +250,7 @@
        *      - each moduleName is pushed onto an array, to preserve
        *          the order in which the modules were defined
        */
-      tempDefine(...args) {
+       tempDefine(...args) {
           // Cache the incoming module
           const moduleName = args[0];
           this.defineCache[moduleName] = args;
@@ -191,15 +264,17 @@
               this.initApp();
           }
       }
+
       // Called by the customInit hook via lwr.initializeApp()
-      postCustomInit() {
+       postCustomInit() {
           this.bootReady = true;
           if (this.canInit()) {
               this.initApp();
           }
       }
+
       // Create the loader and initialize the application
-      initApp() {
+       initApp() {
           try {
               const loaderConfig = {
                   endpoints: this.config.endpoints,
@@ -213,18 +288,24 @@
                       rootComponents: this.config.rootComponents,
                   },
               };
-              const loader = createLoader(this.loaderSpecifier, this.defineCache[this.loaderSpecifier], loaderConfig, this.config.preloadModules);
+              const loader = createLoader(
+                  this.loaderSpecifier,
+                  this.defineCache[this.loaderSpecifier],
+                  loaderConfig,
+                  this.config.preloadModules,
+              );
               this.mountApp(loader);
-          }
-          catch (e) {
+          } catch (e) {
               this.enterErrorState(e);
           }
       }
-      waitForDOMContentLoaded() {
+
+       waitForDOMContentLoaded() {
           // eslint-disable-next-line lwr/no-unguarded-apis
           if (typeof document === undefined) {
               return Promise.resolve();
           }
+
           // Resolve if document is already "ready" https://developer.mozilla.org/en-US/docs/Web/API/Document/readyState
           // eslint-disable-next-line lwr/no-unguarded-apis
           if (document.readyState === 'interactive' || document.readyState === 'complete') {
@@ -237,17 +318,21 @@
               });
           });
       }
+
       // Create a module out of the profiler
       // Note: The profiler is also available as a module through lwc module resolution (see package.json)
-      createProfilerModule(globalLWR) {
+       createProfilerModule(globalLWR) {
           const exporter = (exports) => {
               Object.assign(exports, { logOperationStart, logOperationEnd });
           };
-          globalLWR.define('lwr/profiler/v/0_10_0-alpha_2', ['exports'], exporter);
+          globalLWR.define('lwr/profiler/v/0_10_0-alpha_20', ['exports'], exporter);
       }
+
       // Set up the application globals, import map, root custom element...
-      mountApp(loader) {
-          const { bootstrapModule, rootComponent, rootComponents, ssrProps, endpoints, imports, index } = this.config;
+       mountApp(loader) {
+          const { bootstrapModule, rootComponent, rootComponents, ssrProps, endpoints, imports, index } =
+              this.config;
+
           // Set global LWR.define to loader.define
           this.global.LWR = Object.freeze({
               define: loader.define.bind(loader),
@@ -258,42 +343,50 @@
               imports: imports || {},
               index: index || {},
           });
+
           // Redefine all modules in the temporary cache
           this.orderedDefs.forEach((specifier) => {
               if (specifier !== this.loaderSpecifier) {
                   loader.define(...this.defineCache[specifier]);
               }
           });
+
           // by default, app initialization is gated on waiting for document to be parsed (via DOMContentLoaded)
           const { disableInitDefer } = this.config;
+
           // Load the import mappings and application bootstrap module
           loader
               .registerImportMappings({ imports, index }, [bootstrapModule, rootComponent])
               .then(() => {
-              if (!disableInitDefer) {
-                  return this.waitForDOMContentLoaded();
-              }
-          })
+                  if (!disableInitDefer) {
+                      return this.waitForDOMContentLoaded();
+                  }
+              })
               .then(() => loader.load(bootstrapModule))
               .catch((reason) => {
-              this.enterErrorState(new Error(`Application ${rootComponent || bootstrapModule} could not be loaded: ${reason}`));
-          });
+                  this.enterErrorState(
+                      new Error(
+                          `Application ${rootComponent || bootstrapModule} could not be loaded: ${reason}`,
+                      ),
+                  );
+              });
       }
+
       // Trigger bootstrap error state, and call error handler if registered
-      enterErrorState(error) {
+       enterErrorState(error) {
           logOperationStart({ id: BOOTSTRAP_ERROR });
           if (this.errorHandler) {
               this.errorHandler(error);
-          }
-          else {
+          } else {
               if (hasConsole) {
                   // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
                   console.error(`An error occurred during LWR bootstrap. ${error.message}`, error.stack);
               }
           }
       }
+
       // eslint-disable-next-line no-undef, lwr/no-unguarded-apis
-      startWatchdogTimer() {
+       startWatchdogTimer() {
           // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
           return setTimeout(() => {
               this.enterErrorState(new Error('Failed to load required modules - timed out'));
@@ -302,16 +395,17 @@
   }
 
   // The loader module is ALWAYS required
-  const GLOBAL = globalThis;
+  const GLOBAL = globalThis ;
   GLOBAL.LWR.requiredModules = GLOBAL.LWR.requiredModules || [];
-  if (GLOBAL.LWR.requiredModules.indexOf('lwr/loader/v/0_10_0-alpha_2') < 0) {
-      GLOBAL.LWR.requiredModules.push('lwr/loader/v/0_10_0-alpha_2');
+  if (GLOBAL.LWR.requiredModules.indexOf('lwr/loader/v/0_10_0-alpha_20') < 0) {
+      GLOBAL.LWR.requiredModules.push('lwr/loader/v/0_10_0-alpha_20');
   }
   new LoaderShim(GLOBAL);
 
-}());
+})();
+//# sourceMappingURL=lwr-loader-shim.js.map
 
-LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use strict';
+LWR.define('lwr/loader/v/0_10_0-alpha_20', ['exports'], (function (exports) { 'use strict';
 
     const templateRegex = /\{([0-9]+)\}/g;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -326,17 +420,26 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         const message = Array.isArray(args) ? templateString(errorInfo.message, args) : errorInfo.message;
         return `LWR${errorInfo.code}: ${message}`;
     }
+
     class LoaderError extends Error {
         constructor(errorInfo, errorArgs) {
             super();
             this.message = generateErrorMessage(errorInfo, errorArgs);
         }
     }
+
     function invariant(condition, errorInfo) {
         if (!condition) {
             throw new LoaderError(errorInfo);
         }
     }
+
+
+
+
+
+
+
     const MISSING_NAME = Object.freeze({
         code: 3000,
         message: 'A module name is required.',
@@ -427,6 +530,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         level: 0,
         message: 'Invalid import metadata: {0} {1}',
     });
+
     /* importMap errors */
     Object.freeze({
         code: 3011,
@@ -436,7 +540,9 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
 
     /* eslint-disable lwr/no-unguarded-apis */
     const hasDocument = typeof document !== 'undefined';
+
     const hasSetTimeout = typeof setTimeout === 'function';
+
     const hasConsole = typeof console !== 'undefined';
     /* eslint-enable lwr/no-unguarded-apis */
 
@@ -444,7 +550,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         let baseUrl = undefined;
         if (hasDocument) {
             // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
-            const baseEl = document.querySelector('base[href]');
+            const baseEl = document.querySelector('base[href]') ;
             baseUrl = baseEl && baseEl.href;
         }
         // eslint-disable-next-line lwr/no-unguarded-apis
@@ -456,8 +562,10 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 baseUrl = baseUrl.slice(0, lastSepIndex + 1);
             }
         }
+
         return baseUrl;
     }
+
     /**
      * Check if a string is a URL based on Common Internet Scheme Syntax
      * https://www.ietf.org/rfc/rfc1738.txt
@@ -484,24 +592,26 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
     function isUrl(url) {
         return url.indexOf('://') !== -1;
     }
+
     // Borrowed and adapted from https://github.com/systemjs/systemjs/blob/master/src/common.js
     // Resolves the first path segment relative to the second/parent URL
     // eg: resolveIfNotPlainOrUrl('../test', 'http://www.site.com/one/two') => 'http://www.site.com/test'
     // eg: resolveIfNotPlainOrUrl('./x/y/z', 'https://my.com/segment')).toBe('https://my.com/x/y/z')
     function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
         const backslashRegEx = /\\/g;
-        if (relUrl.indexOf('\\') !== -1)
-            relUrl = relUrl.replace(backslashRegEx, '/');
+        if (relUrl.indexOf('\\') !== -1) relUrl = relUrl.replace(backslashRegEx, '/');
         // protocol-relative
         if (relUrl[0] === '/' && relUrl[1] === '/') {
             return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
         }
         // relative-url
-        else if ((relUrl[0] === '.' &&
-            (relUrl[1] === '/' ||
-                (relUrl[1] === '.' && (relUrl[2] === '/' || (relUrl.length === 2 && (relUrl += '/')))) ||
-                (relUrl.length === 1 && (relUrl += '/')))) ||
-            relUrl[0] === '/') {
+        else if (
+            (relUrl[0] === '.' &&
+                (relUrl[1] === '/' ||
+                    (relUrl[1] === '.' && (relUrl[2] === '/' || (relUrl.length === 2 && (relUrl += '/')))) ||
+                    (relUrl.length === 1 && (relUrl += '/')))) ||
+            relUrl[0] === '/'
+        ) {
             const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
             let pathname;
             if (parentUrl[parentProtocol.length + 1] === '/') {
@@ -509,21 +619,23 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 if (parentProtocol !== 'file:') {
                     pathname = parentUrl.slice(parentProtocol.length + 2);
                     pathname = pathname.slice(pathname.indexOf('/') + 1);
-                }
-                else {
+                } else {
                     pathname = parentUrl.slice(8);
                 }
-            }
-            else {
+            } else {
                 // resolving to :/ so pathname is the /... part
-                pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/' ? 1 : 0));
+                pathname = parentUrl.slice(
+                    parentProtocol.length + (parentUrl[parentProtocol.length] === '/' ? 1 : 0),
+                );
             }
-            if (relUrl[0] === '/')
-                return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+
+            if (relUrl[0] === '/') return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+
             // join together and split for removal of .. and . segments
             // looping the string instead of anything fancy for perf reasons
             // '../../../../../z' resolved to 'x/y' is just 'z'
             const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
+
             const output = [];
             let segmentIndex = -1;
             for (let i = 0; i < segmented.length; i++) {
@@ -534,6 +646,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                         segmentIndex = -1;
                     }
                 }
+
                 // new segment - check if it is relative
                 else if (segmented[i] === '.') {
                     // ../ segment
@@ -544,8 +657,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     // ./ segment
                     else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
                         i += 1;
-                    }
-                    else {
+                    } else {
                         // the start of a new segment as below
                         segmentIndex = i;
                     }
@@ -556,13 +668,14 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 }
             }
             // finish reading out the last segment
-            if (segmentIndex !== -1)
-                output.push(segmented.slice(segmentIndex));
+            if (segmentIndex !== -1) output.push(segmented.slice(segmentIndex));
             return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
         }
     }
+
     function resolveUrl(relUrl, parentUrl) {
-        const resolvedUrl = resolveIfNotPlainOrUrl(relUrl, parentUrl) ||
+        const resolvedUrl =
+            resolveIfNotPlainOrUrl(relUrl, parentUrl) ||
             (isUrl(relUrl) ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
         return resolvedUrl;
     }
@@ -575,6 +688,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         script.src = url;
         return script;
     }
+
     let lastWindowError$1, lastWindowErrorUrl;
     function loadModuleDef(url) {
         return new Promise(function (resolve, reject) {
@@ -588,8 +702,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     document.head.removeChild(script);
                     if (lastWindowErrorUrl === url) {
                         reject(lastWindowError$1);
-                    }
-                    else {
+                    } else {
                         resolve();
                     }
                 });
@@ -598,6 +711,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             }
         });
     }
+
     if (hasDocument) {
         // When a script is executed, runtime errors are on the global/window scope which are NOT caught by the script's onerror handler.
         // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
@@ -621,44 +735,53 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
 
     /* spec based import map resolver */
     class ImportMetadataResolver {
-        constructor(config, invalidationCallback) {
-            // Default to empty mappings
-            this.importURICache = new Map();
-            this.pendingURICache = new Map();
-            this.loadMappingHooks = [];
+        // Default to empty mappings
+         __init() {this.importURICache = new Map();}
+         __init2() {this.pendingURICache = new Map();}
+        
+        
+         __init3() {this.loadMappingHooks = [];}
+
+        constructor(config, invalidationCallback) {ImportMetadataResolver.prototype.__init.call(this);ImportMetadataResolver.prototype.__init2.call(this);ImportMetadataResolver.prototype.__init3.call(this);
             this.config = config;
             this.invalidationCallback = invalidationCallback;
         }
+
         addLoadMappingHook(hook) {
             this.loadMappingHooks.push(hook);
         }
+
         getMappingEndpoint() {
             return this.config.endpoints && this.config.endpoints.uris
                 ? this.config.endpoints.uris.mapping
                 : undefined;
         }
+
         getModifiersAsUrlParams() {
             const modifiers = this.config.endpoints ? this.config.endpoints.modifiers : undefined;
+
             if (!modifiers) {
                 // No modifiers return an empty string to append to the URL
                 return '';
-            }
-            else {
+            } else {
                 const qs = Object.keys(modifiers)
                     .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(modifiers[key])}`)
                     .join('&');
                 return `?${qs}`;
             }
         }
+
         buildMappingUrl(specifier) {
             const mappingEndpoint = this.getMappingEndpoint();
             const specifiers = encodeURIComponent(specifier);
             const modifiers = this.getModifiersAsUrlParams();
             return `${mappingEndpoint}${specifiers}${modifiers}`;
         }
+
         getBaseUrl() {
             return this.config.baseUrl;
         }
+
         registerImportMappings(newImportMetadata, rootSpecifiers) {
             if (!rootSpecifiers || rootSpecifiers.length === 0) {
                 const imports = newImportMetadata ? JSON.stringify(newImportMetadata) : 'undefined';
@@ -680,8 +803,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     const existing = this.importURICache.get(specifier);
                     if (!existing) {
                         this.saveImportURIRecord(specifier, uri, indexValue, rootSpecifiers.includes(specifier));
-                    }
-                    else {
+                    } else {
                         const identity = indexValue || uri;
                         const existingIdentity = existing.identity || existing.uri;
                         if (existingIdentity !== identity) {
@@ -695,22 +817,24 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 });
             }
         }
+
         // Get URL from the local cache or return undefiend
-        getURI(specifier) {
+         getURI(specifier) {
             return this.importURICache.has(specifier)
                 ? resolveUrl(this.importURICache.get(specifier).uri, this.getBaseUrl())
                 : undefined;
         }
+
         resolveLocal(specifier) {
             const uri = this.getURI(specifier);
             if (uri) {
                 return uri;
-            }
-            else if (isUrl(specifier) || specifier.startsWith('/')) {
+            } else if (isUrl(specifier) || specifier.startsWith('/')) {
                 return specifier;
             }
             return undefined;
         }
+
         /**
          *  Resolves a the URI for a specified module.  It will return the value in this order:
          *
@@ -725,15 +849,14 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             let uri = this.getURI(specifier);
             if (uri) {
                 return uri;
-            }
-            else if (isUrl(specifier) || specifier.startsWith('/')) {
+            } else if (isUrl(specifier) || specifier.startsWith('/')) {
                 return specifier;
-            }
-            else {
+            } else {
                 const pending = this.pendingURICache.get(specifier);
                 if (pending) {
                     return pending;
                 }
+
                 this.config.profiler.logOperationStart({ id: MAPPINGS_FETCH, specifier });
                 const fetchMappingService = this.hasMappingHooks()
                     ? this.evaluateMappingHooks
@@ -741,33 +864,37 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 const promise = fetchMappingService
                     .bind(this)(specifier)
                     .then((importMetadata) => {
-                    if (!importMetadata || !importMetadata.imports) {
-                        throw new LoaderError(UNRESOLVED, [specifier]);
-                    }
-                    this.registerImportMappings(importMetadata, [specifier]);
-                    uri = this.getURI(specifier);
-                    if (!uri) {
-                        throw new LoaderError(UNRESOLVED, [specifier]);
-                    }
-                    this.config.profiler.logOperationEnd({ id: MAPPINGS_FETCH, specifier });
-                    return uri;
-                })
+                        if (!importMetadata || !importMetadata.imports) {
+                            throw new LoaderError(UNRESOLVED, [specifier]);
+                        }
+                        this.registerImportMappings(importMetadata, [specifier]);
+                        uri = this.getURI(specifier);
+                        if (!uri) {
+                            throw new LoaderError(UNRESOLVED, [specifier]);
+                        }
+
+                        this.config.profiler.logOperationEnd({ id: MAPPINGS_FETCH, specifier });
+                        return uri;
+                    })
                     .finally(() => {
-                    this.pendingURICache.delete(specifier);
-                });
+                        this.pendingURICache.delete(specifier);
+                    });
+
                 this.pendingURICache.set(specifier, promise);
                 return promise;
             }
         }
-        hasMappingHooks() {
+
+         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) {
+         async evaluateMappingHooks(specifier) {
             // Check with any registered loadMappingHooks
             const loadMappingHooks = this.loadMappingHooks;
             if (loadMappingHooks.length) {
@@ -782,13 +909,16 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     }
                 }
             }
+
             // If we still do not have a match call the mapping service
             return this.fetchNewMappings(specifier);
         }
-        async fetchNewMappings(specifier) {
+
+         async fetchNewMappings(specifier) {
             if (typeof globalThis.fetch !== 'function') {
                 throw new LoaderError(UNRESOLVED, [specifier]);
             }
+
             // TODO For module invalidation with bundles it is recommended we have to send back all loaded root specified
             // to ensure we detect all conflicts.
             const uri = resolveUrl(this.buildMappingUrl(specifier), this.getBaseUrl());
@@ -800,21 +930,21 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 return res
                     .json()
                     .then((ret) => {
-                    return ret;
-                })
+                        return ret ;
+                    })
                     .catch((err) => {
-                    throw new LoaderError(UNRESOLVED, [specifier]);
-                });
+                        throw new LoaderError(UNRESOLVED, [specifier]);
+                    });
             });
         }
-        saveImportURIRecord(specifier, uri, identity, isRoot) {
+
+         saveImportURIRecord(specifier, uri, identity, isRoot) {
             if (!identity || uri === identity) {
                 this.importURICache.set(specifier, {
                     uri,
                     isRoot: isRoot,
                 });
-            }
-            else {
+            } else {
                 this.importURICache.set(specifier, {
                     uri,
                     identity,
@@ -827,11 +957,13 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
     function reportError(error) {
         // TODO eventually this should be configurable instrumentation to send this somewhere
         // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
-        if (hasConsole)
-            console.error(error);
+        if (hasConsole) console.error(error);
     }
 
-    function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
+    function evaluateHandleStaleModuleHooks(
+        handleStaleModuleHooks,
+        hookArgs,
+    ) {
         const { name, oldUrl, newUrl } = hookArgs;
         // keep evaluating hooks if return value is null
         for (let i = 0; i < handleStaleModuleHooks.length; i++) {
@@ -841,39 +973,82 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 if (hookResult !== null) {
                     break;
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 reportError(new LoaderError(STALE_HOOK_ERROR));
             }
         }
     }
 
-    const MODULE_LOAD_TIMEOUT_TIMER = 300000;
+    const MODULE_LOAD_TIMEOUT_TIMER = 60 * 1000; // 1m
+
+    /*!
+     * Copyright (C) 2023 salesforce.com, inc.
+     */
+    // @ts-ignore: Prevent cannot find name 'trustedTypes' error.
+    const SUPPORTS_TRUSTED_TYPES = typeof trustedTypes !== 'undefined';
+    function createTrustedTypesPolicy(name, options) {
+      // @ts-ignore: Prevent cannot find name 'trustedTypes' error.
+      return trustedTypes.createPolicy(name, options);
+    }
+    function createFallbackPolicy(_name, options) {
+      return options;
+    }
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/trusted-types
+    const createPolicy = SUPPORTS_TRUSTED_TYPES ? createTrustedTypesPolicy : createFallbackPolicy;
+    const policyOptions = {
+      createHTML(value) {
+        return value;
+      },
+      createScript(value) {
+        return value;
+      },
+      createScriptURL(value) {
+        return value;
+      }
+    };
+    const trusted = createPolicy('trusted', policyOptions);
+    /*! version: 0.19.4 */
 
     /* global console,process */
+
+
     let lastWindowError;
     if (hasDocument) {
         globalThis.addEventListener('error', (evt) => {
             lastWindowError = evt.error;
         });
     }
+
     if (process.env.NODE_ENV !== 'production') {
         if (!hasSetTimeout && hasConsole) {
             // eslint-disable-next-line lwr/no-unguarded-apis
             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'));
+        return (
+            Object.prototype.hasOwnProperty.call(response, 'data') &&
+            !Object.prototype.hasOwnProperty.call(response, 'blob')
+        );
     }
-    function isFetchResponse(response) {
+    function isFetchResponse(
+        response,
+    ) {
         // if it quacks like a duck...
-        return typeof response.blob === 'function';
+        return typeof (response ).blob === 'function';
     }
-    function isResponseAPromise(response) {
-        return !!(response && response.then);
+
+    function isResponseAPromise(
+        response
+
+
+
+    ,
+    ) {
+        return !!(response && (response ).then);
     }
+
     async function evaluateLoadHookResponse(response, id) {
         return Promise.resolve().then(async () => {
             if (!response.status) {
@@ -882,36 +1057,41 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             if (response.status !== 200) {
                 throw new LoaderError(HTTP_FAIL_LOAD, [id, `${response.status}`]);
             }
+
             const isResponse = isFetchResponse(response);
             let code;
             if (isCustomResponse(response)) {
                 code = response.data;
-            }
-            else if (isResponse) {
+            } else if (isResponse) {
                 // handle fetch response
-                code = await response.text();
-            }
-            else {
+                code = await (response ).text();
+            } else {
                 throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
             }
+
             if (!code) {
                 throw new LoaderError(FAIL_LOAD, [id]);
             }
+
             code = `${code}\n//# sourceURL=${id}`; // append sourceURL for debugging
             try {
                 // TODO eval source maps for debugging
-                eval(code);
-            }
-            catch (e) {
+                eval(trusted.createScript(code));
+            } catch (e) {
                 throw new LoaderError(FAIL_LOAD, [id]);
             }
+
             if (lastWindowError) {
                 throw new LoaderError(FAIL_LOAD, [id]);
             }
             return true;
         });
     }
-    async function evaluateLoadHook(id, hookPromise) {
+
+    async function evaluateLoadHook(
+        id,
+        hookPromise,
+    ) {
         if (!hasSetTimeout) {
             return hookPromise;
         }
@@ -923,45 +1103,91 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             }, MODULE_LOAD_TIMEOUT_TIMER);
             hookPromise
                 .then((response) => {
-                resolve(response);
-            })
+                    resolve(response);
+                })
                 .catch(() => {
-                reject(new LoaderError(FAIL_HOOK_LOAD, [id]));
-            })
+                    reject(new LoaderError(FAIL_HOOK_LOAD, [id]));
+                })
                 .finally(() => {
-                // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
-                clearTimeout(timer);
-            });
+                    // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+                    clearTimeout(timer);
+                });
         });
     }
 
     /* global console,process */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     class ModuleRegistry {
-        constructor(config) {
-            // A registry for named AMD defines containing the *metadata* of AMD module
-            this.namedDefineRegistry = new Map();
-            // The evaluated module registry where the module identifier (name or URL?) is the key
-            this.moduleRegistry = new Map();
-            // Aliases of modules in the registry
-            this.aliases = new Map();
+        
+
+        constructor(config) {ModuleRegistry.prototype.__init.call(this);ModuleRegistry.prototype.__init2.call(this);ModuleRegistry.prototype.__init3.call(this);
             this.profiler = config.profiler;
-            this.resolver = new ImportMetadataResolver(config, this.importMetadataInvalidationCallback.bind(this));
+            this.resolver = new ImportMetadataResolver(
+                config,
+                this.importMetadataInvalidationCallback.bind(this),
+            );
         }
+
         async load(id, importer) {
             const resolvedId = await this.resolve(id, importer);
             const moduleRecord = this.getModuleRecord(resolvedId, id);
             if (moduleRecord.evaluated) {
                 return moduleRecord.module;
-            }
-            else {
+            } else {
                 if (!moduleRecord.evaluationPromise) {
                     moduleRecord.evaluationPromise = this.topLevelEvaluation(moduleRecord);
                 }
                 return moduleRecord.evaluationPromise;
             }
         }
+
         async resolve(id, importer) {
             const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
+
             let resolved;
             let aliasedId = id;
             const resolveHooks = this.resolveHook;
@@ -974,6 +1200,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                         // eslint-disable-next-line no-await-in-loop
                         result = isResponseAPromise(response) ? await response : response;
                     }
+
                     // if result is not null, attempt resolution
                     if (result !== null) {
                         if (typeof result === 'string') {
@@ -984,6 +1211,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                             aliasedId = result; // the next hook will receive the new id
                             continue;
                         }
+
                         resolved =
                             result && result.url && (resolveIfNotPlainOrUrl(result.url, parentUrl) || result.url);
                         if (!resolved) {
@@ -993,27 +1221,32 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                         break;
                     }
                 }
+
                 if (aliasedId !== id) {
                     // resolved module id is the aliased module if it has already been defined
                     if (!resolved && this.namedDefineRegistry.has(aliasedId)) {
                         return aliasedId;
-                    }
-                    else {
+                    } else {
                         id = aliasedId;
                     }
                 }
             }
+
             if (!resolved) {
                 const resolvedOrPlain = resolveIfNotPlainOrUrl(id, parentUrl) || id;
+
                 // if module registry already has named module the resolved id is the plain id
                 if (this.moduleRegistry.has(resolvedOrPlain)) {
                     return resolvedOrPlain;
                 }
+
                 const resolvedUrl = this.resolver.resolveLocal(resolvedOrPlain);
                 if (resolvedUrl) {
                     // return the plain id if it is already defined && the resolvedUrl is NOT already in the module registry
-                    if (this.namedDefineRegistry.has(resolvedOrPlain) &&
-                        this.namedDefineRegistry.get(resolvedOrPlain).defined) {
+                    if (
+                        this.namedDefineRegistry.has(resolvedOrPlain) &&
+                        this.namedDefineRegistry.get(resolvedOrPlain).defined
+                    ) {
                         const record = this.moduleRegistry.get(resolvedUrl);
                         if (!record || !this.aliases.has(resolvedOrPlain)) {
                             return resolvedOrPlain;
@@ -1021,13 +1254,13 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     }
                     return resolvedUrl;
                 }
+
                 if (this.namedDefineRegistry.has(resolvedOrPlain)) {
                     return resolvedOrPlain;
                 }
                 try {
                     resolved = await this.resolver.resolve(resolvedOrPlain);
-                }
-                catch (e) {
+                } catch (e) {
                     // defer to error handling below for unresolved
                 }
             }
@@ -1035,6 +1268,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 if (this.namedDefineRegistry.has(id)) {
                     return id;
                 }
+
                 throw new LoaderError(UNRESOLVED, [id]);
             }
             if (importer && isUrl(resolved)) {
@@ -1042,9 +1276,11 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             }
             return resolved;
         }
+
         has(id) {
             return this.moduleRegistry.has(id);
         }
+
         define(name, dependencies, exporter) {
             const mod = this.namedDefineRegistry.get(name);
             // Don't allow redefining a module.
@@ -1056,6 +1292,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 this.lastDefine = mod;
                 return;
             }
+
             const moduleDef = {
                 name,
                 dependencies,
@@ -1066,10 +1303,12 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 // if module is "external", resolve the external promise to notify any dependees
                 mod.external.resolveExternal(moduleDef);
             }
+
             this.profiler.logOperationStart({ id: 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.
          *
@@ -1082,6 +1321,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     let timer;
                     const moduleDefPromise = new Promise((resolve, reject) => {
                         resolveExternal = resolve;
+
                         // watch the external for timeout
                         // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
                         timer = setTimeout(() => {
@@ -1099,24 +1339,39 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                             moduleDefPromise,
                         },
                     };
-                    this.namedDefineRegistry.set(id, moduleDef);
-                }
-                else if (process.env.NODE_ENV !== 'production' && hasConsole) {
+                    this.namedDefineRegistry.set(id, moduleDef );
+                } else if (process.env.NODE_ENV !== 'production' && hasConsole) {
                     // eslint-disable-next-line lwr/no-unguarded-apis
                     console.warn(MODULE_ALREADY_LOADED.message, id);
                 }
             });
         }
+
+        
+
+        // A registry for named AMD defines containing the *metadata* of AMD module
+         __init() {this.namedDefineRegistry = new Map();}
+
+        // The evaluated module registry where the module identifier (name or URL?) is the key
+         __init2() {this.moduleRegistry = new Map();}
+
+        // Aliases of modules in the registry
+        __init3() {this.aliases = new Map();}
+
+        
+
         getImportMetadataResolver() {
             return this.resolver;
         }
+
         // Returns an existing module record by the resolvedId or aliased id
-        getExistingModuleRecord(resolvedId, aliasId) {
+         getExistingModuleRecord(resolvedId, aliasId) {
             const moduleRecord = this.moduleRegistry.get(resolvedId);
             if (moduleRecord) {
                 this.storeModuleAlias(aliasId, resolvedId);
                 return moduleRecord;
             }
+
             // Check if this is a known alias
             if (resolvedId !== aliasId) {
                 const alias = this.aliases.get(aliasId);
@@ -1129,13 +1384,15 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             }
             return moduleRecord;
         }
-        getModuleRecord(resolvedId, id) {
+
+         getModuleRecord(resolvedId, id) {
             // Look for an existing record
             const existingRecord = this.getExistingModuleRecord(resolvedId, id);
             if (existingRecord) {
                 // return existing
                 return existingRecord;
             }
+
             // Create a new Module Record
             const instantiation = this.getModuleDef(resolvedId, id);
             const dependencyRecords = instantiation.then((moduleDef) => {
@@ -1143,15 +1400,17 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 // get dep and filter out exports
                 const filtered = dependencies
                     .map((dep) => {
-                    if (dep === 'exports') {
-                        return;
-                    }
-                    invariant(dep !== 'require', NO_AMD_REQUIRE);
-                    return this.getModuleDependencyRecord.call(this, dep);
-                })
-                    .filter((depRecord) => depRecord !== undefined);
+                        if (dep === 'exports') {
+                            return;
+                        }
+                        invariant(dep !== 'require', NO_AMD_REQUIRE);
+                        return this.getModuleDependencyRecord.call(this, dep);
+                    })
+                    .filter((depRecord) => depRecord !== undefined) ;
+
                 return Promise.all(filtered);
             });
+
             const newModuleRecord = {
                 id: resolvedId,
                 module: Object.create(null),
@@ -1160,16 +1419,17 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 evaluated: false,
                 evaluationPromise: null,
             };
+
             this.moduleRegistry.set(resolvedId, newModuleRecord);
             this.storeModuleAlias(id, resolvedId);
             return newModuleRecord;
         }
-        storeModuleAlias(aliasId, resolvedId) {
+
+         storeModuleAlias(aliasId, resolvedId) {
             if (aliasId !== resolvedId) {
                 if (!this.aliases.has(aliasId)) {
                     this.aliases.set(aliasId, resolvedId);
-                }
-                else if (process.env.NODE_ENV !== 'production' && hasConsole) {
+                } else if (process.env.NODE_ENV !== 'production' && hasConsole) {
                     // Warn the user if they were not aliasing to the resolvedId
                     const currentResolvedId = this.aliases.get(aliasId);
                     if (currentResolvedId !== resolvedId) {
@@ -1179,17 +1439,23 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 }
             }
         }
-        async getModuleDependencyRecord(dependency) {
+
+         async getModuleDependencyRecord(dependency) {
             const resolvedDepId = await this.resolve(dependency);
             return this.getModuleRecord(resolvedDepId, dependency);
         }
+
         // execute the "top-level code" (the code outside of functions) of a module
-        async topLevelEvaluation(moduleRecord) {
+         async topLevelEvaluation(moduleRecord) {
             await this.instantiateAll(moduleRecord, {});
             return this.evaluateModule(moduleRecord, {});
         }
+
         // Returns a promise when a module and all of it's dependencies have finished instantiation
-        async instantiateAll(moduleRecord, instantiatedMap) {
+         async instantiateAll(
+            moduleRecord,
+            instantiatedMap,
+        ) {
             if (!instantiatedMap[moduleRecord.id]) {
                 instantiatedMap[moduleRecord.id] = true;
                 const dependencyModuleRecords = await moduleRecord.dependencyRecords;
@@ -1202,46 +1468,61 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 }
             }
         }
-        async evaluateModule(moduleRecord, evaluationMap) {
+
+         async evaluateModule(
+            moduleRecord,
+            evaluationMap,
+        ) {
             const dependencyModuleRecords = await moduleRecord.dependencyRecords;
             if (dependencyModuleRecords.length > 0) {
                 evaluationMap[moduleRecord.id] = true;
                 // evaluate dependencies first
                 await this.evaluateModuleDependencies(dependencyModuleRecords, evaluationMap);
             }
+
             const { exporter, dependencies } = await moduleRecord.instantiation;
             // The exports object automatically gets filled in by the exporter evaluation
             const exports = {};
-            const depsMapped = await Promise.all(dependencies.map(async (dep) => {
-                if (dep === 'exports') {
-                    return exports;
-                }
-                const resolvedDepId = await this.resolve(dep);
-                const moduleRecord = this.moduleRegistry.get(resolvedDepId);
-                if (!moduleRecord) {
+            const depsMapped = await Promise.all(
+                dependencies.map(async (dep) => {
+                    if (dep === 'exports') {
+                        return exports;
+                    }
+                    const resolvedDepId = await this.resolve(dep);
+
+                    const moduleRecord = this.moduleRegistry.get(resolvedDepId) ;
+                    if (!moduleRecord) {
+                        throw new LoaderError(FAILED_DEP, [resolvedDepId]);
+                    }
+
+                    const module = moduleRecord.module;
+
+                    /**
+                     * Circular dependencies are handled properly when named exports are used,
+                     * however, for default exports there is a bug: https://github.com/rollup/rollup/issues/3384
+                     *
+                     * The workaround below applies for circular dependencies (!moduleRecord.evaluated)
+                     */
+                    if (!moduleRecord.evaluated) {
+                        return this.getCircularDependencyWrapper(module);
+                    }
+
+                    if (module) {
+                        return module.__defaultInterop ? module.default : module;
+                    }
+
                     throw new LoaderError(FAILED_DEP, [resolvedDepId]);
-                }
-                const module = moduleRecord.module;
-                /**
-                 * Circular dependencies are handled properly when named exports are used,
-                 * however, for default exports there is a bug: https://github.com/rollup/rollup/issues/3384
-                 *
-                 * The workaround below applies for circular dependencies (!moduleRecord.evaluated)
-                 */
-                if (!moduleRecord.evaluated) {
-                    return this.getCircularDependencyWrapper(module);
-                }
-                if (module) {
-                    return module.__defaultInterop ? module.default : module;
-                }
-                throw new LoaderError(FAILED_DEP, [resolvedDepId]);
-            }));
+                }),
+            );
+
             // W-10029836 - In the case where we could be instantiating multiple graphs at the same time lets make sure the module have not already been evaluated
             if (moduleRecord.evaluated) {
                 return moduleRecord.module;
             }
+
             // evaluates the module function
             let moduleDefault = exporter(...depsMapped);
+
             // value is returned from exporter, then we are not using named exports
             if (moduleDefault !== undefined) {
                 moduleDefault = { default: moduleDefault };
@@ -1257,7 +1538,9 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     Object.defineProperty(exports, '__useDefault', { value: true });
                 }
             }
+
             const moduleExports = moduleDefault || exports;
+
             // update the module record
             // copy over enumerable public methods to module
             for (const key in moduleExports) {
@@ -1271,6 +1554,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     },
                 });
             }
+
             // copy non-enumerable to module
             if (moduleExports.__useDefault) {
                 Object.defineProperty(moduleRecord.module, '__useDefault', { value: true });
@@ -1281,27 +1565,36 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             if (moduleExports.__esModule) {
                 Object.defineProperty(moduleRecord.module, '__esModule', { value: true });
             }
+
             moduleRecord.evaluated = true;
             Object.freeze(moduleRecord.module);
             return moduleRecord.module;
         }
+
         // Determines if named exports module has only default export
-        isNamedExportDefaultOnly(exports) {
-            return (exports !== undefined &&
+         isNamedExportDefaultOnly(exports) {
+            return (
+                exports !== undefined &&
                 Object.getOwnPropertyNames(exports).length === 2 &&
                 Object.prototype.hasOwnProperty.call(exports, 'default') &&
-                Object.prototype.hasOwnProperty.call(exports, '__esModule'));
+                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(module) {
+         getCircularDependencyWrapper(module) {
             const tmp = () => {
                 return module.__useDefault || module.__defaultInterop ? module.default : module;
             };
             tmp.__circular__ = true;
             return tmp;
         }
-        async evaluateModuleDependencies(dependencyModuleRecords, evaluationMap) {
+
+         async evaluateModuleDependencies(
+            dependencyModuleRecords,
+            evaluationMap,
+        ) {
             for (let i = 0; i < dependencyModuleRecords.length; i++) {
                 const depRecord = dependencyModuleRecords[i];
                 if (!depRecord.evaluated && !evaluationMap[depRecord.id]) {
@@ -1311,15 +1604,17 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 }
             }
         }
-        async getModuleDef(resolvedId, originalId) {
+
+         async getModuleDef(resolvedId, originalId) {
             // reset lastDefine
             this.lastDefine = undefined;
+
             // the module name can be the resolved ID or the original ID if neither are URL's.
             const moduleName = !isUrl(resolvedId)
                 ? resolvedId
                 : originalId !== resolvedId
-                    ? originalId
-                    : undefined;
+                ? originalId
+                : undefined;
             let moduleDef = moduleName && this.namedDefineRegistry.get(moduleName);
             if (moduleDef && moduleDef.external) {
                 return moduleDef.external.moduleDefPromise;
@@ -1332,67 +1627,75 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             this.profiler.logOperationStart({ id: 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 = (isResponseAPromise(response)
-                            ? // eslint-disable-next-line no-await-in-loop
-                                await evaluateLoadHook(resolvedId, response)
-                            : response);
-                        if (result === undefined) {
-                            throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
-                        }
-                        if (result && result !== null) {
-                            return evaluateLoadHookResponse(result, resolvedId);
+                    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 = (
+                                isResponseAPromise(response)
+                                    ? // eslint-disable-next-line no-await-in-loop
+                                      await evaluateLoadHook(resolvedId, response)
+                                    : response
+                            ) ;
+                            if (result === undefined) {
+                                throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+                            }
+                            if (result && result !== null) {
+                                return evaluateLoadHookResponse(result, resolvedId);
+                            }
                         }
                     }
-                }
-                return false;
-            })
+                    return false;
+                })
                 .then((result) => {
-                if (result !== true && hasDocument) {
-                    return loadModuleDef(resolvedId);
-                }
-            })
+                    if (result !== true && hasDocument) {
+                        return loadModuleDef(resolvedId);
+                    }
+                })
                 .then(() => {
-                // Attempt to retrieve the module definition by name first
-                moduleDef = moduleName && this.namedDefineRegistry.get(moduleName);
-                // Fallback to the last loader.define call
-                if (!moduleDef) {
-                    moduleDef = this.lastDefine;
-                }
-                // This should not happen
-                if (!moduleDef) {
-                    throw new LoaderError(FAIL_INSTANTIATE, [resolvedId]);
-                }
-                this.profiler.logOperationEnd({ id: MODULE_FETCH, specifier });
-                return moduleDef;
-            })
+                    // Attempt to retrieve the module definition by name first
+                    moduleDef = moduleName && this.namedDefineRegistry.get(moduleName);
+
+                    // Fallback to the last loader.define call
+                    if (!moduleDef) {
+                        moduleDef = this.lastDefine;
+                    }
+
+                    // This should not happen
+                    if (!moduleDef) {
+                        throw new LoaderError(FAIL_INSTANTIATE, [resolvedId]);
+                    }
+
+                    this.profiler.logOperationEnd({ id: MODULE_FETCH, specifier });
+                    return moduleDef;
+                })
                 .catch((e) => {
-                this.profiler.logOperationStart({ id: MODULE_ERROR, specifier });
-                throw e;
-            });
+                    this.profiler.logOperationStart({ id: MODULE_ERROR, specifier });
+                    throw e;
+                });
         }
+
+        
+        
+        
         addLoaderPlugin(hooks) {
             if (typeof hooks !== 'object') {
                 throw new LoaderError(INVALID_HOOK);
             }
             const { loadModule: loadHook, resolveModule: resolveHook, loadMapping } = hooks;
+
             if (resolveHook) {
                 if (this.resolveHook) {
                     this.resolveHook.push(resolveHook);
-                }
-                else {
+                } else {
                     this.resolveHook = [resolveHook];
                 }
             }
             if (loadHook) {
                 if (this.loadHook) {
                     this.loadHook.push(loadHook);
-                }
-                else {
+                } else {
                     this.loadHook = [loadHook];
                 }
             }
@@ -1400,7 +1703,8 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 this.resolver.addLoadMappingHook(loadMapping);
             }
         }
-        importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
+
+         importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
             const handleStaleModuleHooks = this.handleStaleModuleHook;
             if (handleStaleModuleHooks) {
                 evaluateHandleStaleModuleHooks(handleStaleModuleHooks, {
@@ -1408,19 +1712,19 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     oldUrl,
                     newUrl,
                 });
-            }
-            else {
+            } else {
                 if (process.env.NODE_ENV !== 'production' && hasConsole) {
                     // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
                     console.warn(`stale module detected ${name}, current URL:${oldUrl}, new URL:${newUrl}`);
                 }
             }
         }
+
+        
         registerHandleStaleModuleHook(handleStaleModule) {
             if (this.handleStaleModuleHook) {
                 this.handleStaleModuleHook.push(handleStaleModule);
-            }
-            else {
+            } else {
                 this.handleStaleModuleHook = [handleStaleModule];
             }
         }
@@ -1430,15 +1734,21 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
      * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
      */
     class Loader {
+        
+
+        
         constructor(config) {
             let baseUrl = config.baseUrl;
             const mappingEndpoint = config.endpoints ? config.endpoints.uris.mapping : undefined;
             let profiler = config.profiler;
+
             if (!mappingEndpoint) {
                 throw new LoaderError(NO_MAPPING_URL);
             }
+
             // add a trailing slash, if it does not exist
             config.endpoints.uris.mapping = mappingEndpoint.replace(/\/?$/, '/');
+
             if (baseUrl) {
                 // add a trailing slash, if it does not exist
                 baseUrl = baseUrl.replace(/\/?$/, '/');
@@ -1449,6 +1759,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             if (!baseUrl) {
                 throw new LoaderError(NO_BASE_URL);
             }
+
             if (!profiler) {
                 // default noop profiler
                 profiler = {
@@ -1460,7 +1771,9 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                     },
                 };
             }
+
             this.registry = new ModuleRegistry(Object.freeze({ endpoints: config.endpoints, baseUrl, profiler }));
+
             // TODO: W-10539691 - temp workaround for LWR-Java -- remove once appId is implemented there
             if (config.appMetadata && !config.appMetadata.appId) {
                 // Parse the appId from the bootstrapModule
@@ -1469,6 +1782,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 const appId = match && match[1];
                 config.appMetadata.appId = appId;
             }
+
             // TODO: https://github.com/salesforce-experience-platform-emu/lwr/issues/1087
             this.services = Object.freeze({
                 addLoaderPlugin: this.registry.addLoaderPlugin.bind(this.registry),
@@ -1476,6 +1790,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
                 appMetadata: config.appMetadata,
             });
         }
+
         /**
          * Defines/registers a single named AMD module definition.
          *
@@ -1488,14 +1803,18 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
             invariant(typeof name === 'string', MISSING_NAME);
             let ctor = execute;
             let deps = dependencies;
+
             // Convert no dependencies form `define('name', function(){}, {});` to: `define('name', [], function(){}, {})`
             if (typeof deps === 'function') {
                 ctor = dependencies;
                 deps = [];
             }
+
             invariant(Array.isArray(deps), INVALID_DEPS);
-            this.registry.define(name, deps, ctor);
+
+            this.registry.define(name, deps, ctor );
         }
+
         /**
          * Retrieves/loads a module, returning it from the registry if it exists and fetching it if it doesn't.
          *
@@ -1507,6 +1826,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         async load(id, importer) {
             return this.registry.load(id, importer);
         }
+
         /**
          * Checks if a Module exists in the registry.  Note, returns false even if the ModuleDefinition exists but the Module has not been instantiated yet (executed).
          *
@@ -1516,6 +1836,7 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         has(id) {
             return this.registry.has(id);
         }
+
         /**
          * Resolves the module identifier or URL.  Returns the module identifier if the moduleDefinition exists, or the full resolved URL if a URL is given.
          *
@@ -1527,9 +1848,11 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
         async resolve(id, importer) {
             return this.registry.resolve(id, importer);
         }
+
         async registerImportMappings(mappings, rootSpecifiers) {
             this.registry.getImportMetadataResolver().registerImportMappings(mappings, rootSpecifiers);
         }
+
         /**
          * Marks modules as "externally" loaded/provided (e.g. preloaded), so that the loader does not attempt to load them.
          *
@@ -1544,4 +1867,5 @@ LWR.define('lwr/loader/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-});
+}));
+//# sourceMappingURL=lwr-loader-shim.bundle.js.map