@metrone-io/sdk 1.0.1 → 1.1.0

package/dist/index.esm.js

@@ -99,46 +99,51 @@ var Metrone = /** @class */ (function () {
     function Metrone(config) {
         var _this = this;
         this.isInitialized = false;
+        this.trackingActive = false;
         this.eventQueue = [];
         this.isOnline = true;
-        this.version = '1.0.1';
+        this.version = '1.1.0';
         this.updateCheckInterval = null;
-        this.config = __assign({ endpoint: 'https://api.metrone.io/v1/events', debug: false, autoTrack: true, autoUpdate: false, batchSize: 10, flushInterval: 5000, offlineQueue: true, maxQueueSize: 100, respectDoNotTrack: true, anonymizeIP: true, cookieConsent: 'optional' }, config);
-        // Validate required config
+        this.flushTimerId = null;
+        this.boundVisibilityHandler = null;
+        this.boundBeforeUnloadHandler = null;
+        this.lastTrackedPath = '';
+        this.config = __assign({ endpoint: 'https://api.metrone.io/v1/events', debug: false, autoTrack: true, autoTrackSPA: false, autoUpdate: false, batchSize: 10, flushInterval: 5000, offlineQueue: true, maxQueueSize: 100, respectDoNotTrack: false, anonymizeIP: true, cookieConsent: 'optional' }, config);
         if (!this.config.apiKey) {
-            throw new Error('API key is required');
+            throw new Error('[Metrone] API key is required');
         }
         var validPrefixes = ['metrone_live_', 'metrone_test_', 'mk_live_', 'mk_test_'];
         if (!validPrefixes.some(function (p) { return _this.config.apiKey.startsWith(p); })) {
-            throw new Error('Invalid API key format. Must start with "metrone_live_", "metrone_test_", "mk_live_", or "mk_test_"');
+            throw new Error('[Metrone] Invalid API key format. Must start with "metrone_live_", "metrone_test_", "mk_live_", or "mk_test_"');
+        }
+        if (!this.config.batchEndpoint) {
+            this.config.batchEndpoint = this.config.endpoint.replace(/\/events\/?$/, '/events/batch');
         }
         this.sessionId = this.generateSessionId();
         this.isInitialized = true;
-        // Check for Do Not Track
         if (this.config.respectDoNotTrack && this.isDoNotTrackEnabled()) {
-            if (this.config.debug) {
-                console.log('🔒 Do Not Track is enabled, analytics disabled');
-            }
+            console.warn('[Metrone] Do Not Track detected — analytics disabled. Set respectDoNotTrack: false to override.');
             return;
         }
-        // Check for cookie consent
         if (this.config.cookieConsent === 'required' && !this.hasConsent()) {
-            if (this.config.debug) {
-                console.log('🍪 Cookie consent required, analytics disabled');
-            }
+            console.warn('[Metrone] Cookie consent required but not granted — analytics disabled.');
             return;
         }
-        // Set up online/offline detection
+        this.trackingActive = true;
         this.setupOnlineDetection();
+        this.setupPageUnloadFlush();
         if (this.config.autoTrack) {
+            this.lastTrackedPath = window.location.pathname;
             this.pageview();
         }
-        // Set up batch processing
+        if (this.config.autoTrackSPA) {
+            this.setupSPATracking();
+        }
         if (this.config.batchSize && this.config.batchSize > 1) {
             this.setupBatchProcessing();
         }
         if (this.config.debug) {
-            console.log('Metrone SDK initialized:', {
+            console.log('[Metrone] SDK initialized:', {
                 apiKey: this.config.apiKey.substring(0, 12) + '...',
                 projectId: this.config.projectId,
                 sessionId: this.sessionId,
@@ -147,11 +152,17 @@ var Metrone = /** @class */ (function () {
             });
         }
     }
+    /**
+     * Whether the SDK is actively tracking events (not disabled by DNT/consent).
+     */
+    Metrone.prototype.isActive = function () {
+        return this.isInitialized && this.trackingActive;
+    };
     /**
      * Track a page view
      */
     Metrone.prototype.pageview = function (url, title, metadata) {
-        if (!this.isInitialized)
+        if (!this.isInitialized || !this.trackingActive)
             return;
         this.track('pageview', __assign({ page_url: url || window.location.href, page_path: window.location.pathname, page_title: title || document.title, referrer: document.referrer, source: 'web' }, metadata));
     };
@@ -160,9 +171,11 @@ var Metrone = /** @class */ (function () {
      */
     Metrone.prototype.track = function (eventName, data) {
         if (!this.isInitialized) {
-            console.warn('Analytics SDK not initialized');
+            console.warn('[Metrone] SDK not initialized');
             return;
         }
+        if (!this.trackingActive)
+            return;
         var _a = (data !== null && data !== void 0 ? data : {}), source = _a.source, channel = _a.channel, ai_provider = _a.ai_provider, ai_call_id = _a.ai_call_id, ai_session_id = _a.ai_session_id, ai_intent = _a.ai_intent, ai_duration_sec = _a.ai_duration_sec, utm_source = _a.utm_source, utm_medium = _a.utm_medium, utm_campaign = _a.utm_campaign, utm_term = _a.utm_term, utm_content = _a.utm_content, page_path = _a.page_path, page_title = _a.page_title, dataPageUrl = _a.page_url, dataReferrer = _a.referrer, event_name = _a.event_name, rest = __rest(_a, ["source", "channel", "ai_provider", "ai_call_id", "ai_session_id", "ai_intent", "ai_duration_sec", "utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content", "page_path", "page_title", "page_url", "referrer", "event_name"]);
         var eventData = {
             event_type: eventName,
@@ -254,9 +267,6 @@ var Metrone = /** @class */ (function () {
     Metrone.prototype.trackAISession = function (data) {
         this.track("ai_session_".concat(data.action), __assign({ source: 'assistant', ai_provider: data.provider || 'unknown', ai_session_id: data.session_id, ai_duration_sec: data.duration }, data.metadata));
     };
-    /**
-     * Send event to analytics API
-     */
     Metrone.prototype.sendEvent = function (eventData) {
         return __awaiter(this, void 0, void 0, function () {
             var requestData, error_1;
@@ -266,7 +276,6 @@ var Metrone = /** @class */ (function () {
                         _a.trys.push([0, 6, , 7]);
                         requestData = __assign(__assign({}, eventData), { api_key: this.config.apiKey });
                         if (!(this.config.batchSize && this.config.batchSize > 1)) return [3 /*break*/, 3];
-                        // Add to batch queue
                         this.eventQueue.push(requestData);
                         if (!(this.eventQueue.length >= this.config.batchSize)) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.flushBatch()];
@@ -274,20 +283,14 @@ var Metrone = /** @class */ (function () {
                         _a.sent();
                         _a.label = 2;
                     case 2: return [3 /*break*/, 5];
-                    case 3: 
-                    // Send immediately
-                    return [4 /*yield*/, this.sendRequest(requestData)];
+                    case 3: return [4 /*yield*/, this.sendRequest(requestData)];
                     case 4:
-                        // Send immediately
                         _a.sent();
                         _a.label = 5;
                     case 5: return [3 /*break*/, 7];
                     case 6:
                         error_1 = _a.sent();
-                        if (this.config.debug) {
-                            console.error('Failed to send analytics event:', error_1);
-                        }
-                        // Queue for retry if offline
+                        console.warn('[Metrone] Failed to send event:', error_1.message);
                         if (this.config.offlineQueue && !this.isOnline) {
                             this.queueEvent(eventData);
                         }
@@ -297,9 +300,6 @@ var Metrone = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Send request to analytics API
-     */
     Metrone.prototype.sendRequest = function (data) {
         return __awaiter(this, void 0, void 0, function () {
             var response;
@@ -307,30 +307,25 @@ var Metrone = /** @class */ (function () {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, fetch(this.config.endpoint, {
                             method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                            },
+                            headers: { 'Content-Type': 'application/json' },
                             body: JSON.stringify(data)
                         })];
                     case 1:
                         response = _a.sent();
                         if (!response.ok) {
-                            throw new Error("Analytics API error: ".concat(response.status, " ").concat(response.statusText));
+                            throw new Error("".concat(response.status, " ").concat(response.statusText));
                         }
                         if (this.config.debug) {
-                            console.log('Analytics event sent:', data.event_type);
+                            console.log('[Metrone] Event sent:', data.event_type);
                         }
                         return [2 /*return*/];
                 }
             });
         });
     };
-    /**
-     * Flush batch of events
-     */
     Metrone.prototype.flushBatch = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var batch, batchEndpoint, error_2;
+            var batch, error_2;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -342,19 +337,16 @@ var Metrone = /** @class */ (function () {
                         _b.label = 1;
                     case 1:
                         _b.trys.push([1, 3, , 4]);
-                        batchEndpoint = this.config.endpoint.replace(/\/events\/?$/, '/events/batch');
-                        return [4 /*yield*/, this.sendBatchRequest(batchEndpoint, batch)];
+                        return [4 /*yield*/, this.sendBatchRequest(batch)];
                     case 2:
                         _b.sent();
                         if (this.config.debug) {
-                            console.log("Batch sent: ".concat(batch.length, " events"));
+                            console.log("[Metrone] Batch sent: ".concat(batch.length, " events"));
                         }
                         return [3 /*break*/, 4];
                     case 3:
                         error_2 = _b.sent();
-                        if (this.config.debug) {
-                            console.error('Failed to send batch:', error_2);
-                        }
+                        console.warn('[Metrone] Failed to send batch:', error_2.message);
                         if (this.config.offlineQueue && !this.isOnline) {
                             (_a = this.eventQueue).unshift.apply(_a, batch);
                         }
@@ -364,22 +356,20 @@ var Metrone = /** @class */ (function () {
             });
         });
     };
-    Metrone.prototype.sendBatchRequest = function (endpoint, events) {
+    Metrone.prototype.sendBatchRequest = function (events) {
         return __awaiter(this, void 0, void 0, function () {
             var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, fetch(endpoint, {
+                    case 0: return [4 /*yield*/, fetch(this.config.batchEndpoint, {
                             method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                            },
+                            headers: { 'Content-Type': 'application/json' },
                             body: JSON.stringify(events)
                         })];
                     case 1:
                         response = _a.sent();
                         if (!response.ok) {
-                            throw new Error("Analytics API error: ".concat(response.status, " ").concat(response.statusText));
+                            throw new Error("".concat(response.status, " ").concat(response.statusText));
                         }
                         return [2 /*return*/];
                 }
@@ -387,20 +377,33 @@ var Metrone = /** @class */ (function () {
         });
     };
     /**
-     * Queue event for offline processing
+     * Flush queued events using sendBeacon (survives page unload).
      */
+    Metrone.prototype.beaconFlush = function () {
+        if (this.eventQueue.length === 0)
+            return;
+        var batch = __spreadArray([], this.eventQueue, true);
+        this.eventQueue = [];
+        try {
+            var payload = JSON.stringify(batch);
+            var sent = navigator.sendBeacon(this.config.batchEndpoint, payload);
+            if (!sent && this.config.debug) {
+                console.warn('[Metrone] sendBeacon failed, events may be lost');
+            }
+        }
+        catch (_a) {
+            // sendBeacon not available or failed — nothing we can do at unload time
+        }
+    };
     Metrone.prototype.queueEvent = function (eventData) {
         if (this.eventQueue.length >= (this.config.maxQueueSize || 100)) {
-            this.eventQueue.shift(); // Remove oldest event
+            this.eventQueue.shift();
         }
         this.eventQueue.push(eventData);
     };
-    /**
-     * Process offline queue when back online
-     */
     Metrone.prototype.processQueue = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var queue, _i, queue_1, event_1, error_3;
+            var queue, _i, queue_1, event_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -421,11 +424,7 @@ var Metrone = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 5];
                     case 4:
-                        error_3 = _a.sent();
-                        if (this.config.debug) {
-                            console.error('Failed to process queued event:', error_3);
-                        }
-                        // Re-queue failed events
+                        _a.sent();
                         this.eventQueue.push(event_1);
                         return [3 /*break*/, 5];
                     case 5:
@@ -433,58 +432,80 @@ var Metrone = /** @class */ (function () {
                         return [3 /*break*/, 1];
                     case 6:
                         if (this.config.debug) {
-                            console.log("\uD83D\uDD04 Processed ".concat(queue.length, " queued events"));
+                            console.log("[Metrone] Processed ".concat(queue.length, " queued events"));
                         }
                         return [2 /*return*/];
                 }
             });
         });
     };
-    /**
-     * Set up online/offline detection
-     */
     Metrone.prototype.setupOnlineDetection = function () {
         var _this = this;
         this.isOnline = navigator.onLine;
         window.addEventListener('online', function () {
             _this.isOnline = true;
             if (_this.config.debug) {
-                console.log('🌐 Back online, processing queue');
+                console.log('[Metrone] Back online, processing queue');
             }
             _this.processQueue();
         });
         window.addEventListener('offline', function () {
             _this.isOnline = false;
             if (_this.config.debug) {
-                console.log('📴 Gone offline, queuing events');
+                console.log('[Metrone] Gone offline, queuing events');
             }
         });
     };
-    /**
-     * Set up batch processing
-     */
     Metrone.prototype.setupBatchProcessing = function () {
         var _this = this;
         if (this.config.flushInterval && this.config.flushInterval > 0) {
-            setInterval(function () {
+            this.flushTimerId = window.setInterval(function () {
                 _this.flushBatch();
             }, this.config.flushInterval);
         }
     };
     /**
-     * Set up auto-updates
+     * Flush pending events on page hide / beforeunload using sendBeacon.
+     */
+    Metrone.prototype.setupPageUnloadFlush = function () {
+        var _this = this;
+        this.boundVisibilityHandler = function () {
+            if (document.visibilityState === 'hidden') {
+                _this.beaconFlush();
+            }
+        };
+        this.boundBeforeUnloadHandler = function () {
+            _this.beaconFlush();
+        };
+        document.addEventListener('visibilitychange', this.boundVisibilityHandler);
+        window.addEventListener('beforeunload', this.boundBeforeUnloadHandler);
+    };
+    /**
+     * Auto-track SPA route changes via History API and popstate.
      */
-    Metrone.prototype.setupAutoUpdates = function () {
+    Metrone.prototype.setupSPATracking = function () {
         var _this = this;
-        // Check for updates every hour
-        this.updateCheckInterval = window.setInterval(function () {
-            _this.checkForUpdates();
-        }, 60 * 60 * 1000);
-        // Initial check
-        this.checkForUpdates();
+        var origPushState = history.pushState.bind(history);
+        var origReplaceState = history.replaceState.bind(history);
+        var onRouteChange = function () {
+            var newPath = window.location.pathname;
+            if (newPath !== _this.lastTrackedPath) {
+                _this.lastTrackedPath = newPath;
+                setTimeout(function () { return _this.pageview(); }, 0);
+            }
+        };
+        history.pushState = function (data, unused, url) {
+            origPushState(data, unused, url);
+            onRouteChange();
+        };
+        history.replaceState = function (data, unused, url) {
+            origReplaceState(data, unused, url);
+            onRouteChange();
+        };
+        window.addEventListener('popstate', onRouteChange);
     };
     /**
-     * Check for SDK updates
+     * Check for SDK updates (only relevant for script-tag installations).
      */
     Metrone.prototype.checkForUpdates = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -492,21 +513,35 @@ var Metrone = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, fetch('/api/analytics/version')];
+                        if (this.isModuleContext()) {
+                            if (this.config.debug) {
+                                console.log('[Metrone] Auto-update is not supported in module/bundler context. Update via npm instead.');
+                            }
+                            return [2 /*return*/, {
+                                    available: false,
+                                    current: this.version,
+                                    latest: this.version,
+                                    features: [],
+                                    changelog: []
+                                }];
+                        }
+                        _a.label = 1;
                     case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, fetch('/api/analytics/version')];
+                    case 2:
                         response = _a.sent();
                         return [4 /*yield*/, response.json()];
-                    case 2:
+                    case 3:
                         updateInfo = _a.sent();
                         if (updateInfo.latest !== this.version) {
                             this.handleUpdate(updateInfo);
                         }
                         return [2 /*return*/, updateInfo];
-                    case 3:
+                    case 4:
                         error_4 = _a.sent();
                         if (this.config.debug) {
-                            console.log('Update check failed:', error_4);
+                            console.log('[Metrone] Update check failed:', error_4);
                         }
                         return [2 /*return*/, {
                                 available: false,
@@ -515,87 +550,76 @@ var Metrone = /** @class */ (function () {
                                 features: [],
                                 changelog: []
                             }];
-                    case 4: return [2 /*return*/];
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
-    /**
-     * Handle SDK update
-     */
     Metrone.prototype.handleUpdate = function (updateInfo) {
-        if (this.config.autoUpdate !== false) {
+        if (this.config.autoUpdate !== false && !this.isModuleContext()) {
             this.loadNewVersion(updateInfo.latest);
         }
         else {
             this.notifyUpdate(updateInfo);
         }
     };
-    /**
-     * Load new SDK version
-     */
     Metrone.prototype.loadNewVersion = function (version) {
         var _this = this;
         if (this.config.debug) {
-            console.log("\uD83D\uDD04 Updating SDK to version ".concat(version));
+            console.log("[Metrone] Updating SDK to version ".concat(version));
         }
-        // Reload the SDK script
         var script = document.createElement('script');
         script.src = '/js/metrone.js';
         script.onload = function () {
             if (_this.config.debug) {
-                console.log("\u2705 SDK updated to version ".concat(version));
+                console.log("[Metrone] SDK updated to version ".concat(version));
             }
         };
         document.head.appendChild(script);
     };
-    /**
-     * Notify about available update
-     */
     Metrone.prototype.notifyUpdate = function (updateInfo) {
         if (this.config.debug) {
-            console.log("\uD83D\uDCE2 SDK update available: ".concat(updateInfo.latest));
-            console.log('New features:', updateInfo.features);
+            console.log("[Metrone] SDK update available: ".concat(updateInfo.latest));
         }
-        // Dispatch custom event for update notification
         window.dispatchEvent(new CustomEvent('metrone-update', {
             detail: updateInfo
         }));
     };
     /**
-     * Generate session ID
+     * Detect whether the SDK is running inside a bundler/module context
+     * vs. a plain script-tag.
      */
+    Metrone.prototype.isModuleContext = function () {
+        try {
+            // If this code is part of a bundle, `module` or import.meta will be defined.
+            // The simplest heuristic: check if the current script tag has type="module"
+            // or if we're in a context where document.currentScript is null (bundled).
+            return typeof document === 'undefined' || document.currentScript === null;
+        }
+        catch (_a) {
+            return true;
+        }
+    };
     Metrone.prototype.generateSessionId = function () {
         var timestamp = Date.now().toString(36);
         var random = Math.random().toString(36).substring(2, 15);
         return "sess_".concat(timestamp, "_").concat(random);
     };
-    /**
-     * Check if Do Not Track is enabled
-     */
     Metrone.prototype.isDoNotTrackEnabled = function () {
         return navigator.doNotTrack === '1' ||
             navigator.doNotTrack === 'yes' ||
             window.doNotTrack === '1';
     };
-    /**
-     * Check if user has given consent
-     */
     Metrone.prototype.hasConsent = function () {
-        // Check for common consent management platforms
         var consent = localStorage.getItem('cookie-consent') ||
             localStorage.getItem('gdpr-consent') ||
             localStorage.getItem('cc-consent');
         return consent === 'accepted' || consent === 'true';
     };
-    /**
-     * Request user consent
-     */
     Metrone.prototype.requestConsent = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, new Promise(function (resolve) {
-                        // Dispatch custom event for consent request
                         window.dispatchEvent(new CustomEvent('metrone-consent-request', {
                             detail: { resolve: resolve }
                         }));
@@ -603,45 +627,30 @@ var Metrone = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Revoke user consent
-     */
     Metrone.prototype.revokeConsent = function () {
         localStorage.removeItem('cookie-consent');
         localStorage.removeItem('gdpr-consent');
         localStorage.removeItem('cc-consent');
         if (this.config.debug) {
-            console.log('🔒 Consent revoked, analytics disabled');
+            console.log('[Metrone] Consent revoked, analytics disabled');
         }
     };
-    /**
-     * Anonymize data
-     */
     Metrone.prototype.anonymize = function (data) {
         var hash = this.simpleHash(data);
         return "anon_".concat(hash);
     };
-    /**
-     * Simple hash function
-     */
     Metrone.prototype.simpleHash = function (str) {
         var hash = 0;
         for (var i = 0; i < str.length; i++) {
             var char = str.charCodeAt(i);
             hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32-bit integer
+            hash = hash & hash;
         }
         return Math.abs(hash).toString(36);
     };
-    /**
-     * Check if running on mobile device
-     */
     Metrone.prototype.isMobile = function () {
         return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
     };
-    /**
-     * Get screen size
-     */
     Metrone.prototype.getScreenSize = function () {
         var width = window.screen.width;
         if (width < 768)
@@ -650,62 +659,54 @@ var Metrone = /** @class */ (function () {
             return 'tablet';
         return 'desktop';
     };
-    /**
-     * Flush pending events
-     */
     Metrone.prototype.flush = function () {
         this.flushBatch();
     };
-    /**
-     * Destroy SDK instance
-     */
     Metrone.prototype.destroy = function () {
         if (this.updateCheckInterval) {
             clearInterval(this.updateCheckInterval);
         }
-        this.flush();
+        if (this.flushTimerId) {
+            clearInterval(this.flushTimerId);
+        }
+        if (this.boundVisibilityHandler) {
+            document.removeEventListener('visibilitychange', this.boundVisibilityHandler);
+        }
+        if (this.boundBeforeUnloadHandler) {
+            window.removeEventListener('beforeunload', this.boundBeforeUnloadHandler);
+        }
+        this.beaconFlush();
         this.isInitialized = false;
+        this.trackingActive = false;
         if (this.config.debug) {
-            console.log('🗑️ Metrone SDK destroyed');
+            console.log('[Metrone] SDK destroyed');
         }
     };
-    /**
-     * Get current version
-     */
     Metrone.prototype.getVersion = function () {
         return this.version;
     };
-    /**
-     * Get session ID
-     */
     Metrone.prototype.getSessionId = function () {
         return this.sessionId;
     };
-    /**
-     * Get configuration
-     */
     Metrone.prototype.getConfig = function () {
         return __assign({}, this.config);
     };
     return Metrone;
 }());
-// Global initialization function
+var globalAnalytics = null;
 function initAnalytics(config) {
-    return new Metrone(config);
+    globalAnalytics = new Metrone(config);
+    return globalAnalytics;
 }
-// Global instance for backward compatibility
-var globalAnalytics = null;
 function getAnalytics() {
     return globalAnalytics;
 }
-// Auto-initialize if config is provided via window
 if (typeof window !== 'undefined') {
     var config = window.MetroneConfig;
     if (config) {
         globalAnalytics = new Metrone(config);
     }
 }
-// Export for global usage
 if (typeof window !== 'undefined') {
     window.Metrone = Metrone;
     window.initAnalytics = initAnalytics;
@@ -718,7 +719,7 @@ if (typeof window !== 'undefined') {
  */
 // Core SDK
 // Version
-var VERSION = '1.0.1';
+var VERSION = '1.1.0';
 
 export { Metrone, VERSION, Metrone as default, getAnalytics, initAnalytics };
 //# sourceMappingURL=index.esm.js.map