@lwrjs/everywhere 0.10.0-alpha.4 → 0.10.0-alpha.7

package/build/assets/amd/lwr-everywhere-debug.js

@@ -9,6 +9,7 @@
 function getConfiguration(options) {
     const { format, server, apiVersion, apiPrefix, locale, bundle, debug } = options;
     const thisUrl = new URL(import.meta.url);
+
     // URLs
     const ORIGIN = server || thisUrl.origin || '';
     const PREFIX = `${apiPrefix}/${apiVersion}`;
@@ -17,9 +18,11 @@ function getConfiguration(options) {
     const ENDPOINT = bundle
         ? `${ORIGIN}${PREFIX}/bundle/${format}/${POSTFIX}${BUNDLE_ID}-0/module/mi/`
         : `${ORIGIN}${PREFIX}/module/${format}/${POSTFIX}/mi/`;
+
     // Component specifiers and URIs
-    const BOOT_MODULE = `lwr/everywhere${format === 'esm' ? 'Esm' : 'Amd'}/v/0_10_0-alpha_4`;
+    const BOOT_MODULE = `lwr/everywhere${format === 'esm' ? 'Esm' : 'Amd'}/v/0_10_0-alpha_7`;
     const BOOT_URI = `${ENDPOINT}${encodeURIComponent(BOOT_MODULE)}/latest${debug ? '?debug' : ''}`;
+
     // Client Bootstrap Config
     const config = {
         appId: 'lwre',
@@ -39,6 +42,7 @@ function getConfiguration(options) {
     if (debug && config.endpoints) {
         config.endpoints.modifiers = { debug: 'true' };
     }
+
     return config;
 }
 
@@ -48,7 +52,7 @@ function getConfiguration(options) {
 * 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.4 */
+/* LWR Module Loader v0.10.0-alpha.7 */
 const templateRegex = /\{([0-9]+)\}/g;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function templateString(template, args) {
@@ -62,17 +66,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.',
@@ -163,6 +176,7 @@ const BAD_IMPORT_METADATA = Object.freeze({
     level: 0,
     message: 'Invalid import metadata: {0} {1}',
 });
+
 /* importMap errors */
 Object.freeze({
     code: 3011,
@@ -172,7 +186,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 */
 
@@ -180,7 +196,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
@@ -192,8 +208,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
@@ -220,24 +238,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] === '/') {
@@ -245,21 +265,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++) {
@@ -270,6 +292,7 @@ function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
                     segmentIndex = -1;
                 }
             }
+
             // new segment - check if it is relative
             else if (segmented[i] === '.') {
                 // ../ segment
@@ -280,8 +303,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;
                 }
@@ -292,13 +314,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;
 }
@@ -311,6 +334,7 @@ function createScript(url) {
     script.src = url;
     return script;
 }
+
 let lastWindowError$1, lastWindowErrorUrl;
 function loadModuleDef(url) {
     return new Promise(function (resolve, reject) {
@@ -324,8 +348,7 @@ function loadModuleDef(url) {
                 document.head.removeChild(script);
                 if (lastWindowErrorUrl === url) {
                     reject(lastWindowError$1);
-                }
-                else {
+                } else {
                     resolve();
                 }
             });
@@ -334,6 +357,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
@@ -357,44 +381,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';
@@ -416,8 +449,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) {
@@ -431,22 +463,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:
      *
@@ -461,15 +495,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
@@ -477,33 +510,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) {
@@ -518,13 +555,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());
@@ -536,21 +576,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,
@@ -563,11 +603,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++) {
@@ -577,8 +619,7 @@ function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
             if (hookResult !== null) {
                 break;
             }
-        }
-        catch (e) {
+        } catch (e) {
             reportError(new LoaderError(STALE_HOOK_ERROR));
         }
     }
@@ -587,29 +628,45 @@ function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
 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) {
@@ -618,36 +675,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;
     }
@@ -659,45 +721,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;
@@ -710,6 +818,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') {
@@ -720,6 +829,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) {
@@ -729,27 +839,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;
@@ -757,13 +872,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
             }
         }
@@ -771,6 +886,7 @@ class ModuleRegistry {
             if (this.namedDefineRegistry.has(id)) {
                 return id;
             }
+
             throw new LoaderError(UNRESOLVED, [id]);
         }
         if (importer && isUrl(resolved)) {
@@ -778,9 +894,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.
@@ -792,6 +910,7 @@ class ModuleRegistry {
             this.lastDefine = mod;
             return;
         }
+
         const moduleDef = {
             name,
             dependencies,
@@ -802,10 +921,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.
      *
@@ -818,6 +939,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(() => {
@@ -835,24 +957,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);
@@ -865,13 +1002,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) => {
@@ -879,15 +1018,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),
@@ -896,16 +1037,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) {
@@ -915,17 +1057,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;
@@ -938,46 +1086,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 };
@@ -993,7 +1156,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) {
@@ -1007,6 +1172,7 @@ class ModuleRegistry {
                 },
             });
         }
+
         // copy non-enumerable to module
         if (moduleExports.__useDefault) {
             Object.defineProperty(moduleRecord.module, '__useDefault', { value: true });
@@ -1017,27 +1183,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]) {
@@ -1047,15 +1222,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;
@@ -1068,67 +1245,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];
             }
         }
@@ -1136,7 +1321,8 @@ class ModuleRegistry {
             this.resolver.addLoadMappingHook(loadMapping);
         }
     }
-    importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
+
+     importMetadataInvalidationCallback({ name, oldUrl, newUrl }) {
         const handleStaleModuleHooks = this.handleStaleModuleHook;
         if (handleStaleModuleHooks) {
             evaluateHandleStaleModuleHooks(handleStaleModuleHooks, {
@@ -1144,19 +1330,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];
         }
     }
@@ -1166,15 +1352,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(/\/?$/, '/');
@@ -1185,6 +1377,7 @@ class Loader {
         if (!baseUrl) {
             throw new LoaderError(NO_BASE_URL);
         }
+
         if (!profiler) {
             // default noop profiler
             profiler = {
@@ -1196,7 +1389,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
@@ -1205,6 +1400,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),
@@ -1212,6 +1408,7 @@ class Loader {
             appMetadata: config.appMetadata,
         });
     }
+
     /**
      * Defines/registers a single named AMD module definition.
      *
@@ -1224,14 +1421,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.
      *
@@ -1243,6 +1444,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).
      *
@@ -1252,6 +1454,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.
      *
@@ -1263,9 +1466,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.
      *
@@ -1276,103 +1481,128 @@ class Loader {
     }
 }
 
+function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
 /** LWR Everywhere module for AMD **/
+
 // Process the LWR Client Bootstrap Config
-const configOptions = { "format": "amd", "apiVersion": "1", "apiPrefix": "", "bundle": false, "debug": true };
+const configOptions = {"format":"amd","apiVersion":"1","apiPrefix":"","bundle":false,"debug":true} ;
 const configuration = getConfiguration(configOptions);
 const { bootstrapModule, endpoints, baseUrl, imports, index } = configuration;
+
 // Initialize the AMD loader (its code is bundled into the LWR Everywhere module)
 const loader = new Loader({ endpoints, baseUrl });
-loader.define('lwr/loader/v/0_10_0-alpha_4', ['exports'], (exports) => {
+loader.define('lwr/loader/v/0_10_0-alpha_7', ['exports'], (exports) => {
     Object.assign(exports, {
         define: loader.define.bind(loader),
         load: loader.load.bind(loader),
     });
 });
 await loader.registerImportMappings({ imports, index }, [bootstrapModule]);
-globalThis.LWR = Object.freeze({ define: loader.define.bind(loader) });
+(globalThis ).LWR = Object.freeze({ define: loader.define.bind(loader) });
+
 // Define preload modules (ie: ABS, vault, etc) BEFORE loading them
-LWR.define('lwr/everywhereAmd/v/0_10_0-alpha_4', ['exports', 'lwr/vault/v/0_10_0-alpha_4'], function (exports, _0_10_0Alpha_4) {
-    // IMPORTANT: Do not add any static imports to this file that are not bundled with the amd-client
-    // Do an OAuthed fetch
-    async function authFetch(url, accept = 'javascript') {
-        const authInfo = _0_10_0Alpha_4.getAuthInfo();
-        if (authInfo) {
-            return fetch(url, {
-                headers: {
-                    Accept: `application/${accept}`,
-                    Authorization: `Bearer ${authInfo.access_token}`
-                }
-            });
-        }
-        return null; // defer to loader
-    }
-    // Add a hook for adding OAuth headers to module and mapping requests
-    // Workaround: core does not have proper versioning; replace all versions with 0_0_1
-    function everywhereHooks(serviceAPI, mappingEndpoint, coreVersion) {
-        serviceAPI.addLoaderPlugin({
-            loadModule: async (url) => {
-                return authFetch(url);
-            },
-            loadMapping: async (specifier) => {
-                const res = await authFetch(`${mappingEndpoint}${encodeURIComponent(specifier)}`, 'json');
-                if (res && res.ok) {
-                    return res.json();
-                }
-                return null;
-            },
-            resolveModule: specifier => {
-                // Workaround W-8010259 (dynamic imports without versions)
-                // by adding a default version to version-less specifiers
-                if (specifier && !/\/v\/[^/]+?$/.test(specifier)) {
-                    return `${specifier}/v/${coreVersion}`;
-                }
-                return null; // defer to loader
-            }
-        });
-    }
-    function initAmd(services, mappingEndpoint, coreVersion) {
-        // Initialize the loader hooks for LWR-S endpoints
-        if (mappingEndpoint.match(/\/v5\d\.0\//)) {
-            everywhereHooks(services, mappingEndpoint, coreVersion);
-        }
+LWR.define('lwr/everywhereAmd/v/0_10_0-alpha_7', ['exports', 'lwr/vault/v/0_10_0-alpha_7'], (function (exports, _0_10_0Alpha_7) {
+  // IMPORTANT: Do not add any static imports to this file that are not bundled with the amd-client
+
+  // Do an OAuthed fetch
+  async function authFetch(url, accept = 'javascript') {
+    const authInfo = _0_10_0Alpha_7.getAuthInfo();
+    if (authInfo) {
+      return fetch(url, {
+        headers: {
+          Accept: `application/${accept}`,
+          Authorization: `Bearer ${authInfo.access_token}`
+        }
+      });
     }
-    // Export the LWRE authenticate() API
-    // This is a duplicate of the function exported from "lwr/everywhere"
-    //      because it MUST be bundled into the LWRE module via "lwr/everywhereAmd"
-    function authenticate(authInfo) {
-        // Put OAuth info into the vault
-        if (authInfo) {
-            _0_10_0Alpha_4.setAuthInfo(authInfo);
+    return null; // defer to loader
+  }
+
+  // Add a hook for adding OAuth headers to module and mapping requests
+  // Workaround: core does not have proper versioning; replace all versions with 0_0_1
+  function everywhereHooks(serviceAPI, mappingEndpoint, coreVersion) {
+    serviceAPI.addLoaderPlugin({
+      loadModule: async url => {
+        return authFetch(url);
+      },
+      loadMapping: async specifier => {
+        const res = await authFetch(`${mappingEndpoint}${encodeURIComponent(specifier)}`, 'json');
+        if (res && res.ok) {
+          return res.json();
+        }
+        return null;
+      },
+      resolveModule: specifier => {
+        // Workaround W-8010259 (dynamic imports without versions)
+        // by adding a default version to version-less specifiers
+        if (specifier && !/\/v\/[^/]+?$/.test(specifier)) {
+          return `${specifier}/v/${coreVersion}`;
         }
+        return null; // defer to loader
+      }
+    });
+  }
+
+  function initAmd(services, mappingEndpoint, coreVersion) {
+    // Initialize the loader hooks for LWR-S endpoints
+    if (mappingEndpoint.match(/\/v5\d\.0\//)) {
+      everywhereHooks(services, mappingEndpoint, coreVersion);
     }
-    exports.authenticate = authenticate;
-    exports.initAmd = initAmd;
-    Object.defineProperty(exports, '__esModule', { value: true });
-});
-LWR.define('lwr/vault/v/0_10_0-alpha_4', ['exports'], function (exports) {
-    // Credential vault for storing setters and subscribers for OAuth info
-    // This module is a SINGLETON and must be excluded from ESM bundling
-    let authInfo;
-    // Get and set the OAuth info
-    function getAuthInfo() {
-        return authInfo;
-    }
-    function setAuthInfo(ai) {
-        authInfo = ai;
+  }
+
+  // Export the LWRE authenticate() API
+  // This is a duplicate of the function exported from "lwr/everywhere"
+  //      because it MUST be bundled into the LWRE module via "lwr/everywhereAmd"
+  function authenticate(authInfo) {
+    // Put OAuth info into the vault
+    if (authInfo) {
+      _0_10_0Alpha_7.setAuthInfo(authInfo);
     }
-    exports.getAuthInfo = getAuthInfo;
-    exports.setAuthInfo = setAuthInfo;
-    Object.defineProperty(exports, '__esModule', { value: true });
-});
+  }
+
+  exports.authenticate = authenticate;
+  exports.initAmd = initAmd;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+LWR.define('lwr/vault/v/0_10_0-alpha_7', ['exports'], (function (exports) {
+  // Credential vault for storing setters and subscribers for OAuth info
+  // This module is a SINGLETON and must be excluded from ESM bundling
+
+  let authInfo;
+
+  // Get and set the OAuth info
+  function getAuthInfo() {
+    return authInfo;
+  }
+  function setAuthInfo(ai) {
+    authInfo = ai;
+  }
+
+  exports.getAuthInfo = getAuthInfo;
+  exports.setAuthInfo = setAuthInfo;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+
+
 // Set up the AMD loader hooks for OAuth
 const { initAmd, authenticate } = await loader.load(bootstrapModule);
-initAmd(loader.services, endpoints?.uris.mapping, '0_10_0-alpha_4');
+initAmd(loader.services, _optionalChain([endpoints, 'optionalAccess', _ => _.uris, 'access', _2 => _2.mapping]), '0_10_0-alpha_7');
+
 // Wrap the createComponent API to allow proper ordering of module definitions:
 //  1. LWRE module bundle (this): lwr/loader, lwr/everywhereAmd, lwr/vault
 //  2. lwr/everywhere (deps: lwc, synthetic shadow, lwr/host, etc)
 //  3. Salesforce hosted UI content (i.e. embedded components and deps)
-async function createComponent(specifier, nodeId, properties = {}, config) {
+async function createComponent(
+    specifier,
+    nodeId,
+    properties = {},
+    config,
+) {
     // Do not load the "lwr/everywhere" API module ahead of time
     // This import MUST be done AFTER the loader hooks are in place via authenticate() so
     //      modules [statically] imported from core have the appropriate Authorization headers