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

package/build/modules/lwr/loader/loader.js

@@ -4,7 +4,7 @@
 * SPDX-License-Identifier: MIT
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
 */
-/* LWR Module Loader v0.10.0-alpha.2 */
+/* LWR Module Loader v0.10.0-alpha.20 */
 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.',
@@ -119,6 +128,7 @@ const BAD_IMPORT_METADATA = Object.freeze({
     level: 0,
     message: 'Invalid import metadata: {0} {1}',
 });
+
 /* importMap errors */
 Object.freeze({
     code: 3011,
@@ -128,7 +138,9 @@ 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 */
 
@@ -136,7 +148,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
@@ -148,8 +160,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
@@ -176,24 +190,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] === '/') {
@@ -201,21 +217,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++) {
@@ -226,6 +244,7 @@ function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
                     segmentIndex = -1;
                 }
             }
+
             // new segment - check if it is relative
             else if (segmented[i] === '.') {
                 // ../ segment
@@ -236,8 +255,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;
                 }
@@ -248,13 +266,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;
 }
@@ -267,6 +286,7 @@ function createScript(url) {
     script.src = url;
     return script;
 }
+
 let lastWindowError$1, lastWindowErrorUrl;
 function loadModuleDef(url) {
     return new Promise(function (resolve, reject) {
@@ -280,8 +300,7 @@ function loadModuleDef(url) {
                 document.head.removeChild(script);
                 if (lastWindowErrorUrl === url) {
                     reject(lastWindowError$1);
-                }
-                else {
+                } else {
                     resolve();
                 }
             });
@@ -290,6 +309,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
@@ -313,44 +333,53 @@ const MAPPINGS_ERROR = `${LOADER_PREFIX}mappings.error`;
 
 /* spec based import map resolver */
 class ImportMetadataResolver {
-    constructor(config, invalidationCallback) {
-        // Default to empty mappings
-        this.importURICache = new Map();
-        this.pendingURICache = new Map();
-        this.loadMappingHooks = [];
+    // Default to empty mappings
+     __init() {this.importURICache = new Map();}
+     __init2() {this.pendingURICache = new Map();}
+    
+    
+     __init3() {this.loadMappingHooks = [];}
+
+    constructor(config, invalidationCallback) {ImportMetadataResolver.prototype.__init.call(this);ImportMetadataResolver.prototype.__init2.call(this);ImportMetadataResolver.prototype.__init3.call(this);
         this.config = config;
         this.invalidationCallback = invalidationCallback;
     }
+
     addLoadMappingHook(hook) {
         this.loadMappingHooks.push(hook);
     }
+
     getMappingEndpoint() {
         return this.config.endpoints && this.config.endpoints.uris
             ? this.config.endpoints.uris.mapping
             : undefined;
     }
+
     getModifiersAsUrlParams() {
         const modifiers = this.config.endpoints ? this.config.endpoints.modifiers : undefined;
+
         if (!modifiers) {
             // No modifiers return an empty string to append to the URL
             return '';
-        }
-        else {
+        } else {
             const qs = Object.keys(modifiers)
                 .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(modifiers[key])}`)
                 .join('&');
             return `?${qs}`;
         }
     }
+
     buildMappingUrl(specifier) {
         const mappingEndpoint = this.getMappingEndpoint();
         const specifiers = encodeURIComponent(specifier);
         const modifiers = this.getModifiersAsUrlParams();
         return `${mappingEndpoint}${specifiers}${modifiers}`;
     }
+
     getBaseUrl() {
         return this.config.baseUrl;
     }
+
     registerImportMappings(newImportMetadata, rootSpecifiers) {
         if (!rootSpecifiers || rootSpecifiers.length === 0) {
             const imports = newImportMetadata ? JSON.stringify(newImportMetadata) : 'undefined';
@@ -372,8 +401,7 @@ class ImportMetadataResolver {
                 const existing = this.importURICache.get(specifier);
                 if (!existing) {
                     this.saveImportURIRecord(specifier, uri, indexValue, rootSpecifiers.includes(specifier));
-                }
-                else {
+                } else {
                     const identity = indexValue || uri;
                     const existingIdentity = existing.identity || existing.uri;
                     if (existingIdentity !== identity) {
@@ -387,22 +415,24 @@ class ImportMetadataResolver {
             });
         }
     }
+
     // Get URL from the local cache or return undefiend
-    getURI(specifier) {
+     getURI(specifier) {
         return this.importURICache.has(specifier)
             ? resolveUrl(this.importURICache.get(specifier).uri, this.getBaseUrl())
             : undefined;
     }
+
     resolveLocal(specifier) {
         const uri = this.getURI(specifier);
         if (uri) {
             return uri;
-        }
-        else if (isUrl(specifier) || specifier.startsWith('/')) {
+        } else if (isUrl(specifier) || specifier.startsWith('/')) {
             return specifier;
         }
         return undefined;
     }
+
     /**
      *  Resolves a the URI for a specified module.  It will return the value in this order:
      *
@@ -417,15 +447,14 @@ class ImportMetadataResolver {
         let uri = this.getURI(specifier);
         if (uri) {
             return uri;
-        }
-        else if (isUrl(specifier) || specifier.startsWith('/')) {
+        } else if (isUrl(specifier) || specifier.startsWith('/')) {
             return specifier;
-        }
-        else {
+        } else {
             const pending = this.pendingURICache.get(specifier);
             if (pending) {
                 return pending;
             }
+
             this.config.profiler.logOperationStart({ id: MAPPINGS_FETCH, specifier });
             const fetchMappingService = this.hasMappingHooks()
                 ? this.evaluateMappingHooks
@@ -433,33 +462,37 @@ class ImportMetadataResolver {
             const promise = fetchMappingService
                 .bind(this)(specifier)
                 .then((importMetadata) => {
-                if (!importMetadata || !importMetadata.imports) {
-                    throw new LoaderError(UNRESOLVED, [specifier]);
-                }
-                this.registerImportMappings(importMetadata, [specifier]);
-                uri = this.getURI(specifier);
-                if (!uri) {
-                    throw new LoaderError(UNRESOLVED, [specifier]);
-                }
-                this.config.profiler.logOperationEnd({ id: MAPPINGS_FETCH, specifier });
-                return uri;
-            })
+                    if (!importMetadata || !importMetadata.imports) {
+                        throw new LoaderError(UNRESOLVED, [specifier]);
+                    }
+                    this.registerImportMappings(importMetadata, [specifier]);
+                    uri = this.getURI(specifier);
+                    if (!uri) {
+                        throw new LoaderError(UNRESOLVED, [specifier]);
+                    }
+
+                    this.config.profiler.logOperationEnd({ id: MAPPINGS_FETCH, specifier });
+                    return uri;
+                })
                 .finally(() => {
-                this.pendingURICache.delete(specifier);
-            });
+                    this.pendingURICache.delete(specifier);
+                });
+
             this.pendingURICache.set(specifier, promise);
             return promise;
         }
     }
-    hasMappingHooks() {
+
+     hasMappingHooks() {
         return this.loadMappingHooks.length > 0;
     }
+
     /**
      *  Evaluates mapping hooks.  Returns first match. If all hooks return null call the mapping service.
      *  @param specifier Request module identifier
      *  @returns Import Metadata from the module root
      */
-    async evaluateMappingHooks(specifier) {
+     async evaluateMappingHooks(specifier) {
         // Check with any registered loadMappingHooks
         const loadMappingHooks = this.loadMappingHooks;
         if (loadMappingHooks.length) {
@@ -474,13 +507,16 @@ class ImportMetadataResolver {
                 }
             }
         }
+
         // If we still do not have a match call the mapping service
         return this.fetchNewMappings(specifier);
     }
-    async fetchNewMappings(specifier) {
+
+     async fetchNewMappings(specifier) {
         if (typeof globalThis.fetch !== 'function') {
             throw new LoaderError(UNRESOLVED, [specifier]);
         }
+
         // TODO For module invalidation with bundles it is recommended we have to send back all loaded root specified
         // to ensure we detect all conflicts.
         const uri = resolveUrl(this.buildMappingUrl(specifier), this.getBaseUrl());
@@ -492,21 +528,21 @@ class ImportMetadataResolver {
             return res
                 .json()
                 .then((ret) => {
-                return ret;
-            })
+                    return ret ;
+                })
                 .catch((err) => {
-                throw new LoaderError(UNRESOLVED, [specifier]);
-            });
+                    throw new LoaderError(UNRESOLVED, [specifier]);
+                });
         });
     }
-    saveImportURIRecord(specifier, uri, identity, isRoot) {
+
+     saveImportURIRecord(specifier, uri, identity, isRoot) {
         if (!identity || uri === identity) {
             this.importURICache.set(specifier, {
                 uri,
                 isRoot: isRoot,
             });
-        }
-        else {
+        } else {
             this.importURICache.set(specifier, {
                 uri,
                 identity,
@@ -519,11 +555,13 @@ class ImportMetadataResolver {
 function reportError(error) {
     // TODO eventually this should be configurable instrumentation to send this somewhere
     // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
-    if (hasConsole)
-        console.error(error);
+    if (hasConsole) console.error(error);
 }
 
-function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
+function evaluateHandleStaleModuleHooks(
+    handleStaleModuleHooks,
+    hookArgs,
+) {
     const { name, oldUrl, newUrl } = hookArgs;
     // keep evaluating hooks if return value is null
     for (let i = 0; i < handleStaleModuleHooks.length; i++) {
@@ -533,39 +571,82 @@ function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
             if (hookResult !== null) {
                 break;
             }
-        }
-        catch (e) {
+        } catch (e) {
             reportError(new LoaderError(STALE_HOOK_ERROR));
         }
     }
 }
 
-const MODULE_LOAD_TIMEOUT_TIMER = 300000;
+const MODULE_LOAD_TIMEOUT_TIMER = 60 * 1000; // 1m
+
+/*!
+ * Copyright (C) 2023 salesforce.com, inc.
+ */
+// @ts-ignore: Prevent cannot find name 'trustedTypes' error.
+const SUPPORTS_TRUSTED_TYPES = typeof trustedTypes !== 'undefined';
+function createTrustedTypesPolicy(name, options) {
+  // @ts-ignore: Prevent cannot find name 'trustedTypes' error.
+  return trustedTypes.createPolicy(name, options);
+}
+function createFallbackPolicy(_name, options) {
+  return options;
+}
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/trusted-types
+const createPolicy = SUPPORTS_TRUSTED_TYPES ? createTrustedTypesPolicy : createFallbackPolicy;
+const policyOptions = {
+  createHTML(value) {
+    return value;
+  },
+  createScript(value) {
+    return value;
+  },
+  createScriptURL(value) {
+    return value;
+  }
+};
+const trusted = createPolicy('trusted', policyOptions);
+/*! version: 0.19.4 */
 
 /* global console,process */
+
+
 let lastWindowError;
 if (hasDocument) {
     globalThis.addEventListener('error', (evt) => {
         lastWindowError = evt.error;
     });
 }
+
 if (process.env.NODE_ENV !== 'production') {
     if (!hasSetTimeout && hasConsole) {
         // eslint-disable-next-line lwr/no-unguarded-apis
         console.warn('setTimeout API is not available, watchdog timer on load hook will not be set');
     }
 }
+
 function isCustomResponse(response) {
-    return (Object.prototype.hasOwnProperty.call(response, 'data') &&
-        !Object.prototype.hasOwnProperty.call(response, 'blob'));
+    return (
+        Object.prototype.hasOwnProperty.call(response, 'data') &&
+        !Object.prototype.hasOwnProperty.call(response, 'blob')
+    );
 }
-function isFetchResponse(response) {
+function isFetchResponse(
+    response,
+) {
     // if it quacks like a duck...
-    return typeof response.blob === 'function';
+    return typeof (response ).blob === 'function';
 }
-function isResponseAPromise(response) {
-    return !!(response && response.then);
+
+function isResponseAPromise(
+    response
+
+
+
+,
+) {
+    return !!(response && (response ).then);
 }
+
 async function evaluateLoadHookResponse(response, id) {
     return Promise.resolve().then(async () => {
         if (!response.status) {
@@ -574,36 +655,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) {
+            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;
     }
@@ -615,45 +701,91 @@ 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);
+            });
     });
 }
 
 /* global console,process */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 class ModuleRegistry {
-    constructor(config) {
-        // A registry for named AMD defines containing the *metadata* of AMD module
-        this.namedDefineRegistry = new Map();
-        // The evaluated module registry where the module identifier (name or URL?) is the key
-        this.moduleRegistry = new Map();
-        // Aliases of modules in the registry
-        this.aliases = new Map();
+    
+
+    constructor(config) {ModuleRegistry.prototype.__init.call(this);ModuleRegistry.prototype.__init2.call(this);ModuleRegistry.prototype.__init3.call(this);
         this.profiler = config.profiler;
-        this.resolver = new ImportMetadataResolver(config, this.importMetadataInvalidationCallback.bind(this));
+        this.resolver = new ImportMetadataResolver(
+            config,
+            this.importMetadataInvalidationCallback.bind(this),
+        );
     }
+
     async load(id, importer) {
         const resolvedId = await this.resolve(id, importer);
         const moduleRecord = this.getModuleRecord(resolvedId, id);
         if (moduleRecord.evaluated) {
             return moduleRecord.module;
-        }
-        else {
+        } else {
             if (!moduleRecord.evaluationPromise) {
                 moduleRecord.evaluationPromise = this.topLevelEvaluation(moduleRecord);
             }
             return moduleRecord.evaluationPromise;
         }
     }
+
     async resolve(id, importer) {
         const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
+
         let resolved;
         let aliasedId = id;
         const resolveHooks = this.resolveHook;
@@ -666,6 +798,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') {
@@ -676,6 +809,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) {
@@ -685,27 +819,32 @@ 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;
             }
+
             const resolvedUrl = this.resolver.resolveLocal(resolvedOrPlain);
             if (resolvedUrl) {
                 // return the plain id if it is already defined && the resolvedUrl is NOT already in the module registry
-                if (this.namedDefineRegistry.has(resolvedOrPlain) &&
-                    this.namedDefineRegistry.get(resolvedOrPlain).defined) {
+                if (
+                    this.namedDefineRegistry.has(resolvedOrPlain) &&
+                    this.namedDefineRegistry.get(resolvedOrPlain).defined
+                ) {
                     const record = this.moduleRegistry.get(resolvedUrl);
                     if (!record || !this.aliases.has(resolvedOrPlain)) {
                         return resolvedOrPlain;
@@ -713,13 +852,13 @@ class ModuleRegistry {
                 }
                 return resolvedUrl;
             }
+
             if (this.namedDefineRegistry.has(resolvedOrPlain)) {
                 return resolvedOrPlain;
             }
             try {
                 resolved = await this.resolver.resolve(resolvedOrPlain);
-            }
-            catch (e) {
+            } catch (e) {
                 // defer to error handling below for unresolved
             }
         }
@@ -727,6 +866,7 @@ class ModuleRegistry {
             if (this.namedDefineRegistry.has(id)) {
                 return id;
             }
+
             throw new LoaderError(UNRESOLVED, [id]);
         }
         if (importer && isUrl(resolved)) {
@@ -734,9 +874,11 @@ class ModuleRegistry {
         }
         return resolved;
     }
+
     has(id) {
         return this.moduleRegistry.has(id);
     }
+
     define(name, dependencies, exporter) {
         const mod = this.namedDefineRegistry.get(name);
         // Don't allow redefining a module.
@@ -748,6 +890,7 @@ class ModuleRegistry {
             this.lastDefine = mod;
             return;
         }
+
         const moduleDef = {
             name,
             dependencies,
@@ -758,10 +901,12 @@ 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;
     }
+
     /**
      * Marks modules as "externally" loaded/provided, so that the loader does not attempt to fetch them.
      *
@@ -774,6 +919,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(() => {
@@ -791,24 +937,39 @@ 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);
             }
         });
     }
+
+    
+
+    // A registry for named AMD defines containing the *metadata* of AMD module
+     __init() {this.namedDefineRegistry = new Map();}
+
+    // The evaluated module registry where the module identifier (name or URL?) is the key
+     __init2() {this.moduleRegistry = new Map();}
+
+    // Aliases of modules in the registry
+    __init3() {this.aliases = new Map();}
+
+    
+
     getImportMetadataResolver() {
         return this.resolver;
     }
+
     // Returns an existing module record by the resolvedId or aliased id
-    getExistingModuleRecord(resolvedId, aliasId) {
+     getExistingModuleRecord(resolvedId, aliasId) {
         const moduleRecord = this.moduleRegistry.get(resolvedId);
         if (moduleRecord) {
             this.storeModuleAlias(aliasId, resolvedId);
             return moduleRecord;
         }
+
         // Check if this is a known alias
         if (resolvedId !== aliasId) {
             const alias = this.aliases.get(aliasId);
@@ -821,13 +982,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) => {
@@ -835,15 +998,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),
@@ -852,16 +1017,17 @@ class ModuleRegistry {
             evaluated: false,
             evaluationPromise: null,
         };
+
         this.moduleRegistry.set(resolvedId, newModuleRecord);
         this.storeModuleAlias(id, resolvedId);
         return newModuleRecord;
     }
-    storeModuleAlias(aliasId, resolvedId) {
+
+     storeModuleAlias(aliasId, resolvedId) {
         if (aliasId !== resolvedId) {
             if (!this.aliases.has(aliasId)) {
                 this.aliases.set(aliasId, resolvedId);
-            }
-            else if (process.env.NODE_ENV !== 'production' && hasConsole) {
+            } else if (process.env.NODE_ENV !== 'production' && hasConsole) {
                 // Warn the user if they were not aliasing to the resolvedId
                 const currentResolvedId = this.aliases.get(aliasId);
                 if (currentResolvedId !== resolvedId) {
@@ -871,17 +1037,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;
@@ -894,46 +1066,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 };
@@ -949,7 +1136,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) {
@@ -963,6 +1152,7 @@ class ModuleRegistry {
                 },
             });
         }
+
         // copy non-enumerable to module
         if (moduleExports.__useDefault) {
             Object.defineProperty(moduleRecord.module, '__useDefault', { value: true });
@@ -973,27 +1163,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]) {
@@ -1003,15 +1202,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;
@@ -1024,67 +1225,75 @@ 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, loadMapping } = hooks;
+
         if (resolveHook) {
             if (this.resolveHook) {
                 this.resolveHook.push(resolveHook);
-            }
-            else {
+            } else {
                 this.resolveHook = [resolveHook];
             }
         }
         if (loadHook) {
             if (this.loadHook) {
                 this.loadHook.push(loadHook);
-            }
-            else {
+            } else {
                 this.loadHook = [loadHook];
             }
         }
@@ -1092,7 +1301,8 @@ class ModuleRegistry {
             this.resolver.addLoadMappingHook(loadMapping);
         }
     }
-    importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
+
+     importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
         const handleStaleModuleHooks = this.handleStaleModuleHook;
         if (handleStaleModuleHooks) {
             evaluateHandleStaleModuleHooks(handleStaleModuleHooks, {
@@ -1100,19 +1310,19 @@ class ModuleRegistry {
                 oldUrl,
                 newUrl,
             });
-        }
-        else {
+        } else {
             if (process.env.NODE_ENV !== 'production' && hasConsole) {
                 // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
                 console.warn(`stale module detected ${name}, current URL:${oldUrl}, new URL:${newUrl}`);
             }
         }
     }
+
+    
     registerHandleStaleModuleHook(handleStaleModule) {
         if (this.handleStaleModuleHook) {
             this.handleStaleModuleHook.push(handleStaleModule);
-        }
-        else {
+        } else {
             this.handleStaleModuleHook = [handleStaleModule];
         }
     }
@@ -1122,15 +1332,21 @@ class ModuleRegistry {
  * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
  */
 class Loader {
+    
+
+    
     constructor(config) {
         let baseUrl = config.baseUrl;
         const mappingEndpoint = config.endpoints ? config.endpoints.uris.mapping : undefined;
         let profiler = config.profiler;
+
         if (!mappingEndpoint) {
             throw new LoaderError(NO_MAPPING_URL);
         }
+
         // add a trailing slash, if it does not exist
         config.endpoints.uris.mapping = mappingEndpoint.replace(/\/?$/, '/');
+
         if (baseUrl) {
             // add a trailing slash, if it does not exist
             baseUrl = baseUrl.replace(/\/?$/, '/');
@@ -1141,6 +1357,7 @@ class Loader {
         if (!baseUrl) {
             throw new LoaderError(NO_BASE_URL);
         }
+
         if (!profiler) {
             // default noop profiler
             profiler = {
@@ -1152,7 +1369,9 @@ class Loader {
                 },
             };
         }
+
         this.registry = new ModuleRegistry(Object.freeze({ endpoints: config.endpoints, baseUrl, profiler }));
+
         // TODO: W-10539691 - temp workaround for LWR-Java -- remove once appId is implemented there
         if (config.appMetadata && !config.appMetadata.appId) {
             // Parse the appId from the bootstrapModule
@@ -1161,6 +1380,7 @@ class Loader {
             const appId = match && match[1];
             config.appMetadata.appId = appId;
         }
+
         // TODO: https://github.com/salesforce-experience-platform-emu/lwr/issues/1087
         this.services = Object.freeze({
             addLoaderPlugin: this.registry.addLoaderPlugin.bind(this.registry),
@@ -1168,6 +1388,7 @@ class Loader {
             appMetadata: config.appMetadata,
         });
     }
+
     /**
      * Defines/registers a single named AMD module definition.
      *
@@ -1180,14 +1401,18 @@ class Loader {
         invariant(typeof name === 'string', MISSING_NAME);
         let ctor = execute;
         let deps = dependencies;
+
         // Convert no dependencies form `define('name', function(){}, {});` to: `define('name', [], function(){}, {})`
         if (typeof deps === 'function') {
             ctor = dependencies;
             deps = [];
         }
+
         invariant(Array.isArray(deps), INVALID_DEPS);
-        this.registry.define(name, deps, ctor);
+
+        this.registry.define(name, deps, ctor );
     }
+
     /**
      * Retrieves/loads a module, returning it from the registry if it exists and fetching it if it doesn't.
      *
@@ -1199,6 +1424,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).
      *
@@ -1208,6 +1434,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.
      *
@@ -1219,9 +1446,11 @@ class Loader {
     async resolve(id, importer) {
         return this.registry.resolve(id, importer);
     }
+
     async registerImportMappings(mappings, rootSpecifiers) {
         this.registry.getImportMetadataResolver().registerImportMappings(mappings, rootSpecifiers);
     }
+
     /**
      * Marks modules as "externally" loaded/provided (e.g. preloaded), so that the loader does not attempt to load them.
      *
@@ -1233,3 +1462,4 @@ class Loader {
 }
 
 export { Loader };
+//# sourceMappingURL=loader.js.map