@tolgee/core 5.8.0 → 5.8.2

package/dist/tolgee.umd.js

@@ -7,15 +7,17 @@
     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;
     }
@@ -54,63 +56,32 @@
         }
     }
 
-    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());
@@ -121,10 +92,10 @@
                     handler.fn({ value: undefined });
                 }
             });
-        };
+        }
         let queue = [];
         // merge events in queue into one event
-        const solveQueue = () => {
+        function solveQueue() {
             if (queue.length === 0) {
                 return;
             }
@@ -147,75 +118,97 @@
                 ? 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();
@@ -249,29 +242,11 @@
         }
     };
 
-    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, {
@@ -280,78 +255,6 @@
             });
             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
          */
@@ -384,73 +287,152 @@
             }
             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.
@@ -511,7 +493,7 @@
         });
         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);
@@ -523,9 +505,9 @@
             isInitialLoading: false,
             isRunning: false,
         };
-    };
+    }
 
-    const Plugins = (getLanguage, getInitialOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) => {
+    function Plugins(getLanguage, getInitialOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) {
         const plugins = {
             ui: undefined,
         };
@@ -554,63 +536,44 @@
             });
             (_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;
             }
@@ -618,86 +581,15 @@
             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,
@@ -713,252 +605,308 @@
             });
             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"]);
@@ -992,10 +940,10 @@
         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);
@@ -1031,7 +979,7 @@
             const previousValue = cache.getTranslation(keyObject, key);
             cache.changeTranslation(keyObject, key, value);
             return {
-                revert: () => {
+                revert() {
                     cache.changeTranslation(keyObject, key, previousValue);
                 },
             };
@@ -1040,20 +988,6 @@
             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);
@@ -1067,43 +1001,10 @@
             });
             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 }) {
@@ -1151,13 +1052,7 @@
                 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();
@@ -1173,59 +1068,98 @@
                     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.
              */
@@ -1376,7 +1310,7 @@
              */
             addPlugin(plugin) {
                 if (plugin) {
-                    withRestart(() => controller.addPlugin(tolgee, plugin));
+                    withRestart(() => controller.addPlugin(self, plugin));
                 }
             },
             /**
@@ -1391,8 +1325,8 @@
                 }
             },
         });
-        return tolgee;
-    };
+        return self;
+    }
     /**
      * Tolgee chainable constructor.
      *