@tolgee/core 5.8.1-prerelease.16fc4f78.0 → 5.8.2

package/dist/tolgee.cjs.js

@@ -5,15 +5,17 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function isPromise(value) {
     return Boolean(value && typeof value.then === 'function');
 }
-const valueOrPromise = (value, callback) => {
+function valueOrPromise(value, callback) {
     if (isPromise(value)) {
         return Promise.resolve(value).then(callback);
     }
     else {
         return callback(value);
     }
-};
-const missingOptionError = (option) => `Tolgee: You need to specify '${option}' option`;
+}
+function missingOptionError(option) {
+    return `Tolgee: You need to specify '${option}' option`;
+}
 function isObject(item) {
     return typeof item === 'object' && !Array.isArray(item) && item !== null;
 }
@@ -52,63 +54,32 @@ function getErrorMessage(error) {
     }
 }
 
-const EventEmitter = (isActive) => {
+function EventEmitter(isActive) {
     let handlers = [];
-    const listen = (handler) => {
-        const handlerWrapper = (e) => {
-            handler(e);
-        };
-        handlers.push(handlerWrapper);
-        return {
-            unsubscribe: () => {
-                handlers = handlers.filter((i) => handlerWrapper !== i);
-            },
-        };
-    };
-    const emit = (data) => {
-        if (isActive()) {
-            handlers.forEach((handler) => handler({ value: data }));
-        }
-    };
-    return Object.freeze({ listen, emit });
-};
+    return Object.freeze({
+        listen(handler) {
+            const handlerWrapper = (e) => {
+                handler(e);
+            };
+            handlers.push(handlerWrapper);
+            return {
+                unsubscribe() {
+                    handlers = handlers.filter((i) => handlerWrapper !== i);
+                },
+            };
+        },
+        emit(data) {
+            if (isActive()) {
+                handlers.forEach((handler) => handler({ value: data }));
+            }
+        },
+    });
+}
 
-const EventEmitterSelective = (isActive, getFallbackNs, getDefaultNs) => {
+function EventEmitterSelective(isActive, getFallbackNs, getDefaultNs) {
     const listeners = new Set();
     const partialListeners = new Set();
-    const listen = (handler) => {
-        listeners.add(handler);
-        const result = {
-            unsubscribe: () => {
-                listeners.delete(handler);
-            },
-        };
-        return result;
-    };
-    const listenSome = (handler) => {
-        const handlerWrapper = {
-            fn: (e) => {
-                handler(e);
-            },
-            namespaces: new Set(),
-        };
-        partialListeners.add(handlerWrapper);
-        const result = {
-            unsubscribe: () => {
-                partialListeners.delete(handlerWrapper);
-            },
-            subscribeNs: (ns) => {
-                getFallbackArray(ns).forEach((val) => handlerWrapper.namespaces.add(val));
-                if (ns === undefined) {
-                    // subscribing to default ns
-                    handlerWrapper.namespaces.add(getDefaultNs());
-                }
-                return result;
-            },
-        };
-        return result;
-    };
-    const callHandlers = (ns) => {
+    function callHandlers(ns) {
         // everything is implicitly subscribed to fallbacks
         // as it can always fall through to it
         const fallbackNamespaces = new Set(getFallbackNs());
@@ -119,10 +90,10 @@ const EventEmitterSelective = (isActive, getFallbackNs, getDefaultNs) => {
                 handler.fn({ value: undefined });
             }
         });
-    };
+    }
     let queue = [];
     // merge events in queue into one event
-    const solveQueue = () => {
+    function solveQueue() {
         if (queue.length === 0) {
             return;
         }
@@ -145,75 +116,97 @@ const EventEmitterSelective = (isActive, getFallbackNs, getDefaultNs) => {
             ? Array.from(namespaces.keys())
             : undefined;
         callHandlers(namespacesArray);
-    };
-    const emit = (ns, delayed) => {
-        if (isActive()) {
-            queue.push(ns);
-            if (!delayed) {
-                solveQueue();
-            }
-            else {
-                setTimeout(solveQueue, 0);
+    }
+    return Object.freeze({
+        emit(ns, delayed) {
+            if (isActive()) {
+                queue.push(ns);
+                if (!delayed) {
+                    solveQueue();
+                }
+                else {
+                    setTimeout(solveQueue, 0);
+                }
             }
-        }
-    };
-    return Object.freeze({ listenSome, listen, emit });
-};
+        },
+        listen(handler) {
+            listeners.add(handler);
+            const result = {
+                unsubscribe: () => {
+                    listeners.delete(handler);
+                },
+            };
+            return result;
+        },
+        listenSome(handler) {
+            const handlerWrapper = {
+                fn: (e) => {
+                    handler(e);
+                },
+                namespaces: new Set(),
+            };
+            partialListeners.add(handlerWrapper);
+            const result = {
+                unsubscribe: () => {
+                    partialListeners.delete(handlerWrapper);
+                },
+                subscribeNs: (ns) => {
+                    getFallbackArray(ns).forEach((val) => handlerWrapper.namespaces.add(val));
+                    if (ns === undefined) {
+                        // subscribing to default ns
+                        handlerWrapper.namespaces.add(getDefaultNs());
+                    }
+                    return result;
+                },
+            };
+            return result;
+        },
+    });
+}
 
-const Events = (getFallbackNs, getDefaultNs) => {
+function Events(getFallbackNs, getDefaultNs) {
     let emitterActive = true;
     function isActive() {
         return emitterActive;
     }
-    const onPendingLanguageChange = EventEmitter(isActive);
-    const onLanguageChange = EventEmitter(isActive);
-    const onLoadingChange = EventEmitter(isActive);
-    const onFetchingChange = EventEmitter(isActive);
-    const onInitialLoaded = EventEmitter(isActive);
-    const onRunningChange = EventEmitter(isActive);
-    const onCacheChange = EventEmitter(isActive);
-    const onUpdate = EventEmitterSelective(isActive, getFallbackNs, getDefaultNs);
-    onInitialLoaded.listen(() => onUpdate.emit());
-    onLanguageChange.listen(() => onUpdate.emit());
-    onCacheChange.listen(({ value }) => {
-        onUpdate.emit([value.namespace], true);
-    });
-    const on = (event, handler) => {
-        switch (event) {
-            case 'pendingLanguage':
-                return onPendingLanguageChange.listen(handler);
-            case 'language':
-                return onLanguageChange.listen(handler);
-            case 'loading':
-                return onLoadingChange.listen(handler);
-            case 'fetching':
-                return onFetchingChange.listen(handler);
-            case 'initialLoad':
-                return onInitialLoaded.listen(handler);
-            case 'running':
-                return onRunningChange.listen(handler);
-            case 'cache':
-                return onCacheChange.listen(handler);
-            case 'update':
-                return onUpdate.listen(handler);
-        }
-    };
-    function setEmitterActive(active) {
-        emitterActive = active;
-    }
-    return Object.freeze({
-        onPendingLanguageChange,
-        onLanguageChange,
-        onLoadingChange,
-        onFetchingChange,
-        onInitialLoaded,
-        onRunningChange,
-        onCacheChange,
-        onUpdate,
-        setEmitterActive,
-        on,
+    const self = Object.freeze({
+        onPendingLanguageChange: EventEmitter(isActive),
+        onLanguageChange: EventEmitter(isActive),
+        onLoadingChange: EventEmitter(isActive),
+        onFetchingChange: EventEmitter(isActive),
+        onInitialLoaded: EventEmitter(isActive),
+        onRunningChange: EventEmitter(isActive),
+        onCacheChange: EventEmitter(isActive),
+        onUpdate: EventEmitterSelective(isActive, getFallbackNs, getDefaultNs),
+        setEmitterActive(active) {
+            emitterActive = active;
+        },
+        on: ((event, handler) => {
+            switch (event) {
+                case 'pendingLanguage':
+                    return self.onPendingLanguageChange.listen(handler);
+                case 'language':
+                    return self.onLanguageChange.listen(handler);
+                case 'loading':
+                    return self.onLoadingChange.listen(handler);
+                case 'fetching':
+                    return self.onFetchingChange.listen(handler);
+                case 'initialLoad':
+                    return self.onInitialLoaded.listen(handler);
+                case 'running':
+                    return self.onRunningChange.listen(handler);
+                case 'cache':
+                    return self.onCacheChange.listen(handler);
+                case 'update':
+                    return self.onUpdate.listen(handler);
+            }
+        }),
     });
-};
+    self.onInitialLoaded.listen(() => self.onUpdate.emit());
+    self.onLanguageChange.listen(() => self.onUpdate.emit());
+    self.onCacheChange.listen(({ value }) => self.onUpdate.emit([value.namespace], true));
+    return self;
+}
 
 const flattenTranslations = (data) => {
     const result = new Map();
@@ -247,29 +240,11 @@ const encodeCacheKey = ({ language, namespace, }) => {
     }
 };
 
-const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefaultNs, isInitialLoading, fetchingObserver, loadingObserver) => {
+function Cache(onCacheChange, backendGetRecord, backendGetDevRecord, withDefaultNs, isInitialLoading, fetchingObserver, loadingObserver) {
     const asyncRequests = new Map();
     const cache = new Map();
     let staticData = {};
     let version = 0;
-    function addStaticData(data) {
-        if (data) {
-            staticData = Object.assign(Object.assign({}, staticData), data);
-            Object.entries(data).forEach(([key, value]) => {
-                if (typeof value !== 'function') {
-                    const descriptor = decodeCacheKey(key);
-                    const existing = cache.get(key);
-                    if (!existing || existing.version === 0) {
-                        addRecordInternal(descriptor, value, 0);
-                    }
-                }
-            });
-        }
-    }
-    function invalidate() {
-        asyncRequests.clear();
-        version += 1;
-    }
     function addRecordInternal(descriptor, data, recordVersion) {
         const cacheKey = encodeCacheKey(descriptor);
         cache.set(cacheKey, {
@@ -278,78 +253,6 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
         });
         onCacheChange.emit(descriptor);
     }
-    function addRecord(descriptor, data) {
-        addRecordInternal(descriptor, data, version);
-    }
-    function exists(descriptor, strict = false) {
-        const record = cache.get(encodeCacheKey(descriptor));
-        if (record && strict) {
-            return record.version === version;
-        }
-        return Boolean(record);
-    }
-    function getRecord(descriptor) {
-        var _a;
-        return (_a = cache.get(encodeCacheKey(withDefaultNs(descriptor)))) === null || _a === void 0 ? void 0 : _a.data;
-    }
-    function getTranslation(descriptor, key) {
-        var _a;
-        return (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data.get(key);
-    }
-    function getTranslationNs(namespaces, languages, key) {
-        var _a;
-        for (const namespace of namespaces) {
-            for (const language of languages) {
-                const value = (_a = cache
-                    .get(encodeCacheKey({ language, namespace }))) === null || _a === void 0 ? void 0 : _a.data.get(key);
-                if (value !== undefined && value !== null) {
-                    return [namespace];
-                }
-            }
-        }
-        return unique(namespaces);
-    }
-    function getTranslationFallback(namespaces, languages, key) {
-        var _a;
-        for (const namespace of namespaces) {
-            for (const language of languages) {
-                const value = (_a = cache
-                    .get(encodeCacheKey({ language, namespace }))) === null || _a === void 0 ? void 0 : _a.data.get(key);
-                if (value !== undefined && value !== null) {
-                    return value;
-                }
-            }
-        }
-        return undefined;
-    }
-    function changeTranslation(descriptor, key, value) {
-        var _a;
-        const record = (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data;
-        record === null || record === void 0 ? void 0 : record.set(key, value);
-        onCacheChange.emit(Object.assign(Object.assign({}, descriptor), { key }));
-    }
-    function isFetching(ns) {
-        if (isInitialLoading()) {
-            return true;
-        }
-        if (ns === undefined) {
-            return asyncRequests.size > 0;
-        }
-        const namespaces = getFallbackArray(ns);
-        return Boolean(Array.from(asyncRequests.keys()).find((key) => namespaces.includes(decodeCacheKey(key).namespace)));
-    }
-    function isLoading(language, ns) {
-        const namespaces = getFallbackArray(ns);
-        return Boolean(isInitialLoading() ||
-            Array.from(asyncRequests.keys()).find((key) => {
-                const descriptor = decodeCacheKey(key);
-                return ((!namespaces.length || namespaces.includes(descriptor.namespace)) &&
-                    !exists({
-                        namespace: descriptor.namespace,
-                        language: language,
-                    }));
-            }));
-    }
     /**
      * Fetches production data
      */
@@ -382,73 +285,152 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
         }
         return dataPromise;
     }
-    async function loadRecords(descriptors, isDev) {
-        const withPromises = descriptors.map((descriptor) => {
-            const keyObject = withDefaultNs(descriptor);
-            const cacheKey = encodeCacheKey(keyObject);
-            const existingPromise = asyncRequests.get(cacheKey);
-            if (existingPromise) {
+    const self = Object.freeze({
+        addStaticData(data) {
+            if (data) {
+                staticData = Object.assign(Object.assign({}, staticData), data);
+                Object.entries(data).forEach(([key, value]) => {
+                    if (typeof value !== 'function') {
+                        const descriptor = decodeCacheKey(key);
+                        const existing = cache.get(key);
+                        if (!existing || existing.version === 0) {
+                            addRecordInternal(descriptor, value, 0);
+                        }
+                    }
+                });
+            }
+        },
+        invalidate() {
+            asyncRequests.clear();
+            version += 1;
+        },
+        addRecord(descriptor, data) {
+            addRecordInternal(descriptor, data, version);
+        },
+        exists(descriptor, strict = false) {
+            const record = cache.get(encodeCacheKey(descriptor));
+            if (record && strict) {
+                return record.version === version;
+            }
+            return Boolean(record);
+        },
+        getRecord(descriptor) {
+            var _a;
+            return (_a = cache.get(encodeCacheKey(withDefaultNs(descriptor)))) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        getTranslation(descriptor, key) {
+            var _a;
+            return (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data.get(key);
+        },
+        getTranslationNs(namespaces, languages, key) {
+            var _a;
+            for (const namespace of namespaces) {
+                for (const language of languages) {
+                    const value = (_a = cache
+                        .get(encodeCacheKey({ language, namespace }))) === null || _a === void 0 ? void 0 : _a.data.get(key);
+                    if (value !== undefined && value !== null) {
+                        return [namespace];
+                    }
+                }
+            }
+            return unique(namespaces);
+        },
+        getTranslationFallback(namespaces, languages, key) {
+            var _a;
+            for (const namespace of namespaces) {
+                for (const language of languages) {
+                    const value = (_a = cache
+                        .get(encodeCacheKey({ language, namespace }))) === null || _a === void 0 ? void 0 : _a.data.get(key);
+                    if (value !== undefined && value !== null) {
+                        return value;
+                    }
+                }
+            }
+            return undefined;
+        },
+        changeTranslation(descriptor, key, value) {
+            var _a;
+            const record = (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data;
+            record === null || record === void 0 ? void 0 : record.set(key, value);
+            onCacheChange.emit(Object.assign(Object.assign({}, descriptor), { key }));
+        },
+        isFetching(ns) {
+            if (isInitialLoading()) {
+                return true;
+            }
+            if (ns === undefined) {
+                return asyncRequests.size > 0;
+            }
+            const namespaces = getFallbackArray(ns);
+            return Boolean(Array.from(asyncRequests.keys()).find((key) => namespaces.includes(decodeCacheKey(key).namespace)));
+        },
+        isLoading(language, ns) {
+            const namespaces = getFallbackArray(ns);
+            return Boolean(isInitialLoading() ||
+                Array.from(asyncRequests.keys()).find((key) => {
+                    const descriptor = decodeCacheKey(key);
+                    return ((!namespaces.length ||
+                        namespaces.includes(descriptor.namespace)) &&
+                        !self.exists({
+                            namespace: descriptor.namespace,
+                            language: language,
+                        }));
+                }));
+        },
+        async loadRecords(descriptors, isDev) {
+            const withPromises = descriptors.map((descriptor) => {
+                const keyObject = withDefaultNs(descriptor);
+                const cacheKey = encodeCacheKey(keyObject);
+                const existingPromise = asyncRequests.get(cacheKey);
+                if (existingPromise) {
+                    return {
+                        new: false,
+                        promise: existingPromise,
+                        keyObject,
+                        cacheKey,
+                    };
+                }
+                const dataPromise = fetchData(keyObject, isDev) || Promise.resolve(undefined);
+                asyncRequests.set(cacheKey, dataPromise);
                 return {
-                    new: false,
-                    promise: existingPromise,
+                    new: true,
+                    promise: dataPromise,
                     keyObject,
                     cacheKey,
                 };
-            }
-            const dataPromise = fetchData(keyObject, isDev) || Promise.resolve(undefined);
-            asyncRequests.set(cacheKey, dataPromise);
-            return {
-                new: true,
-                promise: dataPromise,
-                keyObject,
-                cacheKey,
-            };
-        });
-        fetchingObserver.notify();
-        loadingObserver.notify();
-        const results = await Promise.all(withPromises.map((val) => val.promise));
-        withPromises.forEach((value, i) => {
-            const promiseChanged = asyncRequests.get(value.cacheKey) !== value.promise;
-            // if promise has changed in between, it means cache been invalidated or
-            // new data are being fetched
-            if (value.new && !promiseChanged) {
-                asyncRequests.delete(value.cacheKey);
-                const data = results[i];
-                if (data) {
-                    addRecord(value.keyObject, data);
-                }
-                else if (!getRecord(value.keyObject)) {
-                    // if no data exist, put empty object
-                    addRecord(value.keyObject, {});
+            });
+            fetchingObserver.notify();
+            loadingObserver.notify();
+            const results = await Promise.all(withPromises.map((val) => val.promise));
+            withPromises.forEach((value, i) => {
+                const promiseChanged = asyncRequests.get(value.cacheKey) !== value.promise;
+                // if promise has changed in between, it means cache been invalidated or
+                // new data are being fetched
+                if (value.new && !promiseChanged) {
+                    asyncRequests.delete(value.cacheKey);
+                    const data = results[i];
+                    if (data) {
+                        self.addRecord(value.keyObject, data);
+                    }
+                    else if (!self.getRecord(value.keyObject)) {
+                        // if no data exist, put empty object
+                        self.addRecord(value.keyObject, {});
+                    }
                 }
-            }
-        });
-        fetchingObserver.notify();
-        loadingObserver.notify();
-        return withPromises.map((val) => getRecord(val.keyObject));
-    }
-    function getAllRecords() {
-        const entries = Array.from(cache.entries());
-        return entries.map(([key, entry]) => {
-            return Object.assign(Object.assign({}, decodeCacheKey(key)), { data: entry.data });
-        });
-    }
-    return Object.freeze({
-        addStaticData,
-        invalidate,
-        addRecord,
-        exists,
-        getRecord,
-        getTranslation,
-        getTranslationNs,
-        getTranslationFallback,
-        changeTranslation,
-        isFetching,
-        isLoading,
-        loadRecords,
-        getAllRecords,
+            });
+            fetchingObserver.notify();
+            loadingObserver.notify();
+            return withPromises.map((val) => self.getRecord(val.keyObject));
+        },
+        getAllRecords() {
+            const entries = Array.from(cache.entries());
+            return entries.map(([key, entry]) => {
+                return Object.assign(Object.assign({}, decodeCacheKey(key)), { data: entry.data });
+            });
+        },
     });
-};
+    return self;
+}
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -509,7 +491,7 @@ const combineOptions = (...states) => {
     });
     return result;
 };
-const initState = (options, previousState) => {
+function initState(options, previousState) {
     const initialOptions = combineOptions(defaultValues, previousState === null || previousState === void 0 ? void 0 : previousState.initialOptions, options);
     // remove extra '/' from url end
     initialOptions.apiUrl = sanitizeUrl(initialOptions.apiUrl);
@@ -521,9 +503,9 @@ const initState = (options, previousState) => {
         isInitialLoading: false,
         isRunning: false,
     };
-};
+}
 
-const Plugins = (getLanguage, getInitialOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) => {
+function Plugins(getLanguage, getInitialOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) {
     const plugins = {
         ui: undefined,
     };
@@ -552,63 +534,44 @@ const Plugins = (getLanguage, getInitialOptions, getAvailableLanguages, getTrans
         });
         (_a = instances.ui) === null || _a === void 0 ? void 0 : _a.handleElementClick(withNs, event);
     };
-    const stop = () => {
-        var _a;
-        instances.ui = undefined;
-        (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.stop();
-    };
-    const highlight = (key, ns) => {
-        var _a, _b;
-        return ((_b = (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.highlight) === null || _b === void 0 ? void 0 : _b.call(_a, key, ns)) || { unhighlight() { } };
-    };
     const findPositions = (key, ns) => {
         var _a;
         return ((_a = instances.observer) === null || _a === void 0 ? void 0 : _a.findPositions(key, ns)) || [];
     };
-    const translate = (props) => {
+    function translate(props) {
         const translation = getTranslation({
             key: props.key,
             ns: props.ns,
         });
-        return formatTranslation(Object.assign(Object.assign({}, props), { translation, formatEnabled: true }));
-    };
-    const setObserver = (observer) => {
+        return self.formatTranslation(Object.assign(Object.assign({}, props), { translation, formatEnabled: true }));
+    }
+    function setObserver(observer) {
         instances.observer = observer === null || observer === void 0 ? void 0 : observer();
-    };
-    const hasObserver = () => {
+    }
+    function hasObserver() {
         return Boolean(instances.observer);
-    };
-    const addFormatter = (formatter) => {
+    }
+    function addFormatter(formatter) {
         if (formatter) {
             instances.formatters.push(formatter);
         }
-    };
-    const setFinalFormatter = (formatter) => {
+    }
+    function setFinalFormatter(formatter) {
         instances.finalFormatter = formatter;
-    };
-    const setUi = (ui) => {
+    }
+    function setUi(ui) {
         plugins.ui = ui;
-    };
-    const hasUi = () => {
+    }
+    function hasUi() {
         return Boolean(plugins.ui);
-    };
-    const setLanguageStorage = (storage) => {
+    }
+    function setLanguageStorage(storage) {
         instances.languageStorage = storage;
-    };
-    const getLanguageStorage = () => {
-        return instances.languageStorage;
-    };
-    const setStoredLanguage = (language) => {
-        var _a;
-        (_a = instances.languageStorage) === null || _a === void 0 ? void 0 : _a.setLanguage(language);
-    };
-    const setLanguageDetector = (detector) => {
+    }
+    function setLanguageDetector(detector) {
         instances.languageDetector = detector;
-    };
-    const getLanguageDetector = () => {
-        return instances.languageDetector;
-    };
-    const detectLanguage = () => {
+    }
+    function detectLanguage() {
         if (!instances.languageDetector) {
             return undefined;
         }
@@ -616,86 +579,15 @@ const Plugins = (getLanguage, getInitialOptions, getAvailableLanguages, getTrans
         return instances.languageDetector.getLanguage({
             availableLanguages,
         });
-    };
-    const getInitialLanguage = () => {
-        var _a;
-        const availableLanguages = getAvailableLanguages();
-        const languageOrPromise = (_a = instances.languageStorage) === null || _a === void 0 ? void 0 : _a.getLanguage();
-        return valueOrPromise(languageOrPromise, (language) => {
-            if ((!availableLanguages || availableLanguages.includes(language)) &&
-                language) {
-                return language;
-            }
-            return detectLanguage();
-        });
-    };
-    const addBackend = (backend) => {
+    }
+    function addBackend(backend) {
         if (backend) {
             instances.backends.push(backend);
         }
-    };
-    const setDevBackend = (backend) => {
+    }
+    function setDevBackend(backend) {
         instances.devBackend = backend;
-    };
-    const run = () => {
-        var _a, _b;
-        const { apiKey, apiUrl, projectId, observerOptions } = getInitialOptions();
-        instances.ui = (_a = plugins.ui) === null || _a === void 0 ? void 0 : _a.call(plugins, {
-            apiKey: apiKey,
-            apiUrl: apiUrl,
-            projectId,
-            highlight,
-            changeTranslation,
-            findPositions,
-        });
-        (_b = instances.observer) === null || _b === void 0 ? void 0 : _b.run({
-            mouseHighlight: true,
-            options: observerOptions,
-            translate,
-            onClick,
-        });
-    };
-    const getDevBackend = () => {
-        return instances.devBackend;
-    };
-    const getBackendDevRecord = ({ language, namespace }) => {
-        var _a;
-        const { apiKey, apiUrl, projectId } = getInitialOptions();
-        return (_a = instances.devBackend) === null || _a === void 0 ? void 0 : _a.getRecord({
-            apiKey,
-            apiUrl,
-            projectId,
-            language,
-            namespace,
-        });
-    };
-    const getBackendRecord = ({ language, namespace }) => {
-        for (const backend of instances.backends) {
-            const data = backend.getRecord({ language, namespace });
-            if (isPromise(data)) {
-                return data === null || data === void 0 ? void 0 : data.catch((e) => {
-                    // eslint-disable-next-line no-console
-                    console.error(e);
-                    return {};
-                });
-            }
-            if (data !== undefined) {
-                return data;
-            }
-        }
-        return undefined;
-    };
-    const unwrap = (text) => {
-        var _a;
-        if (instances.observer) {
-            return (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.unwrap(text);
-        }
-        return { text, keys: [] };
-    };
-    const retranslate = () => {
-        var _a;
-        (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.retranslate();
-    };
+    }
     function addPlugin(tolgeeInstance, plugin) {
         const pluginTools = Object.freeze({
             setFinalFormatter,
@@ -711,252 +603,308 @@ const Plugins = (getLanguage, getInitialOptions, getAvailableLanguages, getTrans
         });
         plugin(tolgeeInstance, pluginTools);
     }
-    function formatTranslation(_a) {
-        var _b;
-        var { formatEnabled } = _a, props = __rest(_a, ["formatEnabled"]);
-        const { key, translation, defaultValue, noWrap, params, orEmpty, ns } = props;
-        const formattableTranslation = translation || defaultValue;
-        let result = formattableTranslation || (orEmpty ? '' : key);
-        const language = getLanguage();
-        const isFormatEnabled = formatEnabled || !((_b = instances.observer) === null || _b === void 0 ? void 0 : _b.outputNotFormattable);
-        const wrap = (result) => {
-            if (instances.observer && !noWrap) {
-                return instances.observer.wrap({
-                    key,
-                    translation: result,
-                    defaultValue,
-                    params,
-                    ns,
-                });
+    const self = Object.freeze({
+        addPlugin,
+        run() {
+            var _a, _b;
+            const { apiKey, apiUrl, projectId, observerOptions } = getInitialOptions();
+            instances.ui = (_a = plugins.ui) === null || _a === void 0 ? void 0 : _a.call(plugins, {
+                apiKey: apiKey,
+                apiUrl: apiUrl,
+                projectId,
+                highlight: self.highlight,
+                changeTranslation,
+                findPositions,
+            });
+            (_b = instances.observer) === null || _b === void 0 ? void 0 : _b.run({
+                mouseHighlight: true,
+                options: observerOptions,
+                translate,
+                onClick,
+            });
+        },
+        stop() {
+            var _a;
+            instances.ui = undefined;
+            (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.stop();
+        },
+        getLanguageStorage() {
+            return instances.languageStorage;
+        },
+        getInitialLanguage() {
+            var _a;
+            const availableLanguages = getAvailableLanguages();
+            const languageOrPromise = (_a = instances.languageStorage) === null || _a === void 0 ? void 0 : _a.getLanguage();
+            return valueOrPromise(languageOrPromise, (language) => {
+                if ((!availableLanguages || availableLanguages.includes(language)) &&
+                    language) {
+                    return language;
+                }
+                return detectLanguage();
+            });
+        },
+        setStoredLanguage(language) {
+            var _a;
+            (_a = instances.languageStorage) === null || _a === void 0 ? void 0 : _a.setLanguage(language);
+        },
+        getDevBackend() {
+            return instances.devBackend;
+        },
+        getBackendRecord: (({ language, namespace }) => {
+            for (const backend of instances.backends) {
+                const data = backend.getRecord({ language, namespace });
+                if (isPromise(data)) {
+                    return data === null || data === void 0 ? void 0 : data.catch((e) => {
+                        // eslint-disable-next-line no-console
+                        console.error(e);
+                        return {};
+                    });
+                }
+                if (data !== undefined) {
+                    return data;
+                }
             }
-            return result;
-        };
-        result = wrap(result);
-        try {
-            if (formattableTranslation && language && isFormatEnabled) {
-                for (const formatter of instances.formatters) {
-                    result = formatter.format({
+            return undefined;
+        }),
+        getBackendDevRecord: (({ language, namespace }) => {
+            var _a;
+            const { apiKey, apiUrl, projectId } = getInitialOptions();
+            return (_a = instances.devBackend) === null || _a === void 0 ? void 0 : _a.getRecord({
+                apiKey,
+                apiUrl,
+                projectId,
+                language,
+                namespace,
+            });
+        }),
+        getLanguageDetector() {
+            return instances.languageDetector;
+        },
+        retranslate() {
+            var _a;
+            (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.retranslate();
+        },
+        highlight: ((key, ns) => {
+            var _a, _b;
+            return ((_b = (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.highlight) === null || _b === void 0 ? void 0 : _b.call(_a, key, ns)) || { unhighlight() { } };
+        }),
+        unwrap(text) {
+            var _a;
+            if (instances.observer) {
+                return (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.unwrap(text);
+            }
+            return { text, keys: [] };
+        },
+        wrap(params) {
+            var _a;
+            if (instances.observer) {
+                return (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.wrap(params);
+            }
+            return params.translation;
+        },
+        hasDevBackend() {
+            return Boolean(self.getDevBackend());
+        },
+        formatTranslation(_a) {
+            var _b;
+            var { formatEnabled } = _a, props = __rest(_a, ["formatEnabled"]);
+            const { key, translation, defaultValue, noWrap, params, orEmpty, ns } = props;
+            const formattableTranslation = translation || defaultValue;
+            let result = formattableTranslation || (orEmpty ? '' : key);
+            const language = getLanguage();
+            const isFormatEnabled = formatEnabled || !((_b = instances.observer) === null || _b === void 0 ? void 0 : _b.outputNotFormattable);
+            const wrap = (result) => {
+                if (instances.observer && !noWrap) {
+                    return instances.observer.wrap({
+                        key,
+                        translation: result,
+                        defaultValue,
+                        params,
+                        ns,
+                    });
+                }
+                return result;
+            };
+            result = wrap(result);
+            try {
+                if (formattableTranslation && language && isFormatEnabled) {
+                    for (const formatter of instances.formatters) {
+                        result = formatter.format({
+                            translation: result,
+                            language,
+                            params,
+                        });
+                    }
+                }
+                if (instances.finalFormatter &&
+                    formattableTranslation &&
+                    language &&
+                    isFormatEnabled) {
+                    result = instances.finalFormatter.format({
                         translation: result,
                         language,
                         params,
                     });
                 }
             }
-            if (instances.finalFormatter &&
-                formattableTranslation &&
-                language &&
-                isFormatEnabled) {
-                result = instances.finalFormatter.format({
-                    translation: result,
-                    language,
-                    params,
-                });
-            }
-        }
-        catch (e) {
-            // eslint-disable-next-line no-console
-            console.error(e);
-            const errorMessage = getErrorMessage(e) || DEFAULT_FORMAT_ERROR;
-            const onFormatError = getInitialOptions().onFormatError;
-            const formatErrorType = typeof onFormatError;
-            if (formatErrorType === 'string') {
-                result = onFormatError;
-            }
-            else if (formatErrorType === 'function') {
-                result = onFormatError(errorMessage, props);
-            }
-            else {
-                result = DEFAULT_FORMAT_ERROR;
+            catch (e) {
+                // eslint-disable-next-line no-console
+                console.error(e);
+                const errorMessage = getErrorMessage(e) || DEFAULT_FORMAT_ERROR;
+                const onFormatError = getInitialOptions().onFormatError;
+                const formatErrorType = typeof onFormatError;
+                if (formatErrorType === 'string') {
+                    result = onFormatError;
+                }
+                else if (formatErrorType === 'function') {
+                    result = onFormatError(errorMessage, props);
+                }
+                else {
+                    result = DEFAULT_FORMAT_ERROR;
+                }
+                // wrap error message, so it's detectable
+                result = wrap(result);
             }
-            // wrap error message, so it's detectable
-            result = wrap(result);
-        }
-        return result;
-    }
-    function hasDevBackend() {
-        return Boolean(getDevBackend());
-    }
-    const wrap = (params) => {
-        var _a;
-        if (instances.observer) {
-            return (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.wrap(params);
-        }
-        return params.translation;
-    };
-    return Object.freeze({
-        addPlugin,
-        formatTranslation,
-        getDevBackend,
-        getBackendRecord,
-        getBackendDevRecord,
-        getLanguageDetector,
-        getLanguageStorage,
-        getInitialLanguage,
-        setStoredLanguage,
-        run,
-        stop,
-        retranslate,
-        highlight,
-        unwrap,
-        wrap,
-        hasDevBackend,
+            return result;
+        },
     });
-};
+    return self;
+}
 
 const ValueObserver = (initialValue, valueGetter, handler) => {
     let previousValue = initialValue;
-    function init(value) {
-        previousValue = value;
-    }
-    function notify() {
-        const value = valueGetter();
-        if (previousValue !== value) {
-            handler(value);
-        }
-        previousValue = value;
-    }
     return Object.freeze({
-        init,
-        notify,
+        init(value) {
+            previousValue = value;
+        },
+        notify() {
+            const value = valueGetter();
+            if (previousValue !== value) {
+                handler(value);
+            }
+            previousValue = value;
+        },
     });
 };
 
-const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
+function State(onLanguageChange, onPendingLanguageChange, onRunningChange) {
     let state = initState();
     let devCredentials = undefined;
-    function init(options) {
-        state = initState(options, state);
-    }
-    function isRunning() {
-        return state.isRunning;
-    }
-    function setRunning(value) {
-        if (state.isRunning !== value) {
-            state.isRunning = value;
-            onRunningChange.emit(value);
-        }
-    }
-    function isInitialLoading() {
-        return state.isInitialLoading;
-    }
-    function setInitialLoading(value) {
-        state.isInitialLoading = value;
-    }
-    function getLanguage() {
-        return state.language || state.initialOptions.language;
-    }
-    function setLanguage(language) {
-        if (state.language !== language) {
-            state.language = language;
-            onLanguageChange.emit(language);
-        }
-    }
-    function getPendingLanguage() {
-        return state.pendingLanguage || getLanguage();
-    }
-    function setPendingLanguage(language) {
-        if (state.pendingLanguage !== language) {
-            state.pendingLanguage = language;
-            onPendingLanguageChange.emit(language);
-        }
-    }
-    function getInitialOptions() {
-        return Object.assign(Object.assign({}, state.initialOptions), devCredentials);
-    }
-    function addActiveNs(ns) {
-        const namespaces = getFallbackArray(ns);
-        namespaces.forEach((namespace) => {
-            const value = state.activeNamespaces.get(namespace);
-            if (value !== undefined) {
-                state.activeNamespaces.set(namespace, value + 1);
+    const self = Object.freeze({
+        init(options) {
+            state = initState(options, state);
+        },
+        isRunning() {
+            return state.isRunning;
+        },
+        setRunning(value) {
+            if (state.isRunning !== value) {
+                state.isRunning = value;
+                onRunningChange.emit(value);
             }
-            else {
-                state.activeNamespaces.set(namespace, 1);
+        },
+        isInitialLoading() {
+            return state.isInitialLoading;
+        },
+        setInitialLoading(value) {
+            state.isInitialLoading = value;
+        },
+        getLanguage() {
+            return state.language || state.initialOptions.language;
+        },
+        setLanguage(language) {
+            if (state.language !== language) {
+                state.language = language;
+                onLanguageChange.emit(language);
             }
-        });
-    }
-    function removeActiveNs(ns) {
-        const namespaces = getFallbackArray(ns);
-        namespaces.forEach((namespace) => {
-            const value = state.activeNamespaces.get(namespace);
-            if (value !== undefined && value > 1) {
-                state.activeNamespaces.set(namespace, value - 1);
+        },
+        getPendingLanguage() {
+            return state.pendingLanguage || self.getLanguage();
+        },
+        setPendingLanguage(language) {
+            if (state.pendingLanguage !== language) {
+                state.pendingLanguage = language;
+                onPendingLanguageChange.emit(language);
+            }
+        },
+        getInitialOptions() {
+            return Object.assign(Object.assign({}, state.initialOptions), devCredentials);
+        },
+        addActiveNs(ns) {
+            const namespaces = getFallbackArray(ns);
+            namespaces.forEach((namespace) => {
+                const value = state.activeNamespaces.get(namespace);
+                if (value !== undefined) {
+                    state.activeNamespaces.set(namespace, value + 1);
+                }
+                else {
+                    state.activeNamespaces.set(namespace, 1);
+                }
+            });
+        },
+        removeActiveNs(ns) {
+            const namespaces = getFallbackArray(ns);
+            namespaces.forEach((namespace) => {
+                const value = state.activeNamespaces.get(namespace);
+                if (value !== undefined && value > 1) {
+                    state.activeNamespaces.set(namespace, value - 1);
+                }
+                else {
+                    state.activeNamespaces.delete(namespace);
+                }
+            });
+        },
+        getRequiredNamespaces() {
+            return unique([
+                ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
+                ...getFallbackArray(state.initialOptions.fallbackNs),
+                ...state.activeNamespaces.keys(),
+            ]);
+        },
+        getFallbackLangs(lang) {
+            const language = lang || self.getLanguage();
+            if (!language) {
+                return [];
+            }
+            return unique([
+                language,
+                ...getFallbackFromStruct(language, state.initialOptions.fallbackLanguage),
+            ]);
+        },
+        getFallbackNs() {
+            return getFallbackArray(state.initialOptions.fallbackNs);
+        },
+        getDefaultNs(ns) {
+            return ns === undefined ? state.initialOptions.defaultNs : ns;
+        },
+        getAvailableLanguages() {
+            if (state.initialOptions.availableLanguages) {
+                return state.initialOptions.availableLanguages;
+            }
+            else if (state.initialOptions.staticData) {
+                const languagesFromStaticData = Object.keys(state.initialOptions.staticData).map((key) => decodeCacheKey(key).language);
+                return Array.from(new Set(languagesFromStaticData));
+            }
+        },
+        withDefaultNs(descriptor) {
+            return {
+                namespace: descriptor.namespace === undefined
+                    ? self.getInitialOptions().defaultNs
+                    : descriptor.namespace,
+                language: descriptor.language,
+            };
+        },
+        overrideCredentials(credentials) {
+            if (credentials) {
+                devCredentials = Object.assign(Object.assign({}, credentials), { apiUrl: sanitizeUrl(credentials.apiUrl) });
             }
             else {
-                state.activeNamespaces.delete(namespace);
+                devCredentials = undefined;
             }
-        });
-    }
-    function getRequiredNamespaces() {
-        return unique([
-            ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
-            ...getFallbackArray(state.initialOptions.fallbackNs),
-            ...state.activeNamespaces.keys(),
-        ]);
-    }
-    function getFallbackLangs(lang) {
-        const language = lang || getLanguage();
-        if (!language) {
-            return [];
-        }
-        return unique([
-            language,
-            ...getFallbackFromStruct(language, state.initialOptions.fallbackLanguage),
-        ]);
-    }
-    function getFallbackNs() {
-        return getFallbackArray(state.initialOptions.fallbackNs);
-    }
-    function getDefaultNs(ns) {
-        return ns === undefined ? state.initialOptions.defaultNs : ns;
-    }
-    function getAvailableLanguages() {
-        if (state.initialOptions.availableLanguages) {
-            return state.initialOptions.availableLanguages;
-        }
-        else if (state.initialOptions.staticData) {
-            const languagesFromStaticData = Object.keys(state.initialOptions.staticData).map((key) => decodeCacheKey(key).language);
-            return Array.from(new Set(languagesFromStaticData));
-        }
-    }
-    function withDefaultNs(descriptor) {
-        return {
-            namespace: descriptor.namespace === undefined
-                ? getInitialOptions().defaultNs
-                : descriptor.namespace,
-            language: descriptor.language,
-        };
-    }
-    function overrideCredentials(credentials) {
-        if (credentials) {
-            devCredentials = Object.assign(Object.assign({}, credentials), { apiUrl: sanitizeUrl(credentials.apiUrl) });
-        }
-        else {
-            devCredentials = undefined;
-        }
-    }
-    return Object.freeze({
-        init,
-        isRunning,
-        setRunning,
-        isInitialLoading,
-        setInitialLoading,
-        getLanguage,
-        setLanguage,
-        getPendingLanguage,
-        setPendingLanguage,
-        getInitialOptions,
-        addActiveNs,
-        removeActiveNs,
-        getRequiredNamespaces,
-        getFallbackLangs,
-        getFallbackNs,
-        getDefaultNs,
-        getAvailableLanguages,
-        withDefaultNs,
-        overrideCredentials,
+        },
     });
-};
+    return self;
+}
 
 function parseCombinedOptions(_a) {
     var { ns, noWrap, orEmpty, params, language } = _a, rest = __rest(_a, ["ns", "noWrap", "orEmpty", "params", "language"]);
@@ -990,10 +938,10 @@ const getTranslateProps = (keyOrProps, ...params) => {
     return result;
 };
 
-const Controller = ({ options }) => {
+function Controller({ options }) {
     const events = Events(getFallbackNs, getDefaultNs);
     const fetchingObserver = ValueObserver(false, () => cache.isFetching(), events.onFetchingChange.emit);
-    const loadingObserver = ValueObserver(false, () => isLoading(), events.onLoadingChange.emit);
+    const loadingObserver = ValueObserver(false, () => self.isLoading(), events.onLoadingChange.emit);
     const state = State(events.onLanguageChange, events.onPendingLanguageChange, events.onRunningChange);
     const pluginService = Plugins(state.getLanguage, state.getInitialOptions, state.getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation);
     const cache = Cache(events.onCacheChange, pluginService.getBackendRecord, pluginService.getBackendDevRecord, state.withDefaultNs, state.isInitialLoading, fetchingObserver, loadingObserver);
@@ -1029,7 +977,7 @@ const Controller = ({ options }) => {
         const previousValue = cache.getTranslation(keyObject, key);
         cache.changeTranslation(keyObject, key, value);
         return {
-            revert: () => {
+            revert() {
                 cache.changeTranslation(keyObject, key, previousValue);
             },
         };
@@ -1038,20 +986,6 @@ const Controller = ({ options }) => {
         state.init(options);
         cache.addStaticData(state.getInitialOptions().staticData);
     }
-    function isLoading(ns) {
-        return cache.isLoading(state.getLanguage(), ns);
-    }
-    function isDev() {
-        return Boolean(state.getInitialOptions().apiKey && state.getInitialOptions().apiUrl);
-    }
-    async function addActiveNs(ns, forget) {
-        if (!forget) {
-            state.addActiveNs(ns);
-        }
-        if (state.isRunning()) {
-            await loadRequiredRecords(undefined, ns);
-        }
-    }
     function getRequiredRecords(lang, ns) {
         const languages = state.getFallbackLangs(lang);
         const namespaces = getRequiredNamespaces(ns);
@@ -1065,43 +999,10 @@ const Controller = ({ options }) => {
         });
         return result;
     }
-    function isLoaded(ns) {
-        const language = state.getLanguage();
-        if (!language) {
-            return false;
-        }
-        const languages = state.getFallbackLangs(language);
-        const namespaces = getRequiredNamespaces(ns);
-        const result = [];
-        languages.forEach((language) => {
-            namespaces.forEach((namespace) => {
-                if (!cache.exists({ language, namespace })) {
-                    result.push({ language, namespace });
-                }
-            });
-        });
-        return result.length === 0;
-    }
     function loadRequiredRecords(lang, ns) {
         const descriptors = getRequiredRecords(lang, ns);
         if (descriptors.length) {
-            return valueOrPromise(loadRecords(descriptors), () => { });
-        }
-    }
-    async function changeLanguage(language) {
-        if (state.getPendingLanguage() === language &&
-            state.getLanguage() === language) {
-            return;
-        }
-        state.setPendingLanguage(language);
-        if (state.isRunning()) {
-            await loadRequiredRecords(language);
-        }
-        if (language === state.getPendingLanguage()) {
-            // there might be parallel language change
-            // we only want to apply latest
-            state.setLanguage(language);
-            pluginService.setStoredLanguage(language);
+            return valueOrPromise(self.loadRecords(descriptors), () => { });
         }
     }
     function getTranslationNs({ key, ns }) {
@@ -1149,13 +1050,7 @@ const Controller = ({ options }) => {
             language && state.setLanguage(language);
         });
     }
-    async function loadRecord(descriptor) {
-        return (await loadRecords([descriptor]))[0];
-    }
-    function loadRecords(descriptors) {
-        return cache.loadRecords(descriptors, isDev());
-    }
-    const checkCorrectConfiguration = () => {
+    function checkCorrectConfiguration() {
         const languageComputable = pluginService.getLanguageDetector() || pluginService.getLanguageStorage();
         if (languageComputable) {
             const availableLanguages = state.getAvailableLanguages();
@@ -1171,59 +1066,98 @@ const Controller = ({ options }) => {
                 throw new Error(missingOptionError('language'));
             }
         }
-    };
-    function run() {
-        let result = undefined;
-        checkCorrectConfiguration();
-        if (!state.isRunning()) {
-            if (isDev()) {
-                cache.invalidate();
-            }
-            state.setRunning(true);
-            pluginService.run();
-            result = loadInitial();
-        }
-        return Promise.resolve(result);
-    }
-    function stop() {
-        if (state.isRunning()) {
-            pluginService.stop();
-            state.setRunning(false);
-        }
     }
-    const t = (...args) => {
-        // @ts-ignore
-        const params = getTranslateProps(...args);
-        const translation = getTranslation(params);
-        return pluginService.formatTranslation(Object.assign(Object.assign({}, params), { translation }));
-    };
-    return Object.freeze(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, events), state), pluginService), cache), { init,
-        changeLanguage,
-        getTranslation,
-        changeTranslation,
-        addActiveNs,
-        loadRecords,
-        loadRecord,
-        isLoading,
-        isLoaded,
-        t,
-        isDev,
-        run,
-        stop }));
-};
+    const self = Object.freeze(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, events), state), pluginService), cache), { init: init, getTranslation: getTranslation, changeTranslation: changeTranslation, async changeLanguage(language) {
+            if (state.getPendingLanguage() === language &&
+                state.getLanguage() === language) {
+                return;
+            }
+            state.setPendingLanguage(language);
+            if (state.isRunning()) {
+                await loadRequiredRecords(language);
+            }
+            if (language === state.getPendingLanguage()) {
+                // there might be parallel language change
+                // we only want to apply latest
+                state.setLanguage(language);
+                pluginService.setStoredLanguage(language);
+            }
+        },
+        async addActiveNs(ns, forget) {
+            if (!forget) {
+                state.addActiveNs(ns);
+            }
+            if (state.isRunning()) {
+                await loadRequiredRecords(undefined, ns);
+            }
+        },
+        loadRecords(descriptors) {
+            return cache.loadRecords(descriptors, self.isDev());
+        },
+        async loadRecord(descriptor) {
+            return (await self.loadRecords([descriptor]))[0];
+        },
+        isLoading(ns) {
+            return cache.isLoading(state.getLanguage(), ns);
+        },
+        isLoaded(ns) {
+            const language = state.getLanguage();
+            if (!language) {
+                return false;
+            }
+            const languages = state.getFallbackLangs(language);
+            const namespaces = getRequiredNamespaces(ns);
+            const result = [];
+            languages.forEach((language) => {
+                namespaces.forEach((namespace) => {
+                    if (!cache.exists({ language, namespace })) {
+                        result.push({ language, namespace });
+                    }
+                });
+            });
+            return result.length === 0;
+        }, t: ((...args) => {
+            // @ts-ignore
+            const params = getTranslateProps(...args);
+            const translation = getTranslation(params);
+            return pluginService.formatTranslation(Object.assign(Object.assign({}, params), { translation }));
+        }), isDev() {
+            return Boolean(state.getInitialOptions().apiKey && state.getInitialOptions().apiUrl);
+        },
+        run() {
+            let result = undefined;
+            checkCorrectConfiguration();
+            if (!state.isRunning()) {
+                if (self.isDev()) {
+                    cache.invalidate();
+                }
+                state.setRunning(true);
+                pluginService.run();
+                result = loadInitial();
+            }
+            return Promise.resolve(result);
+        },
+        stop() {
+            if (state.isRunning()) {
+                pluginService.stop();
+                state.setRunning(false);
+            }
+        } }));
+    return self;
+}
 
-const createTolgee = (options) => {
+function createTolgee(options) {
     const controller = Controller({
         options,
     });
     // restarts tolgee while applying callback
-    const withRestart = (callback) => {
+    function withRestart(callback) {
         const wasRunning = controller.isRunning();
         wasRunning && controller.stop();
         callback();
         wasRunning && controller.run();
-    };
-    const tolgee = Object.freeze({
+    }
+    const self = Object.freeze({
         /**
          * Listen to tolgee events.
          */
@@ -1374,7 +1308,7 @@ const createTolgee = (options) => {
          */
         addPlugin(plugin) {
             if (plugin) {
-                withRestart(() => controller.addPlugin(tolgee, plugin));
+                withRestart(() => controller.addPlugin(self, plugin));
             }
         },
         /**
@@ -1389,8 +1323,8 @@ const createTolgee = (options) => {
             }
         },
     });
-    return tolgee;
-};
+    return self;
+}
 /**
  * Tolgee chainable constructor.
  *