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

package/build/assets/prod/lwr-loader-shim-legacy.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 Legacy Module Loader Shim v0.10.0-alpha.2 */
+/* LWR Legacy 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,19 +102,27 @@
     }
   }
 
-  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);
+
       // register externally loaded modules
       if (externalModules && externalModules.length) {
           loader.registerExternalModules(externalModules);
       }
+
       // Define the loader module with public API: { define, load, services }
       const exporter = (exports) => {
           Object.assign(exports, {
@@ -94,10 +133,11 @@
           return;
       };
       loader.define(name, ['exports'], exporter, definition[3]);
+
       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) {
@@ -110,11 +150,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 = {
@@ -128,48 +175,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.loaderModule = 'lwr/loaderLegacy/v/0_10_0-alpha_2';
+          this.config = global.LWR ;
+          this.loaderModule = 'lwr/loaderLegacy/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
@@ -179,7 +252,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;
@@ -193,19 +266,22 @@
               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 = {
                   baseUrl: this.config.baseUrl,
                   profiler: { logOperationStart, logOperationEnd },
+
                   // TODO: can be removed following https://github.com/salesforce-experience-platform-emu/lwr/issues/1087
                   appMetadata: {
                       appId: this.config.appId,
@@ -214,18 +290,24 @@
                       rootComponents: this.config.rootComponents,
                   },
               };
-              const loader = createLoader(this.loaderModule, this.defineCache[this.loaderModule], loaderConfig, this.config.preloadModules);
+              const loader = createLoader(
+                  this.loaderModule,
+                  this.defineCache[this.loaderModule],
+                  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') {
@@ -238,17 +320,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, importMappings, rootComponents, ssrProps, endpoints } = this.config;
+       mountApp(loader) {
+          const { bootstrapModule, rootComponent, importMappings, rootComponents, ssrProps, endpoints } =
+              this.config;
+
           // Set global LWR.define to loader.define
           this.global.LWR = Object.freeze({
               define: loader.define.bind(loader),
@@ -258,42 +344,50 @@
               importMappings,
               endpoints,
           });
+
           // Redefine all modules in the temporary cache
           this.orderedDefs.forEach((specifier) => {
               if (specifier !== this.loaderModule) {
                   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(importMappings)
               .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 +396,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/loaderLegacy/v/0_10_0-alpha_2') < 0) {
-      GLOBAL.LWR.requiredModules.push('lwr/loaderLegacy/v/0_10_0-alpha_2');
+  if (GLOBAL.LWR.requiredModules.indexOf('lwr/loaderLegacy/v/0_10_0-alpha_20') < 0) {
+      GLOBAL.LWR.requiredModules.push('lwr/loaderLegacy/v/0_10_0-alpha_20');
   }
   new LoaderShim(GLOBAL);
 
-}());
+})();
+//# sourceMappingURL=lwr-loader-shim-legacy.js.map
 
-LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports) { 'use strict';
+LWR.define('lwr/loaderLegacy/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 +421,26 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         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.',
@@ -417,6 +521,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         level: 0,
         message: 'Error loading "{0}" from hook',
     });
+
     /* importMap errors */
     const BAD_IMPORT_MAP = Object.freeze({
         code: 3011,
@@ -426,7 +531,9 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
 
     /* 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 */
 
@@ -434,7 +541,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         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
@@ -446,8 +553,10 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 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
@@ -474,24 +583,26 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
     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] === '/') {
@@ -499,21 +610,23 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 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++) {
@@ -524,6 +637,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                         segmentIndex = -1;
                     }
                 }
+
                 // new segment - check if it is relative
                 else if (segmented[i] === '.') {
                     // ../ segment
@@ -534,8 +648,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     // ./ segment
                     else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
                         i += 1;
-                    }
-                    else {
+                    } else {
                         // the start of a new segment as below
                         segmentIndex = i;
                     }
@@ -546,13 +659,14 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 }
             }
             // 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;
     }
@@ -565,6 +679,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         script.src = url;
         return script;
     }
+
     let lastWindowError$1, lastWindowErrorUrl;
     function loadModuleDef(url) {
         return new Promise(function (resolve, reject) {
@@ -578,8 +693,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     document.head.removeChild(script);
                     if (lastWindowErrorUrl === url) {
                         reject(lastWindowError$1);
-                    }
-                    else {
+                    } else {
                         resolve();
                     }
                 });
@@ -588,6 +702,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }
         });
     }
+
     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
@@ -597,32 +712,76 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         });
     }
 
-    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) {
@@ -631,36 +790,41 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             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;
         }
@@ -672,26 +836,28 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }, 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);
+                });
         });
     }
 
     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, oldHash, newHash } = hookArgs;
         // keep evaluating hooks if return value is null
         for (let i = 0; i < handleStaleModuleHooks.length; i++) {
@@ -701,8 +867,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 if (hookResult !== null) {
                     break;
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 reportError(new LoaderError(STALE_HOOK_ERROR));
             }
         }
@@ -717,32 +882,82 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
     const MODULE_ERROR = `${LOADER_PREFIX}module.error`;
 
     /* 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.baseUrl = config.baseUrl || '';
             this.profiler = config.profiler;
         }
+
         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.baseUrl; // only support baseUrl for now
+
             let resolved;
             let aliasedId = id;
             const resolveHooks = this.resolveHook;
@@ -755,6 +970,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                         // 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') {
@@ -765,6 +981,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                             aliasedId = result; // the next hook will receive the new id
                             continue;
                         }
+
                         resolved =
                             result && result.url && (resolveIfNotPlainOrUrl(result.url, parentUrl) || result.url);
                         if (!resolved) {
@@ -774,34 +991,38 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                         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;
                 }
+
                 if (this.resolver) {
                     resolved = this.resolver.resolve(resolvedOrPlain, parentUrl);
                     // 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(resolved);
                         if (!record || !this.aliases.has(resolvedOrPlain)) {
                             return resolvedOrPlain;
                         }
                     }
-                }
-                else {
+                } else {
                     resolved = resolvedOrPlain;
                 }
             }
@@ -809,6 +1030,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 if (this.namedDefineRegistry.has(id)) {
                     return id;
                 }
+
                 throw new LoaderError(UNRESOLVED, [id]);
             }
             if (importer && isUrl(resolved)) {
@@ -816,10 +1038,17 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }
             return resolved;
         }
+
         has(id) {
             return this.moduleRegistry.has(id);
         }
-        define(name, dependencies, exporter, signatures) {
+
+        define(
+            name,
+            dependencies,
+            exporter,
+            signatures,
+        ) {
             const mod = this.namedDefineRegistry.get(name);
             // Don't allow redefining a module.
             if (mod && mod.defined) {
@@ -830,6 +1059,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 this.lastDefine = mod;
                 return;
             }
+
             const moduleDef = {
                 name,
                 dependencies,
@@ -841,9 +1071,11 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 // 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;
+
             // Check signatures of dependencies against those in the namedDefineRegistry
             if (signatures.hashes) {
                 Object.entries(signatures.hashes).forEach(([dep, sig]) => {
@@ -851,6 +1083,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 });
             }
         }
+
         /**
          * Marks modules as "externally" loaded/provided, so that the loader does not attempt to fetch them.
          *
@@ -863,6 +1096,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     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(() => {
@@ -880,15 +1114,15 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                             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);
                 }
             });
         }
-        checkModuleSignature(name, signature) {
+
+         checkModuleSignature(name, signature) {
             const moduleDef = this.namedDefineRegistry.get(name);
             if (!moduleDef) {
                 // Placeholder module definition entry for saving known signature
@@ -899,9 +1133,10 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     },
                     defined: false,
                 };
-                this.namedDefineRegistry.set(name, modDef);
+                this.namedDefineRegistry.set(name, modDef );
                 return;
             }
+
             const currentSig = moduleDef.signatures ? moduleDef.signatures.ownHash : undefined;
             if (currentSig && signature !== currentSig) {
                 const handleStaleModuleHooks = this.handleStaleModuleHook;
@@ -911,25 +1146,43 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                         oldHash: currentSig,
                         newHash: signature,
                     });
-                }
-                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 sig:${currentSig}, new sig:${signature}`);
+                        console.warn(
+                            `stale module detected ${name}, current sig:${currentSig}, new sig:${signature}`,
+                        );
                     }
                 }
             }
         }
+
+        
         setImportResolver(resolver) {
             this.resolver = resolver;
         }
+
+        
+
+        // 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();}
+
+        
+
         // 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);
@@ -942,13 +1195,15 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }
             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) => {
@@ -956,15 +1211,17 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 // 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),
@@ -977,12 +1234,12 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             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 (hasConsole) {
+                } else if (hasConsole) {
                     // Warn the user if they were not aliasing to the resolvedId
                     const currentResolvedId = this.aliases.get(aliasId);
                     if (currentResolvedId !== resolvedId) {
@@ -992,17 +1249,23 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 }
             }
         }
-        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;
@@ -1015,46 +1278,61 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 }
             }
         }
-        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 };
@@ -1070,7 +1348,9 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     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) {
@@ -1084,6 +1364,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     },
                 });
             }
+
             // copy non-enumerable to module
             if (moduleExports.__useDefault) {
                 Object.defineProperty(moduleRecord.module, '__useDefault', { value: true });
@@ -1094,27 +1375,36 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             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]) {
@@ -1124,15 +1414,17 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 }
             }
         }
-        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;
@@ -1145,76 +1437,84 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             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 } = 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];
                 }
             }
         }
+
+        
         registerHandleStaleModuleHook(handleStaleModule) {
             if (this.handleStaleModuleHook) {
                 this.handleStaleModuleHook.push(handleStaleModule);
-            }
-            else {
+            } else {
                 this.handleStaleModuleHook = [handleStaleModule];
             }
         }
@@ -1246,6 +1546,19 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
      *
      * This implementation is adapted from https://github.com/systemjs/systemjs/blob/master/src/features/import-map.js
      */
+
+    // Spec based import map object https://github.com/WICG/import-maps
+
+
+
+
+
+
+
+
+
+
+
     // Resolves an import map package entry
     function applyPackages(id, packages, defaultUri) {
         const pkgName = getMatch(id, packages);
@@ -1256,9 +1569,9 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }
             if (id.length > pkgName.length && pkg[pkg.length - 1] !== '/') {
                 targetWarning(pkgName, pkg, "should have a trailing '/'");
-            }
-            else {
-                const isPackage = id.length > pkgName.length &&
+            } else {
+                const isPackage =
+                    id.length > pkgName.length &&
                     pkg[pkg.length - 1] === '/' &&
                     pkg.lastIndexOf(pkgName) === pkg.length - pkgName.length;
                 if (isPackage) {
@@ -1267,8 +1580,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 }
                 return pkg + id.slice(pkgName.length);
             }
-        }
-        else if (defaultUri) {
+        } else if (defaultUri) {
             // When a specifier's URI cannot be resolved via the imports, fallback to "default".
             //     -> https://rfcs.lwc.dev/rfcs/lwr/0000-import-metadata#json-schema
             // However, if `id` is already a fully resolved url,
@@ -1279,8 +1591,13 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }
         }
     }
+
     // Resolves an entry in the import map
-    function resolveImportMapEntry(importMap, resolvedOrPlain, parentUrl) {
+    function resolveImportMapEntry(
+        importMap,
+        resolvedOrPlain,
+        parentUrl,
+    ) {
         if (!importMap.scopes) {
             importMap.scopes = {};
         }
@@ -1296,12 +1613,21 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             }
             scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), scopes);
         }
-        return (applyPackages(resolvedOrPlain, importMap.imports, importMap.default) ||
+        return (
+            applyPackages(resolvedOrPlain, importMap.imports, importMap.default) ||
             (isUrl(resolvedOrPlain) && resolvedOrPlain) ||
-            undefined);
+            undefined
+        );
     }
+
     // In place transformation of the ImportMap object
-    function resolveAndComposePackages(packages, outPackages, baseUrl, parentMap, parentUrl) {
+    function resolveAndComposePackages(
+        packages,
+        outPackages,
+        baseUrl,
+        parentMap,
+        parentUrl,
+    ) {
         for (const p in packages) {
             const resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
             const rhs = packages[p];
@@ -1309,42 +1635,62 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             if (typeof rhs !== 'string') {
                 continue;
             }
-            const mapped = resolveImportMapEntry(parentMap, resolveIfNotPlainOrUrl(rhs, baseUrl) || rhs, parentUrl);
+            const mapped = resolveImportMapEntry(
+                parentMap,
+                resolveIfNotPlainOrUrl(rhs, baseUrl) || rhs,
+                parentUrl,
+            );
             if (!mapped) {
                 targetWarning(p, rhs, 'bare specifier did not resolve');
-            }
-            else {
+            } else {
                 outPackages[resolvedLhs] = mapped;
             }
         }
     }
+
     // Composes a single import map object given a child and parent import map
-    function resolveAndComposeImportMap(json, baseUrl, parentMap = { imports: {}, scopes: {} }) {
+    function resolveAndComposeImportMap(
+        json,
+        baseUrl,
+        parentMap = { imports: {}, scopes: {} },
+    ) {
         const outMap = {
             imports: Object.assign({}, parentMap.imports),
             scopes: Object.assign({}, parentMap.scopes),
             default: json.default,
         };
+
         if (json.imports) {
             resolveAndComposePackages(json.imports, outMap.imports, baseUrl, parentMap);
         }
+
         if (json.scopes) {
             for (const s in json.scopes) {
                 const resolvedScope = resolveUrl(s, baseUrl);
-                resolveAndComposePackages(json.scopes[s], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, parentMap, resolvedScope);
+                resolveAndComposePackages(
+                    json.scopes[s],
+                    outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}),
+                    baseUrl,
+                    parentMap,
+                    resolvedScope,
+                );
             }
         }
+
         if (json.default) {
             outMap.default = resolveIfNotPlainOrUrl(json.default, baseUrl);
         }
+
         return outMap;
     }
 
     /* spec based import map resolver */
-    class ImportMapResolver {
+    class ImportMapResolver  {
+        
         constructor(importMap) {
             this.importMap = importMap;
         }
+
         resolve(resolvedOrPlain, parentUrl) {
             return resolveImportMapEntry(this.importMap, resolvedOrPlain, parentUrl);
         }
@@ -1355,26 +1701,33 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
      *
      * This implementation is adapted from https://github.com/systemjs/systemjs/blob/master/src/features/import-map.js
      */
+
     const IMPORTMAP_SCRIPT_TYPE = 'lwr-importmap';
+
     // iterates on the any <script type="${IMPORTMAP_SCRIPT_TYPE}", invoking the given callback for each
-    function iterateDocumentImportMaps(callBack, extraSelector) {
+    function iterateDocumentImportMaps(
+        callBack,
+        extraSelector,
+    ) {
         // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
         const nodeList = document.querySelectorAll(`script[type="${IMPORTMAP_SCRIPT_TYPE}"]` + extraSelector);
         const filtered = Array.from(nodeList).filter((node) => {
-            if (node.src) {
+            if ((node ).src) {
                 // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
-                if (hasConsole)
-                    console.warn('LWR does not support import maps from script src');
+                if (hasConsole) console.warn('LWR does not support import maps from script src');
                 return false;
             }
             return true;
         });
+
         Array.prototype.forEach.call(filtered, callBack);
     }
+
     // retrives the import map text from a <script type="${IMPORTMAP_SCRIPT_TYPE}"
     async function getImportMapFromScript(script) {
         return Promise.resolve(script.innerHTML);
     }
+
     // get importMap from <script type="lwr-importmap">
     async function evaluateImportMaps(baseUrl) {
         let importMap = { imports: {}, scopes: {} };
@@ -1386,23 +1739,27 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
             if (!baseUrl) {
                 throw new LoaderError(NO_BASE_URL);
             }
+
             iterateDocumentImportMaps((script) => {
                 importMapPromise = importMapPromise
                     .then(() => {
-                    return getImportMapFromScript(script);
-                })
+                        return getImportMapFromScript(script);
+                    })
                     .then((importMapTxt) => {
-                    try {
-                        return JSON.parse(importMapTxt);
-                    }
-                    catch (e) {
-                        throw new LoaderError(BAD_IMPORT_MAP);
-                    }
-                })
+                        try {
+                            return JSON.parse(importMapTxt);
+                        } catch (e) {
+                            throw new LoaderError(BAD_IMPORT_MAP);
+                        }
+                    })
                     .then((jsonImportMap) => {
-                    importMap = resolveAndComposeImportMap(jsonImportMap, script.src || baseUrl, importMap);
-                    return importMap;
-                });
+                        importMap = resolveAndComposeImportMap(
+                            jsonImportMap,
+                            script.src || (baseUrl ),
+                            importMap,
+                        );
+                        return importMap;
+                    });
             }, '');
         }
         return importMapPromise;
@@ -1412,6 +1769,10 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
      * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
      */
     class Loader {
+        
+        
+
+        
         constructor(config) {
             config = config || {};
             let baseUrl = config.baseUrl;
@@ -1427,6 +1788,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 throw new LoaderError(NO_BASE_URL);
             }
             this.baseUrl = baseUrl;
+
             if (!profiler) {
                 // default noop profiler
                 profiler = {
@@ -1438,7 +1800,9 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                     },
                 };
             }
+
             this.registry = new ModuleRegistry({ baseUrl, profiler });
+
             // TODO: https://github.com/salesforce-experience-platform-emu/lwr/issues/1087
             this.services = Object.freeze({
                 addLoaderPlugin: this.registry.addLoaderPlugin.bind(this.registry),
@@ -1446,6 +1810,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 appMetadata: config.appMetadata,
             });
         }
+
         /**
          * Defines/registers a single named AMD module definition.
          *
@@ -1455,21 +1820,31 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
          * @param {ModuleDefinitionSignatures} signatures Object containing the module signature and the signatures of its dependencies
          * @return {void}
          */
-        define(name, dependencies, execute, signatures) {
+        define(
+            name,
+            dependencies,
+            execute,
+            signatures,
+        ) {
             invariant(typeof name === 'string', MISSING_NAME);
             let ctor = execute;
             let deps = dependencies;
             let sigs = signatures;
+
             // Convert no dependencies form `define('name', function(){}, {});` to: `define('name', [], function(){}, {})`
             if (typeof deps === 'function') {
                 ctor = dependencies;
                 deps = [];
                 sigs = execute;
             }
+
             sigs = sigs || {};
+
             invariant(Array.isArray(deps), INVALID_DEPS);
-            this.registry.define(name, deps, ctor, sigs);
+
+            this.registry.define(name, deps, ctor , sigs );
         }
+
         /**
          * Retrieves/loads a module, returning it from the registry if it exists and fetching it if it doesn't.
          *
@@ -1481,6 +1856,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         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).
          *
@@ -1490,6 +1866,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         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.
          *
@@ -1501,13 +1878,14 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
         async resolve(id, importer) {
             return this.registry.resolve(id, importer);
         }
+
+        
         async registerImportMappings(mappings) {
             let importMap;
             if (!mappings) {
                 // If no mappings given, check for lwr-importmap on the document
                 importMap = await evaluateImportMaps(this.baseUrl);
-            }
-            else {
+            } else {
                 // merge the new mappings with the base import map - note this goes against
                 // import maps spec if we do this after resolving any imports
                 importMap = resolveAndComposeImportMap(mappings, this.baseUrl, this.parentImportMap);
@@ -1518,6 +1896,7 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
                 this.registry.setImportResolver(importMapResolver);
             }
         }
+
         /**
          * Marks modules as "externally" loaded/provided (e.g. preloaded), so that the loader does not attempt to load them.
          *
@@ -1532,4 +1911,5 @@ LWR.define('lwr/loaderLegacy/v/0_10_0-alpha_2', ['exports'], function (exports)
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-});
+}));
+//# sourceMappingURL=lwr-loader-shim-legacy.bundle.js.map