@ngx-pwa/local-storage 17.0.0 → 18.0.0

package/fesm2022/ngx-pwa-local-storage.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, makeEnvironmentProviders, NgModule, inject, Injectable, PLATFORM_ID } from '@angular/core';
-import { ReplaySubject, fromEvent, race, throwError, of, asyncScheduler, Observable, from } from 'rxjs';
-import { map, mergeMap, first, takeWhile, tap, observeOn, catchError } from 'rxjs/operators';
+import { of, throwError, Observable, asyncScheduler, from, ReplaySubject, fromEvent, race } from 'rxjs';
+import { observeOn, mergeMap, map, first, takeWhile, tap, catchError } from 'rxjs/operators';
 import { isPlatformBrowser } from '@angular/common';
 
 /**
@@ -18,12 +18,12 @@ class IDBBrokenError extends Error {
     }
 }
 /**
- * Exception message when a value can't be serialized for `localStorage`
+ * Exception message when a value cannot be serialized for `localStorage`
  */
 const SERIALIZATION_ERROR = `The storage is currently localStorage,
 where data must be serialized, and the provided data can't be serialized.`;
 /**
- * Exception raised when a value can't be serialized for `localStorage`
+ * Exception throwned when a value cannot be serialized for `localStorage`
  */
 class SerializationError extends Error {
     constructor() {
@@ -92,26 +92,30 @@ const IDB_NO_WRAP = new InjectionToken("localStorageIDBWrap", {
 
 /**
  * Allows to add a prefix before `localStorage` keys.
- * *Use only* for interoperability with other APIs or to avoid collision for multiple apps on the same subdomain.
- * **WARNING: do not change this option in an app already deployed in production, as previously stored data would be lost.**
+ *
+ * *Use only* for interoperability with other APIs or to avoid collision for multiple applications on the same subdomain.
+ *
+ * **WARNING: do not change this option in an application already deployed in production, as previously stored data would be lost.**
  *
  * @example
- * bootstrapApplication(AppComponent, {
+ * export const appConfig: ApplicationConfig = {
  *   providers: [provideLocalStoragePrefix('custom_')]
- * });
+ * };
  */
 function provideLocalStoragePrefix(prefix) {
     return makeEnvironmentProviders([{ provide: LS_PREFIX, useValue: prefix }]);
 }
 /**
  * Allows to change the name used for `indexedDB` database.
- * *Use only* for interoperability with other APIs or to avoid collision for multiple apps on the same subdomain.
- * **WARNING: do not change this option in an app already deployed in production, as previously stored data would be lost.**
+ *
+ * *Use only* for interoperability with other APIs or to avoid collision for multiple applications on the same subdomain.
+ *
+ * **WARNING: do not change this option in an application already deployed in production, as previously stored data would be lost.**
  *
  * @example
- * bootstrapApplication(AppComponent, {
+ * export const appConfig: ApplicationConfig = {
  *   providers: [provideIndexedDBDataBaseName('custom')]
- * });
+ * };
  */
 function provideIndexedDBDataBaseName(name) {
     return makeEnvironmentProviders([{ provide: IDB_DB_NAME, useValue: name }]);
@@ -119,40 +123,47 @@ function provideIndexedDBDataBaseName(name) {
 /**
  * Allows to change the database version used for `indexedDB` database.
  * Must be an unsigned **integer**.
+ *
  * **Use with caution as the creation of the store depends on the version.**
- * *Use only* for interoperability with other APIs or to avoid collision for multiple apps on the same subdomain.
- * **WARNING: do not change this option in an app already deployed in production, as previously stored data would be lost.**
+ *
+ * *Use only* for interoperability with other APIs or to avoid collision for multiple applications on the same subdomain.
+ *
+ * **WARNING: do not change this option in an applicattion already deployed in production, as previously stored data would be lost.**
  *
  * @example
- * bootstrapApplication(AppComponent, {
+ * export const appConfig: ApplicationConfig = {
  *   providers: [provideIndexedDBDataBaseVersion(2)]
- * });
+ * };
  */
 function provideIndexedDBDataBaseVersion(version) {
     return makeEnvironmentProviders([{ provide: IDB_DB_VERSION, useValue: version }]);
 }
 /**
  * Allows to change the name used for `indexedDB` object store.
+ *
  * *Use only* for interoperability with other APIs.
- * **WARNING: do not change this option in an app already deployed in production, as previously stored data would be lost.**
+ *
+ * **WARNING: do not change this option in an application already deployed in production, as previously stored data would be lost.**
  *
  * @example
- * bootstrapApplication(AppComponent, {
+ * export const appConfig: ApplicationConfig = {
  *   providers: [provideIndexedDBStoreName('custom')]
- * });
+ * };
  */
 function provideIndexedDBStoreName(name) {
     return makeEnvironmentProviders([{ provide: IDB_STORE_NAME, useValue: name }]);
 }
 
 /**
- * This module is only here for backward compatibility, do not add it by yourself
+ * This module is only here for backward compatibility, **do not add it by yourself**
+ *
+ * @ignore
  */
 class StorageModule {
     /**
      * Only useful to provide options, otherwise it does nothing.
-     * **Must be used at initialization, ie. in `AppModule`, and must not be loaded again in another module.**
      *
+     * **Must be used at initialization, ie. in `AppModule`, and must not be loaded again in another module.**
      */
     static forRoot(config) {
         return {
@@ -166,11 +177,11 @@ class StorageModule {
             ],
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: StorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.0", ngImport: i0, type: StorageModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: StorageModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: StorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.0", ngImport: i0, type: StorageModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: StorageModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: StorageModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: StorageModule, decorators: [{
             type: NgModule
         }] });
 
@@ -180,7 +191,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImpor
 const VALIDATION_ERROR = `Data stored is not valid against the provided JSON schema.
 Check your JSON schema, otherwise it means data has been corrupted.`;
 /**
- * Exception raised when a value is not valid against the JSON schema
+ * Exception throwned when a value is not valid against the JSON schema
  */
 class ValidationError extends Error {
     constructor() {
@@ -189,536 +200,596 @@ class ValidationError extends Error {
     }
 }
 
-class IndexedDBDatabase {
+class LocalStorageDatabase {
     constructor() {
-        /**
-         * `indexedDB` database connection, wrapped in a RxJS `ReplaySubject` to be able to access the connection
-         * even after the connection success event happened
-         */
-        this.database = new ReplaySubject(1);
-        /**
-         * Index used when wrapping value. *For backward compatibility only.*
-         */
-        this.wrapIndex = "value";
-        this.dbName = inject(IDB_DB_NAME);
-        this.storeName = inject(IDB_STORE_NAME);
-        this.dbVersion = inject(IDB_DB_VERSION);
-        this.noWrap = inject(IDB_NO_WRAP);
-        /* Connect to `indexedDB`, with prefix if provided by the user */
-        this.connect();
-    }
-    /**
-     * Information about `indexedDB` connection. *Only useful for interoperability.*
-     * @returns `indexedDB` database name, store name and database version
-     */
-    get backingStore() {
-        return {
-            database: this.dbName,
-            store: this.storeName,
-            version: this.dbVersion,
-        };
+        /* Prefix if asked, or no prefix otherwise */
+        this.prefix = inject(LS_PREFIX) || "";
     }
     /**
-     * Number of items in our `indexedDB` database and object store
+     * Number of items in `localStorage`
      */
     get size() {
-        /* Open a transaction in read-only mode */
-        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
-            const { store, events } = transactionData;
-            /* Request to know the number of items */
-            const request = store.count();
-            /* Return the result */
-            return events.pipe(map(() => request.result));
-        }), 
-        /* The observable will complete after the first value */
-        first());
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(localStorage.length);
     }
     /**
-     * Gets an item value in our `indexedDB` store
+     * Gets an item value in `localStorage`
      * @param key The item's key
-     * @returns The item's value if the key exists, `undefined` otherwise, wrapped in an RxJS `Observable`
+     * @returns The item's value if the key exists, `undefined` otherwise, wrapped in a RxJS `Observable`
      */
     get(key) {
-        /* Open a transaction in read-only mode */
-        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
-            const { store, events } = transactionData;
-            /* Request the value with the key provided by the user */
-            const request = store.get(key);
-            /* Listen events and return the result */
-            return events.pipe(map(() => {
-                if ((request.result !== undefined) && (request.result !== null)) {
-                    /* Prior to v8, the value was wrapped in an `{ value: ...}` object */
-                    if (!this.noWrap && (typeof request.result === "object") && (this.wrapIndex in request.result) &&
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                        (request.result[this.wrapIndex] !== undefined) && (request.result[this.wrapIndex] !== null)) {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                        return request.result[this.wrapIndex];
-                    }
-                    else {
-                        /* Cast to the wanted type */
-                        return request.result;
-                    }
-                }
-                /* Return `undefined` if the value is empty */
-                return undefined;
-            }));
-        }), 
-        /* The observable will complete after the first value */
-        first());
+        /* Get raw data */
+        const unparsedData = localStorage.getItem(this.prefixKey(key));
+        /* No need to parse if data is `null` or `undefined` */
+        if (unparsedData !== null) {
+            /* Try to parse */
+            try {
+                const parsedData = JSON.parse(unparsedData);
+                /* Wrap in a RxJS `Observable` to be consistent with other storages */
+                return of(parsedData);
+            }
+            catch (error) {
+                return throwError(() => error);
+            }
+        }
+        return of(undefined);
     }
     /**
-     * Sets an item in our `indexedDB` store
+     * Store an item in `localStorage`
      * @param key The item's key
      * @param data The item's value
-     * @returns An RxJS `Observable` to wait the end of the operation
+     * @returns A RxJS `Observable` to wait the end of the operation
      */
     set(key, data) {
-        /* Storing `undefined` in `indexedDb` can cause issues in some browsers so removing item instead */
-        if (data === undefined) {
-            return this.delete(key);
+        let serializedData = null;
+        /* Check if data can be serialized */
+        const dataPrototype = Object.getPrototypeOf(data);
+        if ((typeof data === "object") && (data !== null) && !Array.isArray(data) &&
+            !((dataPrototype === Object.prototype) || (dataPrototype === null))) {
+            return throwError(() => new SerializationError());
         }
-        /* Open a transaction in write mode */
-        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
-            const { store, events } = transactionData;
-            /* Prior to v8, data was wrapped in a `{ value: ... }` object */
-            const dataToStore = this.noWrap ? data : { [this.wrapIndex]: data };
-            /* Add if the item is not existing yet, or update otherwise */
-            store.put(dataToStore, key);
-            /* Listen to events and return `undefined` as no value is expected */
-            return events.pipe(map(() => undefined));
-        }), 
-        /* The observable will complete after the first value */
-        first());
+        /* Try to stringify (can fail on circular references) */
+        try {
+            serializedData = JSON.stringify(data);
+        }
+        catch (error) {
+            return throwError(() => error);
+        }
+        /* Can fail if storage quota is exceeded */
+        try {
+            localStorage.setItem(this.prefixKey(key), serializedData);
+        }
+        catch (error) {
+            return throwError(() => error);
+        }
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
     }
     /**
-     * Deletes an item in our `indexedDB` store
+     * Deletes an item in `localStorage`
      * @param key The item's key
-     * @returns An RxJS `Observable` to wait the end of the operation
+     * @returns A RxJS `Observable` to wait the end of the operation
      */
     delete(key) {
-        /* Open a transaction in write mode */
-        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
-            const { store, events } = transactionData;
-            /* Delete the item in store */
-            store.delete(key);
-            /* Listen to events and return `undefined` as no data is expected here */
-            return events.pipe(map(() => undefined));
-        }), 
-        /* The observable will complete after the first value */
-        first());
+        localStorage.removeItem(this.prefixKey(key));
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
     }
     /**
-     * Deletes all items from our `indexedDB` objet store
-     * @returns An RxJS `Observable` to wait the end of the operation
+     * Deletes all items in `localStorage`
+     * @returns A RxJS `Observable` to wait the end of the operation
      */
     clear() {
-        /* Open a transaction in write mode */
-        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
-            const { store, events } = transactionData;
-            /* Delete all items in object store */
-            store.clear();
-            /* Listen to events and return `undefined` as no data is expected here */
-            return events.pipe(map(() => undefined));
-        }), 
-        /* The observable will complete */
-        first());
+        localStorage.clear();
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
     }
     /**
-     * Get all the keys in our `indexedDB` store
-     * @returns An RxJS `Observable` iterating on each key
+     * Get all keys in `localStorage`
+     * Note the order of the keys may be inconsistent in Firefox
+     * @returns A RxJS `Observable` iterating on keys
      */
     keys() {
-        /* Open a transaction in read-only mode */
-        return this.transaction("readonly").pipe(
-        /* `first()` is used as the final operator in other methods to complete the `Observable`
-         * (as it all starts from a `ReplaySubject` which never ends),
-         * but as this method is iterating over multiple values, `first()` **must** be used here */
-        first(), mergeMap((transactionData) => {
-            const { store } = transactionData;
-            /* Open a cursor on the store
-             * Avoid issues like https://github.com/cyrilletuzi/angular-async-local-storage/issues/69 */
-            const request = store.openKeyCursor();
-            /* Listen to success event */
-            const success$ = fromEvent(request, "success").pipe(
-            /* Stop the `Observable` when the cursor is `null` */
-            takeWhile(() => (request.result !== null)), 
-            /* This lib only allows string keys, but user could have added other types of keys from outside
-             * It's OK to cast as the cursor as been tested in the previous operator */
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-base-to-string
-            map(() => request.result.key.toString()), 
-            /* Iterate on the cursor */
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            tap(() => { request.result.continue(); }));
-            /* Listen to error event and if so, throw an error */
-            const error$ = this.listenError(request);
-            /* Choose the first event to occur */
-            return race([success$, error$]);
-        }));
+        /* Create an `Observable` from keys */
+        return new Observable((subscriber) => {
+            /* Iteretate over all the indexes */
+            for (let index = 0; index < localStorage.length; index += 1) {
+                /* Cast as we are sure in this case the key is not `null` */
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Ensured by the logic
+                subscriber.next(this.getUnprefixedKey(index));
+            }
+            subscriber.complete();
+        }).pipe(
+        /* Required to work like other databases which are asynchronous */
+        observeOn(asyncScheduler));
     }
     /**
-     * Check if a key exists in our `indexedDB` store
-     * @returns An RxJS `Observable` telling if the key exists or not
+     * Check if a key exists in `localStorage`
+     * @param key The item's key
+     * @returns A RxJS `Observable` telling if the key exists or not
      */
     has(key) {
-        /* Open a transaction in read-only mode */
-        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
-            const { store, events } = transactionData;
-            /* Check if the key exists in the store
-             * Fixes https://github.com/cyrilletuzi/angular-async-local-storage/issues/69
-             */
-            const request = store.getKey(key);
-            /* Listen to events and return `true` or `false` */
-            return events.pipe(map(() => (request.result !== undefined) ? true : false));
-        }), 
-        /* The observable will complete */
-        first());
+        /* Itérate over all indexes in storage */
+        for (let index = 0; index < localStorage.length; index += 1) {
+            if (key === this.getUnprefixedKey(index)) {
+                /* Wrap in a RxJS `Observable` to be consistent with other storages */
+                return of(true);
+            }
+        }
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(false);
     }
     /**
-     * Connects to `indexedDB` and creates the object store on first time
+     * Get an unprefixed key
+     * @param index Index of the key
+     * @returns The unprefixed key name if exists, `null` otherwise
      */
-    connect() {
-        let request;
-        /* Connect to `indexedDB`
-         * Will fail in Safari cross-origin iframes
-         * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42} */
-        try {
-            /* Do NOT explicit `window` here, as `indexedDB` could be used from a web worker too */
-            request = indexedDB.open(this.dbName, this.dbVersion);
+    getUnprefixedKey(index) {
+        /* Get the key in storage: may have a prefix */
+        const prefixedKey = localStorage.key(index);
+        if (prefixedKey !== null) {
+            /* If no prefix, the key is already good, otherwrite strip the prefix */
+            return !this.prefix ? prefixedKey : prefixedKey.substring(this.prefix.length);
         }
-        catch {
-            this.database.error(new IDBBrokenError());
-            return;
-        }
-        /* Create store on first connection */
-        this.createStore(request);
-        /* Listen to success and error events */
-        const success$ = fromEvent(request, "success");
-        const error$ = this.listenError(request);
-        /* Choose the first to occur */
-        race([success$, error$])
-            /* The observable will complete */
-            .pipe(first())
-            .subscribe({
-            next: () => {
-                /* Register the database connection in the `ReplaySubject` for further access */
-                this.database.next(request.result);
-            },
-            error: () => {
-                /* Firefox private mode issue: fallback storage if IndexedDb connection is failing
-                * @see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=781982}
-                * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/26} */
-                this.database.error(new IDBBrokenError());
-            },
-        });
-    }
-    /**
-     * Create store on first use of `indexedDB`
-     * @param request `indexedDB` database opening request
-     */
-    createStore(request) {
-        /* Listen to the event fired on first connection */
-        fromEvent(request, "upgradeneeded")
-            /* The observable will complete */
-            .pipe(first())
-            .subscribe({
-            next: () => {
-                /* Check if the store already exists, to avoid error */
-                if (!request.result.objectStoreNames.contains(this.storeName)) {
-                    /* Create the object store */
-                    request.result.createObjectStore(this.storeName);
-                }
-            }
-        });
-    }
-    /**
-     * Open an `indexedDB` transaction and get our store
-     * @param mode `readonly` or `readwrite`
-     * @returns An `indexedDB` transaction store and events, wrapped in an RxJS `Observable`
-     */
-    transaction(mode) {
-        /* From the `indexedDB` connection, open a transaction and get the store */
-        return this.database
-            .pipe(mergeMap((database) => {
-            let transaction;
-            try {
-                transaction = database.transaction([this.storeName], mode);
-            }
-            catch (error) {
-                /* The store could have been deleted from outside */
-                return throwError(() => error);
-            }
-            /* Get the store from the transaction */
-            const store = transaction.objectStore(this.storeName);
-            /* Listen transaction `complete` and `error` events */
-            const events = this.listenTransactionEvents(transaction);
-            return of({ store, events });
-        }));
-    }
-    /**
-     * Listen errors on a transaction or request, and throw if trigerred
-     * @param transactionOrRequest `indexedDb` transaction or request to listen
-     * @returns An `Observable` listening to errors
-     */
-    listenError(transactionOrRequest) {
-        return fromEvent(transactionOrRequest, "error").pipe(
-        /* Throw on error to be able to catch errors in RxJS way.
-         * Here `event.target` must be used, as `transactionOrRequest.error` will be `null`
-         * if we are on the request and the error is only triggered later by the transaction */
-        mergeMap((event) => throwError(() => event.target?.error)));
+        return null;
     }
     /**
-     * Listen transaction `complete` and `error` events
-     * @param transaction Transaction to listen
-     * @returns An `Observable` listening to transaction `complete` and `error` events
+     * Add the prefix to a key
+     * @param key The key name
+     * @returns The prefixed key name
      */
-    listenTransactionEvents(transaction) {
-        /* Listen to the `complete` event */
-        const complete$ = fromEvent(transaction, "complete");
-        /* Listen to the `error` event */
-        const error$ = this.listenError(transaction);
-        /* Choose the first event to occur */
-        return race([complete$, error$]);
+    prefixKey(key) {
+        return `${this.prefix}${key}`;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: IndexedDBDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: IndexedDBDatabase, providedIn: "root" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: LocalStorageDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: LocalStorageDatabase, providedIn: "root" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: IndexedDBDatabase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: LocalStorageDatabase, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: "root"
                 }]
         }], ctorParameters: () => [] });
 
-class LocalStorageDatabase {
+class MemoryDatabase {
     constructor() {
-        /* Prefix if asked, or no prefix otherwise */
-        this.prefix = inject(LS_PREFIX) || "";
+        /**
+         * Memory storage
+         */
+        this.memoryStorage = new Map();
     }
     /**
-     * Number of items in `localStorage`
+     * Number of items in memory
      */
     get size() {
         /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(localStorage.length);
+        return of(this.memoryStorage.size);
     }
     /**
-     * Gets an item value in `localStorage`
+     * Gets an item value in memory
      * @param key The item's key
      * @returns The item's value if the key exists, `undefined` otherwise, wrapped in a RxJS `Observable`
      */
     get(key) {
-        /* Get raw data */
-        const unparsedData = localStorage.getItem(this.prefixKey(key));
-        let parsedData;
-        /* No need to parse if data is `null` or `undefined` */
-        if (unparsedData !== null) {
-            /* Try to parse */
-            try {
-                parsedData = JSON.parse(unparsedData);
-            }
-            catch (error) {
-                return throwError(() => error);
-            }
-        }
         /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(parsedData);
+        return of(this.memoryStorage.get(key));
     }
     /**
-     * Store an item in `localStorage`
+     * Sets an item in memory
      * @param key The item's key
      * @param data The item's value
      * @returns A RxJS `Observable` to wait the end of the operation
      */
     set(key, data) {
-        let serializedData = null;
-        /* Check if data can be serialized */
-        const dataPrototype = Object.getPrototypeOf(data);
-        if ((typeof data === "object") && (data !== null) && !Array.isArray(data) &&
-            !((dataPrototype === Object.prototype) || (dataPrototype === null))) {
-            return throwError(() => new SerializationError());
-        }
-        /* Try to stringify (can fail on circular references) */
-        try {
-            serializedData = JSON.stringify(data);
-        }
-        catch (error) {
-            return throwError(() => error);
-        }
-        /* Can fail if storage quota is exceeded */
-        try {
-            localStorage.setItem(this.prefixKey(key), serializedData);
-        }
-        catch (error) {
-            return throwError(() => error);
-        }
+        this.memoryStorage.set(key, data);
         /* Wrap in a RxJS `Observable` to be consistent with other storages */
         return of(undefined);
     }
     /**
-     * Deletes an item in `localStorage`
+     * Deletes an item in memory
      * @param key The item's key
      * @returns A RxJS `Observable` to wait the end of the operation
      */
     delete(key) {
-        localStorage.removeItem(this.prefixKey(key));
+        this.memoryStorage.delete(key);
         /* Wrap in a RxJS `Observable` to be consistent with other storages */
         return of(undefined);
     }
     /**
-     * Deletes all items in `localStorage`
+     * Deletes all items in memory
      * @returns A RxJS `Observable` to wait the end of the operation
      */
     clear() {
-        localStorage.clear();
+        this.memoryStorage.clear();
         /* Wrap in a RxJS `Observable` to be consistent with other storages */
         return of(undefined);
     }
     /**
-     * Get all keys in `localStorage`
-     * Note the order of the keys may be inconsistent in Firefox
+     * Get all keys in memory
      * @returns A RxJS `Observable` iterating on keys
      */
     keys() {
         /* Create an `Observable` from keys */
-        return new Observable((subscriber) => {
-            /* Iteretate over all the indexes */
-            for (let index = 0; index < localStorage.length; index += 1) {
-                /* Cast as we are sure in this case the key is not `null` */
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                subscriber.next(this.getUnprefixedKey(index));
-            }
-            subscriber.complete();
-        }).pipe(
-        /* Required to work like other databases which are asynchronous */
-        observeOn(asyncScheduler));
+        return from(this.memoryStorage.keys());
     }
     /**
-     * Check if a key exists in `localStorage`
-     * @param key The item's key
-     * @returns A RxJS `Observable` telling if the key exists or not
+     * Check if a key exists in memory
+     * @param key Key name
+     * @returns a RxJS `Observable` telling if the key exists or not
      */
     has(key) {
-        /* Itérate over all indexes in storage */
-        for (let index = 0; index < localStorage.length; index += 1) {
-            if (key === this.getUnprefixedKey(index)) {
-                /* Wrap in a RxJS `Observable` to be consistent with other storages */
-                return of(true);
-            }
-        }
         /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(false);
+        return of(this.memoryStorage.has(key));
     }
-    /**
-     * Get an unprefixed key
-     * @param index Index of the key
-     * @returns The unprefixed key name if exists, `null` otherwise
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MemoryDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MemoryDatabase, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MemoryDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+/**
+ * Factory to create a storage according to browser support
+ * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/BROWSERS_SUPPORT.md}
+ */
+function localDatabaseFactory() {
+    const platformId = inject(PLATFORM_ID);
+    /* When storage is fully disabled in browser (via the "Block all cookies" option),
+     * just trying to check `indexedDB` or `localStorage` variables causes a security exception.
+     * Prevents https://github.com/cyrilletuzi/angular-async-local-storage/issues/118
      */
-    getUnprefixedKey(index) {
-        /* Get the key in storage: may have a prefix */
-        const prefixedKey = localStorage.key(index);
-        if (prefixedKey !== null) {
-            /* If no prefix, the key is already good, otherwrite strip the prefix */
-            return !this.prefix ? prefixedKey : prefixedKey.substring(this.prefix.length);
+    try {
+        // Do not explicit `window` here, as the global object is not the same in web workers
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- They can be undefined in some browsers scenarios
+        if (isPlatformBrowser(platformId) && (indexedDB !== undefined) && (indexedDB !== null) && ("open" in indexedDB)) {
+            /* Check:
+            * - if we are in a browser context (issue: server-side rendering)
+            * - it could exist but be `undefined` or `null`
+            * - it could exists but not having a working API
+            * Will be the case for:
+            * - All other browsers in normal mode
+            * - Chromium / Safari / Firefox private mode, but in this case, data will be swiped when the user leaves the app */
+            return new IndexedDBDatabase();
+        }
+        else if (isPlatformBrowser(platformId)
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- They can be undefined in some browsers scenarios
+            && (localStorage !== undefined) && (localStorage !== null) && ("getItem" in localStorage)) {
+            /* Check:
+            * - if we are in a browser context (issue: server-side rendering)
+            * - if `localStorage` exists (to be sure)
+            * - it could exists but not having a working API
+            * Will be the case for:
+            * - Safari cross-origin iframes, detected later in `IndexedDBDatabase.connect()`
+            * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42}
+            */
+            return new LocalStorageDatabase();
         }
-        return null;
     }
-    /**
-     * Add the prefix to a key
-     * @param key The key name
-     * @returns The prefixed key name
-     */
-    prefixKey(key) {
-        return `${this.prefix}${key}`;
+    catch {
+        // Nothing to do
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: LocalStorageDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: LocalStorageDatabase, providedIn: "root" }); }
+    /* Will be the case for:
+     * - In browsers if storage has been fully disabled (via the "Block all cookies" option)
+     * - Server-side rendering
+     * - All other non-browser context
+     */
+    return new MemoryDatabase();
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: LocalStorageDatabase, decorators: [{
+class LocalDatabase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: LocalDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: LocalDatabase, providedIn: "root", useFactory: localDatabaseFactory }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: LocalDatabase, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: "root"
+                    providedIn: "root",
+                    useFactory: localDatabaseFactory,
                 }]
-        }], ctorParameters: () => [] });
+        }] });
 
-class MemoryDatabase {
+class IndexedDBDatabase {
     constructor() {
         /**
-         * Memory storage
+         * `indexedDB` database connection, wrapped in a RxJS `ReplaySubject` to be able to access the connection
+         * even after the connection success event happened
          */
-        this.memoryStorage = new Map();
+        this.database = new ReplaySubject(1);
+        /**
+         * Index used when wrapping value. *For backward compatibility only.*
+         */
+        this.wrapIndex = "value";
+        this.dbName = inject(IDB_DB_NAME);
+        this.storeName = inject(IDB_STORE_NAME);
+        this.dbVersion = inject(IDB_DB_VERSION);
+        this.noWrap = inject(IDB_NO_WRAP);
+        /* Connect to `indexedDB`, with prefix if provided by the user */
+        this.connect();
+    }
+    /**
+     * Information about `indexedDB` connection. *Only useful for interoperability.*
+     * @returns `indexedDB` database name, store name and database version
+     */
+    get backingStore() {
+        return {
+            database: this.dbName,
+            store: this.storeName,
+            version: this.dbVersion,
+        };
+    }
+    /**
+     * Number of items in our `indexedDB` database and object store
+     */
+    get size() {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Request to know the number of items */
+            const request = store.count();
+            /* Return the result */
+            return events.pipe(map(() => request.result));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Gets an item value in our `indexedDB` store
+     * @param key The item's key
+     * @returns The item's value if the key exists, `undefined` otherwise, wrapped in an RxJS `Observable`
+     */
+    get(key) {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Request the value with the key provided by the user */
+            const request = store.get(key);
+            /* Listen events and return the result */
+            return events.pipe(map(() => {
+                if ((request.result !== undefined) && (request.result !== null)) {
+                    /* Prior to v8, the value was wrapped in an `{ value: ...}` object */
+                    if (!this.noWrap && (typeof request.result === "object") && (this.wrapIndex in request.result) &&
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- Required by indexedDb behavior
+                        (request.result[this.wrapIndex] !== undefined) && (request.result[this.wrapIndex] !== null)) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- Required by indexedDb behavior
+                        return request.result[this.wrapIndex];
+                    }
+                    else {
+                        /* Cast to the wanted type */
+                        return request.result;
+                    }
+                }
+                /* Return `undefined` if the value is empty */
+                return undefined;
+            }));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Sets an item in our `indexedDB` store
+     * @param key The item's key
+     * @param data The item's value
+     * @returns An RxJS `Observable` to wait the end of the operation
+     */
+    set(key, data) {
+        /* Storing `undefined` in `indexedDb` can cause issues in some browsers so removing item instead */
+        if (data === undefined) {
+            return this.delete(key);
+        }
+        /* Open a transaction in write mode */
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Prior to v8, data was wrapped in a `{ value: ... }` object */
+            const dataToStore = this.noWrap ? data : { [this.wrapIndex]: data };
+            /* Add if the item is not existing yet, or update otherwise */
+            store.put(dataToStore, key);
+            /* Listen to events and return `undefined` as no value is expected */
+            return events.pipe(map(() => undefined));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Deletes an item in our `indexedDB` store
+     * @param key The item's key
+     * @returns An RxJS `Observable` to wait the end of the operation
+     */
+    delete(key) {
+        /* Open a transaction in write mode */
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Delete the item in store */
+            store.delete(key);
+            /* Listen to events and return `undefined` as no data is expected here */
+            return events.pipe(map(() => undefined));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Deletes all items from our `indexedDB` objet store
+     * @returns An RxJS `Observable` to wait the end of the operation
+     */
+    clear() {
+        /* Open a transaction in write mode */
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Delete all items in object store */
+            store.clear();
+            /* Listen to events and return `undefined` as no data is expected here */
+            return events.pipe(map(() => undefined));
+        }), 
+        /* The observable will complete */
+        first());
     }
     /**
-     * Number of items in memory
+     * Get all the keys in our `indexedDB` store
+     * @returns An RxJS `Observable` iterating on each key
      */
-    get size() {
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(this.memoryStorage.size);
+    keys() {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(
+        /* `first()` is used as the final operator in other methods to complete the `Observable`
+         * (as it all starts from a `ReplaySubject` which never ends),
+         * but as this method is iterating over multiple values, `first()` **must** be used here */
+        first(), mergeMap((transactionData) => {
+            const { store } = transactionData;
+            /* Open a cursor on the store
+             * Avoid issues like https://github.com/cyrilletuzi/angular-async-local-storage/issues/69 */
+            const request = store.openKeyCursor();
+            /* Listen to success event */
+            const success$ = fromEvent(request, "success").pipe(
+            /* Stop the `Observable` when the cursor is `null` */
+            // eslint-disable-next-line rxjs/no-ignored-takewhile-value -- Required by indexedDb behavior, getting the result from the event does not always work
+            takeWhile(() => (request.result !== null)), 
+            /* This lib only allows string keys, but user could have added other types of keys from outside
+             * It's OK to cast as the cursor as been tested in the previous operator */
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-base-to-string -- Required by indexedDb behavior, and strings are enforced by the lib
+            map(() => request.result.key.toString()), 
+            /* Iterate on the cursor */
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Required by indexedDb behavior
+            tap(() => { request.result.continue(); }));
+            /* Listen to error event and if so, throw an error */
+            const error$ = this.listenError(request);
+            /* Choose the first event to occur */
+            return race([success$, error$]);
+        }));
     }
     /**
-     * Gets an item value in memory
-     * @param key The item's key
-     * @returns The item's value if the key exists, `undefined` otherwise, wrapped in a RxJS `Observable`
+     * Check if a key exists in our `indexedDB` store
+     * @returns An RxJS `Observable` telling if the key exists or not
      */
-    get(key) {
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(this.memoryStorage.get(key));
+    has(key) {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Check if the key exists in the store
+             * Fixes https://github.com/cyrilletuzi/angular-async-local-storage/issues/69
+             */
+            const request = store.getKey(key);
+            /* Listen to events and return `true` or `false` */
+            return events.pipe(map(() => (request.result !== undefined) ? true : false));
+        }), 
+        /* The observable will complete */
+        first());
     }
     /**
-     * Sets an item in memory
-     * @param key The item's key
-     * @param data The item's value
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * Connects to `indexedDB` and creates the object store on first time
      */
-    set(key, data) {
-        this.memoryStorage.set(key, data);
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(undefined);
+    connect() {
+        let request;
+        /* Connect to `indexedDB`
+         * Will fail in Safari cross-origin iframes
+         * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42} */
+        try {
+            /* Do NOT explicit `window` here, as `indexedDB` could be used from a web worker too */
+            request = indexedDB.open(this.dbName, this.dbVersion);
+        }
+        catch {
+            this.database.error(new IDBBrokenError());
+            return;
+        }
+        /* Create store on first connection */
+        this.createStore(request);
+        /* Listen to success and error events */
+        const success$ = fromEvent(request, "success");
+        const error$ = this.listenError(request);
+        /* Choose the first to occur */
+        race([success$, error$])
+            /* The observable will complete */
+            .pipe(first())
+            .subscribe({
+            next: () => {
+                /* Register the database connection in the `ReplaySubject` for further access */
+                this.database.next(request.result);
+            },
+            error: () => {
+                /* Keeping this error management for safety, but it should not happen anymore.
+                 * It was for Firefox private mode issue in Firefox versions < 115
+                 * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/26} */
+                this.database.error(new IDBBrokenError());
+            },
+        });
     }
     /**
-     * Deletes an item in memory
-     * @param key The item's key
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * Create store on first use of `indexedDB`
+     * @param request `indexedDB` database opening request
      */
-    delete(key) {
-        this.memoryStorage.delete(key);
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(undefined);
+    createStore(request) {
+        /* Listen to the event fired on first connection */
+        fromEvent(request, "upgradeneeded")
+            /* The observable will complete */
+            .pipe(first())
+            .subscribe({
+            next: () => {
+                /* Check if the store already exists, to avoid error */
+                if (!request.result.objectStoreNames.contains(this.storeName)) {
+                    /* Create the object store */
+                    request.result.createObjectStore(this.storeName);
+                }
+            }
+        });
     }
     /**
-     * Deletes all items in memory
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * Open an `indexedDB` transaction and get our store
+     * @param mode `readonly` or `readwrite`
+     * @returns An `indexedDB` transaction store and events, wrapped in an RxJS `Observable`
      */
-    clear() {
-        this.memoryStorage.clear();
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(undefined);
+    transaction(mode) {
+        /* From the `indexedDB` connection, open a transaction and get the store */
+        return this.database
+            .pipe(mergeMap((database) => {
+            let transaction;
+            try {
+                transaction = database.transaction([this.storeName], mode);
+            }
+            catch (error) {
+                /* The store could have been deleted from outside */
+                return throwError(() => error);
+            }
+            /* Get the store from the transaction */
+            const store = transaction.objectStore(this.storeName);
+            /* Listen transaction `complete` and `error` events */
+            const events = this.listenTransactionEvents(transaction);
+            return of({ store, events });
+        }));
     }
     /**
-     * Get all keys in memory
-     * @returns A RxJS `Observable` iterating on keys
+     * Listen errors on a transaction or request, and throw if trigerred
+     * @param transactionOrRequest `indexedDb` transaction or request to listen
+     * @returns An `Observable` listening to errors
      */
-    keys() {
-        /* Create an `Observable` from keys */
-        return from(this.memoryStorage.keys());
+    listenError(transactionOrRequest) {
+        return fromEvent(transactionOrRequest, "error").pipe(
+        /* Throw on error to be able to catch errors in RxJS way.
+         * Here `event.target` must be used, as `transactionOrRequest.error` will be `null`
+         * if we are on the request and the error is only triggered later by the transaction */
+        mergeMap((event) => throwError(() => event.target?.error)));
     }
     /**
-     * Check if a key exists in memory
-     * @param key Key name
-     * @returns a RxJS `Observable` telling if the key exists or not
+     * Listen transaction `complete` and `error` events
+     * @param transaction Transaction to listen
+     * @returns An `Observable` listening to transaction `complete` and `error` events
      */
-    has(key) {
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(this.memoryStorage.has(key));
+    listenTransactionEvents(transaction) {
+        /* Listen to the `complete` event */
+        const complete$ = fromEvent(transaction, "complete");
+        /* Listen to the `error` event */
+        const error$ = this.listenError(transaction);
+        /* Choose the first event to occur */
+        return race([complete$, error$]);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MemoryDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MemoryDatabase, providedIn: "root" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: IndexedDBDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: IndexedDBDatabase, providedIn: "root" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MemoryDatabase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: IndexedDBDatabase, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: "root"
                 }]
-        }] });
+        }], ctorParameters: () => [] });
 
 class JSONValidator {
     /**
@@ -767,16 +838,15 @@ class JSONValidator {
             return false;
         }
         if (schema.pattern) {
-            let regularExpression = null;
             try {
-                regularExpression = new RegExp(schema.pattern);
+                const regularExpression = new RegExp(schema.pattern);
+                if (!regularExpression.test(data)) {
+                    return false;
+                }
             }
             catch {
                 // Nothing to do
             }
-            if (regularExpression && !regularExpression.test(data)) {
-                return false;
-            }
         }
         return true;
     }
@@ -883,9 +953,8 @@ class JSONValidator {
             return false;
         }
         if (schemas) {
-            for (let i = 0; i < schemas.length; i += 1) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                if (!this.validate(data[i], schemas[i])) {
+            for (const [index, schema] of schemas.entries()) {
+                if (!this.validate(data[index], schema)) {
                     return false;
                 }
             }
@@ -912,7 +981,7 @@ class JSONValidator {
         /* Validate required properties */
         if (schema.required) {
             for (const requiredProp of schema.required) {
-                if (!Object.prototype.hasOwnProperty.call(data, requiredProp)) {
+                if (!Object.hasOwn(data, requiredProp)) {
                     return false;
                 }
             }
@@ -920,8 +989,8 @@ class JSONValidator {
         /* Recursively validate all properties */
         for (const property in schema.properties) {
             /* Filter to keep only real properties (no internal JS stuff) and check if the data has the property too */
-            if (Object.prototype.hasOwnProperty.call(schema.properties, property) && Object.prototype.hasOwnProperty.call(data, property)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            if (Object.hasOwn(schema.properties, property) && Object.hasOwn(data, property)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Ensured by the logic
                 if (!this.validate(data[property], schema.properties[property])) {
                     return false;
                 }
@@ -954,92 +1023,32 @@ class JSONValidator {
         /* Cast as the data can be of multiple types, and so TypeScript is lost */
         return (schema.enum.includes(data));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: JSONValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: JSONValidator, providedIn: "root" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: JSONValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: JSONValidator, providedIn: "root" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: JSONValidator, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: JSONValidator, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: "root"
                 }]
         }] });
 
-/**
- * Factory to create a storage according to browser support
- * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/BROWSERS_SUPPORT.md}
- */
-function localDatabaseFactory() {
-    const platformId = inject(PLATFORM_ID);
-    /* When storage is fully disabled in browser (via the "Block all cookies" option),
-     * just trying to check `indexedDB` or `localStorage` variables causes a security exception.
-     * Prevents https://github.com/cyrilletuzi/angular-async-local-storage/issues/118
-     */
-    try {
-        // Do not explicit `window` here, as the global object is not the same in web workers
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- They can be undefined in some browsers scenarios
-        if (isPlatformBrowser(platformId) && (indexedDB !== undefined) && (indexedDB !== null) && ("open" in indexedDB)) {
-            /* Check:
-            * - if we are in a browser context (issue: server-side rendering)
-            * - it could exist but be `undefined` or `null`
-            * - it could exists but not having a working API
-            * Will be the case for:
-            * - All other browsers in normal mode
-            * - Chromium / Safari private mode, but in this case, data will be swiped when the user leaves the app */
-            return new IndexedDBDatabase();
-        }
-        else if (isPlatformBrowser(platformId)
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- They can be undefined in some browsers scenarios
-            && (localStorage !== undefined) && (localStorage !== null) && ("getItem" in localStorage)) {
-            /* Check:
-            * - if we are in a browser context (issue: server-side rendering)
-            * - if `localStorage` exists (to be sure)
-            * - it could exists but not having a working API
-            * Will be the case for:
-            * - Safari cross-origin iframes, detected later in `IndexedDBDatabase.connect()`
-            * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42}
-            * - Firefox private mode, but in this case, data will be swiped when the user leaves the app
-            * For Firefox, can only be detected later in `IndexedDBDatabase.connect()`
-            * @see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=781982}
-            */
-            return new LocalStorageDatabase();
-        }
-    }
-    catch {
-        // Nothing to do
-    }
-    /* Will be the case for:
-     * - In browsers if storage has been fully disabled (via the "Block all cookies" option)
-     * - Server-side rendering
-     * - All other non-browser context
-     */
-    return new MemoryDatabase();
-}
-class LocalDatabase {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: LocalDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: LocalDatabase, providedIn: "root", useFactory: localDatabaseFactory }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: LocalDatabase, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                    useFactory: localDatabaseFactory,
-                }]
-        }] });
-
 class StorageMap {
+    #database;
+    #jsonValidator;
+    #notifiers = new Map();
     /**
      * Constructor params are provided by Angular (but can also be passed manually in tests)
      * @param database Storage to use
-     * @param jsonValidator Validator service
-     * @param LSPrefix Prefix for `localStorage` keys to avoid collision for multiple apps on the same subdomain or for interoperability
      */
-    constructor(database, jsonValidator = new JSONValidator()) {
-        this.database = database;
-        this.jsonValidator = jsonValidator;
-        this.notifiers = new Map();
+    constructor(database) {
+        this.#database = database;
+        this.#jsonValidator = new JSONValidator();
     }
     /**
-     * **Number of items** in storage, wrapped in an `Observable`.
+     * **Number of items** in storage, wrapped in an Observable.
+     *
+     * Note you do *not* need to unsubscribe (it is a self-completing Observable).
      *
      * @example
      * this.storageMap.size.subscribe((size) => {
@@ -1047,14 +1056,17 @@ class StorageMap {
      * });
      */
     get size() {
-        return this.database.size
+        return this.#database.size
             /* Catch if `indexedDb` is broken */
-            .pipe(this.catchIDBBroken(() => this.database.size));
+            .pipe(this.#catchIDBBroken(() => this.#database.size));
     }
     /**
-     * Tells you which storage engine is used. *Only useful for interoperability.*
+     * Tells you which storage engine is used.
+     *
+     * *Only useful for interoperability.*
+     *
      * Note that due to some browsers issues in some special contexts
-     * (Firefox private mode and Safari cross-origin iframes),
+     * (like Safari cross-origin iframes),
      * **this information may be wrong at initialization,**
      * as the storage could fallback from `indexedDB` to `localStorage`
      * only after a first read or write operation.
@@ -1066,13 +1078,13 @@ class StorageMap {
      * if (this.storageMap.backingEngine === 'indexedDB') {}
      */
     get backingEngine() {
-        if (this.database instanceof IndexedDBDatabase) {
+        if (this.#database instanceof IndexedDBDatabase) {
             return "indexedDB";
         }
-        else if (this.database instanceof LocalStorageDatabase) {
+        else if (this.#database instanceof LocalStorageDatabase) {
             return "localStorage";
         }
-        else if (this.database instanceof MemoryDatabase) {
+        else if (this.#database instanceof MemoryDatabase) {
             return "memory";
         }
         else {
@@ -1080,10 +1092,12 @@ class StorageMap {
         }
     }
     /**
-     * Info about `indexedDB` database. *Only useful for interoperability.*
+     * Information about `indexedDB` database.
+     *
+     * *Only useful for interoperability.*
+     *
      * @returns `indexedDB` database name, store name and database version.
-     * **Values will be empty if the storage is not `indexedDB`,**
-     * **so it should be used after an engine check**.
+     * **Values will be empty if the storage is not `indexedDB`, so it should be used after an engine check**.
      *
      * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/INTEROPERABILITY.md}
      *
@@ -1093,15 +1107,17 @@ class StorageMap {
      * }
      */
     get backingStore() {
-        return (this.database instanceof IndexedDBDatabase) ?
-            this.database.backingStore :
+        return (this.#database instanceof IndexedDBDatabase) ?
+            this.#database.backingStore :
             { database: "", store: "", version: 0 };
     }
     /**
-     * Info about `localStorage` fallback storage. *Only useful for interoperability.*
+     * Information about `localStorage` fallback storage.
+     *
+     * *Only useful for interoperability.*
+     *
      * @returns `localStorage` prefix.
-     * **Values will be empty if the storage is not `localStorage`,**
-     * **so it should be used after an engine check**.
+     * **Values will be empty if the storage is not `localStorage`, so it should be used after an engine check**.
      *
      * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/INTEROPERABILITY.md}
      *
@@ -1111,22 +1127,22 @@ class StorageMap {
      * }
      */
     get fallbackBackingStore() {
-        return (this.database instanceof LocalStorageDatabase) ?
-            { prefix: this.database.prefix } :
+        return (this.#database instanceof LocalStorageDatabase) ?
+            { prefix: this.#database.prefix } :
             { prefix: "" };
     }
     get(key, schema) {
         /* Get the data in storage */
-        return this.database.get(key).pipe(
+        return this.#database.get(key).pipe(
         /* Check if `indexedDb` is broken */
-        this.catchIDBBroken(() => this.database.get(key)), mergeMap((data) => {
+        this.#catchIDBBroken(() => this.#database.get(key)), mergeMap((data) => {
             /* No need to validate if the data is empty */
             if ((data === undefined) || (data === null)) {
                 return of(undefined);
             }
             else if (schema) {
                 /* Validate data against a JSON schema if provided */
-                if (!this.jsonValidator.validate(data, schema)) {
+                if (!this.#jsonValidator.validate(data, schema)) {
                     return throwError(() => new ValidationError());
                 }
                 /* Data have been checked, so it's OK to cast */
@@ -1137,12 +1153,19 @@ class StorageMap {
         }));
     }
     /**
-     * Set an item in storage.
-     * Note that setting `null` or `undefined` will remove the item to avoid some browsers issues.
+     * Store an item in storage.
+     *
+     * Note that:
+     * * you *do* need to subscribe, even if you do not have something specific to do after writing in storage, otherwise nothing happens (because it is how RxJS Observables work),
+     * * but you do *not* need to unsubscribe (it is a self-completing Observable),
+     * * setting `null` or `undefined` will remove the item to avoid some browsers issues,
+     * * you should stick to serializable JSON data, meaning primitive types, arrays and literal objects. Date, Map, Set, Blob and other special structures can cause issues in some scenarios.
+     * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/SERIALIZATION.md}
+     *
      * @param key The item's key
      * @param data The item's value
      * @param schema Optional JSON schema to validate the data
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * @returns A RxJS Observable to wait the end of the operation
      *
      * @example
      * this.storageMap.set('key', 'value').subscribe(() => {});
@@ -1154,54 +1177,68 @@ class StorageMap {
             return this.delete(key);
         }
         /* Validate data against a JSON schema if provided */
-        if (schema && !this.jsonValidator.validate(data, schema)) {
+        if (schema && !this.#jsonValidator.validate(data, schema)) {
             return throwError(() => new ValidationError());
         }
-        return this.database.set(key, data).pipe(
+        return this.#database.set(key, data).pipe(
         /* Catch if `indexedDb` is broken */
-        this.catchIDBBroken(() => this.database.set(key, data)), 
+        this.#catchIDBBroken(() => this.#database.set(key, data)), 
         /* Notify watchers (must be last because it should only happen if the operation succeeds) */
-        tap(() => { this.notify(key, data); }));
+        tap(() => { this.#notify(key, data); }));
     }
     /**
-     * Delete an item in storage
+     * Delete an item in storage.
+     *
+     * Note that:
+     * * you *do* need to subscribe, even if you do not have something specific to do after deleting, otherwise nothing happens (because it is how RxJS Observables work),
+     * * but you do *not* need to unsubscribe (it is a self-completing Observable).
+     *
      * @param key The item's key
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * @returns A RxJS Observable to wait the end of the operation
      *
      * @example
      * this.storageMap.delete('key').subscribe(() => {});
      */
     delete(key) {
-        return this.database.delete(key).pipe(
+        return this.#database.delete(key).pipe(
         /* Catch if `indexedDb` is broken */
-        this.catchIDBBroken(() => this.database.delete(key)), 
+        this.#catchIDBBroken(() => this.#database.delete(key)), 
         /* Notify watchers (must be last because it should only happen if the operation succeeds) */
-        tap(() => { this.notify(key, undefined); }));
+        tap(() => { this.#notify(key, undefined); }));
     }
     /**
-     * Delete all items in storage
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * Delete all items in storage.
+     *
+     * Note that:
+     * * you *do* need to subscribe, even if you do not have something specific to do after clearing, otherwise nothing happens (because it is how RxJS Observables work),
+     * * but you do *not* need to unsubscribe (it is a self-completing Observable).
+     *
+     * @returns A RxJS Observable to wait the end of the operation
      *
      * @example
      * this.storageMap.clear().subscribe(() => {});
      */
     clear() {
-        return this.database.clear().pipe(
+        return this.#database.clear().pipe(
         /* Catch if `indexedDb` is broken */
-        this.catchIDBBroken(() => this.database.clear()), 
+        this.#catchIDBBroken(() => this.#database.clear()), 
         /* Notify watchers (must be last because it should only happen if the operation succeeds) */
         tap(() => {
-            for (const key of this.notifiers.keys()) {
-                this.notify(key, undefined);
+            for (const key of this.#notifiers.keys()) {
+                this.#notify(key, undefined);
             }
         }));
     }
     /**
-     * Get all keys stored in storage. Note **this is an *iterating* `Observable`**:
+     * Get all keys stored in storage.
+     *
+     * Note **this is an *iterating* Observable**:
      * * if there is no key, the `next` callback will not be invoked,
      * * if you need to wait the whole operation to end, be sure to act in the `complete` callback,
-     * as this `Observable` can emit several values and so will invoke the `next` callback several times.
-     * @returns A list of the keys wrapped in a RxJS `Observable`
+     * as this Observable can emit several values and so will invoke the `next` callback several times,
+     * * you do *not* need to unsubscribe (it is a self-completing Observable).
+     *
+     * @returns A list of the keys wrapped in a RxJS Observable
      *
      * @example
      * this.storageMap.keys().subscribe({
@@ -1210,13 +1247,16 @@ class StorageMap {
      * });
      */
     keys() {
-        return this.database.keys()
+        return this.#database.keys()
             /* Catch if `indexedDb` is broken */
-            .pipe(this.catchIDBBroken(() => this.database.keys()));
+            .pipe(this.#catchIDBBroken(() => this.#database.keys()));
     }
     /**
-     * Tells if a key exists in storage
-     * @returns A RxJS `Observable` telling if the key exists
+     * Tells if a key exists in storage.
+     *
+     * Note you do *not* need to unsubscribe (it is a self-completing Observable).
+     *
+     * @returns A RxJS Observable telling if the key exists
      *
      * @example
      * this.storageMap.has('key').subscribe((hasKey) => {
@@ -1224,18 +1264,18 @@ class StorageMap {
      * });
      */
     has(key) {
-        return this.database.has(key)
+        return this.#database.has(key)
             /* Catch if `indexedDb` is broken */
-            .pipe(this.catchIDBBroken(() => this.database.has(key)));
+            .pipe(this.#catchIDBBroken(() => this.#database.has(key)));
     }
     watch(key, schema) {
         /* Check if there is already a notifier */
-        if (!this.notifiers.has(key)) {
-            this.notifiers.set(key, new ReplaySubject(1));
+        if (!this.#notifiers.has(key)) {
+            this.#notifiers.set(key, new ReplaySubject(1));
         }
         /* Non-null assertion is required because TypeScript doesn't narrow `.has()` yet */
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const notifier = this.notifiers.get(key);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Ensured by the logic
+        const notifier = this.#notifiers.get(key);
         /* Get the current item value */
         (schema ? this.get(key, schema) : this.get(key)).subscribe({
             next: (result) => {
@@ -1245,7 +1285,7 @@ class StorageMap {
                 notifier.error(error);
             },
         });
-        /* Only the public API of the `Observable` should be returned */
+        /* Only the public API of the Observable should be returned */
         return (schema ?
             notifier.asObservable() :
             notifier.asObservable());
@@ -1255,8 +1295,8 @@ class StorageMap {
      * @param key The item's key
      * @param data The new value
      */
-    notify(key, value) {
-        const notifier = this.notifiers.get(key);
+    #notify(key, value) {
+        const notifier = this.#notifiers.get(key);
         if (notifier) {
             notifier.next(value);
         }
@@ -1265,12 +1305,12 @@ class StorageMap {
      * RxJS operator to catch if `indexedDB` is broken
      * @param operationCallback Callback with the operation to redo
      */
-    catchIDBBroken(operationCallback) {
+    #catchIDBBroken(operationCallback) {
         return catchError((error) => {
             /* Check if `indexedDB` is broken based on error message (the specific error class seems to be lost in the process) */
             if ((error !== undefined) && (error !== null)
                 && (typeof error === "object") && ("message" in error)
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- Required because TypeScript narrowing is not working here
                 && (error.message === IDB_BROKEN_ERROR)) {
                 /* When storage is fully disabled in browser (via the "Block all cookies" option),
                  * just trying to check `localStorage` variable causes a security exception.
@@ -1279,16 +1319,16 @@ class StorageMap {
                 try {
                     if ("getItem" in localStorage) {
                         /* Fallback to `localStorage` if available */
-                        this.database = new LocalStorageDatabase();
+                        this.#database = new LocalStorageDatabase();
                     }
                     else {
                         /* Fallback to memory storage otherwise */
-                        this.database = new MemoryDatabase();
+                        this.#database = new MemoryDatabase();
                     }
                 }
                 catch {
                     /* Fallback to memory storage otherwise */
-                    this.database = new MemoryDatabase();
+                    this.#database = new MemoryDatabase();
                 }
                 /* Redo the operation */
                 return operationCallback();
@@ -1300,15 +1340,26 @@ class StorageMap {
             }
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: StorageMap, deps: [{ token: LocalDatabase }, { token: JSONValidator }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: StorageMap, providedIn: "root" }); }
+    /**
+     * THIS METHOD IS FOR INTERNAL PURPOSE ONLY AND MUST NOT BE USED,
+     * IT CAN BE REMOVED AT ANY TIME AND MESSING WITH IT CAN CAUSE ISSUES
+     * @private
+     * @ignore
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment, @typescript-eslint/prefer-ts-expect-error -- Silence the not used error, it is used in tests
+    // @ts-ignore
+    ɵinternalGetDatabase() {
+        return this.#database;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: StorageMap, deps: [{ token: LocalDatabase }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: StorageMap, providedIn: "root" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: StorageMap, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: StorageMap, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: "root"
                 }]
-        }], ctorParameters: () => [{ type: LocalDatabase }, { type: JSONValidator }] });
+        }], ctorParameters: () => [{ type: LocalDatabase }] });
 
 /*
  * Public API Surface of local-storage