@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/octane-tsc.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runOctaneTypecheck } from '../dist/esm-node/typecheck.mjs';
+
+process.exitCode = runOctaneTypecheck(process.argv.slice(2));

package/dist/cjs/bootstrap.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    assertNativeHydrationBuildId: ()=>assertNativeHydrationBuildId,
+    assertOctaneIdentity: ()=>assertOctaneIdentity,
+    readOctaneDocumentBootstrap: ()=>readOctaneDocumentBootstrap
+});
+const document_namespaceObject = require("@modern-js/renderer-core/document");
+const identity_namespaceObject = require("@modern-js/renderer-core/identity");
+function assertNativeHydrationBuildId(value) {
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error('An Octane document requires its native client compilation identity.');
+}
+function assertOctaneIdentity(identity) {
+    (0, identity_namespaceObject.readRendererIdentity)(identity, identity);
+    if ('octane' !== identity.renderer) throw new Error('An Octane application requires an Octane renderer identity.');
+}
+function readOctaneDocumentBootstrap(document, expectedIdentity, expectedNativeHydrationBuildId) {
+    assertOctaneIdentity(expectedIdentity);
+    const { identity, documentId, hydrating, nativeHydrationBuildId } = (0, document_namespaceObject.readDocumentBootstrap)(document, expectedIdentity, [
+        'nativeHydrationBuildId'
+    ]);
+    assertNativeHydrationBuildId(nativeHydrationBuildId);
+    if (void 0 !== expectedNativeHydrationBuildId && nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane hydration bytes belong to a different native client compilation.');
+    return Object.freeze({
+        identity,
+        documentId,
+        hydrating,
+        nativeHydrationBuildId
+    });
+}
+exports.assertNativeHydrationBuildId = __webpack_exports__.assertNativeHydrationBuildId;
+exports.assertOctaneIdentity = __webpack_exports__.assertOctaneIdentity;
+exports.readOctaneDocumentBootstrap = __webpack_exports__.readOctaneDocumentBootstrap;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertNativeHydrationBuildId",
+    "assertOctaneIdentity",
+    "readOctaneDocumentBootstrap"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/client.js

@@ -0,0 +1,371 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    hydrateOctaneApplication: ()=>hydrateOctaneApplication,
+    mountOctaneApplication: ()=>mountOctaneApplication,
+    readOctaneDocumentBootstrap: ()=>external_bootstrap_js_namespaceObject.readOctaneDocumentBootstrap
+});
+const identity_namespaceObject = require("@modern-js/renderer-core/identity");
+const external_octane_namespaceObject = require("octane");
+const streamed_signals_namespaceObject = require("octane/hydration/streamed-signals");
+const external_bootstrap_js_namespaceObject = require("./bootstrap.js");
+const external_federation_context_js_namespaceObject = require("./federation-context.js");
+const roots = new WeakMap();
+const documents = new WeakMap();
+const moduleResources = new WeakMap();
+function claimModuleResources(application) {
+    const dispose = application.dispose;
+    if (!dispose) return ()=>{};
+    let resources = moduleResources.get(dispose);
+    if (resources?.retired) throw new Error('A retired Octane application requires a fresh module resource instance.');
+    if (!resources) {
+        resources = {
+            users: 0,
+            retired: false
+        };
+        moduleResources.set(dispose, resources);
+    }
+    resources.users++;
+    let released = false;
+    return ()=>{
+        if (released) return;
+        released = true;
+        resources.users--;
+        if (0 === resources.users && !resources.retired) {
+            resources.retired = true;
+            dispose();
+        }
+    };
+}
+function retireAbandonedModule(application) {
+    if (application.dispose && moduleResources.get(application.dispose)?.users) return;
+    if (application.dispose && moduleResources.get(application.dispose)?.retired) return;
+    claimModuleResources(application)();
+}
+function observeRootErrors(options) {
+    let failed = false;
+    let failure;
+    let handle;
+    return {
+        options: {
+            ...options,
+            onUncaughtError (error) {
+                if (failed) return;
+                failed = true;
+                failure = error;
+                if (handle) {
+                    const failedHandle = handle;
+                    queueMicrotask(()=>{
+                        try {
+                            failedHandle.dispose();
+                        } catch (cleanupError) {
+                            failure = new AggregateError([
+                                error,
+                                cleanupError
+                            ], 'Octane rendering and cleanup failed.');
+                        }
+                        if (options?.onUncaughtError) options.onUncaughtError(failure);
+                        else throw failure;
+                    });
+                }
+            }
+        },
+        attach (next) {
+            handle = next;
+        },
+        assertInitialRender () {
+            if (failed) {
+                options?.onUncaughtError?.(failure);
+                throw failure;
+            }
+        }
+    };
+}
+function claimRoot(container) {
+    if (9 === container.nodeType) throw new Error('An Octane application requires a subtree root in its framework-owned document.');
+    if (roots.has(container)) throw new Error('An Octane application already owns this root container.');
+    const owner = Symbol('Octane root owner');
+    roots.set(container, owner);
+    return ()=>{
+        if (roots.get(container) === owner) roots.delete(container);
+    };
+}
+function cleanupResources(cleanups) {
+    const errors = [];
+    for (const cleanup of cleanups)try {
+        cleanup();
+    } catch (error) {
+        errors.push(error);
+    }
+    if (errors.length) throw new AggregateError(errors, 'Octane application cleanup failed.');
+}
+function reportCleanupError(input, error) {
+    if (input.options?.onUncaughtError) input.options.onUncaughtError(error);
+    else queueMicrotask(()=>{
+        throw error;
+    });
+}
+function loadApplication(input, abandon) {
+    const acquire = (application)=>{
+        try {
+            validateModule(application);
+        } catch (error) {
+            if (application && 'function' == typeof application.dispose) retireAbandonedModule(application);
+            throw error;
+        }
+        return {
+            application,
+            releaseModule: claimModuleResources(application)
+        };
+    };
+    const { signal } = input;
+    if (!signal) return input.load().then(acquire);
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        let abandoned = false;
+        const onAbort = ()=>{
+            if (settled) return;
+            settled = true;
+            abandoned = true;
+            signal.removeEventListener('abort', onAbort);
+            try {
+                abandon();
+                reject(signal.reason);
+            } catch (cleanupError) {
+                reject(new AggregateError([
+                    signal.reason,
+                    cleanupError
+                ], 'Octane startup cancellation failed.'));
+            }
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (signal.aborted) return void onAbort();
+        let loading;
+        try {
+            loading = input.load();
+        } catch (error) {
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+            return;
+        }
+        loading.then((application)=>{
+            if (abandoned) return void queueMicrotask(()=>{
+                try {
+                    retireAbandonedModule(application);
+                } catch (error) {
+                    reportCleanupError(input, error);
+                }
+            });
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            try {
+                resolve(acquire(application));
+            } catch (error) {
+                reject(error);
+            }
+        }, (error)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+function validateModule(application) {
+    if (!application || 'function' != typeof application.default) throw new TypeError('An Octane application module must default-export a native component.');
+    if (void 0 !== application.dispose && 'function' != typeof application.dispose) throw new TypeError('An Octane application disposer must be a function.');
+}
+function createHandle(input) {
+    let releaseModule = input.releaseModule;
+    let disposed = false;
+    const handle = {
+        root: input.root,
+        identity: Object.freeze({
+            ...input.identity
+        }),
+        update (next) {
+            if (disposed) throw new Error('Cannot update a disposed Octane application.');
+            validateModule(next);
+            const previousRelease = releaseModule;
+            const nextRelease = claimModuleResources(next);
+            releaseModule = nextRelease;
+            try {
+                input.federation ? input.root.render(external_federation_context_js_namespaceObject.FederationApplication, {
+                    scope: input.federation,
+                    application: next
+                }) : input.root.render(next.default, next.props);
+                previousRelease();
+            } catch (error) {
+                cleanupResources([
+                    previousRelease,
+                    ()=>handle.dispose()
+                ]);
+                throw error;
+            }
+        },
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            input.signal?.removeEventListener('abort', onAbort);
+            cleanupResources([
+                ()=>input.root.unmount(),
+                ()=>releaseModule(),
+                ()=>input.bridge?.dispose(),
+                input.release
+            ]);
+        }
+    };
+    function onAbort() {
+        queueMicrotask(()=>{
+            try {
+                handle.dispose();
+            } catch (error) {
+                input.onCleanupError?.(error);
+            }
+        });
+    }
+    input.signal?.addEventListener('abort', onAbort, {
+        once: true
+    });
+    return handle;
+}
+async function startApplication(input, release, hydration) {
+    const errors = observeRootErrors(input.options);
+    let bridge;
+    let root;
+    let releaseModule;
+    let handle;
+    let cleaned = false;
+    const cleanup = ()=>{
+        if (handle) return void handle.dispose();
+        if (cleaned) return;
+        cleaned = true;
+        cleanupResources([
+            ()=>root?.unmount(),
+            ()=>releaseModule?.(),
+            ()=>bridge?.dispose(),
+            release
+        ]);
+    };
+    try {
+        const federation = input.federation ? (0, external_federation_context_js_namespaceObject.createFederationScope)(input.federation, false) : void 0;
+        if (hydration) {
+            const { document, documentId } = hydration;
+            bridge = (0, streamed_signals_namespaceObject.bootstrapStreamedSignalHydration)({
+                buildId: input.nativeHydrationBuildId,
+                documentId,
+                ...null === document.defaultView ? {} : {
+                    target: document.defaultView
+                }
+            });
+        }
+        const loaded = await loadApplication(input, cleanup);
+        const application = loaded.application;
+        releaseModule = loaded.releaseModule;
+        input.signal?.throwIfAborted();
+        if (bridge) root = (0, external_octane_namespaceObject.hydrateRoot)(input.container, federation ? external_federation_context_js_namespaceObject.FederationApplication : application.default, federation ? {
+            scope: federation,
+            application
+        } : application.props, {
+            ...errors.options,
+            signalOwner: bridge.signalOwner
+        });
+        else {
+            root = (0, external_octane_namespaceObject.createRoot)(input.container, errors.options);
+            federation ? root.render(external_federation_context_js_namespaceObject.FederationApplication, {
+                scope: federation,
+                application
+            }) : root.render(application.default, application.props);
+        }
+        errors.assertInitialRender();
+        input.signal?.throwIfAborted();
+        handle = createHandle({
+            root,
+            identity: input.identity,
+            releaseModule,
+            release,
+            bridge,
+            federation,
+            ...void 0 === input.signal ? {} : {
+                signal: input.signal
+            },
+            onCleanupError: (error)=>reportCleanupError(input, error)
+        });
+        errors.attach(handle);
+        return handle;
+    } catch (error) {
+        cleanup();
+        throw error;
+    }
+}
+async function mountOctaneApplication(input) {
+    (0, external_bootstrap_js_namespaceObject.assertOctaneIdentity)(input.identity);
+    (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(input.nativeHydrationBuildId);
+    input.signal?.throwIfAborted();
+    return startApplication(input, claimRoot(input.container));
+}
+async function hydrateOctaneApplication(input) {
+    (0, external_bootstrap_js_namespaceObject.assertOctaneIdentity)(input.identity);
+    (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(input.nativeHydrationBuildId);
+    (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(input.documentNativeHydrationBuildId);
+    if (input.nativeHydrationBuildId !== input.documentNativeHydrationBuildId) throw new Error('Octane hydration bytes belong to a different native client compilation.');
+    (0, identity_namespaceObject.assertRendererIdentity)(input.documentIdentity, input.identity);
+    input.signal?.throwIfAborted();
+    if ('string' != typeof input.documentId || 0 === input.documentId.trim().length) throw new Error('Octane hydration requires a nonempty document identity.');
+    const document = input.container.ownerDocument;
+    if (!document) throw new Error('An Octane hydration root requires a document.');
+    if (document !== globalThis.document) throw new Error('Octane hydration requires a root in the active browser document.');
+    if (documents.has(document)) throw new Error('An Octane signal bridge already owns this document.');
+    const releaseRoot = claimRoot(input.container);
+    const documentOwner = Symbol(input.documentId);
+    documents.set(document, documentOwner);
+    const release = ()=>{
+        releaseRoot();
+        if (documents.get(document) === documentOwner) documents.delete(document);
+    };
+    return startApplication(input, release, {
+        document,
+        documentId: input.documentId
+    });
+}
+exports.hydrateOctaneApplication = __webpack_exports__.hydrateOctaneApplication;
+exports.mountOctaneApplication = __webpack_exports__.mountOctaneApplication;
+exports.readOctaneDocumentBootstrap = __webpack_exports__.readOctaneDocumentBootstrap;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "hydrateOctaneApplication",
+    "mountOctaneApplication",
+    "readOctaneDocumentBootstrap"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/entry-application.js

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    componentView: ()=>componentView,
+    localizedRouterRoot: ()=>localizedRouterRoot,
+    octaneRouterFactory: ()=>octaneRouterFactory
+});
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const external_octane_namespaceObject = require("octane");
+const I18nProvider_js_namespaceObject = require("./i18n/I18nProvider.js");
+const external_routes_js_namespaceObject = require("./routes.js");
+function componentView(component, i18n) {
+    const App = component;
+    if (!i18n) return App;
+    return ()=>(0, external_octane_namespaceObject.createElement)(I18nProvider_js_namespaceObject.I18nProvider, {
+            instance: i18n.instance,
+            languages: i18n.languages,
+            localisedUrls: i18n.localisedUrls,
+            children: (0, external_octane_namespaceObject.createElement)(App)
+        });
+}
+const octaneRouterFactory = {
+    routeTree: (routes, modules, options)=>(0, external_routes_js_namespaceObject.createFileSystemRouteTree)(routes, modules, options),
+    router: ({ location, ...options })=>(0, tanstack_router_namespaceObject.createRouter)({
+            ...options,
+            ...location ? {
+                origin: location.origin,
+                history: (0, tanstack_router_namespaceObject.createMemoryHistory)({
+                    initialEntries: [
+                        location.href
+                    ]
+                })
+            } : {}
+        })
+};
+function localizedRouterRoot(Root) {
+    return ({ router, i18n })=>(0, external_octane_namespaceObject.createElement)(I18nProvider_js_namespaceObject.I18nProvider, {
+            instance: i18n.instance,
+            languages: i18n.languages,
+            localisedUrls: i18n.localisedUrls,
+            children: (0, external_octane_namespaceObject.createElement)(Root, {
+                router
+            })
+        });
+}
+exports.componentView = __webpack_exports__.componentView;
+exports.localizedRouterRoot = __webpack_exports__.localizedRouterRoot;
+exports.octaneRouterFactory = __webpack_exports__.octaneRouterFactory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "componentView",
+    "localizedRouterRoot",
+    "octaneRouterFactory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/entry-client.js

@@ -0,0 +1,92 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    startNativeClient: ()=>startNativeClient
+});
+const entry_client_namespaceObject = require("@modern-js/renderer-core/entry-client");
+const router_namespaceObject = require("@modern-js/renderer-core/router");
+const external_client_js_namespaceObject = require("./client.js");
+const external_entry_application_js_namespaceObject = require("./entry-application.js");
+const external_router_client_js_namespaceObject = require("./router-client.js");
+const LocalizedRouterRoot = (0, external_entry_application_js_namespaceObject.localizedRouterRoot)(external_router_client_js_namespaceObject.OctaneRouterRoot);
+function startNativeClient(options) {
+    const { nativeHydrationBuildId } = options;
+    (0, entry_client_namespaceObject.startNativeClientEntry)(options, {
+        readBootstrap: (document, identity)=>(0, external_client_js_namespaceObject.readOctaneDocumentBootstrap)(document, identity, nativeHydrationBuildId),
+        createRouter: (application, routerOptions)=>(0, router_namespaceObject.createNativeRouter)(application, routerOptions, external_entry_application_js_namespaceObject.octaneRouterFactory),
+        async prepareRouter (router, hydrating, signal) {
+            if (hydrating) await (0, external_router_client_js_namespaceObject.prepareOctaneRouterHydration)(router, {
+                signal
+            });
+            else await router.load();
+        },
+        async start ({ root, identity, bootstrap, signal, load }) {
+            const application = {
+                container: root,
+                identity,
+                nativeHydrationBuildId,
+                federation: options.federation,
+                signal,
+                load: async ()=>{
+                    const view = await load();
+                    if ('component' === view.kind) return {
+                        default: (0, external_entry_application_js_namespaceObject.componentView)(view.component, view.i18n)
+                    };
+                    return view.i18n ? {
+                        default: LocalizedRouterRoot,
+                        props: {
+                            router: view.router,
+                            i18n: view.i18n
+                        }
+                    } : {
+                        default: external_router_client_js_namespaceObject.OctaneRouterRoot,
+                        props: {
+                            router: view.router
+                        }
+                    };
+                }
+            };
+            const handle = bootstrap?.hydrating ? await (0, external_client_js_namespaceObject.hydrateOctaneApplication)({
+                ...application,
+                documentIdentity: bootstrap.identity,
+                documentId: bootstrap.documentId,
+                documentNativeHydrationBuildId: bootstrap.nativeHydrationBuildId
+            }) : await (0, external_client_js_namespaceObject.mountOctaneApplication)(application);
+            return ()=>handle.dispose();
+        }
+    });
+}
+exports.startNativeClient = __webpack_exports__.startNativeClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "startNativeClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});