@azure/msal-node-extensions 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/msal-node-extensions.esm.js

@@ -1,200 +1,14 @@
 import { promises } from 'fs';
 import { pid } from 'process';
-import { dirname } from 'path';
-import { Logger, LogLevel } from '@azure/msal-common';
+import path, { dirname } from 'path';
+import { Logger, LogLevel, StringUtils } from '@azure/msal-common';
 import { setPassword, getPassword, deletePassword } from 'keytar';
 
-// A type of promise-like that resolves synchronously and supports only one observer
-const _Pact = /*#__PURE__*/(function() {
-	function _Pact() {}
-	_Pact.prototype.then = function(onFulfilled, onRejected) {
-		const result = new _Pact();
-		const state = this.s;
-		if (state) {
-			const callback = state & 1 ? onFulfilled : onRejected;
-			if (callback) {
-				try {
-					_settle(result, 1, callback(this.v));
-				} catch (e) {
-					_settle(result, 2, e);
-				}
-				return result;
-			} else {
-				return this;
-			}
-		}
-		this.o = function(_this) {
-			try {
-				const value = _this.v;
-				if (_this.s & 1) {
-					_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
-				} else if (onRejected) {
-					_settle(result, 1, onRejected(value));
-				} else {
-					_settle(result, 2, value);
-				}
-			} catch (e) {
-				_settle(result, 2, e);
-			}
-		};
-		return result;
-	};
-	return _Pact;
-})();
-
-// Settles a pact synchronously
-function _settle(pact, state, value) {
-	if (!pact.s) {
-		if (value instanceof _Pact) {
-			if (value.s) {
-				if (state & 1) {
-					state = value.s;
-				}
-				value = value.v;
-			} else {
-				value.o = _settle.bind(null, pact, state);
-				return;
-			}
-		}
-		if (value && value.then) {
-			value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
-			return;
-		}
-		pact.s = state;
-		pact.v = value;
-		const observer = pact.o;
-		if (observer) {
-			observer(pact);
-		}
-	}
-}
-
-function _isSettledPact(thenable) {
-	return thenable instanceof _Pact && thenable.s & 1;
-}
-
-const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
-
-const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
-
-// Asynchronously implement a generic for loop
-function _for(test, update, body) {
-	var stage;
-	for (;;) {
-		var shouldContinue = test();
-		if (_isSettledPact(shouldContinue)) {
-			shouldContinue = shouldContinue.v;
-		}
-		if (!shouldContinue) {
-			return result;
-		}
-		if (shouldContinue.then) {
-			stage = 0;
-			break;
-		}
-		var result = body();
-		if (result && result.then) {
-			if (_isSettledPact(result)) {
-				result = result.s;
-			} else {
-				stage = 1;
-				break;
-			}
-		}
-		if (update) {
-			var updateValue = update();
-			if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
-				stage = 2;
-				break;
-			}
-		}
-	}
-	var pact = new _Pact();
-	var reject = _settle.bind(null, pact, 2);
-	(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
-	return pact;
-	function _resumeAfterBody(value) {
-		result = value;
-		do {
-			if (update) {
-				updateValue = update();
-				if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
-					updateValue.then(_resumeAfterUpdate).then(void 0, reject);
-					return;
-				}
-			}
-			shouldContinue = test();
-			if (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {
-				_settle(pact, 1, result);
-				return;
-			}
-			if (shouldContinue.then) {
-				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-				return;
-			}
-			result = body();
-			if (_isSettledPact(result)) {
-				result = result.v;
-			}
-		} while (!result || !result.then);
-		result.then(_resumeAfterBody).then(void 0, reject);
-	}
-	function _resumeAfterTest(shouldContinue) {
-		if (shouldContinue) {
-			result = body();
-			if (result && result.then) {
-				result.then(_resumeAfterBody).then(void 0, reject);
-			} else {
-				_resumeAfterBody(result);
-			}
-		} else {
-			_settle(pact, 1, result);
-		}
-	}
-	function _resumeAfterUpdate() {
-		if (shouldContinue = test()) {
-			if (shouldContinue.then) {
-				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-			} else {
-				_resumeAfterTest(shouldContinue);
-			}
-		} else {
-			_settle(pact, 1, result);
-		}
-	}
-}
-
-// Asynchronously call a function and send errors to recovery continuation
-function _catch(body, recover) {
-	try {
-		var result = body();
-	} catch(e) {
-		return recover(e);
-	}
-	if (result && result.then) {
-		return result.then(void 0, recover);
-	}
-	return result;
-}
-
-// Asynchronously await a promise and pass the result to a finally continuation
-function _finallyRethrows(body, finalizer) {
-	try {
-		var result = body();
-	} catch (e) {
-		return finalizer(true, e);
-	}
-	if (result && result.then) {
-		return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
-	}
-	return finalizer(false, result);
-}
-
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-var Constants = {
+const Constants = {
   /**
    * An existing file was the target of an operation that required that the target not exist
    */
@@ -208,108 +22,48 @@ var Constants = {
   ENOENT_ERROR: "ENOENT",
 
   /**
-   * Default service name for using MSAL Keytar
+   * Operation not permitted. An attempt was made to perform an operation that requires
+   * elevated privileges.
    */
-  DEFAULT_SERVICE_NAME: "msal-node-extensions"
-};
-
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-  subClass.__proto__ = superClass;
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-function _construct(Parent, args, Class) {
-  if (_isNativeReflectConstruct()) {
-    _construct = Reflect.construct;
-  } else {
-    _construct = function _construct(Parent, args, Class) {
-      var a = [null];
-      a.push.apply(a, args);
-      var Constructor = Function.bind.apply(Parent, a);
-      var instance = new Constructor();
-      if (Class) _setPrototypeOf(instance, Class.prototype);
-      return instance;
-    };
-  }
-
-  return _construct.apply(null, arguments);
-}
-
-function _isNativeFunction(fn) {
-  return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-
-function _wrapNativeSuper(Class) {
-  var _cache = typeof Map === "function" ? new Map() : undefined;
-
-  _wrapNativeSuper = function _wrapNativeSuper(Class) {
-    if (Class === null || !_isNativeFunction(Class)) return Class;
+  EPERM_ERROR: "EPERM",
 
-    if (typeof Class !== "function") {
-      throw new TypeError("Super expression must either be null or a function");
-    }
-
-    if (typeof _cache !== "undefined") {
-      if (_cache.has(Class)) return _cache.get(Class);
-
-      _cache.set(Class, Wrapper);
-    }
-
-    function Wrapper() {
-      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
-    }
+  /**
+   * Default service name for using MSAL Keytar
+   */
+  DEFAULT_SERVICE_NAME: "msal-node-extensions",
 
-    Wrapper.prototype = Object.create(Class.prototype, {
-      constructor: {
-        value: Wrapper,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    return _setPrototypeOf(Wrapper, Class);
-  };
+  /**
+   * Test data used to verify underlying persistence mechanism
+   */
+  PERSISTENCE_TEST_DATA: "Dummy data to verify underlying persistence mechanism",
 
-  return _wrapNativeSuper(Class);
-}
+  /**
+   * This is the value of a the guid if the process is being ran by the root user
+   */
+  LINUX_ROOT_USER_GUID: 0,
 
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
+  /**
+   * List of environment variables
+   */
+  ENVIRONMENT: {
+    HOME: "HOME",
+    LOGNAME: "LOGNAME",
+    USER: "USER",
+    LNAME: "LNAME",
+    USERNAME: "USERNAME",
+    PLATFORM: "platform",
+    LOCAL_APPLICATION_DATA: "LOCALAPPDATA"
+  },
+  // Name of the default cache file
+  DEFAULT_CACHE_FILE_NAME: "cache.json"
+};
+var Platform;
 
-  return self;
-}
+(function (Platform) {
+  Platform["WINDOWS"] = "win32";
+  Platform["LINUX"] = "linux";
+  Platform["MACOS"] = "darwin";
+})(Platform || (Platform = {}));
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -319,75 +73,113 @@ function _assertThisInitialized(self) {
 /**
  * Error thrown when trying to write MSAL cache to persistence.
  */
-var PersistenceError = /*#__PURE__*/function (_Error) {
-  _inheritsLoose(PersistenceError, _Error);
-
-  function PersistenceError(errorCode, errorMessage) {
-    var _this;
-
-    var errorString = errorMessage ? errorCode + ": " + errorMessage : errorCode;
-    _this = _Error.call(this, errorString) || this;
-    Object.setPrototypeOf(_assertThisInitialized(_this), PersistenceError.prototype);
-    _this.errorCode = errorCode;
-    _this.errorMessage = errorMessage;
-    _this.name = "PersistenceError";
-    return _this;
+class PersistenceError extends Error {
+  constructor(errorCode, errorMessage) {
+    const errorString = errorMessage ? `${errorCode}: ${errorMessage}` : errorCode;
+    super(errorString);
+    Object.setPrototypeOf(this, PersistenceError.prototype);
+    this.errorCode = errorCode;
+    this.errorMessage = errorMessage;
+    this.name = "PersistenceError";
   }
   /**
    * Error thrown when trying to access the file system.
    */
 
 
-  PersistenceError.createFileSystemError = function createFileSystemError(errorCode, errorMessage) {
+  static createFileSystemError(errorCode, errorMessage) {
     return new PersistenceError(errorCode, errorMessage);
   }
   /**
    * Error thrown when trying to write, load, or delete data from secret service on linux.
    * Libsecret is used to access secret service.
    */
-  ;
 
-  PersistenceError.createLibSecretError = function createLibSecretError(errorCode, errorMessage) {
-    var updatedErrorMessage = "Error accessing Gnome Keyring: " + errorCode + "- " + errorMessage;
-    return new PersistenceError("GnomeKeyringError", updatedErrorMessage);
+
+  static createLibSecretError(errorMessage) {
+    return new PersistenceError("GnomeKeyringError", errorMessage);
   }
   /**
    * Error thrown when trying to write, load, or delete data from keychain on macOs.
    */
-  ;
 
-  PersistenceError.createKeychainPersistenceError = function createKeychainPersistenceError(errorCode, errorMessage) {
-    var updatedErrorMessage = "Error accessing Keychain: " + errorCode + "- " + errorMessage;
-    return new PersistenceError("KeychainError", updatedErrorMessage);
+
+  static createKeychainPersistenceError(errorMessage) {
+    return new PersistenceError("KeychainError", errorMessage);
   }
   /**
    * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
    */
-  ;
 
-  PersistenceError.createFilePersistenceWithDPAPIError = function createFilePersistenceWithDPAPIError(errorCode, errorMessage) {
-    var updatedErrorMessage = "Error accessing DPAPI encrypted file: " + errorCode + "- " + errorMessage;
-    return new PersistenceError("DPAPIEncryptedFileError", updatedErrorMessage);
+
+  static createFilePersistenceWithDPAPIError(errorMessage) {
+    return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
   }
   /**
    * Error thrown when using the cross platform lock.
    */
-  ;
 
-  PersistenceError.createCrossPlatformLockError = function createCrossPlatformLockError(errorCode, errorMessage) {
-    var updatedErrorMessage = "Error acquiring lock: " + errorCode + "- " + errorMessage;
-    return new PersistenceError("CrossPlatformLockError", updatedErrorMessage);
-  };
 
-  return PersistenceError;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
+  static createCrossPlatformLockError(errorMessage) {
+    return new PersistenceError("CrossPlatformLockError", errorMessage);
+  }
+  /**
+   * Throw cache persistence error
+   *
+   * @param errorMessage string
+   * @returns PersistenceError
+   */
+
 
+  static createCachePersistenceError(errorMessage) {
+    return new PersistenceError("CachePersistenceError", errorMessage);
+  }
+  /**
+   * Throw unsupported error
+   *
+   * @param errorMessage string
+   * @returns PersistenceError
+   */
+
+
+  static createNotSupportedError(errorMessage) {
+    return new PersistenceError("NotSupportedError", errorMessage);
+  }
+  /**
+   * Throw persistence not verified error
+   *
+   * @param errorMessage string
+   * @returns PersistenceError
+   */
+
+
+  static createPersistenceNotVerifiedError(errorMessage) {
+    return new PersistenceError("PersistenceNotVerifiedError", errorMessage);
+  }
+  /**
+   * Throw persistence creation validation error
+   *
+   * @param errorMessage string
+   * @returns PersistenceError
+   */
+
+
+  static createPersistenceNotValidatedError(errorMessage) {
+    return new PersistenceError("PersistenceNotValidatedError", errorMessage);
+  }
+
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 /**
  * Cross-process lock that works on all platforms.
  */
 
-var CrossPlatformLock = /*#__PURE__*/function () {
-  function CrossPlatformLock(lockFilePath, logger, lockOptions) {
+class CrossPlatformLock {
+  constructor(lockFilePath, logger, lockOptions) {
     this.lockFilePath = lockFilePath;
     this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
     this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
@@ -400,91 +192,65 @@ var CrossPlatformLock = /*#__PURE__*/function () {
    */
 
 
-  var _proto = CrossPlatformLock.prototype;
-
-  _proto.lock = function lock() {
-    try {
-      var _temp3 = function _temp3(_result3) {
-        if (_exit2) return _result3;
-        throw PersistenceError.createCrossPlatformLockError("Exceeded retry options", "Not able to acquire lock. Exceeded amount of retries set in options");
-      };
-
-      var _exit2 = false;
-
-      var _this2 = this;
-
-      var _tryCount = 0;
-
-      var _temp4 = _for(function () {
-        return !_exit2 && _tryCount < _this2.retryNumber;
-      }, function () {
-        return _tryCount++;
-      }, function () {
-        return _catch(function () {
-          _this2.logger.info("Pid " + pid + " trying to acquire lock");
-
-          return Promise.resolve(promises.open(_this2.lockFilePath, "wx+")).then(function (_fs$open) {
-            _this2.lockFileHandle = _fs$open;
-
-            _this2.logger.info("Pid " + pid + " acquired lock");
-
-            return Promise.resolve(_this2.lockFileHandle.write(pid.toString())).then(function () {
-              _exit2 = true;
-            });
-          });
-        }, function (err) {
-          return function () {
-            if (err.code == Constants.EEXIST_ERROR) {
-              _this2.logger.info(err);
-
-              return Promise.resolve(_this2.sleep(_this2.retryDelay)).then(function () {});
-            } else {
-              throw PersistenceError.createCrossPlatformLockError(err.code, err.message);
-            }
-          }();
-        });
-      });
-
-      return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(_temp3) : _temp3(_temp4));
-    } catch (e) {
-      return Promise.reject(e);
+  async lock() {
+    for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
+      try {
+        this.logger.info(`Pid ${pid} trying to acquire lock`);
+        this.lockFileHandle = await promises.open(this.lockFilePath, "wx+");
+        this.logger.info(`Pid ${pid} acquired lock`);
+        await this.lockFileHandle.write(pid.toString());
+        return;
+      } catch (err) {
+        if (err.code === Constants.EEXIST_ERROR || err.code === Constants.EPERM_ERROR) {
+          this.logger.info(err);
+          await this.sleep(this.retryDelay);
+        } else {
+          this.logger.error(`${pid} was not able to acquire lock. Ran into error: ${err.message}`);
+          throw PersistenceError.createCrossPlatformLockError(err.message);
+        }
+      }
     }
+
+    this.logger.error(`${pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
+    throw PersistenceError.createCrossPlatformLockError("Not able to acquire lock. Exceeded amount of retries set in options");
   }
   /**
    * unlocks cache file by deleting .lockfile.
    */
-  ;
 
-  _proto.unlock = function unlock() {
+
+  async unlock() {
     try {
-      var _this4 = this;
-
-      return Promise.resolve(_catch(function () {
-        // delete lock file
-        return Promise.resolve(promises.unlink(_this4.lockFilePath)).then(function () {
-          return Promise.resolve(_this4.lockFileHandle.close()).then(function () {});
-        });
-      }, function (err) {
-        if (err.code == Constants.ENOENT_ERROR) {
-          _this4.logger.warning("Tried to unlock but Lockfile does not exist");
-        } else {
-          throw PersistenceError.createCrossPlatformLockError(err.code, err.message);
-        }
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      if (this.lockFileHandle) {
+        // if we have a file handle to the .lockfile, delete lock file
+        await promises.unlink(this.lockFilePath);
+        await this.lockFileHandle.close();
+        this.logger.info("lockfile deleted");
+      } else {
+        this.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
+      }
+    } catch (err) {
+      if (err.code === Constants.ENOENT_ERROR) {
+        this.logger.info("Tried to unlock but lockfile does not exist");
+      } else {
+        this.logger.error(`${pid} was not able to release lock. Ran into error: ${err.message}`);
+        throw PersistenceError.createCrossPlatformLockError(err.message);
+      }
     }
-  };
+  }
 
-  _proto.sleep = function sleep(ms) {
-    return new Promise(function (resolve) {
+  sleep(ms) {
+    return new Promise(resolve => {
       setTimeout(resolve, ms);
     });
-  };
+  }
 
-  return CrossPlatformLock;
-}();
+}
 
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 /**
  * MSAL cache plugin which enables callers to write the MSAL cache to disk on Windows,
  * macOs, and Linux.
@@ -499,125 +265,115 @@ var CrossPlatformLock = /*#__PURE__*/function () {
  * libsecret be installed.
  */
 
-var PersistenceCachePlugin = /*#__PURE__*/function () {
-  function PersistenceCachePlugin(persistence, lockOptions) {
+class PersistenceCachePlugin {
+  constructor(persistence, lockOptions) {
     this.persistence = persistence; // initialize logger
 
     this.logger = persistence.getLogger(); // create file lock
 
-    this.lockFilePath = this.persistence.getFilePath() + ".lockfile";
+    this.lockFilePath = `${this.persistence.getFilePath()}.lockfile`;
     this.crossPlatformLock = new CrossPlatformLock(this.lockFilePath, this.logger, lockOptions); // initialize default values
 
     this.lastSync = 0;
     this.currentCache = null;
   }
   /**
-   * Reads from storage and avoids saves an in memory copy. If persistence has not been updated
+   * Reads from storage and saves an in-memory copy. If persistence has not been updated
    * since last time data was read, in memory copy is used.
+   *
+   * If cacheContext.cacheHasChanged === true, then file lock is created and not deleted until
+   * afterCacheAccess() is called, to prevent the cache file from changing in between
+   * beforeCacheAccess() and afterCacheAccess().
    */
 
 
-  var _proto = PersistenceCachePlugin.prototype;
-
-  _proto.readFromStorage = function readFromStorage() {
-    try {
-      var _this2 = this;
-
-      _this2.logger.info("Reading from storage");
+  async beforeCacheAccess(cacheContext) {
+    this.logger.info("Executing before cache access");
+    const reloadNecessary = await this.persistence.reloadNecessary(this.lastSync);
 
-      return Promise.resolve(_this2.persistence.reloadNecessary(_this2.lastSync)).then(function (_this$persistence$rel) {
-        function _temp3() {
-          return _this2.currentCache;
-        }
+    if (!reloadNecessary && this.currentCache !== null) {
+      if (cacheContext.cacheHasChanged) {
+        this.logger.verbose("Cache context has changed");
+        await this.crossPlatformLock.lock();
+      }
 
-        var _temp2 = function () {
-          if (_this$persistence$rel || _this2.currentCache == null) {
-            var _temp4 = _finallyRethrows(function () {
-              _this2.logger.info("Reload necessary. Last sync time: " + _this2.lastSync);
-
-              return Promise.resolve(_this2.crossPlatformLock.lock()).then(function () {
-                return Promise.resolve(_this2.persistence.load()).then(function (_this$persistence$loa) {
-                  _this2.currentCache = _this$persistence$loa;
-                  _this2.lastSync = new Date().getTime();
-
-                  _this2.logger.info("Last sync time updated to: " + _this2.lastSync);
-                });
-              });
-            }, function (_wasThrown, _result) {
-              return Promise.resolve(_this2.crossPlatformLock.unlock()).then(function () {
-                _this2.logger.info("Pid " + pid + " Released lock");
-
-                if (_wasThrown) throw _result;
-                return _result;
-              });
-            });
-
-            if (_temp4 && _temp4.then) return _temp4.then(function () {});
-          }
-        }();
+      return;
+    }
 
-        return _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
-      });
-    } catch (e) {
-      return Promise.reject(e);
+    try {
+      this.logger.info(`Reload necessary. Last sync time: ${this.lastSync}`);
+      await this.crossPlatformLock.lock();
+      this.currentCache = await this.persistence.load();
+      this.lastSync = new Date().getTime();
+      cacheContext.tokenCache.deserialize(this.currentCache);
+      this.logger.info(`Last sync time updated to: ${this.lastSync}`);
+    } finally {
+      if (!cacheContext.cacheHasChanged) {
+        await this.crossPlatformLock.unlock();
+        this.logger.info(`Pid ${pid} released lock`);
+      } else {
+        this.logger.info(`Pid ${pid} beforeCacheAccess did not release lock`);
+      }
     }
   }
   /**
-   * Writes to storage. If persistence has not been updated since last time data was read,
-   * reads and latest state from persistence, sends state via callback, and updates in memory copy.
+   * Writes to storage if MSAL in memory copy of cache has been changed.
    */
-  ;
 
-  _proto.writeToStorage = function writeToStorage(callback) {
+
+  async afterCacheAccess(cacheContext) {
+    this.logger.info("Executing after cache access");
+
     try {
-      var _this4 = this;
-
-      var _temp8 = _finallyRethrows(function () {
-        _this4.logger.info("Writing to storage");
-
-        return Promise.resolve(_this4.crossPlatformLock.lock()).then(function () {
-          return Promise.resolve(_this4.persistence.reloadNecessary(_this4.lastSync)).then(function (_this3$persistence$re) {
-            function _temp6() {
-              return Promise.resolve(callback(_this4.currentCache)).then(function (_callback) {
-                _this4.currentCache = _callback;
-                return Promise.resolve(_this4.persistence.save(_this4.currentCache)).then(function () {});
-              });
-            }
-
-            var _temp5 = function () {
-              if (_this3$persistence$re) {
-                _this4.logger.info("Reload necessary. Last sync time: " + _this4.lastSync);
-
-                return Promise.resolve(_this4.persistence.load()).then(function (_this3$persistence$lo) {
-                  _this4.currentCache = _this3$persistence$lo;
-                  _this4.lastSync = new Date().getTime();
-
-                  _this4.logger.info("Last sync time updated to: " + _this4.lastSync);
-                });
-              }
-            }();
-
-            return _temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5);
-          });
-        });
-      }, function (_wasThrown2, _result2) {
-        return Promise.resolve(_this4.crossPlatformLock.unlock()).then(function () {
-          _this4.logger.info("Pid " + pid + " Released lock");
-
-          if (_wasThrown2) throw _result2;
-          return _result2;
-        });
-      });
+      if (cacheContext.cacheHasChanged) {
+        this.logger.info("Msal in-memory cache has changed. Writing changes to persistence");
+        this.currentCache = cacheContext.tokenCache.serialize();
+        await this.persistence.save(this.currentCache);
+      } else {
+        this.logger.info("Msal in-memory cache has not changed. Did not write to persistence");
+      }
+    } finally {
+      await this.crossPlatformLock.unlock();
+      this.logger.info(`Pid ${pid} afterCacheAccess released lock`);
+    }
+  }
 
-      return Promise.resolve(_temp8 && _temp8.then ? _temp8.then(function () {}) : void 0);
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class BasePersistence {
+  async verifyPersistence() {
+    // We are using a different location for the test to avoid overriding the functional cache
+    const persistenceValidator = await this.createForPersistenceValidation();
+
+    try {
+      await persistenceValidator.save(Constants.PERSISTENCE_TEST_DATA);
+      const retrievedDummyData = await persistenceValidator.load();
+
+      if (!retrievedDummyData) {
+        throw PersistenceError.createCachePersistenceError("Persistence check failed. Data was written but it could not be read. " + "Possible cause: on Linux, LibSecret is installed but D-Bus isn't running because it cannot be started over SSH.");
+      }
+
+      if (retrievedDummyData !== Constants.PERSISTENCE_TEST_DATA) {
+        throw PersistenceError.createCachePersistenceError(`Persistence check failed. Data written ${Constants.PERSISTENCE_TEST_DATA} is different from data read ${retrievedDummyData}`);
+      }
+
+      await persistenceValidator.delete();
+      return true;
     } catch (e) {
-      return Promise.reject(e);
+      throw PersistenceError.createCachePersistenceError(`Verifing persistence failed with the error: ${e}`);
     }
-  };
+  }
 
-  return PersistenceCachePlugin;
-}();
+}
 
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 /**
  * Reads and writes data to file specified by file location. File contents are not
  * encrypted.
@@ -626,201 +382,165 @@ var PersistenceCachePlugin = /*#__PURE__*/function () {
  * file and any directories in the path recursively.
  */
 
-var FilePersistence = /*#__PURE__*/function () {
-  function FilePersistence() {}
-
-  FilePersistence.create = function create(fileLocation, loggerOptions) {
-    try {
-      var filePersistence = new FilePersistence();
-      filePersistence.filePath = fileLocation;
-      filePersistence.logger = new Logger(loggerOptions || FilePersistence.createDefaultLoggerOptions());
-      return Promise.resolve(filePersistence.createCacheFile()).then(function () {
-        return filePersistence;
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  var _proto = FilePersistence.prototype;
+class FilePersistence extends BasePersistence {
+  static async create(fileLocation, loggerOptions) {
+    const filePersistence = new FilePersistence();
+    filePersistence.filePath = fileLocation;
+    filePersistence.logger = new Logger(loggerOptions || FilePersistence.createDefaultLoggerOptions());
+    await filePersistence.createCacheFile();
+    return filePersistence;
+  }
 
-  _proto.save = function save(contents) {
+  async save(contents) {
     try {
-      var _this2 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.writeFile(_this2.getFilePath(), contents, "utf-8")).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      await promises.writeFile(this.getFilePath(), contents, "utf-8");
+    } catch (err) {
+      throw PersistenceError.createFileSystemError(err.code, err.message);
     }
-  };
+  }
 
-  _proto.saveBuffer = function saveBuffer(contents) {
+  async saveBuffer(contents) {
     try {
-      var _this4 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.writeFile(_this4.getFilePath(), contents)).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      await promises.writeFile(this.getFilePath(), contents);
+    } catch (err) {
+      throw PersistenceError.createFileSystemError(err.code, err.message);
     }
-  };
+  }
 
-  _proto.load = function load() {
+  async load() {
     try {
-      var _this6 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.readFile(_this6.getFilePath(), "utf-8"));
-      }, function (err) {
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      return await promises.readFile(this.getFilePath(), "utf-8");
+    } catch (err) {
+      throw PersistenceError.createFileSystemError(err.code, err.message);
     }
-  };
+  }
 
-  _proto.loadBuffer = function loadBuffer() {
+  async loadBuffer() {
     try {
-      var _this8 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.readFile(_this8.getFilePath()));
-      }, function (err) {
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      return await promises.readFile(this.getFilePath());
+    } catch (err) {
+      throw PersistenceError.createFileSystemError(err.code, err.message);
     }
-  };
+  }
 
-  _proto["delete"] = function _delete() {
+  async delete() {
     try {
-      var _this10 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.unlink(_this10.getFilePath())).then(function () {
-          return true;
-        });
-      }, function (err) {
-        if (err.code == Constants.ENOENT_ERROR) {
-          // file does not exist, so it was not deleted
-          _this10.logger.warning("Cache file does not exist, so it could not be deleted");
-
-          return false;
-        }
+      await promises.unlink(this.getFilePath());
+      return true;
+    } catch (err) {
+      if (err.code === Constants.ENOENT_ERROR) {
+        // file does not exist, so it was not deleted
+        this.logger.warning("Cache file does not exist, so it could not be deleted");
+        return false;
+      }
 
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      throw PersistenceError.createFileSystemError(err.code, err.message);
     }
-  };
+  }
 
-  _proto.getFilePath = function getFilePath() {
+  getFilePath() {
     return this.filePath;
-  };
-
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
-    try {
-      var _this12 = this;
+  }
 
-      return Promise.resolve(_this12.timeLastModified()).then(function (_this11$timeLastModif) {
-        return lastSync < _this11$timeLastModif;
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+  async reloadNecessary(lastSync) {
+    return lastSync < (await this.timeLastModified());
+  }
 
-  _proto.getLogger = function getLogger() {
+  getLogger() {
     return this.logger;
-  };
+  }
+
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePath)}/test.cache`;
+    return FilePersistence.create(testCacheFileLocation);
+  }
 
-  FilePersistence.createDefaultLoggerOptions = function createDefaultLoggerOptions() {
+  static createDefaultLoggerOptions() {
     return {
-      loggerCallback: function loggerCallback() {// allow users to not set loggerCallback
+      loggerCallback: () => {// allow users to not set loggerCallback
       },
       piiLoggingEnabled: false,
       logLevel: LogLevel.Info
     };
-  };
+  }
 
-  _proto.timeLastModified = function timeLastModified() {
+  async timeLastModified() {
     try {
-      var _this14 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.stat(_this14.filePath)).then(function (stats) {
-          return stats.mtime.getTime();
-        });
-      }, function (err) {
-        if (err.code == Constants.ENOENT_ERROR) {
-          // file does not exist, so it's never been modified
-          _this14.logger.verbose("Cache file does not exist");
-
-          return 0;
-        }
+      const stats = await promises.stat(this.filePath);
+      return stats.mtime.getTime();
+    } catch (err) {
+      if (err.code === Constants.ENOENT_ERROR) {
+        // file does not exist, so it's never been modified
+        this.logger.verbose("Cache file does not exist");
+        return 0;
+      }
 
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      throw PersistenceError.createFileSystemError(err.code, err.message);
     }
-  };
+  }
+
+  async createCacheFile() {
+    await this.createFileDirectory(); // File is created only if it does not exist
+
+    const fileHandle = await promises.open(this.filePath, "a");
+    await fileHandle.close();
+    this.logger.info(`File created at ${this.filePath}`);
+  }
 
-  _proto.createCacheFile = function createCacheFile() {
+  async createFileDirectory() {
     try {
-      var _this16 = this;
-
-      return Promise.resolve(_this16.createFileDirectory()).then(function () {
-        // File is created only if it does not exist
-        return Promise.resolve(promises.open(_this16.filePath, "a")).then(function (fileHandle) {
-          return Promise.resolve(fileHandle.close()).then(function () {
-            _this16.logger.info("File created at " + _this16.filePath);
-          });
-        });
+      await promises.mkdir(dirname(this.filePath), {
+        recursive: true
       });
-    } catch (e) {
-      return Promise.reject(e);
+    } catch (err) {
+      if (err.code === Constants.EEXIST_ERROR) {
+        this.logger.info(`Directory ${dirname(this.filePath)}  already exists`);
+      } else {
+        throw PersistenceError.createFileSystemError(err.code, err.message);
+      }
     }
-  };
+  }
 
-  _proto.createFileDirectory = function createFileDirectory() {
-    try {
-      var _this18 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(promises.mkdir(dirname(_this18.filePath), {
-          recursive: true
-        })).then(function () {});
-      }, function (err) {
-        if (err.code == Constants.EEXIST_ERROR) {
-          _this18.logger.info("Directory " + dirname(_this18.filePath) + "  already exists");
-        } else {
-          throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 
-  return FilePersistence;
-}();
+/* eslint-disable-next-line @typescript-eslint/no-var-requires, no-var, import/no-commonjs */
+var Dpapi = /*#__PURE__*/require("bindings")({
+  bindings: "dpapi",
+  userDefinedTries: [["module_root", "node_modules", "@azure", "msal-node-extensions", "build", "Release", "bindings"]]
+});
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-var Dpapi = /*#__PURE__*/require("bindings")("dpapi");
 
+/**
+ * Specifies the scope of the data protection - either the current user or the local
+ * machine.
+ *
+ * You do not need a key to protect or unprotect the data.
+ * If you set the Scope to CurrentUser, only applications running on your credentials can
+ * unprotect the data; however, that means that any application running on your credentials
+ * can access the protected data. If you set the Scope to LocalMachine, any full-trust
+ * application on the computer can unprotect, access, and modify the data.
+ *
+ */
+var DataProtectionScope;
+
+(function (DataProtectionScope) {
+  DataProtectionScope["CurrentUser"] = "CurrentUser";
+  DataProtectionScope["LocalMachine"] = "LocalMachine";
+})(DataProtectionScope || (DataProtectionScope = {}));
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 /**
  * Uses CryptProtectData and CryptUnprotectData on Windows to encrypt and decrypt file contents.
  *
@@ -828,117 +548,70 @@ var Dpapi = /*#__PURE__*/require("bindings")("dpapi");
  * optionalEntropy: Password or other additional entropy used to encrypt the data
  */
 
-var FilePersistenceWithDataProtection = /*#__PURE__*/function () {
-  function FilePersistenceWithDataProtection(scope, optionalEntropy) {
+class FilePersistenceWithDataProtection extends BasePersistence {
+  constructor(scope, optionalEntropy) {
+    super();
     this.scope = scope;
     this.optionalEntropy = optionalEntropy ? Buffer.from(optionalEntropy, "utf-8") : null;
   }
 
-  FilePersistenceWithDataProtection.create = function create(fileLocation, scope, optionalEntropy, loggerOptions) {
-    try {
-      var persistence = new FilePersistenceWithDataProtection(scope, optionalEntropy);
-      return Promise.resolve(FilePersistence.create(fileLocation, loggerOptions)).then(function (_FilePersistence$crea) {
-        persistence.filePersistence = _FilePersistence$crea;
-        return persistence;
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  var _proto = FilePersistenceWithDataProtection.prototype;
+  static async create(fileLocation, scope, optionalEntropy, loggerOptions) {
+    const persistence = new FilePersistenceWithDataProtection(scope, optionalEntropy);
+    persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+    return persistence;
+  }
 
-  _proto.save = function save(contents) {
+  async save(contents) {
     try {
-      var _this2 = this;
-
-      return Promise.resolve(_catch(function () {
-        var encryptedContents = Dpapi.protectData(Buffer.from(contents, "utf-8"), _this2.optionalEntropy, _this2.scope.toString());
-        return Promise.resolve(_this2.filePersistence.saveBuffer(encryptedContents)).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createFilePersistenceWithDPAPIError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      const encryptedContents = Dpapi.protectData(Buffer.from(contents, "utf-8"), this.optionalEntropy, this.scope.toString());
+      await this.filePersistence.saveBuffer(encryptedContents);
+    } catch (err) {
+      throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
     }
-  };
+  }
 
-  _proto.load = function load() {
+  async load() {
     try {
-      var _this4 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(_this4.filePersistence.loadBuffer()).then(function (encryptedContents) {
-          if (typeof encryptedContents === "undefined" || !encryptedContents || 0 === encryptedContents.length) {
-            _this4.filePersistence.getLogger().info("Encrypted contents loaded from file were null or empty");
+      const encryptedContents = await this.filePersistence.loadBuffer();
 
-            return null;
-          }
-
-          return Dpapi.unprotectData(encryptedContents, _this4.optionalEntropy, _this4.scope.toString()).toString();
-        });
-      }, function (err) {
-        throw PersistenceError.createFilePersistenceWithDPAPIError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  _proto["delete"] = function _delete() {
-    try {
-      var _this6 = this;
+      if (typeof encryptedContents === "undefined" || !encryptedContents || 0 === encryptedContents.length) {
+        this.filePersistence.getLogger().info("Encrypted contents loaded from file were null or empty");
+        return null;
+      }
 
-      return Promise.resolve(_this6.filePersistence["delete"]());
-    } catch (e) {
-      return Promise.reject(e);
+      return Dpapi.unprotectData(encryptedContents, this.optionalEntropy, this.scope.toString()).toString();
+    } catch (err) {
+      throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
     }
-  };
+  }
 
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
-    try {
-      var _this8 = this;
+  async delete() {
+    return this.filePersistence.delete();
+  }
 
-      return Promise.resolve(_this8.filePersistence.reloadNecessary(lastSync));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+  async reloadNecessary(lastSync) {
+    return this.filePersistence.reloadNecessary(lastSync);
+  }
 
-  _proto.getFilePath = function getFilePath() {
+  getFilePath() {
     return this.filePersistence.getFilePath();
-  };
+  }
 
-  _proto.getLogger = function getLogger() {
+  getLogger() {
     return this.filePersistence.getLogger();
-  };
+  }
 
-  return FilePersistenceWithDataProtection;
-}();
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+    return FilePersistenceWithDataProtection.create(testCacheFileLocation, DataProtectionScope.CurrentUser);
+  }
+
+}
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
-/**
- * Specifies the scope of the data protection - either the current user or the local
- * machine.
- *
- * You do not need a key to protect or unprotect the data.
- * If you set the Scope to CurrentUser, only applications running on your credentials can
- * unprotect the data; however, that means that any application running on your credentials
- * can access the protected data. If you set the Scope to LocalMachine, any full-trust
- * application on the computer can unprotect, access, and modify the data.
- *
- */
-var DataProtectionScope;
-
-(function (DataProtectionScope) {
-  DataProtectionScope["CurrentUser"] = "CurrentUser";
-  DataProtectionScope["LocalMachine"] = "LocalMachine";
-})(DataProtectionScope || (DataProtectionScope = {}));
-
 /**
  * Uses reads and writes passwords to macOS keychain
  *
@@ -946,99 +619,70 @@ var DataProtectionScope;
  * accountName: Account under which password should be stored
  */
 
-var KeychainPersistence = /*#__PURE__*/function () {
-  function KeychainPersistence(serviceName, accountName) {
+class KeychainPersistence extends BasePersistence {
+  constructor(serviceName, accountName) {
+    super();
     this.serviceName = serviceName;
     this.accountName = accountName;
   }
 
-  KeychainPersistence.create = function create(fileLocation, serviceName, accountName, loggerOptions) {
-    try {
-      var persistence = new KeychainPersistence(serviceName, accountName);
-      return Promise.resolve(FilePersistence.create(fileLocation, loggerOptions)).then(function (_FilePersistence$crea) {
-        persistence.filePersistence = _FilePersistence$crea;
-        return persistence;
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  var _proto = KeychainPersistence.prototype;
+  static async create(fileLocation, serviceName, accountName, loggerOptions) {
+    const persistence = new KeychainPersistence(serviceName, accountName);
+    persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+    return persistence;
+  }
 
-  _proto.save = function save(contents) {
+  async save(contents) {
     try {
-      var _temp3 = function _temp3(_result) {
-        return _exit2 ? _result : Promise.resolve(_this2.filePersistence.save("{}")).then(function () {});
-      };
-
-      var _exit2 = false;
-
-      var _this2 = this;
+      await setPassword(this.serviceName, this.accountName, contents);
+    } catch (err) {
+      throw PersistenceError.createKeychainPersistenceError(err.message);
+    } // Write dummy data to update file mtime
 
-      var _temp4 = _catch(function () {
-        return Promise.resolve(setPassword(_this2.serviceName, _this2.accountName, contents)).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createKeychainPersistenceError(err.code, err.message);
-      });
 
-      return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(_temp3) : _temp3(_temp4)); // Write dummy data to update file mtime
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+    await this.filePersistence.save("{}");
+  }
 
-  _proto.load = function load() {
+  async load() {
     try {
-      var _this4 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(getPassword(_this4.serviceName, _this4.accountName));
-      }, function (err) {
-        throw PersistenceError.createKeychainPersistenceError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      return await getPassword(this.serviceName, this.accountName);
+    } catch (err) {
+      throw PersistenceError.createKeychainPersistenceError(err.message);
     }
-  };
+  }
 
-  _proto["delete"] = function _delete() {
+  async delete() {
     try {
-      var _this6 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(_this6.filePersistence["delete"]()).then(function () {
-          return Promise.resolve(deletePassword(_this6.serviceName, _this6.accountName));
-        });
-      }, function (err) {
-        throw PersistenceError.createKeychainPersistenceError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      await this.filePersistence.delete();
+      return await deletePassword(this.serviceName, this.accountName);
+    } catch (err) {
+      throw PersistenceError.createKeychainPersistenceError(err.message);
     }
-  };
-
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
-    try {
-      var _this8 = this;
+  }
 
-      return Promise.resolve(_this8.filePersistence.reloadNecessary(lastSync));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+  async reloadNecessary(lastSync) {
+    return this.filePersistence.reloadNecessary(lastSync);
+  }
 
-  _proto.getFilePath = function getFilePath() {
+  getFilePath() {
     return this.filePersistence.getFilePath();
-  };
+  }
 
-  _proto.getLogger = function getLogger() {
+  getLogger() {
     return this.filePersistence.getLogger();
-  };
+  }
+
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+    return KeychainPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
+  }
 
-  return KeychainPersistence;
-}();
+}
 
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 /**
  * Uses reads and writes passwords to Secret Service API/libsecret. Requires libsecret
  * to be installed.
@@ -1047,98 +691,215 @@ var KeychainPersistence = /*#__PURE__*/function () {
  * accountName: Account under which password should be stored
  */
 
-var LibSecretPersistence = /*#__PURE__*/function () {
-  function LibSecretPersistence(serviceName, accountName) {
+class LibSecretPersistence extends BasePersistence {
+  constructor(serviceName, accountName) {
+    super();
     this.serviceName = serviceName;
     this.accountName = accountName;
   }
 
-  LibSecretPersistence.create = function create(fileLocation, serviceName, accountName, loggerOptions) {
+  static async create(fileLocation, serviceName, accountName, loggerOptions) {
+    const persistence = new LibSecretPersistence(serviceName, accountName);
+    persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+    return persistence;
+  }
+
+  async save(contents) {
     try {
-      var persistence = new LibSecretPersistence(serviceName, accountName);
-      return Promise.resolve(FilePersistence.create(fileLocation, loggerOptions)).then(function (_FilePersistence$crea) {
-        persistence.filePersistence = _FilePersistence$crea;
-        return persistence;
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+      await setPassword(this.serviceName, this.accountName, contents);
+    } catch (err) {
+      throw PersistenceError.createLibSecretError(err.message);
+    } // Write dummy data to update file mtime
 
-  var _proto = LibSecretPersistence.prototype;
 
-  _proto.save = function save(contents) {
+    await this.filePersistence.save("{}");
+  }
+
+  async load() {
     try {
-      var _temp3 = function _temp3(_result) {
-        return _exit2 ? _result : Promise.resolve(_this2.filePersistence.save("{}")).then(function () {});
-      };
+      return await getPassword(this.serviceName, this.accountName);
+    } catch (err) {
+      throw PersistenceError.createLibSecretError(err.message);
+    }
+  }
 
-      var _exit2 = false;
+  async delete() {
+    try {
+      await this.filePersistence.delete();
+      return await deletePassword(this.serviceName, this.accountName);
+    } catch (err) {
+      throw PersistenceError.createLibSecretError(err.message);
+    }
+  }
 
-      var _this2 = this;
+  async reloadNecessary(lastSync) {
+    return this.filePersistence.reloadNecessary(lastSync);
+  }
 
-      var _temp4 = _catch(function () {
-        return Promise.resolve(setPassword(_this2.serviceName, _this2.accountName, contents)).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createLibSecretError(err.code, err.message);
-      });
+  getFilePath() {
+    return this.filePersistence.getFilePath();
+  }
 
-      return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(_temp3) : _temp3(_temp4)); // Write dummy data to update file mtime
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+  getLogger() {
+    return this.filePersistence.getLogger();
+  }
 
-  _proto.load = function load() {
-    try {
-      var _this4 = this;
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+    return LibSecretPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
+  }
 
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(getPassword(_this4.serviceName, _this4.accountName));
-      }, function (err) {
-        throw PersistenceError.createLibSecretError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class Environment {
+  static get homeEnvVar() {
+    return this.getEnvironmentVariable(Constants.ENVIRONMENT.HOME);
+  }
+
+  static get lognameEnvVar() {
+    return this.getEnvironmentVariable(Constants.ENVIRONMENT.LOGNAME);
+  }
+
+  static get userEnvVar() {
+    return this.getEnvironmentVariable(Constants.ENVIRONMENT.USER);
+  }
+
+  static get lnameEnvVar() {
+    return this.getEnvironmentVariable(Constants.ENVIRONMENT.LNAME);
+  }
+
+  static get usernameEnvVar() {
+    return this.getEnvironmentVariable(Constants.ENVIRONMENT.USERNAME);
+  }
+
+  static getEnvironmentVariable(name) {
+    return process.env[name];
+  }
+
+  static getEnvironmentPlatform() {
+    return process.platform;
+  }
+
+  static isWindowsPlatform() {
+    return this.getEnvironmentPlatform() === Platform.WINDOWS;
+  }
+
+  static isLinuxPlatform() {
+    return this.getEnvironmentPlatform() === Platform.LINUX;
+  }
+
+  static isMacPlatform() {
+    return this.getEnvironmentPlatform() === Platform.MACOS;
+  }
+
+  static isLinuxRootUser() {
+    return process.getuid() === Constants.LINUX_ROOT_USER_GUID;
+  }
+
+  static getUserRootDirectory() {
+    return !this.isWindowsPlatform ? this.getUserHomeDirOnUnix() : this.getUserHomeDirOnWindows();
+  }
+
+  static getUserHomeDirOnWindows() {
+    return this.getEnvironmentVariable(Constants.ENVIRONMENT.LOCAL_APPLICATION_DATA);
+  }
+
+  static getUserHomeDirOnUnix() {
+    if (this.isWindowsPlatform()) {
+      throw PersistenceError.createNotSupportedError("Getting the user home directory for unix is not supported in windows");
     }
-  };
 
-  _proto["delete"] = function _delete() {
-    try {
-      var _this6 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(_this6.filePersistence["delete"]()).then(function () {
-          return Promise.resolve(deletePassword(_this6.serviceName, _this6.accountName));
-        });
-      }, function (err) {
-        throw PersistenceError.createLibSecretError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+    if (!StringUtils.isEmpty(this.homeEnvVar)) {
+      return this.homeEnvVar;
     }
-  };
 
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
-    try {
-      var _this8 = this;
+    let username = null;
 
-      return Promise.resolve(_this8.filePersistence.reloadNecessary(lastSync));
-    } catch (e) {
-      return Promise.reject(e);
+    if (!StringUtils.isEmpty(this.lognameEnvVar)) {
+      username = this.lognameEnvVar;
+    } else if (!StringUtils.isEmpty(this.userEnvVar)) {
+      username = this.userEnvVar;
+    } else if (!StringUtils.isEmpty(this.lnameEnvVar)) {
+      username = this.lnameEnvVar;
+    } else if (!StringUtils.isEmpty(this.usernameEnvVar)) {
+      username = this.usernameEnvVar;
     }
-  };
 
-  _proto.getFilePath = function getFilePath() {
-    return this.filePersistence.getFilePath();
-  };
+    if (this.isMacPlatform()) {
+      return !StringUtils.isEmpty(username) ? path.join("/Users", username) : null;
+    } else if (this.isLinuxPlatform()) {
+      if (this.isLinuxRootUser()) {
+        return "/root";
+      } else {
+        return !StringUtils.isEmpty(username) ? path.join("/home", username) : null;
+      }
+    } else {
+      throw PersistenceError.createNotSupportedError("Getting the user home directory for unix is not supported in windows");
+    }
+  }
 
-  _proto.getLogger = function getLogger() {
-    return this.filePersistence.getLogger();
-  };
+}
 
-  return LibSecretPersistence;
-}();
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class PersistenceCreator {
+  static async createPersistence(config) {
+    let peristence; // On Windows, uses a DPAPI encrypted file
+
+    if (Environment.isWindowsPlatform()) {
+      if (!config.cachePath || !config.dataProtectionScope) {
+        throw PersistenceError.createPersistenceNotValidatedError("Cache path and/or data protection scope not provided for the FilePersistenceWithDataProtection cache plugin");
+      }
+
+      peristence = await FilePersistenceWithDataProtection.create(config.cachePath, DataProtectionScope.CurrentUser);
+    } // On Mac, uses keychain.
+    else if (Environment.isMacPlatform()) {
+        if (!config.cachePath || !config.serviceName || !config.accountName) {
+          throw PersistenceError.createPersistenceNotValidatedError("Cache path, service name and/or account name not provided for the KeychainPersistence cache plugin");
+        }
+
+        peristence = await KeychainPersistence.create(config.cachePath, config.serviceName, config.accountName);
+      } // On Linux, uses  libsecret to store to secret service. Libsecret has to be installed.
+      else if (Environment.isLinuxPlatform()) {
+          if (!config.cachePath || !config.serviceName || !config.accountName) {
+            throw PersistenceError.createPersistenceNotValidatedError("Cache path, service name and/or account name not provided for the LibSecretPersistence cache plugin");
+          }
+
+          peristence = await LibSecretPersistence.create(config.cachePath, config.serviceName, config.accountName);
+        } else {
+          throw PersistenceError.createNotSupportedError("The current environment is not supported by msal-node-extensions yet.");
+        } // Initially suppress the error thrown during persistence verification to allow us to fallback to plain text
+
+
+    const isPersistenceVerified = await peristence.verifyPersistence().catch(() => false);
+
+    if (!isPersistenceVerified) {
+      if (Environment.isLinuxPlatform() && config.usePlaintextFileOnLinux) {
+        if (!config.cachePath) {
+          throw PersistenceError.createPersistenceNotValidatedError("Cache path not provided for the FilePersistence cache plugin");
+        }
+
+        peristence = await FilePersistence.create(config.cachePath);
+        const isFilePersistenceVerified = await peristence.verifyPersistence();
+
+        if (isFilePersistenceVerified) {
+          return peristence;
+        }
+      }
+
+      throw PersistenceError.createPersistenceNotVerifiedError("Persistence could not be verified");
+    }
+
+    return peristence;
+  }
+
+}
 
-export { DataProtectionScope, FilePersistence, FilePersistenceWithDataProtection, KeychainPersistence, LibSecretPersistence, PersistenceCachePlugin };
+export { DataProtectionScope, Environment, FilePersistence, FilePersistenceWithDataProtection, KeychainPersistence, LibSecretPersistence, PersistenceCachePlugin, PersistenceCreator };
 //# sourceMappingURL=msal-node-extensions.esm.js.map