@rspack/dev-server 1.2.1 → 2.0.0-beta.2

package/client/overlay.js

@@ -1,228 +1,221 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack-dev-server
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
- */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-// The error overlay is inspired (and mostly copied) from Create React App (https://github.com/facebookincubator/create-react-app)
-// They, in turn, got inspired by webpack-hot-middleware (https://github.com/glenjamin/webpack-hot-middleware).
-import ansiHTML from './utils/ansiHTML';
-var getCodePoint = !!String.prototype.codePointAt
-    ? function (input, position) {
-        return input.codePointAt(position);
+import ansiHTML from "./utils/ansiHTML.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
     }
-    : function (input, position) {
-        return (input.charCodeAt(position) - 0xd800) * 0x400 +
-            input.charCodeAt(position + 1) -
-            0xdc00 +
-            0x10000;
-    };
-var replaceUsingRegExp = function (macroText, macroRegExp, macroReplacer) {
+    return target;
+}
+function overlay_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else overlay_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+const getCodePoint = String.prototype.codePointAt ? (input, position)=>input.codePointAt(position) : (input, position)=>(input.charCodeAt(position) - 0xd800) * 0x400 + input.charCodeAt(position + 1) - 0xdc00 + 0x10000;
+const replaceUsingRegExp = (macroText, macroRegExp, macroReplacer)=>{
     macroRegExp.lastIndex = 0;
-    var replaceMatch = macroRegExp.exec(macroText);
-    var replaceResult;
+    let replaceMatch = macroRegExp.exec(macroText);
+    let replaceResult;
     if (replaceMatch) {
         replaceResult = '';
-        var replaceLastIndex = 0;
+        let replaceLastIndex = 0;
         do {
-            if (replaceLastIndex !== replaceMatch.index) {
-                replaceResult += macroText.slice(replaceLastIndex, replaceMatch.index);
-            }
-            var replaceInput = replaceMatch[0];
+            if (replaceLastIndex !== replaceMatch.index) replaceResult += macroText.slice(replaceLastIndex, replaceMatch.index);
+            const replaceInput = replaceMatch[0];
             replaceResult += macroReplacer(replaceInput);
             replaceLastIndex = replaceMatch.index + replaceInput.length;
-        } while ((replaceMatch = macroRegExp.exec(macroText)));
-        if (replaceLastIndex !== macroText.length) {
-            replaceResult += macroText.slice(replaceLastIndex);
-        }
-    }
-    else {
-        replaceResult = macroText;
-    }
+        }while (replaceMatch = macroRegExp.exec(macroText));
+        if (replaceLastIndex !== macroText.length) replaceResult += macroText.slice(replaceLastIndex);
+    } else replaceResult = macroText;
     return replaceResult;
 };
-var references = {
+const references = {
     '<': '&lt;',
     '>': '&gt;',
     '"': '&quot;',
     "'": '&apos;',
-    '&': '&amp;',
+    '&': '&amp;'
 };
 function encode(text) {
-    if (!text) {
-        return '';
-    }
-    return replaceUsingRegExp(text, /[<>'"&]/g, function (input) {
-        var result = references[input];
+    if (!text) return '';
+    return replaceUsingRegExp(text, /[<>'"&]/g, (input)=>{
+        let result = references[input];
         if (!result) {
-            var code = input.length > 1 ? getCodePoint(input, 0) : input.charCodeAt(0);
-            result = "&#".concat(code, ";");
+            const code = input.length > 1 ? getCodePoint(input, 0) : input.charCodeAt(0);
+            result = `&#${code};`;
         }
         return result;
     });
 }
-/**
- * A simplified `createMachine` from `@xstate/fsm` with the following differences:
- * - the returned machine is technically a "service". No `interpret(machine).start()` is needed.
- * - the state definition only support `on` and target must be declared with { target: 'nextState', actions: [] } explicitly.
- * - event passed to `send` must be an object with `type` property.
- * - actions implementation will be [assign action](https://xstate.js.org/docs/guides/context.html#assign-action) if you return any value.
- * Do not return anything if you just want to invoke side effect.
- *
- * The goal of this custom function is to avoid installing the entire `'xstate/fsm'` package, while enabling modeling using
- * state machine. You can copy the first parameter into the editor at https://stately.ai/viz to visualize the state machine.
- */
-function createMachine(_a, _b) {
-    var states = _a.states, context = _a.context, initial = _a.initial;
-    var actions = _b.actions;
-    var currentState = initial;
-    var currentContext = context;
+function createMachine({ states, context, initial }, { actions }) {
+    let currentState = initial;
+    let currentContext = context;
     return {
-        send: function (event) {
-            var currentStateOn = states[currentState].on;
-            var transitionConfig = currentStateOn && currentStateOn[event.type];
+        send: (event)=>{
+            const currentStateOn = states[currentState].on;
+            const transitionConfig = currentStateOn && currentStateOn[event.type];
             if (transitionConfig) {
                 currentState = transitionConfig.target;
-                if (transitionConfig.actions) {
-                    transitionConfig.actions.forEach(function (actName) {
-                        var actionImpl = actions[actName];
-                        var nextContextValue = actionImpl && actionImpl(currentContext, event);
-                        if (nextContextValue) {
-                            currentContext = __assign(__assign({}, currentContext), nextContextValue);
-                        }
-                    });
-                }
+                if (transitionConfig.actions) transitionConfig.actions.forEach((actName)=>{
+                    const actionImpl = actions[actName];
+                    const nextContextValue = actionImpl && actionImpl(currentContext, event);
+                    if (nextContextValue) currentContext = _object_spread({}, currentContext, nextContextValue);
+                });
             }
-        },
+        }
     };
 }
-var createOverlayMachine = function (options) {
-    var hideOverlay = options.hideOverlay, showOverlay = options.showOverlay;
+const createOverlayMachine = (options)=>{
+    const { hideOverlay, showOverlay } = options;
     return createMachine({
         initial: 'hidden',
         context: {
             level: 'error',
             messages: [],
-            messageSource: 'build',
+            messageSource: 'build'
         },
         states: {
             hidden: {
                 on: {
                     BUILD_ERROR: {
                         target: 'displayBuildError',
-                        actions: ['setMessages', 'showOverlay'],
+                        actions: [
+                            'setMessages',
+                            'showOverlay'
+                        ]
                     },
                     RUNTIME_ERROR: {
                         target: 'displayRuntimeError',
-                        actions: ['setMessages', 'showOverlay'],
-                    },
-                },
+                        actions: [
+                            'setMessages',
+                            'showOverlay'
+                        ]
+                    }
+                }
             },
             displayBuildError: {
                 on: {
                     DISMISS: {
                         target: 'hidden',
-                        actions: ['dismissMessages', 'hideOverlay'],
+                        actions: [
+                            'dismissMessages',
+                            'hideOverlay'
+                        ]
                     },
                     BUILD_ERROR: {
                         target: 'displayBuildError',
-                        actions: ['appendMessages', 'showOverlay'],
-                    },
-                },
+                        actions: [
+                            'appendMessages',
+                            'showOverlay'
+                        ]
+                    }
+                }
             },
             displayRuntimeError: {
                 on: {
                     DISMISS: {
                         target: 'hidden',
-                        actions: ['dismissMessages', 'hideOverlay'],
+                        actions: [
+                            'dismissMessages',
+                            'hideOverlay'
+                        ]
                     },
                     RUNTIME_ERROR: {
                         target: 'displayRuntimeError',
-                        actions: ['appendMessages', 'showOverlay'],
+                        actions: [
+                            'appendMessages',
+                            'showOverlay'
+                        ]
                     },
                     BUILD_ERROR: {
                         target: 'displayBuildError',
-                        actions: ['setMessages', 'showOverlay'],
-                    },
-                },
-            },
-        },
+                        actions: [
+                            'setMessages',
+                            'showOverlay'
+                        ]
+                    }
+                }
+            }
+        }
     }, {
         actions: {
-            dismissMessages: function () {
-                return {
+            dismissMessages: ()=>({
                     messages: [],
                     level: 'error',
-                    messageSource: 'build',
-                };
-            },
-            appendMessages: function (context, event) {
-                return {
+                    messageSource: 'build'
+                }),
+            appendMessages: (context, event)=>({
                     messages: context.messages.concat(event.messages),
                     level: event.level || context.level,
-                    messageSource: event.type === 'RUNTIME_ERROR' ? 'runtime' : 'build',
-                };
-            },
-            setMessages: function (context, event) {
-                return {
+                    messageSource: 'RUNTIME_ERROR' === event.type ? 'runtime' : 'build'
+                }),
+            setMessages: (context, event)=>({
                     messages: event.messages,
                     level: event.level || context.level,
-                    messageSource: event.type === 'RUNTIME_ERROR' ? 'runtime' : 'build',
-                };
-            },
-            hideOverlay: hideOverlay,
-            showOverlay: showOverlay,
-        },
+                    messageSource: 'RUNTIME_ERROR' === event.type ? 'runtime' : 'build'
+                }),
+            hideOverlay,
+            showOverlay
+        }
     });
 };
-var parseErrorToStacks = function (error) {
-    if (!error || !(error instanceof Error)) {
-        throw new Error('parseErrorToStacks expects Error object');
-    }
-    if (typeof error.stack === 'string') {
-        return error.stack
-            .split('\n')
-            .filter(function (stack) { return stack !== "Error: ".concat(error.message); });
-    }
+const parseErrorToStacks = (error)=>{
+    if (!error || !(error instanceof Error)) throw new Error('parseErrorToStacks expects Error object');
+    if ('string' == typeof error.stack) return error.stack.split('\n').filter((stack)=>stack !== `Error: ${error.message}`);
 };
-var listenToRuntimeError = function (callback) {
+const listenToRuntimeError = (callback)=>{
     window.addEventListener('error', callback);
-    return function cleanup() {
+    return function() {
         window.removeEventListener('error', callback);
     };
 };
-var listenToUnhandledRejection = function (callback) {
+const listenToUnhandledRejection = (callback)=>{
     window.addEventListener('unhandledrejection', callback);
-    return function cleanup() {
+    return function() {
         window.removeEventListener('unhandledrejection', callback);
     };
 };
-// Styles are inspired by `react-error-overlay`
-var msgStyles = {
+const msgStyles = {
     error: {
         backgroundColor: 'rgba(206, 17, 38, 0.1)',
-        color: '#fccfcf',
+        color: '#fccfcf'
     },
     warning: {
         backgroundColor: 'rgba(251, 245, 180, 0.1)',
-        color: '#fbf5b4',
-    },
+        color: '#fbf5b4'
+    }
 };
-var iframeStyle = {
+const iframeStyle = {
     position: 'fixed',
     top: '0px',
     left: '0px',
@@ -231,9 +224,9 @@ var iframeStyle = {
     width: '100vw',
     height: '100vh',
     border: 'none',
-    'z-index': 9999999999,
+    'z-index': 9999999999
 };
-var containerStyle = {
+const containerStyle = {
     position: 'fixed',
     boxSizing: 'border-box',
     left: '0px',
@@ -248,9 +241,9 @@ var containerStyle = {
     whiteSpace: 'pre-wrap',
     overflow: 'auto',
     backgroundColor: 'rgba(0, 0, 0, 0.9)',
-    color: 'white',
+    color: 'white'
 };
-var headerStyle = {
+const headerStyle = {
     color: '#e83b46',
     fontSize: '2em',
     whiteSpace: 'pre-wrap',
@@ -258,9 +251,9 @@ var headerStyle = {
     margin: '0 2rem 2rem 0',
     flex: '0 0 auto',
     maxHeight: '50%',
-    overflow: 'auto',
+    overflow: 'auto'
 };
-var dismissButtonStyle = {
+const dismissButtonStyle = {
     color: '#ffffff',
     lineHeight: '1rem',
     fontSize: '1.5rem',
@@ -270,22 +263,24 @@ var dismissButtonStyle = {
     right: '0px',
     top: '0px',
     backgroundColor: 'transparent',
-    border: 'none',
+    border: 'none'
 };
-var msgTypeStyle = {
+const msgTypeStyle = {
     color: '#e83b46',
     fontSize: '1.2em',
     marginBottom: '1rem',
-    fontFamily: 'sans-serif',
+    fontFamily: 'sans-serif'
 };
-var msgTextStyle = {
+const msgTextStyle = {
     lineHeight: '1.5',
     fontSize: '1rem',
-    fontFamily: 'Menlo, Consolas, monospace',
+    fontFamily: 'Menlo, Consolas, monospace'
 };
-// ANSI HTML
-var colors = {
-    reset: ['transparent', 'transparent'],
+const colors = {
+    reset: [
+        'transparent',
+        'transparent'
+    ],
     black: '181818',
     red: 'E36049',
     green: 'B3CB74',
@@ -294,81 +289,69 @@ var colors = {
     magenta: '7FACCA',
     cyan: 'C3C2EF',
     lightgrey: 'EBE7E3',
-    darkgrey: '6D7891',
+    darkgrey: '6D7891'
 };
 ansiHTML.setColors(colors);
-var formatProblem = function (type, item) {
-    var header = type === 'warning' ? 'WARNING' : 'ERROR';
-    var body = '';
-    if (typeof item === 'string') {
-        body += item;
-    }
+const formatProblem = (type, item)=>{
+    let header = 'warning' === type ? 'WARNING' : 'ERROR';
+    let body = '';
+    if ('string' == typeof item) body += item;
     else {
-        var file = item.file || '';
-        var moduleName = item.moduleName
-            ? item.moduleName.indexOf('!') !== -1
-                ? "".concat(item.moduleName.replace(/^(\s|\S)*!/, ''), " (").concat(item.moduleName, ")")
-                : "".concat(item.moduleName)
-            : '';
-        var loc = item.loc;
-        header += "".concat(moduleName || file
-            ? " in ".concat(moduleName ? "".concat(moduleName).concat(file ? " (".concat(file, ")") : '') : file).concat(loc ? " ".concat(loc) : '')
-            : '');
+        const file = item.file || '';
+        const moduleName = item.moduleName ? -1 !== item.moduleName.indexOf('!') ? `${item.moduleName.replace(/^(\s|\S)*!/, '')} (${item.moduleName})` : `${item.moduleName}` : '';
+        const loc = item.loc;
+        header += `${moduleName || file ? ` in ${moduleName ? `${moduleName}${file ? ` (${file})` : ''}` : file}${loc ? ` ${loc}` : ''}` : ''}`;
         body += item.message || '';
     }
-    if (typeof item !== 'string' && Array.isArray(item.stack)) {
-        item.stack.forEach(function (stack) {
-            if (typeof stack === 'string') {
-                body += "\r\n".concat(stack);
-            }
-        });
-    }
-    return { header: header, body: body };
+    if ('string' != typeof item && Array.isArray(item.stack)) item.stack.forEach((stack)=>{
+        if ('string' == typeof stack) body += `\r\n${stack}`;
+    });
+    return {
+        header,
+        body
+    };
 };
-var createOverlay = function (options) {
-    var iframeContainerElement;
-    var containerElement;
-    var headerElement;
-    var onLoadQueue = [];
-    var overlayTrustedTypesPolicy;
+const createOverlay = (options)=>{
+    let iframeContainerElement;
+    let containerElement;
+    let headerElement;
+    let onLoadQueue = [];
+    let overlayTrustedTypesPolicy;
     function applyStyle(element, style) {
-        Object.keys(style).forEach(function (prop) {
-            element.style[prop] =
-                style[prop];
+        Object.keys(style).forEach((prop)=>{
+            element.style[prop] = style[prop];
         });
     }
     function createContainer(trustedTypesPolicyName) {
-        // Enable Trusted Types if they are available in the current browser.
-        if (window.trustedTypes) {
-            overlayTrustedTypesPolicy = window.trustedTypes.createPolicy(trustedTypesPolicyName || 'webpack-dev-server#overlay', {
-                createHTML: function (value) { return value; },
-            });
-        }
+        if (window.trustedTypes) overlayTrustedTypesPolicy = window.trustedTypes.createPolicy(trustedTypesPolicyName || 'rspack-dev-server#overlay', {
+            createHTML: (value)=>value
+        });
         iframeContainerElement = document.createElement('iframe');
-        iframeContainerElement.id = 'webpack-dev-server-client-overlay';
+        iframeContainerElement.id = 'rspack-dev-server-client-overlay';
         iframeContainerElement.src = 'about:blank';
         applyStyle(iframeContainerElement, iframeStyle);
-        iframeContainerElement.onload = function () {
-            var contentElement = (iframeContainerElement === null || iframeContainerElement === void 0 ? void 0 : iframeContainerElement.contentDocument).createElement('div');
-            containerElement = (iframeContainerElement === null || iframeContainerElement === void 0 ? void 0 : iframeContainerElement.contentDocument).createElement('div');
-            contentElement.id = 'webpack-dev-server-client-overlay-div';
+        iframeContainerElement.onload = ()=>{
+            const contentElement = (null == iframeContainerElement ? void 0 : iframeContainerElement.contentDocument).createElement('div');
+            containerElement = (null == iframeContainerElement ? void 0 : iframeContainerElement.contentDocument).createElement('div');
+            contentElement.id = 'rspack-dev-server-client-overlay-div';
             applyStyle(contentElement, containerStyle);
             headerElement = document.createElement('div');
             headerElement.innerText = 'Compiled with problems:';
             applyStyle(headerElement, headerStyle);
-            var closeButtonElement = document.createElement('button');
+            const closeButtonElement = document.createElement('button');
             applyStyle(closeButtonElement, dismissButtonStyle);
             closeButtonElement.innerText = '×';
             closeButtonElement.ariaLabel = 'Dismiss';
-            closeButtonElement.addEventListener('click', function () {
-                // eslint-disable-next-line no-use-before-define
-                overlayService.send({ type: 'DISMISS' });
+            closeButtonElement.addEventListener('click', ()=>{
+                overlayService.send({
+                    type: 'DISMISS'
+                });
             });
             contentElement.appendChild(headerElement);
             contentElement.appendChild(closeButtonElement);
             contentElement.appendChild(containerElement);
-            (iframeContainerElement === null || iframeContainerElement === void 0 ? void 0 : iframeContainerElement.contentDocument).body.appendChild(contentElement);
-            onLoadQueue.forEach(function (onLoad) {
+            (null == iframeContainerElement ? void 0 : iframeContainerElement.contentDocument).body.appendChild(contentElement);
+            onLoadQueue.forEach((onLoad)=>{
                 onLoad(contentElement);
             });
             onLoadQueue = [];
@@ -378,124 +361,92 @@ var createOverlay = function (options) {
     }
     function ensureOverlayExists(callback, trustedTypesPolicyName) {
         if (containerElement) {
-            containerElement.innerHTML = overlayTrustedTypesPolicy
-                ? overlayTrustedTypesPolicy.createHTML('')
-                : '';
-            // Everything is ready, call the callback right away.
+            containerElement.innerHTML = overlayTrustedTypesPolicy ? overlayTrustedTypesPolicy.createHTML('') : '';
             callback(containerElement);
             return;
         }
         onLoadQueue.push(callback);
-        if (iframeContainerElement) {
-            return;
-        }
+        if (iframeContainerElement) return;
         createContainer(trustedTypesPolicyName);
     }
-    // Successful compilation.
     function hide() {
-        if (!iframeContainerElement) {
-            return;
-        }
-        // Clean up and reset internal state.
+        if (!iframeContainerElement) return;
         document.body.removeChild(iframeContainerElement);
         iframeContainerElement = null;
         containerElement = null;
     }
-    // Compilation with errors (e.g. syntax error or missing modules).
     function show(type, messages, trustedTypesPolicyName, messageSource) {
-        ensureOverlayExists(function () {
-            headerElement.innerText =
-                messageSource === 'runtime'
-                    ? 'Uncaught runtime errors:'
-                    : 'Compiled with problems:';
-            messages.forEach(function (message) {
-                var entryElement = document.createElement('div');
-                var msgStyle = type === 'warning' ? msgStyles.warning : msgStyles.error;
-                applyStyle(entryElement, __assign(__assign({}, msgStyle), { padding: '1rem 1rem 1.5rem 1rem' }));
-                var typeElement = document.createElement('div');
-                var _a = formatProblem(type, message), header = _a.header, body = _a.body;
+        ensureOverlayExists(()=>{
+            headerElement.innerText = 'runtime' === messageSource ? 'Uncaught runtime errors:' : 'Compiled with problems:';
+            messages.forEach((message)=>{
+                const entryElement = document.createElement('div');
+                const msgStyle = 'warning' === type ? msgStyles.warning : msgStyles.error;
+                applyStyle(entryElement, _object_spread_props(_object_spread({}, msgStyle), {
+                    padding: '1rem 1rem 1.5rem 1rem'
+                }));
+                const typeElement = document.createElement('div');
+                const { header, body } = formatProblem(type, message);
                 typeElement.innerText = header;
                 applyStyle(typeElement, msgTypeStyle);
-                if (typeof message !== 'string' && message.moduleIdentifier) {
-                    applyStyle(typeElement, { cursor: 'pointer' });
-                    // element.dataset not supported in IE
+                if ('string' != typeof message && message.moduleIdentifier) {
+                    applyStyle(typeElement, {
+                        cursor: 'pointer'
+                    });
                     typeElement.setAttribute('data-can-open', 'true');
-                    typeElement.addEventListener('click', function () {
-                        fetch("/webpack-dev-server/open-editor?fileName=".concat(message.moduleIdentifier));
+                    typeElement.addEventListener('click', ()=>{
+                        fetch(`/rspack-dev-server/open-editor?fileName=${message.moduleIdentifier}`);
                     });
                 }
-                // Make it look similar to our terminal.
-                var text = ansiHTML(encode(body));
-                var messageTextNode = document.createElement('div');
+                const text = ansiHTML(encode(body));
+                const messageTextNode = document.createElement('div');
                 applyStyle(messageTextNode, msgTextStyle);
-                messageTextNode.innerHTML = overlayTrustedTypesPolicy
-                    ? overlayTrustedTypesPolicy.createHTML(text)
-                    : text;
+                messageTextNode.innerHTML = overlayTrustedTypesPolicy ? overlayTrustedTypesPolicy.createHTML(text) : text;
                 entryElement.appendChild(typeElement);
                 entryElement.appendChild(messageTextNode);
-                containerElement === null || containerElement === void 0 ? void 0 : containerElement.appendChild(entryElement);
+                null == containerElement || containerElement.appendChild(entryElement);
             });
         }, trustedTypesPolicyName);
     }
-    var handleEscapeKey;
-    var hideOverlayWithEscCleanup = function () {
+    let handleEscapeKey;
+    const hideOverlayWithEscCleanup = ()=>{
         window.removeEventListener('keydown', handleEscapeKey);
         hide();
     };
-    var overlayService = createOverlayMachine({
-        showOverlay: function (_a) {
-            var _b = _a.level, level = _b === void 0 ? 'error' : _b, messages = _a.messages, messageSource = _a.messageSource;
-            return show(level, messages, options.trustedTypesPolicyName, messageSource);
-        },
-        hideOverlay: hideOverlayWithEscCleanup,
+    const overlayService = createOverlayMachine({
+        showOverlay: ({ level = 'error', messages, messageSource })=>show(level, messages, options.trustedTypesPolicyName, messageSource),
+        hideOverlay: hideOverlayWithEscCleanup
     });
-    /**
-     * ESC key press to dismiss the overlay.
-     */
-    handleEscapeKey = function (event) {
-        if (event.key === 'Escape' || event.key === 'Esc' || event.keyCode === 27) {
-            overlayService.send({ type: 'DISMISS' });
-        }
+    handleEscapeKey = (event)=>{
+        if ('Escape' === event.key || 'Esc' === event.key || 27 === event.keyCode) overlayService.send({
+            type: 'DISMISS'
+        });
     };
     window.addEventListener('keydown', handleEscapeKey);
     if (options.catchRuntimeError) {
-        var handleError_1 = function (error, fallbackMessage) {
-            var errorObject = error instanceof Error
-                ? error
-                : // @ts-expect-error error options
-                    new Error(error || fallbackMessage, { cause: error });
-            var shouldDisplay = typeof options.catchRuntimeError === 'function'
-                ? options.catchRuntimeError(errorObject)
-                : true;
-            if (shouldDisplay) {
-                overlayService.send({
-                    type: 'RUNTIME_ERROR',
-                    messages: [
-                        {
-                            message: errorObject.message,
-                            stack: parseErrorToStacks(errorObject),
-                        },
-                    ],
-                });
-            }
+        const handleError = (error, fallbackMessage)=>{
+            const errorObject = error instanceof Error ? error : new Error(error || fallbackMessage, {
+                cause: error
+            });
+            const shouldDisplay = 'function' == typeof options.catchRuntimeError ? options.catchRuntimeError(errorObject) : true;
+            if (shouldDisplay) overlayService.send({
+                type: 'RUNTIME_ERROR',
+                messages: [
+                    {
+                        message: errorObject.message,
+                        stack: parseErrorToStacks(errorObject)
+                    }
+                ]
+            });
         };
-        listenToRuntimeError(function (errorEvent) {
-            // error property may be empty in older browser like IE
-            var error = errorEvent.error, message = errorEvent.message;
-            if (!error && !message) {
-                return;
-            }
-            // if error stack indicates a React error boundary caught the error, do not show overlay.
-            if (error &&
-                error.stack &&
-                error.stack.includes('invokeGuardedCallbackDev')) {
-                return;
-            }
-            handleError_1(error, message);
+        listenToRuntimeError((errorEvent)=>{
+            const { error, message } = errorEvent;
+            if (!error && !message) return;
+            if (error && error.stack && error.stack.includes('invokeGuardedCallbackDev')) return;
+            handleError(error, message);
         });
-        listenToUnhandledRejection(function (promiseRejectionEvent) {
-            var reason = promiseRejectionEvent.reason;
-            handleError_1(reason, 'Unknown promise rejection reason');
+        listenToUnhandledRejection((promiseRejectionEvent)=>{
+            const { reason } = promiseRejectionEvent;
+            handleError(reason, 'Unknown promise rejection reason');
         });
     }
     return overlayService;