@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/esm/runtime/i18n/detection/cache.mjs

@@ -0,0 +1,103 @@
+const detectorInstanceCache = new WeakMap();
+const DETECTOR_SAFE_OPTION_KEYS = [
+    'lowerCaseLng',
+    'nonExplicitSupportedLngs',
+    'load',
+    'partialBundledLanguages',
+    'returnNull',
+    'returnEmptyString',
+    'returnObjects',
+    'joinArrays',
+    'keySeparator',
+    'nsSeparator',
+    'pluralSeparator',
+    'contextSeparator',
+    'fallbackNS',
+    'ns',
+    'defaultNS',
+    'debug'
+];
+const stableStringify = (value)=>{
+    if (null == value) return JSON.stringify(value);
+    if ('object' != typeof value) return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map((item)=>stableStringify(item)).join(',')}]`;
+    const record = value;
+    const sortedKeys = Object.keys(record).sort();
+    const sortedEntries = sortedKeys.map((key)=>{
+        const stringifiedValue = stableStringify(record[key]);
+        return `${JSON.stringify(key)}:${stringifiedValue}`;
+    });
+    return `{${sortedEntries.join(',')}}`;
+};
+const buildDetectorConfigKey = (languages, fallbackLanguage, mergedDetection)=>stableStringify({
+        languages,
+        fallbackLanguage,
+        detection: mergedDetection
+    });
+const pickSafeDetectionOptions = (userInitOptions)=>{
+    if (!userInitOptions) return {};
+    const safeOptions = {};
+    for (const key of DETECTOR_SAFE_OPTION_KEYS){
+        const value = userInitOptions[key];
+        if (void 0 !== value) safeOptions[key] = value;
+    }
+    if (userInitOptions.interpolation) safeOptions.interpolation = {
+        ...userInitOptions.interpolation
+    };
+    return safeOptions;
+};
+const cleanupDetectorCacheEntry = (entry)=>{
+    if (!entry || !entry.isTemporary) return;
+    const instance = entry.instance;
+    try {
+        instance?.removeAllListeners?.();
+    } catch (error) {}
+    try {
+        instance?.off?.('*');
+    } catch (error) {}
+    try {
+        instance?.services?.backendConnector?.backend?.stop?.();
+    } catch (error) {}
+    try {
+        instance?.services?.backendConnector?.backend?.close?.();
+    } catch (error) {}
+};
+const createDetectorInstance = (baseInstance, configKey)=>{
+    const cached = detectorInstanceCache.get(baseInstance);
+    if (cached && cached.configKey === configKey) return {
+        instance: cached.instance,
+        isTemporary: cached.isTemporary
+    };
+    if (cached) {
+        cleanupDetectorCacheEntry(cached);
+        detectorInstanceCache.delete(baseInstance);
+    }
+    const createNewInstance = ()=>{
+        if ('function' == typeof baseInstance.createInstance) try {
+            const created = baseInstance.createInstance();
+            if (created) return {
+                instance: created,
+                isTemporary: true
+            };
+        } catch (error) {}
+        if ('function' == typeof baseInstance.cloneInstance) try {
+            const cloned = baseInstance.cloneInstance();
+            if (cloned) return {
+                instance: cloned,
+                isTemporary: true
+            };
+        } catch (error) {}
+        return {
+            instance: baseInstance,
+            isTemporary: false
+        };
+    };
+    const created = createNewInstance();
+    if (created.isTemporary) detectorInstanceCache.set(baseInstance, {
+        instance: created.instance,
+        isTemporary: true,
+        configKey
+    });
+    return created;
+};
+export { buildDetectorConfigKey, createDetectorInstance, detectorInstanceCache, pickSafeDetectionOptions };

package/dist/esm/runtime/i18n/detection/detector.mjs

@@ -0,0 +1,62 @@
+import { isBrowser } from "@modern-js/runtime";
+import { buildDetectorConfigKey, createDetectorInstance, detectorInstanceCache, pickSafeDetectionOptions } from "./cache.mjs";
+import { mergeDetectionOptions } from "./initOptions.mjs";
+import { getSupportedLanguage, isLanguageSupported } from "./language.mjs";
+import { detectLanguage, useI18nextLanguageDetector } from "./middleware.mjs";
+const initializeI18nForDetector = async (i18nInstance, options)=>{
+    const mergedDetection = mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
+    const configKey = buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection);
+    const { instance, isTemporary } = createDetectorInstance(i18nInstance, configKey);
+    const safeUserOptions = pickSafeDetectionOptions(options.userInitOptions);
+    const initOptions = {
+        ...safeUserOptions,
+        fallbackLng: options.fallbackLanguage,
+        supportedLngs: options.languages,
+        detection: mergedDetection,
+        initImmediate: true,
+        interpolation: {
+            ...safeUserOptions?.interpolation || {},
+            escapeValue: safeUserOptions?.interpolation?.escapeValue ?? false
+        },
+        react: {
+            useSuspense: false
+        }
+    };
+    useI18nextLanguageDetector(instance);
+    if (instance.isInitialized) {
+        if (isTemporary) await instance.init(initOptions);
+    } else await instance.init(initOptions);
+    return {
+        detectorInstance: instance,
+        isTemporary
+    };
+};
+const detectLanguageFromI18nextDetector = async (i18nInstance, options)=>{
+    if (!options.i18nextDetector) return;
+    const mergedDetection = mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
+    const { detectorInstance, isTemporary } = await initializeI18nForDetector(i18nInstance, options);
+    try {
+        const request = options.ssrContext?.request;
+        if (!isBrowser() && !request) return;
+        const detectorLang = detectLanguage(detectorInstance, request, mergedDetection);
+        if (detectorLang) {
+            const supportedLang = getSupportedLanguage(detectorLang, options.languages);
+            if (supportedLang) return supportedLang;
+        }
+        if (detectorInstance.isInitialized && detectorInstance.language) {
+            const currentLang = detectorInstance.language;
+            if (isLanguageSupported(currentLang, options.languages)) return currentLang;
+        }
+    } catch (error) {} finally{
+        if (isTemporary && detectorInstance !== i18nInstance) detectorInstanceCache.set(i18nInstance, {
+            instance: detectorInstance,
+            isTemporary: true,
+            configKey: buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection)
+        });
+        else if (detectorInstance === i18nInstance) {
+            i18nInstance.isInitialized = false;
+            delete i18nInstance.language;
+        }
+    }
+};
+export { detectLanguageFromI18nextDetector };

package/dist/esm/runtime/i18n/detection/index.mjs

@@ -1,260 +1,4 @@
-import { isBrowser } from "@modern-js/runtime";
-import { detectLanguageFromPath } from "../../utils.mjs";
-import { isI18nWrapperInstance } from "../instance.mjs";
-import { mergeDetectionOptions } from "./config.mjs";
-import { cacheUserLanguage, detectLanguage, readLanguageFromStorage, useI18nextLanguageDetector } from "./middleware.mjs";
-const detectorInstanceCache = new WeakMap();
-const DETECTOR_SAFE_OPTION_KEYS = [
-    'lowerCaseLng',
-    'nonExplicitSupportedLngs',
-    'load',
-    'partialBundledLanguages',
-    'returnNull',
-    'returnEmptyString',
-    'returnObjects',
-    'joinArrays',
-    'keySeparator',
-    'nsSeparator',
-    'pluralSeparator',
-    'contextSeparator',
-    'fallbackNS',
-    'ns',
-    'defaultNS',
-    'debug'
-];
-const stableStringify = (value)=>{
-    if (null == value) return JSON.stringify(value);
-    if ('object' != typeof value) return JSON.stringify(value);
-    if (Array.isArray(value)) return `[${value.map((item)=>stableStringify(item)).join(',')}]`;
-    const sortedKeys = Object.keys(value).sort();
-    const sortedEntries = sortedKeys.map((key)=>{
-        const stringifiedValue = stableStringify(value[key]);
-        return `${JSON.stringify(key)}:${stringifiedValue}`;
-    });
-    return `{${sortedEntries.join(',')}}`;
-};
-const buildDetectorConfigKey = (languages, fallbackLanguage, mergedDetection)=>stableStringify({
-        languages,
-        fallbackLanguage,
-        detection: mergedDetection
-    });
-const pickSafeDetectionOptions = (userInitOptions)=>{
-    if (!userInitOptions) return {};
-    const safeOptions = {};
-    for (const key of DETECTOR_SAFE_OPTION_KEYS){
-        const value = userInitOptions[key];
-        if (void 0 !== value) safeOptions[key] = value;
-    }
-    if (userInitOptions.interpolation) safeOptions.interpolation = {
-        ...userInitOptions.interpolation
-    };
-    return safeOptions;
-};
-const cleanupDetectorCacheEntry = (entry)=>{
-    if (!entry || !entry.isTemporary) return;
-    const instance = entry.instance;
-    try {
-        instance?.removeAllListeners?.();
-    } catch (error) {}
-    try {
-        instance?.off?.('*');
-    } catch (error) {}
-    try {
-        instance?.services?.backendConnector?.backend?.stop?.();
-    } catch (error) {}
-    try {
-        instance?.services?.backendConnector?.backend?.close?.();
-    } catch (error) {}
-};
-function exportServerLngToWindow(context, lng) {
-    context.__i18nData__ = {
-        lng
-    };
-}
-const getLanguageFromSSRData = (window1)=>{
-    try {
-        const ssrData = window1._SSR_DATA;
-        if (!ssrData || !ssrData.data || !ssrData.data.i18nData) return;
-        const lng = ssrData.data.i18nData.lng;
-        return 'string' == typeof lng && '' !== lng.trim() ? lng : void 0;
-    } catch (error) {
-        return;
-    }
-};
-const normalizeLanguageCode = (language)=>{
-    if (!language) return language;
-    const baseLang = language.split('-')[0];
-    return baseLang;
-};
-const isLanguageSupported = (language, supportedLanguages)=>{
-    if (!language) return false;
-    if (0 === supportedLanguages.length) return true;
-    if (supportedLanguages.includes(language)) return true;
-    const baseLang = normalizeLanguageCode(language);
-    if (baseLang !== language && supportedLanguages.includes(baseLang)) return true;
-    return false;
-};
-const getSupportedLanguage = (language, supportedLanguages)=>{
-    if (!language) return;
-    if (0 === supportedLanguages.length) return language;
-    if (supportedLanguages.includes(language)) return language;
-    const baseLang = normalizeLanguageCode(language);
-    if (baseLang !== language && supportedLanguages.includes(baseLang)) return baseLang;
-};
-const detectLanguageFromSSR = (languages)=>{
-    if (!isBrowser()) return;
-    try {
-        const ssrLanguage = getLanguageFromSSRData(window);
-        if (ssrLanguage && isLanguageSupported(ssrLanguage, languages)) return ssrLanguage;
-    } catch (error) {}
-};
-const detectLanguageFromPathPriority = (pathname, languages, localePathRedirect)=>{
-    if (!localePathRedirect) return;
-    if (!languages || 0 === languages.length) return;
-    if (!pathname || '' === pathname.trim()) return;
-    try {
-        const pathDetection = detectLanguageFromPath(pathname, languages, localePathRedirect);
-        if (true === pathDetection.detected && pathDetection.language) return pathDetection.language;
-    } catch (error) {}
-};
-const createDetectorInstance = (baseInstance, configKey)=>{
-    const cached = detectorInstanceCache.get(baseInstance);
-    if (cached && cached.configKey === configKey) return {
-        instance: cached.instance,
-        isTemporary: cached.isTemporary
-    };
-    if (cached) {
-        cleanupDetectorCacheEntry(cached);
-        detectorInstanceCache.delete(baseInstance);
-    }
-    const createNewInstance = ()=>{
-        if ('function' == typeof baseInstance.createInstance) try {
-            const created = baseInstance.createInstance();
-            if (created) return {
-                instance: created,
-                isTemporary: true
-            };
-        } catch (error) {}
-        if ('function' == typeof baseInstance.cloneInstance) try {
-            const cloned = baseInstance.cloneInstance();
-            if (cloned) return {
-                instance: cloned,
-                isTemporary: true
-            };
-        } catch (error) {}
-        return {
-            instance: baseInstance,
-            isTemporary: false
-        };
-    };
-    const created = createNewInstance();
-    if (created.isTemporary) detectorInstanceCache.set(baseInstance, {
-        instance: created.instance,
-        isTemporary: true,
-        configKey
-    });
-    return created;
-};
-const initializeI18nForDetector = async (i18nInstance, options)=>{
-    const mergedDetection = detection_mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
-    const configKey = buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection);
-    const { instance, isTemporary } = createDetectorInstance(i18nInstance, configKey);
-    const safeUserOptions = pickSafeDetectionOptions(options.userInitOptions);
-    const initOptions = {
-        ...safeUserOptions,
-        fallbackLng: options.fallbackLanguage,
-        supportedLngs: options.languages,
-        detection: mergedDetection,
-        initImmediate: true,
-        interpolation: {
-            ...safeUserOptions?.interpolation || {},
-            escapeValue: safeUserOptions?.interpolation?.escapeValue ?? false
-        },
-        react: {
-            useSuspense: false
-        }
-    };
-    useI18nextLanguageDetector(instance);
-    if (instance.isInitialized) {
-        if (isTemporary) await instance.init(initOptions);
-    } else await instance.init(initOptions);
-    return {
-        detectorInstance: instance,
-        isTemporary
-    };
-};
-const detectLanguageFromI18nextDetector = async (i18nInstance, options)=>{
-    if (!options.i18nextDetector) return;
-    const mergedDetection = detection_mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
-    const { detectorInstance, isTemporary } = await initializeI18nForDetector(i18nInstance, options);
-    try {
-        const request = options.ssrContext?.request;
-        if (!isBrowser() && !request) return;
-        const detectorLang = detectLanguage(detectorInstance, request, mergedDetection);
-        if (detectorLang) {
-            const supportedLang = getSupportedLanguage(detectorLang, options.languages);
-            if (supportedLang) return supportedLang;
-        }
-        if (detectorInstance.isInitialized && detectorInstance.language) {
-            const currentLang = detectorInstance.language;
-            if (isLanguageSupported(currentLang, options.languages)) return currentLang;
-        }
-    } catch (error) {} finally{
-        if (isTemporary && detectorInstance !== i18nInstance) detectorInstanceCache.set(i18nInstance, {
-            instance: detectorInstance,
-            isTemporary: true,
-            configKey: buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection)
-        });
-        else if (detectorInstance === i18nInstance) {
-            i18nInstance.isInitialized = false;
-            delete i18nInstance.language;
-        }
-    }
-};
-const detectLanguageWithPriority = async (i18nInstance, options)=>{
-    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
-    let detectedLanguage;
-    detectedLanguage = detectLanguageFromSSR(languages);
-    if (!detectedLanguage) detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
-    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(detection_mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
-        languages,
-        fallbackLanguage,
-        localePathRedirect,
-        i18nextDetector,
-        detection,
-        userInitOptions,
-        mergedBackend: options.mergedBackend,
-        ssrContext
-    });
-    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
-    return {
-        detectedLanguage,
-        finalLanguage
-    };
-};
-const buildInitOptions = (params)=>{
-    const { finalLanguage, fallbackLanguage, languages, userInitOptions, mergedDetection, mergeBackend } = params;
-    return {
-        ...userInitOptions || {},
-        lng: finalLanguage,
-        fallbackLng: fallbackLanguage,
-        supportedLngs: languages,
-        detection: mergedDetection,
-        backend: mergeBackend,
-        interpolation: {
-            ...userInitOptions?.interpolation || {},
-            escapeValue: userInitOptions?.interpolation?.escapeValue ?? false
-        },
-        react: {
-            useSuspense: isBrowser()
-        }
-    };
-};
-const detection_mergeDetectionOptions = (i18nextDetector, detection, localePathRedirect, userInitOptions)=>{
-    let mergedDetection;
-    mergedDetection = i18nextDetector ? mergeDetectionOptions(detection, userInitOptions?.detection) : userInitOptions?.detection || {};
-    if (!mergedDetection || 'object' != typeof mergedDetection) mergedDetection = {};
-    if (localePathRedirect && mergedDetection.order) mergedDetection.order = mergedDetection.order.filter((item)=>'path' !== item);
-    return mergedDetection;
-};
-export { buildInitOptions, cacheUserLanguage, detectLanguageWithPriority, detection_mergeDetectionOptions as mergeDetectionOptions, exportServerLngToWindow, getLanguageFromSSRData };
+export { buildInitOptions, mergeDetectionOptions } from "./initOptions.mjs";
+export { cacheUserLanguage } from "./middleware.mjs";
+export { detectLanguageWithPriority } from "./priority.mjs";
+export { exportServerLngToWindow, getLanguageFromSSRData } from "./ssr.mjs";

package/dist/esm/runtime/i18n/detection/initOptions.mjs

@@ -0,0 +1,28 @@
+import { isBrowser } from "@modern-js/runtime";
+import { mergeDetectionOptions } from "./config.mjs";
+const buildInitOptions = (params)=>{
+    const { finalLanguage, fallbackLanguage, languages, userInitOptions, mergedDetection, mergeBackend } = params;
+    return {
+        ...userInitOptions || {},
+        lng: finalLanguage,
+        fallbackLng: fallbackLanguage,
+        supportedLngs: languages,
+        detection: mergedDetection,
+        backend: mergeBackend,
+        interpolation: {
+            ...userInitOptions?.interpolation || {},
+            escapeValue: userInitOptions?.interpolation?.escapeValue ?? false
+        },
+        react: {
+            useSuspense: isBrowser()
+        }
+    };
+};
+const initOptions_mergeDetectionOptions = (i18nextDetector, detection, localePathRedirect, userInitOptions)=>{
+    let mergedDetection;
+    mergedDetection = i18nextDetector ? mergeDetectionOptions(detection, userInitOptions?.detection) : userInitOptions?.detection || {};
+    if (!mergedDetection || 'object' != typeof mergedDetection) mergedDetection = {};
+    if (localePathRedirect && mergedDetection.order) mergedDetection.order = mergedDetection.order.filter((item)=>'path' !== item);
+    return mergedDetection;
+};
+export { buildInitOptions, initOptions_mergeDetectionOptions as mergeDetectionOptions };

package/dist/esm/runtime/i18n/detection/language.mjs

@@ -0,0 +1,21 @@
+const normalizeLanguageCode = (language)=>{
+    if (!language) return language;
+    const baseLang = language.split('-')[0];
+    return baseLang;
+};
+const isLanguageSupported = (language, supportedLanguages)=>{
+    if (!language) return false;
+    if (0 === supportedLanguages.length) return true;
+    if (supportedLanguages.includes(language)) return true;
+    const baseLang = normalizeLanguageCode(language);
+    if (baseLang !== language && supportedLanguages.includes(baseLang)) return true;
+    return false;
+};
+const getSupportedLanguage = (language, supportedLanguages)=>{
+    if (!language) return;
+    if (0 === supportedLanguages.length) return language;
+    if (supportedLanguages.includes(language)) return language;
+    const baseLang = normalizeLanguageCode(language);
+    if (baseLang !== language && supportedLanguages.includes(baseLang)) return baseLang;
+};
+export { getSupportedLanguage, isLanguageSupported };

package/dist/esm/runtime/i18n/detection/path.mjs

@@ -0,0 +1,11 @@
+import { detectLanguageFromPath } from "../../utils.mjs";
+const detectLanguageFromPathPriority = (pathname, languages, localePathRedirect)=>{
+    if (!localePathRedirect) return;
+    if (!languages || 0 === languages.length) return;
+    if (!pathname || '' === pathname.trim()) return;
+    try {
+        const pathDetection = detectLanguageFromPath(pathname, languages, localePathRedirect);
+        if (true === pathDetection.detected && pathDetection.language) return pathDetection.language;
+    } catch (error) {}
+};
+export { detectLanguageFromPathPriority };

package/dist/esm/runtime/i18n/detection/priority.mjs

@@ -0,0 +1,28 @@
+import { isI18nWrapperInstance } from "../instance.mjs";
+import { detectLanguageFromI18nextDetector } from "./detector.mjs";
+import { mergeDetectionOptions } from "./initOptions.mjs";
+import { readLanguageFromStorage } from "./middleware.mjs";
+import { detectLanguageFromPathPriority } from "./path.mjs";
+import { detectLanguageFromSSR } from "./ssr.mjs";
+const detectLanguageWithPriority = async (i18nInstance, options)=>{
+    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
+    let detectedLanguage;
+    detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
+    if (!detectedLanguage) detectedLanguage = detectLanguageFromSSR(languages);
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend: options.mergedBackend,
+        ssrContext
+    });
+    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
+    return {
+        detectedLanguage,
+        finalLanguage
+    };
+};
+export { detectLanguageWithPriority };

package/dist/esm/runtime/i18n/detection/ssr.mjs

@@ -0,0 +1,26 @@
+import { isBrowser } from "@modern-js/runtime";
+import { getSupportedLanguage } from "./language.mjs";
+function exportServerLngToWindow(context, lng) {
+    context.__i18nData__ = {
+        lng
+    };
+}
+const getLanguageFromSSRData = (window1)=>{
+    try {
+        const ssrData = window1._SSR_DATA;
+        if (!ssrData || !ssrData.data || !ssrData.data.i18nData) return;
+        const lng = ssrData.data.i18nData.lng;
+        return 'string' == typeof lng && '' !== lng.trim() ? lng : void 0;
+    } catch (error) {
+        return;
+    }
+};
+const detectLanguageFromSSR = (languages)=>{
+    if (!isBrowser()) return;
+    try {
+        const ssrLanguage = getLanguageFromSSRData(window);
+        const supportedLanguage = getSupportedLanguage(ssrLanguage, languages);
+        if (supportedLanguage) return supportedLanguage;
+    } catch (error) {}
+};
+export { detectLanguageFromSSR, exportServerLngToWindow, getLanguageFromSSRData };

package/dist/esm/runtime/i18n/instance.mjs

@@ -1,8 +1,10 @@
 function isI18nWrapperInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
-    if (!obj.i18nInstance || 'object' != typeof obj.i18nInstance) return false;
-    if (!obj.i18nInstance.instance) return false;
-    if ('function' != typeof obj.init || 'function' != typeof obj.use) return false;
+    const candidate = obj;
+    if (!candidate.i18nInstance || 'object' != typeof candidate.i18nInstance) return false;
+    const wrapper = candidate.i18nInstance;
+    if (!wrapper.instance) return false;
+    if ('function' != typeof candidate.init || 'function' != typeof candidate.use) return false;
     return true;
 }
 function getI18nWrapperI18nextInstance(wrapperInstance) {
@@ -19,7 +21,8 @@ function getActualI18nextInstance(instance) {
 function isI18nInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
     if (isI18nWrapperInstance(obj)) return true;
-    return 'function' == typeof obj.init && 'function' == typeof obj.use;
+    const candidate = obj;
+    return 'function' == typeof candidate.init && 'function' == typeof candidate.use;
 }
 async function tryImportI18next() {
     try {
@@ -40,12 +43,36 @@ async function createI18nextInstance() {
         return null;
     }
 }
-function getI18nextInstanceForProvider(instance) {
+function getI18nextInstanceForProvider(instance, language) {
+    let providerInstance = instance;
     if (isI18nWrapperInstance(instance)) {
         const i18nextInstance = getI18nWrapperI18nextInstance(instance);
-        if (i18nextInstance) return i18nextInstance;
+        if (i18nextInstance) providerInstance = i18nextInstance;
     }
-    return instance;
+    if (!language || "u" < typeof Proxy) return providerInstance;
+    return new Proxy(providerInstance, {
+        get (target, property, receiver) {
+            if ('language' === property || 'resolvedLanguage' === property) return language;
+            if ('languages' === property) {
+                const languages = Reflect.get(target, property, receiver);
+                return Array.isArray(languages) ? [
+                    language,
+                    ...languages.filter((item)=>item !== language)
+                ] : [
+                    language
+                ];
+            }
+            if ('t' === property && 'function' == typeof target.getFixedT) return target.getFixedT(language);
+            if ('hasLoadedNamespace' === property && 'function' == typeof target.hasLoadedNamespace) {
+                const hasLoadedNamespace = target.hasLoadedNamespace;
+                return (namespace, options)=>hasLoadedNamespace.call(target, namespace, {
+                        ...options,
+                        lng: options?.lng || language
+                    });
+            }
+            return Reflect.get(target, property, receiver);
+        }
+    });
 }
 async function getI18nInstance(userInstance) {
     if (userInstance) {
@@ -56,4 +83,4 @@ async function getI18nInstance(userInstance) {
     if (i18nextInstance) return i18nextInstance;
     throw new Error('No i18n instance found');
 }
-export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };
+export { getActualI18nextInstance, getI18nInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };