@lwrjs/everywhere 0.9.0-alpha.8 → 0.9.0

package/build/__generated_site_amd_modules__/1/module/amd/1/l/en-US/mi/lwr/loader/v/{0_9_0-alpha_8/s/b332def6b740c63a4aa2d9a373f969bb → 0_9_0/s/37491c0be6765e2cd302cf146e9d624a}/lwr_loader.js

@@ -1,11 +1,21 @@
-LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
-  "use strict";
+LWR.define('lwr/loader/v/0_9_0', ['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.9.0 */
   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}`;
@@ -15,6 +25,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       super();
       this.message = generateErrorMessage(errorInfo, errorArgs);
     }
+    /*LWC compiler v2.38.1*/
   }
   function invariant(condition, errorInfo) {
     if (!condition) {
@@ -22,79 +33,79 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
     }
   }
   const MISSING_NAME = Object.freeze({
-    code: 3e3,
-    message: "A module name is required.",
+    code: 3000,
+    message: 'A module name is required.',
     level: 0
   });
   const FAIL_INSTANTIATE = Object.freeze({
     code: 3004,
-    message: "Failed to instantiate module: {0}",
+    message: 'Failed to instantiate module: {0}',
     level: 0
   });
   const NO_AMD_REQUIRE = Object.freeze({
     code: 3005,
-    message: "AMD require not supported.",
+    message: 'AMD require not supported.',
     level: 0
   });
   const FAILED_DEP = Object.freeze({
     code: 3006,
     level: 0,
-    message: "Failed to load dependency: {0}"
+    message: 'Failed to load dependency: {0}'
   });
   const INVALID_DEPS = Object.freeze({
     code: 3007,
-    message: "Unexpected value received for dependencies argument; expected an array.",
+    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}"
+    message: 'Error loading {0}'
   });
   const UNRESOLVED = Object.freeze({
     code: 3009,
     level: 0,
-    message: "Unable to resolve bare specifier: {0}"
+    message: 'Unable to resolve bare specifier: {0}'
   });
   const NO_BASE_URL = Object.freeze({
     code: 3010,
     level: 0,
-    message: "baseUrl not set"
+    message: 'baseUrl not set'
   });
   Object.freeze({
     code: 3011,
     level: 0,
-    message: "Cannot set a loader service multiple times"
+    message: 'Cannot set a loader service multiple times'
   });
   const INVALID_HOOK = Object.freeze({
     code: 3012,
     level: 0,
-    message: "Invalid hook received"
+    message: 'Invalid hook received'
   });
   const INVALID_LOADER_SERVICE_RESPONSE = Object.freeze({
     code: 3013,
     level: 0,
-    message: "Invalid response received from hook"
+    message: 'Invalid response received from hook'
   });
   const MODULE_LOAD_TIMEOUT = Object.freeze({
     code: 3014,
     level: 0,
-    message: "Error loading {0} - timed out"
+    message: 'Error loading {0} - timed out'
   });
   const HTTP_FAIL_LOAD = Object.freeze({
     code: 3015,
     level: 0,
-    message: "Error loading {0}, status code {1}"
+    message: 'Error loading {0}, status code {1}'
   });
   const STALE_HOOK_ERROR = Object.freeze({
     code: 3016,
     level: 0,
-    message: "An error occurred handling module conflict"
+    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: {0}"
+    message: 'Marking module(s) as externally loaded, but they are already loaded:'
   });
   const FAIL_HOOK_LOAD = Object.freeze({
     code: 3018,
@@ -104,107 +115,159 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
   const NO_MAPPING_URL = Object.freeze({
     code: 3019,
     level: 0,
-    message: "Mapping endpoint not set"
+    message: 'Mapping endpoint not set'
   });
   const BAD_IMPORT_METADATA = Object.freeze({
     code: 3020,
     level: 0,
-    message: "Invalid import metadata: {0} {1}"
+    message: 'Invalid import metadata: {0} {1}'
   });
+  /* importMap errors */
   Object.freeze({
     code: 3011,
     level: 0,
-    message: "import map is not valid"
+    message: 'import map is not valid'
   });
-  const hasDocument = typeof document !== "undefined";
-  const hasSetTimeout = typeof setTimeout === "function";
-  const hasConsole = typeof console !== "undefined";
+
+  /* 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 = void 0;
+    let baseUrl = undefined;
     if (hasDocument) {
-      const baseEl = document.querySelector("base[href]");
+      // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+      const baseEl = document.querySelector('base[href]');
       baseUrl = baseEl && baseEl.href;
     }
-    if (!baseUrl && typeof location !== "undefined") {
-      baseUrl = location.href.split("#")[0].split("?")[0];
-      const lastSepIndex = baseUrl.lastIndexOf("/");
+    // 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;
+    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[0] === "/" && relUrl[1] === "/") {
-      return parentUrl.slice(0, parentUrl.indexOf(":") + 1) + relUrl;
-    } 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);
+    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] === "/") {
-        if (parentProtocol !== "file:") {
+      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);
+          pathname = pathname.slice(pathname.indexOf('/') + 1);
         } else {
           pathname = parentUrl.slice(8);
         }
       } else {
-        pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === "/" ? 1 : 0));
+        // 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;
-      const segmented = pathname.slice(0, pathname.lastIndexOf("/") + 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++) {
+        // busy reading a segment - only terminate on '/'
         if (segmentIndex !== -1) {
-          if (segmented[i] === "/") {
+          if (segmented[i] === '/') {
             output.push(segmented.slice(segmentIndex, i + 1));
             segmentIndex = -1;
           }
-        } else if (segmented[i] === ".") {
-          if (segmented[i + 1] === "." && (segmented[i + 2] === "/" || i + 2 === segmented.length)) {
+        }
+        // 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;
-          } else if (segmented[i + 1] === "/" || i + 1 === segmented.length) {
+          }
+          // ./ segment
+          else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
             i += 1;
           } else {
+            // the start of a new segment as below
             segmentIndex = i;
           }
-        } else {
+        }
+        // it is the start of a new segment
+        else {
           segmentIndex = i;
         }
       }
-      if (segmentIndex !== -1)
-        output.push(segmented.slice(segmentIndex));
-      return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join("");
+      // 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));
+    const resolvedUrl = resolveIfNotPlainOrUrl(relUrl, parentUrl) || (isUrl(relUrl) ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
     return resolvedUrl;
   }
   function createScript(url) {
-    const script = document.createElement("script");
+    // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+    const script = document.createElement('script');
     script.async = true;
-    script.crossOrigin = "anonymous";
+    script.crossOrigin = 'anonymous';
     script.src = url;
     return script;
   }
   let lastWindowError$1, lastWindowErrorUrl;
   function loadModuleDef(url) {
-    return new Promise(function(resolve, reject) {
+    return new Promise(function (resolve, reject) {
       if (hasDocument) {
+        /* eslint-disable lwr/no-unguarded-apis, no-undef */
         const script = createScript(url);
-        script.addEventListener("error", () => {
+        script.addEventListener('error', () => {
           reject(new LoaderError(FAIL_LOAD, [url]));
         });
-        script.addEventListener("load", () => {
+        script.addEventListener('load', () => {
           document.head.removeChild(script);
           if (lastWindowErrorUrl === url) {
             reject(lastWindowError$1);
@@ -213,23 +276,36 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           }
         });
         document.head.appendChild(script);
+        /* eslint-enable lwr/no-unguarded-apis, no-undef */
       }
     });
   }
+
   if (hasDocument) {
-    window.addEventListener("error", (evt) => {
+    // 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;
     });
   }
-  const LOADER_PREFIX = "lwr.loader.";
+
+  // Bootstrap / shim
+
+  // Loader: modules
+  const LOADER_PREFIX = 'lwr.loader.';
   const MODULE_DEFINE = `${LOADER_PREFIX}module.define`;
   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 {
     constructor(config, invalidationCallback) {
+      // Default to empty mappings
       this.importURICache = new Map();
       this.pendingURICache = new Map();
       this.loadMappingHooks = [];
@@ -240,14 +316,15 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       this.loadMappingHooks.push(hook);
     }
     getMappingEndpoint() {
-      return this.config.endpoints && this.config.endpoints.uris ? this.config.endpoints.uris.mapping : void 0;
+      return this.config.endpoints && this.config.endpoints.uris ? this.config.endpoints.uris.mapping : undefined;
     }
     getModifiersAsUrlParams() {
-      const modifiers = this.config.endpoints ? this.config.endpoints.modifiers : void 0;
+      const modifiers = this.config.endpoints ? this.config.endpoints.modifiers : undefined;
       if (!modifiers) {
-        return "";
+        // 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("&");
+        const qs = Object.keys(modifiers).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(modifiers[key])}`).join('&');
         return `?${qs}`;
       }
     }
@@ -262,18 +339,18 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
     }
     registerImportMappings(newImportMetadata, rootSpecifiers) {
       if (!rootSpecifiers || rootSpecifiers.length === 0) {
-        const imports = newImportMetadata ? JSON.stringify(newImportMetadata) : "undefined";
-        throw new LoaderError(BAD_IMPORT_METADATA, [imports, rootSpecifiers ? "[]" : "undefined"]);
+        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)]);
+        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) => {
+        specifiers.forEach(specifier => {
           const indexValue = index[specifier];
           const existing = this.importURICache.get(specifier);
           if (!existing) {
@@ -292,23 +369,34 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         });
       }
     }
+    // Get URL from the local cache or return undefiend
     getURI(specifier) {
-      return this.importURICache.has(specifier) ? resolveUrl(this.importURICache.get(specifier).uri, this.getBaseUrl()) : void 0;
+      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 void 0;
+      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("/")) {
+      } else if (isUrl(specifier) || specifier.startsWith('/')) {
         return specifier;
       } else {
         const pending = this.pendingURICache.get(specifier);
@@ -320,7 +408,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           specifier
         });
         const fetchMappingService = this.hasMappingHooks() ? this.evaluateMappingHooks : this.fetchNewMappings;
-        const promise = fetchMappingService.bind(this)(specifier).then((importMetadata) => {
+        const promise = fetchMappingService.bind(this)(specifier).then(importMetadata => {
           if (!importMetadata || !importMetadata.imports) {
             throw new LoaderError(UNRESOLVED, [specifier]);
           }
@@ -344,28 +432,39 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
     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
           });
-          if (response || response === void 0) {
+          // 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") {
+      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) => {
+      return globalThis.fetch(uri).then(res => {
         if (!res.ok) {
           this.config.profiler.logOperationStart({
             id: MAPPINGS_ERROR,
@@ -373,9 +472,9 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           });
           throw new LoaderError(UNRESOLVED, [specifier]);
         }
-        return res.json().then((ret) => {
+        return res.json().then(ret => {
           return ret;
-        }).catch((err) => {
+        }).catch(err => {
           throw new LoaderError(UNRESOLVED, [specifier]);
         });
       });
@@ -384,20 +483,21 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       if (!identity || uri === identity) {
         this.importURICache.set(specifier, {
           uri,
-          isRoot
+          isRoot: isRoot
         });
       } else {
         this.importURICache.set(specifier, {
           uri,
           identity,
-          isRoot
+          isRoot: isRoot
         });
       }
     }
   }
   function reportError(error) {
-    if (hasConsole)
-      console.error(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 {
@@ -405,6 +505,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       oldUrl,
       newUrl
     } = hookArgs;
+    // keep evaluating hooks if return value is null
     for (let i = 0; i < handleStaleModuleHooks.length; i++) {
       const hook = handleStaleModuleHooks[i];
       try {
@@ -421,23 +522,27 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       }
     }
   }
-  const MODULE_LOAD_TIMEOUT_TIMER = 3e5;
+  const MODULE_LOAD_TIMEOUT_TIMER = 300000;
+
+  /* global console,process */
   let lastWindowError;
   if (hasDocument) {
-    globalThis.addEventListener("error", (evt) => {
+    globalThis.addEventListener('error', evt => {
       lastWindowError = evt.error;
     });
   }
-  if (true) {
+  if (process.env.NODE_ENV !== 'production') {
     if (!hasSetTimeout && hasConsole) {
-      console.warn("setTimeout API is not available, watchdog timer on load hook will not be set");
+      // 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) {
-    return typeof response.blob === "function";
+    // if it quacks like a duck...
+    return typeof response.blob === 'function';
   }
   function isResponseAPromise(response) {
     return !!(response && response.then);
@@ -455,6 +560,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       if (isCustomResponse(response)) {
         code = response.data;
       } else if (isResponse) {
+        // handle fetch response
         code = await response.text();
       } else {
         throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
@@ -462,9 +568,9 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       if (!code) {
         throw new LoaderError(FAIL_LOAD, [id]);
       }
-      code = `${code}
-//# sourceURL=${id}`;
+      code = `${code}\n//# sourceURL=${id}`; // append sourceURL for debugging
       try {
+        // TODO eval source maps for debugging
         eval(code);
       } catch (e) {
         throw new LoaderError(FAIL_LOAD, [id]);
@@ -480,22 +586,30 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       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) => {
+      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) {
+      // 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();
       this.profiler = config.profiler;
       this.resolver = new ImportMetadataResolver(config, this.importMetadataInvalidationCallback.bind(this));
@@ -513,7 +627,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       }
     }
     async resolve(id, importer) {
-      const parentUrl = this.resolver.getBaseUrl();
+      const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
       let resolved;
       let aliasedId = id;
       const resolveHooks = this.resolveHook;
@@ -525,24 +639,29 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           });
           let result;
           if (response || response === null) {
+            // 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") {
+            if (typeof result === 'string') {
               if (resolveIfNotPlainOrUrl(result, parentUrl)) {
+                // string response can't be a URL
                 throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
               }
-              aliasedId = result;
+              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 {
@@ -552,11 +671,13 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       }
       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) {
             const record = this.moduleRegistry.get(resolvedUrl);
             if (!record || !this.aliases.has(resolvedOrPlain)) {
@@ -571,6 +692,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         try {
           resolved = await this.resolver.resolve(resolvedOrPlain);
         } catch (e) {
+          // defer to error handling below for unresolved
         }
       }
       if (!resolved || !isUrl(resolved)) {
@@ -589,8 +711,10 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
     }
     define(name, dependencies, exporter) {
       const mod = this.namedDefineRegistry.get(name);
+      // Don't allow redefining a module.
       if (mod && mod.defined) {
-        if (hasConsole) {
+        if (process.env.NODE_ENV !== 'production' && hasConsole) {
+          // eslint-disable-next-line lwr/no-unguarded-apis
           console.warn(`Module redefine attempted: ${name}`);
         }
         this.lastDefine = mod;
@@ -603,6 +727,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         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({
@@ -612,20 +737,25 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       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) {
-      const alreadyRegistered = [];
-      modules.map((id) => {
-        if (this.namedDefineRegistry.has(id)) {
-          alreadyRegistered.push(id);
-        } else {
+      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 = {
@@ -637,21 +767,23 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
             }
           };
           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);
         }
       });
-      if (alreadyRegistered.length) {
-        throw new LoaderError(MODULE_ALREADY_LOADED, [alreadyRegistered.join(", ")]);
-      }
     }
     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) {
@@ -664,20 +796,24 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       return moduleRecord;
     }
     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 dependencyRecords = instantiation.then(moduleDef => {
         const dependencies = moduleDef.dependencies;
-        const filtered = dependencies.map((dep) => {
-          if (dep === "exports") {
+        // get dep and filter out exports
+        const filtered = dependencies.map(dep => {
+          if (dep === 'exports') {
             return;
           }
-          invariant(dep !== "require", NO_AMD_REQUIRE);
+          invariant(dep !== 'require', NO_AMD_REQUIRE);
           return this.getModuleDependencyRecord.call(this, dep);
-        }).filter((depRecord) => depRecord !== void 0);
+        }).filter(depRecord => depRecord !== undefined);
         return Promise.all(filtered);
       });
       const newModuleRecord = {
@@ -696,9 +832,11 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       if (aliasId !== resolvedId) {
         if (!this.aliases.has(aliasId)) {
           this.aliases.set(aliasId, resolvedId);
-        } else if (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) {
+            // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
             console.warn(`Alias update attempt: ${aliasId}=>${currentResolvedId}, ${resolvedId}`);
           }
         }
@@ -708,10 +846,12 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       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;
@@ -719,6 +859,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         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);
           }
         }
@@ -728,24 +869,32 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       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") {
+      const depsMapped = await Promise.all(dependencies.map(async dep => {
+        if (dep === 'exports') {
           return exports;
         }
         const resolvedDepId = await this.resolve(dep);
-        const moduleRecord2 = this.moduleRegistry.get(resolvedDepId);
-        if (!moduleRecord2) {
+        const moduleRecord = this.moduleRegistry.get(resolvedDepId);
+        if (!moduleRecord) {
           throw new LoaderError(FAILED_DEP, [resolvedDepId]);
         }
-        const module = moduleRecord2.module;
-        if (!moduleRecord2.evaluated) {
+        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) {
@@ -753,25 +902,36 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         }
         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);
-      if (moduleDefault !== void 0) {
+      // value is returned from exporter, then we are not using named exports
+      if (moduleDefault !== undefined) {
         moduleDefault = {
           default: moduleDefault
         };
-        Object.defineProperty(moduleDefault, "__defaultInterop", {
+        // __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
         });
-      } else {
+      }
+      // 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", {
+          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,
@@ -783,18 +943,19 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           }
         });
       }
+      // copy non-enumerable to module
       if (moduleExports.__useDefault) {
-        Object.defineProperty(moduleRecord.module, "__useDefault", {
+        Object.defineProperty(moduleRecord.module, '__useDefault', {
           value: true
         });
       }
       if (moduleExports.__defaultInterop) {
-        Object.defineProperty(moduleRecord.module, "__defaultInterop", {
+        Object.defineProperty(moduleRecord.module, '__defaultInterop', {
           value: true
         });
       }
       if (moduleExports.__esModule) {
-        Object.defineProperty(moduleRecord.module, "__esModule", {
+        Object.defineProperty(moduleRecord.module, '__esModule', {
           value: true
         });
       }
@@ -802,9 +963,12 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       Object.freeze(moduleRecord.module);
       return moduleRecord.module;
     }
+    // Determines if named exports module has only default export
     isNamedExportDefaultOnly(exports) {
-      return exports !== void 0 && Object.getOwnPropertyNames(exports).length === 2 && Object.prototype.hasOwnProperty.call(exports, "default") && Object.prototype.hasOwnProperty.call(exports, "__esModule");
+      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;
@@ -817,13 +981,16 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         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) {
-      this.lastDefine = void 0;
-      const moduleName = !isUrl(resolvedId) ? resolvedId : originalId !== resolvedId ? originalId : void 0;
+      // 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;
@@ -831,7 +998,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       if (moduleDef && moduleDef.defined) {
         return moduleDef;
       }
-      const parentUrl = this.resolver.getBaseUrl();
+      const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
       const specifier = moduleName || originalId;
       this.profiler.logOperationStart({
         id: MODULE_FETCH,
@@ -843,8 +1010,10 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           for (let i = 0; i < loadHooks.length; i++) {
             const loadHook = loadHooks[i];
             const response = loadHook(resolvedId, parentUrl);
-            const result = isResponseAPromise(response) ? await evaluateLoadHook(resolvedId, response) : response;
-            if (result === void 0) {
+            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) {
@@ -853,15 +1022,18 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           }
         }
         return false;
-      }).then((result) => {
+      }).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]);
         }
@@ -870,7 +1042,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           specifier
         });
         return moduleDef;
-      }).catch((e) => {
+      }).catch(e => {
         this.profiler.logOperationStart({
           id: MODULE_ERROR,
           specifier
@@ -879,7 +1051,7 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       });
     }
     addLoaderPlugin(hooks) {
-      if (typeof hooks !== "object") {
+      if (typeof hooks !== 'object') {
         throw new LoaderError(INVALID_HOOK);
       }
       const {
@@ -918,7 +1090,8 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
           newUrl
         });
       } else {
-        if (hasConsole) {
+        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}`);
         }
       }
@@ -931,17 +1104,23 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
       }
     }
   }
+
+  /**
+   * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
+   */
   class Loader {
     constructor(config) {
       let baseUrl = config.baseUrl;
-      const mappingEndpoint = config.endpoints ? config.endpoints.uris.mapping : void 0;
+      const mappingEndpoint = config.endpoints ? config.endpoints.uris.mapping : undefined;
       let profiler = config.profiler;
       if (!mappingEndpoint) {
         throw new LoaderError(NO_MAPPING_URL);
       }
-      config.endpoints.uris.mapping = mappingEndpoint.replace(/\/?$/, "/");
+      // add a trailing slash, if it does not exist
+      config.endpoints.uris.mapping = mappingEndpoint.replace(/\/?$/, '/');
       if (baseUrl) {
-        baseUrl = baseUrl.replace(/\/?$/, "/");
+        // add a trailing slash, if it does not exist
+        baseUrl = baseUrl.replace(/\/?$/, '/');
       }
       if (!baseUrl) {
         baseUrl = getBaseUrl();
@@ -950,10 +1129,13 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         throw new LoaderError(NO_BASE_URL);
       }
       if (!profiler) {
+        // default noop profiler
         profiler = {
           logOperationStart: () => {
+            /* noop */
           },
           logOperationEnd: () => {
+            /* noop */
           }
         };
       }
@@ -962,44 +1144,87 @@ LWR.define("lwr/loader/v/0_9_0-alpha_8", ["exports"], function(exports) {
         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
       });
     }
+    /**
+     * 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);
+      invariant(typeof name === 'string', MISSING_NAME);
       let ctor = execute;
       let deps = dependencies;
-      if (typeof deps === "function") {
+      // 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});
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
 });