@esfaenza/localizations 11.2.9 → 11.2.11

package/bundles/esfaenza-localizations.umd.js

@@ -1,13 +1,339 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@esfaenza/extensions')) :
-    typeof define === 'function' && define.amd ? define('@esfaenza/localizations', ['exports', '@angular/core', '@esfaenza/extensions'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza.localizations = {}), global.ng.core, global.extensions));
-}(this, (function (exports, core, extensions) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs/operators'), require('rxjs'), require('@esfaenza/extensions')) :
+    typeof define === 'function' && define.amd ? define('@esfaenza/localizations', ['exports', '@angular/core', 'rxjs/operators', 'rxjs', '@esfaenza/extensions'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza.localizations = {}), global.ng.core, global.rxjs.operators, global.rxjs, global.extensions));
+}(this, (function (exports, i0, operators, rxjs, extensions) { 'use strict';
 
-    /**
-     * Locale da utilizzare per le traduzioni
-     */
-    var LOC_LOCALE = new core.InjectionToken('LOC_LOCALE');
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () {
+                            return e[k];
+                        }
+                    });
+                }
+            });
+        }
+        n['default'] = e;
+        return Object.freeze(n);
+    }
+
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+
+    /*! *****************************************************************************
+    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.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    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 __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+            to[j] = from[i];
+        return to;
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
+    }
 
     /**
      * Contenitore delle localizzazioni collegate ad un testo "base", una per ogni linguaggio supportato
@@ -80,15 +406,6 @@
         new LocaleObject('en-US', 'English', ['en', 'en-US'])
     ];
 
-    /**
-     * Classe di configurazione per il modulo di localizzazione
-     */
-    var LocalizationModuleConfig = /** @class */ (function () {
-        function LocalizationModuleConfig() {
-        }
-        return LocalizationModuleConfig;
-    }());
-
     /**
      * Classe che rappresenta la localizzazione di un test base per una certa lingua
      */
@@ -106,77 +423,14 @@
         return SpecializedLocalization;
     }());
 
-    /**
-     * Classe singleton che contiene le traduzioni di base (per evitare di ripeterle in oggi classe di traduzione) e le funzioni base per
-     * inserire e leggere traduzioni in/da una cache
-     */
-    var BaseLocalization = /** @class */ (function () {
-        /**
-         * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
-         */
-        function BaseLocalization() {
-            /**
-             * Cache di tutte le localizzazioni di base
-             */
-            this.BaseTranslations = {};
-            // Odio sprecare caratteri... soprattutto quando rischio che non vengano minificati
-            var bt = this.BaseTranslations;
-            var bl = BaseLocalization;
-            bl.set(bt, "en->it", "Remove", ["Elimina"]);
-            bl.set(bt, "en->it", "Paging", ["Paginazione"]);
-            bl.set(bt, "en->it", "Yes", ["Si"]);
-            bl.set(bt, "en->it", "No", ["No"]);
-            bl.set(bt, "en->it", "YES", ["SI'"]);
-            bl.set(bt, "en->it", "NO", ["NO"]);
-            bl.set(bt, "en->it", "Found objects", ["Risultati trovati"]);
-            bl.set(bt, "en->it", "Loading data...", ["Carico i dati..."]);
-            bl.set(bt, "en->it", "Error during save operations", ["Errori durante il salvataggio"]);
-            bl.set(bt, "en->it", "Error", ["Errore"]);
-            bl.set(bt, "en->it", "Warning", ["Avviso"]);
-            bl.set(bt, "en->it", "Information", ["Informazione"]);
-            bl.set(bt, "en->it", "Save", ["Salva"]);
-            bl.set(bt, "en->it", "Back", ["Indietro"]);
-            bl.set(bt, "en->it", "From", ["Da"]);
-            bl.set(bt, "en->it", "To", ["A"]);
-            bl.set(bt, "en->it", "View Chart", ["Vedi Grafico"]);
-            bl.set(bt, "en->it", "View Table", ["Vedi Tabella"]);
-            bl.set(bt, "en->it", "Notes", ["Note"]);
-            bl.set(bt, "en->it", "Edit Notes", ["Modifica Note"]);
-            bl.set(bt, "en->it", "Cancel", ["Annulla"]);
-            bl.set(bt, "en->it", "Confirm", ["Conferma"]);
-            bl.set(bt, "en->it", "View", ["Visualizza"]);
-            bl.set(bt, "en->it", "Close", ["Chiudi"]);
-            bl.set(bt, "en->it", "Select", ["Seleziona"]);
-            bl.set(bt, "en->it", "Meter Reading registered successfully", ["Lettura registrata correttamente"]);
-            bl.set(bt, "en->it", "Validation errors during save operations", ["Errori di validazione durante il salvataggio"]);
-            bl.set(bt, "en->it", "Can't register reading", ["Impossibile registrare la lettura"]);
-            bl.set(bt, "en->it", "Electricity", ["Elettricita"]);
-            bl.set(bt, "en->it", "Gas", ["Gas"]);
-            bl.set(bt, "en->it", "Water", ["Acqua"]);
-            bl.set(bt, "en->it", "Delete", ["Elimina"]);
-            bl.set(bt, "en->it", "This operation cannot be reverted", ["Questa operazione non puo' essere annullata"]);
-            bl.set(bt, "en->it", "Hide", ["Nascondi"]);
-            // Helper validazione
-            bl.set(bt, "en->it", "Required field", ["Campo richiesto"]);
-            bl.set(bt, "en->it", "Wrong field format", ["Formato campo errato"]);
-            bl.set(bt, "en->it", "Wrong field format or field missing", ["Formato campo errato o campo mancante"]);
-            bl.set(bt, "en->it", "You don't have the required permissions to view this page. The navigation has been blocked", ["Non si hanno privilegi a sufficienza per accedere a questa pagina. La navigazione e' stata bloccata"]);
-            // Informazioni sulle date
-            bl.setToken(bt, "en->it", "getDateMonthPosition", "0", ["1"]);
-            bl.setToken(bt, "en->it", "getDisplayDateMonthPosition", "1", ["1"]);
-            bl.setToken(bt, "en->it", "getLocale", "en-US", ["it-IT"]);
-            bl.setToken(bt, "en->it", "getSmallDateFormat", "MM/DD/YYYY", ["DD/MM/YYYY"]);
-            bl.setToken(bt, "en->it", "getDefaultDateFormat", "MM/DD/YYYY", ["MM/DD/YYYY"]);
-            bl.setToken(bt, "en->it", "getSmallDateDisplayFormat", "DD/MM/YYYY", ["DD/MM/YYYY"]);
-            bl.setToken(bt, "en->it", "getFullDateFormat", "MM/DD/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
-            bl.setToken(bt, "en->it", "getFullDateDisplayFormat", "DD/MM/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
-            bl.setToken(bt, "en->it", "getFullDateFormatNoSeconds", "MM/DD/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
-            bl.setToken(bt, "en->it", "getFullDateDisplayFormatNoSeconds", "DD/MM/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+    var LocalizationPersistor = /** @class */ (function () {
+        function LocalizationPersistor(LocCache) {
+            if (LocCache === void 0) { LocCache = null; }
+            this.LocCache = LocCache;
         }
         /**
          * Imposta la localizzazione di un token all'interno della cache scelta
          *
-         * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione del token con le localizzazioni
          * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.
          * Ad esempio, "en->it" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right**
          * è presente l'unica traduzione in italiano, per definire più traduzioni sul lato destro della freccia bisogna concatenarle con la virgola, ad esempio "en->it,jp,ecc"
@@ -184,56 +438,56 @@
          * @param {string} left Valore del token per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**
          * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
          */
-        BaseLocalization.setToken = function (locCache, direction, token, left, right) {
+        LocalizationPersistor.prototype.setToken = function (direction, token, left, right) {
+            var _this = this;
             var parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
             var parsingRes = parsingRegex.exec(direction);
             var from = parsingRes[1];
             var to = parsingRes[2].replace(/\s/g, '').split(',');
             var localeFrom = LocaleDefinitions.getByAlias(from);
-            BaseLocalization._set(locCache, token, localeFrom.id, left, true);
+            this._set(token, localeFrom.id, left, true);
             to.forEach(function (t, index) {
                 var localeTo = LocaleDefinitions.getByAlias(t);
-                BaseLocalization._set(locCache, token, localeTo.id, right[index], true);
+                _this._set(token, localeTo.id, right[index], true);
             });
         };
         /**
          * Imposta la localizzazione di una frase all'interno della cache scelta
          *
-         * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione della frase con le localizzazioni
          * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.
          * Ad esempio, "en->it" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right**
          * è presente l'unica traduzione in italiano, per definire più traduzioni sul lato destro della freccia bisogna concatenarle con la virgola, ad esempio "en->it,jp,ecc"
          * @param {string} left Valore della frase per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**
          * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
          */
-        BaseLocalization.set = function (locCache, direction, left, right) {
+        LocalizationPersistor.prototype.set = function (direction, left, right) {
+            var _this = this;
             var parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
             var parsingRes = parsingRegex.exec(direction);
             var from = parsingRes[1];
             var to = parsingRes[2].replace(/\s/g, '').split(',');
             var localeFrom = LocaleDefinitions.getByAlias(from);
-            BaseLocalization._set(locCache, left, localeFrom.id, left);
+            this._set(left, localeFrom.id, left);
             to.forEach(function (t, index) {
                 var localeTo = LocaleDefinitions.getByAlias(t);
-                BaseLocalization._set(locCache, left, localeTo.id, right[index]);
+                _this._set(left, localeTo.id, right[index]);
             });
         };
         /**
          * Imposta all'interno della cache specificata un'unica traduzione partendo da un testo di base
          *
-         * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione del testo con le localizzazioni
          * @param {string} text Testo da tradurre
          * @param {string} culture Lingua per cui inserire la traduzione
          * @param {string} translation Traduzione del **text** nella lingua specificata da **culture**
          * @param {boolean} token Indica se il **text** è un token o è una frase normale
          */
-        BaseLocalization._set = function (locCache, text, culture, translation, token) {
-            var item = BaseLocalization.findByText(locCache, text, token);
+        LocalizationPersistor.prototype._set = function (text, culture, translation, token) {
+            var item = this.get(text, token);
             if (!item) {
-                locCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
+                this.LocCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
                 return;
             }
-            var trs = BaseLocalization.translationByCulture(item, culture);
+            var trs = this.translationByCulture(item, culture);
             if (trs) {
                 console.warn("Localization already loaded for sentence '" + text + "' and culture " + culture);
                 return;
@@ -243,18 +497,15 @@
         /**
          * Partendo da una cache di localizzazione, dato un testo che può essere o meno un token, cerca quell'elemento all'interno della cache
          *
-         * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno del quale cercare il **text**
-         * @param {string} text Testo da cercare nella **locCache**
+         * @param {string} text Testo da cercare nella **LocCache**
          * @param {boolean} allowtokens Indica se l'elemento cercato può essere un token o se dev'essere per forza una frase (per evitare rari
          * casi di collisione in cui magari un token è uguale a una frase tradotta)
          *
          * @returns {ItemLocalization} Informazioni di localizzazione per il **text** cercato
          */
-        BaseLocalization.findByText = function (locCache, text, allowtokens) {
-            var possibleItem = locCache[text];
-            if (!possibleItem)
-                return null;
-            var item = allowtokens || !possibleItem.token ? possibleItem : null;
+        LocalizationPersistor.prototype.get = function (text, allowtokens) {
+            var possibleItem = this.LocCache[text];
+            var item = possibleItem && (allowtokens || !possibleItem.token) ? possibleItem : null;
             return item;
         };
         /**
@@ -265,7 +516,7 @@
          *
          * @returns {SpecializedLocalization} Informazioni di localizzazione specifiche della lingua richiesta
          */
-        BaseLocalization.translationByCulture = function (item, culture) {
+        LocalizationPersistor.prototype.translationByCulture = function (item, culture) {
             for (var i = 0; i < item.translations.length; i++) {
                 var trl = item.translations[i];
                 if (trl.culture == culture)
@@ -273,12 +524,180 @@
             }
             return null;
         };
+        return LocalizationPersistor;
+    }());
+
+    exports.BaseLocalizationTokens = void 0;
+    (function (BaseLocalizationTokens) {
+        BaseLocalizationTokens["getDateMonthPosition"] = "getDateMonthPosition";
+        BaseLocalizationTokens["getDisplayDateMonthPosition"] = "getDisplayDateMonthPosition";
+        BaseLocalizationTokens["getLocale"] = "getLocale";
+        BaseLocalizationTokens["getSmallDateFormat"] = "getSmallDateFormat";
+        BaseLocalizationTokens["getDefaultDateFormat"] = "getDefaultDateFormat";
+        BaseLocalizationTokens["getSmallDateDisplayFormat"] = "getSmallDateDisplayFormat";
+        BaseLocalizationTokens["getFullDateFormat"] = "getFullDateFormat";
+        BaseLocalizationTokens["getFullDateDisplayFormat"] = "getFullDateDisplayFormat";
+        BaseLocalizationTokens["getFullDateFormatNoSeconds"] = "getFullDateFormatNoSeconds";
+        BaseLocalizationTokens["getFullDateDisplayFormatNoSeconds"] = "getFullDateDisplayFormatNoSeconds";
+    })(exports.BaseLocalizationTokens || (exports.BaseLocalizationTokens = {}));
+
+    /** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+    var LocalePersistor = /** @class */ (function () {
+        function LocalePersistor() {
+            /** Chiave su cui salvare il locale */
+            this.LOCALE = "LOCALE";
+        }
+        return LocalePersistor;
+    }());
+
+    /** Locale da utilizzare per le traduzioni */
+    var LOC_LOCALE = new i0.InjectionToken('LOC_LOCALE');
+    /** Policy da utilizzare per traduzioni mancanti */
+    var LOC_MISSING_POLICY = new i0.InjectionToken('LOC_MISSING_POLICY');
+
+    /**
+     * Classe singleton che contiene le traduzioni di base (per evitare di ripeterle in oggi classe di traduzione) e le funzioni base per
+     * inserire e leggere traduzioni in/da una cache
+     */
+    var BaseLocalization = /** @class */ (function () {
+        /**
+         * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
+         */
+        function BaseLocalization(LocalePersistor, defaultLocale) {
+            var _this = this;
+            this.LocalePersistor = LocalePersistor;
+            /**
+             * Cache di tutte le localizzazioni di base
+             */
+            this.LocCache = {};
+            /**
+             * Locale di riferimento per tutte le traduzioni
+             */
+            this.Locale = new rxjs.ReplaySubject(1);
+            // Recupero il locale alla partenza del BaseLocalization in modo, spero di dare tempo all'applicazione di tirarlo su
+            this.LocalePersistor.recover().pipe(operators.take(1)).subscribe(function (l) { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (!l) {
+                        l = defaultLocale;
+                        this.LocalePersistor.persist(defaultLocale);
+                    }
+                    this.Locale.next(l);
+                    return [2 /*return*/];
+                });
+            }); });
+            this.Persistor = new LocalizationPersistor(this.LocCache);
+            this.Persistor.set("en->it", "Remove", ["Elimina"]);
+            this.Persistor.set("en->it", "Paging", ["Paginazione"]);
+            this.Persistor.set("en->it", "Yes", ["Si"]);
+            this.Persistor.set("en->it", "No", ["No"]);
+            this.Persistor.set("en->it", "YES", ["SI'"]);
+            this.Persistor.set("en->it", "NO", ["NO"]);
+            this.Persistor.set("en->it", "Found objects", ["Risultati trovati"]);
+            this.Persistor.set("en->it", "Loading data...", ["Carico i dati..."]);
+            this.Persistor.set("en->it", "Error during save operations", ["Errori durante il salvataggio"]);
+            this.Persistor.set("en->it", "Error", ["Errore"]);
+            this.Persistor.set("en->it", "Warning", ["Avviso"]);
+            this.Persistor.set("en->it", "Information", ["Informazione"]);
+            this.Persistor.set("en->it", "Save", ["Salva"]);
+            this.Persistor.set("en->it", "Back", ["Indietro"]);
+            this.Persistor.set("en->it", "From", ["Da"]);
+            this.Persistor.set("en->it", "To", ["A"]);
+            this.Persistor.set("en->it", "View Chart", ["Vedi Grafico"]);
+            this.Persistor.set("en->it", "View Table", ["Vedi Tabella"]);
+            this.Persistor.set("en->it", "Notes", ["Note"]);
+            this.Persistor.set("en->it", "Edit Notes", ["Modifica Note"]);
+            this.Persistor.set("en->it", "Cancel", ["Annulla"]);
+            this.Persistor.set("en->it", "Confirm", ["Conferma"]);
+            this.Persistor.set("en->it", "View", ["Visualizza"]);
+            this.Persistor.set("en->it", "Close", ["Chiudi"]);
+            this.Persistor.set("en->it", "Select", ["Seleziona"]);
+            this.Persistor.set("en->it", "Meter Reading registered successfully", ["Lettura registrata correttamente"]);
+            this.Persistor.set("en->it", "Validation errors during save operations", ["Errori di validazione durante il salvataggio"]);
+            this.Persistor.set("en->it", "Can't register reading", ["Impossibile registrare la lettura"]);
+            this.Persistor.set("en->it", "Electricity", ["Elettricita"]);
+            this.Persistor.set("en->it", "Gas", ["Gas"]);
+            this.Persistor.set("en->it", "Water", ["Acqua"]);
+            this.Persistor.set("en->it", "Delete", ["Elimina"]);
+            this.Persistor.set("en->it", "This operation cannot be reverted", ["Questa operazione non puo' essere annullata"]);
+            this.Persistor.set("en->it", "Hide", ["Nascondi"]);
+            // Helper validazione
+            this.Persistor.set("en->it", "Required field", ["Campo richiesto"]);
+            this.Persistor.set("en->it", "Wrong field format", ["Formato campo errato"]);
+            this.Persistor.set("en->it", "Wrong field format or field missing", ["Formato campo errato o campo mancante"]);
+            this.Persistor.set("en->it", "You don't have the required permissions to view this page. The navigation has been blocked", ["Non si hanno privilegi a sufficienza per accedere a questa pagina. La navigazione e' stata bloccata"]);
+            // Informazioni sulle date
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getDateMonthPosition, "0", ["1"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getDisplayDateMonthPosition, "1", ["1"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getLocale, "en-US", ["it-IT"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getSmallDateFormat, "MM/DD/YYYY", ["DD/MM/YYYY"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getDefaultDateFormat, "MM/DD/YYYY", ["MM/DD/YYYY"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getSmallDateDisplayFormat, "DD/MM/YYYY", ["DD/MM/YYYY"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getFullDateFormat, "MM/DD/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getFullDateDisplayFormat, "DD/MM/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getFullDateFormatNoSeconds, "MM/DD/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+            this.Persistor.setToken("en->it", exports.BaseLocalizationTokens.getFullDateDisplayFormatNoSeconds, "DD/MM/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+        }
         return BaseLocalization;
     }());
+    BaseLocalization.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function BaseLocalization_Factory() { return new BaseLocalization(i0__namespace.ɵɵinject(LocalePersistor), i0__namespace.ɵɵinject(LOC_LOCALE)); }, token: BaseLocalization, providedIn: "root" });
     BaseLocalization.decorators = [
-        { type: core.Injectable }
+        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    BaseLocalization.ctorParameters = function () { return [
+        { type: LocalePersistor },
+        { type: String, decorators: [{ type: i0.Inject, args: [LOC_LOCALE,] }] }
+    ]; };
+
+    // Angular
+    /**
+     * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
+     */
+    var LocDatePipe = /** @class */ (function () {
+        /**
+         * @ignore
+         */
+        function LocDatePipe(dts) {
+            this.dts = dts;
+        }
+        /**
+         * Trasformazione della data in input in base al formato richiesto
+         *
+         * @param {any} value Valore da ricondurre ad una data e formattare
+         * @param {string} format Formato in output della data da visualizzare
+         *
+         * @returns {string} Data formattata in base al formato
+         */
+        LocDatePipe.prototype.transform = function (value, format) {
+            if (format === void 0) { format = "DD/MM/YYYY"; }
+            if (value == null || value === "")
+                return null;
+            if (!this.dts) {
+                console.error("Tentativo di usare loc_date senza DateService. È possibile importare DateService installando e configurando il pacchetto @esfaenza/extensions");
+                return null;
+            }
+            var detatchedValue = JSON.parse(JSON.stringify(value));
+            var dt = this.dts.getDateConvertion(detatchedValue);
+            return dt.format(format);
+        };
+        return LocDatePipe;
+    }());
+    LocDatePipe.decorators = [
+        { type: i0.Pipe, args: [{ name: "loc_date", pure: true },] }
     ];
-    BaseLocalization.ctorParameters = function () { return []; };
+    LocDatePipe.ctorParameters = function () { return [
+        { type: extensions.DateService, decorators: [{ type: i0.Optional }] }
+    ]; };
+
+    /**
+     * Enum che rappresenta le policy di comportamento qualore il sistema di localizzazione non trovi la localizzazione cercata,
+     * usare **ThrowException** solo se ci si sente infallibili o si vuole debuggare in maniera approfondita l'applicazione
+     */
+    exports.LocalizationMissingPolicy = void 0;
+    (function (LocalizationMissingPolicy) {
+        LocalizationMissingPolicy[LocalizationMissingPolicy["PrintEmpty"] = 0] = "PrintEmpty";
+        LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSource"] = 1] = "PrintSource";
+        LocalizationMissingPolicy[LocalizationMissingPolicy["ThrowException"] = 2] = "ThrowException";
+    })(exports.LocalizationMissingPolicy || (exports.LocalizationMissingPolicy = {}));
 
     /**
      * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
@@ -287,17 +706,24 @@
         /**
          * Costruttore
          *
-         * @param {string} baseLoc Locale da utilizzare nel momento che questo servizio richiede le traduzioni
+         * @param {string} Locale Locale da utilizzare nel momento che questo servizio richiede le traduzioni
          * @param {baseLocalization} baseLocalization Classe base di localizzazione già fornita a livello di root dalla libreria stessa.
          * È sufficiente iniettarla nell'eventuale costruttore che estende questa classe e passarla as-is
          */
-        function LocalizationService(baseLoc, baseLocalization) {
-            this.baseLoc = baseLoc;
-            this.baseLocalization = baseLocalization;
+        function LocalizationService(injector) {
+            var _this = this;
+            this.injector = injector;
             /**
              * Cache di tutte le localizzazioni disonibili all'interno di questa classe
              */
             this.TranslationCache = {};
+            this.LocalePersistor = this.injector.get(LocalePersistor);
+            this.baseLocalization = this.injector.get(BaseLocalization);
+            this.onMissing = this.injector.get(LOC_MISSING_POLICY);
+            this.Persistor = new LocalizationPersistor(this.TranslationCache);
+            this.baseLocalization.Locale.subscribe(function (lr) {
+                _this.Locale = lr;
+            });
         }
         /**
          * Imposta la localizzazione di un token all'interno della **TranslationCache**
@@ -310,7 +736,7 @@
          * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
          */
         LocalizationService.prototype.setToken = function (direction, token, left, right) {
-            BaseLocalization.setToken(this.TranslationCache, direction, token, left, right);
+            this.Persistor.setToken(direction, token, left, right);
         };
         /**
          * Imposta la localizzazione di una frase all'interno della **TranslationCache**
@@ -322,7 +748,13 @@
          * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
          */
         LocalizationService.prototype.set = function (direction, left, right) {
-            BaseLocalization.set(this.TranslationCache, direction, left, right);
+            // Controlla di non reinserire la stessa localizzazione presente nel BaseLocalization
+            // i controlli per il non reinserimento della stessa localizzazione all'interno della stessa istanza è fatto lato Persistor
+            if (this.baseLocalization.Persistor.get(left, false)) {
+                console.warn("La localizzazione per " + left + " \u00E8 gi\u00E0 presente fra le localizzazioni base, ignoro l'operazione");
+                return;
+            }
+            this.Persistor.set(direction, left, right);
         };
         /**
          * Localizza un token
@@ -343,88 +775,60 @@
          * @returns {string} Frase localizzata
          */
         LocalizationService.prototype.loc = function (text, allowtokens) {
+            if (!this.Locale)
+                throw "Il sistema di localizzazione non ha ancora caricato il Locale, assicurarsi di caricare l'APP solo al retrieve del locale'";
             if (!text || text == "undefined")
                 return "";
-            // Questo può succedere solo se qualcuno crea questa service a manazza. In quel caso prendo la classe di default e basta
-            if (this.baseLocalization == null)
-                this.baseLocalization = new BaseLocalization();
             // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base
-            var item = BaseLocalization.findByText(this.TranslationCache, text, allowtokens) || BaseLocalization.findByText(this.baseLocalization.BaseTranslations, text, allowtokens);
+            var item = this.Persistor.get(text, allowtokens) || this.baseLocalization.Persistor.get(text, allowtokens);
             if (!item) {
-                console.error("Couldn't find localization for '" + text + "'");
-                return "";
+                var message = "Impossibile trovare la localizzazione per '" + text + "'";
+                switch (this.onMissing) {
+                    case exports.LocalizationMissingPolicy.PrintEmpty:
+                        console.error(message);
+                        return "";
+                    case exports.LocalizationMissingPolicy.PrintSource:
+                        console.warn(message);
+                        return text;
+                    case exports.LocalizationMissingPolicy.ThrowException:
+                        throw message;
+                }
             }
-            var loc = BaseLocalization.translationByCulture(item, this.baseLoc);
+            var loc = this.Persistor.translationByCulture(item, this.Locale);
             if (!loc) {
-                console.error("Couldn't find localization for '" + text + "', culture " + this.baseLoc);
+                console.error("Impossibile trovare la localizzazione per '" + text + "', culture " + this.Locale);
                 return "";
             }
             return loc.translation;
         };
-        /**
-         * Localizzazione per Severity classiche (E per errore, W per warning e I per info)
-         *
-         * @param {string} text Severity da tradurre
-         *
-         * @returns {string} Severity tradotta
-         */
-        LocalizationService.prototype.locSeverity = function (text) {
-            if (text == "E")
-                return this.loc("Error");
-            if (text == "W")
-                return this.loc("Warning");
-            if (text == "I")
-                return this.loc("Information");
-            return "";
+        LocalizationService.prototype.changeLocale = function (newLocale) {
+            return __awaiter(this, void 0, void 0, function () {
+                var locale;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.LocalePersistor.recover().toPromise()];
+                        case 1:
+                            locale = _a.sent();
+                            if (!(newLocale == locale)) return [3 /*break*/, 2];
+                            console.info("Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione");
+                            return [2 /*return*/];
+                        case 2: return [4 /*yield*/, this.LocalePersistor.persist(newLocale).toPromise()];
+                        case 3:
+                            _a.sent();
+                            location.reload();
+                            _a.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
         };
         return LocalizationService;
     }());
     LocalizationService.decorators = [
-        { type: core.Injectable }
+        { type: i0.Injectable }
     ];
     LocalizationService.ctorParameters = function () { return [
-        { type: String, decorators: [{ type: core.Inject, args: [LOC_LOCALE,] }] },
-        { type: BaseLocalization }
-    ]; };
-
-    // Angular
-    /**
-     * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
-     */
-    var LocDatePipe = /** @class */ (function () {
-        /**
-         * @ignore
-         */
-        function LocDatePipe(dts) {
-            this.dts = dts;
-        }
-        /**
-         * Trasformazione della data in input in base al formato richiesto
-         *
-         * @param {any} value Valore da ricondurre ad una data e formattare
-         * @param {string} format Formato in output della data da visualizzare
-         *
-         * @returns {string} Data formattata in base al formato
-         */
-        LocDatePipe.prototype.transform = function (value, format) {
-            if (format === void 0) { format = "DD/MM/YYYY"; }
-            if (value == null || value === "")
-                return null;
-            if (!this.dts) {
-                console.error("Tentativo di usare loc_date senza DateService. È possibile importare DateService installando e configurando il pacchetto @esfaenza/extensions");
-                return null;
-            }
-            var detatchedValue = JSON.parse(JSON.stringify(value));
-            var dt = this.dts.getDateConvertion(detatchedValue);
-            return dt.format(format);
-        };
-        return LocDatePipe;
-    }());
-    LocDatePipe.decorators = [
-        { type: core.Pipe, args: [{ name: "loc_date", pure: true },] }
-    ];
-    LocDatePipe.ctorParameters = function () { return [
-        { type: extensions.DateService, decorators: [{ type: core.Optional }] }
+        { type: i0.Injector }
     ]; };
 
     // Angular
@@ -458,12 +862,34 @@
         return LocalizePipe;
     }());
     LocalizePipe.decorators = [
-        { type: core.Pipe, args: [{ name: "localize", pure: true },] }
+        { type: i0.Pipe, args: [{ name: "localize", pure: true },] }
     ];
     LocalizePipe.ctorParameters = function () { return [
         { type: LocalizationService }
     ]; };
 
+    var LocalStorageLocalePersistor = /** @class */ (function (_super) {
+        __extends(LocalStorageLocalePersistor, _super);
+        function LocalStorageLocalePersistor() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        /** @ignore Vedi classe base */
+        LocalStorageLocalePersistor.prototype.persist = function (locale) {
+            localStorage.setItem(this.LOCALE, locale);
+            return rxjs.of(true).pipe(operators.first());
+        };
+        /** @ignore Vedi classe base */
+        LocalStorageLocalePersistor.prototype.recover = function () {
+            var ret = localStorage.getItem(this.LOCALE);
+            return rxjs.of(ret).pipe(operators.first());
+        };
+        return LocalStorageLocalePersistor;
+    }(LocalePersistor));
+    LocalStorageLocalePersistor.decorators = [
+        { type: i0.Injectable }
+    ];
+
+    // Angular
     var LocalizationModule = /** @class */ (function () {
         function LocalizationModule() {
         }
@@ -473,19 +899,30 @@
                 providers: [
                     LocalizationService,
                     BaseLocalization,
-                    { provide: LOC_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.locale) || 'it-IT' }
+                    { provide: LOC_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.defaultLocale) || 'it-IT' },
+                    { provide: LOC_MISSING_POLICY, useValue: (config === null || config === void 0 ? void 0 : config.localizationMissingPolicy) || exports.LocalizationMissingPolicy.PrintEmpty },
+                    { provide: LocalePersistor, useClass: (config === null || config === void 0 ? void 0 : config.localePersistor) || LocalStorageLocalePersistor },
                 ]
             };
         };
         return LocalizationModule;
     }());
     LocalizationModule.decorators = [
-        { type: core.NgModule, args: [{
+        { type: i0.NgModule, args: [{
                     declarations: [LocalizePipe, LocDatePipe],
                     exports: [LocalizePipe, LocDatePipe]
                 },] }
     ];
 
+    /**
+     * Classe di configurazione per il modulo di localizzazione
+     */
+    var LocalizationModuleConfig = /** @class */ (function () {
+        function LocalizationModuleConfig() {
+        }
+        return LocalizationModuleConfig;
+    }());
+
     /*
      * Public API Surface of localizations
      */
@@ -494,13 +931,16 @@
      * Generated bundle index. Do not edit.
      */
 
+    exports.BaseLocalization = BaseLocalization;
     exports.LOC_LOCALE = LOC_LOCALE;
+    exports.LOC_MISSING_POLICY = LOC_MISSING_POLICY;
     exports.LocDatePipe = LocDatePipe;
     exports.LocalizationModule = LocalizationModule;
     exports.LocalizationModuleConfig = LocalizationModuleConfig;
     exports.LocalizationService = LocalizationService;
     exports.LocalizePipe = LocalizePipe;
-    exports.ɵa = BaseLocalization;
+    exports.ɵa = LocalePersistor;
+    exports.ɵb = LocalStorageLocalePersistor;
 
     Object.defineProperty(exports, '__esModule', { value: true });