@hamak/auth 0.5.1

package/dist/impl/services/AuthService.js

@@ -0,0 +1,277 @@
+/**
+ * Auth Service Implementation
+ * Core authentication service that orchestrates strategies and storage
+ */
+/**
+ * Auth service implementation
+ *
+ * Provides a unified authentication API that delegates to registered
+ * strategies and manages token storage and state.
+ */
+export class AuthService {
+    constructor(strategyRegistry, tokenStorage) {
+        this.strategyRegistry = strategyRegistry;
+        this.tokenStorage = tokenStorage;
+        this.user = null;
+        this.listeners = new Set();
+        this.initialized = false;
+    }
+    // ============================================================
+    // Lifecycle
+    // ============================================================
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Restore user from storage
+        this.user = this.tokenStorage.getUser();
+        // Check if token is valid
+        if (this.tokenStorage.isTokenExpired()) {
+            // Try to refresh
+            const refreshToken = this.tokenStorage.getRefreshToken();
+            if (refreshToken) {
+                const result = await this.refreshToken();
+                if (!result.success) {
+                    // Clear invalid session
+                    this.tokenStorage.clearAll();
+                    this.user = null;
+                }
+            }
+            else {
+                // No refresh token, clear session
+                this.tokenStorage.clearAll();
+                this.user = null;
+            }
+        }
+        this.initialized = true;
+    }
+    destroy() {
+        this.listeners.clear();
+        this.initialized = false;
+    }
+    // ============================================================
+    // State Queries
+    // ============================================================
+    isAuthenticated() {
+        return !!this.tokenStorage.getAccessToken() && !this.tokenStorage.isTokenExpired();
+    }
+    getCurrentUser() {
+        return this.user;
+    }
+    getAccessToken() {
+        return this.tokenStorage.getAccessToken();
+    }
+    getPermissions() {
+        return this.user?.permissions || [];
+    }
+    getRoles() {
+        return this.user?.roles || [];
+    }
+    hasPermission(permission) {
+        return this.getPermissions().includes(permission);
+    }
+    hasRole(role) {
+        return this.getRoles().includes(role);
+    }
+    hasAnyRole(roles) {
+        const userRoles = this.getRoles();
+        return roles.some((role) => userRoles.includes(role));
+    }
+    hasAllRoles(roles) {
+        const userRoles = this.getRoles();
+        return roles.every((role) => userRoles.includes(role));
+    }
+    // ============================================================
+    // Authentication Operations
+    // ============================================================
+    async login(credentials) {
+        const strategy = this.getStrategyForCredentials(credentials);
+        if (!strategy) {
+            return {
+                success: false,
+                error: {
+                    code: 'server_error',
+                    message: 'No suitable authentication strategy found'
+                }
+            };
+        }
+        const result = await strategy.authenticate(credentials);
+        if (result.success) {
+            this.handleAuthSuccess(result, 'login');
+        }
+        return result;
+    }
+    async logout() {
+        const accessToken = this.tokenStorage.getAccessToken();
+        const strategy = this.strategyRegistry.getDefault();
+        if (accessToken && strategy) {
+            try {
+                await strategy.logout(accessToken);
+            }
+            catch {
+                // Continue with local logout even if server logout fails
+            }
+        }
+        this.tokenStorage.clearAll();
+        this.user = null;
+        this.notifyListeners('logout');
+    }
+    async refreshToken() {
+        const refreshToken = this.tokenStorage.getRefreshToken();
+        if (!refreshToken) {
+            return {
+                success: false,
+                error: {
+                    code: 'no_refresh_token',
+                    message: 'No refresh token available'
+                }
+            };
+        }
+        const strategy = this.strategyRegistry.getDefault();
+        if (!strategy) {
+            return {
+                success: false,
+                error: {
+                    code: 'server_error',
+                    message: 'No authentication strategy configured'
+                }
+            };
+        }
+        const result = await strategy.refreshToken(refreshToken);
+        if (result.success) {
+            this.handleAuthSuccess(result, 'token_refresh');
+        }
+        else if (result.error?.code === 'invalid_token' || result.error?.code === 'token_expired') {
+            // Refresh token is invalid, clear session
+            this.tokenStorage.clearAll();
+            this.user = null;
+            this.notifyListeners('session_expired');
+        }
+        return result;
+    }
+    // ============================================================
+    // OAuth Operations
+    // ============================================================
+    initiateOAuth(provider) {
+        const strategy = this.getOAuthStrategy(provider);
+        if (!strategy) {
+            console.error('No OAuth strategy found');
+            return;
+        }
+        // getAuthorizationUrl returns a Promise, need to handle it
+        Promise.resolve(strategy.getAuthorizationUrl()).then((url) => {
+            window.location.href = url;
+        });
+    }
+    async handleOAuthCallback(params) {
+        // Find OAuth strategy that matches the stored state
+        const strategies = this.strategyRegistry.getAllOAuth();
+        for (const strategy of strategies) {
+            const storedState = strategy.getStoredState();
+            if (storedState === params.state) {
+                const result = await strategy.handleCallback(params);
+                if (result.success) {
+                    this.handleAuthSuccess(result, 'login');
+                }
+                return result;
+            }
+        }
+        // No matching strategy found, try default
+        const defaultStrategy = this.getOAuthStrategy();
+        if (defaultStrategy) {
+            const result = await defaultStrategy.handleCallback(params);
+            if (result.success) {
+                this.handleAuthSuccess(result, 'login');
+            }
+            return result;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'invalid_state',
+                message: 'No matching OAuth strategy found for this callback'
+            }
+        };
+    }
+    getAuthorizationUrl(provider) {
+        const strategy = this.getOAuthStrategy(provider);
+        if (!strategy) {
+            return null;
+        }
+        // Note: This is synchronous but the actual method might be async
+        // For full compatibility, use initiateOAuth instead
+        const url = strategy.getAuthorizationUrl();
+        // If it's a promise, return null - caller should use initiateOAuth instead
+        if (url && typeof url === 'object' && 'then' in url) {
+            return null;
+        }
+        return url;
+    }
+    // ============================================================
+    // Event Subscriptions
+    // ============================================================
+    onAuthStateChange(callback) {
+        this.listeners.add(callback);
+        return () => this.listeners.delete(callback);
+    }
+    // ============================================================
+    // Private Helpers
+    // ============================================================
+    handleAuthSuccess(result, changeType) {
+        if (result.accessToken) {
+            this.tokenStorage.setAccessToken(result.accessToken, result.expiresAt);
+        }
+        if (result.refreshToken) {
+            this.tokenStorage.setRefreshToken(result.refreshToken);
+        }
+        if (result.user) {
+            this.user = result.user;
+            this.tokenStorage.setUser(result.user);
+        }
+        this.notifyListeners(changeType);
+    }
+    notifyListeners(changeType) {
+        const isAuthenticated = this.isAuthenticated();
+        this.listeners.forEach((callback) => {
+            try {
+                callback(isAuthenticated, this.user, changeType);
+            }
+            catch (error) {
+                console.error('Auth state callback error:', error);
+            }
+        });
+    }
+    getStrategyForCredentials(credentials) {
+        // For OAuth credentials with a provider, use that specific strategy
+        if (credentials.type === 'oauth' && credentials.provider) {
+            return this.strategyRegistry.get(credentials.provider);
+        }
+        // For password credentials, look for a password strategy
+        if (credentials.type === 'password') {
+            const strategies = this.strategyRegistry.getAll();
+            const passwordStrategy = strategies.find((s) => s.type === 'password');
+            if (passwordStrategy) {
+                return passwordStrategy;
+            }
+            // Some OAuth strategies (like Keycloak) support direct password auth
+            return this.strategyRegistry.getDefault();
+        }
+        // Default to the default strategy
+        return this.strategyRegistry.getDefault();
+    }
+    getOAuthStrategy(provider) {
+        if (provider) {
+            return this.strategyRegistry.getOAuth(provider);
+        }
+        // Return first OAuth strategy or default if it's OAuth
+        const defaultStrategy = this.strategyRegistry.getDefault();
+        if (defaultStrategy && this.isOAuthStrategy(defaultStrategy)) {
+            return defaultStrategy;
+        }
+        const oauthStrategies = this.strategyRegistry.getAllOAuth();
+        return oauthStrategies[0];
+    }
+    isOAuthStrategy(strategy) {
+        return 'getAuthorizationUrl' in strategy && 'handleCallback' in strategy;
+    }
+}

package/dist/impl/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AuthService';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/impl/services/index.js

@@ -0,0 +1 @@
+export * from './AuthService';

package/dist/impl/storage/LocalTokenStorage.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Local Storage Token Storage Implementation
+ * Persists tokens using browser localStorage
+ */
+import type { User } from '../../api';
+import type { ITokenStorage, StoredTokens, TokenStorageConfig } from '../../spi';
+/**
+ * Token storage implementation using localStorage
+ */
+export declare class LocalTokenStorage implements ITokenStorage {
+    private readonly keyPrefix;
+    constructor(config?: TokenStorageConfig);
+    private getKey;
+    private getItem;
+    private setItem;
+    private removeItem;
+    getAccessToken(): string | null;
+    setAccessToken(token: string, expiresAt?: number): void;
+    getRefreshToken(): string | null;
+    setRefreshToken(token: string): void;
+    getTokens(): StoredTokens | null;
+    setTokens(tokens: StoredTokens): void;
+    clearTokens(): void;
+    isTokenExpired(): boolean;
+    isTokenExpiringSoon(thresholdMs: number): boolean;
+    getTokenExpiry(): number | null;
+    getUser(): User | null;
+    setUser(user: User): void;
+    clearUser(): void;
+    clearAll(): void;
+}
+//# sourceMappingURL=LocalTokenStorage.d.ts.map

package/dist/impl/storage/LocalTokenStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalTokenStorage.d.ts","sourceRoot":"","sources":["../../../src/impl/storage/LocalTokenStorage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAcjF;;GAEG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,MAAM,GAAE,kBAAuB;IAI3C,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,UAAU;IAQlB,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAOvD,eAAe,IAAI,MAAM,GAAG,IAAI;IAIhC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIpC,SAAS,IAAI,YAAY,GAAG,IAAI;IAkBhC,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAarC,WAAW,IAAI,IAAI;IAQnB,cAAc,IAAI,OAAO;IAezB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IASjD,cAAc,IAAI,MAAM,GAAG,IAAI;IAQ/B,OAAO,IAAI,IAAI,GAAG,IAAI;IAYtB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIzB,SAAS,IAAI,IAAI;IAIjB,QAAQ,IAAI,IAAI;CAIjB"}

package/dist/impl/storage/LocalTokenStorage.js

@@ -0,0 +1,148 @@
+/**
+ * Local Storage Token Storage Implementation
+ * Persists tokens using browser localStorage
+ */
+/**
+ * Storage keys
+ */
+const STORAGE_KEYS = {
+    ACCESS_TOKEN: 'accessToken',
+    REFRESH_TOKEN: 'refreshToken',
+    EXPIRES_AT: 'expiresAt',
+    TOKEN_TYPE: 'tokenType',
+    SCOPE: 'scope',
+    USER: 'user'
+};
+/**
+ * Token storage implementation using localStorage
+ */
+export class LocalTokenStorage {
+    constructor(config = {}) {
+        this.keyPrefix = config.keyPrefix || '@hamak/auth';
+    }
+    getKey(key) {
+        return `${this.keyPrefix}:${key}`;
+    }
+    getItem(key) {
+        try {
+            return localStorage.getItem(this.getKey(key));
+        }
+        catch {
+            return null;
+        }
+    }
+    setItem(key, value) {
+        try {
+            localStorage.setItem(this.getKey(key), value);
+        }
+        catch {
+            // Storage might be full or disabled
+            console.warn('Failed to store item in localStorage:', key);
+        }
+    }
+    removeItem(key) {
+        try {
+            localStorage.removeItem(this.getKey(key));
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    getAccessToken() {
+        return this.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+    }
+    setAccessToken(token, expiresAt) {
+        this.setItem(STORAGE_KEYS.ACCESS_TOKEN, token);
+        if (expiresAt !== undefined) {
+            this.setItem(STORAGE_KEYS.EXPIRES_AT, String(expiresAt));
+        }
+    }
+    getRefreshToken() {
+        return this.getItem(STORAGE_KEYS.REFRESH_TOKEN);
+    }
+    setRefreshToken(token) {
+        this.setItem(STORAGE_KEYS.REFRESH_TOKEN, token);
+    }
+    getTokens() {
+        const accessToken = this.getAccessToken();
+        if (!accessToken) {
+            return null;
+        }
+        const expiresAtStr = this.getItem(STORAGE_KEYS.EXPIRES_AT);
+        const scopeStr = this.getItem(STORAGE_KEYS.SCOPE);
+        return {
+            accessToken,
+            refreshToken: this.getRefreshToken() || undefined,
+            tokenType: this.getItem(STORAGE_KEYS.TOKEN_TYPE) || 'Bearer',
+            expiresAt: expiresAtStr ? parseInt(expiresAtStr, 10) : undefined,
+            scope: scopeStr ? JSON.parse(scopeStr) : undefined
+        };
+    }
+    setTokens(tokens) {
+        this.setAccessToken(tokens.accessToken, tokens.expiresAt);
+        if (tokens.refreshToken) {
+            this.setRefreshToken(tokens.refreshToken);
+        }
+        if (tokens.tokenType) {
+            this.setItem(STORAGE_KEYS.TOKEN_TYPE, tokens.tokenType);
+        }
+        if (tokens.scope) {
+            this.setItem(STORAGE_KEYS.SCOPE, JSON.stringify(tokens.scope));
+        }
+    }
+    clearTokens() {
+        this.removeItem(STORAGE_KEYS.ACCESS_TOKEN);
+        this.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+        this.removeItem(STORAGE_KEYS.EXPIRES_AT);
+        this.removeItem(STORAGE_KEYS.TOKEN_TYPE);
+        this.removeItem(STORAGE_KEYS.SCOPE);
+    }
+    isTokenExpired() {
+        const accessToken = this.getAccessToken();
+        if (!accessToken) {
+            return true;
+        }
+        const expiresAt = this.getTokenExpiry();
+        if (!expiresAt) {
+            // No expiry info, assume valid
+            return false;
+        }
+        return Date.now() >= expiresAt;
+    }
+    isTokenExpiringSoon(thresholdMs) {
+        const expiresAt = this.getTokenExpiry();
+        if (!expiresAt) {
+            return false;
+        }
+        return Date.now() + thresholdMs >= expiresAt;
+    }
+    getTokenExpiry() {
+        const expiresAtStr = this.getItem(STORAGE_KEYS.EXPIRES_AT);
+        if (!expiresAtStr) {
+            return null;
+        }
+        return parseInt(expiresAtStr, 10);
+    }
+    getUser() {
+        const userStr = this.getItem(STORAGE_KEYS.USER);
+        if (!userStr) {
+            return null;
+        }
+        try {
+            return JSON.parse(userStr);
+        }
+        catch {
+            return null;
+        }
+    }
+    setUser(user) {
+        this.setItem(STORAGE_KEYS.USER, JSON.stringify(user));
+    }
+    clearUser() {
+        this.removeItem(STORAGE_KEYS.USER);
+    }
+    clearAll() {
+        this.clearTokens();
+        this.clearUser();
+    }
+}

package/dist/impl/storage/MemoryTokenStorage.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Memory Token Storage Implementation
+ * Stores tokens in memory (cleared on page refresh)
+ */
+import type { User } from '../../api';
+import type { ITokenStorage, StoredTokens } from '../../spi';
+/**
+ * Token storage implementation using in-memory storage
+ * Tokens are cleared when the page is refreshed
+ * Useful for high-security scenarios where persistence is not desired
+ */
+export declare class MemoryTokenStorage implements ITokenStorage {
+    private accessToken;
+    private refreshToken;
+    private expiresAt;
+    private tokenType;
+    private scope;
+    private user;
+    getAccessToken(): string | null;
+    setAccessToken(token: string, expiresAt?: number): void;
+    getRefreshToken(): string | null;
+    setRefreshToken(token: string): void;
+    getTokens(): StoredTokens | null;
+    setTokens(tokens: StoredTokens): void;
+    clearTokens(): void;
+    isTokenExpired(): boolean;
+    isTokenExpiringSoon(thresholdMs: number): boolean;
+    getTokenExpiry(): number | null;
+    getUser(): User | null;
+    setUser(user: User): void;
+    clearUser(): void;
+    clearAll(): void;
+}
+//# sourceMappingURL=MemoryTokenStorage.d.ts.map

package/dist/impl/storage/MemoryTokenStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryTokenStorage.d.ts","sourceRoot":"","sources":["../../../src/impl/storage/MemoryTokenStorage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IACtD,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,IAAI,CAAqB;IAEjC,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAOvD,eAAe,IAAI,MAAM,GAAG,IAAI;IAIhC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIpC,SAAS,IAAI,YAAY,GAAG,IAAI;IAchC,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAQrC,WAAW,IAAI,IAAI;IAQnB,cAAc,IAAI,OAAO;IAYzB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAQjD,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B,OAAO,IAAI,IAAI,GAAG,IAAI;IAItB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIzB,SAAS,IAAI,IAAI;IAIjB,QAAQ,IAAI,IAAI;CAIjB"}

package/dist/impl/storage/MemoryTokenStorage.js

@@ -0,0 +1,91 @@
+/**
+ * Memory Token Storage Implementation
+ * Stores tokens in memory (cleared on page refresh)
+ */
+/**
+ * Token storage implementation using in-memory storage
+ * Tokens are cleared when the page is refreshed
+ * Useful for high-security scenarios where persistence is not desired
+ */
+export class MemoryTokenStorage {
+    constructor() {
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.expiresAt = null;
+        this.tokenType = 'Bearer';
+        this.scope = null;
+        this.user = null;
+    }
+    getAccessToken() {
+        return this.accessToken;
+    }
+    setAccessToken(token, expiresAt) {
+        this.accessToken = token;
+        if (expiresAt !== undefined) {
+            this.expiresAt = expiresAt;
+        }
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setRefreshToken(token) {
+        this.refreshToken = token;
+    }
+    getTokens() {
+        if (!this.accessToken) {
+            return null;
+        }
+        return {
+            accessToken: this.accessToken,
+            refreshToken: this.refreshToken || undefined,
+            tokenType: this.tokenType,
+            expiresAt: this.expiresAt || undefined,
+            scope: this.scope || undefined
+        };
+    }
+    setTokens(tokens) {
+        this.accessToken = tokens.accessToken;
+        this.refreshToken = tokens.refreshToken || null;
+        this.expiresAt = tokens.expiresAt || null;
+        this.tokenType = tokens.tokenType || 'Bearer';
+        this.scope = tokens.scope || null;
+    }
+    clearTokens() {
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.expiresAt = null;
+        this.tokenType = 'Bearer';
+        this.scope = null;
+    }
+    isTokenExpired() {
+        if (!this.accessToken) {
+            return true;
+        }
+        if (!this.expiresAt) {
+            return false;
+        }
+        return Date.now() >= this.expiresAt;
+    }
+    isTokenExpiringSoon(thresholdMs) {
+        if (!this.expiresAt) {
+            return false;
+        }
+        return Date.now() + thresholdMs >= this.expiresAt;
+    }
+    getTokenExpiry() {
+        return this.expiresAt;
+    }
+    getUser() {
+        return this.user;
+    }
+    setUser(user) {
+        this.user = user;
+    }
+    clearUser() {
+        this.user = null;
+    }
+    clearAll() {
+        this.clearTokens();
+        this.clearUser();
+    }
+}

package/dist/impl/storage/SessionTokenStorage.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Session Storage Token Storage Implementation
+ * Persists tokens using browser sessionStorage (cleared when tab closes)
+ */
+import type { User } from '../../api';
+import type { ITokenStorage, StoredTokens, TokenStorageConfig } from '../../spi';
+/**
+ * Token storage implementation using sessionStorage
+ * Tokens are cleared when the browser tab is closed
+ */
+export declare class SessionTokenStorage implements ITokenStorage {
+    private readonly keyPrefix;
+    constructor(config?: TokenStorageConfig);
+    private getKey;
+    private getItem;
+    private setItem;
+    private removeItem;
+    getAccessToken(): string | null;
+    setAccessToken(token: string, expiresAt?: number): void;
+    getRefreshToken(): string | null;
+    setRefreshToken(token: string): void;
+    getTokens(): StoredTokens | null;
+    setTokens(tokens: StoredTokens): void;
+    clearTokens(): void;
+    isTokenExpired(): boolean;
+    isTokenExpiringSoon(thresholdMs: number): boolean;
+    getTokenExpiry(): number | null;
+    getUser(): User | null;
+    setUser(user: User): void;
+    clearUser(): void;
+    clearAll(): void;
+}
+//# sourceMappingURL=SessionTokenStorage.d.ts.map

package/dist/impl/storage/SessionTokenStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionTokenStorage.d.ts","sourceRoot":"","sources":["../../../src/impl/storage/SessionTokenStorage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAcjF;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IACvD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,MAAM,GAAE,kBAAuB;IAI3C,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,UAAU;IAQlB,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAOvD,eAAe,IAAI,MAAM,GAAG,IAAI;IAIhC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIpC,SAAS,IAAI,YAAY,GAAG,IAAI;IAkBhC,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAarC,WAAW,IAAI,IAAI;IAQnB,cAAc,IAAI,OAAO;IAczB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IASjD,cAAc,IAAI,MAAM,GAAG,IAAI;IAQ/B,OAAO,IAAI,IAAI,GAAG,IAAI;IAYtB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIzB,SAAS,IAAI,IAAI;IAIjB,QAAQ,IAAI,IAAI;CAIjB"}