@tolgee/core 5.0.0-rc.9be0f0e.0 → 5.0.0

package/dist/{tolgee.esm.mjs → tolgee.esm.js}

@@ -1,22 +1,15 @@
-const EventEmitter = () => {
-    let handlers = [];
-    const listen = (handler) => {
-        const handlerWrapper = (e) => {
-            handler(e);
-        };
-        handlers.push(handlerWrapper);
-        return {
-            unsubscribe: () => {
-                handlers = handlers.filter((i) => handlerWrapper !== i);
-            },
-        };
-    };
-    const emit = (data) => {
-        handlers.forEach((handler) => handler({ value: data }));
-    };
-    return Object.freeze({ listen, emit });
+function isPromise(value) {
+    return Boolean(value && typeof value.then === 'function');
+}
+const 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 isObject(item) {
     return typeof item === 'object' && !Array.isArray(item) && item !== null;
 }
@@ -43,22 +36,40 @@ function getFallbackFromStruct(language, fallbackLanguage) {
 function unique(arr) {
     return Array.from(new Set(arr));
 }
-
-function incrementInMap(map, value) {
-    const currNum = map.get(value) || 0;
-    map.set(value, currNum + 1);
+function sanitizeUrl(url) {
+    return url ? url.replace(/\/+$/, '') : url;
 }
-function decrementInMap(map, value) {
-    let currNum = map.get(value) || 1;
-    currNum -= 1;
-    if (currNum <= 0) {
-        map.delete(value);
+function getErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
     }
-    else {
-        map.set(value, currNum);
+    else if (typeof (error === null || error === void 0 ? void 0 : error.message) === 'string') {
+        return error.message;
     }
 }
-const EventEmitterSelective = () => {
+
+const 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 });
+};
+
+const EventEmitterSelective = (isActive, getFallbackNs, getDefaultNs) => {
     const listeners = new Set();
     const partialListeners = new Set();
     const listen = (handler) => {
@@ -75,8 +86,7 @@ const EventEmitterSelective = () => {
             fn: (e) => {
                 handler(e);
             },
-            keys: new Map(),
-            namespaces: new Map(),
+            namespaces: new Set(),
         };
         partialListeners.add(handlerWrapper);
         const result = {
@@ -84,105 +94,85 @@ const EventEmitterSelective = () => {
                 partialListeners.delete(handlerWrapper);
             },
             subscribeNs: (ns) => {
-                getFallbackArray(ns).forEach((val) => incrementInMap(handlerWrapper.namespaces, val));
-                return result;
-            },
-            unsubscribeNs: (ns) => {
-                getFallbackArray(ns).forEach((val) => decrementInMap(handlerWrapper.namespaces, val));
-                return result;
-            },
-            subscribeKey: (descriptor) => {
-                const { key, ns } = descriptor;
-                incrementInMap(handlerWrapper.keys, key);
-                getFallbackArray(ns).forEach((val) => incrementInMap(handlerWrapper.namespaces, val));
+                getFallbackArray(ns).forEach((val) => handlerWrapper.namespaces.add(val));
                 if (ns === undefined) {
-                    // subscribing to all namespaces
-                    incrementInMap(handlerWrapper.namespaces, undefined);
-                }
-                return result;
-            },
-            unsubscribeKey: (descriptor) => {
-                const { key, ns } = descriptor;
-                decrementInMap(handlerWrapper.keys, key);
-                getFallbackArray(ns).forEach((val) => decrementInMap(handlerWrapper.namespaces, val));
-                if (ns === undefined) {
-                    // subscribing to all namespaces
-                    decrementInMap(handlerWrapper.namespaces, undefined);
+                    // subscribing to default ns
+                    handlerWrapper.namespaces.add(getDefaultNs());
                 }
                 return result;
             },
         };
         return result;
     };
-    const callHandlers = (key, ns) => {
+    const callHandlers = (ns) => {
+        // everything is implicitly subscribed to fallbacks
+        // as it can always fall through to it
+        const fallbackNamespaces = new Set(getFallbackNs());
         partialListeners.forEach((handler) => {
-            const nsMentioned = ns !== undefined;
-            const nsMatches = handler.namespaces.has(undefined) ||
-                (ns === null || ns === void 0 ? void 0 : ns.findIndex((ns) => handler.namespaces.has(ns))) !== -1;
-            const keyMentioned = key !== undefined;
-            const keyMatches = key === undefined || handler.keys.has(key) || handler.keys.size === 0;
-            if ((!nsMentioned || nsMatches) && (!keyMentioned || keyMatches)) {
+            const nsMatches = ns === undefined ||
+                (ns === null || ns === void 0 ? void 0 : ns.findIndex((ns) => fallbackNamespaces.has(ns) || handler.namespaces.has(ns))) !== -1;
+            if (nsMatches) {
                 handler.fn({ value: undefined });
             }
         });
     };
     let queue = [];
+    // merge events in queue into one event
     const solveQueue = () => {
         if (queue.length === 0) {
             return;
         }
+        const queueCopy = queue;
+        queue = [];
         listeners.forEach((handler) => {
             handler({ value: undefined });
         });
-        let namespaces = [];
-        let keys = [];
-        queue.forEach((descriptor) => {
-            if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.ns) === undefined) {
+        let namespaces = new Set();
+        queueCopy.forEach((ns) => {
+            if (ns === undefined) {
+                // when no ns specified, it affects all namespaces
                 namespaces = undefined;
             }
             else if (namespaces !== undefined) {
-                namespaces = [...namespaces, ...descriptor.ns];
+                ns.forEach((ns) => namespaces.add(ns));
             }
-            if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.key) === undefined) {
-                keys = undefined;
-            }
-            else if (keys !== undefined) {
-                keys = [...keys, descriptor.key];
-            }
-        });
-        (keys || [undefined]).forEach((key) => {
-            callHandlers(key, namespaces);
         });
-        queue = [];
+        const namespacesArray = namespaces
+            ? Array.from(namespaces.keys())
+            : undefined;
+        callHandlers(namespacesArray);
     };
-    const emit = (descriptor, delayed) => {
-        queue.push(descriptor);
-        if (!delayed) {
-            solveQueue();
-        }
-        else {
-            Promise.resolve().then(() => {
+    const emit = (ns, delayed) => {
+        if (isActive()) {
+            queue.push(ns);
+            if (!delayed) {
                 solveQueue();
-            });
+            }
+            else {
+                setTimeout(solveQueue, 0);
+            }
         }
     };
     return Object.freeze({ listenSome, listen, emit });
 };
 
-const Events = () => {
-    const onPendingLanguageChange = EventEmitter();
-    const onLanguageChange = EventEmitter();
-    const onKeyChange = EventEmitter();
-    const onLoadingChange = EventEmitter();
-    const onFetchingChange = EventEmitter();
-    const onInitialLoaded = EventEmitter();
-    const onKeyUpdate = EventEmitterSelective();
-    const onCacheChange = EventEmitter();
-    const onRunningChange = EventEmitter();
-    onInitialLoaded.listen(() => onKeyUpdate.emit());
-    onLanguageChange.listen(() => onKeyUpdate.emit());
+const 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 }) => {
-        onKeyUpdate.emit({ ns: [value.namespace], key: value.key }, true);
+        onUpdate.emit([value.namespace], true);
     });
     const on = (event, handler) => {
         switch (event) {
@@ -200,20 +190,23 @@ const Events = () => {
                 return onRunningChange.listen(handler);
             case 'cache':
                 return onCacheChange.listen(handler);
-            case 'keyUpdate':
-                return onKeyUpdate.listen(handler);
+            case 'update':
+                return onUpdate.listen(handler);
         }
     };
+    function setEmmiterActive(active) {
+        emitterActive = active;
+    }
     return Object.freeze({
         onPendingLanguageChange,
         onLanguageChange,
-        onKeyChange,
-        onKeyUpdate,
         onLoadingChange,
         onFetchingChange,
         onInitialLoaded,
         onRunningChange,
         onCacheChange,
+        onUpdate,
+        setEmmiterActive,
         on,
     });
 };
@@ -226,7 +219,7 @@ const flattenTranslations = (data) => {
             return;
         }
         if (typeof value === 'object') {
-            Object.entries(flattenTranslations(value)).forEach(([flatKey, flatValue]) => {
+            flattenTranslations(value).forEach((flatValue, flatKey) => {
                 result.set(key + '.' + flatKey, flatValue);
             });
             return;
@@ -236,7 +229,9 @@ const flattenTranslations = (data) => {
     return result;
 };
 const decodeCacheKey = (key) => {
-    const [firstPart, secondPart] = key.split(':');
+    const [firstPart, ...rest] = key.split(':');
+    // if namespaces contains ":" it won't get lost
+    const secondPart = rest.join(':');
     return { language: firstPart, namespace: secondPart || '' };
 };
 const encodeCacheKey = ({ language, namespace, }) => {
@@ -291,7 +286,7 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
     }
     function getRecord(descriptor) {
         var _a;
-        return (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data;
+        return (_a = cache.get(encodeCacheKey(withDefaultNs(descriptor)))) === null || _a === void 0 ? void 0 : _a.data;
     }
     function getTranslation(descriptor, key) {
         var _a;
@@ -304,11 +299,11 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
                 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 [namespace];
                 }
             }
         }
-        return Array.from(new Set(namespaces));
+        return unique(namespaces);
     }
     function getTranslationFallback(namespaces, languages, key) {
         var _a;
@@ -329,9 +324,6 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
         record === null || record === void 0 ? void 0 : record.set(key, value);
         onCacheChange.emit(Object.assign(Object.assign({}, descriptor), { key }));
     }
-    function clear() {
-        cache.clear();
-    }
     function isFetching(ns) {
         if (isInitialLoading()) {
             return true;
@@ -354,24 +346,20 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
                     }));
             }));
     }
-    function fetchNormal(keyObject) {
+    /**
+     * Fetches production data
+     */
+    function fetchProd(keyObject) {
         let dataPromise = undefined;
         if (!dataPromise) {
             const staticDataValue = staticData[encodeCacheKey(keyObject)];
             if (typeof staticDataValue === 'function') {
                 dataPromise = staticDataValue();
             }
-            else if (staticDataValue) {
-                dataPromise = Promise.resolve(staticDataValue);
-            }
         }
         if (!dataPromise) {
             dataPromise = backendGetRecord(keyObject);
         }
-        if (!dataPromise) {
-            // return empty data, so we know it has already been attempted to fetch
-            dataPromise = Promise.resolve({});
-        }
         return dataPromise;
     }
     function fetchData(keyObject, isDev) {
@@ -381,12 +369,12 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
             dataPromise = (_a = backendGetDevRecord(keyObject)) === null || _a === void 0 ? void 0 : _a.catch(() => {
                 // eslint-disable-next-line no-console
                 console.warn(`Tolgee: Failed to fetch data from dev backend`);
-                // fallback to normal fetch if dev fails
-                return fetchNormal(keyObject);
+                // fallback to prod fetch if dev fails
+                return fetchProd(keyObject);
             });
         }
         if (!dataPromise) {
-            dataPromise = fetchNormal(keyObject);
+            dataPromise = fetchProd(keyObject);
         }
         return dataPromise;
     }
@@ -403,7 +391,7 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
                     cacheKey,
                 };
             }
-            const dataPromise = fetchData(keyObject, isDev);
+            const dataPromise = fetchData(keyObject, isDev) || Promise.resolve(undefined);
             asyncRequests.set(cacheKey, dataPromise);
             return {
                 new: true,
@@ -425,6 +413,10 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
                 if (data) {
                     addRecord(value.keyObject, data);
                 }
+                else if (!getRecord(value.keyObject)) {
+                    // if no data exist, put empty object
+                    addRecord(value.keyObject, {});
+                }
             }
         });
         fetchingObserver.notify();
@@ -450,27 +442,85 @@ const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefault
         isFetching,
         isLoading,
         loadRecords,
-        clear,
         getAllRecords,
     });
 };
 
-function isPromise(value) {
-    return Boolean(value && typeof value.then === 'function');
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
 }
-const valueOrPromise = (value, callback) => {
-    if (isPromise(value)) {
-        return Promise.resolve(value).then(callback);
-    }
-    else {
-        return callback(value);
-    }
+
+const defaultObserverOptions = {
+    tagAttributes: {
+        textarea: ['placeholder'],
+        input: ['value', 'placeholder'],
+        img: ['alt'],
+        '*': ['aria-label', 'title'],
+    },
+    restrictedElements: ['script', 'style'],
+    highlightKeys: ['Alt'],
+    highlightColor: 'rgb(255, 0, 0)',
+    highlightWidth: 5,
+    inputPrefix: '%-%tolgee:',
+    inputSuffix: '%-%',
+    passToParent: ['option', 'optgroup'],
+};
+
+const DEFAULT_FORMAT_ERROR = 'invalid';
+const defaultValues = {
+    defaultNs: '',
+    observerOptions: defaultObserverOptions,
+    observerType: 'invisible',
+    onFormatError: DEFAULT_FORMAT_ERROR,
+};
+const combineOptions = (...states) => {
+    let result = {};
+    states.forEach((state) => {
+        result = Object.assign(Object.assign(Object.assign({}, result), state), { observerOptions: Object.assign(Object.assign({}, result.observerOptions), state === null || state === void 0 ? void 0 : state.observerOptions) });
+    });
+    return result;
+};
+const 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);
+    return {
+        initialOptions,
+        activeNamespaces: (previousState === null || previousState === void 0 ? void 0 : previousState.activeNamespaces) || new Map(),
+        language: previousState === null || previousState === void 0 ? void 0 : previousState.language,
+        pendingLanguage: previousState === null || previousState === void 0 ? void 0 : previousState.language,
+        isInitialLoading: false,
+        isRunning: false,
+    };
 };
-const missingOptionError = (option) => `Tolgee: You need to specify '${option}' option`;
 
-const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) => {
+const Plugins = (getLanguage, getInitialOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) => {
     const plugins = {
         ui: undefined,
+        observer: undefined,
     };
     const instances = {
         formatters: [],
@@ -482,39 +532,20 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
         languageDetector: undefined,
         languageStorage: undefined,
     };
-    const onClick = async (event, { keysAndDefaults }) => {
+    const onClick = async ({ keysAndDefaults, event }) => {
         var _a;
-        const withNs = keysAndDefaults.map(({ key, ns, defaultValue }) => ({
-            key,
-            defaultValue,
-            ns: getFallbackArray(getTranslationNs({ key, ns, defaultValue })),
-            translation: getTranslation({
+        const withNs = keysAndDefaults.map(({ key, ns, defaultValue }) => {
+            return {
                 key,
-                ns,
-            }),
-        }));
-        (_a = instances.ui) === null || _a === void 0 ? void 0 : _a.handleElementClick(event, withNs);
-    };
-    const run = () => {
-        var _a;
-        instances.ui =
-            plugins.ui &&
-                new plugins.ui({
-                    apiKey: getInitialOptions().apiKey,
-                    apiUrl: getInitialOptions().apiUrl,
-                    highlight,
-                    changeTranslation,
-                });
-        (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.run({ mouseHighlight: Boolean(instances.ui) });
-        checkCorrectConfiguration();
-    };
-    const checkCorrectConfiguration = () => {
-        if (instances.languageDetector) {
-            const availableLanguages = getAvailableLanguages();
-            if (!availableLanguages) {
-                throw new Error(missingOptionError('availableLanguages'));
-            }
-        }
+                defaultValue,
+                ns: getTranslationNs({ key, ns }),
+                translation: getTranslation({
+                    key,
+                    ns,
+                }),
+            };
+        });
+        (_a = instances.ui) === null || _a === void 0 ? void 0 : _a.handleElementClick(withNs, event);
     };
     const stop = () => {
         var _a;
@@ -526,14 +557,17 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
         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 translate = (props) => {
-        const translation = getTranslation(props);
+        const translation = getTranslation({
+            key: props.key,
+            ns: props.ns,
+        });
         return formatTranslation(Object.assign(Object.assign({}, props), { translation, formatEnabled: true }));
     };
     const setObserver = (observer) => {
-        instances.observer = observer === null || observer === void 0 ? void 0 : observer({ translate, onClick });
+        plugins.observer = observer;
     };
-    const getObserver = () => {
-        return instances.observer;
+    const hasObserver = () => {
+        return Boolean(plugins.observer);
     };
     const addFormatter = (formatter) => {
         if (formatter) {
@@ -544,14 +578,17 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
         instances.finalFormatter = formatter;
     };
     const setUi = (ui) => {
-        plugins.ui = (ui === null || ui === void 0 ? void 0 : ui.UI) || ui;
+        plugins.ui = ui;
     };
-    const getUi = () => {
-        return plugins.ui;
+    const hasUi = () => {
+        return Boolean(plugins.ui);
     };
     const 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);
@@ -559,6 +596,9 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
     const setLanguageDetector = (detector) => {
         instances.languageDetector = detector;
     };
+    const getLanguageDetector = () => {
+        return instances.languageDetector;
+    };
     const detectLanguage = () => {
         if (!instances.languageDetector) {
             return undefined;
@@ -588,14 +628,37 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
     const setDevBackend = (backend) => {
         instances.devBackend = backend;
     };
+    const run = () => {
+        var _a, _b, _c;
+        if (!instances.ui) {
+            const { apiKey, apiUrl, projectId } = getInitialOptions();
+            instances.ui = (_a = plugins.ui) === null || _a === void 0 ? void 0 : _a.call(plugins, {
+                apiKey: apiKey,
+                apiUrl: apiUrl,
+                projectId,
+                highlight,
+                changeTranslation,
+            });
+        }
+        if (!instances.observer) {
+            instances.observer = (_b = plugins.observer) === null || _b === void 0 ? void 0 : _b.call(plugins, {
+                translate,
+                onClick,
+                options: getInitialOptions().observerOptions,
+            });
+        }
+        (_c = instances.observer) === null || _c === void 0 ? void 0 : _c.run({ mouseHighlight: true });
+    };
     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: getInitialOptions().apiKey,
-            apiUrl: getInitialOptions().apiUrl,
+            apiKey,
+            apiUrl,
+            projectId,
             language,
             namespace,
         });
@@ -616,42 +679,97 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
         }
         return undefined;
     };
-    const formatTranslation = ({ key, translation, defaultValue, noWrap, params, orEmpty, ns, formatEnabled, }) => {
+    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,
+            addFormatter,
+            setObserver,
+            hasObserver,
+            setUi,
+            hasUi,
+            setDevBackend,
+            addBackend,
+            setLanguageDetector,
+            setLanguageStorage,
+        });
+        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);
-        if (instances.observer && !noWrap) {
-            result = instances.observer.wrap({
-                key,
-                translation: result,
-                defaultValue,
-                params,
-                ns,
-            });
-        }
         const language = getLanguage();
-        const isFormatEnabled = formatEnabled || !((_a = instances.observer) === null || _a === void 0 ? void 0 : _a.outputNotFormattable);
-        if (formattableTranslation && language && isFormatEnabled) {
-            for (const formatter of instances.formatters) {
-                result = formatter.format({
+        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;
+            }
+            // 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) {
@@ -659,40 +777,23 @@ const PluginService = (getLanguage, getInitialOptions, getAvailableLanguages, ge
         }
         return params.translation;
     };
-    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();
-    };
     return Object.freeze({
-        setFinalFormatter,
-        addFormatter,
+        addPlugin,
         formatTranslation,
-        setObserver,
-        getObserver,
-        setUi,
-        getUi,
-        addBackend,
-        setDevBackend,
         getDevBackend,
         getBackendRecord,
         getBackendDevRecord,
-        setLanguageDetector,
-        setLanguageStorage,
+        getLanguageDetector,
+        getLanguageStorage,
         getInitialLanguage,
         setStoredLanguage,
         run,
         stop,
         retranslate,
         highlight,
-        wrap,
         unwrap,
+        wrap,
+        hasDevBackend,
     });
 };
 
@@ -714,28 +815,9 @@ const ValueObserver = (initialValue, valueGetter, handler) => {
     });
 };
 
-const defaultValues = {
-    enableLanguageStore: true,
-    defaultNs: '',
-    filesUrlPrefix: 'i18n/',
-};
-const initState = (options, previousState) => {
-    const initialOptions = Object.assign(Object.assign(Object.assign({}, defaultValues), previousState === null || previousState === void 0 ? void 0 : previousState.initialOptions), options);
-    // remove extra '/' from url end
-    const apiUrl = initialOptions.apiUrl;
-    initialOptions.apiUrl = apiUrl ? apiUrl.replace(/\/+$/, '') : apiUrl;
-    return {
-        initialOptions,
-        activeNamespaces: (previousState === null || previousState === void 0 ? void 0 : previousState.activeNamespaces) || new Map(),
-        language: previousState === null || previousState === void 0 ? void 0 : previousState.language,
-        pendingLanguage: previousState === null || previousState === void 0 ? void 0 : previousState.language,
-        isInitialLoading: false,
-        isRunning: false,
-    };
-};
-
 const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
     let state = initState();
+    let devCredentials = undefined;
     function init(options) {
         state = initState(options, state);
     }
@@ -757,13 +839,6 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
     function getLanguage() {
         return state.language || state.initialOptions.language;
     }
-    function getLanguageOrFail() {
-        const language = state.language || state.initialOptions.language;
-        if (!language) {
-            throw new Error(`No language set`);
-        }
-        return language;
-    }
     function setLanguage(language) {
         if (state.language !== language) {
             state.language = language;
@@ -780,7 +855,7 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
         }
     }
     function getInitialOptions() {
-        return state.initialOptions;
+        return Object.assign(Object.assign({}, state.initialOptions), devCredentials);
     }
     function addActiveNs(ns) {
         const namespaces = getFallbackArray(ns);
@@ -809,6 +884,7 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
     function getRequiredNamespaces() {
         return unique([
             ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
+            ...getFallbackArray(state.initialOptions.fallbackNs),
             ...state.activeNamespaces.keys(),
         ]);
     }
@@ -822,11 +898,11 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
             ...getFallbackFromStruct(language, state.initialOptions.fallbackLanguage),
         ]);
     }
-    function getFallbackNamespaces() {
-        const defaultNs = state.initialOptions.defaultNs;
-        const fallbackNs = state.initialOptions.fallbackNs;
-        const fallbackNamespaces = typeof defaultNs === 'string' ? [defaultNs] : [];
-        return unique([...fallbackNamespaces, ...getFallbackArray(fallbackNs)]);
+    function getFallbackNs() {
+        return getFallbackArray(state.initialOptions.fallbackNs);
+    }
+    function getDefaultNs(ns) {
+        return ns === undefined ? state.initialOptions.defaultNs : ns;
     }
     function getAvailableLanguages() {
         if (state.initialOptions.availableLanguages) {
@@ -845,6 +921,14 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
             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,
@@ -852,7 +936,6 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
         isInitialLoading,
         setInitialLoading,
         getLanguage,
-        getLanguageOrFail,
         setLanguage,
         getPendingLanguage,
         setPendingLanguage,
@@ -861,50 +944,24 @@ const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
         removeActiveNs,
         getRequiredNamespaces,
         getFallbackLangs,
-        getFallbackNamespaces,
+        getFallbackNs,
+        getDefaultNs,
         getAvailableLanguages,
         withDefaultNs,
+        overrideCredentials,
     });
 };
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
 function parseCombinedOptions(_a) {
     var { ns, noWrap, orEmpty, params } = _a, rest = __rest(_a, ["ns", "noWrap", "orEmpty", "params"]);
     const options = {
         ns: ns,
         noWrap: noWrap,
         orEmpty: orEmpty,
-        params: Object.assign(Object.assign({}, rest), params),
     };
-    return options;
+    return Object.assign(Object.assign({}, options), { params: Object.assign({}, rest) });
 }
-const getTranslateParams = (keyOrProps, ...params) => {
+const getTranslateProps = (keyOrProps, ...params) => {
     let result = {};
     let options;
     if (typeof keyOrProps === 'object') {
@@ -926,28 +983,40 @@ const getTranslateParams = (keyOrProps, ...params) => {
     return result;
 };
 
-const Controller = ({ events, options }) => {
+const 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 state = State(events.onLanguageChange, events.onPendingLanguageChange, events.onRunningChange);
-    const pluginService = PluginService(state.getLanguage, state.getInitialOptions, state.getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation);
+    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);
-    state.init(options);
-    cache.addStaticData(state.getInitialOptions().staticData);
-    if (isDev()) {
-        cache.invalidate();
+    if (options) {
+        init(options);
     }
-    events.onKeyUpdate.listen(() => {
+    events.onUpdate.listen(() => {
         if (state.isRunning()) {
             pluginService.retranslate();
         }
     });
-    const t = (...args) => {
-        // @ts-ignore
-        const params = getTranslateParams(...args);
-        const translation = getTranslation(params);
-        return pluginService.formatTranslation(Object.assign(Object.assign({}, params), { translation }));
-    };
+    function getFallbackNs() {
+        return state.getFallbackNs();
+    }
+    function getDefaultNs(ns) {
+        return state.getDefaultNs(ns);
+    }
+    // gets all namespaces where translation could be located
+    // takes (ns|default, fallback ns)
+    function getDefaultAndFallbackNs(ns) {
+        return [...getFallbackArray(getDefaultNs(ns)), ...getFallbackNs()];
+    }
+    // gets all namespaces which need to be loaded
+    // takes (ns|default, initial ns, fallback ns, active ns)
+    function getRequiredNamespaces(ns) {
+        return [
+            ...getFallbackArray(ns || getDefaultNs()),
+            ...state.getRequiredNamespaces(),
+        ];
+    }
     function changeTranslation(descriptor, key, value) {
         const keyObject = state.withDefaultNs(descriptor);
         const previousValue = cache.getTranslation(keyObject, key);
@@ -966,7 +1035,7 @@ const Controller = ({ events, options }) => {
         return cache.isLoading(state.getLanguage(), ns);
     }
     function isDev() {
-        return Boolean(state.getInitialOptions().apiKey && pluginService.getDevBackend());
+        return Boolean(state.getInitialOptions().apiKey && state.getInitialOptions().apiUrl);
     }
     async function addActiveNs(ns, forget) {
         if (!forget) {
@@ -978,7 +1047,7 @@ const Controller = ({ events, options }) => {
     }
     function getRequiredRecords(lang, ns) {
         const languages = state.getFallbackLangs(lang);
-        const namespaces = ns !== undefined ? getFallbackArray(ns) : state.getRequiredNamespaces();
+        const namespaces = getRequiredNamespaces(ns);
         const result = [];
         languages.forEach((language) => {
             namespaces.forEach((namespace) => {
@@ -995,7 +1064,7 @@ const Controller = ({ events, options }) => {
             return false;
         }
         const languages = state.getFallbackLangs(language);
-        const namespaces = ns !== undefined ? getFallbackArray(ns) : state.getRequiredNamespaces();
+        const namespaces = getRequiredNamespaces(ns);
         const result = [];
         languages.forEach((language) => {
             namespaces.forEach((namespace) => {
@@ -1028,24 +1097,19 @@ const Controller = ({ events, options }) => {
             pluginService.setStoredLanguage(language);
         }
     }
-    function getTranslationNs({ key, ns, }) {
-        const namespaces = ns
-            ? getFallbackArray(ns)
-            : state.getFallbackNamespaces();
+    function getTranslationNs({ key, ns }) {
         const languages = state.getFallbackLangs();
+        const namespaces = getDefaultAndFallbackNs(ns);
         return cache.getTranslationNs(namespaces, languages, key);
     }
-    function getTranslation({ key, ns, }) {
-        const namespaces = ns
-            ? getFallbackArray(ns)
-            : state.getFallbackNamespaces();
+    function getTranslation({ key, ns }) {
+        const namespaces = getDefaultAndFallbackNs(ns);
         const languages = state.getFallbackLangs();
         return cache.getTranslationFallback(namespaces, languages, key);
     }
     function loadInitial() {
         const data = valueOrPromise(initializeLanguage(), () => {
             // fail if there is no language
-            state.getLanguageOrFail();
             return loadRequiredRecords();
         });
         if (isPromise(data)) {
@@ -1084,8 +1148,26 @@ const Controller = ({ events, options }) => {
     function loadRecords(descriptors) {
         return cache.loadRecords(descriptors, isDev());
     }
+    const checkCorrectConfiguration = () => {
+        const languageComputable = pluginService.getLanguageDetector() || pluginService.getLanguageStorage();
+        if (languageComputable) {
+            const availableLanguages = state.getAvailableLanguages();
+            if (!availableLanguages) {
+                throw new Error(missingOptionError('availableLanguages'));
+            }
+        }
+        if (!state.getLanguage() && !state.getInitialOptions().defaultLanguage) {
+            if (languageComputable) {
+                throw new Error(missingOptionError('defaultLanguage'));
+            }
+            else {
+                throw new Error(missingOptionError('language'));
+            }
+        }
+    };
     function run() {
         let result = undefined;
+        checkCorrectConfiguration();
         if (!state.isRunning()) {
             if (isDev()) {
                 cache.invalidate();
@@ -1102,12 +1184,17 @@ const Controller = ({ events, options }) => {
             state.setRunning(false);
         }
     }
-    return Object.freeze(Object.assign(Object.assign(Object.assign(Object.assign({}, state), pluginService), cache), { init,
+    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,
-        loadRequiredRecords,
         loadRecords,
         loadRecord,
         isLoading,
@@ -1118,24 +1205,11 @@ const Controller = ({ events, options }) => {
         stop }));
 };
 
-const Tolgee = (options) => {
-    const events = Events();
+const createTolgee = (options) => {
     const controller = Controller({
-        events,
         options,
     });
-    const pluginTools = Object.freeze({
-        setFinalFormatter: controller.setFinalFormatter,
-        addFormatter: controller.addFormatter,
-        setObserver: controller.setObserver,
-        getObserver: controller.getObserver,
-        setUi: controller.setUi,
-        getUi: controller.getUi,
-        setDevBackend: controller.setDevBackend,
-        addBackend: controller.addBackend,
-        setLanguageDetector: controller.setLanguageDetector,
-        setLanguageStorage: controller.setLanguageStorage,
-    });
+    // restarts tolgee while applying callback
     const withRestart = (callback) => {
         const wasRunning = controller.isRunning();
         wasRunning && controller.stop();
@@ -1143,55 +1217,357 @@ const Tolgee = (options) => {
         wasRunning && controller.run();
     };
     const tolgee = Object.freeze({
-        // event listeners
-        on: events.on,
-        onKeyUpdate: events.onKeyUpdate.listenSome,
-        // state
+        /**
+         * Listen to tolgee events.
+         */
+        on: controller.on,
+        /**
+         * Listen for specific namespaces changes.
+         *
+         * ```
+         * const sub = tolgee.onUpdate(handler)
+         *
+         * // subscribe to selected namespace
+         * sub.subscribeNs(['common'])
+         *
+         * // unsubscribe
+         * sub.unsubscribe()
+         * ```
+         */
+        onNsUpdate: controller.onUpdate.listenSome,
+        /**
+         * Turn off/on events emitting. Is on by default.
+         */
+        setEmmiterActive: controller.setEmmiterActive,
+        /**
+         * @return current language if set.
+         */
         getLanguage: controller.getLanguage,
+        /**
+         * `pendingLanguage` represents language which is currently being loaded.
+         * @return current `pendingLanguage` if set.
+         */
         getPendingLanguage: controller.getPendingLanguage,
+        /**
+         * Change current language.
+         * - if not running sets `pendingLanguage`, `language` to the new value
+         * - if running sets `pendingLanguage` to the value, fetches necessary data and then changes `language`
+         *
+         * @return Promise which is resolved when `language` is changed.
+         */
         changeLanguage: controller.changeLanguage,
+        /**
+         * Temporarily change translation in cache.
+         * @return object with revert method.
+         */
         changeTranslation: controller.changeTranslation,
+        /**
+         * Adds namespace(s) list of active namespaces. And if tolgee is running, loads required data.
+         */
         addActiveNs: controller.addActiveNs,
+        /**
+         * Remove namespace(s) from active namespaces.
+         *
+         * Tolgee internally counts how many times was each active namespace added,
+         * so this method will remove namespace only if the counter goes down to 0.
+         */
         removeActiveNs: controller.removeActiveNs,
+        /**
+         * Manually load multiple records from `Backend` (or `DevBackend` when in dev mode)
+         *
+         * It loads data together and adds them to cache in one operation, to prevent partly loaded state.
+         */
         loadRecords: controller.loadRecords,
+        /**
+         * Manually load record from `Backend` (or `DevBackend` when in dev mode)
+         */
         loadRecord: controller.loadRecord,
+        /**
+         *
+         */
         addStaticData: controller.addStaticData,
+        /**
+         * Get record from cache.
+         */
         getRecord: controller.getRecord,
+        /**
+         * Get all records from cache.
+         */
         getAllRecords: controller.getAllRecords,
+        /**
+         * @param ns optional list of namespaces that you are interested in
+         * @return `true` if there are data that need to be fetched.
+         */
         isLoaded: controller.isLoaded,
+        /**
+         * @return `true` if tolgee is loading initial data (triggered by `run`).
+         */
         isInitialLoading: controller.isInitialLoading,
+        /**
+         * @param ns optional list of namespaces that you are interested in
+         * @return `true` if tolgee is loading some translations for the first time.
+         */
         isLoading: controller.isLoading,
+        /**
+         * @param ns optional list of namespaces that you are interested in
+         * @return `true` if tolgee is fetching some translations.
+         */
         isFetching: controller.isFetching,
+        /**
+         * @return `true` if tolgee is running.
+         */
         isRunning: controller.isRunning,
+        /**
+         * Changes internal state to running: true and loads initial files.
+         * Runs runnable plugins mainly Observer if present.
+         */
         run: controller.run,
+        /**
+         * Changes internal state to running: false and stops runnable plugins.
+         */
         stop: controller.stop,
+        /**
+         * Returns translated and formatted key.
+         * If Observer is present and tolgee is running, wraps result to be identifiable in the DOM.
+         */
         t: controller.t,
+        /**
+         * Highlight keys that match selection.
+         */
         highlight: controller.highlight,
+        /**
+         * @return current Tolgee options.
+         */
         getInitialOptions: controller.getInitialOptions,
+        /**
+         * Tolgee is in dev mode if `DevTools` plugin is used and `apiKey` + `apiUrl` are specified.
+         * @return `true` if tolgee is in dev mode.
+         */
         isDev: controller.isDev,
+        /**
+         * Wraps translation if there is `Observer` plugin
+         */
         wrap: controller.wrap,
+        /**
+         * Unwrap translation
+         */
         unwrap: controller.unwrap,
-        // plugins
-        use: (plugin) => {
+        /**
+         * Override creadentials passed on initialization.
+         *
+         * When called in running state, tolgee stops and runs again.
+         */
+        overrideCredentials(credentials) {
+            withRestart(() => controller.overrideCredentials(credentials));
+        },
+        /**
+         * Add tolgee plugin after initialization.
+         *
+         * When called in running state, tolgee stops and runs again.
+         */
+        addPlugin(plugin) {
             if (plugin) {
-                withRestart(() => plugin(tolgee, pluginTools));
+                withRestart(() => controller.addPlugin(tolgee, plugin));
             }
-            return tolgee;
         },
-        init: (options) => {
-            withRestart(() => controller.init(options));
-            return tolgee;
+        /**
+         * Updates options after instance creation. Extends existing options,
+         * so it only changes the fields, that are listed.
+         *
+         * When called in running state, tolgee stops and runs again.
+         */
+        updateOptions(options) {
+            if (options) {
+                withRestart(() => controller.init(options));
+            }
         },
     });
     return tolgee;
 };
+/**
+ * Tolgee chainable constructor.
+ *
+ * Usage:
+ * ```
+ * const tolgee = Tolgee().use(...).init(...)
+ * ```
+ */
+const TolgeeCore = () => {
+    const state = {
+        plugins: [],
+        options: {},
+    };
+    const tolgeeChain = Object.freeze({
+        use(plugin) {
+            state.plugins.push(plugin);
+            return tolgeeChain;
+        },
+        updateDefaults(options) {
+            state.options = combineOptions(state.options, options);
+            return tolgeeChain;
+        },
+        init(options) {
+            const tolgee = createTolgee(combineOptions(state.options, options));
+            state.plugins.forEach(tolgee.addPlugin);
+            return tolgee;
+        },
+    });
+    return tolgeeChain;
+};
 
-const RESTRICTED_ASCENDANT_ATTRIBUTE = 'data-tolgee-restricted';
-const TOLGEE_ATTRIBUTE_NAME = '_tolgee';
-const TOLGEE_HIGHLIGHTER_CLASS = '_tolgee-highlighter';
-const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = 'data-tolgee-key-only';
-// needs to be same as in @tolgee/ui package
-const DEVTOOLS_ID = '__tolgee_dev_tools';
+const ERROR_PARAM_EMPTY = 0, ERROR_UNEXPECTED_CHAR = 1, ERROR_UNEXPECTED_END = 2;
+class FormatError extends Error {
+    constructor(code, index, text) {
+        let error;
+        if (code === ERROR_PARAM_EMPTY) {
+            error = 'Empty parameter';
+        }
+        else if (code === ERROR_UNEXPECTED_CHAR) {
+            error = 'Unexpected character';
+        }
+        else {
+            error = 'Unexpected end';
+        }
+        super(`Tolgee parser: ${error} at ${index} in "${text}"`);
+        this.code = code;
+        this.index = index;
+    }
+}
+
+function isWhitespace(ch) {
+    return /\s/.test(ch);
+}
+const STATE_TEXT = 0, STATE_ESCAPE_MAYBE = 1, STATE_ESCAPE = 2, STATE_PARAM = 3, STATE_PARAM_AFTER = 4;
+const END_STATES = new Set([
+    STATE_ESCAPE,
+    STATE_ESCAPE_MAYBE,
+    STATE_TEXT,
+]);
+const CHAR_ESCAPE = "'";
+const ESCAPABLE = new Set(['{', '}', CHAR_ESCAPE]);
+const isAllowedInParam = (char) => {
+    return /[0-9a-zA-Z_]/.test(char);
+};
+function formatParser(translation) {
+    let state = STATE_TEXT;
+    let text = '';
+    let param = '';
+    let ch = '';
+    const texts = [];
+    const params = [];
+    let i = 0;
+    function parsingError(code) {
+        throw new FormatError(code, i, translation);
+    }
+    const addText = () => {
+        texts.push(text);
+        text = '';
+    };
+    const addParamChar = () => {
+        if (!isAllowedInParam(ch)) {
+            parsingError(ERROR_UNEXPECTED_CHAR);
+        }
+        param += ch;
+    };
+    const addParam = () => {
+        if (param === '') {
+            parsingError(ERROR_PARAM_EMPTY);
+        }
+        params.push(param);
+        param = '';
+    };
+    for (i = 0; i < translation.length; i++) {
+        ch = translation[i];
+        switch (state) {
+            case STATE_TEXT:
+                if (ch === CHAR_ESCAPE) {
+                    text += ch;
+                    state = STATE_ESCAPE_MAYBE;
+                }
+                else if (ch === '{') {
+                    addText();
+                    state = STATE_PARAM;
+                }
+                else {
+                    text += ch;
+                    state = STATE_TEXT;
+                }
+                break;
+            case STATE_ESCAPE_MAYBE:
+                if (ESCAPABLE.has(ch)) {
+                    text = text.slice(0, -1) + ch;
+                    state = STATE_ESCAPE;
+                }
+                else {
+                    text += ch;
+                    state = STATE_TEXT;
+                }
+                break;
+            case STATE_ESCAPE:
+                if (ch === CHAR_ESCAPE) {
+                    state = STATE_TEXT;
+                }
+                else {
+                    text += ch;
+                    state = STATE_ESCAPE;
+                }
+                break;
+            case STATE_PARAM:
+                if (ch === '}') {
+                    addParam();
+                    state = STATE_TEXT;
+                }
+                else if (!isWhitespace(ch)) {
+                    addParamChar();
+                    state = STATE_PARAM;
+                }
+                else if (param !== '') {
+                    addParam();
+                    state = STATE_PARAM_AFTER;
+                }
+                break;
+            case STATE_PARAM_AFTER:
+                if (ch == '}') {
+                    state = STATE_TEXT;
+                }
+                else if (isWhitespace(ch)) {
+                    state = STATE_PARAM_AFTER;
+                }
+                else {
+                    parsingError(ERROR_UNEXPECTED_CHAR);
+                }
+        }
+    }
+    if (!END_STATES.has(state)) {
+        parsingError(ERROR_UNEXPECTED_END);
+    }
+    addText();
+    return [texts, params];
+}
+
+function formatter(translation, params) {
+    const [texts, pars] = formatParser(translation);
+    const result = [texts[0]];
+    for (let i = 1; i < texts.length; i++) {
+        const parameter = params === null || params === void 0 ? void 0 : params[pars[i - 1]];
+        if (parameter === undefined) {
+            throw new Error(`Missing parameter "${pars[i - 1]}" in "${translation}"`);
+        }
+        result.push(String(parameter));
+        result.push(texts[i]);
+    }
+    return result.join('');
+}
+
+function createFormatSimple() {
+    return {
+        format: ({ translation, params }) => formatter(translation, params),
+    };
+}
+const FormatSimple = () => (tolgee, tools) => {
+    tools.setFinalFormatter(createFormatSimple());
+    return tolgee;
+};
 
-export { DEVTOOLS_ID, RESTRICTED_ASCENDANT_ATTRIBUTE, TOLGEE_ATTRIBUTE_NAME, TOLGEE_HIGHLIGHTER_CLASS, TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE, Tolgee, getFallback, getFallbackArray, getTranslateParams };
-//# sourceMappingURL=tolgee.esm.mjs.map
+export { FormatSimple, TolgeeCore, getFallback, getFallbackArray, getTranslateProps };
+//# sourceMappingURL=tolgee.esm.js.map