@ngx-pwa/local-storage 14.0.0 → 16.0.0

package/{fesm2020 → fesm2022}/ngx-pwa-local-storage.mjs

@@ -1,266 +1,53 @@
-import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, inject, Inject, PLATFORM_ID, NgModule, makeEnvironmentProviders } from '@angular/core';
 import { isPlatformBrowser } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, PLATFORM_ID, makeEnvironmentProviders, NgModule } from '@angular/core';
 import { ReplaySubject, fromEvent, race, throwError, of, Observable, asyncScheduler, from } from 'rxjs';
 import { mergeMap, map, first, takeWhile, tap, observeOn, catchError } from 'rxjs/operators';
 
-class JSONValidator {
-    /**
-     * Validate a JSON data against a Jsubset of the JSON Schema standard.
-     * Types are enforced to validate everything: each schema must
-     * @param data JSON data to validate
-     * @param schema Subset of JSON Schema. Must have a `type`.
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/VALIDATION.md}
-     */
-    validate(data, schema) {
-        switch (schema.type) {
-            case 'string':
-                return this.validateString(data, schema);
-            case 'number':
-            case 'integer':
-                return this.validateNumber(data, schema);
-            case 'boolean':
-                return this.validateBoolean(data, schema);
-            case 'array':
-                return this.validateArray(data, schema);
-            case 'object':
-                return this.validateObject(data, schema);
-        }
-    }
-    /**
-     * Validate a string
-     * @param data Data to validate
-     * @param schema Schema describing the string
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateString(data, schema) {
-        if (typeof data !== 'string') {
-            return false;
-        }
-        if (!this.validateConst(data, schema)) {
-            return false;
-        }
-        if (!this.validateEnum(data, schema)) {
-            return false;
-        }
-        if ((schema.maxLength !== undefined) && (data.length > schema.maxLength)) {
-            return false;
-        }
-        if ((schema.minLength !== undefined) && (data.length < schema.minLength)) {
-            return false;
-        }
-        if (schema.pattern) {
-            let regularExpression = null;
-            try {
-                regularExpression = new RegExp(schema.pattern);
-            }
-            catch {
-                // Nothing to do
-            }
-            if (regularExpression && !regularExpression.test(data)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Validate a number or an integer
-     * @param data Data to validate
-     * @param schema Schema describing the number or integer
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateNumber(data, schema) {
-        if (typeof data !== 'number') {
-            return false;
-        }
-        if ((schema.type === 'integer') && !Number.isInteger(data)) {
-            return false;
-        }
-        if (!this.validateConst(data, schema)) {
-            return false;
-        }
-        if (!this.validateEnum(data, schema)) {
-            return false;
-        }
-        /* Test is done this way to not divide by 0 */
-        if (schema.multipleOf && !Number.isInteger(data / schema.multipleOf)) {
-            return false;
-        }
-        if ((schema.maximum !== undefined) && (data > schema.maximum)) {
-            return false;
-        }
-        if ((schema.exclusiveMaximum !== undefined) && (data >= schema.exclusiveMaximum)) {
-            return false;
-        }
-        if ((schema.minimum !== undefined) && (data < schema.minimum)) {
-            return false;
-        }
-        if ((schema.exclusiveMinimum !== undefined) && (data <= schema.exclusiveMinimum)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Validate a boolean
-     * @param data Data to validate
-     * @param schema Schema describing the boolean
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateBoolean(data, schema) {
-        if (typeof data !== 'boolean') {
-            return false;
-        }
-        if (!this.validateConst(data, schema)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Validate an array
-     * @param data Data to validate
-     * @param schema Schema describing the array
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateArray(data, schema) {
-        if (!Array.isArray(data)) {
-            return false;
-        }
-        if ((schema.maxItems !== undefined) && (data.length > schema.maxItems)) {
-            return false;
-        }
-        if ((schema.minItems !== undefined) && (data.length < schema.minItems)) {
-            return false;
-        }
-        if (schema.uniqueItems) {
-            /* Create a set to eliminate values with multiple occurences */
-            const dataSet = new Set(data);
-            if (data.length !== dataSet.size) {
-                return false;
-            }
-        }
-        /* Specific test for tuples */
-        if (Array.isArray(schema.items)) {
-            // TODO: cast should not be needed here
-            return this.validateTuple(data, schema.items);
-        }
-        /* Validate all the values in array */
-        for (const value of data) {
-            // TODO: remove when TypeScript 4.1 is available
-            // (currently the narrowed type from `Array.isArray()` is lost on readonly arrays)
-            if (!this.validate(value, schema.items)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Validate a tuple (array with fixed length and multiple types)
-     * @param data Data to validate
-     * @param schemas Schemas describing the tuple
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateTuple(data, schemas) {
-        /* Tuples have a fixed length */
-        if (data.length !== schemas.length) {
-            return false;
-        }
-        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])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Validate an object
-     * @param data Data to validate
-     * @param schema JSON schema describing the object
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateObject(data, schema) {
-        /* Check the type and if not `null` as `null` also have the type `object` in old browsers */
-        if ((typeof data !== 'object') || (data === null)) {
-            return false;
-        }
-        /* Check if the object doesn't have more properties than expected
-         * Equivalent of `additionalProperties: false`
-         */
-        if (Object.keys(schema.properties).length < Object.keys(data).length) {
-            return false;
-        }
-        /* Validate required properties */
-        if (schema.required) {
-            for (const requiredProp of schema.required) {
-                if (!Object.prototype.hasOwnProperty.call(data, requiredProp)) {
-                    return false;
-                }
-            }
-        }
-        /* 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 (!this.validate(data[property], schema.properties[property])) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Validate a constant
-     * @param data Data ta validate
-     * @param schema JSON schema describing the constant
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateConst(data, schema) {
-        if (!schema.const) {
-            return true;
-        }
-        return (data === schema.const);
+/**
+ * Exception message when `indexedDB` is not working
+ */
+const IDB_BROKEN_ERROR = "indexedDB is not working";
+/**
+ * Exception raised when `indexedDB` is not working
+ */
+class IDBBrokenError extends Error {
+    constructor() {
+        super(...arguments);
+        this.message = IDB_BROKEN_ERROR;
     }
-    /**
-     * Validate an enum
-     * @param data Data ta validate
-     * @param schema JSON schema describing the enum
-     * @returns If data is valid: `true`, if it is invalid: `false`
-     */
-    validateEnum(data, schema) {
-        if (!schema.enum) {
-            return true;
-        }
-        /* Cast as the data can be of multiple types, and so TypeScript is lost */
-        return (schema.enum.includes(data));
+}
+/**
+ * Exception message when a value can't 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`
+ */
+class SerializationError extends Error {
+    constructor() {
+        super(...arguments);
+        this.message = SERIALIZATION_ERROR;
     }
 }
-JSONValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: JSONValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-JSONValidator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: JSONValidator, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: JSONValidator, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
 
 /**
  * Token to provide a prefix to `localStorage` keys.
  */
-const LS_PREFIX = new InjectionToken('localStoragePrefix', {
-    providedIn: 'root',
-    factory: () => ''
+const LS_PREFIX = new InjectionToken("localStoragePrefix", {
+    providedIn: "root",
+    factory: () => ""
 });
 /**
  * Default name used for `indexedDB` database.
  */
-const DEFAULT_IDB_DB_NAME = 'ngStorage';
+const DEFAULT_IDB_DB_NAME = "ngStorage";
 /**
  * Token to provide `indexedDB` database name.
  */
-const IDB_DB_NAME = new InjectionToken('localStorageIDBDBName', {
-    providedIn: 'root',
+const IDB_DB_NAME = new InjectionToken("localStorageIDBDBName", {
+    providedIn: "root",
     factory: () => DEFAULT_IDB_DB_NAME
 });
 /**
@@ -271,20 +58,20 @@ const DEFAULT_IDB_DB_VERSION = 1;
  * Token to provide `indexedDB` database version.
  * Must be an unsigned **integer**.
  */
-const IDB_DB_VERSION = new InjectionToken('localStorageIDBDBVersion', {
-    providedIn: 'root',
+const IDB_DB_VERSION = new InjectionToken("localStorageIDBDBVersion", {
+    providedIn: "root",
     factory: () => DEFAULT_IDB_DB_VERSION
 });
 /**
  * Default name used for `indexedDB` object store.
  */
-const DEFAULT_IDB_STORE_NAME = 'localStorage';
+const DEFAULT_IDB_STORE_NAME = "localStorage";
 /**
  * Token to provide `indexedDB` store name.
  * For backward compatibility, the default can't be set now, `IndexedDBDatabase` will do it at runtime.
  */
-const IDB_STORE_NAME = new InjectionToken('localStorageIDBStoreName', {
-    providedIn: 'root',
+const IDB_STORE_NAME = new InjectionToken("localStorageIDBStoreName", {
+    providedIn: "root",
     factory: () => DEFAULT_IDB_STORE_NAME
 });
 /**
@@ -298,40 +85,12 @@ const DEFAULT_IDB_NO_WRAP = true;
  * Defaults to `true`. Change to `false` for backward compatiblity in existing applications.
  * **DO NOT CHANGE THIS BEHAVIOR ONCE IN PRODUCTION**, as it would break with existing data.
  */
-const IDB_NO_WRAP = new InjectionToken('localStorageIDBWrap', {
-    providedIn: 'root',
+const IDB_NO_WRAP = new InjectionToken("localStorageIDBWrap", {
+    providedIn: "root",
     factory: () => DEFAULT_IDB_NO_WRAP
 });
 
-/**
- * Exception message when `indexedDB` is not working
- */
-const IDB_BROKEN_ERROR = 'indexedDB is not working';
-/**
- * Exception raised when `indexedDB` is not working
- */
-class IDBBrokenError extends Error {
-    constructor() {
-        super(...arguments);
-        this.message = IDB_BROKEN_ERROR;
-    }
-}
-/**
- * Exception message when a value can't 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`
- */
-class SerializationError extends Error {
-    constructor() {
-        super(...arguments);
-        this.message = SERIALIZATION_ERROR;
-    }
-}
-
-class IndexedDBDatabase {
+class IndexedDBDatabase {
     constructor() {
         /**
          * `indexedDB` database connection, wrapped in a RxJS `ReplaySubject` to be able to access the connection
@@ -341,7 +100,7 @@ class IndexedDBDatabase {
         /**
          * Index used when wrapping value. *For backward compatibility only.*
          */
-        this.wrapIndex = 'value';
+        this.wrapIndex = "value";
         this.dbName = inject(IDB_DB_NAME);
         this.storeName = inject(IDB_STORE_NAME);
         this.dbVersion = inject(IDB_DB_VERSION);
@@ -365,7 +124,7 @@ class IndexedDBDatabase {
      */
     get size() {
         /* Open a transaction in read-only mode */
-        return this.transaction('readonly').pipe(mergeMap((transactionData) => {
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
             const { store, events } = transactionData;
             /* Request to know the number of items */
             const request = store.count();
@@ -382,7 +141,7 @@ class IndexedDBDatabase {
      */
     get(key) {
         /* Open a transaction in read-only mode */
-        return this.transaction('readonly').pipe(mergeMap((transactionData) => {
+        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);
@@ -390,7 +149,7 @@ class IndexedDBDatabase {
             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) &&
+                    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
@@ -420,7 +179,7 @@ class IndexedDBDatabase {
             return this.delete(key);
         }
         /* Open a transaction in write mode */
-        return this.transaction('readwrite').pipe(mergeMap((transactionData) => {
+        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 };
@@ -439,7 +198,7 @@ class IndexedDBDatabase {
      */
     delete(key) {
         /* Open a transaction in write mode */
-        return this.transaction('readwrite').pipe(mergeMap((transactionData) => {
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
             const { store, events } = transactionData;
             /* Delete the item in store */
             store.delete(key);
@@ -455,7 +214,7 @@ class IndexedDBDatabase {
      */
     clear() {
         /* Open a transaction in write mode */
-        return this.transaction('readwrite').pipe(mergeMap((transactionData) => {
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
             const { store, events } = transactionData;
             /* Delete all items in object store */
             store.clear();
@@ -471,7 +230,7 @@ class IndexedDBDatabase {
      */
     keys() {
         /* Open a transaction in read-only mode */
-        return this.transaction('readonly').pipe(
+        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 */
@@ -481,7 +240,7 @@ class IndexedDBDatabase {
              * 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(
+            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
@@ -501,7 +260,7 @@ class IndexedDBDatabase {
      */
     has(key) {
         /* Open a transaction in read-only mode */
-        return this.transaction('readonly').pipe(mergeMap((transactionData) => {
+        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
@@ -532,7 +291,7 @@ class IndexedDBDatabase {
         /* Create store on first connection */
         this.createStore(request);
         /* Listen to success and error events */
-        const success$ = fromEvent(request, 'success');
+        const success$ = fromEvent(request, "success");
         const error$ = this.listenError(request);
         /* Choose the first to occur */
         race([success$, error$])
@@ -557,7 +316,7 @@ class IndexedDBDatabase {
      */
     createStore(request) {
         /* Listen to the event fired on first connection */
-        fromEvent(request, 'upgradeneeded')
+        fromEvent(request, "upgradeneeded")
             /* The observable will complete */
             .pipe(first())
             .subscribe({
@@ -600,7 +359,7 @@ class IndexedDBDatabase {
      * @returns An `Observable` listening to errors
      */
     listenError(transactionOrRequest) {
-        return fromEvent(transactionOrRequest, 'error').pipe(
+        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 */
@@ -613,27 +372,27 @@ class IndexedDBDatabase {
      */
     listenTransactionEvents(transaction) {
         /* Listen to the `complete` event */
-        const complete$ = fromEvent(transaction, 'complete');
+        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: "16.0.0", ngImport: i0, type: IndexedDBDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IndexedDBDatabase, providedIn: "root" }); }
 }
-IndexedDBDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: IndexedDBDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-IndexedDBDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: IndexedDBDatabase, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: IndexedDBDatabase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IndexedDBDatabase, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: "root"
                 }]
         }], ctorParameters: function () { return []; } });
 
 class LocalStorageDatabase {
-    // `inject()` cannot be used here, as `LocalStorageDatabase` is instanciated at runtime in some scenarios
-    constructor(prefix = '') {
+    constructor() {
+        console.log('test');
         /* Prefix if asked, or no prefix otherwise */
-        this.prefix = prefix || '';
+        this.prefix = inject(LS_PREFIX) || "";
     }
     /**
      * Number of items in `localStorage`
@@ -674,7 +433,7 @@ class LocalStorageDatabase {
         let serializedData = null;
         /* Check if data can be serialized */
         const dataPrototype = Object.getPrototypeOf(data);
-        if ((typeof data === 'object') && (data !== null) && !Array.isArray(data) &&
+        if ((typeof data === "object") && (data !== null) && !Array.isArray(data) &&
             !((dataPrototype === Object.prototype) || (dataPrototype === null))) {
             return throwError(() => new SerializationError());
         }
@@ -758,7 +517,7 @@ class LocalStorageDatabase {
         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.substr(this.prefix.length);
+            return !this.prefix ? prefixedKey : prefixedKey.substring(this.prefix.length);
         }
         return null;
     }
@@ -770,18 +529,15 @@ class LocalStorageDatabase {
     prefixKey(key) {
         return `${this.prefix}${key}`;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageDatabase, providedIn: "root" }); }
 }
-LocalStorageDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalStorageDatabase, deps: [{ token: LS_PREFIX }], target: i0.ɵɵFactoryTarget.Injectable });
-LocalStorageDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalStorageDatabase, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalStorageDatabase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageDatabase, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: "root"
                 }]
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [LS_PREFIX]
-                }] }]; } });
+        }], ctorParameters: function () { return []; } });
 
 class MemoryDatabase {
     constructor() {
@@ -828,116 +584,472 @@ class MemoryDatabase {
         return of(undefined);
     }
     /**
-     * Deletes all items in memory
-     * @returns A RxJS `Observable` to wait the end of the operation
+     * Deletes all items in memory
+     * @returns A RxJS `Observable` to wait the end of the operation
+     */
+    clear() {
+        this.memoryStorage.clear();
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
+    }
+    /**
+     * Get all keys in memory
+     * @returns A RxJS `Observable` iterating on keys
+     */
+    keys() {
+        /* Create an `Observable` from keys */
+        return from(this.memoryStorage.keys());
+    }
+    /**
+     * Check if a key exists in memory
+     * @param key Key name
+     * @returns a RxJS `Observable` telling if the key exists or not
+     */
+    has(key) {
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(this.memoryStorage.has(key));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MemoryDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MemoryDatabase, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.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
+     */
+    try {
+        // Do not explicit `window` here, as the global object is not the same in web workers
+        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)
+            && (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: "16.0.0", ngImport: i0, type: LocalDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalDatabase, providedIn: "root", useFactory: localDatabaseFactory }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                    useFactory: localDatabaseFactory,
+                }]
+        }] });
+
+/**
+ * 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.**
+ *
+ * @example
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideLocalStoragePrefix('custom_')]
+ * });
+ *
+ * @example
+ * NgModule({
+ *   providers: [provideLocalStoragePrefix('custom_')]
+ * })
+ * export class AppModule
+ */
+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.**
+ *
+ * @example
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideIndexedDBDataBaseName('custom')]
+ * });
+ *
+ * @example
+ * NgModule({
+ *   providers: [provideIndexedDBDataBaseName('custom')]
+ * })
+ * export class AppModule
+ */
+function provideIndexedDBDataBaseName(name) {
+    return makeEnvironmentProviders([{ provide: IDB_DB_NAME, useValue: 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.**
+ *
+ * @example
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideIndexedDBDataBaseVersion(2)]
+ * });
+ *
+ * @example
+ * NgModule({
+ *   providers: [provideIndexedDBDataBaseVersion(2)]
+ * })
+ * export class AppModule
+ */
+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.**
+ *
+ * @example
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideIndexedDBStoreName('custom')]
+ * });
+ *
+ * @example
+ * NgModule({
+ *   providers: [provideIndexedDBStoreName('custom')]
+ * })
+ * export class AppModule
+ */
+function provideIndexedDBStoreName(name) {
+    return makeEnvironmentProviders([{ provide: IDB_STORE_NAME, useValue: name }]);
+}
+
+/**
+ * This module does not contain anything, it's only useful to provide options via `.forRoot()`.
+ */
+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.**
+     *
+     * @example
+     * NgModule({
+     *   imports: [StorageModule.forRoot({
+     *     LSPrefix: 'custom_',
+     *   })]
+     * })
+     * export class AppModule
+     */
+    static forRoot(config) {
+        return {
+            ngModule: StorageModule,
+            providers: [
+                config.LSPrefix ? { provide: LS_PREFIX, useValue: config.LSPrefix } : [],
+                config.IDBDBName ? { provide: IDB_DB_NAME, useValue: config.IDBDBName } : [],
+                config.IDBStoreName ? { provide: IDB_STORE_NAME, useValue: config.IDBStoreName } : [],
+                config.IDBDBVersion ? { provide: IDB_DB_VERSION, useValue: config.IDBDBVersion } : [],
+                (config.IDBNoWrap === false) ? { provide: IDB_NO_WRAP, useValue: config.IDBNoWrap } : [],
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: StorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: StorageModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: StorageModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: StorageModule, decorators: [{
+            type: NgModule
+        }] });
+
+/**
+ * Exception message when a value is not valid against the JSON schema
+ */
+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
+ */
+class ValidationError extends Error {
+    constructor() {
+        super(...arguments);
+        this.message = VALIDATION_ERROR;
+    }
+}
+
+class JSONValidator {
+    /**
+     * Validate a JSON data against a Jsubset of the JSON Schema standard.
+     * Types are enforced to validate everything: each schema must
+     * @param data JSON data to validate
+     * @param schema Subset of JSON Schema. Must have a `type`.
+     * @returns If data is valid: `true`, if it is invalid: `false`
+     * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/VALIDATION.md}
+     */
+    validate(data, schema) {
+        switch (schema.type) {
+            case "string":
+                return this.validateString(data, schema);
+            case "number":
+            case "integer":
+                return this.validateNumber(data, schema);
+            case "boolean":
+                return this.validateBoolean(data, schema);
+            case "array":
+                return this.validateArray(data, schema);
+            case "object":
+                return this.validateObject(data, schema);
+        }
+    }
+    /**
+     * Validate a string
+     * @param data Data to validate
+     * @param schema Schema describing the string
+     * @returns If data is valid: `true`, if it is invalid: `false`
+     */
+    validateString(data, schema) {
+        if (typeof data !== "string") {
+            return false;
+        }
+        if (!this.validateConst(data, schema)) {
+            return false;
+        }
+        if (!this.validateEnum(data, schema)) {
+            return false;
+        }
+        if ((schema.maxLength !== undefined) && (data.length > schema.maxLength)) {
+            return false;
+        }
+        if ((schema.minLength !== undefined) && (data.length < schema.minLength)) {
+            return false;
+        }
+        if (schema.pattern) {
+            let regularExpression = null;
+            try {
+                regularExpression = new RegExp(schema.pattern);
+            }
+            catch {
+                // Nothing to do
+            }
+            if (regularExpression && !regularExpression.test(data)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate a number or an integer
+     * @param data Data to validate
+     * @param schema Schema describing the number or integer
+     * @returns If data is valid: `true`, if it is invalid: `false`
+     */
+    validateNumber(data, schema) {
+        if (typeof data !== "number") {
+            return false;
+        }
+        if ((schema.type === "integer") && !Number.isInteger(data)) {
+            return false;
+        }
+        if (!this.validateConst(data, schema)) {
+            return false;
+        }
+        if (!this.validateEnum(data, schema)) {
+            return false;
+        }
+        /* Test is done this way to not divide by 0 */
+        if (schema.multipleOf && !Number.isInteger(data / schema.multipleOf)) {
+            return false;
+        }
+        if ((schema.maximum !== undefined) && (data > schema.maximum)) {
+            return false;
+        }
+        if ((schema.exclusiveMaximum !== undefined) && (data >= schema.exclusiveMaximum)) {
+            return false;
+        }
+        if ((schema.minimum !== undefined) && (data < schema.minimum)) {
+            return false;
+        }
+        if ((schema.exclusiveMinimum !== undefined) && (data <= schema.exclusiveMinimum)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Validate a boolean
+     * @param data Data to validate
+     * @param schema Schema describing the boolean
+     * @returns If data is valid: `true`, if it is invalid: `false`
+     */
+    validateBoolean(data, schema) {
+        if (typeof data !== "boolean") {
+            return false;
+        }
+        if (!this.validateConst(data, schema)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Validate an array
+     * @param data Data to validate
+     * @param schema Schema describing the array
+     * @returns If data is valid: `true`, if it is invalid: `false`
+     */
+    validateArray(data, schema) {
+        if (!Array.isArray(data)) {
+            return false;
+        }
+        if ((schema.maxItems !== undefined) && (data.length > schema.maxItems)) {
+            return false;
+        }
+        if ((schema.minItems !== undefined) && (data.length < schema.minItems)) {
+            return false;
+        }
+        if (schema.uniqueItems) {
+            /* Create a set to eliminate values with multiple occurences */
+            const dataSet = new Set(data);
+            if (data.length !== dataSet.size) {
+                return false;
+            }
+        }
+        /* Specific test for tuples */
+        if (Array.isArray(schema.items)) {
+            // TODO: cast should not be needed here
+            return this.validateTuple(data, schema.items);
+        }
+        /* Validate all the values in array */
+        for (const value of data) {
+            // TODO: remove when TypeScript 4.1 is available
+            // (currently the narrowed type from `Array.isArray()` is lost on readonly arrays)
+            if (!this.validate(value, schema.items)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate a tuple (array with fixed length and multiple types)
+     * @param data Data to validate
+     * @param schemas Schemas describing the tuple
+     * @returns If data is valid: `true`, if it is invalid: `false`
+     */
+    validateTuple(data, schemas) {
+        /* Tuples have a fixed length */
+        if (data.length !== schemas.length) {
+            return false;
+        }
+        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])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate an object
+     * @param data Data to validate
+     * @param schema JSON schema describing the object
+     * @returns If data is valid: `true`, if it is invalid: `false`
      */
-    clear() {
-        this.memoryStorage.clear();
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(undefined);
+    validateObject(data, schema) {
+        /* Check the type and if not `null` as `null` also have the type `object` in old browsers */
+        if ((typeof data !== "object") || (data === null)) {
+            return false;
+        }
+        /* Check if the object doesn't have more properties than expected
+         * Equivalent of `additionalProperties: false`
+         */
+        if (Object.keys(schema.properties).length < Object.keys(data).length) {
+            return false;
+        }
+        /* Validate required properties */
+        if (schema.required) {
+            for (const requiredProp of schema.required) {
+                if (!Object.prototype.hasOwnProperty.call(data, requiredProp)) {
+                    return false;
+                }
+            }
+        }
+        /* 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 (!this.validate(data[property], schema.properties[property])) {
+                    return false;
+                }
+            }
+        }
+        return true;
     }
     /**
-     * Get all keys in memory
-     * @returns A RxJS `Observable` iterating on keys
+     * Validate a constant
+     * @param data Data ta validate
+     * @param schema JSON schema describing the constant
+     * @returns If data is valid: `true`, if it is invalid: `false`
      */
-    keys() {
-        /* Create an `Observable` from keys */
-        return from(this.memoryStorage.keys());
+    validateConst(data, schema) {
+        if (!schema.const) {
+            return true;
+        }
+        return (data === schema.const);
     }
     /**
-     * Check if a key exists in memory
-     * @param key Key name
-     * @returns a RxJS `Observable` telling if the key exists or not
-     */
-    has(key) {
-        /* Wrap in a RxJS `Observable` to be consistent with other storages */
-        return of(this.memoryStorage.has(key));
-    }
-}
-MemoryDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: MemoryDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-MemoryDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: MemoryDatabase, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", 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
+     * Validate an enum
+     * @param data Data ta validate
+     * @param schema JSON schema describing the enum
+     * @returns If data is valid: `true`, if it is invalid: `false`
      */
-    try {
-        // Do not explicit `window` here, as the global object is not the same in web workers
-        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)
-            && (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();
+    validateEnum(data, schema) {
+        if (!schema.enum) {
+            return true;
         }
+        /* Cast as the data can be of multiple types, and so TypeScript is lost */
+        return (schema.enum.includes(data));
     }
-    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: "16.0.0", ngImport: i0, type: JSONValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: JSONValidator, providedIn: "root" }); }
 }
-LocalDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-LocalDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalDatabase, providedIn: 'root', useFactory: localDatabaseFactory });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalDatabase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: JSONValidator, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root',
-                    useFactory: localDatabaseFactory,
+                    providedIn: "root"
                 }]
         }] });
 
-/**
- * Exception message when a value is not valid against the JSON schema
- */
-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
- */
-class ValidationError extends Error {
-    constructor() {
-        super(...arguments);
-        this.message = VALIDATION_ERROR;
-    }
-}
-
 class StorageMap {
     /**
      * Constructor params are provided by Angular (but can also be passed manually in tests)
@@ -945,12 +1057,9 @@ class StorageMap {
      * @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(), 
-    // `inject()` cannot be used here, as `StorageMap` needs other manual params
-    LSPrefix = '') {
+    constructor(database, jsonValidator = new JSONValidator()) {
         this.database = database;
         this.jsonValidator = jsonValidator;
-        this.LSPrefix = LSPrefix;
         this.notifiers = new Map();
     }
     /**
@@ -982,16 +1091,16 @@ class StorageMap {
      */
     get backingEngine() {
         if (this.database instanceof IndexedDBDatabase) {
-            return 'indexedDB';
+            return "indexedDB";
         }
         else if (this.database instanceof LocalStorageDatabase) {
-            return 'localStorage';
+            return "localStorage";
         }
         else if (this.database instanceof MemoryDatabase) {
-            return 'memory';
+            return "memory";
         }
         else {
-            return 'unknown';
+            return "unknown";
         }
     }
     /**
@@ -1010,7 +1119,7 @@ class StorageMap {
     get backingStore() {
         return (this.database instanceof IndexedDBDatabase) ?
             this.database.backingStore :
-            { database: '', store: '', version: 0 };
+            { database: "", store: "", version: 0 };
     }
     /**
      * Info about `localStorage` fallback storage. *Only useful for interoperability.*
@@ -1028,7 +1137,7 @@ class StorageMap {
     get fallbackBackingStore() {
         return (this.database instanceof LocalStorageDatabase) ?
             { prefix: this.database.prefix } :
-            { prefix: '' };
+            { prefix: "" };
     }
     get(key, schema) {
         /* Get the data in storage */
@@ -1180,7 +1289,7 @@ class StorageMap {
         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)
+                && (typeof error === "object") && ("message" in error)
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 && (error.message === IDB_BROKEN_ERROR)) {
                 /* When storage is fully disabled in browser (via the "Block all cookies" option),
@@ -1188,9 +1297,9 @@ class StorageMap {
                  * Prevents https://github.com/cyrilletuzi/angular-async-local-storage/issues/118
                  */
                 try {
-                    if ('getItem' in localStorage) {
+                    if ("getItem" in localStorage) {
                         /* Fallback to `localStorage` if available */
-                        this.database = new LocalStorageDatabase(this.LSPrefix);
+                        this.database = new LocalStorageDatabase();
                     }
                     else {
                         /* Fallback to memory storage otherwise */
@@ -1211,24 +1320,17 @@ class StorageMap {
             }
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.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: "16.0.0", ngImport: i0, type: StorageMap, providedIn: "root" }); }
 }
-StorageMap.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: StorageMap, deps: [{ token: LocalDatabase }, { token: JSONValidator }, { token: LS_PREFIX }], target: i0.ɵɵFactoryTarget.Injectable });
-StorageMap.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: StorageMap, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: StorageMap, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: StorageMap, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: "root"
                 }]
-        }], ctorParameters: function () { return [{ type: LocalDatabase }, { type: JSONValidator }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [LS_PREFIX]
-                }] }]; } });
+        }], ctorParameters: function () { return [{ type: LocalDatabase }, { type: JSONValidator }]; } });
 
 class LocalStorage {
-    /* Use the `StorageMap` service to avoid code duplication */
-    constructor(storageMap) {
-        this.storageMap = storageMap;
-    }
     /**
      * Number of items in storage wrapped in an `Observable`
      *
@@ -1240,10 +1342,14 @@ class LocalStorage {
     get length() {
         return this.storageMap.size;
     }
+    /* Use the `StorageMap` service to avoid code duplication */
+    constructor(storageMap) {
+        this.storageMap = storageMap;
+    }
     getItem(key, schema) {
         if (schema) {
             /* Backward compatibility with version <= 7 */
-            schema = ('schema' in schema) ? schema.schema : schema;
+            schema = ("schema" in schema) ? schema.schema : schema;
         }
         return (schema ? this.storageMap.get(key, schema) : this.storageMap.get(key)).pipe(
         /* Transform `undefined` into `null` to align with `localStorage` API */
@@ -1290,131 +1396,16 @@ class LocalStorage {
         /* Transform `undefined` into `true` for backward compatibility with v7 */
         map(() => true));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorage, deps: [{ token: StorageMap }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorage, providedIn: "root" }); }
 }
-LocalStorage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalStorage, deps: [{ token: StorageMap }], target: i0.ɵɵFactoryTarget.Injectable });
-LocalStorage.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalStorage, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: LocalStorage, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorage, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: "root"
                 }]
         }], ctorParameters: function () { return [{ type: StorageMap }]; } });
 
-/**
- * This module does not contain anything, it's only useful to provide options via `.forRoot()`.
- */
-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.**
-     *
-     * @example
-     * NgModule({
-     *   imports: [StorageModule.forRoot({
-     *     LSPrefix: 'custom_',
-     *   })]
-     * })
-     * export class AppModule
-     */
-    static forRoot(config) {
-        return {
-            ngModule: StorageModule,
-            providers: [
-                config.LSPrefix ? { provide: LS_PREFIX, useValue: config.LSPrefix } : [],
-                config.IDBDBName ? { provide: IDB_DB_NAME, useValue: config.IDBDBName } : [],
-                config.IDBStoreName ? { provide: IDB_STORE_NAME, useValue: config.IDBStoreName } : [],
-                config.IDBDBVersion ? { provide: IDB_DB_VERSION, useValue: config.IDBDBVersion } : [],
-                (config.IDBNoWrap === false) ? { provide: IDB_NO_WRAP, useValue: config.IDBNoWrap } : [],
-            ],
-        };
-    }
-}
-StorageModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: StorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-StorageModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.4", ngImport: i0, type: StorageModule });
-StorageModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: StorageModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: StorageModule, decorators: [{
-            type: NgModule
-        }] });
-
-/**
- * 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.**
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideLocalStoragePrefix('custom_')]
- * });
- *
- * @example
- * NgModule({
- *   providers: [provideLocalStoragePrefix('custom_')]
- * })
- * export class AppModule
- */
-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.**
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideIndexedDBDataBaseName('custom')]
- * });
- *
- * @example
- * NgModule({
- *   providers: [provideIndexedDBDataBaseName('custom')]
- * })
- * export class AppModule
- */
-function provideIndexedDBDataBaseName(name) {
-    return makeEnvironmentProviders([{ provide: IDB_DB_NAME, useValue: 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.**
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideIndexedDBDataBaseVersion(2)]
- * });
- *
- * @example
- * NgModule({
- *   providers: [provideIndexedDBDataBaseVersion(2)]
- * })
- * export class AppModule
- */
-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.**
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideIndexedDBStoreName('custom')]
- * });
- *
- * @example
- * NgModule({
- *   providers: [provideIndexedDBStoreName('custom')]
- * })
- * export class AppModule
- */
-function provideIndexedDBStoreName(name) {
-    return makeEnvironmentProviders([{ provide: IDB_STORE_NAME, useValue: name }]);
-}
-
 /*
  * Public API Surface of local-storage
  */
@@ -1425,4 +1416,3 @@ function provideIndexedDBStoreName(name) {
 
 export { JSONValidator, LocalDatabase, LocalStorage, SERIALIZATION_ERROR, SerializationError, StorageMap, StorageModule, VALIDATION_ERROR, ValidationError, provideIndexedDBDataBaseName, provideIndexedDBDataBaseVersion, provideIndexedDBStoreName, provideLocalStoragePrefix };
 //# sourceMappingURL=ngx-pwa-local-storage.mjs.map
-//# sourceMappingURL=ngx-pwa-local-storage.mjs.map