@lwrjs/everywhere 0.12.0-alpha.23 → 0.12.0-alpha.25

package/build/__generated_site_amd_modules__/1/module/amd/1/l/en-US/mi/lwr/loader/v/0_12_0-alpha_25/s/2115e9304d87c9926770b16f31a63742/lwr_loader.js

@@ -0,0 +1,1396 @@
+LWR.define('lwr/loader/v/0_12_0-alpha_25', ['exports'], (function (exports) { 'use strict';
+
+  /**
+  * Copyright (c) 2021, salesforce.com, inc.
+  * All rights reserved.
+  * 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.12.0-alpha.25 */
+  const templateRegex = /\{([0-9]+)\}/g;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function templateString(template, args) {
+    return template.replace(templateRegex, (_, index) => {
+      return args[index];
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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);
+    }
+    /*LWC compiler v6.3.2*/
+  }
+  function invariant(condition, errorInfo) {
+    if (!condition) {
+      throw new LoaderError(errorInfo);
+    }
+  }
+  const MISSING_NAME = Object.freeze({
+    code: 3000,
+    message: 'A module name is required.',
+    level: 0
+  });
+  const FAIL_INSTANTIATE = Object.freeze({
+    code: 3004,
+    message: 'Failed to instantiate module: {0}',
+    level: 0
+  });
+  const NO_AMD_REQUIRE = Object.freeze({
+    code: 3005,
+    message: 'AMD require not supported.',
+    level: 0
+  });
+  const FAILED_DEP = Object.freeze({
+    code: 3006,
+    level: 0,
+    message: 'Failed to load dependency: {0}'
+  });
+  const INVALID_DEPS = Object.freeze({
+    code: 3007,
+    message: 'Unexpected value received for dependencies argument; expected an array.',
+    level: 0
+  });
+  const FAIL_LOAD = Object.freeze({
+    code: 3008,
+    level: 0,
+    message: 'Error loading {0}'
+  });
+  const UNRESOLVED = Object.freeze({
+    code: 3009,
+    level: 0,
+    message: 'Unable to resolve bare specifier: {0}'
+  });
+  const NO_BASE_URL = Object.freeze({
+    code: 3010,
+    level: 0,
+    message: 'baseUrl not set'
+  });
+  Object.freeze({
+    code: 3011,
+    level: 0,
+    message: 'Cannot set a loader service multiple times'
+  });
+  const INVALID_HOOK = Object.freeze({
+    code: 3012,
+    level: 0,
+    message: 'Invalid hook received'
+  });
+  const INVALID_LOADER_SERVICE_RESPONSE = Object.freeze({
+    code: 3013,
+    level: 0,
+    message: 'Invalid response received from hook'
+  });
+  const MODULE_LOAD_TIMEOUT = Object.freeze({
+    code: 3014,
+    level: 0,
+    message: 'Error loading {0} - timed out'
+  });
+  const HTTP_FAIL_LOAD = Object.freeze({
+    code: 3015,
+    level: 0,
+    message: 'Error loading {0}, status code {1}'
+  });
+  const STALE_HOOK_ERROR = Object.freeze({
+    code: 3016,
+    level: 0,
+    message: 'An error occurred handling module conflict'
+  });
+  const MODULE_ALREADY_LOADED = Object.freeze({
+    code: 3017,
+    level: 0,
+    message: 'Marking module(s) as externally loaded, but they are already loaded:'
+  });
+  const FAIL_HOOK_LOAD = Object.freeze({
+    code: 3018,
+    level: 0,
+    message: 'Error loading "{0}" from hook'
+  });
+  const NO_MAPPING_URL = Object.freeze({
+    code: 3019,
+    level: 0,
+    message: 'Mapping endpoint not set'
+  });
+  const BAD_IMPORT_METADATA = Object.freeze({
+    code: 3020,
+    level: 0,
+    message: 'Invalid import metadata: {0} {1}'
+  });
+  const EXPORTER_ERROR = Object.freeze({
+    code: 3021,
+    level: 0,
+    message: 'Error evaluating module "{0}", error was "{1}"'
+  });
+
+  /* importMap errors */
+  Object.freeze({
+    code: 3011,
+    level: 0,
+    message: 'import map is not valid'
+  });
+
+  /* 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 */
+
+  function getBaseUrl() {
+    let baseUrl = undefined;
+    if (hasDocument) {
+      // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+      const baseEl = document.querySelector('base[href]');
+      baseUrl = baseEl && baseEl.href;
+    }
+    // eslint-disable-next-line lwr/no-unguarded-apis
+    if (!baseUrl && typeof location !== 'undefined') {
+      // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+      baseUrl = location.href.split('#')[0].split('?')[0];
+      const lastSepIndex = baseUrl.lastIndexOf('/');
+      if (lastSepIndex !== -1) {
+        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
+   *
+   * URL Format:
+   *  <scheme>:<scheme-specific-part>
+   * Common Internet Scheme Syntax:
+   *  The scheme specific part starts with a double slash('//')
+   *
+   * A valid URL has a colon that is followed by a double slash.
+   *
+   * @param url - the url that is being checked
+   * @returns boolean
+   *
+   * @example Valid URLs
+   * 'https://salesforce.com'
+   * 'http://localhost:3000'
+   *
+   * @example Invalid URLs
+   * 'salesforce.com'
+   * 'localhost:3000'
+   * '@salesforce/label/type:namespace:name'
+   */
+  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, '/');
+    // 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] === '/') {
+      const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
+      let pathname;
+      if (parentUrl[parentProtocol.length + 1] === '/') {
+        // resolving to a :// so we need to read out the auth and host
+        if (parentProtocol !== 'file:') {
+          pathname = parentUrl.slice(parentProtocol.length + 2);
+          pathname = pathname.slice(pathname.indexOf('/') + 1);
+        } else {
+          pathname = parentUrl.slice(8);
+        }
+      } else {
+        // resolving to :/ so pathname is the /... part
+        pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/' ? 1 : 0));
+      }
+      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++) {
+        // busy reading a segment - only terminate on '/'
+        if (segmentIndex !== -1) {
+          if (segmented[i] === '/') {
+            output.push(segmented.slice(segmentIndex, i + 1));
+            segmentIndex = -1;
+          }
+        }
+
+        // new segment - check if it is relative
+        else if (segmented[i] === '.') {
+          // ../ segment
+          if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
+            output.pop();
+            i += 2;
+          }
+          // ./ segment
+          else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
+            i += 1;
+          } else {
+            // the start of a new segment as below
+            segmentIndex = i;
+          }
+        }
+        // it is the start of a new segment
+        else {
+          segmentIndex = i;
+        }
+      }
+      // finish reading out the last segment
+      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) || (isUrl(relUrl) ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
+    return resolvedUrl;
+  }
+  function createScript(url) {
+    // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+    const script = document.createElement('script');
+    script.async = true;
+    script.crossOrigin = 'anonymous';
+    script.src = url;
+    return script;
+  }
+  let lastWindowError$1, lastWindowErrorUrl;
+  function loadModuleDef(url) {
+    return new Promise(function (resolve, reject) {
+      if (hasDocument) {
+        /* eslint-disable lwr/no-unguarded-apis, no-undef */
+        const script = createScript(url);
+        script.addEventListener('error', () => {
+          reject(new LoaderError(FAIL_LOAD, [url]));
+        });
+        script.addEventListener('load', () => {
+          document.head.removeChild(script);
+          if (lastWindowErrorUrl === url) {
+            reject(lastWindowError$1);
+          } else {
+            resolve();
+          }
+        });
+        document.head.appendChild(script);
+        /* eslint-enable lwr/no-unguarded-apis, no-undef */
+      }
+    });
+  }
+  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
+    window.addEventListener('error', evt => {
+      lastWindowErrorUrl = evt.filename;
+      lastWindowError$1 = evt.error;
+    });
+  }
+
+  // Bootstrap / shim
+
+  // Loader: modules
+  const LOADER_PREFIX = 'lwr.loader.';
+  const MODULE_DEFINE = `${LOADER_PREFIX}module.define`;
+  const MODULE_DYNAMIC_LOAD = `${LOADER_PREFIX}moduleRegistry.dynamicLoad`;
+  const MODULE_FETCH = `${LOADER_PREFIX}module.fetch`;
+  const MODULE_ERROR = `${LOADER_PREFIX}module.error`;
+
+  // Loader: mappings
+  const MAPPINGS_FETCH = `${LOADER_PREFIX}mappings.fetch`;
+  const MAPPINGS_ERROR = `${LOADER_PREFIX}mappings.error`;
+
+  /* spec based import map resolver */
+  class ImportMetadataResolver {
+    // 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 {
+        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';
+        throw new LoaderError(BAD_IMPORT_METADATA, [imports, rootSpecifiers ? '[]' : 'undefined']);
+      }
+      if (!newImportMetadata) {
+        throw new LoaderError(BAD_IMPORT_METADATA, ['undefined', JSON.stringify(rootSpecifiers)]);
+      }
+      if (!newImportMetadata.imports || Object.keys(newImportMetadata.imports).length === 0) {
+        throw new LoaderError(BAD_IMPORT_METADATA, [JSON.stringify(newImportMetadata), JSON.stringify(rootSpecifiers)]);
+      }
+      const index = newImportMetadata.index || {};
+      for (const [uri, specifiers] of Object.entries(newImportMetadata.imports)) {
+        specifiers.forEach(specifier => {
+          const indexValue = index[specifier];
+          const existing = this.importURICache.get(specifier);
+          if (!existing) {
+            this.saveImportURIRecord(specifier, uri, indexValue, rootSpecifiers.includes(specifier));
+          } else {
+            const identity = indexValue || uri;
+            const existingIdentity = existing.identity || existing.uri;
+            if (existingIdentity !== identity) {
+              this.invalidationCallback({
+                name: specifier,
+                oldUrl: existingIdentity,
+                newUrl: identity
+              });
+            }
+          }
+        });
+      }
+    }
+
+    // Get URL from the local cache or return undefiend
+    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('/')) {
+        return specifier;
+      }
+      return undefined;
+    }
+
+    /**
+     *  Resolves a the URI for a specified module.  It will return the value in this order:
+     *
+     *  1) Mapping from local URI cache
+     *  2) The URI if a specifier is already an absolute URI
+     *  3) Mapping fetched from a registered loader hook
+     *  4)
+     *  @param specifier
+     *  @returns module URI
+     */
+    async resolve(specifier) {
+      let uri = this.getURI(specifier);
+      if (uri) {
+        return uri;
+      } else if (isUrl(specifier) || specifier.startsWith('/')) {
+        return specifier;
+      } 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 : this.fetchNewMappings;
+        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;
+        }).finally(() => {
+          this.pendingURICache.delete(specifier);
+        });
+        this.pendingURICache.set(specifier, promise);
+        return promise;
+      }
+    }
+    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) {
+      // Check with any registered loadMappingHooks
+      const loadMappingHooks = this.loadMappingHooks;
+      if (loadMappingHooks.length) {
+        const knownModules = Array.from(this.importURICache.keys());
+        for (let i = 0; i < loadMappingHooks.length; i++) {
+          const loadMappingHook = loadMappingHooks[i];
+          // eslint-disable-next-line no-await-in-loop
+          const response = await loadMappingHook(specifier, {
+            knownModules
+          });
+          // undefined (but not null) is considered an un expected response so we will stop processing hooks here and throw an error
+          if (response || response === undefined) {
+            return response;
+          }
+        }
+      }
+
+      // If we still do not have a match call the mapping service
+      return this.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());
+      return globalThis.fetch(uri).then(res => {
+        if (!res.ok) {
+          this.config.profiler.logOperationStart({
+            id: MAPPINGS_ERROR,
+            specifier
+          });
+          throw new LoaderError(UNRESOLVED, [specifier]);
+        }
+        return res.json().then(ret => {
+          return ret;
+        }).catch(err => {
+          throw new LoaderError(UNRESOLVED, [specifier]);
+        });
+      });
+    }
+    saveImportURIRecord(specifier, uri, identity, isRoot) {
+      if (!identity || uri === identity) {
+        this.importURICache.set(specifier, {
+          uri,
+          isRoot: isRoot
+        });
+      } else {
+        this.importURICache.set(specifier, {
+          uri,
+          identity,
+          isRoot: isRoot
+        });
+      }
+    }
+  }
+  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);
+  }
+  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++) {
+      const hook = handleStaleModuleHooks[i];
+      try {
+        const hookResult = hook({
+          name,
+          oldUrl,
+          newUrl
+        });
+        if (hookResult !== null) {
+          break;
+        }
+      } catch (e) {
+        reportError(new LoaderError(STALE_HOOK_ERROR));
+      }
+    }
+  }
+  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;
+    }
+  };
+  // Temporarily surround in try-catch until migration to AMD run.
+  try {
+    // istanbul ignore next: this creates a special policy described here https://developer.mozilla.org/en-US/docs/Web/API/TrustedTypePolicyFactory/createPolicy
+    createPolicy('default', {
+      createHTML(dirty) {
+        // Treat null & undefined separately
+        if (dirty === 'null' || dirty === 'undefined') {
+          return dirty;
+        }
+        return dirty;
+      },
+      // Ignore typescript type validation for this policy.
+      // Returning `undefined` from a TT policy blocks usages
+      // of specific DOM sinks affected by this hook.
+      // We want to block eval and inline scripts.
+      // @ts-ignore
+      createScript(dirty) {
+        // Treat null & undefined separately
+        if (dirty === 'null' || dirty === 'undefined') {
+          return dirty;
+        }
+        // Block script evaluation
+        return undefined;
+      },
+      createScriptURL(dirty) {
+        // Treat null & undefined separately
+        if (dirty === 'null' || dirty === 'undefined') {
+          return dirty;
+        }
+        return dirty;
+      }
+    });
+  } catch (_unused) {
+    // swallow
+  }
+  const trusted = createPolicy('trusted', policyOptions);
+  /*! version: 0.21.3 */
+
+  /* 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');
+  }
+  function isFetchResponse(response) {
+    // if it quacks like a duck...
+    return typeof response.blob === 'function';
+  }
+  function isResponseAPromise(response) {
+    return !!(response && response.then);
+  }
+  async function evaluateLoadHookResponse(response, id) {
+    return Promise.resolve().then(async () => {
+      if (!response || !response.status) {
+        throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+      }
+      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) {
+        // handle fetch response
+        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(trusted.createScript(code));
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production' && hasConsole) {
+          // eslint-disable-next-line lwr/no-unguarded-apis
+          console.error(e);
+        }
+        throw new LoaderError(FAIL_LOAD, [id]);
+      }
+      if (lastWindowError) {
+        throw new LoaderError(FAIL_LOAD, [id]);
+      }
+      return true;
+    });
+  }
+  async function evaluateLoadHook(id, hookPromise) {
+    if (!hasSetTimeout) {
+      return hookPromise;
+    }
+    return new Promise((resolve, reject) => {
+      // wrap the hook in a watchdog timer
+      // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+      const timer = setTimeout(() => {
+        reject(new LoaderError(MODULE_LOAD_TIMEOUT, [id]));
+      }, MODULE_LOAD_TIMEOUT_TIMER);
+      hookPromise.then(response => {
+        resolve(response);
+      }).catch(() => {
+        reject(new LoaderError(FAIL_HOOK_LOAD, [id]));
+      }).finally(() => {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        clearTimeout(timer);
+      });
+    });
+  }
+
+  /* global console,process */
+
+  class ModuleRegistry {
+    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));
+    }
+    async load(id, importer) {
+      const metadata = importer ? {
+        importer
+      } : {};
+      this.profiler.logOperationStart({
+        id: MODULE_DYNAMIC_LOAD,
+        specifier: id,
+        metadata
+      });
+      const resolvedId = await this.resolve(id, importer);
+      const moduleRecord = await this.getModuleRecord(resolvedId, id);
+      if (moduleRecord.evaluated) {
+        return moduleRecord.module;
+      } 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;
+      if (resolveHooks) {
+        for (let i = 0; i < resolveHooks.length; i++) {
+          const resolveHook = resolveHooks[i];
+          const response = resolveHook(aliasedId, {
+            parentUrl
+          });
+          let result;
+          if (response || response === null) {
+            // eslint-disable-next-line no-await-in-loop
+            result = isResponseAPromise(response) ? await response : response;
+          }
+          if (!this.isValidResolveResponse(result)) {
+            throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+          }
+
+          // if result is not null, attempt resolution
+          if (result !== null) {
+            if (typeof result === 'string') {
+              if (resolveIfNotPlainOrUrl(result, parentUrl)) {
+                // string response can't be a URL
+                throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+              }
+              aliasedId = result; // the next hook will receive the new id
+              continue;
+            }
+            resolved = result && result.url && (resolveIfNotPlainOrUrl(result.url, parentUrl) || result.url);
+            if (!resolved) {
+              throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+            }
+            // Don't process any more hooks if we have resolved
+            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 {
+            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) {
+          // resolve to the bare specifier if conditions are met
+          if (this.namedDefineRegistry.has(resolvedOrPlain)) {
+            const namedDefineRecord = this.namedDefineRegistry.get(resolvedOrPlain);
+            if (namedDefineRecord.external || namedDefineRecord.defined) {
+              const record = this.moduleRegistry.get(resolvedUrl);
+              if (!record || !this.aliases.has(resolvedOrPlain)) {
+                return resolvedOrPlain;
+              }
+            }
+          }
+          return resolvedUrl;
+        }
+        if (this.namedDefineRegistry.has(resolvedOrPlain)) {
+          return resolvedOrPlain;
+        }
+        try {
+          resolved = await this.resolver.resolve(resolvedOrPlain);
+        } catch (e) {
+          // defer to error handling below for unresolved
+        }
+      }
+      if (!resolved || !isUrl(resolved)) {
+        if (this.namedDefineRegistry.has(id)) {
+          return id;
+        }
+        throw new LoaderError(UNRESOLVED, [id]);
+      }
+      if (importer && isUrl(resolved)) {
+        resolved += `?importer=${encodeURIComponent(importer)}`;
+      }
+      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.
+      if (mod && mod.defined) {
+        if (process.env.NODE_ENV !== 'production' && hasConsole) {
+          // eslint-disable-next-line lwr/no-unguarded-apis
+          console.warn(`Module redefine attempted: ${name}`);
+        }
+        this.lastDefine = mod;
+        return;
+      }
+      const moduleDef = {
+        name,
+        dependencies,
+        exporter,
+        defined: true
+      };
+      if (mod && mod.external) {
+        // 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.
+     *
+     * @param modules - list of module identifiers
+     */
+    registerExternalModules(modules) {
+      modules.map(id => {
+        if (!this.namedDefineRegistry.has(id)) {
+          let resolveExternal;
+          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(() => {
+              reject(new LoaderError(MODULE_LOAD_TIMEOUT, [id]));
+            }, MODULE_LOAD_TIMEOUT_TIMER);
+          }).finally(() => {
+            // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+            clearTimeout(timer);
+          });
+          const moduleDef = {
+            name: id,
+            defined: false,
+            external: {
+              resolveExternal,
+              moduleDefPromise
+            }
+          };
+          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) {
+      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);
+        if (alias) {
+          const aliasedModule = this.moduleRegistry.get(alias);
+          if (aliasedModule) {
+            return aliasedModule;
+          }
+        }
+      }
+      return moduleRecord;
+    }
+    async 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 => {
+        const dependencies = moduleDef.dependencies || [];
+        // 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);
+        return Promise.all(filtered);
+      });
+      const newModuleRecord = {
+        id: resolvedId,
+        module: Object.create(null),
+        dependencyRecords,
+        instantiation,
+        evaluated: false,
+        evaluationPromise: null
+      };
+      this.moduleRegistry.set(resolvedId, newModuleRecord);
+      this.storeModuleAlias(id, resolvedId);
+
+      // Wait for the dependencies to resolve the return the moduleRecord
+      return dependencyRecords.then(() => newModuleRecord);
+    }
+    storeModuleAlias(aliasId, resolvedId) {
+      if (aliasId !== resolvedId) {
+        if (!this.aliases.has(aliasId)) {
+          this.aliases.set(aliasId, resolvedId);
+        } 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) {
+            // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+            if (process.env.NODE_ENV !== 'production' && hasConsole) {
+              // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+              console.warn(`Alias update attempt: ${aliasId}=>${currentResolvedId}, ${resolvedId}`);
+            }
+          }
+        }
+      }
+    }
+    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) {
+      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) {
+      if (!instantiatedMap[moduleRecord.id]) {
+        instantiatedMap[moduleRecord.id] = true;
+        const dependencyModuleRecords = await moduleRecord.dependencyRecords;
+        if (dependencyModuleRecords) {
+          for (let i = 0; i < dependencyModuleRecords.length; i++) {
+            const depRecord = dependencyModuleRecords[i];
+            // eslint-disable-next-line no-await-in-loop
+            await this.instantiateAll(depRecord, instantiatedMap);
+          }
+        }
+      }
+    }
+    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 = dependencies ? 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]);
+      })) : [];
+
+      // 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;
+      try {
+        moduleDefault = exporter(...depsMapped);
+      } catch (e) {
+        throw new LoaderError(EXPORTER_ERROR, [moduleRecord.id, e.message || e]);
+      }
+      // value is returned from exporter, then we are not using named exports
+      if (moduleDefault !== undefined) {
+        moduleDefault = {
+          default: moduleDefault
+        };
+        // __defaultInterop is ONLY used to support backwards compatibility
+        // of importing default exports the "wrong" way (when not using named exports).
+        // See https://github.com/salesforce-experience-platform-emu/lwr/pull/816
+        Object.defineProperty(moduleDefault, '__defaultInterop', {
+          value: true
+        });
+      }
+      // if no return value, then we are using the exports object
+      else {
+        // handle only default export with Rollup forced named exports
+        if (this.isNamedExportDefaultOnly(exports)) {
+          Object.defineProperty(exports, '__useDefault', {
+            value: true
+          });
+        }
+      }
+      const moduleExports = moduleDefault || exports;
+
+      // update the module record
+      // copy over enumerable public methods to module
+      for (const key in moduleExports) {
+        Object.defineProperty(moduleRecord.module, key, {
+          enumerable: true,
+          set(value) {
+            moduleExports[key] = value;
+          },
+          get() {
+            return moduleExports[key];
+          }
+        });
+      }
+
+      // copy non-enumerable to module
+      if (moduleExports.__useDefault) {
+        Object.defineProperty(moduleRecord.module, '__useDefault', {
+          value: true
+        });
+      }
+      if (moduleExports.__defaultInterop) {
+        Object.defineProperty(moduleRecord.module, '__defaultInterop', {
+          value: true
+        });
+      }
+      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 && Object.getOwnPropertyNames(exports).length === 2 && Object.prototype.hasOwnProperty.call(exports, 'default') && 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) {
+      const tmp = () => {
+        return module.__useDefault || module.__defaultInterop ? module.default : module;
+      };
+      tmp.__circular__ = true;
+      return tmp;
+    }
+    async evaluateModuleDependencies(dependencyModuleRecords, evaluationMap) {
+      for (let i = 0; i < dependencyModuleRecords.length; i++) {
+        const depRecord = dependencyModuleRecords[i];
+        if (!depRecord.evaluated && !evaluationMap[depRecord.id]) {
+          evaluationMap[depRecord.id] = true;
+          // eslint-disable-next-line no-await-in-loop
+          await this.evaluateModule(depRecord, evaluationMap);
+        }
+      }
+    }
+    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;
+      let moduleDef = moduleName && this.namedDefineRegistry.get(moduleName);
+      if (moduleDef && moduleDef.external) {
+        return moduleDef.external.moduleDefPromise;
+      }
+      if (moduleDef && moduleDef.defined) {
+        return moduleDef;
+      }
+      const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
+      const specifier = moduleName || originalId;
+      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);
+            }
+          }
+        }
+        return false;
+      }).then(result => {
+        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;
+      }).catch(e => {
+        // Create module error marks for all errors caused by the loader
+        // Note: these marks do not include errors caused by invalid server responses or loader hooks
+        if (!(e instanceof LoaderError)) {
+          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 {
+          this.resolveHook = [resolveHook];
+        }
+      }
+      if (loadHook) {
+        if (this.loadHook) {
+          this.loadHook.push(loadHook);
+        } else {
+          this.loadHook = [loadHook];
+        }
+      }
+      if (loadMapping) {
+        this.resolver.addLoadMappingHook(loadMapping);
+      }
+    }
+    importMetadataInvalidationCallback({
+      name,
+      oldUrl,
+      newUrl
+    }) {
+      const handleStaleModuleHooks = this.handleStaleModuleHook;
+      if (handleStaleModuleHooks) {
+        evaluateHandleStaleModuleHooks(handleStaleModuleHooks, {
+          name,
+          oldUrl,
+          newUrl
+        });
+      } 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 {
+        this.handleStaleModuleHook = [handleStaleModule];
+      }
+    }
+    isValidResolveResponse(res) {
+      return res === null || typeof res === 'string' || res && typeof res.url === 'string';
+    }
+  }
+
+  /**
+   * 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(/\/?$/, '/');
+      }
+      if (!baseUrl) {
+        baseUrl = getBaseUrl();
+      }
+      if (!baseUrl) {
+        throw new LoaderError(NO_BASE_URL);
+      }
+      if (!profiler) {
+        // default noop profiler
+        profiler = {
+          logOperationStart: () => {
+            /* noop */
+          },
+          logOperationEnd: () => {
+            /* noop */
+          }
+        };
+      }
+      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
+        // LWR-Java bootstrap module format: @lwr-bootstrap/my/app/v/0_0_1 -- my/app is the appId
+        const match = config.appMetadata.bootstrapModule.match(/@lwr-bootstrap\/(.+)\/v\/.+/);
+        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),
+        handleStaleModule: this.registry.registerHandleStaleModuleHook.bind(this.registry),
+        appMetadata: config.appMetadata,
+        serverData: config.serverData || {}
+      });
+    }
+
+    /**
+     * Defines/registers a single named AMD module definition.
+     *
+     * @param {string} name The module name
+     * @param {string[]} dependencies A list of module dependencies (module imports)
+     * @param {Function} execute The function containing the module code. AKA exporter as it also returns the modules exports when executed
+     * @return {void}
+     */
+    define(name, dependencies, execute) {
+      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);
+    }
+
+    /**
+     * Retrieves/loads a module, returning it from the registry if it exists and fetching it if it doesn't.
+     *
+     * @param {string} id - A module identifier or URL
+     * @param {string} importer - The versioned specifier of the module importer
+     *                            Used when the ID is not versioned (eg: variable dynamic imports)
+     * @return {Promise<Module>}
+     */
+    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).
+     *
+     * @param {string} id - A module identifier or URL
+     * @return {boolean}
+     */
+    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.
+     *
+     * @param {string} id - A module identifier or URL
+     * @param {string} importer - The versioned specifier of the module importer
+     *                            Used when the ID is not versioned (eg: variable dynamic imports)
+     * @return {string}
+     */
+    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.
+     *
+     * @param modules - list of module identifiers
+     */
+    registerExternalModules(modules) {
+      this.registry.registerExternalModules(modules);
+    }
+  }
+
+  exports.Loader = Loader;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));