maxsimcli 1.2.2 → 1.3.0

package/dist/assets/dashboard/node_modules/next/dist/client/router.js

@@ -0,0 +1,199 @@
+/* global window */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    Router: null,
+    createRouter: null,
+    default: null,
+    makePublicRouterInstance: null,
+    useRouter: null,
+    withRouter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Router: function() {
+        return _router.default;
+    },
+    createRouter: function() {
+        return createRouter;
+    },
+    // Export the singletonRouter and this is the public API.
+    default: function() {
+        return _default;
+    },
+    makePublicRouterInstance: function() {
+        return makePublicRouterInstance;
+    },
+    useRouter: function() {
+        return useRouter;
+    },
+    withRouter: function() {
+        return _withrouter.default;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _router = /*#__PURE__*/ _interop_require_default._(require("../shared/lib/router/router"));
+const _routercontextsharedruntime = require("../shared/lib/router-context.shared-runtime");
+const _iserror = /*#__PURE__*/ _interop_require_default._(require("../lib/is-error"));
+const _withrouter = /*#__PURE__*/ _interop_require_default._(require("./with-router"));
+const singletonRouter = {
+    router: null,
+    readyCallbacks: [],
+    ready (callback) {
+        if (this.router) return callback();
+        if (typeof window !== 'undefined') {
+            this.readyCallbacks.push(callback);
+        }
+    }
+};
+// Create public properties and methods of the router in the singletonRouter
+const urlPropertyFields = [
+    'pathname',
+    'route',
+    'query',
+    'asPath',
+    'components',
+    'isFallback',
+    'basePath',
+    'locale',
+    'locales',
+    'defaultLocale',
+    'isReady',
+    'isPreview',
+    'isLocaleDomain',
+    'domainLocales'
+];
+const routerEvents = [
+    'routeChangeStart',
+    'beforeHistoryChange',
+    'routeChangeComplete',
+    'routeChangeError',
+    'hashChangeStart',
+    'hashChangeComplete'
+];
+const coreMethodFields = [
+    'push',
+    'replace',
+    'reload',
+    'back',
+    'prefetch',
+    'beforePopState'
+];
+// Events is a static property on the router, the router doesn't have to be initialized to use it
+Object.defineProperty(singletonRouter, 'events', {
+    get () {
+        return _router.default.events;
+    }
+});
+function getRouter() {
+    if (!singletonRouter.router) {
+        const message = 'No router instance found.\n' + 'You should only use "next/router" on the client side of your app.\n';
+        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return singletonRouter.router;
+}
+urlPropertyFields.forEach((field)=>{
+    // Here we need to use Object.defineProperty because we need to return
+    // the property assigned to the actual router
+    // The value might get changed as we change routes and this is the
+    // proper way to access it
+    Object.defineProperty(singletonRouter, field, {
+        get () {
+            const router = getRouter();
+            return router[field];
+        }
+    });
+});
+coreMethodFields.forEach((field)=>{
+    // We don't really know the types here, so we add them later instead
+    ;
+    singletonRouter[field] = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const router = getRouter();
+        return router[field](...args);
+    };
+});
+routerEvents.forEach((event)=>{
+    singletonRouter.ready(()=>{
+        _router.default.events.on(event, function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            const eventField = "on" + event.charAt(0).toUpperCase() + event.substring(1);
+            const _singletonRouter = singletonRouter;
+            if (_singletonRouter[eventField]) {
+                try {
+                    _singletonRouter[eventField](...args);
+                } catch (err) {
+                    console.error("Error when running the Router event: " + eventField);
+                    console.error((0, _iserror.default)(err) ? err.message + "\n" + err.stack : err + '');
+                }
+            }
+        });
+    });
+});
+const _default = singletonRouter;
+function useRouter() {
+    const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
+    if (!router) {
+        throw Object.defineProperty(new Error('NextRouter was not mounted. https://nextjs.org/docs/messages/next-router-not-mounted'), "__NEXT_ERROR_CODE", {
+            value: "E509",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return router;
+}
+function createRouter() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    singletonRouter.router = new _router.default(...args);
+    singletonRouter.readyCallbacks.forEach((cb)=>cb());
+    singletonRouter.readyCallbacks = [];
+    return singletonRouter.router;
+}
+function makePublicRouterInstance(router) {
+    const scopedRouter = router;
+    const instance = {};
+    for (const property of urlPropertyFields){
+        if (typeof scopedRouter[property] === 'object') {
+            instance[property] = Object.assign(Array.isArray(scopedRouter[property]) ? [] : {}, scopedRouter[property]) // makes sure query is not stateful
+            ;
+            continue;
+        }
+        instance[property] = scopedRouter[property];
+    }
+    // Events is a static property on the router, the router doesn't have to be initialized to use it
+    instance.events = _router.default.events;
+    coreMethodFields.forEach((field)=>{
+        instance[field] = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            return scopedRouter[field](...args);
+        };
+    });
+    return instance;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=router.js.map

package/dist/assets/dashboard/node_modules/next/dist/client/script.js

@@ -0,0 +1,347 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    handleClientScriptLoad: null,
+    initScriptLoader: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    handleClientScriptLoad: function() {
+        return handleClientScriptLoad;
+    },
+    initScriptLoader: function() {
+        return initScriptLoader;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _reactdom = /*#__PURE__*/ _interop_require_default._(require("react-dom"));
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _headmanagercontextsharedruntime = require("../shared/lib/head-manager-context.shared-runtime");
+const _setattributesfromprops = require("./set-attributes-from-props");
+const _requestidlecallback = require("./request-idle-callback");
+const ScriptCache = new Map();
+const LoadCache = new Set();
+const insertStylesheets = (stylesheets)=>{
+    // Case 1: Styles for afterInteractive/lazyOnload with appDir injected via handleClientScriptLoad
+    //
+    // Using ReactDOM.preinit to feature detect appDir and inject styles
+    // Stylesheets might have already been loaded if initialized with Script component
+    // Re-inject styles here to handle scripts loaded via handleClientScriptLoad
+    // ReactDOM.preinit handles dedup and ensures the styles are loaded only once
+    if (_reactdom.default.preinit) {
+        stylesheets.forEach((stylesheet)=>{
+            _reactdom.default.preinit(stylesheet, {
+                as: 'style'
+            });
+        });
+        return;
+    }
+    // Case 2: Styles for afterInteractive/lazyOnload with pages injected via handleClientScriptLoad
+    //
+    // We use this function to load styles when appdir is not detected
+    // TODO: Use React float APIs to load styles once available for pages dir
+    if (typeof window !== 'undefined') {
+        let head = document.head;
+        stylesheets.forEach((stylesheet)=>{
+            let link = document.createElement('link');
+            link.type = 'text/css';
+            link.rel = 'stylesheet';
+            link.href = stylesheet;
+            head.appendChild(link);
+        });
+    }
+};
+const loadScript = (props)=>{
+    const { src, id, onLoad = ()=>{}, onReady = null, dangerouslySetInnerHTML, children = '', strategy = 'afterInteractive', onError, stylesheets } = props;
+    const cacheKey = id || src;
+    // Script has already loaded
+    if (cacheKey && LoadCache.has(cacheKey)) {
+        return;
+    }
+    // Contents of this script are already loading/loaded
+    if (ScriptCache.has(src)) {
+        LoadCache.add(cacheKey);
+        // It is possible that multiple `next/script` components all have same "src", but has different "onLoad"
+        // This is to make sure the same remote script will only load once, but "onLoad" are executed in order
+        ScriptCache.get(src).then(onLoad, onError);
+        return;
+    }
+    /** Execute after the script first loaded */ const afterLoad = ()=>{
+        // Run onReady for the first time after load event
+        if (onReady) {
+            onReady();
+        }
+        // add cacheKey to LoadCache when load successfully
+        LoadCache.add(cacheKey);
+    };
+    const el = document.createElement('script');
+    const loadPromise = new Promise((resolve, reject)=>{
+        el.addEventListener('load', function(e) {
+            resolve();
+            if (onLoad) {
+                onLoad.call(this, e);
+            }
+            afterLoad();
+        });
+        el.addEventListener('error', function(e) {
+            reject(e);
+        });
+    }).catch(function(e) {
+        if (onError) {
+            onError(e);
+        }
+    });
+    if (dangerouslySetInnerHTML) {
+        // Casting since lib.dom.d.ts doesn't have TrustedHTML yet.
+        el.innerHTML = dangerouslySetInnerHTML.__html || '';
+        afterLoad();
+    } else if (children) {
+        el.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
+        afterLoad();
+    } else if (src) {
+        el.src = src;
+        // do not add cacheKey into LoadCache for remote script here
+        // cacheKey will be added to LoadCache when it is actually loaded (see loadPromise above)
+        ScriptCache.set(src, loadPromise);
+    }
+    (0, _setattributesfromprops.setAttributesFromProps)(el, props);
+    if (strategy === 'worker') {
+        el.setAttribute('type', 'text/partytown');
+    }
+    el.setAttribute('data-nscript', strategy);
+    // Load styles associated with this script
+    if (stylesheets) {
+        insertStylesheets(stylesheets);
+    }
+    document.body.appendChild(el);
+};
+function handleClientScriptLoad(props) {
+    const { strategy = 'afterInteractive' } = props;
+    if (strategy === 'lazyOnload') {
+        window.addEventListener('load', ()=>{
+            (0, _requestidlecallback.requestIdleCallback)(()=>loadScript(props));
+        });
+    } else {
+        loadScript(props);
+    }
+}
+function loadLazyScript(props) {
+    if (document.readyState === 'complete') {
+        (0, _requestidlecallback.requestIdleCallback)(()=>loadScript(props));
+    } else {
+        window.addEventListener('load', ()=>{
+            (0, _requestidlecallback.requestIdleCallback)(()=>loadScript(props));
+        });
+    }
+}
+function addBeforeInteractiveToCache() {
+    const scripts = [
+        ...document.querySelectorAll('[data-nscript="beforeInteractive"]'),
+        ...document.querySelectorAll('[data-nscript="beforePageRender"]')
+    ];
+    scripts.forEach((script)=>{
+        const cacheKey = script.id || script.getAttribute('src');
+        LoadCache.add(cacheKey);
+    });
+}
+function initScriptLoader(scriptLoaderItems) {
+    scriptLoaderItems.forEach(handleClientScriptLoad);
+    addBeforeInteractiveToCache();
+}
+/**
+ * Load a third-party scripts in an optimized way.
+ *
+ * Read more: [Next.js Docs: `next/script`](https://nextjs.org/docs/app/api-reference/components/script)
+ */ function Script(props) {
+    const { id, src = '', onLoad = ()=>{}, onReady = null, strategy = 'afterInteractive', onError, stylesheets, ...restProps } = props;
+    // Context is available only during SSR
+    let { updateScripts, scripts, getIsSsr, appDir, nonce } = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
+    // if a nonce is explicitly passed to the script tag, favor that over the automatic handling
+    nonce = restProps.nonce || nonce;
+    /**
+   * - First mount:
+   *   1. The useEffect for onReady executes
+   *   2. hasOnReadyEffectCalled.current is false, but the script hasn't loaded yet (not in LoadCache)
+   *      onReady is skipped, set hasOnReadyEffectCalled.current to true
+   *   3. The useEffect for loadScript executes
+   *   4. hasLoadScriptEffectCalled.current is false, loadScript executes
+   *      Once the script is loaded, the onLoad and onReady will be called by then
+   *   [If strict mode is enabled / is wrapped in <OffScreen /> component]
+   *   5. The useEffect for onReady executes again
+   *   6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
+   *   7. The useEffect for loadScript executes again
+   *   8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
+   *
+   * - Second mount:
+   *   1. The useEffect for onReady executes
+   *   2. hasOnReadyEffectCalled.current is false, but the script has already loaded (found in LoadCache)
+   *      onReady is called, set hasOnReadyEffectCalled.current to true
+   *   3. The useEffect for loadScript executes
+   *   4. The script is already loaded, loadScript bails out
+   *   [If strict mode is enabled / is wrapped in <OffScreen /> component]
+   *   5. The useEffect for onReady executes again
+   *   6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
+   *   7. The useEffect for loadScript executes again
+   *   8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
+   */ const hasOnReadyEffectCalled = (0, _react.useRef)(false);
+    (0, _react.useEffect)(()=>{
+        const cacheKey = id || src;
+        if (!hasOnReadyEffectCalled.current) {
+            // Run onReady if script has loaded before but component is re-mounted
+            if (onReady && cacheKey && LoadCache.has(cacheKey)) {
+                onReady();
+            }
+            hasOnReadyEffectCalled.current = true;
+        }
+    }, [
+        onReady,
+        id,
+        src
+    ]);
+    const hasLoadScriptEffectCalled = (0, _react.useRef)(false);
+    (0, _react.useEffect)(()=>{
+        if (!hasLoadScriptEffectCalled.current) {
+            if (strategy === 'afterInteractive') {
+                loadScript(props);
+            } else if (strategy === 'lazyOnload') {
+                loadLazyScript(props);
+            }
+            hasLoadScriptEffectCalled.current = true;
+        }
+    }, [
+        props,
+        strategy
+    ]);
+    if (strategy === 'beforeInteractive' || strategy === 'worker') {
+        if (updateScripts) {
+            scripts[strategy] = (scripts[strategy] || []).concat([
+                {
+                    id,
+                    src,
+                    onLoad,
+                    onReady,
+                    onError,
+                    ...restProps,
+                    nonce
+                }
+            ]);
+            updateScripts(scripts);
+        } else if (getIsSsr && getIsSsr()) {
+            // Script has already loaded during SSR
+            LoadCache.add(id || src);
+        } else if (getIsSsr && !getIsSsr()) {
+            loadScript({
+                ...props,
+                nonce
+            });
+        }
+    }
+    // For the app directory, we need React Float to preload these scripts.
+    if (appDir) {
+        // Injecting stylesheets here handles beforeInteractive and worker scripts correctly
+        // For other strategies injecting here ensures correct stylesheet order
+        // ReactDOM.preinit handles loading the styles in the correct order,
+        // also ensures the stylesheet is loaded only once and in a consistent manner
+        //
+        // Case 1: Styles for beforeInteractive/worker with appDir - handled here
+        // Case 2: Styles for beforeInteractive/worker with pages dir - Not handled yet
+        // Case 3: Styles for afterInteractive/lazyOnload with appDir - handled here
+        // Case 4: Styles for afterInteractive/lazyOnload with pages dir - handled in insertStylesheets function
+        if (stylesheets) {
+            stylesheets.forEach((styleSrc)=>{
+                _reactdom.default.preinit(styleSrc, {
+                    as: 'style'
+                });
+            });
+        }
+        // Before interactive scripts need to be loaded by Next.js' runtime instead
+        // of native <script> tags, because they no longer have `defer`.
+        if (strategy === 'beforeInteractive') {
+            if (!src) {
+                // For inlined scripts, we put the content in `children`.
+                if (restProps.dangerouslySetInnerHTML) {
+                    // Casting since lib.dom.d.ts doesn't have TrustedHTML yet.
+                    restProps.children = restProps.dangerouslySetInnerHTML.__html;
+                    delete restProps.dangerouslySetInnerHTML;
+                }
+                return /*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
+                    nonce: nonce,
+                    dangerouslySetInnerHTML: {
+                        __html: "(self.__next_s=self.__next_s||[]).push(" + JSON.stringify([
+                            0,
+                            {
+                                ...restProps,
+                                id
+                            }
+                        ]) + ")"
+                    }
+                });
+            } else {
+                // @ts-ignore
+                _reactdom.default.preload(src, restProps.integrity ? {
+                    as: 'script',
+                    integrity: restProps.integrity,
+                    nonce,
+                    crossOrigin: restProps.crossOrigin
+                } : {
+                    as: 'script',
+                    nonce,
+                    crossOrigin: restProps.crossOrigin
+                });
+                return /*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
+                    nonce: nonce,
+                    dangerouslySetInnerHTML: {
+                        __html: "(self.__next_s=self.__next_s||[]).push(" + JSON.stringify([
+                            src,
+                            {
+                                ...restProps,
+                                id
+                            }
+                        ]) + ")"
+                    }
+                });
+            }
+        } else if (strategy === 'afterInteractive') {
+            if (src) {
+                // @ts-ignore
+                _reactdom.default.preload(src, restProps.integrity ? {
+                    as: 'script',
+                    integrity: restProps.integrity,
+                    nonce,
+                    crossOrigin: restProps.crossOrigin
+                } : {
+                    as: 'script',
+                    nonce,
+                    crossOrigin: restProps.crossOrigin
+                });
+            }
+        }
+    }
+    return null;
+}
+Object.defineProperty(Script, '__nextScript', {
+    value: true
+});
+const _default = Script;
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=script.js.map

package/dist/assets/dashboard/node_modules/next/dist/client/set-attributes-from-props.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "setAttributesFromProps", {
+    enumerable: true,
+    get: function() {
+        return setAttributesFromProps;
+    }
+});
+const DOMAttributeNames = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
+    noModule: 'noModule'
+};
+const ignoreProps = [
+    'onLoad',
+    'onReady',
+    'dangerouslySetInnerHTML',
+    'children',
+    'onError',
+    'strategy',
+    'stylesheets'
+];
+function isBooleanScriptAttribute(attr) {
+    return [
+        'async',
+        'defer',
+        'noModule'
+    ].includes(attr);
+}
+function setAttributesFromProps(el, props) {
+    for (const [p, value] of Object.entries(props)){
+        if (!props.hasOwnProperty(p)) continue;
+        if (ignoreProps.includes(p)) continue;
+        // we don't render undefined props to the DOM
+        if (value === undefined) {
+            continue;
+        }
+        const attr = DOMAttributeNames[p] || p.toLowerCase();
+        if (el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr)) {
+            // Correctly assign boolean script attributes
+            // https://github.com/vercel/next.js/pull/20748
+            ;
+            el[attr] = !!value;
+        } else {
+            el.setAttribute(attr, String(value));
+        }
+        // Remove falsy non-zero boolean attributes so they are correctly interpreted
+        // (e.g. if we set them to false, this coerces to the string "false", which the browser interprets as true)
+        if (value === false || el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr) && (!value || value === 'false')) {
+            // Call setAttribute before, as we need to set and unset the attribute to override force async:
+            // https://html.spec.whatwg.org/multipage/scripting.html#script-force-async
+            el.setAttribute(attr, '');
+            el.removeAttribute(attr);
+        }
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=set-attributes-from-props.js.map

package/dist/assets/dashboard/node_modules/next/dist/client/trusted-types.js

@@ -0,0 +1,40 @@
+/**
+ * Stores the Trusted Types Policy. Starts as undefined and can be set to null
+ * if Trusted Types is not supported in the browser.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "__unsafeCreateTrustedScriptURL", {
+    enumerable: true,
+    get: function() {
+        return __unsafeCreateTrustedScriptURL;
+    }
+});
+let policy;
+/**
+ * Getter for the Trusted Types Policy. If it is undefined, it is instantiated
+ * here or set to null if Trusted Types is not supported in the browser.
+ */ function getPolicy() {
+    if (typeof policy === 'undefined' && typeof window !== 'undefined') {
+        var _window_trustedTypes;
+        policy = ((_window_trustedTypes = window.trustedTypes) == null ? void 0 : _window_trustedTypes.createPolicy('nextjs', {
+            createHTML: (input)=>input,
+            createScript: (input)=>input,
+            createScriptURL: (input)=>input
+        })) || null;
+    }
+    return policy;
+}
+function __unsafeCreateTrustedScriptURL(url) {
+    var _getPolicy;
+    return ((_getPolicy = getPolicy()) == null ? void 0 : _getPolicy.createScriptURL(url)) || url;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=trusted-types.js.map

package/dist/assets/dashboard/node_modules/next/dist/client/with-router.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return withRouter;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _router = require("./router");
+function withRouter(ComposedComponent) {
+    function WithRouterWrapper(props) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(ComposedComponent, {
+            router: (0, _router.useRouter)(),
+            ...props
+        });
+    }
+    WithRouterWrapper.getInitialProps = ComposedComponent.getInitialProps;
+    WithRouterWrapper.origGetInitialProps = ComposedComponent.origGetInitialProps;
+    if (process.env.NODE_ENV !== 'production') {
+        const name = ComposedComponent.displayName || ComposedComponent.name || 'Unknown';
+        WithRouterWrapper.displayName = "withRouter(" + name + ")";
+    }
+    return WithRouterWrapper;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=with-router.js.map