@bleedingdev/modern-js-i18n-integration 0.0.0 → 3.9.0-ultramodern.6

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/dist/cjs/cli.js

@@ -0,0 +1,97 @@
+"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__, {
+    default: ()=>cli,
+    ultramodernI18nIntegrationPlugin: ()=>ultramodernI18nIntegrationPlugin
+});
+const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
+const runtimePaths = new Map([
+    [
+        '@modern-js/plugin-i18n/runtime',
+        '@modern-js/i18n-integration/runtime'
+    ],
+    [
+        '@modern-js/plugin-i18n/runtime/no-react-i18next',
+        '@modern-js/i18n-integration/runtime/no-react-i18next'
+    ]
+]);
+const integrationRuntimePaths = new Set(runtimePaths.values());
+const ultramodernI18nIntegrationPlugin = ()=>({
+        name: '@modern-js/i18n-integration',
+        pre: [
+            '@modern-js/plugin-i18n'
+        ],
+        setup (api) {
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>({
+                    entrypoint,
+                    plugins: plugins.map((plugin)=>{
+                        const path = runtimePaths.get(plugin.path);
+                        return path ? {
+                            ...plugin,
+                            path
+                        } : plugin;
+                    })
+                }));
+            api._internalServerPlugins(({ plugins })=>({
+                    plugins: plugins.map((plugin)=>'@modern-js/plugin-i18n/server' === plugin.name ? {
+                            ...plugin,
+                            name: '@modern-js/i18n-integration/server'
+                        } : plugin)
+                }));
+            api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                const { plugins } = await api.getHooks()._internalRuntimePlugins.call({
+                    entrypoint,
+                    plugins: []
+                });
+                const descriptor = plugins.find((plugin)=>integrationRuntimePaths.has(plugin.path));
+                const config = descriptor?.config;
+                const { localePathRedirect, languages = [], localisedUrls } = config?.localeDetection ?? {};
+                const resolved = (0, i18n_runtime_extensions_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
+                if (!localePathRedirect || !languages.length || !resolved.enabled) return {
+                    entrypoint,
+                    routes
+                };
+                return {
+                    entrypoint,
+                    routes: (0, i18n_runtime_extensions_namespaceObject.applyLocalisedUrlsToRoutes)(routes, languages, resolved.map)
+                };
+            });
+        }
+    });
+const cli = ultramodernI18nIntegrationPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.ultramodernI18nIntegrationPlugin = __webpack_exports__.ultramodernI18nIntegrationPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "ultramodernI18nIntegrationPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/federation/boundary.js

@@ -0,0 +1,100 @@
+"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__, {
+    FederatedI18nBoundary: ()=>FederatedI18nBoundary
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const consumer_namespaceObject = require("@modern-js/plugin-i18n/runtime/consumer");
+const external_react_namespaceObject = require("react");
+const FederatedI18nBoundary = ({ children, defaultNamespace, fallbackLanguage, resources, supportedLanguages })=>{
+    const parent = (0, external_react_namespaceObject.useContext)(consumer_namespaceObject.ModernI18nContext);
+    const I18nextProvider = (0, external_react_namespaceObject.useContext)(consumer_namespaceObject.ReactI18nextProviderContext);
+    if (!parent) throw new Error('FederatedI18nBoundary must be used within ModernI18nProvider');
+    const languages = supportedLanguages ?? parent.languages ?? Object.keys(resources);
+    const scopedInstance = (0, external_react_namespaceObject.useMemo)(()=>{
+        const parentInstance = (0, consumer_namespaceObject.getActualI18nextInstance)(parent.i18nInstance);
+        const clone = parentInstance.cloneInstance?.({
+            defaultNS: defaultNamespace,
+            fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
+            forkResourceStore: true,
+            initImmediate: false,
+            lng: parent.language,
+            ns: [
+                defaultNamespace
+            ],
+            resources,
+            supportedLngs: languages
+        });
+        if (!clone) throw new Error('FederatedI18nBoundary requires an i18n instance with cloneInstance support');
+        const resourceStore = clone.store;
+        const parentResourceStore = parentInstance.store;
+        const sharesNestedResourceState = Object.entries(resourceStore?.data ?? {}).some(([language, namespaces])=>{
+            const parentNamespaces = parentResourceStore?.data?.[language];
+            return namespaces === parentNamespaces || Object.entries(namespaces).some(([namespace, resource])=>null !== resource && 'object' == typeof resource && resource === parentNamespaces?.[namespace]);
+        });
+        if (clone === parentInstance || resourceStore === parentResourceStore || resourceStore?.data === parentResourceStore?.data || sharesNestedResourceState) throw new Error('FederatedI18nBoundary cloneInstance did not isolate the host resource store');
+        if (!resourceStore?.addResourceBundle || !clone.removeResourceBundle || !resourceStore.data) throw new Error('FederatedI18nBoundary requires an isolated mutable i18n resource store');
+        for (const [language, namespaces] of Object.entries(resourceStore.data))for (const namespace of Object.keys(namespaces))clone.removeResourceBundle(language, namespace);
+        for (const [language, namespaces] of Object.entries(resources))for (const [namespace, resource] of Object.entries(namespaces))resourceStore.addResourceBundle(language, namespace, resource, true, true);
+        return clone;
+    }, [
+        defaultNamespace,
+        fallbackLanguage,
+        languages,
+        parent.i18nInstance,
+        parent.language,
+        resources
+    ]);
+    const value = (0, external_react_namespaceObject.useMemo)(()=>({
+            ...parent,
+            i18nInstance: scopedInstance,
+            language: parent.language,
+            languages
+        }), [
+        languages,
+        parent,
+        scopedInstance
+    ]);
+    const scopedContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(consumer_namespaceObject.ModernI18nProvider, {
+        value: value,
+        children: children
+    });
+    return I18nextProvider ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
+        i18n: scopedInstance,
+        children: scopedContent
+    }) : scopedContent;
+};
+exports.FederatedI18nBoundary = __webpack_exports__.FederatedI18nBoundary;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FederatedI18nBoundary"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/federation/registration.js

@@ -0,0 +1,43 @@
+"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__, {
+    registerFederatedI18nBoundary: ()=>registerFederatedI18nBoundary
+});
+const external_boundary_js_namespaceObject = require("./boundary.js");
+function registerFederatedI18nBoundary(api) {
+    api.resolveComponent((component, { name })=>'i18n.FederatedI18nBoundary' === name ? external_boundary_js_namespaceObject.FederatedI18nBoundary : component);
+}
+exports.registerFederatedI18nBoundary = __webpack_exports__.registerFederatedI18nBoundary;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "registerFederatedI18nBoundary"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/languageSynchronization.js

@@ -0,0 +1,44 @@
+"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__, {
+    I18nLanguageSynchronization: ()=>I18nLanguageSynchronization
+});
+const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
+const I18nLanguageSynchronization = ({ i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang, children })=>{
+    const synchronizeLanguage = (0, i18n_runtime_extensions_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang);
+    return children(synchronizeLanguage);
+};
+exports.I18nLanguageSynchronization = __webpack_exports__.I18nLanguageSynchronization;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18nLanguageSynchronization"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/navigation.js

@@ -0,0 +1,220 @@
+"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__, {
+    I18nRouterNavigationProvider: ()=>I18nRouterNavigationProvider
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const no_react_i18next_namespaceObject = require("@modern-js/plugin-i18n/runtime/no-react-i18next");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const router_state_namespaceObject = require("@modern-js/runtime-extensions/router-state");
+const external_react_namespaceObject = require("react");
+const normalizeUrlPart = (value, prefix)=>{
+    if ('string' != typeof value || !value) return '';
+    return value.startsWith(prefix) ? value : `${prefix}${value}`;
+};
+const normalizeLocation = (location)=>{
+    if (!location || 'object' != typeof location) return null;
+    const locationValue = location;
+    if ('string' != typeof locationValue.pathname) return null;
+    return {
+        pathname: locationValue.pathname,
+        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
+        hash: normalizeUrlPart(locationValue.hash, '#')
+    };
+};
+const getWindowLocation = ()=>{
+    if (!(0, runtime_namespaceObject.isBrowser)()) return null;
+    return {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    };
+};
+const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
+    const framework = (0, router_state_namespaceObject.getRouterRuntimeState)(internalContext)?.framework || (0, router_state_namespaceObject.getRouterRuntimeState)(runtimeContext)?.framework;
+    if (framework) return framework;
+    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
+    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
+    if (inReactRouter) return 'react-router';
+};
+const getRouterInstance = (internalContext, contextRouter)=>{
+    if (contextRouter) return contextRouter;
+    const router = (0, router_state_namespaceObject.getRouterRuntimeState)(internalContext)?.instance;
+    if (!router || 'object' != typeof router) return null;
+    return router;
+};
+const getRouterStateLocation = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
+};
+const getRouterParams = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
+    if (!Array.isArray(matches)) return {};
+    return matches.reduce((params, match)=>{
+        if (match?.params) Object.assign(params, match.params);
+        return params;
+    }, {});
+};
+const getRouterSnapshot = (internalContext, contextRouter)=>{
+    const location = getRouterStateLocation(internalContext, contextRouter);
+    const params = getRouterParams(internalContext, contextRouter);
+    return JSON.stringify([
+        location?.pathname ?? '',
+        location?.search ?? '',
+        location?.hash ?? '',
+        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+};
+const useIntegratedRouterAdapter = ()=>{
+    const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
+    const internalContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
+    const routerApi = internalContext.router || runtimeContext.router;
+    const native = (0, no_react_i18next_namespaceObject.useNativeI18nRouterAdapter)();
+    const inReactRouter = native.hasRouter;
+    const reactRouterNavigate = native.navigate;
+    const reactRouterLocation = inReactRouter ? native.location : null;
+    const reactRouterParams = native.params;
+    const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+    const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
+    const contextRouter = contextUseRouter ? contextUseRouter({
+        warn: false
+    }) : null;
+    const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
+    const subscribeToRouter = (0, external_react_namespaceObject.useCallback)((update)=>{
+        const router = getRouterInstance(internalContext, contextRouter);
+        if (!router) return ()=>void 0;
+        const unsubscribers = [];
+        if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            const unsubscribe = subscribe.call(router, update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('tanstack' === framework && 'function' == typeof router.stores?.location?.subscribe) {
+            const unsubscribe = router.stores.location.subscribe(update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('tanstack' === framework && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            for (const eventType of [
+                'onBeforeNavigate',
+                'onBeforeLoad'
+            ]){
+                const unsubscribe = subscribe.call(router, eventType, update);
+                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+            }
+        }
+        return ()=>{
+            for (const unsubscribe of unsubscribers)unsubscribe();
+        };
+    }, [
+        contextRouter,
+        framework,
+        inReactRouter,
+        internalContext
+    ]);
+    const getSnapshot = (0, external_react_namespaceObject.useCallback)(()=>getRouterSnapshot(internalContext, contextRouter), [
+        contextRouter,
+        internalContext
+    ]);
+    (0, external_react_namespaceObject.useSyncExternalStore)(subscribeToRouter, getSnapshot, getSnapshot);
+    const navigate = (0, external_react_namespaceObject.useCallback)((href, options)=>{
+        const router = getRouterInstance(internalContext, contextRouter);
+        const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+        if ('tanstack' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+            throw new Error('TanStack router instance is not available.');
+        }
+        if (reactRouterNavigate) return reactRouterNavigate(href, options);
+        if ('react-router' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate(href, options);
+            throw new Error('React Router instance is not available.');
+        }
+    }, [
+        contextRouter,
+        internalContext,
+        inReactRouter,
+        reactRouterNavigate,
+        runtimeContext
+    ]);
+    const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
+    const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
+    return {
+        framework,
+        hasRouter,
+        location,
+        navigate: hasRouter ? navigate : null,
+        Link,
+        params,
+        ...'tanstack' === framework ? {
+            createLinkProps: createTanstackLinkProps
+        } : {}
+    };
+};
+const createTanstackLinkProps = (target)=>{
+    const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+    return {
+        to: target.pathname,
+        ...target.search ? {
+            search: target.search
+        } : {},
+        ...target.hash ? {
+            hash: target.hash
+        } : {},
+        ...void 0 === target.hashScrollIntoView ? {} : {
+            hashScrollIntoView: target.hashScrollIntoView
+        },
+        ...void 0 === preload ? {} : {
+            preload
+        }
+    };
+};
+const I18nRouterNavigationProvider = ({ children })=>{
+    const value = useIntegratedRouterAdapter();
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(no_react_i18next_namespaceObject.I18nNavigationProvider, {
+        value: value,
+        children: children
+    });
+};
+exports.I18nRouterNavigationProvider = __webpack_exports__.I18nRouterNavigationProvider;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18nRouterNavigationProvider"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/options.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime-no-react-i18next.js

@@ -0,0 +1,46 @@
+"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__, {
+    default: ()=>runtime_no_react_i18next,
+    i18nPlugin: ()=>i18nPlugin
+});
+const no_react_i18next_namespaceObject = require("@modern-js/plugin-i18n/runtime/no-react-i18next");
+const external_runtimeComposition_js_namespaceObject = require("./runtimeComposition.js");
+const i18nPlugin = (0, external_runtimeComposition_js_namespaceObject.composeI18nPlugin)(no_react_i18next_namespaceObject.i18nPlugin);
+const runtime_no_react_i18next = i18nPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.i18nPlugin = __webpack_exports__.i18nPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "i18nPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime.js

@@ -0,0 +1,46 @@
+"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__, {
+    default: ()=>runtime,
+    i18nPlugin: ()=>i18nPlugin
+});
+const runtime_namespaceObject = require("@modern-js/plugin-i18n/runtime");
+const external_runtimeComposition_js_namespaceObject = require("./runtimeComposition.js");
+const i18nPlugin = (0, external_runtimeComposition_js_namespaceObject.composeI18nPlugin)(runtime_namespaceObject.i18nPlugin);
+const runtime = i18nPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.i18nPlugin = __webpack_exports__.i18nPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "i18nPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});