@lwrjs/loader 0.10.0-alpha.0 → 0.10.0-alpha.10

package/build/modules/lwr/loaderLegacy/loaderLegacy.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 v0.10.0-alpha.0 */
+/* LWR Legacy Module Loader v0.10.0-alpha.10 */
 const templateRegex = /\{([0-9]+)\}/g;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function templateString(template, args) {
@@ -18,17 +18,26 @@ function generateErrorMessage(errorInfo, args) {
     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.',
@@ -109,6 +118,7 @@ const FAIL_HOOK_LOAD = Object.freeze({
     level: 0,
     message: 'Error loading "{0}" from hook',
 });
+
 /* importMap errors */
 const BAD_IMPORT_MAP = Object.freeze({
     code: 3011,
@@ -118,7 +128,9 @@ const BAD_IMPORT_MAP = Object.freeze({
 
 /* 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 */
 
@@ -126,7 +138,7 @@ function getBaseUrl() {
     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
@@ -138,8 +150,10 @@ function getBaseUrl() {
             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
@@ -166,24 +180,26 @@ function getBaseUrl() {
 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] === '/') {
@@ -191,21 +207,23 @@ function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
             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++) {
@@ -216,6 +234,7 @@ function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
                     segmentIndex = -1;
                 }
             }
+
             // new segment - check if it is relative
             else if (segmented[i] === '.') {
                 // ../ segment
@@ -226,8 +245,7 @@ function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
                 // ./ segment
                 else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
                     i += 1;
-                }
-                else {
+                } else {
                     // the start of a new segment as below
                     segmentIndex = i;
                 }
@@ -238,13 +256,14 @@ function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
             }
         }
         // 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;
 }
@@ -257,6 +276,7 @@ function createScript(url) {
     script.src = url;
     return script;
 }
+
 let lastWindowError$1, lastWindowErrorUrl;
 function loadModuleDef(url) {
     return new Promise(function (resolve, reject) {
@@ -270,8 +290,7 @@ function loadModuleDef(url) {
                 document.head.removeChild(script);
                 if (lastWindowErrorUrl === url) {
                     reject(lastWindowError$1);
-                }
-                else {
+                } else {
                     resolve();
                 }
             });
@@ -280,6 +299,7 @@ function loadModuleDef(url) {
         }
     });
 }
+
 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
@@ -292,29 +312,45 @@ if (hasDocument) {
 const MODULE_LOAD_TIMEOUT_TIMER = 300000;
 
 /* 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) {
@@ -323,36 +359,41 @@ async function evaluateLoadHookResponse(response, id) {
         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) {
+        } 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;
     }
@@ -364,26 +405,28 @@ async function evaluateLoadHook(id, hookPromise) {
         }, 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++) {
@@ -393,8 +436,7 @@ function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
             if (hookResult !== null) {
                 break;
             }
-        }
-        catch (e) {
+        } catch (e) {
             reportError(new LoaderError(STALE_HOOK_ERROR));
         }
     }
@@ -409,32 +451,82 @@ const MODULE_FETCH = `${LOADER_PREFIX}module.fetch`;
 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;
@@ -447,6 +539,7 @@ class ModuleRegistry {
                     // 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') {
@@ -457,6 +550,7 @@ class ModuleRegistry {
                         aliasedId = result; // the next hook will receive the new id
                         continue;
                     }
+
                     resolved =
                         result && result.url && (resolveIfNotPlainOrUrl(result.url, parentUrl) || result.url);
                     if (!resolved) {
@@ -466,34 +560,38 @@ class ModuleRegistry {
                     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;
             }
         }
@@ -501,6 +599,7 @@ class ModuleRegistry {
             if (this.namedDefineRegistry.has(id)) {
                 return id;
             }
+
             throw new LoaderError(UNRESOLVED, [id]);
         }
         if (importer && isUrl(resolved)) {
@@ -508,10 +607,17 @@ class ModuleRegistry {
         }
         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) {
@@ -522,6 +628,7 @@ class ModuleRegistry {
             this.lastDefine = mod;
             return;
         }
+
         const moduleDef = {
             name,
             dependencies,
@@ -533,9 +640,11 @@ class ModuleRegistry {
             // 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]) => {
@@ -543,6 +652,7 @@ class ModuleRegistry {
             });
         }
     }
+
     /**
      * Marks modules as "externally" loaded/provided, so that the loader does not attempt to fetch them.
      *
@@ -555,6 +665,7 @@ class ModuleRegistry {
                 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(() => {
@@ -572,15 +683,15 @@ class ModuleRegistry {
                         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
@@ -591,9 +702,10 @@ class ModuleRegistry {
                 },
                 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;
@@ -603,25 +715,43 @@ class ModuleRegistry {
                     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);
@@ -634,13 +764,15 @@ class ModuleRegistry {
         }
         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) => {
@@ -648,15 +780,17 @@ class ModuleRegistry {
             // 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),
@@ -669,12 +803,12 @@ class ModuleRegistry {
         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) {
@@ -684,17 +818,23 @@ class ModuleRegistry {
             }
         }
     }
-    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;
@@ -707,46 +847,61 @@ class ModuleRegistry {
             }
         }
     }
-    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 };
@@ -762,7 +917,9 @@ class ModuleRegistry {
                 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) {
@@ -776,6 +933,7 @@ class ModuleRegistry {
                 },
             });
         }
+
         // copy non-enumerable to module
         if (moduleExports.__useDefault) {
             Object.defineProperty(moduleRecord.module, '__useDefault', { value: true });
@@ -786,27 +944,36 @@ class ModuleRegistry {
         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]) {
@@ -816,15 +983,17 @@ class ModuleRegistry {
             }
         }
     }
-    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;
@@ -837,76 +1006,84 @@ class ModuleRegistry {
         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];
         }
     }
@@ -938,6 +1115,19 @@ function targetWarning(match, target, msg) {
  *
  * 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);
@@ -948,9 +1138,9 @@ function applyPackages(id, packages, defaultUri) {
         }
         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) {
@@ -959,8 +1149,7 @@ function applyPackages(id, packages, defaultUri) {
             }
             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,
@@ -971,8 +1160,13 @@ function applyPackages(id, packages, defaultUri) {
         }
     }
 }
+
 // Resolves an entry in the import map
-function resolveImportMapEntry(importMap, resolvedOrPlain, parentUrl) {
+function resolveImportMapEntry(
+    importMap,
+    resolvedOrPlain,
+    parentUrl,
+) {
     if (!importMap.scopes) {
         importMap.scopes = {};
     }
@@ -988,12 +1182,21 @@ function resolveImportMapEntry(importMap, resolvedOrPlain, parentUrl) {
         }
         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];
@@ -1001,42 +1204,62 @@ function resolveAndComposePackages(packages, outPackages, baseUrl, parentMap, pa
         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);
     }
@@ -1047,26 +1270,33 @@ class ImportMapResolver {
  *
  * 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: {} };
@@ -1078,23 +1308,27 @@ async function evaluateImportMaps(baseUrl) {
         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;
@@ -1104,6 +1338,10 @@ async function evaluateImportMaps(baseUrl) {
  * 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;
@@ -1119,6 +1357,7 @@ class Loader {
             throw new LoaderError(NO_BASE_URL);
         }
         this.baseUrl = baseUrl;
+
         if (!profiler) {
             // default noop profiler
             profiler = {
@@ -1130,7 +1369,9 @@ class Loader {
                 },
             };
         }
+
         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),
@@ -1138,6 +1379,7 @@ class Loader {
             appMetadata: config.appMetadata,
         });
     }
+
     /**
      * Defines/registers a single named AMD module definition.
      *
@@ -1147,21 +1389,31 @@ class Loader {
      * @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.
      *
@@ -1173,6 +1425,7 @@ class Loader {
     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).
      *
@@ -1182,6 +1435,7 @@ class Loader {
     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.
      *
@@ -1193,13 +1447,14 @@ class Loader {
     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);
@@ -1210,6 +1465,7 @@ class Loader {
             this.registry.setImportResolver(importMapResolver);
         }
     }
+
     /**
      * Marks modules as "externally" loaded/provided (e.g. preloaded), so that the loader does not attempt to load them.
      *