@jsenv/core 27.5.1 → 27.6.0

package/dist/js/html_supervisor_installer.js

@@ -10,213 +10,308 @@ const unevalException = value => {
   });
 };
 
-const JSENV_ERROR_OVERLAY_TAGNAME = "jsenv-error-overlay";
-const displayErrorInDocument = (error, {
+const formatError = (error, {
   rootDirectoryUrl,
+  errorBaseUrl,
   openInEditor,
   url,
   line,
-  column,
-  reportedBy,
-  requestedRessource
+  column
 }) => {
-  document.querySelectorAll(JSENV_ERROR_OVERLAY_TAGNAME).forEach(node => {
-    node.parentNode.removeChild(node);
-  });
-  const {
-    theme,
-    title,
+  let {
     message,
-    stack,
-    tip
-  } = errorToHTML(error, {
+    stack
+  } = normalizeErrorParts(error);
+  let errorDetailsPromiseReference = {
+    current: null
+  };
+  let tip = `Reported by the browser while executing <code>${window.location.pathname}${window.location.search}</code>.`;
+  let errorUrlSite;
+  const errorMeta = extractErrorMeta(error, {
     url,
     line,
-    column,
-    reportedBy,
-    requestedRessource
-  });
-  let jsenvErrorOverlay = new JsenvErrorOverlay({
-    theme,
-    title,
-    text: createErrorText({
-      rootDirectoryUrl,
-      openInEditor,
-      message,
-      stack
-    }),
-    tip
+    column
   });
-  document.body.appendChild(jsenvErrorOverlay);
 
-  const removeErrorOverlay = () => {
-    if (jsenvErrorOverlay && jsenvErrorOverlay.parentNode) {
-      document.body.removeChild(jsenvErrorOverlay);
-      jsenvErrorOverlay = null;
+  const resolveUrlSite = ({
+    url,
+    line,
+    column
+  }) => {
+    const inlineUrlMatch = url.match(/@L([0-9]+)C([0-9]+)\-L([0-9]+)C([0-9]+)(\.[\w]+)$/);
+
+    if (inlineUrlMatch) {
+      const htmlUrl = url.slice(0, inlineUrlMatch.index);
+      const tagLineStart = parseInt(inlineUrlMatch[1]);
+      const tagColumnStart = parseInt(inlineUrlMatch[2]);
+      const tagLineEnd = parseInt(inlineUrlMatch[3]);
+      const tagColumnEnd = parseInt(inlineUrlMatch[4]);
+      const extension = inlineUrlMatch[5];
+      url = htmlUrl;
+      line = tagLineStart + (line === undefined ? 0 : parseInt(line)); // stackTrace formatted by V8 (chrome)
+
+      if (Error.captureStackTrace) {
+        line--;
+      }
+
+      if (errorMeta.type === "dynamic_import_syntax_error") {
+        // syntax error on inline script need line-1 for some reason
+        if (Error.captureStackTrace) {
+          line--;
+        } else {
+          // firefox and safari need line-2
+          line -= 2;
+        }
+      }
+
+      column = tagColumnStart + (column === undefined ? 0 : parseInt(column));
+      const fileUrl = resolveFileUrl(url);
+      return {
+        isInline: true,
+        originalUrl: `${fileUrl}@L${tagLineStart}C${tagColumnStart}-L${tagLineEnd}C${tagColumnEnd}${extension}`,
+        url: fileUrl,
+        line,
+        column
+      };
     }
+
+    return {
+      isInline: false,
+      url: resolveFileUrl(url),
+      line,
+      column
+    };
   };
 
-  if (window.__reloader__) {
-    window.__reloader__.onstatuschange = () => {
-      if (window.__reloader__.status === "reloading") {
-        removeErrorOverlay();
+  const resolveFileUrl = url => {
+    let urlObject = new URL(url);
+
+    if (urlObject.origin === window.origin) {
+      urlObject = new URL(`${urlObject.pathname.slice(1)}${urlObject.search}`, rootDirectoryUrl);
+    }
+
+    if (urlObject.href.startsWith("file:")) {
+      const atFsIndex = urlObject.pathname.indexOf("/@fs/");
+
+      if (atFsIndex > -1) {
+        const afterAtFs = urlObject.pathname.slice(atFsIndex + "/@fs/".length);
+        return new URL(afterAtFs, "file:///").href;
       }
-    };
+    }
+
+    return urlObject.href;
+  };
+
+  const generateClickableText = text => {
+    const textWithHtmlLinks = makeLinksClickable(text, {
+      createLink: (url, {
+        line,
+        column
+      }) => {
+        const urlSite = resolveUrlSite({
+          url,
+          line,
+          column
+        });
+
+        if (!errorUrlSite && text === stack) {
+          onErrorLocated(urlSite);
+        }
+
+        if (errorBaseUrl) {
+          if (urlSite.url.startsWith(rootDirectoryUrl)) {
+            urlSite.url = `${errorBaseUrl}${urlSite.url.slice(rootDirectoryUrl.length)}`;
+          } else {
+            urlSite.url = "file:///mocked_for_snapshots";
+          }
+        }
+
+        const urlWithLineAndColumn = formatUrlWithLineAndColumn(urlSite);
+        return {
+          href: url.startsWith("file:") && openInEditor ? `javascript:window.fetch('/__open_in_editor__/${urlWithLineAndColumn}')` : urlSite.url,
+          text: urlWithLineAndColumn
+        };
+      }
+    });
+    return textWithHtmlLinks;
+  };
+
+  const formatErrorText = ({
+    message,
+    stack,
+    codeFrame
+  }) => {
+    let text;
+
+    if (message && stack) {
+      text = `${generateClickableText(message)}\n${generateClickableText(stack)}`;
+    } else if (stack) {
+      text = generateClickableText(stack);
+    } else {
+      text = generateClickableText(message);
+    }
+
+    if (codeFrame) {
+      text += `\n\n${generateClickableText(codeFrame)}`;
+    }
+
+    return text;
+  };
+
+  const onErrorLocated = urlSite => {
+    errorUrlSite = urlSite;
+
+    errorDetailsPromiseReference.current = (async () => {
+      if (errorMeta.type === "dynamic_import_fetch_error") {
+        const response = await window.fetch(`/__get_error_cause__/${urlSite.isInline ? urlSite.originalUrl : urlSite.url}`);
+
+        if (response.status !== 200) {
+          return null;
+        }
+
+        const causeInfo = await response.json();
+
+        if (!causeInfo) {
+          return null;
+        }
+
+        const causeText = causeInfo.code === "NOT_FOUND" ? formatErrorText({
+          message: causeInfo.reason,
+          stack: causeInfo.codeFrame
+        }) : formatErrorText({
+          message: causeInfo.stack,
+          stack: causeInfo.codeFrame
+        });
+        return {
+          cause: causeText
+        };
+      }
+
+      if (urlSite.line !== undefined) {
+        const response = await window.fetch(`/__get_code_frame__/${formatUrlWithLineAndColumn(urlSite)}`);
+        const codeFrame = await response.text();
+        return {
+          codeFrame: formatErrorText({
+            message: codeFrame
+          })
+        };
+      }
+
+      return null;
+    })();
+  }; // error.stack is more reliable than url/line/column reported on window error events
+  // so use it only when error.stack is not available
+
+
+  if (url && !stack && // ignore window.reportError() it gives no valuable info
+  !url.endsWith("html_supervisor_installer.js")) {
+    onErrorLocated(resolveUrlSite({
+      url,
+      line,
+      column
+    }));
+  } else if (errorMeta.url) {
+    onErrorLocated(resolveUrlSite(errorMeta));
   }
 
-  return removeErrorOverlay;
+  return {
+    theme: error && error.cause && error.cause.code === "PARSE_ERROR" ? "light" : "dark",
+    title: "An error occured",
+    text: formatErrorText({
+      message,
+      stack
+    }),
+    tip: `${tip}
+    <br />
+    Click outside to close.`,
+    errorDetailsPromise: errorDetailsPromiseReference.current
+  };
 };
 
-const createErrorText = ({
-  rootDirectoryUrl,
-  openInEditor,
-  message,
-  stack
+const extractErrorMeta = (error, {
+  line
 }) => {
-  if (message && stack) {
-    return `${replaceLinks(message, {
-      rootDirectoryUrl,
-      openInEditor
-    })}\n${replaceLinks(stack, {
-      rootDirectoryUrl,
-      openInEditor
-    })}`;
+  if (!error) {
+    return {};
   }
 
-  if (stack) {
-    return replaceLinks(stack, {
-      rootDirectoryUrl,
-      openInEditor
-    });
+  const {
+    message
+  } = error;
+
+  if (!message) {
+    return {};
   }
 
-  return replaceLinks(message, {
-    rootDirectoryUrl,
-    openInEditor
-  });
-};
+  {
+    // chrome
+    if (message.includes("does not provide an export named")) {
+      return {
+        type: "dynamic_import_export_missing"
+      };
+    } // firefox
 
-class JsenvErrorOverlay extends HTMLElement {
-  constructor({
-    theme,
-    title,
-    text,
-    tip
-  }) {
-    super();
-    this.root = this.attachShadow({
-      mode: "open"
-    });
-    this.root.innerHTML = overlayHtml;
 
-    this.root.querySelector(".backdrop").onclick = () => {
-      if (!this.parentNode) {
-        // not in document anymore
-        return;
-      }
+    if (message.startsWith("import not found:")) {
+      return {
+        type: "dynamic_import_export_missing",
+        browser: "firefox"
+      };
+    } // safari
 
-      this.root.querySelector(".backdrop").onclick = null;
-      this.parentNode.removeChild(this);
-    };
 
-    this.root.querySelector(".overlay").setAttribute("data-theme", theme);
-    this.root.querySelector(".title").innerHTML = title;
-    this.root.querySelector(".text").innerHTML = text;
-    this.root.querySelector(".tip").innerHTML = tip;
+    if (message.startsWith("import binding name")) {
+      return {
+        type: "dynamic_import_export_missing"
+      };
+    }
   }
 
-}
-
-if (customElements && !customElements.get(JSENV_ERROR_OVERLAY_TAGNAME)) {
-  customElements.define(JSENV_ERROR_OVERLAY_TAGNAME, JsenvErrorOverlay);
-}
+  {
+    if (error.name === "SyntaxError" && typeof line === "number") {
+      return {
+        type: "dynamic_import_syntax_error"
+      };
+    }
+  }
 
-const overlayHtml = `
-<style>
-:host {
-  position: fixed;
-  z-index: 99999;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  overflow-y: scroll;
-  margin: 0;
-  background: rgba(0, 0, 0, 0.66);
-}
+  {
+    // chrome
+    if (message.startsWith("Failed to fetch dynamically imported module: ")) {
+      const url = error.message.slice("Failed to fetch dynamically imported module: ".length);
+      return {
+        type: "dynamic_import_fetch_error",
+        url
+      };
+    } // firefox
 
-.backdrop {
-  position: absolute;
-  left: 0;
-  right: 0;
-  top: 0;
-  bottom: 0;
-}
 
-.overlay {
-  position: relative;
-  background: rgba(0, 0, 0, 0.95);
-  width: 800px;
-  margin: 30px auto;
-  padding: 25px 40px;
-  padding-top: 0;
-  overflow: hidden; /* for h1 margins */
-  border-radius: 4px 8px;
-  box-shadow: 0 20px 40px rgb(0 0 0 / 30%), 0 15px 12px rgb(0 0 0 / 20%);
-  box-sizing: border-box;
-  font-family: monospace;
-  direction: ltr;
-}
+    if (message === "error loading dynamically imported module") {
+      return {
+        type: "dynamic_import_fetch_error"
+      };
+    } // safari
 
-h1 {
-  color: red;
-  text-align: center;
-}
 
-pre {
-  overflow: auto;
-  max-width: 100%;
-  /* padding is nice + prevents scrollbar from hiding the text behind it */
-  /* does not work nicely on firefox though https://bugzilla.mozilla.org/show_bug.cgi?id=748518 */
-  padding: 20px; 
-}
-
-.tip {
-  border-top: 1px solid #999;
-  padding-top: 12px;
-}
+    if (message === "Importing a module script failed.") {
+      return {
+        type: "dynamic_import_fetch_error"
+      };
+    }
+  }
 
-[data-theme="dark"] {
-  color: #999;
-}
-[data-theme="dark"] pre {
-  background: #111;
-  border: 1px solid #333;
-  color: #eee;
-}
+  return {};
+};
 
-[data-theme="light"] {
-  color: #EEEEEE;
-}
-[data-theme="light"] pre {
-  background: #1E1E1E;
-  border: 1px solid white;
-  color: #EEEEEE;
-}
+const formatUrlWithLineAndColumn = ({
+  url,
+  line,
+  column
+}) => {
+  return line === undefined && column === undefined ? url : column === undefined ? `${url}:${line}` : `${url}:${line}:${column}`;
+};
 
-pre a {
-  color: inherit;
-}
-</style>
-<div class="backdrop"></div>
-<div class="overlay">
-  <h1 class="title"></h1>
-  <pre class="text"></pre>
-  <div class="tip"></div>
-</div>
-`;
-
-const parseErrorInfo = error => {
+const normalizeErrorParts = error => {
   if (error === undefined) {
     return {
       message: "undefined"
@@ -294,56 +389,8 @@ const getErrorStackWithoutErrorMessage = error => {
   return stack;
 };
 
-const errorToHTML = (error, {
-  url,
-  line,
-  column,
-  reportedBy,
-  requestedRessource
-}) => {
-  let {
-    message,
-    stack
-  } = parseErrorInfo(error);
-
-  if (url) {
-    if (!stack || error && error.name === "SyntaxError") {
-      stack = `  at ${appendLineAndColumn(url, {
-        line,
-        column
-      })}`;
-    }
-  }
-
-  let tip = formatTip({
-    reportedBy,
-    requestedRessource
-  });
-  return {
-    theme: error && error.cause && error.cause.code === "PARSE_ERROR" ? "light" : "dark",
-    title: "An error occured",
-    message,
-    stack,
-    tip: `${tip}
-<br />
-Click outside to close.`
-  };
-};
-
-const formatTip = ({
-  reportedBy,
-  requestedRessource
-}) => {
-  if (reportedBy === "browser") {
-    return `Reported by the browser while executing <code>${window.location.pathname}${window.location.search}</code>.`;
-  }
-
-  return `Reported by the server while serving <code>${requestedRessource}</code>`;
-};
-
-const replaceLinks = (string, {
-  rootDirectoryUrl,
-  openInEditor
+const makeLinksClickable = (string, {
+  createLink = url => url
 }) => {
   // normalize line breaks
   string = string.replace(/\n/g, "\n");
@@ -354,44 +401,16 @@ const replaceLinks = (string, {
       line,
       column
     }) => {
-      const urlObject = new URL(url);
-
-      const onFileUrl = fileUrlObject => {
-        const atFsIndex = fileUrlObject.pathname.indexOf("/@fs/");
-        let fileUrl;
-
-        if (atFsIndex > -1) {
-          const afterAtFs = fileUrlObject.pathname.slice(atFsIndex + "/@fs/".length);
-          fileUrl = new URL(afterAtFs, "file:///").href;
-        } else {
-          fileUrl = fileUrlObject.href;
-        }
-
-        fileUrl = appendLineAndColumn(fileUrl, {
-          line,
-          column
-        });
-        return link({
-          href: openInEditor ? `javascript:window.fetch('/__open_in_editor__/${fileUrl}')` : fileUrl,
-          text: fileUrl
-        });
-      };
-
-      if (urlObject.origin === window.origin) {
-        const fileUrlObject = new URL(`${urlObject.pathname.slice(1)}${urlObject.search}`, rootDirectoryUrl);
-        return onFileUrl(fileUrlObject);
-      }
-
-      if (urlObject.href.startsWith("file:")) {
-        return onFileUrl(urlObject);
-      }
-
+      const {
+        href,
+        text
+      } = createLink(url, {
+        line,
+        column
+      });
       return link({
-        href: url,
-        text: appendLineAndColumn(url, {
-          line,
-          column
-        })
+        href,
+        text
       });
     }
   });
@@ -400,21 +419,6 @@ const replaceLinks = (string, {
 
 const escapeHtml = string => {
   return string.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-};
-
-const appendLineAndColumn = (url, {
-  line,
-  column
-}) => {
-  if (line !== undefined && column !== undefined) {
-    return `${url}:${line}:${column}`;
-  }
-
-  if (line !== undefined) {
-    return `${url}:${line}`;
-  }
-
-  return url;
 }; // `Error: yo
 // at Object.execute (http://127.0.0.1:57300/build/src/__test__/file-throw.js:9:13)
 // at doExec (http://127.0.0.1:3000/src/__test__/file-throw.js:452:38)
@@ -481,6 +485,218 @@ const link = ({
   text = href
 }) => `<a href="${href}">${text}</a>`;
 
+const JSENV_ERROR_OVERLAY_TAGNAME = "jsenv-error-overlay";
+const displayErrorInDocument = (error, {
+  rootDirectoryUrl,
+  errorBaseUrl,
+  openInEditor,
+  url,
+  line,
+  column,
+  codeFrame
+}) => {
+  const {
+    theme,
+    title,
+    text,
+    tip,
+    errorDetailsPromise
+  } = formatError(error, {
+    rootDirectoryUrl,
+    errorBaseUrl,
+    openInEditor,
+    url,
+    line,
+    column,
+    codeFrame
+  });
+  let jsenvErrorOverlay = new JsenvErrorOverlay({
+    theme,
+    title,
+    text,
+    tip,
+    errorDetailsPromise
+  });
+  document.querySelectorAll(JSENV_ERROR_OVERLAY_TAGNAME).forEach(node => {
+    node.parentNode.removeChild(node);
+  });
+  document.body.appendChild(jsenvErrorOverlay);
+
+  const removeErrorOverlay = () => {
+    if (jsenvErrorOverlay && jsenvErrorOverlay.parentNode) {
+      document.body.removeChild(jsenvErrorOverlay);
+      jsenvErrorOverlay = null;
+    }
+  };
+
+  if (window.__reloader__) {
+    window.__reloader__.onstatuschange = () => {
+      if (window.__reloader__.status === "reloading") {
+        removeErrorOverlay();
+      }
+    };
+  }
+
+  return removeErrorOverlay;
+};
+
+class JsenvErrorOverlay extends HTMLElement {
+  constructor({
+    theme,
+    title,
+    text,
+    tip,
+    errorDetailsPromise
+  }) {
+    super();
+    this.root = this.attachShadow({
+      mode: "open"
+    });
+    this.root.innerHTML = `
+<style>
+  ${overlayCSS}
+</style>
+<div class="backdrop"></div>
+<div class="overlay" data-theme=${theme}>
+  <h1 class="title">
+    ${title}
+  </h1>
+  <pre class="text">${text}</pre>
+  <div class="tip">
+    ${tip}
+  </div>
+</div>`;
+
+    this.root.querySelector(".backdrop").onclick = () => {
+      if (!this.parentNode) {
+        // not in document anymore
+        return;
+      }
+
+      this.root.querySelector(".backdrop").onclick = null;
+      this.parentNode.removeChild(this);
+    };
+
+    if (errorDetailsPromise) {
+      errorDetailsPromise.then(errorDetails => {
+        if (!errorDetails || !this.parentNode) {
+          return;
+        }
+
+        const {
+          codeFrame,
+          cause
+        } = errorDetails;
+
+        if (codeFrame) {
+          this.root.querySelector(".text").innerHTML += `\n\n${codeFrame}`;
+        }
+
+        if (cause) {
+          const causeIndented = prefixRemainingLines(cause, "  ");
+          this.root.querySelector(".text").innerHTML += `\n  [cause]: ${causeIndented}`;
+        }
+      });
+    }
+  }
+
+}
+
+const prefixRemainingLines = (text, prefix) => {
+  const lines = text.split(/\r?\n/);
+  const firstLine = lines.shift();
+  let result = firstLine;
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    i++;
+    result += line.length ? `\n${prefix}${line}` : `\n`;
+  }
+
+  return result;
+};
+
+if (customElements && !customElements.get(JSENV_ERROR_OVERLAY_TAGNAME)) {
+  customElements.define(JSENV_ERROR_OVERLAY_TAGNAME, JsenvErrorOverlay);
+}
+
+const overlayCSS = `
+:host {
+  position: fixed;
+  z-index: 99999;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow-y: scroll;
+  margin: 0;
+  background: rgba(0, 0, 0, 0.66);
+}
+
+.backdrop {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+}
+
+.overlay {
+  position: relative;
+  background: rgba(0, 0, 0, 0.95);
+  width: 800px;
+  margin: 30px auto;
+  padding: 25px 40px;
+  padding-top: 0;
+  overflow: hidden; /* for h1 margins */
+  border-radius: 4px 8px;
+  box-shadow: 0 20px 40px rgb(0 0 0 / 30%), 0 15px 12px rgb(0 0 0 / 20%);
+  box-sizing: border-box;
+  font-family: monospace;
+  direction: ltr;
+}
+
+h1 {
+  color: red;
+  text-align: center;
+}
+
+pre {
+  overflow: auto;
+  max-width: 100%;
+  /* padding is nice + prevents scrollbar from hiding the text behind it */
+  /* does not work nicely on firefox though https://bugzilla.mozilla.org/show_bug.cgi?id=748518 */
+  padding: 20px; 
+}
+
+.tip {
+  border-top: 1px solid #999;
+  padding-top: 12px;
+}
+
+[data-theme="dark"] {
+  color: #999;
+}
+[data-theme="dark"] pre {
+  background: #111;
+  border: 1px solid #333;
+  color: #eee;
+}
+
+[data-theme="light"] {
+  color: #EEEEEE;
+}
+[data-theme="light"] pre {
+  background: #1E1E1E;
+  border: 1px solid white;
+  color: #EEEEEE;
+}
+
+pre a {
+  color: inherit;
+}`;
+
 const {
   Notification
 } = window;
@@ -514,6 +730,7 @@ const installHtmlSupervisor = ({
   logs,
   measurePerf,
   errorOverlay,
+  errorBaseUrl,
   openInEditor
 }) => {
 
@@ -601,14 +818,18 @@ const installHtmlSupervisor = ({
     let completed;
     let result;
     let error;
+    const urlObject = new URL(src, window.location);
 
-    try {
-      const urlObject = new URL(src, window.location);
+    if (reload) {
+      urlObject.searchParams.set("hmr", Date.now());
+    }
 
-      if (reload) {
-        urlObject.searchParams.set("hmr", Date.now());
-      }
+    __html_supervisor__.currentExecution = {
+      type: type === "module" ? "dynamic_import" : "script_injection",
+      url: urlObject.href
+    };
 
+    try {
       result = await execute(urlObject.href);
       completed = true;
     } catch (e) {
@@ -629,6 +850,7 @@ const installHtmlSupervisor = ({
         console.groupEnd();
       }
 
+      __html_supervisor__.currentExecution = null;
       return;
     }
 
@@ -656,6 +878,8 @@ const installHtmlSupervisor = ({
     if (logs) {
       console.groupEnd();
     }
+
+    __html_supervisor__.currentExecution = null;
   };
 
   const classicExecutionQueue = createExecutionQueue(performExecution);
@@ -744,6 +968,21 @@ const installHtmlSupervisor = ({
   });
 
   if (errorOverlay) {
+    const onErrorReportedByBrowser = (error, {
+      url,
+      line,
+      column
+    }) => {
+      displayErrorInDocument(error, {
+        rootDirectoryUrl,
+        errorBaseUrl,
+        openInEditor,
+        url,
+        line,
+        column
+      });
+    };
+
     window.addEventListener("error", errorEvent => {
       if (!errorEvent.isTrusted) {
         // ignore custom error event (not sent by browser)
@@ -751,76 +990,17 @@ const installHtmlSupervisor = ({
       }
 
       const {
-        error
+        error,
+        filename,
+        lineno,
+        colno
       } = errorEvent;
-      displayErrorInDocument(error, {
-        rootDirectoryUrl,
-        openInEditor,
-        url: errorEvent.filename,
-        line: errorEvent.lineno,
-        column: errorEvent.colno,
-        reportedBy: "browser"
+      onErrorReportedByBrowser(error, {
+        url: filename,
+        line: lineno,
+        column: colno
       });
     });
-
-    if (window.__server_events__) {
-      const isExecuting = () => {
-        if (pendingExecutionCount > 0) {
-          return true;
-        }
-
-        if (document.readyState === "loading" || document.readyState === "interactive") {
-          return true;
-        }
-
-        if (window.__reloader__ && window.__reloader__.status === "reloading") {
-          return true;
-        }
-
-        return false;
-      };
-
-      window.__server_events__.addEventCallbacks({
-        error_while_serving_file: serverErrorEvent => {
-          if (!isExecuting()) {
-            return;
-          }
-
-          const {
-            message,
-            stack,
-            traceUrl,
-            traceLine,
-            traceColumn,
-            traceMessage,
-            requestedRessource,
-            isFaviconAutoRequest
-          } = JSON.parse(serverErrorEvent.data);
-
-          if (isFaviconAutoRequest) {
-            return;
-          } // setTimeout is to ensure the error
-          // dispatched on window by browser is displayed first,
-          // then the server error replaces it (because it contains more information)
-
-
-          setTimeout(() => {
-            displayErrorInDocument({
-              message,
-              stack: stack && traceMessage ? `${stack}\n\n${traceMessage}` : stack ? stack : traceMessage ? `\n${traceMessage}` : ""
-            }, {
-              rootDirectoryUrl,
-              openInEditor,
-              url: traceUrl,
-              line: traceLine,
-              column: traceColumn,
-              reportedBy: "server",
-              requestedRessource
-            });
-          }, 10);
-        }
-      });
-    }
   }
 };