@explorins/pers-sdk 1.6.32 → 1.6.36

package/README.md

@@ -120,9 +120,11 @@ sdk.campaigns.getCampaignService()
 ## Core Features
 
 ### Authentication
+- **Secure DPoP (Demonstrating Proof-of-Possession)**: Enabled by default to bind tokens to the client, preventing replay attacks.
 - External JWT integration (Firebase, Auth0, etc.)
 - Native token validation and refresh
 - User and admin authentication flows
+- Flexible storage strategies (LocalStorage, IndexedDB, Memory)
 
 ### Business Management
 - Business registration and profiles
@@ -152,16 +154,61 @@ sdk.campaigns.getCampaignService()
 ## Configuration
 
 ```typescript
+import { IndexedDBTokenStorage } from '@explorins/pers-sdk/core';
+
 interface PersConfig {
   environment?: 'development' | 'staging' | 'production';
-  apiVersion?: 'v2';
   apiProjectKey: string;
-  timeout?: number;
-  retries?: number;
+  
+  // Storage Strategy (Recommended: IndexedDB)
+  authStorage?: TokenStorage; // Defaults to LocalStorage if omitted
+  
+  // DPoP Security (Default: enabled)
+  dpop?: {
+    enabled: boolean;
+  };
+  
+  // Advanced overrides
   authProvider?: PersAuthProvider;
 }
 ```
 
+## Advanced Authentication
+
+### Using IndexedDB (Recommended)
+
+For better security and performance, use the built-in `IndexedDBTokenStorage` instead of the default LocalStorage.
+
+```typescript
+import { PersSDK } from '@explorins/pers-sdk';
+import { IndexedDBTokenStorage } from '@explorins/pers-sdk/core';
+
+const sdk = new PersSDK(adapter, {
+  environment: 'production',
+  apiProjectKey: 'your-key',
+  // Activates IndexedDB for tokens and keys
+  authStorage: new IndexedDBTokenStorage() 
+});
+```
+
+### Custom Storage & Fallbacks
+
+You can implement your own storage strategy (e.g., hybrid Fallback) by implementing the `TokenStorage` interface. The SDK provides type-safe key constants.
+
+```typescript
+import { TokenStorage, AUTH_STORAGE_KEYS, DPOP_STORAGE_KEYS } from '@explorins/pers-sdk/core';
+
+class HybridStorage implements TokenStorage {
+  // IMPORTANT: Set to 'false' if your storage backend only supports strings (like LocalStorage).
+  // This ensures the SDK generates exportable keys that can be serialized.
+  // Set to 'true' (like IndexedDB) to enable high-security non-extractable CryptoKey objects.
+  readonly supportsObjects = false;
+
+  // Your custom implementation...
+  // Use AUTH_STORAGE_KEYS.ACCESS_TOKEN, DPOP_STORAGE_KEYS.PRIVATE, etc.
+}
+```
+
 ## Error Handling
 
 ```typescript

package/dist/chunks/{pers-sdk-BbflloQE.cjs → pers-sdk-BGDZS3-x.cjs}

@@ -335,14 +335,19 @@ const AUTH_STORAGE_KEYS = {
 };
 /**
  * LocalStorage implementation
+ * Note: Forces string conversion for compatibility
  */
 class LocalStorageTokenStorage {
+    constructor() {
+        this.supportsObjects = false;
+    }
     async get(key) {
         return typeof localStorage !== 'undefined' ? localStorage.getItem(key) : null;
     }
     async set(key, value) {
         if (typeof localStorage !== 'undefined') {
-            localStorage.setItem(key, value);
+            const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+            localStorage.setItem(key, stringValue);
         }
     }
     async remove(key) {
@@ -363,6 +368,7 @@ class LocalStorageTokenStorage {
  */
 class MemoryTokenStorage {
     constructor() {
+        this.supportsObjects = true;
         this.store = new Map();
     }
     async get(key) {
@@ -386,26 +392,30 @@ class AuthTokenManager {
         this.storage = storage;
     }
     async getAccessToken() {
-        return this.storage.get(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
+        const val = await this.storage.get(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
+        // Ensure we return string for tokens
+        return typeof val === 'string' ? val : null;
     }
     async setAccessToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.ACCESS_TOKEN, token);
     }
     async getRefreshToken() {
-        return this.storage.get(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
+        const val = await this.storage.get(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
+        return typeof val === 'string' ? val : null;
     }
     async setRefreshToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.REFRESH_TOKEN, token);
     }
     async getProviderToken() {
-        return this.storage.get(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
+        const val = await this.storage.get(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
+        return typeof val === 'string' ? val : null;
     }
     async setProviderToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.PROVIDER_TOKEN, token);
     }
     async getAuthType() {
         const authType = await this.storage.get(AUTH_STORAGE_KEYS.AUTH_TYPE);
-        return authType;
+        return typeof authType === 'string' ? authType : null;
     }
     async setAuthType(authType) {
         await this.storage.set(AUTH_STORAGE_KEYS.AUTH_TYPE, authType);
@@ -430,6 +440,218 @@ class AuthTokenManager {
     }
 }
 
+class WebDPoPCryptoProvider {
+    get crypto() {
+        // Basic environment check
+        if (typeof crypto !== 'undefined')
+            return crypto;
+        if (typeof window !== 'undefined' && window.crypto)
+            return window.crypto;
+        if (typeof globalThis !== 'undefined' && globalThis.crypto)
+            return globalThis.crypto;
+        throw new Error('WebCrypto API not found. Please polyfill crypto.subtle or use a different DPoPCryptoProvider.');
+    }
+    async generateKeyPair(options) {
+        const extractable = options?.extractable ?? true;
+        const keyPair = await this.crypto.subtle.generateKey({
+            name: 'ECDSA',
+            namedCurve: 'P-256',
+        }, extractable, // Configurable extractability
+        ['sign', 'verify']);
+        const publicKey = await this.crypto.subtle.exportKey('jwk', keyPair.publicKey);
+        // If extractable, export private key as JWK (plain object)
+        // If NOT extractable, keep it as CryptoKey (native handle)
+        // However, DPoPKeyPair interface currently expects JsonWebKey | CryptoKey
+        // We need to check DPoPKeyPair type definition. 
+        // Wait, DPoPKeyPair definition in dpop.types.ts says: 
+        // publicKey: JsonWebKey; privateKey: JsonWebKey;
+        // I need to change that to support CryptoKey.
+        // Let's re-read dpop.types.ts
+        // I assumed it might be compatible but let's verify.
+        // If I change privateKey to unknown or JsonWebKey | CryptoKey, it will be safer.
+        let privateKey;
+        if (extractable) {
+            privateKey = await this.crypto.subtle.exportKey('jwk', keyPair.privateKey);
+        }
+        else {
+            privateKey = keyPair.privateKey;
+        }
+        return { publicKey, privateKey };
+    }
+    async signProof(payload, keyPair) {
+        // 1. Prepare Header
+        const header = {
+            typ: 'dpop+jwt',
+            alg: 'ES256',
+            jwk: keyPair.publicKey
+        };
+        // 2. Prepare Payload
+        // Ensure jti and iat if not present (though Manager usually provides them)
+        const finalPayload = {
+            ...payload,
+            iat: payload.iat || Math.floor(Date.now() / 1000),
+            jti: payload.jti || this.generateUUID()
+        };
+        // 3. Encode segments
+        const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
+        const encodedPayload = this.base64UrlEncode(JSON.stringify(finalPayload));
+        const signingInput = `${encodedHeader}.${encodedPayload}`;
+        // 4. Import private key for signing
+        let privateKey;
+        // Check if it's already a CryptoKey (non-extractable handle)
+        // We check for 'algorithm' property which signals a CryptoKey object
+        if (keyPair.privateKey.algorithm) {
+            privateKey = keyPair.privateKey;
+        }
+        else {
+            // Otherwise import from JWK
+            privateKey = await this.crypto.subtle.importKey('jwk', keyPair.privateKey, {
+                name: 'ECDSA',
+                namedCurve: 'P-256',
+            }, false, ['sign']);
+        }
+        // 5. Sign
+        const signatureBuffer = await this.crypto.subtle.sign({
+            name: 'ECDSA',
+            hash: { name: 'SHA-256' },
+        }, privateKey, new TextEncoder().encode(signingInput));
+        const encodedSignature = this.base64UrlEncodeBuffer(signatureBuffer);
+        return `${signingInput}.${encodedSignature}`;
+    }
+    async hashAccessToken(accessToken) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(accessToken);
+        const hashBuffer = await this.crypto.subtle.digest('SHA-256', data);
+        return this.base64UrlEncodeBuffer(hashBuffer);
+    }
+    // --- Helpers ---
+    generateUUID() {
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        // Fallback for older envs
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    base64UrlEncode(str) {
+        // Use TextEncoder to handle UTF-8 properly
+        const encoder = new TextEncoder();
+        return this.base64UrlEncodeBuffer(encoder.encode(str));
+    }
+    base64UrlEncodeBuffer(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        const len = bytes.byteLength;
+        // Chunk processing for large buffers if needed, but proofs are small
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        // btoa is widely available in browsers.
+        // In Node (non-globals), we might need Buffer.
+        // For universal 'platform agnostic' aiming at standard web-like envs:
+        let base64 = '';
+        if (typeof btoa === 'function') {
+            base64 = btoa(binary);
+        }
+        else if (typeof Buffer !== 'undefined') {
+            base64 = Buffer.from(binary, 'binary').toString('base64');
+        }
+        else {
+            throw new Error('Base64 encoding not supported in this environment');
+        }
+        return base64
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+}
+
+const DPOP_STORAGE_KEYS = {
+    PUBLIC: 'pers_dpop_public_key',
+    PRIVATE: 'pers_dpop_private_key'
+};
+class DPoPManager {
+    constructor(storage, cryptoProvider) {
+        this.storage = storage;
+        this.memoryKeyPair = null;
+        this.cryptoProvider = cryptoProvider || new WebDPoPCryptoProvider();
+    }
+    /**
+     * Ensures a DPoP key pair exists, loading from storage or generating new one.
+     */
+    async ensureKeyPair() {
+        if (this.memoryKeyPair)
+            return this.memoryKeyPair;
+        const storedPublic = await this.storage.get(DPOP_STORAGE_KEYS.PUBLIC);
+        const storedPrivate = await this.storage.get(DPOP_STORAGE_KEYS.PRIVATE);
+        if (storedPublic && storedPrivate) {
+            try {
+                // Handle polymorphic storage: String (JSON) or Object (CryptoKey)
+                const publicKey = typeof storedPublic === 'string' ? JSON.parse(storedPublic) : storedPublic;
+                const privateKey = typeof storedPrivate === 'string' ? JSON.parse(storedPrivate) : storedPrivate;
+                this.memoryKeyPair = { publicKey, privateKey };
+                return this.memoryKeyPair;
+            }
+            catch (e) {
+                console.warn('Corrupted DPoP keys in storage, regenerating.');
+            }
+        }
+        // Generate new key pair
+        // Adaptation: If storage supports raw objects (like IndexedDB or Native Keychain),
+        // we can generate Non-Extractable keys for maximum security.
+        // If storage is text-only (LocalStorage), we must use Extractable keys to serialize them.
+        const useHighSecurity = !!this.storage.supportsObjects;
+        const keyPair = await this.cryptoProvider.generateKeyPair({
+            extractable: !useHighSecurity
+        });
+        // Save to storage
+        await this.storage.set(DPOP_STORAGE_KEYS.PUBLIC, keyPair.publicKey);
+        await this.storage.set(DPOP_STORAGE_KEYS.PRIVATE, keyPair.privateKey);
+        this.memoryKeyPair = keyPair;
+        return keyPair;
+    }
+    /**
+     * Generates the DPoP proof header value.
+     * @param method HTTP method
+     * @param url Request URL
+     * @param accessToken Optional access token to bind the proof to (ath claim)
+     */
+    async generateProofHeader(method, url, accessToken) {
+        const keyPair = await this.ensureKeyPair();
+        const payload = {
+            htm: method,
+            htu: url,
+        };
+        if (accessToken) {
+            payload.ath = await this.cryptoProvider.hashAccessToken(accessToken);
+        }
+        return this.cryptoProvider.signProof(payload, keyPair);
+    }
+    /**
+     * Clears DPoP keys (e.g. on logout)
+     */
+    async clearKeys() {
+        this.memoryKeyPair = null;
+        await this.storage.remove(DPOP_STORAGE_KEYS.PUBLIC);
+        await this.storage.remove(DPOP_STORAGE_KEYS.PRIVATE);
+    }
+    /**
+     * Gets the public key (for debugging/inspection)
+     */
+    async getPublicKey() {
+        try {
+            const kp = await this.ensureKeyPair();
+            return kp.publicKey;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+
 /**
  * Default Authentication Provider
  * Simple implementation of PERS authentication with token lifecycle management
@@ -443,6 +665,9 @@ class DefaultAuthProvider {
         this.authType = config.authType || 'user';
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
+        if (config.dpop?.enabled) {
+            this.dpopManager = new DPoPManager(storage, config.dpop.cryptoProvider);
+        }
     }
     createStorage() {
         return typeof window === 'undefined' || typeof localStorage === 'undefined'
@@ -452,6 +677,26 @@ class DefaultAuthProvider {
     getToken() {
         return this.tokenManager.getAccessToken();
     }
+    async getAuthHeaders(token, method, url) {
+        const headers = {};
+        if (this.dpopManager && method && url) {
+            // Generate DPoP Proof
+            // Note: For 'bypassAuth' requests (token is null), we still generate proof (bound to public key, no ath)
+            // This covers Token Requests (Login) which need DPoP header to bind the issued token.
+            const proof = await this.dpopManager.generateProofHeader(method, url, token || undefined);
+            headers['DPoP'] = proof;
+            if (token) {
+                headers['Authorization'] = `DPoP ${token}`;
+            }
+        }
+        else {
+            // Standard Bearer
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+        }
+        return headers;
+    }
     async getProjectKey() {
         return this.config.projectKey || null;
     }
@@ -486,6 +731,9 @@ class DefaultAuthProvider {
     }
     async clearTokens() {
         await this.tokenManager.clearAllTokens();
+        if (this.dpopManager) {
+            await this.dpopManager.clearKeys();
+        }
     }
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.tokenManager.setTokens(accessToken, refreshToken, providerToken);
@@ -534,7 +782,11 @@ class PersApiClient {
             this.mergedConfig.authProvider = new DefaultAuthProvider({
                 authType: this.mergedConfig.authType || 'user',
                 projectKey: this.mergedConfig.apiProjectKey,
-                storage: this.mergedConfig.authStorage // Support custom storage
+                storage: this.mergedConfig.authStorage, // Support custom storage
+                dpop: {
+                    enabled: this.mergedConfig.dpop?.enabled ?? true, // Enable DPoP by default
+                    cryptoProvider: this.mergedConfig.dpop?.cryptoProvider
+                }
             });
         }
         this.authService = new AuthService(this.authApi, this.mergedConfig.authProvider);
@@ -597,7 +849,7 @@ class PersApiClient {
             });
         }
         const requestOptions = {
-            headers: await this.getHeaders(!bypassAuth),
+            headers: await this.getHeaders(!bypassAuth, method, url),
             timeout: this.mergedConfig.timeout,
             responseType
         };
@@ -692,26 +944,45 @@ class PersApiClient {
      * Get request headers with optional auth token and project key
      *
      * @param includeAuth - Whether to include the Authorization header (default: true)
+     * @param method - HTTP Method (required for DPoP)
+     * @param url - Full Request URL (required for DPoP)
      */
-    async getHeaders(includeAuth = true) {
+    async getHeaders(includeAuth = true, method, url) {
         const headers = {
             'Content-Type': 'application/json',
         };
-        if (includeAuth) {
-            // Add authentication token
-            if (this.mergedConfig.authProvider) {
-                const token = await this.mergedConfig.authProvider.getToken();
-                if (token) {
-                    headers['Authorization'] = `Bearer ${token}`;
+        if (this.mergedConfig.authProvider) {
+            let token = null;
+            if (includeAuth) {
+                token = await this.mergedConfig.authProvider.getToken();
+            }
+            // Handle Authentication Headers (Bearer or DPoP)
+            if (this.mergedConfig.authProvider.getAuthHeaders) {
+                // Provider supports advanced headers (DPoP)
+                // We pass token (null if includeAuth=false) so it can generate DPoP proofs for login requests too
+                try {
+                    const authHeaders = await this.mergedConfig.authProvider.getAuthHeaders(token, method, url);
+                    Object.assign(headers, authHeaders);
                 }
-                else {
-                    console.warn('[PersApiClient] No token available from auth provider');
+                catch (e) {
+                    console.warn('[PersApiClient] Failed to generate auth headers:', e);
+                    // Fallback if token exists but DPoP generation failed? 
+                    // Better to fail or let standardized fallback below handle it?
+                    // If DPoP fails, falling back to Bearer might be insecure if server enforces DPoP. 
+                    // For now, valid token -> Bearer fallback logic mostly for non-DPoP legacy providers.
                 }
             }
-            else {
-                console.warn('[PersApiClient] No auth provider configured');
+            // Fallback: If provider didn't give headers but we have token and NO Authorization header yet
+            if (includeAuth && token && !headers['Authorization']) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            else if (includeAuth && !token) {
+                console.warn('[PersApiClient] No token available from auth provider');
             }
         }
+        else if (includeAuth) {
+            console.warn('[PersApiClient] No auth provider configured');
+        }
         // Add project key
         if (this.mergedConfig.authProvider) {
             const projectKey = await this.mergedConfig.authProvider.getProjectKey();
@@ -747,6 +1018,104 @@ class PersApiClient {
     }
 }
 
+class IndexedDBTokenStorage {
+    constructor() {
+        this.supportsObjects = true;
+        this.dbPromise = null;
+        if (typeof indexedDB === 'undefined') {
+            console.warn('IndexedDB is not available in this environment');
+        }
+    }
+    getDB() {
+        if (this.dbPromise)
+            return this.dbPromise;
+        this.dbPromise = new Promise((resolve, reject) => {
+            if (typeof indexedDB === 'undefined') {
+                return reject(new Error('IndexedDB not supported'));
+            }
+            const request = indexedDB.open(IndexedDBTokenStorage.DB_NAME, IndexedDBTokenStorage.DB_VERSION);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(IndexedDBTokenStorage.STORE_NAME)) {
+                    db.createObjectStore(IndexedDBTokenStorage.STORE_NAME);
+                }
+            };
+            request.onsuccess = (event) => {
+                resolve(event.target.result);
+            };
+            request.onerror = (event) => {
+                reject(event.target.error);
+            };
+        });
+        return this.dbPromise;
+    }
+    async get(key) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(IndexedDBTokenStorage.STORE_NAME, 'readonly');
+                const store = transaction.objectStore(IndexedDBTokenStorage.STORE_NAME);
+                const request = store.get(key);
+                request.onsuccess = () => resolve(request.result || null);
+                request.onerror = () => reject(request.error);
+            });
+        }
+        catch (e) {
+            console.warn('[IndexedDBTokenStorage] Failed to get key', key, e);
+            return null;
+        }
+    }
+    async set(key, value) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(IndexedDBTokenStorage.STORE_NAME, 'readwrite');
+                const store = transaction.objectStore(IndexedDBTokenStorage.STORE_NAME);
+                const request = store.put(value, key);
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(request.error);
+            });
+        }
+        catch (e) {
+            console.error('[IndexedDBTokenStorage] Failed to set key', key, e);
+            throw e;
+        }
+    }
+    async remove(key) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(IndexedDBTokenStorage.STORE_NAME, 'readwrite');
+                const store = transaction.objectStore(IndexedDBTokenStorage.STORE_NAME);
+                const request = store.delete(key);
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(request.error);
+            });
+        }
+        catch (e) {
+            console.warn('[IndexedDBTokenStorage] Failed to remove key', key, e);
+        }
+    }
+    async clear() {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(IndexedDBTokenStorage.STORE_NAME, 'readwrite');
+                const store = transaction.objectStore(IndexedDBTokenStorage.STORE_NAME);
+                const request = store.clear();
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(request.error);
+            });
+        }
+        catch (e) {
+            console.warn('[IndexedDBTokenStorage] Failed to clear storage', e);
+        }
+    }
+}
+IndexedDBTokenStorage.DB_NAME = 'pers-sdk-storage';
+IndexedDBTokenStorage.STORE_NAME = 'auth-tokens';
+IndexedDBTokenStorage.DB_VERSION = 1;
+
 /**
  * Environment Detection Utility
  * Detects runtime environment for platform-specific behaviors
@@ -5928,6 +6297,7 @@ function createPersSDK(httpClient, config) {
     return new PersSDK(httpClient, config);
 }
 
+exports.AUTH_STORAGE_KEYS = AUTH_STORAGE_KEYS;
 exports.AnalyticsManager = AnalyticsManager;
 exports.ApiKeyApi = ApiKeyApi;
 exports.ApiKeyManager = ApiKeyManager;
@@ -5938,11 +6308,14 @@ exports.AuthTokenManager = AuthTokenManager;
 exports.BusinessManager = BusinessManager;
 exports.CampaignManager = CampaignManager;
 exports.DEFAULT_PERS_CONFIG = DEFAULT_PERS_CONFIG;
+exports.DPOP_STORAGE_KEYS = DPOP_STORAGE_KEYS;
+exports.DPoPManager = DPoPManager;
 exports.DefaultAuthProvider = DefaultAuthProvider;
 exports.DonationManager = DonationManager;
 exports.FileApi = FileApi;
 exports.FileManager = FileManager;
 exports.FileService = FileService;
+exports.IndexedDBTokenStorage = IndexedDBTokenStorage;
 exports.LocalStorageTokenStorage = LocalStorageTokenStorage;
 exports.MemoryTokenStorage = MemoryTokenStorage;
 exports.PersApiClient = PersApiClient;
@@ -5955,10 +6328,11 @@ exports.TransactionManager = TransactionManager;
 exports.UserManager = UserManager;
 exports.UserStatusManager = UserStatusManager;
 exports.Web3Manager = Web3Manager;
+exports.WebDPoPCryptoProvider = WebDPoPCryptoProvider;
 exports.buildApiRoot = buildApiRoot;
 exports.createPersSDK = createPersSDK;
 exports.detectEnvironment = detectEnvironment;
 exports.environment = environment;
 exports.mergeWithDefaults = mergeWithDefaults;
 exports.warnIfProblematicEnvironment = warnIfProblematicEnvironment;
-//# sourceMappingURL=pers-sdk-BbflloQE.cjs.map
+//# sourceMappingURL=pers-sdk-BGDZS3-x.cjs.map