@module-federation/utilities 0.0.0-chore-bump-node-22-20260710161714

package/dist/cjs/utils/importDelegatedModule.js

@@ -0,0 +1,126 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  importDelegatedModule: () => (/* binding */ importDelegatedModule)
+});
+
+;// CONCATENATED MODULE: external "./pure.js"
+const external_pure_js_namespaceObject = require("./pure.js");
+;// CONCATENATED MODULE: ./src/utils/importDelegatedModule.ts
+
+const importDelegatedModule = async (keyOrRuntimeRemoteItem)=>{
+    // @ts-ignore
+    return (0,external_pure_js_namespaceObject.loadScript)(keyOrRuntimeRemoteItem).then((asyncContainer)=>{
+        return asyncContainer;
+    }).then((asyncContainer)=>{
+        // most of this is only needed because of legacy promise based implementation
+        // can remove proxies once we remove promise based implementations
+        if (typeof window === 'undefined') {
+            if (!Object.hasOwnProperty.call(keyOrRuntimeRemoteItem, 'globalThis')) {
+                return asyncContainer;
+            }
+            // return asyncContainer;
+            //TODO: need to solve chunk flushing with delegated modules
+            return {
+                get: function(arg) {
+                    //@ts-ignore
+                    return asyncContainer.get(arg).then((f)=>{
+                        const m = f();
+                        const result = {
+                            __esModule: m.__esModule
+                        };
+                        for(const prop in m){
+                            if (typeof m[prop] === 'function') {
+                                Object.defineProperty(result, prop, {
+                                    get: function() {
+                                        return function() {
+                                            //@ts-ignore
+                                            if (globalThis.usedChunks) {
+                                                //@ts-ignore
+                                                globalThis.usedChunks.add(//@ts-ignore
+                                                `${keyOrRuntimeRemoteItem.global}->${arg}`);
+                                            }
+                                            //eslint-disable-next-line prefer-rest-params
+                                            return m[prop](...arguments);
+                                        };
+                                    },
+                                    enumerable: true
+                                });
+                            } else {
+                                Object.defineProperty(result, prop, {
+                                    get: ()=>{
+                                        //@ts-ignore
+                                        if (globalThis.usedChunks) {
+                                            //@ts-ignore
+                                            globalThis.usedChunks.add(//@ts-ignore
+                                            `${keyOrRuntimeRemoteItem.global}->${arg}`);
+                                        }
+                                        return m[prop];
+                                    },
+                                    enumerable: true
+                                });
+                            }
+                        }
+                        if (m.then) {
+                            return Promise.resolve(()=>result);
+                        }
+                        return ()=>result;
+                    });
+                },
+                init: asyncContainer.init
+            };
+        } else {
+            return asyncContainer;
+        }
+    });
+};
+
+exports.importDelegatedModule = __webpack_exports__.importDelegatedModule;
+for(var __rspack_i in __webpack_exports__) {
+  if(["importDelegatedModule"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/importRemote.js

@@ -0,0 +1,176 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+var __webpack_modules__ = ({});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+/**
+ * Constant for remote entry file
+ * @constant {string}
+ */ const REMOTE_ENTRY_FILE = 'remoteEntry.js';
+/**
+ * Function to load remote
+ * @function
+ * @param {ImportRemoteOptions['url']} url - The url of the remote module
+ * @param {ImportRemoteOptions['scope']} scope - The scope of the remote module
+ * @param {ImportRemoteOptions['bustRemoteEntryCache']} bustRemoteEntryCache - Flag to bust the remote entry cache
+ * @returns {Promise<void>} A promise that resolves when the remote is loaded
+ */ const loadRemote = (url, scope, bustRemoteEntryCache)=>new Promise((resolve, reject)=>{
+        const timestamp = bustRemoteEntryCache ? `?t=${new Date().getTime()}` : '';
+        const webpackRequire = __webpack_require__;
+        webpackRequire.l(`${url}${timestamp}`, (event)=>{
+            if (event?.type === 'load') {
+                // Script loaded successfully:
+                return resolve();
+            }
+            const realSrc = event?.target?.src;
+            const error = new Error();
+            error.message = 'Loading script failed.\n(missing: ' + realSrc + ')';
+            error.name = 'ScriptExternalLoadError';
+            reject(error);
+        }, scope);
+    });
+const loadEsmRemote = async (url, scope)=>{
+    const module = await import(/* webpackIgnore: true */ url);
+    if (!module) {
+        throw new Error(`Unable to load requested remote from ${url} with scope ${scope}`);
+    }
+    window[scope] = {
+        ...module,
+        __initializing: false,
+        __initialized: false
+    };
+};
+/**
+ * Function to initialize sharing
+ * @async
+ * @function
+ */ const initSharing = async ()=>{
+    const webpackShareScopes = __webpack_require__.S;
+    if (!webpackShareScopes?.default) {
+        await __webpack_require__.I('default');
+    }
+};
+/**
+ * Function to initialize container
+ * @async
+ * @function
+ * @param {WebpackRemoteContainer} containerScope - The container scope
+ */ const initContainer = async (containerScope)=>{
+    try {
+        const webpackShareScopes = __webpack_require__.S;
+        if (!containerScope.__initialized && !containerScope.__initializing) {
+            containerScope.__initializing = true;
+            await containerScope.init(webpackShareScopes.default);
+            containerScope.__initialized = true;
+            delete containerScope.__initializing;
+        }
+    } catch (error) {
+        console.error(error);
+    }
+};
+/**
+ * Function to import remote
+ * @async
+ * @function
+ * @param {ImportRemoteOptions} options - The options for importing the remote
+ * @returns {Promise<T>} A promise that resolves with the imported module
+ */ const importRemote = async ({ url, scope, module, remoteEntryFileName = REMOTE_ENTRY_FILE, bustRemoteEntryCache = true, esm = false })=>{
+    const remoteScope = scope;
+    if (!window[remoteScope]) {
+        let remoteUrl = '';
+        if (typeof url === 'string') {
+            remoteUrl = url;
+        } else {
+            remoteUrl = await url();
+        }
+        const remoteUrlWithEntryFile = `${remoteUrl}/${remoteEntryFileName}`;
+        const asyncContainer = !esm ? loadRemote(remoteUrlWithEntryFile, scope, bustRemoteEntryCache) : loadEsmRemote(remoteUrlWithEntryFile, scope);
+        // Load the remote and initialize the share scope if it's empty
+        await Promise.all([
+            asyncContainer,
+            initSharing()
+        ]);
+        if (!window[remoteScope]) {
+            throw new Error(`Remote loaded successfully but ${scope} could not be found! Verify that the name is correct in the Webpack configuration!`);
+        }
+        // Initialize the container to get shared modules and get the module factory:
+        const [, moduleFactory] = await Promise.all([
+            initContainer(window[remoteScope]),
+            window[remoteScope].get(module === '.' || module.startsWith('./') ? module : `./${module}`)
+        ]);
+        return moduleFactory();
+    } else {
+        const moduleFactory = await window[remoteScope].get(module === '.' || module.startsWith('./') ? module : `./${module}`);
+        return moduleFactory();
+    }
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  importRemote: importRemote
+});
+
+exports.importRemote = __webpack_exports__.importRemote;
+for(var __rspack_i in __webpack_exports__) {
+  if(["importRemote"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/isEmpty.js

@@ -0,0 +1,60 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const isObjectEmpty = (obj)=>{
+    for(const x in obj){
+        return false;
+    }
+    return true;
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  isObjectEmpty: isObjectEmpty
+});
+
+exports.isObjectEmpty = __webpack_exports__.isObjectEmpty;
+for(var __rspack_i in __webpack_exports__) {
+  if(["isObjectEmpty"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/pure.js

@@ -0,0 +1,215 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+var __webpack_modules__ = ({});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const pure = typeof process !== 'undefined' ? process.env['REMOTES'] || {} : {};
+const remoteVars = pure;
+const extractUrlAndGlobal = (urlAndGlobal)=>{
+    const index = urlAndGlobal.indexOf('@');
+    if (index <= 0 || index === urlAndGlobal.length - 1) {
+        throw new Error(`Invalid request "${urlAndGlobal}"`);
+    }
+    return [
+        urlAndGlobal.substring(index + 1),
+        urlAndGlobal.substring(0, index)
+    ];
+};
+const loadScript = (keyOrRuntimeRemoteItem)=>{
+    const runtimeRemotes = getRuntimeRemotes();
+    // 1) Load remote container if needed
+    let asyncContainer;
+    const reference = typeof keyOrRuntimeRemoteItem === 'string' ? runtimeRemotes[keyOrRuntimeRemoteItem] : keyOrRuntimeRemoteItem;
+    if (reference.asyncContainer) {
+        asyncContainer = typeof reference.asyncContainer.then === 'function' ? reference.asyncContainer : reference.asyncContainer();
+    } else {
+        // This casting is just to satisfy typescript,
+        // In reality remoteGlobal will always be a string;
+        const remoteGlobal = reference.global;
+        // Check if theres an override for container key if not use remote global
+        const containerKey = reference.uniqueKey ? reference.uniqueKey : remoteGlobal;
+        const __webpack_error__ = new Error();
+        // @ts-ignore
+        const globalScope = // @ts-ignore
+        typeof window !== 'undefined' ? window : globalThis.__remote_scope__;
+        if (typeof window === 'undefined') {
+            //@ts-ignore
+            globalScope['_config'][containerKey] = reference.url;
+        } else {
+            // to match promise template system, can be removed once promise template is gone
+            //@ts-ignore
+            if (!globalScope['remoteLoading']) {
+                //@ts-ignore
+                globalScope['remoteLoading'] = {};
+            }
+            //@ts-ignore
+            if (globalScope['remoteLoading'][containerKey]) {
+                //@ts-ignore
+                return globalScope['remoteLoading'][containerKey];
+            }
+        }
+        // @ts-ignore
+        asyncContainer = new Promise(function(resolve, reject) {
+            function resolveRemoteGlobal() {
+                //@ts-ignore
+                const asyncContainer = globalScope[remoteGlobal];
+                return resolve(asyncContainer);
+            }
+            //@ts-ignore
+            if (typeof globalScope[remoteGlobal] !== 'undefined') {
+                return resolveRemoteGlobal();
+            }
+            __webpack_require__.l(reference.url, function(event) {
+                //@ts-ignore
+                if (typeof globalScope[remoteGlobal] !== 'undefined') {
+                    return resolveRemoteGlobal();
+                }
+                const errorType = event && (event.type === 'load' ? 'missing' : event.type);
+                const realSrc = event && event.target && event.target.src;
+                __webpack_error__.message = 'Loading script failed.\n(' + errorType + ': ' + realSrc + ' or global var ' + remoteGlobal + ')';
+                __webpack_error__.name = 'ScriptExternalLoadError';
+                __webpack_error__.type = errorType;
+                __webpack_error__.request = realSrc;
+                reject(__webpack_error__);
+            }, containerKey);
+        }).catch(function(err) {
+            console.error('container is offline, returning fake remote');
+            console.error(err);
+            return {
+                fake: true,
+                // @ts-ignore
+                get: (arg)=>{
+                    console.warn('faking', arg, 'module on, its offline');
+                    return Promise.resolve(()=>{
+                        return {
+                            __esModule: true,
+                            default: ()=>{
+                                return null;
+                            }
+                        };
+                    });
+                },
+                //eslint-disable-next-line
+                init: ()=>{}
+            };
+        });
+        if (typeof window !== 'undefined') {
+            //@ts-ignore
+            globalScope['remoteLoading'][containerKey] = asyncContainer;
+        }
+    }
+    return asyncContainer;
+};
+const getRuntimeRemotes = ()=>{
+    return Object.entries(remoteVars).reduce((acc, [key, value])=>{
+        if (typeof value === 'object' && typeof value.then === 'function') {
+            acc[key] = {
+                asyncContainer: value
+            };
+        } else if (typeof value === 'function') {
+            acc[key] = {
+                asyncContainer: Promise.resolve(value())
+            };
+        } else if (typeof value === 'string') {
+            if (value.startsWith('internal ')) {
+                const [request, query] = value.replace('internal ', '').split('?');
+                if (query) {
+                    const remoteSyntax = new URLSearchParams(query).get('remote');
+                    if (remoteSyntax) {
+                        const [url, global] = extractUrlAndGlobal(remoteSyntax);
+                        acc[key] = {
+                            global,
+                            url
+                        };
+                    }
+                }
+            } else {
+                const [url, global] = extractUrlAndGlobal(value);
+                acc[key] = {
+                    global,
+                    url
+                };
+            }
+        } else {
+            console.warn('remotes process', process.env['REMOTES']);
+            throw new Error(`[mf] Invalid value received for runtime_remote "${key}"`);
+        }
+        return acc;
+    }, {});
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  extractUrlAndGlobal: extractUrlAndGlobal,
+  getRuntimeRemotes: getRuntimeRemotes,
+  loadScript: loadScript,
+  remoteVars: remoteVars
+});
+
+exports.extractUrlAndGlobal = __webpack_exports__.extractUrlAndGlobal;
+exports.getRuntimeRemotes = __webpack_exports__.getRuntimeRemotes;
+exports.loadScript = __webpack_exports__.loadScript;
+exports.remoteVars = __webpack_exports__.remoteVars;
+for(var __rspack_i in __webpack_exports__) {
+  if(["extractUrlAndGlobal","getRuntimeRemotes","loadScript","remoteVars"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/react.js

@@ -0,0 +1,73 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  FederationBoundary: () => (/* reexport */ (FederationBoundary_js_default()))
+});
+
+;// CONCATENATED MODULE: external "../components/FederationBoundary.js"
+const FederationBoundary_js_namespaceObject = require("../components/FederationBoundary.js");
+var FederationBoundary_js_default = /*#__PURE__*/__webpack_require__.n(FederationBoundary_js_namespaceObject);
+;// CONCATENATED MODULE: ./src/utils/react.tsx
+
+
+exports.FederationBoundary = __webpack_exports__.FederationBoundary;
+for(var __rspack_i in __webpack_exports__) {
+  if(["FederationBoundary"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/esm/Logger.mjs

@@ -0,0 +1,12 @@
+class Logger {
+    static getLogger() {
+        return this.loggerInstance;
+    }
+    static setLogger(logger) {
+        this.loggerInstance = logger || console;
+        return logger;
+    }
+}
+Logger.loggerInstance = console;
+
+export { Logger };

package/dist/esm/components/ErrorBoundary.mjs

@@ -0,0 +1,31 @@
+import react from "react";
+
+
+
+/**
+ * Generic error boundary component.
+ */ class ErrorBoundary extends react.Component {
+    static getDerivedStateFromError() {
+        return {
+            hasError: true
+        };
+    }
+    componentDidCatch(error, errorInfo) {
+        console.error(error, errorInfo);
+    }
+    render() {
+        if (this.state.hasError) {
+            return 'An error has occurred.';
+        }
+        return this.props.children;
+    }
+    constructor(props){
+        super(props);
+        this.state = {
+            hasError: false
+        };
+    }
+}
+/* export default */ const components_ErrorBoundary = (ErrorBoundary);
+
+export default components_ErrorBoundary;