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

package/dist/tolgee.umd.js

@@ -4,25 +4,18 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@tolgee/core"] = {}));
 })(this, (function (exports) { 'use strict';
 
-    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;
     }
@@ -49,22 +42,40 @@
     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) => {
@@ -81,8 +92,7 @@
                 fn: (e) => {
                     handler(e);
                 },
-                keys: new Map(),
-                namespaces: new Map(),
+                namespaces: new Set(),
             };
             partialListeners.add(handlerWrapper);
             const result = {
@@ -90,105 +100,85 @@
                     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) {
@@ -206,20 +196,23 @@
                     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,
         });
     };
@@ -232,7 +225,7 @@
                 return;
             }
             if (typeof value === 'object') {
-                Object.entries(flattenTranslations(value)).forEach(([flatKey, flatValue]) => {
+                flattenTranslations(value).forEach((flatValue, flatKey) => {
                     result.set(key + '.' + flatKey, flatValue);
                 });
                 return;
@@ -242,7 +235,9 @@
         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, }) => {
@@ -297,7 +292,7 @@
         }
         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;
@@ -310,11 +305,11 @@
                     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;
@@ -335,9 +330,6 @@
             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;
@@ -360,24 +352,20 @@
                         }));
                 }));
         }
-        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) {
@@ -387,12 +375,12 @@
                 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;
         }
@@ -409,7 +397,7 @@
                         cacheKey,
                     };
                 }
-                const dataPromise = fetchData(keyObject, isDev);
+                const dataPromise = fetchData(keyObject, isDev) || Promise.resolve(undefined);
                 asyncRequests.set(cacheKey, dataPromise);
                 return {
                     new: true,
@@ -431,6 +419,10 @@
                     if (data) {
                         addRecord(value.keyObject, data);
                     }
+                    else if (!getRecord(value.keyObject)) {
+                        // if no data exist, put empty object
+                        addRecord(value.keyObject, {});
+                    }
                 }
             });
             fetchingObserver.notify();
@@ -456,27 +448,85 @@
             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: [],
@@ -488,39 +538,20 @@
             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;
@@ -532,14 +563,17 @@
             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) {
@@ -550,14 +584,17 @@
             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);
@@ -565,6 +602,9 @@
         const setLanguageDetector = (detector) => {
             instances.languageDetector = detector;
         };
+        const getLanguageDetector = () => {
+            return instances.languageDetector;
+        };
         const detectLanguage = () => {
             if (!instances.languageDetector) {
                 return undefined;
@@ -594,14 +634,37 @@
         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,
             });
@@ -622,42 +685,97 @@
             }
             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) {
@@ -665,40 +783,23 @@
             }
             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,
         });
     };
 
@@ -720,28 +821,9 @@
         });
     };
 
-    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);
         }
@@ -763,13 +845,6 @@
         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;
@@ -786,7 +861,7 @@
             }
         }
         function getInitialOptions() {
-            return state.initialOptions;
+            return Object.assign(Object.assign({}, state.initialOptions), devCredentials);
         }
         function addActiveNs(ns) {
             const namespaces = getFallbackArray(ns);
@@ -815,6 +890,7 @@
         function getRequiredNamespaces() {
             return unique([
                 ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
+                ...getFallbackArray(state.initialOptions.fallbackNs),
                 ...state.activeNamespaces.keys(),
             ]);
         }
@@ -828,11 +904,11 @@
                 ...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) {
@@ -851,6 +927,14 @@
                 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,
@@ -858,7 +942,6 @@
             isInitialLoading,
             setInitialLoading,
             getLanguage,
-            getLanguageOrFail,
             setLanguage,
             getPendingLanguage,
             setPendingLanguage,
@@ -867,50 +950,24 @@
             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') {
@@ -932,28 +989,40 @@
         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);
@@ -972,7 +1041,7 @@
             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) {
@@ -984,7 +1053,7 @@
         }
         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) => {
@@ -1001,7 +1070,7 @@
                 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) => {
@@ -1034,24 +1103,19 @@
                 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)) {
@@ -1090,8 +1154,26 @@
         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();
@@ -1108,12 +1190,17 @@
                 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,
@@ -1124,24 +1211,11 @@
             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();
@@ -1149,65 +1223,363 @@
             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;
+    };
 
-    exports.DEVTOOLS_ID = DEVTOOLS_ID;
-    exports.RESTRICTED_ASCENDANT_ATTRIBUTE = RESTRICTED_ASCENDANT_ATTRIBUTE;
-    exports.TOLGEE_ATTRIBUTE_NAME = TOLGEE_ATTRIBUTE_NAME;
-    exports.TOLGEE_HIGHLIGHTER_CLASS = TOLGEE_HIGHLIGHTER_CLASS;
-    exports.TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE;
-    exports.Tolgee = Tolgee;
+    exports.FormatSimple = FormatSimple;
+    exports.TolgeeCore = TolgeeCore;
     exports.getFallback = getFallback;
     exports.getFallbackArray = getFallbackArray;
-    exports.getTranslateParams = getTranslateParams;
+    exports.getTranslateProps = getTranslateProps;
 
     Object.defineProperty(exports, '__esModule', { value: true });