@esfaenza/localizations 16.2.29 → 17.3.0

package/fesm2022/esfaenza-localizations.mjs

@@ -1,530 +1,530 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Injector, Pipe, NgModule } from '@angular/core';
+import { InjectionToken, Inject, Injectable, Injector, Pipe, NgModule } from '@angular/core';
 import { take, first } from 'rxjs/operators';
 import { ReplaySubject, of } from 'rxjs';
 
-/**
- * Contenitore delle localizzazioni collegate ad un testo "base", una per ogni linguaggio supportato
- */
-class ItemLocalization {
-    /**
-     * Costruttore
-     *
-     * @param {boolean} token Indica se è un token o se è un testo
-     * @param {string} baseText Testo base che verrà richiesto quando verrà cercata la localizzazione
-     * @param {SpecializedLocalization[]} translations Lista di traduzioni in base al testo base
-     */
-    constructor(token, baseText, translations) {
-        this.token = token;
-        this.baseText = baseText;
-        this.translations = translations;
-    }
+/**
+ * Contenitore delle localizzazioni collegate ad un testo "base", una per ogni linguaggio supportato
+ */
+class ItemLocalization {
+    /**
+     * Costruttore
+     *
+     * @param {boolean} token Indica se è un token o se è un testo
+     * @param {string} baseText Testo base che verrà richiesto quando verrà cercata la localizzazione
+     * @param {SpecializedLocalization[]} translations Lista di traduzioni in base al testo base
+     */
+    constructor(token, baseText, translations) {
+        this.token = token;
+        this.baseText = baseText;
+        this.translations = translations;
+    }
 }
 
-/**
- * Classe che rappresenta un locale (Es. 'Italiano') con i propri alias (Es. 'it' oppure 'it-IT')
- */
-class LocaleObject {
-    /**
-     * Costruttore
-     *
-     * @param {string} id Codice locale
-     * @param {string} description Descrizione locale
-     * @param {string[]} aliases Alias con cui quel locale è conosciuto
-     * @param {string} smallVersion Versione standard "small" del locale. Es. "it-IT" -> "it"
-     */
-    constructor(id, description, aliases, smallVersion) {
-        this.id = id;
-        this.description = description;
-        this.aliases = aliases;
-        this.smallVersion = smallVersion;
-    }
+/**
+ * Classe che rappresenta un locale (Es. 'Italiano') con i propri alias (Es. 'it' oppure 'it-IT')
+ */
+class LocaleObject {
+    /**
+     * Costruttore
+     *
+     * @param {string} id Codice locale
+     * @param {string} description Descrizione locale
+     * @param {string[]} aliases Alias con cui quel locale è conosciuto
+     * @param {string} smallVersion Versione standard "small" del locale. Es. "it-IT" -> "it"
+     */
+    constructor(id, description, aliases, smallVersion) {
+        this.id = id;
+        this.description = description;
+        this.aliases = aliases;
+        this.smallVersion = smallVersion;
+    }
 }
 
-/** Classe che gestisce le definizioni dei locali disponibili */
-class LocaleDefinitions {
-    /** Cache per ottimizzare la chiamata **getByAlias** */
-    static { this.LocaleCache = {}; }
-    /** @ignore Costruttore */
-    constructor() { }
-    /** Lista dei locali disponibili, definiti anche con i vari alias */
-    static { this.AvailableLocales = [
-        new LocaleObject('it-IT', 'Italiano', ['it', 'it-IT'], "it"),
-        new LocaleObject('en-US', 'English', ['en', 'en-US'], "en")
-    ]; }
-    /**
-     * In base a un alias restituisce il locale rappresentato
-     *
-     * @param {string} alias Alias in base al quale raccogliere il Locale
-     *
-     * @returns {LocaleObject} Locale richiesto dall'alias
-     */
-    static getByAlias(alias) {
-        if (!this.LocaleCache[alias])
-            this.LocaleCache[alias] = this.AvailableLocales.find(t => !!t.aliases.find(a => a == alias));
-        return this.LocaleCache[alias];
-    }
+/** Classe che gestisce le definizioni dei locali disponibili */
+class LocaleDefinitions {
+    /** Cache per ottimizzare la chiamata **getByAlias** */
+    static { this.LocaleCache = {}; }
+    /** @ignore Costruttore */
+    constructor() { }
+    /** Lista dei locali disponibili, definiti anche con i vari alias */
+    static { this.AvailableLocales = [
+        new LocaleObject('it-IT', 'Italiano', ['it', 'it-IT'], "it"),
+        new LocaleObject('en-US', 'English', ['en', 'en-US'], "en")
+    ]; }
+    /**
+     * In base a un alias restituisce il locale rappresentato
+     *
+     * @param {string} alias Alias in base al quale raccogliere il Locale
+     *
+     * @returns {LocaleObject} Locale richiesto dall'alias
+     */
+    static getByAlias(alias) {
+        if (!this.LocaleCache[alias])
+            this.LocaleCache[alias] = this.AvailableLocales.find(t => !!t.aliases.find(a => a == alias));
+        return this.LocaleCache[alias];
+    }
 }
 
-/**
- * Classe che rappresenta la localizzazione di un test base per una certa lingua
- */
-class SpecializedLocalization {
-    /**
-     * Costruttore
-     *
-     * @param {string} culture Culture della traduzione
-     * @param {string} translation Traduzione nella lingua specificata dalla **culture**
-     */
-    constructor(culture, translation) {
-        this.culture = culture;
-        this.translation = translation;
-    }
+/**
+ * Classe che rappresenta la localizzazione di un test base per una certa lingua
+ */
+class SpecializedLocalization {
+    /**
+     * Costruttore
+     *
+     * @param {string} culture Culture della traduzione
+     * @param {string} translation Traduzione nella lingua specificata dalla **culture**
+     */
+    constructor(culture, translation) {
+        this.culture = culture;
+        this.translation = translation;
+    }
 }
 
-class LocalizationPersistor {
-    constructor(LocCache = null) {
-        this.LocCache = LocCache;
-    }
-    /**
-     * Imposta la localizzazione di un token all'interno della cache scelta
-     *
-     * @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} token Nome del token
-     * @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**
-     */
-    setToken(direction, token, left, right) {
-        let parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
-        var parsingRes = parsingRegex.exec(direction);
-        let from = parsingRes[1];
-        let to = parsingRes[2].replace(/\s/g, '').split(',');
-        let localeFrom = LocaleDefinitions.getByAlias(from);
-        this._set(token, localeFrom.id, left, true);
-        to.forEach((t, index) => {
-            let localeTo = LocaleDefinitions.getByAlias(t);
-            this._set(token, localeTo.id, right[index], true);
-        });
-    }
-    /**
-     * Imposta la localizzazione di una frase all'interno della cache scelta
-     *
-     * @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**
-     */
-    set(direction, left, right) {
-        let parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
-        var parsingRes = parsingRegex.exec(direction);
-        let from = parsingRes[1];
-        let to = parsingRes[2].replace(/\s/g, '').split(',');
-        let localeFrom = LocaleDefinitions.getByAlias(from);
-        this._set(left, localeFrom.id, left);
-        to.forEach((t, index) => {
-            let localeTo = LocaleDefinitions.getByAlias(t);
-            this._set(left, localeTo.id, right[index]);
-        });
-    }
-    /**
-     * Imposta all'interno della cache specificata un'unica traduzione partendo da un testo di base
-     *
-     * @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
-     */
-    _set(text, culture, translation, token) {
-        let item = this.get(text, token);
-        if (!item) {
-            this.LocCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
-            return;
-        }
-        var trs = this.translationByCulture(item, culture);
-        if (trs) {
-            console.warn("Localization already loaded for sentence '" + text + "' and culture " + culture);
-            return;
-        }
-        item.translations.push(new SpecializedLocalization(culture, translation));
-    }
-    /**
-     * Partendo da una cache di localizzazione, dato un testo che può essere o meno un token, cerca quell'elemento all'interno della cache
-     *
-     * @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
-     */
-    get(text, allowtokens) {
-        let possibleItem = this.LocCache[text];
-        var item = possibleItem && (allowtokens || !possibleItem.token) ? possibleItem : null;
-        return item;
-    }
-    /**
-     * Date le informazioni di localizzazione per un testo cerca e restituisce la traduzione per una lingua specifica
-     *
-     * @param {ItemLocalization} Informazioni di localizzazione
-     * @param {string} culture Lingua della traduzione richiesta
-     *
-     * @returns {SpecializedLocalization} Informazioni di localizzazione specifiche della lingua richiesta
-     */
-    translationByCulture(item, culture) {
-        for (let i = 0; i < item.translations.length; i++) {
-            let trl = item.translations[i];
-            if (trl.culture == culture)
-                return trl;
-        }
-        return null;
-    }
+class LocalizationPersistor {
+    constructor(LocCache = null) {
+        this.LocCache = LocCache;
+    }
+    /**
+     * Imposta la localizzazione di un token all'interno della cache scelta
+     *
+     * @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} token Nome del token
+     * @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**
+     */
+    setToken(direction, token, left, right) {
+        let parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
+        var parsingRes = parsingRegex.exec(direction);
+        let from = parsingRes[1];
+        let to = parsingRes[2].replace(/\s/g, '').split(',');
+        let localeFrom = LocaleDefinitions.getByAlias(from);
+        this._set(token, localeFrom.id, left, true);
+        to.forEach((t, index) => {
+            let localeTo = LocaleDefinitions.getByAlias(t);
+            this._set(token, localeTo.id, right[index], true);
+        });
+    }
+    /**
+     * Imposta la localizzazione di una frase all'interno della cache scelta
+     *
+     * @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**
+     */
+    set(direction, left, right) {
+        let parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
+        var parsingRes = parsingRegex.exec(direction);
+        let from = parsingRes[1];
+        let to = parsingRes[2].replace(/\s/g, '').split(',');
+        let localeFrom = LocaleDefinitions.getByAlias(from);
+        this._set(left, localeFrom.id, left);
+        to.forEach((t, index) => {
+            let localeTo = LocaleDefinitions.getByAlias(t);
+            this._set(left, localeTo.id, right[index]);
+        });
+    }
+    /**
+     * Imposta all'interno della cache specificata un'unica traduzione partendo da un testo di base
+     *
+     * @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
+     */
+    _set(text, culture, translation, token) {
+        let item = this.get(text, token);
+        if (!item) {
+            this.LocCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
+            return;
+        }
+        var trs = this.translationByCulture(item, culture);
+        if (trs) {
+            console.warn("Localization already loaded for sentence '" + text + "' and culture " + culture);
+            return;
+        }
+        item.translations.push(new SpecializedLocalization(culture, translation));
+    }
+    /**
+     * Partendo da una cache di localizzazione, dato un testo che può essere o meno un token, cerca quell'elemento all'interno della cache
+     *
+     * @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
+     */
+    get(text, allowtokens) {
+        let possibleItem = this.LocCache[text];
+        var item = possibleItem && (allowtokens || !possibleItem.token) ? possibleItem : null;
+        return item;
+    }
+    /**
+     * Date le informazioni di localizzazione per un testo cerca e restituisce la traduzione per una lingua specifica
+     *
+     * @param {ItemLocalization} Informazioni di localizzazione
+     * @param {string} culture Lingua della traduzione richiesta
+     *
+     * @returns {SpecializedLocalization} Informazioni di localizzazione specifiche della lingua richiesta
+     */
+    translationByCulture(item, culture) {
+        for (let i = 0; i < item.translations.length; i++) {
+            let trl = item.translations[i];
+            if (trl.culture == culture)
+                return trl;
+        }
+        return null;
+    }
 }
 
-var BaseLocalizationTokens;
-(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";
+var BaseLocalizationTokens;
+(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";
 })(BaseLocalizationTokens || (BaseLocalizationTokens = {}));
 
-/** Locale da utilizzare per le traduzioni */
-const LOC_LOCALE = new InjectionToken('LOC_LOCALE');
-/** Policy da utilizzare per traduzioni mancanti */
-const LOC_MISSING_POLICY = new InjectionToken('LOC_MISSING_POLICY');
-/** Modalità di Debug */
+/** Locale da utilizzare per le traduzioni */
+const LOC_LOCALE = new InjectionToken('LOC_LOCALE');
+/** Policy da utilizzare per traduzioni mancanti */
+const LOC_MISSING_POLICY = new InjectionToken('LOC_MISSING_POLICY');
+/** Modalità di Debug */
 const LOC_DEBUG_MODE = new InjectionToken('LOC_DEBUG_MODE');
 
-/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
-class LocalePersistor {
-    constructor() {
-        /** Chiave su cui salvare il locale */
-        this.LOCALE = "LOCALE";
-    }
+/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+class LocalePersistor {
+    constructor() {
+        /** Chiave su cui salvare il locale */
+        this.LOCALE = "LOCALE";
+    }
 }
 
-/**
- * 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
- */
-class BaseLocalization {
-    /**
-     * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
-     */
-    constructor(LocalePersistor, defaultLocale) {
-        this.LocalePersistor = LocalePersistor;
-        /**
-         * Cache di tutte le localizzazioni di base
-         */
-        this.LocCache = {};
-        /**
-         * Locale di riferimento per tutte le traduzioni
-         */
-        this.Locale = new ReplaySubject(1);
-        // Recupero il locale alla partenza del BaseLocalization in modo, spero di dare tempo all'applicazione di tirarlo su
-        this.LocalePersistor.recover().pipe(take(1)).subscribe(async (l) => {
-            if (!l) {
-                l = defaultLocale;
-                this.LocalePersistor.persist(defaultLocale);
-            }
-            this.Locale.next(l);
-        });
-        this.Persistor = new LocalizationPersistor(this.LocCache);
-        this.Persistor.set("it->en", "Sì", ["Yes"]);
-        this.Persistor.set("it->en", "No", ["No"]);
-        this.Persistor.set("it->en", "Errore", ["Error"]);
-        this.Persistor.set("it->en", "Avviso", ["Warning"]);
-        this.Persistor.set("it->en", "Informazione", ["Information"]);
-        this.Persistor.set("it->en", "Salva", ["Save"]);
-        this.Persistor.set("it->en", "Indietro", ["Back"]);
-        this.Persistor.set("it->en", "Da", ["From"]);
-        this.Persistor.set("it->en", "A", ["To"]);
-        this.Persistor.set("it->en", "Note", ["Notes"]);
-        this.Persistor.set("it->en", "Modifica Note", ["Edit Notes"]);
-        this.Persistor.set("it->en", "Annulla", ["Cancel"]);
-        this.Persistor.set("it->en", "Conferma", ["Confirm"]);
-        this.Persistor.set("it->en", "Visualizza", ["View"]);
-        this.Persistor.set("it->en", "Elimina", ["Delete"]);
-        this.Persistor.set("it->en", "Chiudi", ["Close"]);
-        this.Persistor.set("it->en", "Seleziona", ["Select"]);
-        this.Persistor.set("it->en", "Elettricità", ["Electricity"]);
-        this.Persistor.set("it->en", "Gas", ["Gas"]);
-        this.Persistor.set("it->en", "Acqua", ["Water"]);
-        this.Persistor.set("it->en", "Questa operazione non può essere annullata", ["This operation cannot be reverted"]);
-        this.Persistor.set("it->en", "Nascondi", ["Hide"]);
-        // Informazioni sulle date
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDateMonthPosition, "0", ["1"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDisplayDateMonthPosition, "1", ["1"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getLocale, "en-US", ["it-IT"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getSmallDateFormat, "MM/DD/YYYY", ["DD/MM/YYYY"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDefaultDateFormat, "MM/DD/YYYY", ["MM/DD/YYYY"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getSmallDateDisplayFormat, "DD/MM/YYYY", ["DD/MM/YYYY"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateFormat, "MM/DD/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateDisplayFormat, "DD/MM/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateFormatNoSeconds, "MM/DD/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
-        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateDisplayFormatNoSeconds, "DD/MM/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseLocalization, deps: [{ token: LocalePersistor }, { token: LOC_LOCALE }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseLocalization, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseLocalization, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: LocalePersistor }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [LOC_LOCALE]
-                }] }]; } });
+/**
+ * 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
+ */
+class BaseLocalization {
+    /**
+     * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
+     */
+    constructor(LocalePersistor, defaultLocale) {
+        this.LocalePersistor = LocalePersistor;
+        /**
+         * Cache di tutte le localizzazioni di base
+         */
+        this.LocCache = {};
+        /**
+         * Locale di riferimento per tutte le traduzioni
+         */
+        this.Locale = new ReplaySubject(1);
+        // Recupero il locale alla partenza del BaseLocalization in modo, spero di dare tempo all'applicazione di tirarlo su
+        this.LocalePersistor.recover().pipe(take(1)).subscribe(async (l) => {
+            if (!l) {
+                l = defaultLocale;
+                this.LocalePersistor.persist(defaultLocale);
+            }
+            this.Locale.next(l);
+        });
+        this.Persistor = new LocalizationPersistor(this.LocCache);
+        this.Persistor.set("it->en", "Sì", ["Yes"]);
+        this.Persistor.set("it->en", "No", ["No"]);
+        this.Persistor.set("it->en", "Errore", ["Error"]);
+        this.Persistor.set("it->en", "Avviso", ["Warning"]);
+        this.Persistor.set("it->en", "Informazione", ["Information"]);
+        this.Persistor.set("it->en", "Salva", ["Save"]);
+        this.Persistor.set("it->en", "Indietro", ["Back"]);
+        this.Persistor.set("it->en", "Da", ["From"]);
+        this.Persistor.set("it->en", "A", ["To"]);
+        this.Persistor.set("it->en", "Note", ["Notes"]);
+        this.Persistor.set("it->en", "Modifica Note", ["Edit Notes"]);
+        this.Persistor.set("it->en", "Annulla", ["Cancel"]);
+        this.Persistor.set("it->en", "Conferma", ["Confirm"]);
+        this.Persistor.set("it->en", "Visualizza", ["View"]);
+        this.Persistor.set("it->en", "Elimina", ["Delete"]);
+        this.Persistor.set("it->en", "Chiudi", ["Close"]);
+        this.Persistor.set("it->en", "Seleziona", ["Select"]);
+        this.Persistor.set("it->en", "Elettricità", ["Electricity"]);
+        this.Persistor.set("it->en", "Gas", ["Gas"]);
+        this.Persistor.set("it->en", "Acqua", ["Water"]);
+        this.Persistor.set("it->en", "Questa operazione non può essere annullata", ["This operation cannot be reverted"]);
+        this.Persistor.set("it->en", "Nascondi", ["Hide"]);
+        // Informazioni sulle date
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDateMonthPosition, "0", ["1"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDisplayDateMonthPosition, "1", ["1"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getLocale, "en-US", ["it-IT"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getSmallDateFormat, "MM/DD/YYYY", ["DD/MM/YYYY"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDefaultDateFormat, "MM/DD/YYYY", ["MM/DD/YYYY"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getSmallDateDisplayFormat, "DD/MM/YYYY", ["DD/MM/YYYY"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateFormat, "MM/DD/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateDisplayFormat, "DD/MM/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateFormatNoSeconds, "MM/DD/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateDisplayFormatNoSeconds, "DD/MM/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseLocalization, deps: [{ token: LocalePersistor }, { token: LOC_LOCALE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseLocalization, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseLocalization, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: LocalePersistor }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOC_LOCALE]
+                }] }] });
 
-/**
- * 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
- */
-var LocalizationMissingPolicy;
-(function (LocalizationMissingPolicy) {
-    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintEmpty"] = 0] = "PrintEmpty";
-    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSource"] = 1] = "PrintSource";
-    LocalizationMissingPolicy[LocalizationMissingPolicy["ThrowException"] = 2] = "ThrowException";
+/**
+ * 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
+ */
+var LocalizationMissingPolicy;
+(function (LocalizationMissingPolicy) {
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintEmpty"] = 0] = "PrintEmpty";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSource"] = 1] = "PrintSource";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["ThrowException"] = 2] = "ThrowException";
 })(LocalizationMissingPolicy || (LocalizationMissingPolicy = {}));
 
-/**
- * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
- */
-class LocalizationService {
-    /**
-     * Costruttore
-     *
-     * @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
-     */
-    constructor(injector) {
-        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(lr => {
-            this.Locale = lr;
-            this.SmallLocale = LocaleDefinitions.getByAlias(lr).smallVersion;
-        });
-    }
-    /**
-     * Genera un nuovo servizio di localizzazione data una classe in modo che le localizzazioni non siano più solo da provide-are a livello di componente, ma possano
-     * anche essere create al volo dal componente/servizio/qualsiasicosa che le deve utilizzare
-     *
-     * @param {Type<LocalizationService>} lcst Classe da usare per crare il nuovo servizio di localizzazione
-     */
-    generateFromType(lcst) {
-        const injector = Injector.create({
-            providers: [
-                { provide: LOC_MISSING_POLICY, useValue: this.onMissing },
-                { provide: BaseLocalization, useValue: this.baseLocalization },
-                { provide: LocalePersistor, useValue: this.LocalePersistor },
-                { provide: LocalizationService, useClass: lcst }
-            ]
-        });
-        return injector.get(LocalizationService);
-    }
-    /**
-     * Imposta la localizzazione di un token all'interno della **TranslationCache**
-     *
-     * @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} token Nome del token
-     * @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**
-     */
-    setToken(direction, token, left, right) {
-        this.Persistor.setToken(direction, token, left, right);
-    }
-    /**
-     * Imposta la localizzazione di una frase all'interno della **TranslationCache**
-     *
-     * @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**
-     */
-    set(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} è già presente fra le localizzazioni base, ignoro l'operazione`);
-            return;
-        }
-        this.Persistor.set(direction, left, right);
-    }
-    /**
-     * Localizza un token
-     *
-     * @param {string} text Il token da localizzare
-     *
-     * @returns {string} Token localizzato
-     */
-    token(text) {
-        return this.loc(text, true);
-    }
-    /**
-     * Localizza una frase
-     *
-     * @param {string} text Frase da localizzare
-     * @param {boolean} allowtokens Indica se la frase **text** potrebbe essere un token o no
-     *
-     * @returns {string} Frase localizzata
-     */
-    loc(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 "";
-        // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base
-        var item = this.Persistor.get(text, allowtokens) || this.baseLocalization.Persistor.get(text, allowtokens);
-        if (!item) {
-            let message = `Impossibile trovare la localizzazione per '${text}'`;
-            switch (this.onMissing) {
-                case LocalizationMissingPolicy.PrintEmpty:
-                    console.error(message);
-                    return "";
-                case LocalizationMissingPolicy.PrintSource:
-                    console.warn(message);
-                    return text;
-                case LocalizationMissingPolicy.ThrowException:
-                    throw message;
-            }
-        }
-        var loc = this.Persistor.translationByCulture(item, this.Locale);
-        if (!loc) {
-            console.error("Impossibile trovare la localizzazione per '" + text + "', culture " + this.Locale);
-            return "";
-        }
-        return loc.translation;
-    }
-    async changeLocale(newLocale) {
-        let locale = await this.LocalePersistor.recover().toPromise();
-        if (newLocale == locale) {
-            console.info("Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione");
-            return;
-        }
-        else {
-            await this.LocalePersistor.persist(newLocale).toPromise();
-            location.reload();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizationService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizationService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+/**
+ * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
+ */
+class LocalizationService {
+    /**
+     * Costruttore
+     *
+     * @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
+     */
+    constructor(injector) {
+        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(lr => {
+            this.Locale = lr;
+            this.SmallLocale = LocaleDefinitions.getByAlias(lr).smallVersion;
+        });
+    }
+    /**
+     * Genera un nuovo servizio di localizzazione data una classe in modo che le localizzazioni non siano più solo da provide-are a livello di componente, ma possano
+     * anche essere create al volo dal componente/servizio/qualsiasicosa che le deve utilizzare
+     *
+     * @param {Type<LocalizationService>} lcst Classe da usare per crare il nuovo servizio di localizzazione
+     */
+    generateFromType(lcst) {
+        const injector = Injector.create({
+            providers: [
+                { provide: LOC_MISSING_POLICY, useValue: this.onMissing },
+                { provide: BaseLocalization, useValue: this.baseLocalization },
+                { provide: LocalePersistor, useValue: this.LocalePersistor },
+                { provide: LocalizationService, useClass: lcst }
+            ]
+        });
+        return injector.get(LocalizationService);
+    }
+    /**
+     * Imposta la localizzazione di un token all'interno della **TranslationCache**
+     *
+     * @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} token Nome del token
+     * @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**
+     */
+    setToken(direction, token, left, right) {
+        this.Persistor.setToken(direction, token, left, right);
+    }
+    /**
+     * Imposta la localizzazione di una frase all'interno della **TranslationCache**
+     *
+     * @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**
+     */
+    set(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} è già presente fra le localizzazioni base, ignoro l'operazione`);
+            return;
+        }
+        this.Persistor.set(direction, left, right);
+    }
+    /**
+     * Localizza un token
+     *
+     * @param {string} text Il token da localizzare
+     *
+     * @returns {string} Token localizzato
+     */
+    token(text) {
+        return this.loc(text, true);
+    }
+    /**
+     * Localizza una frase
+     *
+     * @param {string} text Frase da localizzare
+     * @param {boolean} allowtokens Indica se la frase **text** potrebbe essere un token o no
+     *
+     * @returns {string} Frase localizzata
+     */
+    loc(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 "";
+        // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base
+        var item = this.Persistor.get(text, allowtokens) || this.baseLocalization.Persistor.get(text, allowtokens);
+        if (!item) {
+            let message = `Impossibile trovare la localizzazione per '${text}'`;
+            switch (this.onMissing) {
+                case LocalizationMissingPolicy.PrintEmpty:
+                    console.error(message);
+                    return "";
+                case LocalizationMissingPolicy.PrintSource:
+                    console.warn(message);
+                    return text;
+                case LocalizationMissingPolicy.ThrowException:
+                    throw message;
+            }
+        }
+        var loc = this.Persistor.translationByCulture(item, this.Locale);
+        if (!loc) {
+            console.error("Impossibile trovare la localizzazione per '" + text + "', culture " + this.Locale);
+            return "";
+        }
+        return loc.translation;
+    }
+    async changeLocale(newLocale) {
+        let locale = await this.LocalePersistor.recover().toPromise();
+        if (newLocale == locale) {
+            console.info("Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione");
+            return;
+        }
+        else {
+            await this.LocalePersistor.persist(newLocale).toPromise();
+            location.reload();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
 
-// Angular
-/**
- * Pipe di localizzazione per tradurre direttamente da template
- */
-class LocalizePipe {
-    /**
-     * Costruttore
-     *
-     * @param {LocalizationService} translationContainer Container delle traduzioni disponibili nel contesto in cui viene usata la pipe.
-     *
-     * Viene iniettata dal provider dichiarato nel singolo componente che utilizza la traduzione e, se non esiste, viene iniettato dal default
-     */
-    constructor(translationContainer) {
-        this.translationContainer = translationContainer;
-    }
-    /**
-     * Trasformazione della stringa in input ad una stringa tradotta
-     *
-     * @param {string} value Testo da tradurre
-     * @param {LocalizationService} locContainerOverride Override al contenitore della traduzione iniettato dal costruttore, qualora serva
-     *
-     * @returns {string} Frase tradotta
-     */
-    transform(value, locContainerOverride) {
-        if (value == null || value === "")
-            return "";
-        return (locContainerOverride || this.translationContainer).loc(value);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: LocalizePipe, name: "localize" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizePipe, decorators: [{
-            type: Pipe,
-            args: [{ name: "localize", pure: true }]
-        }], ctorParameters: function () { return [{ type: LocalizationService }]; } });
+// Angular
+/**
+ * Pipe di localizzazione per tradurre direttamente da template
+ */
+class LocalizePipe {
+    /**
+     * Costruttore
+     *
+     * @param {LocalizationService} translationContainer Container delle traduzioni disponibili nel contesto in cui viene usata la pipe.
+     *
+     * Viene iniettata dal provider dichiarato nel singolo componente che utilizza la traduzione e, se non esiste, viene iniettato dal default
+     */
+    constructor(translationContainer) {
+        this.translationContainer = translationContainer;
+    }
+    /**
+     * Trasformazione della stringa in input ad una stringa tradotta
+     *
+     * @param {string} value Testo da tradurre
+     * @param {LocalizationService} locContainerOverride Override al contenitore della traduzione iniettato dal costruttore, qualora serva
+     *
+     * @returns {string} Frase tradotta
+     */
+    transform(value, locContainerOverride) {
+        if (value == null || value === "")
+            return "";
+        return (locContainerOverride || this.translationContainer).loc(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocalizePipe, name: "localize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: "localize", pure: true }]
+        }], ctorParameters: () => [{ type: LocalizationService }] });
 
-// Angular
-class LocalStorageLocalePersistor extends LocalePersistor {
-    /** @ignore Vedi classe base */
-    persist(locale) {
-        localStorage.setItem(this.LOCALE, locale);
-        return of(true).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    recover() {
-        var ret = localStorage.getItem(this.LOCALE);
-        return of(ret).pipe(first());
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageLocalePersistor, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageLocalePersistor }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageLocalePersistor, decorators: [{
-            type: Injectable
+// Angular
+class LocalStorageLocalePersistor extends LocalePersistor {
+    /** @ignore Vedi classe base */
+    persist(locale) {
+        localStorage.setItem(this.LOCALE, locale);
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recover() {
+        var ret = localStorage.getItem(this.LOCALE);
+        return of(ret).pipe(first());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageLocalePersistor, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageLocalePersistor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageLocalePersistor, decorators: [{
+            type: Injectable
         }] });
 
-// Angular
-class LocalizationModule {
-    static forRoot(config) {
-        return {
-            ngModule: LocalizationModule,
-            providers: [
-                LocalizationService,
-                BaseLocalization,
-                { provide: LOC_LOCALE, useValue: config?.defaultLocale || 'it-IT' },
-                { provide: LOC_MISSING_POLICY, useValue: config?.localizationMissingPolicy || LocalizationMissingPolicy.PrintEmpty },
-                { provide: LocalePersistor, useClass: config?.localePersistor || LocalStorageLocalePersistor },
-                { provide: LOC_DEBUG_MODE, useValue: config?.debugMode || false },
-            ]
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: LocalizationModule, declarations: [LocalizePipe], exports: [LocalizePipe] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizationModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalizationModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [LocalizePipe],
-                    exports: [LocalizePipe]
-                }]
+// Angular
+class LocalizationModule {
+    static forRoot(config) {
+        return {
+            ngModule: LocalizationModule,
+            providers: [
+                LocalizationService,
+                BaseLocalization,
+                { provide: LOC_LOCALE, useValue: config?.defaultLocale || 'it-IT' },
+                { provide: LOC_MISSING_POLICY, useValue: config?.localizationMissingPolicy || LocalizationMissingPolicy.PrintEmpty },
+                { provide: LocalePersistor, useClass: config?.localePersistor || LocalStorageLocalePersistor },
+                { provide: LOC_DEBUG_MODE, useValue: config?.debugMode || false },
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocalizationModule, declarations: [LocalizePipe], exports: [LocalizePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LocalizePipe],
+                    exports: [LocalizePipe]
+                }]
         }] });
 
-/**
- * Classe di configurazione per il modulo di localizzazione
- */
-class LocalizationModuleConfig {
+/**
+ * Classe di configurazione per il modulo di localizzazione
+ */
+class LocalizationModuleConfig {
 }
 
-/*
- * Public API Surface of localizations
+/*
+ * Public API Surface of localizations
  */
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { BaseLocalization, BaseLocalizationTokens, LOC_DEBUG_MODE, LOC_LOCALE, LOC_MISSING_POLICY, LocalizationMissingPolicy, LocalizationModule, LocalizationModuleConfig, LocalizationService, LocalizePipe };