@explorins/pers-sdk 1.6.6 → 1.6.9

package/dist/chunks/{pers-sdk-CajYwGkL.cjs → pers-sdk-CmyPEhy7.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
 var persShared = require('@explorins/pers-shared');
+var web3ChainService = require('./web3-chain-service-D75TcHkh.cjs');
 var userService = require('./user-service-D1Rn4U8u.cjs');
 var userStatus = require('../user-status.cjs');
 var tokenService = require('./token-service-BWScn8Qa.cjs');
@@ -13,7 +14,6 @@ var tenantService = require('./tenant-service-Ba7xrWED.cjs');
 var analyticsService = require('./analytics-service-CitlimKJ.cjs');
 var donationService = require('./donation-service-D-xFrONi.cjs');
 var explorer_utils = require('./explorer.utils-GpskbLl1.cjs');
-var web3ChainService = require('./web3-chain-service-BYkj61DN.cjs');
 
 /**
  * PERS SDK Configuration interfaces and utilities
@@ -59,25 +59,16 @@ function mergeWithDefaults(config) {
 }
 
 /**
- * Platform-Agnostic Auth Admin API Client
- *
- * Handles authentication and authorization admin operations using the PERS backend.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * Note: Special header handling (bypass-auth-interceptor) may need to be implemented
- * at the PersApiClient level or through a specialized auth client.
+ * Platform-Agnostic Auth API Client
+ * Handles authentication operations using the PERS backend
  */
 class AuthApi {
     constructor(apiClient) {
         this.apiClient = apiClient;
         this.basePath = '/auth';
     }
-    // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
-    // ==========================================
     /**
-     * ADMIN: Login tenant admin with JWT
-     * Note: JWT handling and auth bypass headers may need special implementation
+     * Login tenant admin with JWT
      */
     async loginTenantAdmin(jwt) {
         const body = {
@@ -87,7 +78,7 @@ class AuthApi {
         return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
     }
     /**
-     * Login user with JWT - bypasses auth headers
+     * Login user with JWT
      */
     async loginUser(jwt) {
         const body = {
@@ -96,6 +87,9 @@ class AuthApi {
         };
         return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
     }
+    /**
+     * Login user with raw data (no external authentication)
+     */
     async loginUnAuthenticated(rawLoginData) {
         const body = {
             authToken: '',
@@ -105,21 +99,16 @@ class AuthApi {
         return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
     }
     /**
-     * Refresh access token - bypasses auth headers to prevent circular dependency
+     * Refresh access token
      */
     async refreshAccessToken(refreshToken) {
-        // Bypass auth headers for refresh calls to prevent circular dependency
         return this.apiClient.post(`${this.basePath}/refresh`, { refreshToken }, { bypassAuth: true });
     }
 }
 
 /**
- * Platform-Agnostic Auth Admin Service
- *
- * Contains auth admin business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
+ * Platform-agnostic authentication service
+ * Handles login, token refresh, and storage operations
  */
 class AuthService {
     constructor(authApi, authProvider) {
@@ -128,110 +117,84 @@ class AuthService {
         this.activeRefreshPromise = null;
     }
     // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
+    // AUTHENTICATION OPERATIONS
     // ==========================================
     /**
-     * ADMIN: Login tenant admin with JWT
-     * Automatically stores tokens if auth provider supports token storage
+     * Login tenant admin with JWT
      */
     async loginTenantAdmin(jwt) {
         const response = await this.authApi.loginTenantAdmin(jwt);
-        // Store tokens if auth provider supports it
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken, 'admin', jwt);
         }
         return response;
     }
     /**
-     * Automatically stores tokens if auth provider supports token storage
+     * Login user with JWT
      */
     async loginUser(jwt) {
         const response = await this.authApi.loginUser(jwt);
-        // Store tokens if auth provider supports it
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken, 'user', jwt);
         }
         return response;
     }
     /**
-     * Automatically stores tokens if auth provider supports token storage
+     * Login user with raw data (no external auth)
      */
     async loginUserWithRawData(rawLoginData) {
-        const loginData = {
-            externalId: rawLoginData?.externalId,
-            email: rawLoginData?.email,
-            firstName: rawLoginData?.firstName,
-            lastName: rawLoginData?.lastName,
-            customData: rawLoginData?.customData
-        };
-        const response = await this.authApi.loginUnAuthenticated(loginData);
-        // Store tokens if auth provider supports it
+        const response = await this.authApi.loginUnAuthenticated(rawLoginData);
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken, 'user');
         }
         return response;
     }
     /**
-     * ADMIN: Refresh access token
-     * Automatically stores new tokens if auth provider supports token storage
-     *
-     * Implements refresh deduplication to prevent race conditions when multiple
-     * requests trigger refresh simultaneously.
+     * Refresh access token with race condition protection
      */
     async refreshAccessToken(refreshToken) {
-        // If there's already an active refresh, return that promise instead of starting a new one
         if (this.activeRefreshPromise) {
-            console.log('[AuthService] Refresh already in progress, reusing existing promise');
             try {
                 return await this.activeRefreshPromise;
             }
             catch (error) {
-                // If the active refresh failed, we'll try again with a fresh attempt
                 console.warn('[AuthService] Active refresh failed, attempting new refresh:', error);
                 this.activeRefreshPromise = null;
             }
         }
-        // Start a new refresh operation
         this.activeRefreshPromise = this.performRefresh(refreshToken);
         try {
-            const result = await this.activeRefreshPromise;
-            return result;
+            return await this.activeRefreshPromise;
         }
         finally {
-            // Clear the active refresh promise when done (success or failure)
             this.activeRefreshPromise = null;
         }
     }
     /**
      * Performs the actual refresh operation
-     * Separated from refreshAccessToken for cleaner promise management
      */
     async performRefresh(refreshToken) {
-        // Use provided refresh token or get from auth provider
         const tokenToUse = refreshToken || (this.authProvider ? await this.authProvider.getRefreshToken() : null);
         if (!tokenToUse) {
             throw new Error('No refresh token available for token refresh');
         }
         const response = await this.authApi.refreshAccessToken(tokenToUse);
-        // Store new tokens if auth provider supports it
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken);
         }
         return response;
     }
     /**
-     * Clear stored tokens if auth provider supports it
-     * Also clears any active refresh operations
+     * Clear stored tokens and active refresh operations
      */
     async clearTokens() {
-        // Clear any active refresh operation
         this.activeRefreshPromise = null;
         if (this.authProvider) {
             await this.authProvider.clearTokens();
         }
     }
     /**
-     * Check if we have valid tokens for authentication
+     * Check if we have valid authentication tokens
      */
     async hasValidAuth() {
         if (!this.authProvider)
@@ -243,43 +206,34 @@ class AuthService {
     // PRIVATE HELPERS
     // ==========================================
     /**
-     * Store tokens using auth provider if it supports token storage
+     * Store tokens using auth provider
      */
     async storeTokens(accessToken, refreshToken, authType, providerToken) {
         if (!this.authProvider)
             return;
         try {
-            // Store access token
-            if (this.authProvider) {
-                await this.authProvider.setAccessToken(accessToken);
-            }
-            // Store refresh token if provided and supported
-            if (refreshToken && this.authProvider) {
+            await this.authProvider.setAccessToken(accessToken);
+            if (refreshToken) {
                 await this.authProvider.setRefreshToken(refreshToken);
             }
-            // Store provider token if provided and provider supports it
-            if (providerToken && 'setProviderToken' in this.authProvider &&
-                typeof this.authProvider.setProviderToken === 'function') {
-                await this.authProvider.setProviderToken(providerToken);
+            // Type-safe handling of extended token storage features
+            const extendedProvider = this.authProvider;
+            if (providerToken && extendedProvider.setProviderToken) {
+                await extendedProvider.setProviderToken(providerToken);
             }
-            // Store auth type if provided and provider supports it
-            if (authType && 'setAuthType' in this.authProvider &&
-                typeof this.authProvider.setAuthType === 'function') {
-                await this.authProvider.setAuthType(authType);
+            if (authType && extendedProvider.setAuthType) {
+                await extendedProvider.setAuthType(authType);
             }
         }
         catch (error) {
-            // Log error for debugging but don't throw - token storage failure shouldn't break auth flow
             console.warn('[AuthService] Failed to store tokens:', error);
         }
     }
 }
 
 /**
- * Simple Token Refresh Manager
- *
- * Just moves the working refresh logic to a separate file for better organization.
- * No overengineering - keeps the exact same simple logic.
+ * Token Refresh Manager
+ * Simple container for token refresh logic with better organization
  */
 class TokenRefreshManager {
     constructor(authService, authProvider) {
@@ -290,12 +244,7 @@ class TokenRefreshManager {
     async ensureValidToken() {
         try {
             const token = await this.authProvider.getToken();
-            if (!token) {
-                await this.attemptInternalRefresh();
-                return;
-            }
-            // Check if token is close to expiry (within 2 minutes)
-            if (this.isTokenExpiringSoon(token, this.tokenRefreshMarginSeconds)) {
+            if (!token || web3ChainService.isTokenExpired(token, this.tokenRefreshMarginSeconds)) {
                 await this.attemptInternalRefresh();
             }
         }
@@ -313,27 +262,11 @@ class TokenRefreshManager {
             return false;
         }
     }
-    isTokenExpiringSoon(token, marginSeconds) {
-        try {
-            const parts = token.split('.');
-            if (parts.length !== 3)
-                return true;
-            const payload = JSON.parse(atob(parts[1]));
-            if (!payload.exp)
-                return false;
-            const timeUntilExpiry = payload.exp - Math.floor(Date.now() / 1000);
-            return timeUntilExpiry <= marginSeconds;
-        }
-        catch {
-            return true;
-        }
-    }
 }
 
 /**
- * Clean Token Storage System
- *
- * Simple, focused token storage with clear separation of concerns.
+ * Token Storage System
+ * Simple, focused token storage with clear separation of concerns
  */
 const AUTH_STORAGE_KEYS = {
     ACCESS_TOKEN: 'pers_access_token',
@@ -346,26 +279,24 @@ const AUTH_STORAGE_KEYS = {
  */
 class LocalStorageTokenStorage {
     async get(key) {
-        if (typeof localStorage === 'undefined')
-            return null;
-        return localStorage.getItem(key);
+        return typeof localStorage !== 'undefined' ? localStorage.getItem(key) : null;
     }
     async set(key, value) {
-        if (typeof localStorage === 'undefined')
-            return;
-        localStorage.setItem(key, value);
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(key, value);
+        }
     }
     async remove(key) {
-        if (typeof localStorage === 'undefined')
-            return;
-        localStorage.removeItem(key);
+        if (typeof localStorage !== 'undefined') {
+            localStorage.removeItem(key);
+        }
     }
     async clear() {
-        if (typeof localStorage === 'undefined')
-            return;
-        Object.values(AUTH_STORAGE_KEYS).forEach(key => {
-            localStorage.removeItem(key);
-        });
+        if (typeof localStorage !== 'undefined') {
+            Object.values(AUTH_STORAGE_KEYS).forEach(key => {
+                localStorage.removeItem(key);
+            });
+        }
     }
 }
 /**
@@ -390,34 +321,29 @@ class MemoryTokenStorage {
 }
 /**
  * Token manager for authentication tokens
- * Clean, focused on auth tokens only
  */
 class AuthTokenManager {
     constructor(storage = new LocalStorageTokenStorage()) {
         this.storage = storage;
     }
-    // Access token methods
     async getAccessToken() {
         return this.storage.get(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
     }
     async setAccessToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.ACCESS_TOKEN, token);
     }
-    // Refresh token methods
     async getRefreshToken() {
         return this.storage.get(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
     }
     async setRefreshToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.REFRESH_TOKEN, token);
     }
-    // Provider token methods
     async getProviderToken() {
         return this.storage.get(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
     }
     async setProviderToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.PROVIDER_TOKEN, token);
     }
-    // Auth type methods
     async getAuthType() {
         const authType = await this.storage.get(AUTH_STORAGE_KEYS.AUTH_TYPE);
         return authType;
@@ -425,7 +351,6 @@ class AuthTokenManager {
     async setAuthType(authType) {
         await this.storage.set(AUTH_STORAGE_KEYS.AUTH_TYPE, authType);
     }
-    // Bulk operations
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.setAccessToken(accessToken);
         if (refreshToken)
@@ -436,7 +361,6 @@ class AuthTokenManager {
     async clearAllTokens() {
         await this.storage.clear();
     }
-    // Utility methods
     async hasAccessToken() {
         const token = await this.getAccessToken();
         return !!token;
@@ -448,31 +372,24 @@ class AuthTokenManager {
 }
 
 /**
- * Clean Default Authentication Provider
- *
- * Simple, focused implementation of PERS authentication
- * with clear separation of concerns and minimal complexity.
+ * Default Authentication Provider
+ * Simple implementation of PERS authentication with token lifecycle management
  */
 /**
- * Clean, simple authentication provider
- * Handles token lifecycle with minimal complexity
+ * Simple authentication provider with token storage
  */
 class DefaultAuthProvider {
     constructor(config = {}) {
         this.config = config;
         this.authType = config.authType || 'user';
-        // Use custom storage if provided, otherwise auto-detect
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
     }
     createStorage() {
-        // Memory storage for server-side or when localStorage unavailable
-        if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return new MemoryTokenStorage();
-        }
-        return new LocalStorageTokenStorage();
+        return typeof window === 'undefined' || typeof localStorage === 'undefined'
+            ? new MemoryTokenStorage()
+            : new LocalStorageTokenStorage();
     }
-    // Core PersAuthProvider methods
     getToken() {
         return this.tokenManager.getAccessToken();
     }
@@ -481,14 +398,10 @@ class DefaultAuthProvider {
     }
     async onTokenExpired() {
         try {
-            // Note: Internal refresh token logic is now handled by PersApiClient.attemptInternalRefresh()
-            // This callback is only called when internal refresh fails or no refresh token is available
-            // Try custom expiration handler first  
             if (this.config.onTokenExpired) {
                 await this.config.onTokenExpired();
                 return;
             }
-            // Try token provider (Firebase, Auth0, etc.) as fallback
             if (this.config.tokenProvider) {
                 const newToken = await this.config.tokenProvider();
                 if (newToken) {
@@ -497,15 +410,12 @@ class DefaultAuthProvider {
                     return;
                 }
             }
-            // Final fallback: clear all tokens (logout)
             await this.tokenManager.clearAllTokens();
         }
         catch (error) {
-            // On any error, clear tokens to ensure clean state
             await this.tokenManager.clearAllTokens();
         }
     }
-    // TokenStorageProvider methods  
     async setAccessToken(token) {
         await this.tokenManager.setAccessToken(token);
     }
@@ -518,7 +428,6 @@ class DefaultAuthProvider {
     async clearTokens() {
         await this.tokenManager.clearAllTokens();
     }
-    // Utility methods
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.tokenManager.setTokens(accessToken, refreshToken, providerToken);
     }
@@ -620,39 +529,21 @@ class PersApiError extends Error {
 
 // packages/pers-sdk/src/core/pers-api-client.ts
 /**
- * PERS API Client - Core platform-agnostic client for PERS backend
+ * PERS API Client - Platform-agnostic HTTP client with authentication
  *
- * Provides authenticated HTTP client with automatic token management,
- * proactive refresh, and comprehensive error handling.
- *
- * Features:
- * - Automatic token refresh before expiry
- * - Background refresh for optimal performance
- * - Provider token fallback for seamless authentication
- * - Configurable retry and timeout settings
- * - Platform-agnostic design
+ * Features: automatic token refresh, background validation, configurable settings
  *
  * @example
  * ```typescript
  * const client = new PersApiClient(httpClient, {
  *   environment: 'production',
  *   apiProjectKey: 'your-project-key',
- *   authProvider: new DefaultAuthProvider({
- *     tokenProvider: () => getFirebaseToken()
- *   })
+ *   authProvider: new DefaultAuthProvider()
  * });
  *
- * // Make authenticated requests
  * const data = await client.get('/users/me');
  * ```
  */
-// Auth constants
-const AUTH_METHODS = {
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    DELETE: 'DELETE',
-};
 class PersApiClient {
     /**
      * Creates a new PERS API Client instance
@@ -701,72 +592,36 @@ class PersApiClient {
     async attemptInternalRefresh() {
         return this.refreshManager.attemptInternalRefresh();
     }
-    /**
-     * Get request headers including auth token and project key
-     */
-    async getHeaders() {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        // Add authentication token
-        if (this.mergedConfig.authProvider) {
-            const token = await this.mergedConfig.authProvider.getToken();
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
-            else {
-                console.warn('[PersApiClient] No token available from auth provider');
-            }
-        }
-        else {
-            console.warn('[PersApiClient] No auth provider configured');
-        }
-        // Add project key
-        if (this.mergedConfig.authProvider) {
-            const projectKey = await this.mergedConfig.authProvider.getProjectKey();
-            if (projectKey) {
-                headers['x-project-key'] = projectKey;
-            }
-        }
-        else if (this.mergedConfig.apiProjectKey) {
-            // Fallback to config project key if no auth provider
-            headers['x-project-key'] = this.mergedConfig.apiProjectKey;
-        }
-        return headers;
-    }
     /**
      * Make a request with proper headers, auth, and error handling
      */
     async request(method, endpoint, body, options) {
         const { retryCount = 0, responseType = 'json', bypassAuth = false } = options || {};
         const url = `${this.apiRoot}${endpoint}`;
-        // Proactive token expiry check and refresh BEFORE making the request
-        // Non-blocking for optimal performance - request proceeds immediately
+        // Proactive token validation for optimal performance
         if (!bypassAuth && this.mergedConfig.authProvider && retryCount === 0) {
             this.ensureValidToken().catch(error => {
-                // Log but don't block request - 401 handling will catch any issues
                 console.debug('[PersApiClient] Background token validation failed:', error);
             });
         }
         const requestOptions = {
-            headers: bypassAuth ? await this.getHeadersWithoutAuth() : await this.getHeaders(),
+            headers: await this.getHeaders(!bypassAuth),
             timeout: this.mergedConfig.timeout,
             responseType
         };
-        // const isCSVEndpoint = endpoint.includes('/export/csv');
         try {
             let result;
             switch (method) {
-                case AUTH_METHODS.GET:
+                case 'GET':
                     result = await this.httpClient.get(url, requestOptions);
                     break;
-                case AUTH_METHODS.POST:
+                case 'POST':
                     result = await this.httpClient.post(url, body, requestOptions);
                     break;
-                case AUTH_METHODS.PUT:
+                case 'PUT':
                     result = await this.httpClient.put(url, body, requestOptions);
                     break;
-                case AUTH_METHODS.DELETE:
+                case 'DELETE':
                     result = await this.httpClient.delete(url, requestOptions);
                     break;
                 default:
@@ -819,46 +674,51 @@ class PersApiClient {
      * ```
      */
     async get(endpoint, responseType) {
-        return this.request(AUTH_METHODS.GET, endpoint, undefined, { responseType });
+        return this.request('GET', endpoint, undefined, { responseType });
     }
     /**
      * Performs an authenticated POST request
-     *
-     * @template T - Expected response type
-     * @param endpoint - API endpoint path (without base URL)
-     * @param body - Request payload data
-     * @param options - Request options including auth bypass
-     * @returns Promise resolving to typed response data
-     *
-     * @example
-     * ```typescript
-     * const user = await client.post<User>('/users', userData);
-     * const publicData = await client.post('/public/contact', formData, { bypassAuth: true });
-     * ```
      */
     async post(endpoint, body, options) {
-        return this.request(AUTH_METHODS.POST, endpoint, body, options);
+        return this.request('POST', endpoint, body, options);
     }
     /**
      * Generic PUT request
      */
     async put(endpoint, body) {
-        return this.request(AUTH_METHODS.PUT, endpoint, body);
+        return this.request('PUT', endpoint, body);
     }
     /**
      * Generic DELETE request
      */
     async delete(endpoint) {
-        return this.request(AUTH_METHODS.DELETE, endpoint);
+        return this.request('DELETE', endpoint);
     }
     /**
-   * Get request headers WITHOUT auth token (for auth operations like refresh/login)
-   */
-    async getHeadersWithoutAuth() {
+     * Get request headers with optional auth token and project key
+     *
+     * @param includeAuth - Whether to include the Authorization header (default: true)
+     */
+    async getHeaders(includeAuth = true) {
         const headers = {
             'Content-Type': 'application/json',
         };
-        // Add project key only (no auth token)
+        if (includeAuth) {
+            // Add authentication token
+            if (this.mergedConfig.authProvider) {
+                const token = await this.mergedConfig.authProvider.getToken();
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
+                }
+                else {
+                    console.warn('[PersApiClient] No token available from auth provider');
+                }
+            }
+            else {
+                console.warn('[PersApiClient] No auth provider configured');
+            }
+        }
+        // Add project key
         if (this.mergedConfig.authProvider) {
             const projectKey = await this.mergedConfig.authProvider.getProjectKey();
             if (projectKey) {
@@ -871,11 +731,10 @@ class PersApiClient {
         return headers;
     }
     // ==========================================
-    // INTERNAL AUTH METHODS (For AuthManager use only)
+    // INTERNAL AUTH METHODS
     // ==========================================
     /**
      * @internal - For AuthManager use only
-     * Direct access to auth service for manager layer
      */
     getAuthService() {
         return this.authService;
@@ -896,25 +755,21 @@ class PersApiClient {
 
 /**
  * Environment Detection Utility
- *
- * Detects the runtime environment to handle platform-specific behaviors
- * for bundling and module resolution.
+ * Detects runtime environment for platform-specific behaviors
  */
 /**
  * Detects the current runtime environment
  */
 function detectEnvironment() {
+    const global = globalThis;
     const isNode = typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null &&
-        typeof globalThis.window === 'undefined';
-    const isBrowser = typeof globalThis.window !== 'undefined' &&
-        typeof globalThis.document !== 'undefined';
-    const isReactNative = typeof globalThis.navigator !== 'undefined' &&
-        typeof globalThis.navigator.product === 'string' &&
-        globalThis.navigator.product.toLowerCase() === 'reactnative';
+        process.versions?.node != null &&
+        typeof global.window === 'undefined';
+    const isBrowser = typeof global.window !== 'undefined' &&
+        typeof global.document !== 'undefined';
+    const isReactNative = typeof global.navigator?.product === 'string' &&
+        global.navigator.product.toLowerCase() === 'reactnative';
     const isWeb = isBrowser || isReactNative;
-    // Node.js streams: Only native in Node.js, need polyfills or avoidance in web
     const needsNodeStreamPolyfills = isWeb;
     return {
         isNode,
@@ -929,7 +784,7 @@ function detectEnvironment() {
  */
 const environment = detectEnvironment();
 /**
- * Warns if we're in an environment that might have bundling issues
+ * Warns if environment might have bundling issues
  */
 function warnIfProblematicEnvironment(feature) {
     if (environment.needsNodeStreamPolyfills) {
@@ -5847,4 +5702,4 @@ exports.detectEnvironment = detectEnvironment;
 exports.environment = environment;
 exports.mergeWithDefaults = mergeWithDefaults;
 exports.warnIfProblematicEnvironment = warnIfProblematicEnvironment;
-//# sourceMappingURL=pers-sdk-CajYwGkL.cjs.map
+//# sourceMappingURL=pers-sdk-CmyPEhy7.cjs.map