@azure/msal-node-extensions 1.0.0-alpha.3 → 1.0.0-alpha.31

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

@@ -1,395 +1,163 @@
 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, AuthError, Constants as Constants$1, PromptValue, ClientAuthError, AuthenticationScheme, ClientConfigurationError, ServerError, InteractionRequiredAuthError } 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);
-}
+import { msalNodeRuntime, ErrorStatus, LogLevel as LogLevel$1 } from '@azure/msal-node-runtime';
 
 /*
  * 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
    */
   EEXIST_ERROR: "EEXIST",
-
   /**
    * No such file or directory: Commonly raised by fs operations to indicate that a component
    * of the specified pathname does not exist. No entity (file or directory) could be found
    * by the given path
    */
   ENOENT_ERROR: "ENOENT",
-
   /**
    * Operation not permitted. An attempt was made to perform an operation that requires
    * elevated privileges.
    */
   EPERM_ERROR: "EPERM",
-
   /**
    * Default service name for using MSAL Keytar
    */
-  DEFAULT_SERVICE_NAME: "msal-node-extensions"
+  DEFAULT_SERVICE_NAME: "msal-node-extensions",
+  /**
+   * Test data used to verify underlying persistence mechanism
+   */
+  PERSISTENCE_TEST_DATA: "Dummy data to verify underlying persistence mechanism",
+  /**
+   * This is the value of a the guid if the process is being ran by the root user
+   */
+  LINUX_ROOT_USER_GUID: 0,
+  /**
+   * 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"
 };
-
-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;
-
-    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);
-    }
-
-    Wrapper.prototype = Object.create(Class.prototype, {
-      constructor: {
-        value: Wrapper,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    return _setPrototypeOf(Wrapper, Class);
-  };
-
-  return _wrapNativeSuper(Class);
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
+var Platform;
+(function (Platform) {
+  Platform["WINDOWS"] = "win32";
+  Platform["LINUX"] = "linux";
+  Platform["MACOS"] = "darwin";
+})(Platform || (Platform = {}));
+var ErrorCodes;
+(function (ErrorCodes) {
+  ErrorCodes["INTERATION_REQUIRED_ERROR_CODE"] = "interaction_required";
+  ErrorCodes["SERVER_UNAVAILABLE"] = "server_unavailable";
+})(ErrorCodes || (ErrorCodes = {}));
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
 /**
  * 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(errorMessage) {
+  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(errorMessage) {
+  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(errorMessage) {
+  static createFilePersistenceWithDPAPIError(errorMessage) {
     return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
   }
   /**
    * Error thrown when using the cross platform lock.
    */
-  ;
-
-  PersistenceError.createCrossPlatformLockError = function createCrossPlatformLockError(errorMessage) {
+  static createCrossPlatformLockError(errorMessage) {
     return new PersistenceError("CrossPlatformLockError", errorMessage);
-  };
-
-  return PersistenceError;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
+  }
+  /**
+   * 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,110 +168,60 @@ var CrossPlatformLock = /*#__PURE__*/function () {
    * cache file but with .lockfile extension. If another process has already created
    * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
    */
-
-
-  var _proto = CrossPlatformLock.prototype;
-
-  _proto.lock = function lock() {
-    try {
-      var _temp3 = function _temp3(_result3) {
-        if (_exit2) return _result3;
-
-        _this2.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");
-      };
-
-      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 || err.code == Constants.EPERM_ERROR) {
-              _this2.logger.info(err);
-
-              return Promise.resolve(_this2.sleep(_this2.retryDelay)).then(function () {});
-            } else {
-              _this2.logger.error(pid + " was not able to acquire lock. Ran into error: " + err.message);
-
-              throw PersistenceError.createCrossPlatformLockError(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 () {
-        var _temp5 = function () {
-          if (_this4.lockFileHandle) {
-            // if we have a file handle to the .lockfile, delete lock file
-            return Promise.resolve(promises.unlink(_this4.lockFilePath)).then(function () {
-              return Promise.resolve(_this4.lockFileHandle.close()).then(function () {
-                _this4.logger.info("lockfile deleted");
-              });
-            });
-          } else {
-            _this4.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
-          }
-        }();
-
-        if (_temp5 && _temp5.then) return _temp5.then(function () {});
-      }, function (err) {
-        if (err.code == Constants.ENOENT_ERROR) {
-          _this4.logger.warning("Tried to unlock but lockfile does not exist");
-        } else {
-          _this4.logger.error(pid + " was not able to release lock. Ran into error: " + err.message);
-
-          throw PersistenceError.createCrossPlatformLockError(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.
@@ -517,126 +235,103 @@ var CrossPlatformLock = /*#__PURE__*/function () {
  * - LibSecretPersistence: Used on linux, writes and reads from secret service API. Requires
  * libsecret be installed.
  */
-
-var PersistenceCachePlugin = /*#__PURE__*/function () {
-  function PersistenceCachePlugin(persistence, lockOptions) {
-    this.persistence = persistence; // initialize logger
-
-    this.logger = persistence.getLogger(); // create file lock
-
-    this.lockFilePath = this.persistence.getFilePath() + ".lockfile";
-    this.crossPlatformLock = new CrossPlatformLock(this.lockFilePath, this.logger, lockOptions); // initialize default values
-
+class PersistenceCachePlugin {
+  constructor(persistence, lockOptions) {
+    this.persistence = persistence;
+    // initialize logger
+    this.logger = persistence.getLogger();
+    // create file lock
+    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() {
+  async beforeCacheAccess(cacheContext) {
+    this.logger.info("Executing before cache access");
+    const reloadNecessary = await this.persistence.reloadNecessary(this.lastSync);
+    if (!reloadNecessary && this.currentCache !== null) {
+      if (cacheContext.cacheHasChanged) {
+        this.logger.verbose("Cache context has changed");
+        await this.crossPlatformLock.lock();
+      }
+      return;
+    }
     try {
-      var _this2 = this;
-
-      _this2.logger.info("Reading from storage");
-
-      return Promise.resolve(_this2.persistence.reloadNecessary(_this2.lastSync)).then(function (_this$persistence$rel) {
-        function _temp3() {
-          return _this2.currentCache;
-        }
-
-        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 _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
-      });
-    } catch (e) {
-      return Promise.reject(e);
+      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.
@@ -644,304 +339,123 @@ var PersistenceCachePlugin = /*#__PURE__*/function () {
  * If file or directory has not been created, it FilePersistence.create() will create
  * 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;
-
-  _proto.save = function save(contents) {
+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;
+  }
+  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;
-        }
-
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      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);
     }
-  };
-
-  _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);
-    }
-  };
-
-  _proto.getLogger = function getLogger() {
+  }
+  async reloadNecessary(lastSync) {
+    return lastSync < (await this.timeLastModified());
+  }
+  getLogger() {
     return this.logger;
-  };
-
-  FilePersistence.createDefaultLoggerOptions = function createDefaultLoggerOptions() {
+  }
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePath)}/test.cache`;
+    return FilePersistence.create(testCacheFileLocation);
+  }
+  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;
-        }
-
-        throw PersistenceError.createFileSystemError(err.code, err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      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);
     }
-  };
-
-  _proto.createCacheFile = function createCacheFile() {
+  }
+  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}`);
+  }
+  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);
-    }
-  };
-
-  return FilePersistence;
-}();
+  }
+}
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
-/* eslint-disable-next-line @typescript-eslint/no-var-requires, no-var */
-var Dpapi = /*#__PURE__*/require("bindings")("dpapi");
-
-/**
- * Uses CryptProtectData and CryptUnprotectData on Windows to encrypt and decrypt file contents.
- *
- * scope: Scope of the data protection. Either local user or the current machine
- * optionalEntropy: Password or other additional entropy used to encrypt the data
- */
-
-var FilePersistenceWithDataProtection = /*#__PURE__*/function () {
-  function FilePersistenceWithDataProtection(scope, optionalEntropy) {
-    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;
-
-  _proto.save = function 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.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  _proto.load = function 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");
-
-            return null;
-          }
-
-          return Dpapi.unprotectData(encryptedContents, _this4.optionalEntropy, _this4.scope.toString()).toString();
-        });
-      }, function (err) {
-        throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  _proto["delete"] = function _delete() {
-    try {
-      var _this6 = this;
-
-      return Promise.resolve(_this6.filePersistence["delete"]());
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
-    try {
-      var _this8 = this;
-
-      return Promise.resolve(_this8.filePersistence.reloadNecessary(lastSync));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  _proto.getFilePath = function getFilePath() {
-    return this.filePersistence.getFilePath();
-  };
-
-  _proto.getLogger = function getLogger() {
-    return this.filePersistence.getLogger();
-  };
-
-  return FilePersistenceWithDataProtection;
-}();
+/* eslint-disable-next-line @typescript-eslint/no-var-requires, no-var, import/no-commonjs */
+var Dpapi = /*#__PURE__*/require("../build/Release/dpapi.node");
 
 /*
  * 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.
@@ -954,112 +468,134 @@ var FilePersistenceWithDataProtection = /*#__PURE__*/function () {
  *
  */
 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 reads and writes passwords to macOS keychain
+ * Uses CryptProtectData and CryptUnprotectData on Windows to encrypt and decrypt file contents.
  *
- * serviceName: Identifier used as key for whatever value is stored
- * accountName: Account under which password should be stored
+ * scope: Scope of the data protection. Either local user or the current machine
+ * optionalEntropy: Password or other additional entropy used to encrypt the data
  */
-
-var KeychainPersistence = /*#__PURE__*/function () {
-  function KeychainPersistence(serviceName, accountName) {
-    this.serviceName = serviceName;
-    this.accountName = accountName;
+class FilePersistenceWithDataProtection extends BasePersistence {
+  constructor(scope, optionalEntropy) {
+    super();
+    this.scope = scope;
+    this.optionalEntropy = optionalEntropy ? Buffer.from(optionalEntropy, "utf-8") : null;
   }
-
-  KeychainPersistence.create = function create(fileLocation, serviceName, accountName, loggerOptions) {
+  static async create(fileLocation, scope, optionalEntropy, loggerOptions) {
+    const persistence = new FilePersistenceWithDataProtection(scope, optionalEntropy);
+    persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+    return persistence;
+  }
+  async save(contents) {
     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);
+      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);
     }
-  };
-
-  var _proto = KeychainPersistence.prototype;
-
-  _proto.save = function save(contents) {
+  }
+  async load() {
     try {
-      var _temp3 = function _temp3(_result) {
-        return _exit2 ? _result : Promise.resolve(_this2.filePersistence.save("{}")).then(function () {});
-      };
-
-      var _exit2 = false;
-
-      var _this2 = this;
-
-      var _temp4 = _catch(function () {
-        return Promise.resolve(setPassword(_this2.serviceName, _this2.accountName, contents)).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createKeychainPersistenceError(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);
+      const encryptedContents = await this.filePersistence.loadBuffer();
+      if (typeof encryptedContents === "undefined" || !encryptedContents || 0 === encryptedContents.length) {
+        this.filePersistence.getLogger().info("Encrypted contents loaded from file were null or empty");
+        return null;
+      }
+      return Dpapi.unprotectData(encryptedContents, this.optionalEntropy, this.scope.toString()).toString();
+    } catch (err) {
+      throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
     }
-  };
+  }
+  async delete() {
+    return this.filePersistence.delete();
+  }
+  async reloadNecessary(lastSync) {
+    return this.filePersistence.reloadNecessary(lastSync);
+  }
+  getFilePath() {
+    return this.filePersistence.getFilePath();
+  }
+  getLogger() {
+    return this.filePersistence.getLogger();
+  }
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+    return FilePersistenceWithDataProtection.create(testCacheFileLocation, DataProtectionScope.CurrentUser);
+  }
+}
 
-  _proto.load = function load() {
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Uses reads and writes passwords to macOS keychain
+ *
+ * serviceName: Identifier used as key for whatever value is stored
+ * accountName: Account under which password should be stored
+ */
+class KeychainPersistence extends BasePersistence {
+  constructor(serviceName, accountName) {
+    super();
+    this.serviceName = serviceName;
+    this.accountName = accountName;
+  }
+  static async create(fileLocation, serviceName, accountName, loggerOptions) {
+    const persistence = new KeychainPersistence(serviceName, accountName);
+    persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+    return persistence;
+  }
+  async save(contents) {
     try {
-      var _this4 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(getPassword(_this4.serviceName, _this4.accountName));
-      }, function (err) {
-        throw PersistenceError.createKeychainPersistenceError(err.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      await setPassword(this.serviceName, this.accountName, contents);
+    } catch (err) {
+      throw PersistenceError.createKeychainPersistenceError(err.message);
     }
-  };
-
-  _proto["delete"] = function _delete() {
+    // Write dummy data to update file mtime
+    await this.filePersistence.save("{}");
+  }
+  async load() {
     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.message);
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+      return await getPassword(this.serviceName, this.accountName);
+    } catch (err) {
+      throw PersistenceError.createKeychainPersistenceError(err.message);
     }
-  };
-
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
+  }
+  async delete() {
     try {
-      var _this8 = this;
-
-      return Promise.resolve(_this8.filePersistence.reloadNecessary(lastSync));
-    } 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.getFilePath = function getFilePath() {
+  }
+  async reloadNecessary(lastSync) {
+    return this.filePersistence.reloadNecessary(lastSync);
+  }
+  getFilePath() {
     return this.filePersistence.getFilePath();
-  };
-
-  _proto.getLogger = function getLogger() {
+  }
+  getLogger() {
     return this.filePersistence.getLogger();
-  };
-
-  return KeychainPersistence;
-}();
+  }
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+    return KeychainPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
+  }
+}
 
+/*
+ * 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.
@@ -1067,99 +603,573 @@ var KeychainPersistence = /*#__PURE__*/function () {
  * serviceName: Identifier used as key for whatever value is stored
  * 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);
     }
-  };
-
-  var _proto = LibSecretPersistence.prototype;
-
-  _proto.save = function save(contents) {
+    // Write dummy data to update file mtime
+    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);
+    }
+  }
+  async delete() {
+    try {
+      await this.filePersistence.delete();
+      return await deletePassword(this.serviceName, this.accountName);
+    } catch (err) {
+      throw PersistenceError.createLibSecretError(err.message);
+    }
+  }
+  async reloadNecessary(lastSync) {
+    return this.filePersistence.reloadNecessary(lastSync);
+  }
+  getFilePath() {
+    return this.filePersistence.getFilePath();
+  }
+  getLogger() {
+    return this.filePersistence.getLogger();
+  }
+  createForPersistenceValidation() {
+    const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+    return LibSecretPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
+  }
+}
 
-      var _exit2 = false;
+/*
+ * 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");
+    }
+    if (!StringUtils.isEmpty(this.homeEnvVar)) {
+      return this.homeEnvVar;
+    }
+    let username = null;
+    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;
+    }
+    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");
+    }
+  }
+}
 
-      var _this2 = this;
+/*
+ * 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, undefined, config.loggerOptions);
+    }
+    // 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, config.loggerOptions);
+    }
+    // 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, config.loggerOptions);
+    } 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, config.loggerOptions);
+        const isFilePersistenceVerified = await peristence.verifyPersistence();
+        if (isFilePersistenceVerified) {
+          return peristence;
+        }
+      }
+      throw PersistenceError.createPersistenceNotVerifiedError("Persistence could not be verified");
+    }
+    return peristence;
+  }
+}
 
-      var _temp4 = _catch(function () {
-        return Promise.resolve(setPassword(_this2.serviceName, _this2.accountName, contents)).then(function () {});
-      }, function (err) {
-        throw PersistenceError.createLibSecretError(err.message);
-      });
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class NativeAuthError extends AuthError {
+  constructor(errorStatus, errorContext, errorCode, errorTag) {
+    super(errorStatus, errorContext);
+    this.name = "NativeAuthError";
+    this.statusCode = errorCode;
+    this.tag = errorTag;
+    Object.setPrototypeOf(this, NativeAuthError.prototype);
+  }
+}
 
-      return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(_temp3) : _temp3(_temp4)); // Write dummy data to update file mtime
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
+/* eslint-disable header/header */
+const name = "@azure/msal-node-extensions";
+const version = "1.0.0-alpha.31";
 
-  _proto.load = function load() {
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class NativeBrokerPlugin {
+  constructor() {
+    const defaultLoggerOptions = {
+      loggerCallback: () => {
+        // Empty logger callback
+      },
+      piiLoggingEnabled: false
+    };
+    this.logger = new Logger(defaultLoggerOptions, name, version); // Default logger
+    this.isBrokerAvailable = msalNodeRuntime.StartupError ? false : true;
+  }
+  setLogger(loggerOptions) {
+    this.logger = new Logger(loggerOptions, name, version);
+    const logCallback = (message, logLevel, containsPii) => {
+      switch (logLevel) {
+        case LogLevel$1.Trace:
+          if (containsPii) {
+            this.logger.tracePii(message);
+          } else {
+            this.logger.trace(message);
+          }
+          break;
+        case LogLevel$1.Debug:
+          if (containsPii) {
+            this.logger.tracePii(message);
+          } else {
+            this.logger.trace(message);
+          }
+          break;
+        case LogLevel$1.Info:
+          if (containsPii) {
+            this.logger.infoPii(message);
+          } else {
+            this.logger.info(message);
+          }
+          break;
+        case LogLevel$1.Warning:
+          if (containsPii) {
+            this.logger.warningPii(message);
+          } else {
+            this.logger.warning(message);
+          }
+          break;
+        case LogLevel$1.Error:
+          if (containsPii) {
+            this.logger.errorPii(message);
+          } else {
+            this.logger.error(message);
+          }
+          break;
+        case LogLevel$1.Fatal:
+          if (containsPii) {
+            this.logger.errorPii(message);
+          } else {
+            this.logger.error(message);
+          }
+          break;
+        default:
+          if (containsPii) {
+            this.logger.infoPii(message);
+          } else {
+            this.logger.info(message);
+          }
+          break;
+      }
+    };
     try {
-      var _this4 = this;
-
-      return Promise.resolve(_catch(function () {
-        return Promise.resolve(getPassword(_this4.serviceName, _this4.accountName));
-      }, function (err) {
-        throw PersistenceError.createLibSecretError(err.message);
-      }));
+      msalNodeRuntime.RegisterLogger(logCallback, loggerOptions.piiLoggingEnabled);
     } catch (e) {
-      return Promise.reject(e);
+      const wrappedError = this.wrapError(e);
+      if (wrappedError) {
+        throw wrappedError;
+      }
     }
-  };
-
-  _proto["delete"] = function _delete() {
+  }
+  async getAccountById(accountId, correlationId) {
+    this.logger.trace("NativeBrokerPlugin - getAccountById called", correlationId);
+    const readAccountResult = await this.readAccountById(accountId, correlationId);
+    return this.generateAccountInfo(readAccountResult.account);
+  }
+  async getAllAccounts(clientId, correlationId) {
+    this.logger.trace("NativeBrokerPlugin - getAllAccounts called", correlationId);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        const accountInfoResult = [];
+        result.accounts.forEach(account => {
+          accountInfoResult.push(this.generateAccountInfo(account));
+        });
+        resolve(accountInfoResult);
+      };
+      try {
+        msalNodeRuntime.DiscoverAccountsAsync(clientId, correlationId, resultCallback);
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async acquireTokenSilent(request) {
+    this.logger.trace("NativeBrokerPlugin - acquireTokenSilent called", request.correlationId);
+    const authParams = this.generateRequestParameters(request);
+    const account = await this.getAccount(request);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        const authenticationResult = this.getAuthenticationResult(request, result);
+        resolve(authenticationResult);
+      };
+      try {
+        if (account) {
+          msalNodeRuntime.AcquireTokenSilentlyAsync(authParams, request.correlationId, account, resultCallback);
+        } else {
+          msalNodeRuntime.SignInSilentlyAsync(authParams, request.correlationId, resultCallback);
+        }
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async acquireTokenInteractive(request, providedWindowHandle) {
+    this.logger.trace("NativeBrokerPlugin - acquireTokenInteractive called", request.correlationId);
+    const authParams = this.generateRequestParameters(request);
+    const account = await this.getAccount(request);
+    const windowHandle = providedWindowHandle || Buffer.from([0]);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        const authenticationResult = this.getAuthenticationResult(request, result);
+        resolve(authenticationResult);
+      };
+      try {
+        switch (request.prompt) {
+          case PromptValue.LOGIN:
+          case PromptValue.SELECT_ACCOUNT:
+          case PromptValue.CREATE:
+            this.logger.info("Calling native interop SignInInteractively API", request.correlationId);
+            const loginHint = request.loginHint || Constants$1.EMPTY_STRING;
+            msalNodeRuntime.SignInInteractivelyAsync(windowHandle, authParams, request.correlationId, loginHint, resultCallback);
+            break;
+          case PromptValue.NONE:
+            if (account) {
+              this.logger.info("Calling native interop AcquireTokenSilently API", request.correlationId);
+              msalNodeRuntime.AcquireTokenSilentlyAsync(authParams, request.correlationId, account, resultCallback);
+            } else {
+              this.logger.info("Calling native interop SignInSilently API", request.correlationId);
+              msalNodeRuntime.SignInSilentlyAsync(authParams, request.correlationId, resultCallback);
+            }
+            break;
+          default:
+            if (account) {
+              this.logger.info("Calling native interop AcquireTokenInteractively API", request.correlationId);
+              msalNodeRuntime.AcquireTokenInteractivelyAsync(windowHandle, authParams, request.correlationId, account, resultCallback);
+            } else {
+              this.logger.info("Calling native interop SignIn API", request.correlationId);
+              const loginHint = request.loginHint || Constants$1.EMPTY_STRING;
+              msalNodeRuntime.SignInAsync(windowHandle, authParams, request.correlationId, loginHint, resultCallback);
+            }
+            break;
+        }
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async signOut(request) {
+    this.logger.trace("NativeBrokerPlugin - signOut called", request.correlationId);
+    const account = await this.getAccount(request);
+    if (!account) {
+      throw ClientAuthError.createNoAccountFoundError();
+    }
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        resolve();
+      };
+      try {
+        msalNodeRuntime.SignOutSilentlyAsync(request.clientId, request.correlationId, account, resultCallback);
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async getAccount(request) {
+    if (request.accountId) {
+      const readAccountResult = await this.readAccountById(request.accountId, request.correlationId);
+      return readAccountResult.account;
+    }
+    return null;
+  }
+  async readAccountById(accountId, correlationId) {
+    this.logger.trace("NativeBrokerPlugin - readAccountById called", correlationId);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        resolve(result);
+      };
+      try {
+        msalNodeRuntime.ReadAccountByIdAsync(accountId, correlationId, resultCallback);
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  generateRequestParameters(request) {
+    this.logger.trace("NativeBrokerPlugin - generateRequestParameters called", request.correlationId);
+    const authParams = new msalNodeRuntime.AuthParameters();
     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));
+      authParams.CreateAuthParameters(request.clientId, request.authority);
+      authParams.SetRedirectUri(request.redirectUri);
+      authParams.SetRequestedScopes(request.scopes.join(" "));
+      if (request.claims) {
+        authParams.SetDecodedClaims(request.claims);
+      }
+      if (request.authenticationScheme === AuthenticationScheme.POP) {
+        if (!request.resourceRequestMethod || !request.resourceRequestUri || !request.shrNonce) {
+          throw new Error("Authentication Scheme set to POP but one or more of the following parameters are missing: resourceRequestMethod, resourceRequestUri, shrNonce");
+        }
+        const resourceUrl = new URL(request.resourceRequestUri);
+        authParams.SetPopParams(request.resourceRequestMethod, resourceUrl.host, resourceUrl.pathname, request.shrNonce);
+      }
+      if (request.extraParameters) {
+        Object.keys(request.extraParameters).forEach(key => {
+          authParams.SetAdditionalParameter(key, request.extraParameters[key]);
         });
-      }, function (err) {
-        throw PersistenceError.createLibSecretError(err.message);
-      }));
+      }
     } catch (e) {
-      return Promise.reject(e);
+      const wrappedError = this.wrapError(e);
+      if (wrappedError) {
+        throw wrappedError;
+      }
     }
-  };
-
-  _proto.reloadNecessary = function reloadNecessary(lastSync) {
+    return authParams;
+  }
+  getAuthenticationResult(request, authResult) {
+    this.logger.trace("NativeBrokerPlugin - getAuthenticationResult called", request.correlationId);
+    let fromCache;
     try {
-      var _this8 = this;
-
-      return Promise.resolve(_this8.filePersistence.reloadNecessary(lastSync));
+      const telemetryJSON = JSON.parse(authResult.telemetryData);
+      fromCache = !!telemetryJSON["is_cache"];
     } catch (e) {
-      return Promise.reject(e);
+      this.logger.error("NativeBrokerPlugin: getAuthenticationResult - Error parsing telemetry data. Could not determine if response came from cache.", request.correlationId);
     }
-  };
-
-  _proto.getFilePath = function getFilePath() {
-    return this.filePersistence.getFilePath();
-  };
-
-  _proto.getLogger = function getLogger() {
-    return this.filePersistence.getLogger();
-  };
-
-  return LibSecretPersistence;
-}();
+    let idTokenClaims;
+    try {
+      idTokenClaims = JSON.parse(authResult.idToken);
+    } catch (e) {
+      throw new Error("Unable to parse idToken claims");
+    }
+    const accountInfo = this.generateAccountInfo(authResult.account, idTokenClaims);
+    const result = {
+      authority: request.authority,
+      uniqueId: idTokenClaims.oid || idTokenClaims.sub || "",
+      tenantId: idTokenClaims.tid || "",
+      scopes: authResult.grantedScopes.split(" "),
+      account: accountInfo,
+      idToken: authResult.rawIdToken,
+      idTokenClaims: idTokenClaims,
+      accessToken: authResult.accessToken,
+      fromCache: fromCache,
+      expiresOn: new Date(authResult.expiresOn * 1000),
+      tokenType: authResult.isPopAuthorization ? AuthenticationScheme.POP : AuthenticationScheme.BEARER,
+      correlationId: request.correlationId,
+      fromNativeBroker: true
+    };
+    return result;
+  }
+  generateAccountInfo(account, idTokenClaims) {
+    this.logger.trace("NativeBrokerPlugin - generateAccountInfo called");
+    const accountInfo = {
+      homeAccountId: account.homeAccountId,
+      environment: account.environment,
+      tenantId: account.realm,
+      username: account.username,
+      localAccountId: account.localAccountId,
+      name: account.displayName,
+      idTokenClaims: idTokenClaims,
+      nativeAccountId: account.accountId
+    };
+    return accountInfo;
+  }
+  isMsalRuntimeError(result) {
+    return result.hasOwnProperty("errorCode") || result.hasOwnProperty("errorStatus") || result.hasOwnProperty("errorContext") || result.hasOwnProperty("errorTag");
+  }
+  wrapError(error) {
+    if (this.isMsalRuntimeError(error)) {
+      const {
+        errorCode,
+        errorStatus,
+        errorContext,
+        errorTag
+      } = error;
+      switch (errorStatus) {
+        case ErrorStatus.InteractionRequired:
+        case ErrorStatus.AccountUnusable:
+          return new InteractionRequiredAuthError(ErrorCodes.INTERATION_REQUIRED_ERROR_CODE, errorContext);
+        case ErrorStatus.NoNetwork:
+        case ErrorStatus.NetworkTemporarilyUnavailable:
+          return ClientAuthError.createNoNetworkConnectivityError();
+        case ErrorStatus.ServerTemporarilyUnavailable:
+          return new ServerError(ErrorCodes.SERVER_UNAVAILABLE, errorContext);
+        case ErrorStatus.UserCanceled:
+          return ClientAuthError.createUserCanceledError();
+        case ErrorStatus.AuthorityUntrusted:
+          return ClientConfigurationError.createUntrustedAuthorityError();
+        case ErrorStatus.UserSwitched:
+          // Not an error case, if there's customer demand we can surface this as a response property
+          return null;
+        case ErrorStatus.AccountNotFound:
+          return ClientAuthError.createNoAccountFoundError();
+        default:
+          return new NativeAuthError(ErrorStatus[errorStatus], errorContext, errorCode, errorTag);
+      }
+    }
+    return error;
+  }
+}
 
-export { DataProtectionScope, FilePersistence, FilePersistenceWithDataProtection, KeychainPersistence, LibSecretPersistence, PersistenceCachePlugin };
+export { DataProtectionScope, Environment, FilePersistence, FilePersistenceWithDataProtection, KeychainPersistence, LibSecretPersistence, NativeBrokerPlugin, PersistenceCachePlugin, PersistenceCreator };
 //# sourceMappingURL=msal-node-extensions.esm.js.map