matrix-js-sdk 41.8.0 → 41.9.0

package/lib/autodiscovery.js

@@ -1,4 +1,3 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2018 New Vector Ltd
@@ -24,7 +23,7 @@ import { SUPPORTED_MATRIX_VERSIONS } from "./version-support.js";
 // Dev note: Auto discovery is part of the spec.
 // See: https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery
 
-export var AutoDiscoveryAction = /*#__PURE__*/function (AutoDiscoveryAction) {
+export let AutoDiscoveryAction = /*#__PURE__*/function (AutoDiscoveryAction) {
   AutoDiscoveryAction["SUCCESS"] = "SUCCESS";
   AutoDiscoveryAction["IGNORE"] = "IGNORE";
   AutoDiscoveryAction["PROMPT"] = "PROMPT";
@@ -32,7 +31,7 @@ export var AutoDiscoveryAction = /*#__PURE__*/function (AutoDiscoveryAction) {
   AutoDiscoveryAction["FAIL_ERROR"] = "FAIL_ERROR";
   return AutoDiscoveryAction;
 }({});
-export var AutoDiscoveryError = /*#__PURE__*/function (AutoDiscoveryError) {
+export let AutoDiscoveryError = /*#__PURE__*/function (AutoDiscoveryError) {
   AutoDiscoveryError["Invalid"] = "Invalid homeserver discovery response";
   AutoDiscoveryError["GenericFailure"] = "Failed to get autodiscovery configuration from server";
   AutoDiscoveryError["InvalidHsBaseUrl"] = "Invalid base_url for m.homeserver";
@@ -63,158 +62,154 @@ export class AutoDiscovery {
    * configuration, which may include error states. Rejects on unexpected
    * failure, not when verification fails.
    */
-  static fromDiscoveryConfig(wellknown) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      var _hsVersions$raw;
-      // Step 1 is to get the config, which is provided to us here.
+  static async fromDiscoveryConfig(wellknown) {
+    // Step 1 is to get the config, which is provided to us here.
 
-      // We default to an error state to make the first few checks easier to
-      // write. We'll update the properties of this object over the duration
-      // of this function.
-      var clientConfig = {
-        "m.homeserver": {
-          state: AutoDiscovery.FAIL_ERROR,
-          error: AutoDiscovery.ERROR_INVALID,
-          base_url: null
-        },
-        "m.identity_server": {
-          // Technically, we don't have a problem with the identity server
-          // config at this point.
-          state: AutoDiscovery.PROMPT,
-          error: null,
-          base_url: null
-        }
-      };
-      if (!(wellknown !== null && wellknown !== void 0 && wellknown["m.homeserver"])) {
-        logger.error("No m.homeserver key in config");
-        clientConfig["m.homeserver"].state = AutoDiscovery.FAIL_PROMPT;
-        clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID;
-        return Promise.resolve(clientConfig);
-      }
-      if (!wellknown["m.homeserver"]["base_url"]) {
-        logger.error("No m.homeserver base_url in config");
-        clientConfig["m.homeserver"].state = AutoDiscovery.FAIL_PROMPT;
-        clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;
-        return Promise.resolve(clientConfig);
+    // We default to an error state to make the first few checks easier to
+    // write. We'll update the properties of this object over the duration
+    // of this function.
+    const clientConfig = {
+      "m.homeserver": {
+        state: AutoDiscovery.FAIL_ERROR,
+        error: AutoDiscovery.ERROR_INVALID,
+        base_url: null
+      },
+      "m.identity_server": {
+        // Technically, we don't have a problem with the identity server
+        // config at this point.
+        state: AutoDiscovery.PROMPT,
+        error: null,
+        base_url: null
       }
+    };
+    if (!wellknown?.["m.homeserver"]) {
+      logger.error("No m.homeserver key in config");
+      clientConfig["m.homeserver"].state = AutoDiscovery.FAIL_PROMPT;
+      clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID;
+      return Promise.resolve(clientConfig);
+    }
+    if (!wellknown["m.homeserver"]["base_url"]) {
+      logger.error("No m.homeserver base_url in config");
+      clientConfig["m.homeserver"].state = AutoDiscovery.FAIL_PROMPT;
+      clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;
+      return Promise.resolve(clientConfig);
+    }
 
-      // Step 2: Make sure the homeserver URL is valid *looking*. We'll make
-      // sure it points to a homeserver in Step 3.
-      var hsUrl = _this.sanitizeWellKnownUrl(wellknown["m.homeserver"]["base_url"]);
-      if (!hsUrl) {
-        logger.error("Invalid base_url for m.homeserver");
-        clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;
-        return Promise.resolve(clientConfig);
-      }
+    // Step 2: Make sure the homeserver URL is valid *looking*. We'll make
+    // sure it points to a homeserver in Step 3.
+    const hsUrl = this.sanitizeWellKnownUrl(wellknown["m.homeserver"]["base_url"]);
+    if (!hsUrl) {
+      logger.error("Invalid base_url for m.homeserver");
+      clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;
+      return Promise.resolve(clientConfig);
+    }
 
-      // Step 3: Make sure the homeserver URL points to a homeserver.
-      var hsVersions = yield _this.fetchWellKnownObject("".concat(hsUrl, "/_matrix/client/versions"));
-      if (!hsVersions || !Array.isArray((_hsVersions$raw = hsVersions.raw) === null || _hsVersions$raw === void 0 ? void 0 : _hsVersions$raw["versions"])) {
-        logger.error("Invalid /versions response");
-        clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HOMESERVER;
+    // Step 3: Make sure the homeserver URL points to a homeserver.
+    const hsVersions = await this.fetchWellKnownObject(`${hsUrl}/_matrix/client/versions`);
+    if (!hsVersions || !Array.isArray(hsVersions.raw?.["versions"])) {
+      logger.error("Invalid /versions response");
+      clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HOMESERVER;
 
-        // Supply the base_url to the caller because they may be ignoring liveliness
-        // errors, like this one.
-        clientConfig["m.homeserver"].base_url = hsUrl;
-        return Promise.resolve(clientConfig);
+      // Supply the base_url to the caller because they may be ignoring liveliness
+      // errors, like this one.
+      clientConfig["m.homeserver"].base_url = hsUrl;
+      return Promise.resolve(clientConfig);
+    }
+
+    // Step 3.1: Non-spec check to ensure the server will actually work for us. We need to check if
+    // any of the versions in `SUPPORTED_MATRIX_VERSIONS` are listed in the /versions response.
+    const hsVersionSet = new Set(hsVersions.raw["versions"]);
+    let supportedVersionFound = false;
+    for (const version of SUPPORTED_MATRIX_VERSIONS) {
+      if (hsVersionSet.has(version)) {
+        supportedVersionFound = true;
+        break;
       }
+    }
+    if (!supportedVersionFound) {
+      logger.error("Homeserver does not meet version requirements");
+      clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_UNSUPPORTED_HOMESERVER_SPEC_VERSION;
+
+      // Supply the base_url to the caller because they may be ignoring liveliness
+      // errors, like this one.
+      clientConfig["m.homeserver"].base_url = hsUrl;
+      return Promise.resolve(clientConfig);
+    }
 
-      // Step 3.1: Non-spec check to ensure the server will actually work for us. We need to check if
-      // any of the versions in `SUPPORTED_MATRIX_VERSIONS` are listed in the /versions response.
-      var hsVersionSet = new Set(hsVersions.raw["versions"]);
-      var supportedVersionFound = false;
-      for (var version of SUPPORTED_MATRIX_VERSIONS) {
-        if (hsVersionSet.has(version)) {
-          supportedVersionFound = true;
-          break;
+    // Step 4: Now that the homeserver looks valid, update our client config.
+    clientConfig["m.homeserver"] = {
+      state: AutoDiscovery.SUCCESS,
+      error: null,
+      base_url: hsUrl
+    };
+
+    // Step 5: Try to pull out the identity server configuration
+    let isUrl = "";
+    if (wellknown["m.identity_server"]) {
+      // We prepare a failing identity server response to save lines later
+      // in this branch.
+      const failingClientConfig = {
+        "m.homeserver": clientConfig["m.homeserver"],
+        "m.identity_server": {
+          state: AutoDiscovery.FAIL_PROMPT,
+          error: AutoDiscovery.ERROR_INVALID_IS,
+          base_url: null
         }
+      };
+
+      // Step 5a: Make sure the URL is valid *looking*. We'll make sure it
+      // points to an identity server in Step 5b.
+      isUrl = this.sanitizeWellKnownUrl(wellknown["m.identity_server"]["base_url"]);
+      if (!isUrl) {
+        logger.error("Invalid base_url for m.identity_server");
+        failingClientConfig["m.identity_server"].error = AutoDiscovery.ERROR_INVALID_IS_BASE_URL;
+        return Promise.resolve(failingClientConfig);
       }
-      if (!supportedVersionFound) {
-        logger.error("Homeserver does not meet version requirements");
-        clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_UNSUPPORTED_HOMESERVER_SPEC_VERSION;
 
-        // Supply the base_url to the caller because they may be ignoring liveliness
-        // errors, like this one.
-        clientConfig["m.homeserver"].base_url = hsUrl;
-        return Promise.resolve(clientConfig);
+      // Step 5b: Verify there is an identity server listening on the provided
+      // URL.
+      const isResponse = await this.fetchWellKnownObject(`${isUrl}/_matrix/identity/v2`);
+      if (!isResponse?.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
+        logger.error("Invalid /v2 response");
+        failingClientConfig["m.identity_server"].error = AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
+
+        // Supply the base_url to the caller because they may be ignoring
+        // liveliness errors, like this one.
+        failingClientConfig["m.identity_server"].base_url = isUrl;
+        return Promise.resolve(failingClientConfig);
       }
+    }
 
-      // Step 4: Now that the homeserver looks valid, update our client config.
-      clientConfig["m.homeserver"] = {
+    // Step 6: Now that the identity server is valid, or never existed,
+    // populate the IS section.
+    if (isUrl && isUrl.toString().length > 0) {
+      clientConfig["m.identity_server"] = {
         state: AutoDiscovery.SUCCESS,
         error: null,
-        base_url: hsUrl
+        base_url: isUrl
       };
+    }
 
-      // Step 5: Try to pull out the identity server configuration
-      var isUrl = "";
-      if (wellknown["m.identity_server"]) {
-        // We prepare a failing identity server response to save lines later
-        // in this branch.
-        var failingClientConfig = {
-          "m.homeserver": clientConfig["m.homeserver"],
-          "m.identity_server": {
-            state: AutoDiscovery.FAIL_PROMPT,
-            error: AutoDiscovery.ERROR_INVALID_IS,
-            base_url: null
-          }
-        };
-
-        // Step 5a: Make sure the URL is valid *looking*. We'll make sure it
-        // points to an identity server in Step 5b.
-        isUrl = _this.sanitizeWellKnownUrl(wellknown["m.identity_server"]["base_url"]);
-        if (!isUrl) {
-          logger.error("Invalid base_url for m.identity_server");
-          failingClientConfig["m.identity_server"].error = AutoDiscovery.ERROR_INVALID_IS_BASE_URL;
-          return Promise.resolve(failingClientConfig);
-        }
-
-        // Step 5b: Verify there is an identity server listening on the provided
-        // URL.
-        var isResponse = yield _this.fetchWellKnownObject("".concat(isUrl, "/_matrix/identity/v2"));
-        if (!(isResponse !== null && isResponse !== void 0 && isResponse.raw) || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
-          logger.error("Invalid /v2 response");
-          failingClientConfig["m.identity_server"].error = AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
-
-          // Supply the base_url to the caller because they may be ignoring
-          // liveliness errors, like this one.
-          failingClientConfig["m.identity_server"].base_url = isUrl;
-          return Promise.resolve(failingClientConfig);
+    // Step 7: Copy any other keys directly into the clientConfig. This is for
+    // things like custom configuration of services.
+    Object.keys(wellknown).forEach(k => {
+      if (k === "m.homeserver" || k === "m.identity_server") {
+        // Only copy selected parts of the config to avoid overwriting
+        // properties computed by the validation logic above.
+        const notProps = ["error", "state", "base_url"];
+        for (const prop of Object.keys(wellknown[k])) {
+          if (notProps.includes(prop)) continue;
+          // @ts-ignore - ts gets unhappy as we're mixing types here
+          clientConfig[k][prop] = wellknown[k][prop];
         }
+      } else {
+        // Just copy the whole thing over otherwise
+        clientConfig[k] = wellknown[k];
       }
+    });
 
-      // Step 6: Now that the identity server is valid, or never existed,
-      // populate the IS section.
-      if (isUrl && isUrl.toString().length > 0) {
-        clientConfig["m.identity_server"] = {
-          state: AutoDiscovery.SUCCESS,
-          error: null,
-          base_url: isUrl
-        };
-      }
-
-      // Step 7: Copy any other keys directly into the clientConfig. This is for
-      // things like custom configuration of services.
-      Object.keys(wellknown).forEach(k => {
-        if (k === "m.homeserver" || k === "m.identity_server") {
-          // Only copy selected parts of the config to avoid overwriting
-          // properties computed by the validation logic above.
-          var notProps = ["error", "state", "base_url"];
-          for (var prop of Object.keys(wellknown[k])) {
-            if (notProps.includes(prop)) continue;
-            // @ts-ignore - ts gets unhappy as we're mixing types here
-            clientConfig[k][prop] = wellknown[k][prop];
-          }
-        } else {
-          // Just copy the whole thing over otherwise
-          clientConfig[k] = wellknown[k];
-        }
-      });
-
-      // Step 8: Give the config to the caller (finally)
-      return Promise.resolve(clientConfig);
-    })();
+    // Step 8: Give the config to the caller (finally)
+    return Promise.resolve(clientConfig);
   }
 
   /**
@@ -229,66 +224,63 @@ export class AutoDiscovery {
    * configuration, which may include error states. Rejects on unexpected
    * failure, not when discovery fails.
    */
-  static findClientConfig(domain) {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      if (!domain || typeof domain !== "string" || domain.length === 0) {
-        throw new Error("'domain' must be a string of non-zero length");
-      }
+  static async findClientConfig(domain) {
+    if (!domain || typeof domain !== "string" || domain.length === 0) {
+      throw new Error("'domain' must be a string of non-zero length");
+    }
 
-      // We use a .well-known lookup for all cases. According to the spec, we
-      // can do other discovery mechanisms if we want such as custom lookups
-      // however we won't bother with that here (mostly because the spec only
-      // supports .well-known right now).
-      //
-      // By using .well-known, we need to ensure we at least pull out a URL
-      // for the homeserver. We don't really need an identity server configuration
-      // but will return one anyways (with state PROMPT) to make development
-      // easier for clients. If we can't get a homeserver URL, all bets are
-      // off on the rest of the config and we'll assume it is invalid too.
+    // We use a .well-known lookup for all cases. According to the spec, we
+    // can do other discovery mechanisms if we want such as custom lookups
+    // however we won't bother with that here (mostly because the spec only
+    // supports .well-known right now).
+    //
+    // By using .well-known, we need to ensure we at least pull out a URL
+    // for the homeserver. We don't really need an identity server configuration
+    // but will return one anyways (with state PROMPT) to make development
+    // easier for clients. If we can't get a homeserver URL, all bets are
+    // off on the rest of the config and we'll assume it is invalid too.
 
-      // We default to an error state to make the first few checks easier to
-      // write. We'll update the properties of this object over the duration
-      // of this function.
-      var clientConfig = {
-        "m.homeserver": {
-          state: AutoDiscovery.FAIL_ERROR,
-          error: AutoDiscovery.ERROR_INVALID,
-          base_url: null
-        },
-        "m.identity_server": {
-          // Technically, we don't have a problem with the identity server
-          // config at this point.
+    // We default to an error state to make the first few checks easier to
+    // write. We'll update the properties of this object over the duration
+    // of this function.
+    const clientConfig = {
+      "m.homeserver": {
+        state: AutoDiscovery.FAIL_ERROR,
+        error: AutoDiscovery.ERROR_INVALID,
+        base_url: null
+      },
+      "m.identity_server": {
+        // Technically, we don't have a problem with the identity server
+        // config at this point.
+        state: AutoDiscovery.PROMPT,
+        error: null,
+        base_url: null
+      }
+    };
+
+    // Step 1: Actually request the .well-known JSON file and make sure it
+    // at least has a homeserver definition.
+    const domainWithProtocol = domain.includes("://") ? domain : `https://${domain}`;
+    const wellknown = await this.fetchWellKnownObject(`${domainWithProtocol}/.well-known/matrix/client`);
+    if (!wellknown || wellknown.action !== AutoDiscoveryAction.SUCCESS) {
+      logger.error("No response or error when parsing .well-known");
+      if (wellknown.reason) logger.error(wellknown.reason);
+      if (wellknown.action === AutoDiscoveryAction.IGNORE) {
+        clientConfig["m.homeserver"] = {
           state: AutoDiscovery.PROMPT,
           error: null,
           base_url: null
-        }
-      };
-
-      // Step 1: Actually request the .well-known JSON file and make sure it
-      // at least has a homeserver definition.
-      var domainWithProtocol = domain.includes("://") ? domain : "https://".concat(domain);
-      var wellknown = yield _this2.fetchWellKnownObject("".concat(domainWithProtocol, "/.well-known/matrix/client"));
-      if (!wellknown || wellknown.action !== AutoDiscoveryAction.SUCCESS) {
-        logger.error("No response or error when parsing .well-known");
-        if (wellknown.reason) logger.error(wellknown.reason);
-        if (wellknown.action === AutoDiscoveryAction.IGNORE) {
-          clientConfig["m.homeserver"] = {
-            state: AutoDiscovery.PROMPT,
-            error: null,
-            base_url: null
-          };
-        } else {
-          // this can only ever be FAIL_PROMPT at this point.
-          clientConfig["m.homeserver"].state = AutoDiscovery.FAIL_PROMPT;
-          clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID;
-        }
-        return Promise.resolve(clientConfig);
+        };
+      } else {
+        // this can only ever be FAIL_PROMPT at this point.
+        clientConfig["m.homeserver"].state = AutoDiscovery.FAIL_PROMPT;
+        clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID;
       }
+      return Promise.resolve(clientConfig);
+    }
 
-      // Step 2: Validate and parse the config
-      return AutoDiscovery.fromDiscoveryConfig(wellknown.raw);
-    })();
+    // Step 2: Validate and parse the config
+    return AutoDiscovery.fromDiscoveryConfig(wellknown.raw);
   }
 
   /**
@@ -299,17 +291,13 @@ export class AutoDiscovery {
    * @returns Promise which resolves to the domain's client config. Can
    * be an empty object.
    */
-  static getRawClientConfig(domain) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      var _response$raw;
-      if (!domain || typeof domain !== "string" || domain.length === 0) {
-        throw new Error("'domain' must be a string of non-zero length");
-      }
-      var response = yield _this3.fetchWellKnownObject("https://".concat(domain, "/.well-known/matrix/client"));
-      if (!response) return {};
-      return (_response$raw = response.raw) !== null && _response$raw !== void 0 ? _response$raw : {};
-    })();
+  static async getRawClientConfig(domain) {
+    if (!domain || typeof domain !== "string" || domain.length === 0) {
+      throw new Error("'domain' must be a string of non-zero length");
+    }
+    const response = await this.fetchWellKnownObject(`https://${domain}/.well-known/matrix/client`);
+    if (!response) return {};
+    return response.raw ?? {};
   }
 
   /**
@@ -323,18 +311,17 @@ export class AutoDiscovery {
   static sanitizeWellKnownUrl(url) {
     if (!url) return false;
     try {
-      var _parsed;
-      var parsed;
+      let parsed;
       try {
         parsed = new URL(url);
       } catch (e) {
         logger.error("Could not parse url", e);
       }
-      if (!((_parsed = parsed) !== null && _parsed !== void 0 && _parsed.hostname)) return false;
+      if (!parsed?.hostname) return false;
       if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
-      var port = parsed.port ? ":".concat(parsed.port) : "";
-      var path = parsed.pathname ? parsed.pathname : "";
-      var saferUrl = "".concat(parsed.protocol, "//").concat(parsed.hostname).concat(port).concat(path);
+      const port = parsed.port ? `:${parsed.port}` : "";
+      const path = parsed.pathname ? parsed.pathname : "";
+      let saferUrl = `${parsed.protocol}//${parsed.hostname}${port}${path}`;
       if (saferUrl.endsWith("/")) {
         saferUrl = saferUrl.substring(0, saferUrl.length - 1);
       }
@@ -370,56 +357,54 @@ export class AutoDiscovery {
    * @returns Promise which resolves to the returned state.
    * @internal
    */
-  static fetchWellKnownObject(url) {
-    return _asyncToGenerator(function* () {
-      var response;
-      try {
-        response = yield AutoDiscovery.fetch(url, {
-          method: Method.Get,
-          signal: timeoutSignal(5000)
-        });
-        if (response.status === 404) {
-          return {
-            raw: {},
-            action: AutoDiscoveryAction.IGNORE,
-            reason: AutoDiscovery.ERROR_MISSING_WELLKNOWN
-          };
-        }
-        if (response.status !== 200) {
-          return {
-            raw: {},
-            action: AutoDiscoveryAction.FAIL_PROMPT,
-            reason: "General failure"
-          };
-        }
-      } catch (err) {
-        var error = err;
-        var reason = "";
-        if (typeof error === "object") {
-          reason = error === null || error === void 0 ? void 0 : error.message;
-        }
+  static async fetchWellKnownObject(url) {
+    let response;
+    try {
+      response = await AutoDiscovery.fetch(url, {
+        method: Method.Get,
+        signal: timeoutSignal(5000)
+      });
+      if (response.status === 404) {
         return {
-          error,
           raw: {},
-          action: AutoDiscoveryAction.FAIL_PROMPT,
-          reason: reason || "General failure"
+          action: AutoDiscoveryAction.IGNORE,
+          reason: AutoDiscovery.ERROR_MISSING_WELLKNOWN
         };
       }
-      try {
-        return {
-          raw: yield response.json(),
-          action: AutoDiscoveryAction.SUCCESS
-        };
-      } catch (err) {
-        var _error = err;
+      if (response.status !== 200) {
         return {
-          error: _error,
           raw: {},
           action: AutoDiscoveryAction.FAIL_PROMPT,
-          reason: (_error === null || _error === void 0 ? void 0 : _error.name) === "SyntaxError" ? AutoDiscovery.ERROR_INVALID_JSON : AutoDiscovery.ERROR_INVALID
+          reason: "General failure"
         };
       }
-    })();
+    } catch (err) {
+      const error = err;
+      let reason = "";
+      if (typeof error === "object") {
+        reason = error?.message;
+      }
+      return {
+        error,
+        raw: {},
+        action: AutoDiscoveryAction.FAIL_PROMPT,
+        reason: reason || "General failure"
+      };
+    }
+    try {
+      return {
+        raw: await response.json(),
+        action: AutoDiscoveryAction.SUCCESS
+      };
+    } catch (err) {
+      const error = err;
+      return {
+        error,
+        raw: {},
+        action: AutoDiscoveryAction.FAIL_PROMPT,
+        reason: error?.name === "SyntaxError" ? AutoDiscovery.ERROR_INVALID_JSON : AutoDiscovery.ERROR_INVALID
+      };
+    }
   }
 }
 // Dev note: the constants defined here are related to but not