Estructura inicial del proyecto

backend/node_modules/@azure/msal-browser/dist/cache/AccountManager.mjs

@@ -0,0 +1,50 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Returns all the accounts in the cache that match the optional filter. If no filter is provided, all accounts are returned.
+ * @param accountFilter - (Optional) filter to narrow down the accounts returned
+ * @returns Array of AccountInfo objects in cache
+ */
+function getAllAccounts(logger, browserStorage, isInBrowser, correlationId, accountFilter) {
+    logger.verbose("1yd030", correlationId);
+    return isInBrowser
+        ? browserStorage.getAllAccounts(accountFilter, correlationId)
+        : [];
+}
+/**
+ * Returns the first account found in the cache that matches the account filter passed in.
+ * @param accountFilter
+ * @returns The first account found in the cache matching the provided filter or null if no account could be found.
+ */
+function getAccount(accountFilter, logger, browserStorage, correlationId) {
+    logger.trace("0u7b90", correlationId);
+    const account = browserStorage.getAccountInfoFilteredBy(accountFilter, correlationId);
+    if (account) {
+        logger.verbose("0btgll", correlationId);
+        return account;
+    }
+    else {
+        logger.verbose("0ltaj5", correlationId);
+        return null;
+    }
+}
+/**
+ * Sets the account to use as the active account. If no account is passed to the acquireToken APIs, then MSAL will use this active account.
+ * @param account
+ */
+function setActiveAccount(account, browserStorage, correlationId) {
+    browserStorage.setActiveAccount(account, correlationId);
+}
+/**
+ * Gets the currently active account
+ */
+function getActiveAccount(browserStorage, correlationId) {
+    return browserStorage.getActiveAccount(correlationId);
+}
+
+export { getAccount, getActiveAccount, getAllAccounts, setActiveAccount };
+//# sourceMappingURL=AccountManager.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/AccountManager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountManager.mjs","sources":["../../src/cache/AccountManager.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;AAGG;AAKH;;;;AAIG;AACG,SAAU,cAAc,CAC1B,MAAc,EACd,cAAmC,EACnC,WAAoB,EACpB,aAAqB,EACrB,aAA6B,EAAA;AAE7B,IAAA,MAAM,CAAC,OAAO,CAAC,uBAAuB,CAAE,CAAA;AACxC,IAAA,OAAO,WAAW;UACZ,cAAc,CAAC,cAAc,CAAC,aAAa,EAAE,aAAa,CAAC;UAC3D,EAAE,CAAC;AACb,CAAC;AAED;;;;AAIG;AACG,SAAU,UAAU,CACtB,aAA4B,EAC5B,MAAc,EACd,cAAmC,EACnC,aAAqB,EAAA;AAErB,IAAA,MAAM,CAAC,KAAK,CAAC,uBAAqB,CAAA,CAAA;IAClC,MAAM,OAAO,GAAuB,cAAc,CAAC,wBAAwB,CACvE,aAAa,EACb,aAAa,CAChB,CAAC;AAEF,IAAA,IAAI,OAAO,EAAE;AACT,QAAA,MAAM,CAAC,OAAO,CACV;AAGJ,QAAA,OAAO,OAAO,CAAC;AAClB,KAAA;AAAM,SAAA;AACH,QAAA,MAAM,CAAC,OAAO,CACV;AAGJ,QAAA,OAAO,IAAI,CAAC;AACf,KAAA;AACL,CAAC;AAED;;;AAGG;SACa,gBAAgB,CAC5B,OAA2B,EAC3B,cAAmC,EACnC,aAAqB,EAAA;AAErB,IAAA,cAAc,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;AAC5D,CAAC;AAED;;AAEG;AACa,SAAA,gBAAgB,CAC5B,cAAmC,EACnC,aAAqB,EAAA;AAErB,IAAA,OAAO,cAAc,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;AAC1D;;;;"}

backend/node_modules/@azure/msal-browser/dist/cache/AsyncMemoryStorage.mjs

@@ -0,0 +1,148 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { BrowserAuthError } from '../error/BrowserAuthError.mjs';
+import { DatabaseStorage } from './DatabaseStorage.mjs';
+import { MemoryStorage } from './MemoryStorage.mjs';
+import { databaseUnavailable } from '../error/BrowserAuthErrorCodes.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * This class allows MSAL to store artifacts asynchronously using the DatabaseStorage IndexedDB wrapper,
+ * backed up with the more volatile MemoryStorage object for cases in which IndexedDB may be unavailable.
+ */
+class AsyncMemoryStorage {
+    constructor(logger) {
+        this.inMemoryCache = new MemoryStorage();
+        this.indexedDBCache = new DatabaseStorage();
+        this.logger = logger;
+    }
+    handleDatabaseAccessError(error, correlationId) {
+        if (error instanceof BrowserAuthError &&
+            error.errorCode === databaseUnavailable) {
+            this.logger.error("1wx7zz", correlationId);
+        }
+        else {
+            throw error;
+        }
+    }
+    /**
+     * Get the item matching the given key. Tries in-memory cache first, then in the asynchronous
+     * storage object if item isn't found in-memory.
+     * @param key
+     * @param correlationId
+     */
+    async getItem(key, correlationId) {
+        const item = this.inMemoryCache.getItem(key);
+        if (!item) {
+            try {
+                this.logger.verbose("0naxpl", correlationId);
+                return await this.indexedDBCache.getItem(key);
+            }
+            catch (e) {
+                this.handleDatabaseAccessError(e, correlationId);
+            }
+        }
+        return item;
+    }
+    /**
+     * Sets the item in the in-memory cache and then tries to set it in the asynchronous
+     * storage object with the given key.
+     * @param key
+     * @param value
+     * @param correlationId
+     */
+    async setItem(key, value, correlationId) {
+        this.inMemoryCache.setItem(key, value);
+        try {
+            await this.indexedDBCache.setItem(key, value);
+        }
+        catch (e) {
+            this.handleDatabaseAccessError(e, correlationId);
+        }
+    }
+    /**
+     * Removes the item matching the key from the in-memory cache, then tries to remove it from the asynchronous storage object.
+     * @param key
+     * @param correlationId
+     */
+    async removeItem(key, correlationId) {
+        this.inMemoryCache.removeItem(key);
+        try {
+            await this.indexedDBCache.removeItem(key);
+        }
+        catch (e) {
+            this.handleDatabaseAccessError(e, correlationId);
+        }
+    }
+    /**
+     * Get all the keys from the in-memory cache as an iterable array of strings. If no keys are found, query the keys in the
+     * asynchronous storage object.
+     * @param correlationId
+     */
+    async getKeys(correlationId) {
+        const cacheKeys = this.inMemoryCache.getKeys();
+        if (cacheKeys.length === 0) {
+            try {
+                this.logger.verbose("1iqrbq", correlationId);
+                return await this.indexedDBCache.getKeys();
+            }
+            catch (e) {
+                this.handleDatabaseAccessError(e, correlationId);
+            }
+        }
+        return cacheKeys;
+    }
+    /**
+     * Returns true or false if the given key is present in the cache.
+     * @param key
+     * @param correlationId
+     */
+    async containsKey(key, correlationId) {
+        const containsKey = this.inMemoryCache.containsKey(key);
+        if (!containsKey) {
+            try {
+                this.logger.verbose("03zl2j", correlationId);
+                return await this.indexedDBCache.containsKey(key);
+            }
+            catch (e) {
+                this.handleDatabaseAccessError(e, correlationId);
+            }
+        }
+        return containsKey;
+    }
+    /**
+     * Clears in-memory Map
+     * @param correlationId
+     */
+    clearInMemory(correlationId) {
+        // InMemory cache is a Map instance, clear is straightforward
+        this.logger.verbose("03r21p", correlationId);
+        this.inMemoryCache.clear();
+        this.logger.verbose("0uksk1", correlationId);
+    }
+    /**
+     * Tries to delete the IndexedDB database
+     * @param correlationId
+     * @returns
+     */
+    async clearPersistent(correlationId) {
+        try {
+            this.logger.verbose("0rdqut", correlationId);
+            const dbDeleted = await this.indexedDBCache.deleteDatabase();
+            if (dbDeleted) {
+                this.logger.verbose("149ouc", correlationId);
+            }
+            return dbDeleted;
+        }
+        catch (e) {
+            this.handleDatabaseAccessError(e, correlationId);
+            return false;
+        }
+    }
+}
+
+export { AsyncMemoryStorage };
+//# sourceMappingURL=AsyncMemoryStorage.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/AsyncMemoryStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncMemoryStorage.mjs","sources":["../../src/cache/AsyncMemoryStorage.ts"],"sourcesContent":[null],"names":["BrowserAuthErrorCodes.databaseUnavailable"],"mappings":"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"}

backend/node_modules/@azure/msal-browser/dist/cache/CacheHelpers.mjs

@@ -0,0 +1,46 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { getAccountKeysCacheKey, getTokenKeysCacheKey } from './CacheKeys.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Returns a list of cache keys for all known accounts
+ * @param storage
+ * @returns
+ */
+function getAccountKeys(storage, schemaVersion) {
+    const accountKeys = storage.getItem(getAccountKeysCacheKey(schemaVersion));
+    if (accountKeys) {
+        return JSON.parse(accountKeys);
+    }
+    return [];
+}
+/**
+ * Returns a list of cache keys for all known tokens
+ * @param clientId
+ * @param storage
+ * @returns
+ */
+function getTokenKeys(clientId, storage, schemaVersion) {
+    const item = storage.getItem(getTokenKeysCacheKey(clientId, schemaVersion));
+    if (item) {
+        const tokenKeys = JSON.parse(item);
+        if (tokenKeys &&
+            tokenKeys.hasOwnProperty("idToken") &&
+            tokenKeys.hasOwnProperty("accessToken") &&
+            tokenKeys.hasOwnProperty("refreshToken")) {
+            return tokenKeys;
+        }
+    }
+    return {
+        idToken: [],
+        accessToken: [],
+        refreshToken: [],
+    };
+}
+
+export { getAccountKeys, getTokenKeys };
+//# sourceMappingURL=CacheHelpers.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/CacheHelpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheHelpers.mjs","sources":["../../src/cache/CacheHelpers.ts"],"sourcesContent":[null],"names":["CacheKeys.getAccountKeysCacheKey","CacheKeys.getTokenKeysCacheKey"],"mappings":";;;;AAAA;;;AAGG;AAMH;;;;AAIG;AACa,SAAA,cAAc,CAC1B,OAA+B,EAC/B,aAAsB,EAAA;AAEtB,IAAA,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAC/BA,sBAAgC,CAAC,aAAa,CAAC,CAClD,CAAC;AACF,IAAA,IAAI,WAAW,EAAE;AACb,QAAA,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAClC,KAAA;AAED,IAAA,OAAO,EAAE,CAAC;AACd,CAAC;AAED;;;;;AAKG;SACa,YAAY,CACxB,QAAgB,EAChB,OAA+B,EAC/B,aAAsB,EAAA;AAEtB,IAAA,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CACxBC,oBAA8B,CAAC,QAAQ,EAAE,aAAa,CAAC,CAC1D,CAAC;AACF,IAAA,IAAI,IAAI,EAAE;QACN,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACnC,QAAA,IACI,SAAS;AACT,YAAA,SAAS,CAAC,cAAc,CAAC,SAAS,CAAC;AACnC,YAAA,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;AACvC,YAAA,SAAS,CAAC,cAAc,CAAC,cAAc,CAAC,EAC1C;AACE,YAAA,OAAO,SAAsB,CAAC;AACjC,SAAA;AACJ,KAAA;IAED,OAAO;AACH,QAAA,OAAO,EAAE,EAAE;AACX,QAAA,WAAW,EAAE,EAAE;AACf,QAAA,YAAY,EAAE,EAAE;KACnB,CAAC;AACN;;;;"}

backend/node_modules/@azure/msal-browser/dist/cache/CacheKeys.mjs

@@ -0,0 +1,33 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const PREFIX = "msal";
+const BROWSER_PREFIX = "browser";
+const CACHE_KEY_SEPARATOR = "|";
+const CREDENTIAL_SCHEMA_VERSION = 3;
+const ACCOUNT_SCHEMA_VERSION = 3;
+const LOG_LEVEL_CACHE_KEY = `${PREFIX}.${BROWSER_PREFIX}.log.level`;
+const LOG_PII_CACHE_KEY = `${PREFIX}.${BROWSER_PREFIX}.log.pii`;
+const BROWSER_PERF_ENABLED_KEY = `${PREFIX}.${BROWSER_PREFIX}.performance.enabled`;
+const VERSION_CACHE_KEY = `${PREFIX}.version`;
+const ACCOUNT_KEYS = "account.keys";
+const TOKEN_KEYS = "token.keys";
+const SSO_CAPABLE = `${PREFIX}.${BROWSER_PREFIX}.sso.capable`;
+function getAccountKeysCacheKey(schema = ACCOUNT_SCHEMA_VERSION) {
+    if (schema < 1) {
+        return `${PREFIX}.${ACCOUNT_KEYS}`;
+    }
+    return `${PREFIX}.${schema}.${ACCOUNT_KEYS}`;
+}
+function getTokenKeysCacheKey(clientId, schema = CREDENTIAL_SCHEMA_VERSION) {
+    if (schema < 1) {
+        return `${PREFIX}.${TOKEN_KEYS}.${clientId}`;
+    }
+    return `${PREFIX}.${schema}.${TOKEN_KEYS}.${clientId}`;
+}
+
+export { ACCOUNT_KEYS, ACCOUNT_SCHEMA_VERSION, BROWSER_PERF_ENABLED_KEY, CACHE_KEY_SEPARATOR, CREDENTIAL_SCHEMA_VERSION, LOG_LEVEL_CACHE_KEY, LOG_PII_CACHE_KEY, PREFIX, SSO_CAPABLE, TOKEN_KEYS, VERSION_CACHE_KEY, getAccountKeysCacheKey, getTokenKeysCacheKey };
+//# sourceMappingURL=CacheKeys.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/CacheKeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheKeys.mjs","sources":["../../src/cache/CacheKeys.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;AAGG;AAEI,MAAM,MAAM,GAAG,OAAO;AAC7B,MAAM,cAAc,GAAG,SAAS,CAAC;AAC1B,MAAM,mBAAmB,GAAG,IAAI;AAChC,MAAM,yBAAyB,GAAG,EAAE;AACpC,MAAM,sBAAsB,GAAG,EAAE;MAE3B,mBAAmB,GAAG,GAAG,MAAM,CAAA,CAAA,EAAI,cAAc,CAAA,UAAA,EAAa;MAC9D,iBAAiB,GAAG,GAAG,MAAM,CAAA,CAAA,EAAI,cAAc,CAAA,QAAA,EAAW;MAC1D,wBAAwB,GAAG,GAAG,MAAM,CAAA,CAAA,EAAI,cAAc,CAAA,oBAAA,EAAuB;AAE7E,MAAA,iBAAiB,GAAG,CAAG,EAAA,MAAM,WAAW;AAC9C,MAAM,YAAY,GAAG,eAAe;AACpC,MAAM,UAAU,GAAG,aAAa;MAC1B,WAAW,GAAG,GAAG,MAAM,CAAA,CAAA,EAAI,cAAc,CAAA,YAAA,EAAe;AAErD,SAAA,sBAAsB,CAClC,MAAA,GAAiB,sBAAsB,EAAA;IAEvC,IAAI,MAAM,GAAG,CAAC,EAAE;AACZ,QAAA,OAAO,CAAG,EAAA,MAAM,CAAI,CAAA,EAAA,YAAY,EAAE,CAAC;AACtC,KAAA;AAED,IAAA,OAAO,GAAG,MAAM,CAAA,CAAA,EAAI,MAAM,CAAI,CAAA,EAAA,YAAY,EAAE,CAAC;AACjD,CAAC;SAEe,oBAAoB,CAChC,QAAgB,EAChB,SAAiB,yBAAyB,EAAA;IAE1C,IAAI,MAAM,GAAG,CAAC,EAAE;AACZ,QAAA,OAAO,GAAG,MAAM,CAAA,CAAA,EAAI,UAAU,CAAI,CAAA,EAAA,QAAQ,EAAE,CAAC;AAChD,KAAA;IAED,OAAO,CAAA,EAAG,MAAM,CAAI,CAAA,EAAA,MAAM,IAAI,UAAU,CAAA,CAAA,EAAI,QAAQ,CAAA,CAAE,CAAC;AAC3D;;;;"}

backend/node_modules/@azure/msal-browser/dist/cache/CookieStorage.mjs

@@ -0,0 +1,95 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { createClientAuthError, ClientAuthErrorCodes } from '@azure/msal-common/browser';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// Cookie life calculation (hours * minutes * seconds * ms)
+const COOKIE_LIFE_MULTIPLIER = 24 * 60 * 60 * 1000;
+const SameSiteOptions = {
+    Lax: "Lax",
+    None: "None",
+};
+class CookieStorage {
+    initialize() {
+        return Promise.resolve();
+    }
+    getItem(key) {
+        const name = encodeURIComponent(key);
+        const cookieList = document.cookie.split(";");
+        for (let i = 0; i < cookieList.length; i++) {
+            const cookie = cookieList[i].trim();
+            const eqIndex = cookie.indexOf("=");
+            const rawKey = eqIndex === -1 ? cookie : cookie.substring(0, eqIndex);
+            if (rawKey === name) {
+                const rawValue = eqIndex === -1 ? "" : cookie.substring(eqIndex + 1);
+                try {
+                    return decodeURIComponent(rawValue);
+                }
+                catch {
+                    return rawValue;
+                }
+            }
+        }
+        return "";
+    }
+    getUserData() {
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
+    }
+    setItem(key, value, cookieLifeDays, secure = true, sameSite = SameSiteOptions.Lax) {
+        let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)};path=/;SameSite=${sameSite};`;
+        if (cookieLifeDays) {
+            const expireTime = getCookieExpirationTime(cookieLifeDays);
+            cookieStr += `expires=${expireTime};`;
+        }
+        if (secure || sameSite === SameSiteOptions.None) {
+            // SameSite None requires Secure flag
+            cookieStr += "Secure;";
+        }
+        document.cookie = cookieStr;
+    }
+    async setUserData() {
+        return Promise.reject(createClientAuthError(ClientAuthErrorCodes.methodNotImplemented));
+    }
+    removeItem(key) {
+        // Setting expiration to -1 removes it
+        this.setItem(key, "", -1);
+    }
+    getKeys() {
+        const cookieList = document.cookie.split(";");
+        const keys = [];
+        cookieList.forEach((cookie) => {
+            const trimmed = cookie.trim();
+            const eqIndex = trimmed.indexOf("=");
+            const rawKey = eqIndex === -1 ? trimmed : trimmed.substring(0, eqIndex);
+            try {
+                keys.push(decodeURIComponent(rawKey));
+            }
+            catch {
+                // Skip cookies with malformed percent-encoded sequences in the key
+            }
+        });
+        return keys;
+    }
+    containsKey(key) {
+        return this.getKeys().includes(key);
+    }
+    decryptData() {
+        // Cookie storage does not support encryption, so this method is a no-op
+        return Promise.resolve(null);
+    }
+}
+/**
+ * Get cookie expiration time
+ * @param cookieLifeDays
+ */
+function getCookieExpirationTime(cookieLifeDays) {
+    const today = new Date();
+    const expr = new Date(today.getTime() + cookieLifeDays * COOKIE_LIFE_MULTIPLIER);
+    return expr.toUTCString();
+}
+
+export { CookieStorage, SameSiteOptions, getCookieExpirationTime };
+//# sourceMappingURL=CookieStorage.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/CookieStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CookieStorage.mjs","sources":["../../src/cache/CookieStorage.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

backend/node_modules/@azure/msal-browser/dist/cache/DatabaseStorage.mjs

@@ -0,0 +1,209 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
+import { DB_NAME, DB_VERSION, DB_TABLE_NAME } from '../utils/BrowserConstants.mjs';
+import { databaseUnavailable, databaseNotOpen } from '../error/BrowserAuthErrorCodes.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Storage wrapper for IndexedDB storage in browsers: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API
+ */
+class DatabaseStorage {
+    constructor() {
+        this.dbName = DB_NAME;
+        this.version = DB_VERSION;
+        this.tableName = DB_TABLE_NAME;
+        this.dbOpen = false;
+    }
+    /**
+     * Opens IndexedDB instance.
+     */
+    async open() {
+        return new Promise((resolve, reject) => {
+            const openDB = window.indexedDB.open(this.dbName, this.version);
+            openDB.addEventListener("upgradeneeded", (e) => {
+                const event = e;
+                event.target.result.createObjectStore(this.tableName);
+            });
+            openDB.addEventListener("success", (e) => {
+                const event = e;
+                this.db = event.target.result;
+                this.dbOpen = true;
+                resolve();
+            });
+            openDB.addEventListener("error", () => reject(createBrowserAuthError(databaseUnavailable)));
+        });
+    }
+    /**
+     * Closes the connection to IndexedDB database when all pending transactions
+     * complete.
+     */
+    closeConnection() {
+        const db = this.db;
+        if (db && this.dbOpen) {
+            db.close();
+            this.dbOpen = false;
+        }
+    }
+    /**
+     * Opens database if it's not already open
+     */
+    async validateDbIsOpen() {
+        if (!this.dbOpen) {
+            return this.open();
+        }
+    }
+    /**
+     * Retrieves item from IndexedDB instance.
+     * @param key
+     */
+    async getItem(key) {
+        await this.validateDbIsOpen();
+        return new Promise((resolve, reject) => {
+            // TODO: Add timeouts?
+            if (!this.db) {
+                return reject(createBrowserAuthError(databaseNotOpen));
+            }
+            const transaction = this.db.transaction([this.tableName], "readonly");
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbGet = objectStore.get(key);
+            dbGet.addEventListener("success", (e) => {
+                const event = e;
+                this.closeConnection();
+                resolve(event.target.result);
+            });
+            dbGet.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+    /**
+     * Adds item to IndexedDB under given key
+     * @param key
+     * @param payload
+     */
+    async setItem(key, payload) {
+        await this.validateDbIsOpen();
+        return new Promise((resolve, reject) => {
+            // TODO: Add timeouts?
+            if (!this.db) {
+                return reject(createBrowserAuthError(databaseNotOpen));
+            }
+            const transaction = this.db.transaction([this.tableName], "readwrite");
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbPut = objectStore.put(payload, key);
+            dbPut.addEventListener("success", () => {
+                this.closeConnection();
+                resolve();
+            });
+            dbPut.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+    /**
+     * Removes item from IndexedDB under given key
+     * @param key
+     */
+    async removeItem(key) {
+        await this.validateDbIsOpen();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                return reject(createBrowserAuthError(databaseNotOpen));
+            }
+            const transaction = this.db.transaction([this.tableName], "readwrite");
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbDelete = objectStore.delete(key);
+            dbDelete.addEventListener("success", () => {
+                this.closeConnection();
+                resolve();
+            });
+            dbDelete.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+    /**
+     * Get all the keys from the storage object as an iterable array of strings.
+     */
+    async getKeys() {
+        await this.validateDbIsOpen();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                return reject(createBrowserAuthError(databaseNotOpen));
+            }
+            const transaction = this.db.transaction([this.tableName], "readonly");
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbGetKeys = objectStore.getAllKeys();
+            dbGetKeys.addEventListener("success", (e) => {
+                const event = e;
+                this.closeConnection();
+                resolve(event.target.result);
+            });
+            dbGetKeys.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+    /**
+     *
+     * Checks whether there is an object under the search key in the object store
+     */
+    async containsKey(key) {
+        await this.validateDbIsOpen();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                return reject(createBrowserAuthError(databaseNotOpen));
+            }
+            const transaction = this.db.transaction([this.tableName], "readonly");
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbContainsKey = objectStore.count(key);
+            dbContainsKey.addEventListener("success", (e) => {
+                const event = e;
+                this.closeConnection();
+                resolve(event.target.result === 1);
+            });
+            dbContainsKey.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+    /**
+     * Deletes the MSAL database. The database is deleted rather than cleared to make it possible
+     * for client applications to downgrade to a previous MSAL version without worrying about forward compatibility issues
+     * with IndexedDB database versions.
+     */
+    async deleteDatabase() {
+        // Check if database being deleted exists
+        if (this.db && this.dbOpen) {
+            this.closeConnection();
+        }
+        return new Promise((resolve, reject) => {
+            const deleteDbRequest = window.indexedDB.deleteDatabase(DB_NAME);
+            const id = setTimeout(() => reject(false), 200); // Reject if events aren't raised within 200ms
+            deleteDbRequest.addEventListener("success", () => {
+                clearTimeout(id);
+                return resolve(true);
+            });
+            deleteDbRequest.addEventListener("blocked", () => {
+                clearTimeout(id);
+                return resolve(true);
+            });
+            deleteDbRequest.addEventListener("error", () => {
+                clearTimeout(id);
+                return reject(false);
+            });
+        });
+    }
+}
+
+export { DatabaseStorage };
+//# sourceMappingURL=DatabaseStorage.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/EncryptedData.mjs

@@ -0,0 +1,14 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+function isEncrypted(data) {
+    return (data.hasOwnProperty("id") &&
+        data.hasOwnProperty("nonce") &&
+        data.hasOwnProperty("data"));
+}
+
+export { isEncrypted };
+//# sourceMappingURL=EncryptedData.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/EncryptedData.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptedData.mjs","sources":["../../src/cache/EncryptedData.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;AAGG;AASG,SAAU,WAAW,CAAC,IAAY,EAAA;AACpC,IAAA,QACI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;AACzB,QAAA,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;AAC5B,QAAA,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAC7B;AACN;;;;"}

backend/node_modules/@azure/msal-browser/dist/cache/LocalStorage.mjs

@@ -0,0 +1,310 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { invoke, invokeAsync } from '@azure/msal-common/browser';
+import { Base64Decode, GenerateHKDF, GenerateBaseKey, UrlEncodeArr, ImportExistingCache, Decrypt, Encrypt } from '../telemetry/BrowserPerformanceEvents.mjs';
+import { LocalStorageUpdated } from '../telemetry/BrowserRootPerformanceEvents.mjs';
+import { generateHKDF, createNewGuid, generateBaseKey, decrypt, encrypt } from '../crypto/BrowserCrypto.mjs';
+import { base64DecToArr } from '../encode/Base64Decode.mjs';
+import { urlEncodeArr } from '../encode/Base64Encode.mjs';
+import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
+import { createBrowserConfigurationAuthError } from '../error/BrowserConfigurationAuthError.mjs';
+import { CookieStorage, SameSiteOptions } from './CookieStorage.mjs';
+import { MemoryStorage } from './MemoryStorage.mjs';
+import { getAccountKeys, getTokenKeys } from './CacheHelpers.mjs';
+import { PREFIX, getAccountKeysCacheKey, getTokenKeysCacheKey } from './CacheKeys.mjs';
+import { isEncrypted } from './EncryptedData.mjs';
+import { storageNotSupported } from '../error/BrowserConfigurationAuthErrorCodes.mjs';
+import { uninitializedPublicClientApplication } from '../error/BrowserAuthErrorCodes.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const ENCRYPTION_KEY = "msal.cache.encryption";
+const BROADCAST_CHANNEL_NAME = "msal.broadcast.cache";
+class LocalStorage {
+    constructor(clientId, logger, performanceClient) {
+        if (!window.localStorage) {
+            throw createBrowserConfigurationAuthError(storageNotSupported);
+        }
+        this.memoryStorage = new MemoryStorage();
+        this.initialized = false;
+        this.clientId = clientId;
+        this.logger = logger;
+        this.performanceClient = performanceClient;
+        this.broadcast = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+    }
+    async initialize(correlationId) {
+        const cookies = new CookieStorage();
+        const cookieString = cookies.getItem(ENCRYPTION_KEY);
+        let parsedCookie = { key: "", id: "" };
+        if (cookieString) {
+            try {
+                parsedCookie = JSON.parse(cookieString);
+            }
+            catch (e) { }
+        }
+        if (parsedCookie.key && parsedCookie.id) {
+            // Encryption key already exists, import
+            const baseKey = invoke(base64DecToArr, Base64Decode, this.logger, this.performanceClient, correlationId)(parsedCookie.key);
+            this.encryptionCookie = {
+                id: parsedCookie.id,
+                key: await invokeAsync(generateHKDF, GenerateHKDF, this.logger, this.performanceClient, correlationId)(baseKey),
+            };
+        }
+        else {
+            // Encryption key doesn't exist or is invalid, generate a new one
+            const id = createNewGuid();
+            const baseKey = await invokeAsync(generateBaseKey, GenerateBaseKey, this.logger, this.performanceClient, correlationId)();
+            const keyStr = invoke(urlEncodeArr, UrlEncodeArr, this.logger, this.performanceClient, correlationId)(new Uint8Array(baseKey));
+            this.encryptionCookie = {
+                id: id,
+                key: await invokeAsync(generateHKDF, GenerateHKDF, this.logger, this.performanceClient, correlationId)(baseKey),
+            };
+            const cookieData = {
+                id: id,
+                key: keyStr,
+            };
+            cookies.setItem(ENCRYPTION_KEY, JSON.stringify(cookieData), 0, // Expiration - 0 means cookie will be cleared at the end of the browser session
+            true, // Secure flag
+            SameSiteOptions.None // SameSite must be None to support iframed apps
+            );
+        }
+        await invokeAsync(this.importExistingCache.bind(this), ImportExistingCache, this.logger, this.performanceClient, correlationId)(correlationId);
+        // Register listener for cache updates in other tabs
+        this.broadcast.addEventListener("message", (event) => {
+            this.updateCache(event, correlationId);
+        });
+        this.initialized = true;
+    }
+    getItem(key) {
+        return window.localStorage.getItem(key);
+    }
+    getUserData(key) {
+        if (!this.initialized) {
+            throw createBrowserAuthError(uninitializedPublicClientApplication);
+        }
+        return this.memoryStorage.getItem(key);
+    }
+    async decryptData(key, data, correlationId) {
+        if (!this.initialized || !this.encryptionCookie) {
+            throw createBrowserAuthError(uninitializedPublicClientApplication);
+        }
+        if (data.id !== this.encryptionCookie.id) {
+            // Data was encrypted with a different key. It must be removed because it is from a previous session.
+            this.performanceClient.incrementFields({ encryptedCacheExpiredCount: 1 }, correlationId);
+            return null;
+        }
+        const decryptedData = await invokeAsync(decrypt, Decrypt, this.logger, this.performanceClient, correlationId)(this.encryptionCookie.key, data.nonce, this.getContext(key), data.data);
+        if (!decryptedData) {
+            return null;
+        }
+        try {
+            return {
+                ...JSON.parse(decryptedData),
+                lastUpdatedAt: data.lastUpdatedAt,
+            };
+        }
+        catch (e) {
+            this.performanceClient.incrementFields({ encryptedCacheCorruptionCount: 1 }, correlationId);
+            return null;
+        }
+    }
+    setItem(key, value) {
+        window.localStorage.setItem(key, value);
+    }
+    async setUserData(key, value, correlationId, timestamp, kmsi) {
+        if (!this.initialized || !this.encryptionCookie) {
+            throw createBrowserAuthError(uninitializedPublicClientApplication);
+        }
+        if (kmsi) {
+            this.setItem(key, value);
+        }
+        else {
+            const { data, nonce } = await invokeAsync(encrypt, Encrypt, this.logger, this.performanceClient, correlationId)(this.encryptionCookie.key, value, this.getContext(key));
+            const encryptedData = {
+                id: this.encryptionCookie.id,
+                nonce: nonce,
+                data: data,
+                lastUpdatedAt: timestamp,
+            };
+            this.setItem(key, JSON.stringify(encryptedData));
+        }
+        this.memoryStorage.setItem(key, value);
+        // Notify other frames to update their in-memory cache
+        this.broadcast.postMessage({
+            key: key,
+            value: value,
+            context: this.getContext(key),
+        });
+    }
+    removeItem(key) {
+        if (this.memoryStorage.containsKey(key)) {
+            this.memoryStorage.removeItem(key);
+            this.broadcast.postMessage({
+                key: key,
+                value: null,
+                context: this.getContext(key),
+            });
+        }
+        window.localStorage.removeItem(key);
+    }
+    getKeys() {
+        return Object.keys(window.localStorage);
+    }
+    containsKey(key) {
+        return window.localStorage.hasOwnProperty(key);
+    }
+    /**
+     * Removes all known MSAL keys from the cache
+     */
+    clear() {
+        // Removes all remaining MSAL cache items
+        this.memoryStorage.clear();
+        const accountKeys = getAccountKeys(this);
+        accountKeys.forEach((key) => this.removeItem(key));
+        const tokenKeys = getTokenKeys(this.clientId, this);
+        tokenKeys.idToken.forEach((key) => this.removeItem(key));
+        tokenKeys.accessToken.forEach((key) => this.removeItem(key));
+        tokenKeys.refreshToken.forEach((key) => this.removeItem(key));
+        // Clean up anything left
+        this.getKeys().forEach((cacheKey) => {
+            if (cacheKey.startsWith(PREFIX) ||
+                cacheKey.indexOf(this.clientId) !== -1) {
+                this.removeItem(cacheKey);
+            }
+        });
+    }
+    /**
+     * Helper to decrypt all known MSAL keys in localStorage and save them to inMemory storage
+     * @returns
+     */
+    async importExistingCache(correlationId) {
+        if (!this.encryptionCookie) {
+            return;
+        }
+        let accountKeys = getAccountKeys(this);
+        accountKeys = await this.importArray(accountKeys, correlationId);
+        // Write valid account keys back to map
+        if (accountKeys.length) {
+            this.setItem(getAccountKeysCacheKey(), JSON.stringify(accountKeys));
+        }
+        else {
+            this.removeItem(getAccountKeysCacheKey());
+        }
+        const tokenKeys = getTokenKeys(this.clientId, this);
+        tokenKeys.idToken = await this.importArray(tokenKeys.idToken, correlationId);
+        tokenKeys.accessToken = await this.importArray(tokenKeys.accessToken, correlationId);
+        tokenKeys.refreshToken = await this.importArray(tokenKeys.refreshToken, correlationId);
+        // Write valid token keys back to map
+        if (tokenKeys.idToken.length ||
+            tokenKeys.accessToken.length ||
+            tokenKeys.refreshToken.length) {
+            this.setItem(getTokenKeysCacheKey(this.clientId), JSON.stringify(tokenKeys));
+        }
+        else {
+            this.removeItem(getTokenKeysCacheKey(this.clientId));
+        }
+    }
+    /**
+     * Helper to decrypt and save cache entries
+     * @param key
+     * @returns
+     */
+    async getItemFromEncryptedCache(key, correlationId) {
+        if (!this.encryptionCookie) {
+            return null;
+        }
+        const rawCache = this.getItem(key);
+        if (!rawCache) {
+            return null;
+        }
+        let encObj;
+        try {
+            encObj = JSON.parse(rawCache);
+        }
+        catch (e) {
+            // Not a valid encrypted object, remove
+            return null;
+        }
+        if (!isEncrypted(encObj)) {
+            // Data is not encrypted
+            this.performanceClient.incrementFields({ unencryptedCacheCount: 1 }, correlationId);
+            return rawCache;
+        }
+        if (encObj.id !== this.encryptionCookie.id) {
+            // Data was encrypted with a different key. It must be removed because it is from a previous session.
+            this.performanceClient.incrementFields({ encryptedCacheExpiredCount: 1 }, correlationId);
+            return null;
+        }
+        this.performanceClient.incrementFields({ encryptedCacheCount: 1 }, correlationId);
+        return invokeAsync(decrypt, Decrypt, this.logger, this.performanceClient, correlationId)(this.encryptionCookie.key, encObj.nonce, this.getContext(key), encObj.data);
+    }
+    /**
+     * Helper to decrypt and save an array of cache keys
+     * @param arr
+     * @returns Array of keys successfully imported
+     */
+    async importArray(arr, correlationId) {
+        const importedArr = [];
+        const promiseArr = [];
+        arr.forEach((key) => {
+            const promise = this.getItemFromEncryptedCache(key, correlationId).then((value) => {
+                if (value) {
+                    this.memoryStorage.setItem(key, value);
+                    importedArr.push(key);
+                }
+                else {
+                    // If value is empty, unencrypted or expired remove
+                    this.removeItem(key);
+                }
+            });
+            promiseArr.push(promise);
+        });
+        await Promise.all(promiseArr);
+        return importedArr;
+    }
+    /**
+     * Gets encryption context for a given cache entry. This is clientId for app specific entries, empty string for shared entries
+     * @param key
+     * @returns
+     */
+    getContext(key) {
+        let context = "";
+        if (key.includes(this.clientId)) {
+            context = this.clientId; // Used to bind encryption key to this appId
+        }
+        return context;
+    }
+    updateCache(event, correlationId) {
+        this.logger.trace("17cxcm", correlationId);
+        const perfMeasurement = this.performanceClient.startMeasurement(LocalStorageUpdated);
+        perfMeasurement.add({ isBackground: true });
+        const { key, value, context } = event.data;
+        if (!key) {
+            this.logger.error("0e10qr", correlationId);
+            perfMeasurement.end({ success: false, errorCode: "noKey" });
+            return;
+        }
+        if (context && context !== this.clientId) {
+            this.logger.trace("04rtdy", correlationId);
+            perfMeasurement.end({
+                success: false,
+                errorCode: "contextMismatch",
+            });
+            return;
+        }
+        if (!value) {
+            this.memoryStorage.removeItem(key);
+            this.logger.verbose("04ypih", correlationId);
+        }
+        else {
+            this.memoryStorage.setItem(key, value);
+            this.logger.verbose("1vzsgt", correlationId);
+        }
+        perfMeasurement.end({ success: true });
+    }
+}
+
+export { LocalStorage };
+//# sourceMappingURL=LocalStorage.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/MemoryStorage.mjs

@@ -0,0 +1,49 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class MemoryStorage {
+    constructor() {
+        this.cache = new Map();
+    }
+    async initialize() {
+        // Memory storage does not require initialization
+    }
+    getItem(key) {
+        return this.cache.get(key) || null;
+    }
+    getUserData(key) {
+        return this.getItem(key);
+    }
+    setItem(key, value) {
+        this.cache.set(key, value);
+    }
+    async setUserData(key, value) {
+        this.setItem(key, value);
+    }
+    removeItem(key) {
+        this.cache.delete(key);
+    }
+    getKeys() {
+        const cacheKeys = [];
+        this.cache.forEach((value, key) => {
+            cacheKeys.push(key);
+        });
+        return cacheKeys;
+    }
+    containsKey(key) {
+        return this.cache.has(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    decryptData() {
+        // Memory storage does not support encryption, so this method is a no-op
+        return Promise.resolve(null);
+    }
+}
+
+export { MemoryStorage };
+//# sourceMappingURL=MemoryStorage.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/MemoryStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryStorage.mjs","sources":["../../src/cache/MemoryStorage.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;AAGG;MAIU,aAAa,CAAA;AAGtB,IAAA,WAAA,GAAA;AACI,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAa,CAAC;KACrC;AAED,IAAA,MAAM,UAAU,GAAA;;KAEf;AAED,IAAA,OAAO,CAAC,GAAW,EAAA;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;KACtC;AAED,IAAA,WAAW,CAAC,GAAW,EAAA;AACnB,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;KAC5B;IAED,OAAO,CAAC,GAAW,EAAE,KAAQ,EAAA;QACzB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KAC9B;AAED,IAAA,MAAM,WAAW,CAAC,GAAW,EAAE,KAAQ,EAAA;AACnC,QAAA,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KAC5B;AAED,IAAA,UAAU,CAAC,GAAW,EAAA;AAClB,QAAA,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;KAC1B;IAED,OAAO,GAAA;QACH,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAQ,EAAE,GAAW,KAAI;AACzC,YAAA,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACxB,SAAC,CAAC,CAAC;AACH,QAAA,OAAO,SAAS,CAAC;KACpB;AAED,IAAA,WAAW,CAAC,GAAW,EAAA;QACnB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;KAC9B;IAED,KAAK,GAAA;AACD,QAAA,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;KACtB;IAED,WAAW,GAAA;;AAEP,QAAA,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;KAChC;AACJ;;;;"}

backend/node_modules/@azure/msal-browser/dist/cache/SessionStorage.mjs

@@ -0,0 +1,47 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { createBrowserConfigurationAuthError } from '../error/BrowserConfigurationAuthError.mjs';
+import { storageNotSupported } from '../error/BrowserConfigurationAuthErrorCodes.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class SessionStorage {
+    constructor() {
+        if (!window.sessionStorage) {
+            throw createBrowserConfigurationAuthError(storageNotSupported);
+        }
+    }
+    async initialize() {
+        // Session storage does not require initialization
+    }
+    getItem(key) {
+        return window.sessionStorage.getItem(key);
+    }
+    getUserData(key) {
+        return this.getItem(key);
+    }
+    setItem(key, value) {
+        window.sessionStorage.setItem(key, value);
+    }
+    async setUserData(key, value) {
+        this.setItem(key, value);
+    }
+    removeItem(key) {
+        window.sessionStorage.removeItem(key);
+    }
+    getKeys() {
+        return Object.keys(window.sessionStorage);
+    }
+    containsKey(key) {
+        return window.sessionStorage.hasOwnProperty(key);
+    }
+    decryptData() {
+        // Session storage does not support encryption, so this method is a no-op
+        return Promise.resolve(null);
+    }
+}
+
+export { SessionStorage };
+//# sourceMappingURL=SessionStorage.mjs.map

backend/node_modules/@azure/msal-browser/dist/cache/SessionStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionStorage.mjs","sources":["../../src/cache/SessionStorage.ts"],"sourcesContent":[null],"names":["BrowserConfigurationAuthErrorCodes.storageNotSupported"],"mappings":";;;;;AAAA;;;AAGG;MAQU,cAAc,CAAA;AACvB,IAAA,WAAA,GAAA;AACI,QAAA,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE;AACxB,YAAA,MAAM,mCAAmC,CACrCA,mBAAsD,CACzD,CAAC;AACL,SAAA;KACJ;AAED,IAAA,MAAM,UAAU,GAAA;;KAEf;AAED,IAAA,OAAO,CAAC,GAAW,EAAA;QACf,OAAO,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;KAC7C;AAED,IAAA,WAAW,CAAC,GAAW,EAAA;AACnB,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;KAC5B;IAED,OAAO,CAAC,GAAW,EAAE,KAAa,EAAA;QAC9B,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KAC7C;AAED,IAAA,MAAM,WAAW,CAAC,GAAW,EAAE,KAAa,EAAA;AACxC,QAAA,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KAC5B;AAED,IAAA,UAAU,CAAC,GAAW,EAAA;AAClB,QAAA,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;KACzC;IAED,OAAO,GAAA;QACH,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;KAC7C;AAED,IAAA,WAAW,CAAC,GAAW,EAAA;QACnB,OAAO,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;KACpD;IAED,WAAW,GAAA;;AAEP,QAAA,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;KAChC;AACJ;;;;"}

backend/node_modules/@azure/msal-browser/dist/cache/TokenCache.mjs

@@ -0,0 +1,218 @@
+/*! @azure/msal-browser v5.11.0 2026-05-19 */
+'use strict';
+import { StubPerformanceClient, AuthToken, Logger, buildStaticAuthorityOptions, AuthorityFactory, Authority, invokeAsync, AccountEntityUtils, buildAccountToCache, CacheHelpers, ScopeSet, TimeUtils } from '@azure/msal-common/browser';
+import { buildConfiguration } from '../config/Configuration.mjs';
+import { createNewGuid } from '../crypto/BrowserCrypto.mjs';
+import { CryptoOps } from '../crypto/CryptoOps.mjs';
+import { base64Decode } from '../encode/Base64Decode.mjs';
+import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
+import { EventHandler } from '../event/EventHandler.mjs';
+import { LoadAccount, LoadIdToken, LoadAccessToken, LoadRefreshToken } from '../telemetry/BrowserPerformanceEvents.mjs';
+import { LoadExternalTokens } from '../telemetry/BrowserRootPerformanceEvents.mjs';
+import { ApiId } from '../utils/BrowserConstants.mjs';
+import { blockNonBrowserEnvironment } from '../utils/BrowserUtils.mjs';
+import { BrowserCacheManager } from './BrowserCacheManager.mjs';
+import { unableToLoadToken } from '../error/BrowserAuthErrorCodes.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * API to load tokens to msal-browser cache.
+ * @param config - Object to configure the MSAL app.
+ * @param request - Silent request containing authority, scopes, and account.
+ * @param response - External token response to load into the cache.
+ * @param options - Options controlling how tokens are loaded into the cache.
+ * @param performanceClient - Optional performance client used for telemetry measurements.
+ * @returns `AuthenticationResult` for the response that was loaded.
+ */
+async function loadExternalTokens(config, request, response, options, performanceClient = new StubPerformanceClient()) {
+    blockNonBrowserEnvironment();
+    const browserConfig = buildConfiguration(config, true);
+    const correlationId = request.correlationId || createNewGuid();
+    const rootMeasurement = performanceClient.startMeasurement(LoadExternalTokens, correlationId);
+    try {
+        const idTokenClaims = response.id_token
+            ? AuthToken.extractTokenClaims(response.id_token, base64Decode)
+            : undefined;
+        const kmsi = AuthToken.isKmsi(idTokenClaims || {});
+        const authorityOptions = {
+            protocolMode: browserConfig.system.protocolMode,
+            knownAuthorities: browserConfig.auth.knownAuthorities,
+            cloudDiscoveryMetadata: browserConfig.auth.cloudDiscoveryMetadata,
+            authorityMetadata: browserConfig.auth.authorityMetadata,
+        };
+        const logger = new Logger(browserConfig.system.loggerOptions || {});
+        const cryptoOps = new CryptoOps(logger, browserConfig.telemetry.client);
+        const storage = new BrowserCacheManager(browserConfig.auth.clientId, browserConfig.cache, cryptoOps, logger, browserConfig.telemetry.client, new EventHandler(logger), buildStaticAuthorityOptions(browserConfig.auth));
+        const authorityString = request.authority || browserConfig.auth.authority;
+        const authority = await AuthorityFactory.createDiscoveredInstance(Authority.generateAuthority(authorityString, request.azureCloudOptions), browserConfig.system.networkClient, storage, authorityOptions, logger, correlationId, performanceClient);
+        const cacheRecordAccount = await invokeAsync(loadAccount, LoadAccount, logger, performanceClient, correlationId)(request, options.clientInfo || response.client_info || "", correlationId, storage, logger, cryptoOps, authority, idTokenClaims, performanceClient);
+        const idToken = await invokeAsync(loadIdToken, LoadIdToken, logger, performanceClient, correlationId)(response, cacheRecordAccount.homeAccountId, cacheRecordAccount.environment, cacheRecordAccount.realm, kmsi, correlationId, storage, logger, config.auth.clientId);
+        const accessToken = await invokeAsync(loadAccessToken, LoadAccessToken, logger, performanceClient, correlationId)(request, response, cacheRecordAccount.homeAccountId, cacheRecordAccount.environment, cacheRecordAccount.realm, kmsi, options, correlationId, storage, logger, config.auth.clientId);
+        const refreshToken = await invokeAsync(loadRefreshToken, LoadRefreshToken, logger, performanceClient, correlationId)(response, cacheRecordAccount.homeAccountId, cacheRecordAccount.environment, kmsi, correlationId, storage, logger, config.auth.clientId, performanceClient);
+        rootMeasurement.end({ success: true }, undefined, AccountEntityUtils.getAccountInfo(cacheRecordAccount));
+        return generateAuthenticationResult(request, {
+            account: cacheRecordAccount,
+            idToken,
+            accessToken,
+            refreshToken,
+        }, authority, idTokenClaims);
+    }
+    catch (error) {
+        rootMeasurement.end({ success: false }, error);
+        throw error;
+    }
+}
+/**
+ * Helper function to load account to msal-browser cache
+ * @param idToken
+ * @param environment
+ * @param clientInfo
+ * @param authorityType
+ * @param requestHomeAccountId
+ * @returns `AccountEntity`
+ */
+async function loadAccount(request, clientInfo, correlationId, storage, logger, cryptoObj, authority, idTokenClaims, performanceClient) {
+    logger.verbose("0ke46k", correlationId);
+    if (request.account) {
+        const accountEntity = AccountEntityUtils.createAccountEntityFromAccountInfo(request.account);
+        await storage.setAccount(accountEntity, correlationId, AuthToken.isKmsi(idTokenClaims || {}), ApiId.loadExternalTokens);
+        return accountEntity;
+    }
+    else if (!clientInfo && !idTokenClaims) {
+        logger.error("0hzcn4", correlationId);
+        throw createBrowserAuthError(unableToLoadToken);
+    }
+    const homeAccountId = AccountEntityUtils.generateHomeAccountId(clientInfo, authority.authorityType, logger, cryptoObj, correlationId, idTokenClaims);
+    const claimsTenantId = idTokenClaims?.tid;
+    const cachedAccount = buildAccountToCache(storage, authority, homeAccountId, base64Decode, correlationId, idTokenClaims, clientInfo, authority.getPreferredCache(), claimsTenantId, undefined, // authCodePayload
+    undefined, // nativeAccountId
+    logger, performanceClient);
+    await storage.setAccount(cachedAccount, correlationId, AuthToken.isKmsi(idTokenClaims || {}), ApiId.loadExternalTokens);
+    return cachedAccount;
+}
+/**
+ * Helper function to load id tokens to msal-browser cache
+ * @param idToken
+ * @param homeAccountId
+ * @param environment
+ * @param tenantId
+ * @returns `IdTokenEntity`
+ */
+async function loadIdToken(response, homeAccountId, environment, tenantId, kmsi, correlationId, storage, logger, clientId) {
+    if (!response.id_token) {
+        logger.verbose("1pm7g1", correlationId);
+        return null;
+    }
+    logger.verbose("168lyi", correlationId);
+    const idTokenEntity = CacheHelpers.createIdTokenEntity(homeAccountId, environment, response.id_token, clientId, tenantId);
+    await storage.setIdTokenCredential(idTokenEntity, correlationId, kmsi);
+    return idTokenEntity;
+}
+/**
+ * Helper function to load access tokens to msal-browser cache
+ * @param request
+ * @param response
+ * @param homeAccountId
+ * @param environment
+ * @param tenantId
+ * @returns `AccessTokenEntity`
+ */
+async function loadAccessToken(request, response, homeAccountId, environment, tenantId, kmsi, options, correlationId, storage, logger, clientId) {
+    if (!response.access_token) {
+        logger.verbose("1ckp9e", correlationId);
+        return null;
+    }
+    else if (!response.expires_in) {
+        logger.error("15mzx8", correlationId);
+        return null;
+    }
+    else if (!response.scope && (!request.scopes || !request.scopes.length)) {
+        logger.error("1h7xse", correlationId);
+        return null;
+    }
+    logger.verbose("01kmxb", correlationId);
+    const scopes = response.scope
+        ? ScopeSet.fromString(response.scope)
+        : new ScopeSet(request.scopes);
+    const expiresOn = options.expiresOn || response.expires_in + TimeUtils.nowSeconds();
+    const extendedExpiresOn = options.extendedExpiresOn ||
+        (response.ext_expires_in || response.expires_in) +
+            TimeUtils.nowSeconds();
+    const accessTokenEntity = CacheHelpers.createAccessTokenEntity(homeAccountId, environment, response.access_token, clientId, tenantId, scopes.printScopes(), expiresOn, extendedExpiresOn, base64Decode);
+    await storage.setAccessTokenCredential(accessTokenEntity, correlationId, kmsi);
+    return accessTokenEntity;
+}
+/**
+ * Helper function to load refresh tokens to msal-browser cache
+ * @param request
+ * @param response
+ * @param homeAccountId
+ * @param environment
+ * @returns `RefreshTokenEntity`
+ */
+async function loadRefreshToken(response, homeAccountId, environment, kmsi, correlationId, storage, logger, clientId, performanceClient) {
+    if (!response.refresh_token) {
+        logger.verbose("1l7um5", correlationId);
+        return null;
+    }
+    const expiresOn = response.refresh_token_expires_in
+        ? response.refresh_token_expires_in + TimeUtils.nowSeconds()
+        : undefined;
+    performanceClient.addFields({
+        extRtExpiresOnSeconds: expiresOn,
+    }, correlationId);
+    logger.verbose("0qy8ev", correlationId);
+    const refreshTokenEntity = CacheHelpers.createRefreshTokenEntity(homeAccountId, environment, response.refresh_token, clientId, response.foci, undefined, // userAssertionHash
+    expiresOn);
+    await storage.setRefreshTokenCredential(refreshTokenEntity, correlationId, kmsi);
+    return refreshTokenEntity;
+}
+/**
+ * Helper function to generate an `AuthenticationResult` for the result.
+ * @param request
+ * @param idTokenObj
+ * @param cacheRecord
+ * @param authority
+ * @returns `AuthenticationResult`
+ */
+function generateAuthenticationResult(request, cacheRecord, authority, idTokenClaims) {
+    let accessToken = "";
+    let responseScopes = [];
+    let expiresOn = null;
+    let extExpiresOn;
+    if (cacheRecord?.accessToken) {
+        accessToken = cacheRecord.accessToken.secret;
+        responseScopes = ScopeSet.fromString(cacheRecord.accessToken.target).asArray();
+        // Access token expiresOn stored in seconds, converting to Date for AuthenticationResult
+        expiresOn = TimeUtils.toDateFromSeconds(cacheRecord.accessToken.expiresOn);
+        extExpiresOn = TimeUtils.toDateFromSeconds(cacheRecord.accessToken.extendedExpiresOn);
+    }
+    const accountEntity = cacheRecord.account;
+    return {
+        authority: authority.canonicalAuthority,
+        uniqueId: cacheRecord.account.localAccountId,
+        tenantId: cacheRecord.account.realm,
+        scopes: responseScopes,
+        account: AccountEntityUtils.getAccountInfo(accountEntity),
+        idToken: cacheRecord.idToken?.secret || "",
+        idTokenClaims: idTokenClaims || {},
+        accessToken: accessToken,
+        fromCache: true,
+        expiresOn: expiresOn,
+        correlationId: request.correlationId || "",
+        requestId: "",
+        extExpiresOn: extExpiresOn,
+        familyId: cacheRecord.refreshToken?.familyId || "",
+        tokenType: cacheRecord?.accessToken?.tokenType || "",
+        state: request.state || "",
+        cloudGraphHostName: accountEntity.cloudGraphHostName || "",
+        msGraphHost: accountEntity.msGraphHost || "",
+        fromPlatformBroker: false,
+    };
+}
+
+export { loadExternalTokens };
+//# sourceMappingURL=TokenCache.mjs.map