@blotoutio/edgetag-sdk-browser 0.6.4 → 0.6.6

package/index.js

@@ -1,6 +1,18 @@
 (function () {
     'use strict';
 
+    var api$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        get init () { return init; },
+        get tag () { return tag; },
+        get consent () { return consent; },
+        get user () { return user; },
+        get data () { return data; },
+        get getData () { return getData; },
+        get keys () { return keys; },
+        get getUserId () { return getUserId; }
+    });
+
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -101,24 +113,56 @@
         saveData('session', currentSession);
     };
     const saveLocal = (value, key) => {
-        localStorage.setItem(key, JSON.stringify(value));
+        try {
+            if (!localStorage) {
+                return;
+            }
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (_a) {
+            console.log('Local storage not supported');
+        }
     };
     const getLocal = (key) => {
-        const data = localStorage.getItem(key);
-        if (!data) {
+        try {
+            if (!localStorage) {
+                return {};
+            }
+            const data = localStorage.getItem(key);
+            if (!data) {
+                return {};
+            }
+            return JSON.parse(data) || {};
+        }
+        catch (_a) {
             return {};
         }
-        return JSON.parse(data) || {};
     };
     const saveSession = (value, key) => {
-        sessionStorage.setItem(key, JSON.stringify(value));
+        try {
+            if (!sessionStorage) {
+                return;
+            }
+            sessionStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (_a) {
+            console.log('Session storage not supported');
+        }
     };
     const getSession = (key) => {
-        const data = sessionStorage.getItem(key);
-        if (!data) {
+        try {
+            if (!sessionStorage) {
+                return {};
+            }
+            const data = sessionStorage.getItem(key);
+            if (!data) {
+                return {};
+            }
+            return JSON.parse(data) || {};
+        }
+        catch (_a) {
             return {};
         }
-        return JSON.parse(data) || {};
     };
 
     let endpointUrl = '';
@@ -161,6 +205,7 @@
         return generateUrl(`/keys`);
     };
 
+    let initialized = false;
     let consentDisabled = false;
     const providers = {};
     const setPreferences = (preferences) => {
@@ -192,6 +237,10 @@
     };
     const isConsentDisabled = () => consentDisabled;
     const getProvidersPackage = () => providers;
+    const isInitialized = () => initialized;
+    const setInitialized = () => {
+        initialized = true;
+    };
 
     const getUserAgent = () => {
         const nav = navigator;
@@ -336,14 +385,13 @@
     // Unique ID creation requires a high quality random # generator. In the browser we therefore
     // require the crypto API and do not support built-in fallback to lower quality random number
     // generators (like Math.random()).
-    var getRandomValues;
-    var rnds8 = new Uint8Array(16);
+    let getRandomValues;
+    const rnds8 = new Uint8Array(16);
     function rng() {
       // lazy load so that environments that need to polyfill have a chance to do so
       if (!getRandomValues) {
-        // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
-        // find the complete implementation of crypto (msCrypto) on IE11.
-        getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+        // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+        getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
 
         if (!getRandomValues) {
           throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
@@ -364,27 +412,16 @@
      * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
      */
 
-    var byteToHex = [];
+    const byteToHex = [];
 
-    for (var i = 0; i < 256; ++i) {
-      byteToHex.push((i + 0x100).toString(16).substr(1));
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 0x100).toString(16).slice(1));
     }
 
-    function stringify(arr) {
-      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    function unsafeStringify(arr, offset = 0) {
       // Note: Be careful editing this code!  It's been tuned for performance
       // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-      var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
-      // of the following:
-      // - One or more input array values don't map to a hex octet (leading to
-      // "undefined" in the uuid)
-      // - Invalid input values for the RFC `version` or `variant` fields
-
-      if (!validate(uuid)) {
-        throw TypeError('Stringified UUID is invalid');
-      }
-
-      return uuid;
+      return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
     }
 
     function parse(uuid) {
@@ -392,8 +429,8 @@
         throw TypeError('Invalid UUID');
       }
 
-      var v;
-      var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+      let v;
+      const arr = new Uint8Array(16); // Parse ########-....-....-....-............
 
       arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
       arr[1] = v >>> 16 & 0xff;
@@ -422,19 +459,21 @@
     function stringToBytes(str) {
       str = unescape(encodeURIComponent(str)); // UTF8 escape
 
-      var bytes = [];
+      const bytes = [];
 
-      for (var i = 0; i < str.length; ++i) {
+      for (let i = 0; i < str.length; ++i) {
         bytes.push(str.charCodeAt(i));
       }
 
       return bytes;
     }
 
-    var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-    var URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
-    function v35 (name, version, hashfunc) {
+    const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    const URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+    function v35(name, version, hashfunc) {
       function generateUUID(value, namespace, buf, offset) {
+        var _namespace;
+
         if (typeof value === 'string') {
           value = stringToBytes(value);
         }
@@ -443,14 +482,14 @@
           namespace = parse(namespace);
         }
 
-        if (namespace.length !== 16) {
+        if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
           throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
         } // Compute hash of namespace and value, Per 4.3
         // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
         // hashfunc([...namespace, ... value])`
 
 
-        var bytes = new Uint8Array(16 + value.length);
+        let bytes = new Uint8Array(16 + value.length);
         bytes.set(namespace);
         bytes.set(value, namespace.length);
         bytes = hashfunc(bytes);
@@ -460,14 +499,14 @@
         if (buf) {
           offset = offset || 0;
 
-          for (var i = 0; i < 16; ++i) {
+          for (let i = 0; i < 16; ++i) {
             buf[offset + i] = bytes[i];
           }
 
           return buf;
         }
 
-        return stringify(bytes);
+        return unsafeStringify(bytes);
       } // Function#name is not settable on some platforms (#270)
 
 
@@ -503,11 +542,11 @@
      */
     function md5(bytes) {
       if (typeof bytes === 'string') {
-        var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+        const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
 
         bytes = new Uint8Array(msg.length);
 
-        for (var i = 0; i < msg.length; ++i) {
+        for (let i = 0; i < msg.length; ++i) {
           bytes[i] = msg.charCodeAt(i);
         }
       }
@@ -520,13 +559,13 @@
 
 
     function md5ToHexEncodedArray(input) {
-      var output = [];
-      var length32 = input.length * 32;
-      var hexTab = '0123456789abcdef';
+      const output = [];
+      const length32 = input.length * 32;
+      const hexTab = '0123456789abcdef';
 
-      for (var i = 0; i < length32; i += 8) {
-        var x = input[i >> 5] >>> i % 32 & 0xff;
-        var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+      for (let i = 0; i < length32; i += 8) {
+        const x = input[i >> 5] >>> i % 32 & 0xff;
+        const hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
         output.push(hex);
       }
 
@@ -549,16 +588,16 @@
       /* append padding */
       x[len >> 5] |= 0x80 << len % 32;
       x[getOutputLength(len) - 1] = len;
-      var a = 1732584193;
-      var b = -271733879;
-      var c = -1732584194;
-      var d = 271733878;
-
-      for (var i = 0; i < x.length; i += 16) {
-        var olda = a;
-        var oldb = b;
-        var oldc = c;
-        var oldd = d;
+      let a = 1732584193;
+      let b = -271733879;
+      let c = -1732584194;
+      let d = 271733878;
+
+      for (let i = 0; i < x.length; i += 16) {
+        const olda = a;
+        const oldb = b;
+        const oldc = c;
+        const oldd = d;
         a = md5ff(a, b, c, d, x[i], 7, -680876936);
         d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
         c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
@@ -642,10 +681,10 @@
         return [];
       }
 
-      var length8 = input.length * 8;
-      var output = new Uint32Array(getOutputLength(length8));
+      const length8 = input.length * 8;
+      const output = new Uint32Array(getOutputLength(length8));
 
-      for (var i = 0; i < length8; i += 8) {
+      for (let i = 0; i < length8; i += 8) {
         output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
       }
 
@@ -658,8 +697,8 @@
 
 
     function safeAdd(x, y) {
-      var lsw = (x & 0xffff) + (y & 0xffff);
-      var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+      const lsw = (x & 0xffff) + (y & 0xffff);
+      const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
       return msw << 16 | lsw & 0xffff;
     }
     /*
@@ -697,9 +736,18 @@
 
     v35('v3', 0x30, md5);
 
+    const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+    var native = {
+      randomUUID
+    };
+
     function v4(options, buf, offset) {
+      if (native.randomUUID && !buf && !options) {
+        return native.randomUUID();
+      }
+
       options = options || {};
-      var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+      const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
 
       rnds[6] = rnds[6] & 0x0f | 0x40;
       rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
@@ -707,14 +755,14 @@
       if (buf) {
         offset = offset || 0;
 
-        for (var i = 0; i < 16; ++i) {
+        for (let i = 0; i < 16; ++i) {
           buf[offset + i] = rnds[i];
         }
 
         return buf;
       }
 
-      return stringify(rnds);
+      return unsafeStringify(rnds);
     }
 
     // Adapted from Chris Veness' SHA1 code at
@@ -740,15 +788,15 @@
     }
 
     function sha1(bytes) {
-      var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
-      var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+      const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+      const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
 
       if (typeof bytes === 'string') {
-        var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+        const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
 
         bytes = [];
 
-        for (var i = 0; i < msg.length; ++i) {
+        for (let i = 0; i < msg.length; ++i) {
           bytes.push(msg.charCodeAt(i));
         }
       } else if (!Array.isArray(bytes)) {
@@ -757,44 +805,44 @@
       }
 
       bytes.push(0x80);
-      var l = bytes.length / 4 + 2;
-      var N = Math.ceil(l / 16);
-      var M = new Array(N);
+      const l = bytes.length / 4 + 2;
+      const N = Math.ceil(l / 16);
+      const M = new Array(N);
 
-      for (var _i = 0; _i < N; ++_i) {
-        var arr = new Uint32Array(16);
+      for (let i = 0; i < N; ++i) {
+        const arr = new Uint32Array(16);
 
-        for (var j = 0; j < 16; ++j) {
-          arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
+        for (let j = 0; j < 16; ++j) {
+          arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
         }
 
-        M[_i] = arr;
+        M[i] = arr;
       }
 
       M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
       M[N - 1][14] = Math.floor(M[N - 1][14]);
       M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
 
-      for (var _i2 = 0; _i2 < N; ++_i2) {
-        var W = new Uint32Array(80);
+      for (let i = 0; i < N; ++i) {
+        const W = new Uint32Array(80);
 
-        for (var t = 0; t < 16; ++t) {
-          W[t] = M[_i2][t];
+        for (let t = 0; t < 16; ++t) {
+          W[t] = M[i][t];
         }
 
-        for (var _t = 16; _t < 80; ++_t) {
-          W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
+        for (let t = 16; t < 80; ++t) {
+          W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
         }
 
-        var a = H[0];
-        var b = H[1];
-        var c = H[2];
-        var d = H[3];
-        var e = H[4];
+        let a = H[0];
+        let b = H[1];
+        let c = H[2];
+        let d = H[3];
+        let e = H[4];
 
-        for (var _t2 = 0; _t2 < 80; ++_t2) {
-          var s = Math.floor(_t2 / 20);
-          var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
+        for (let t = 0; t < 80; ++t) {
+          const s = Math.floor(t / 20);
+          const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
           e = d;
           d = c;
           c = ROTL(b, 30) >>> 0;
@@ -836,6 +884,24 @@
     };
     const getProviderVariables = (name) => manifestVariables[name] || {};
 
+    let stubs = [];
+    const addStubs = (newStubs) => {
+        stubs = [...stubs, ...newStubs];
+    };
+    const addStub = (stub) => {
+        stubs.push(stub);
+    };
+    const processStubs = () => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            stubs.forEach((stub) => api$1[stub.name](...(stub.arguments || [])));
+        }
+        catch (e) {
+            console.error(e);
+        }
+    };
+
     const sendTag = ({ eventName, eventId, data, providerData, providers, options, }) => {
         const payload = {
             eventName,
@@ -850,6 +916,13 @@
         postRequest(getTagURL(), payload, options).catch(info);
     };
     const handleTag = (eventName, data = {}, providers, options) => {
+        if (!isInitialized()) {
+            addStub({
+                name: 'tag',
+                arguments: [eventName, data, providers, options],
+            });
+            return;
+        }
         if (!allowTag(providers)) {
             console.log('No consent');
             return;
@@ -863,21 +936,19 @@
         const providerData = {};
         if (providerPackages) {
             Object.values(providerPackages).forEach((pkg) => {
-                if (!allowProvider(providers, pkg.name)) {
+                if (!pkg || !pkg.tag || !allowProvider(providers, pkg.name)) {
                     return;
                 }
-                if (pkg && pkg.tag) {
-                    const result = pkg.tag({
-                        userId,
-                        eventName,
-                        eventId,
-                        data,
-                        sendTag,
-                        manifestVariables: getProviderVariables(pkg.name),
-                    });
-                    if (result) {
-                        providerData[pkg.name] = result;
-                    }
+                const result = pkg.tag({
+                    userId,
+                    eventName,
+                    eventId,
+                    data,
+                    sendTag,
+                    manifestVariables: getProviderVariables(pkg.name),
+                });
+                if (result) {
+                    providerData[pkg.name] = result;
                 }
             });
         }
@@ -891,6 +962,30 @@
         });
     };
 
+    const handleData = (data, options) => {
+        if (!data || Object.keys(data).length === 0) {
+            console.error('Provide data for data API.');
+            return;
+        }
+        saveKV(data);
+        postRequest(getDataURL(), { data }, options).catch(info);
+    };
+
+    const saveDataToEdge = (key, value, provider) => {
+        if (!value) {
+            return;
+        }
+        if (typeof value !== 'string') {
+            try {
+                value = JSON.stringify(value);
+            }
+            catch (_a) {
+                console.log('Error stringify value');
+                return;
+            }
+        }
+        handleData({ [`${provider}::${key}`]: value });
+    };
     const handleCaptureQuery = (provider, key, persistType) => {
         if (!window) {
             return;
@@ -899,7 +994,15 @@
         if (!params || !params.get(key)) {
             return;
         }
-        saveDataPerKey(persistType, provider, params.get(key), key);
+        const data = params.get(key);
+        if (!data) {
+            return;
+        }
+        if (persistType === 'edge') {
+            saveDataToEdge(key, data, provider);
+            return;
+        }
+        saveDataPerKey(persistType, provider, data, key);
     };
     const handleCaptureStorage = (provider, key, persistType, location) => {
         let data;
@@ -909,17 +1012,20 @@
                 break;
             }
             case 'local': {
-                data = sessionStorage && sessionStorage.getItem(key);
+                data = getData$1('local', key);
                 break;
             }
             case 'session': {
-                data = localStorage && localStorage.getItem(key);
-                break;
+                data = getData$1('session', key);
             }
         }
         if (!data) {
             return;
         }
+        if (persistType === 'edge') {
+            saveDataToEdge(key, data, provider);
+            return;
+        }
         saveDataPerKey(persistType, provider, data, key);
     };
     const handleCapture = (provider, params) => {
@@ -961,6 +1067,8 @@
                 }
             }
         });
+        setInitialized();
+        processStubs();
         savePerKey('local', tagStorage, providers, providersKey);
     };
 
@@ -969,6 +1077,9 @@
         if (!success) {
             return;
         }
+        if (preferences.afterManifestEvents) {
+            addStubs(preferences.afterManifestEvents);
+        }
         const url = new URL(getInitURL());
         if (preferences.disableConsentCheck) {
             url.searchParams.set('consentDisabled', 'true');
@@ -1002,15 +1113,6 @@
         }, options).catch(info);
     };
 
-    const handleData = (data, options) => {
-        if (!data || Object.keys(data).length === 0) {
-            console.error('Provide data for data API.');
-            return;
-        }
-        saveKV(data);
-        postRequest(getDataURL(), { data }, options).catch(info);
-    };
-
     const handleGetData = (keys, callback) => {
         if (!keys || keys.length === 0) {
             console.error('Provide keys for get data API.');
@@ -1052,6 +1154,9 @@
     const keys = (callback) => {
         handleKeys(callback);
     };
+    const getUserId = () => {
+        return handleGetUserId();
+    };
 
     // TODO https://github.com/blotoutio/solutions/issues/826
 
@@ -1088,16 +1193,9 @@
     var api = new API();
 
     (function () {
-      const handleFunction = (arg) => {
-        const sliced = [].slice.call(arg);
-        if (!Array.isArray(sliced)) {
-          return
-        }
-
+      const handleStubs = (event) => {
         try {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          return library[sliced[0]](...sliced.slice(1))
+          return library[event.name](...event.arguments)
         } catch (e) {
           console.error(e);
         }
@@ -1106,19 +1204,61 @@
       const library = api;
       let stubs = [];
       if (window.edgetag) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
         stubs = window.edgetag.stubs || [];
       }
 
       // this needs to be regular function for arguments to work
       window.edgetag = function () {
-        // eslint-disable-next-line prefer-rest-params
-        return handleFunction(arguments)
+        const sliced = [].slice.call(arguments);
+        if (!Array.isArray(sliced)) {
+          return
+        }
+
+        try {
+          return library[sliced[0]](...sliced.slice(1))
+        } catch (e) {
+          console.error(e);
+        }
       };
 
-      // restore calls that were triggered before lib was ready
-      stubs.forEach(handleFunction);
+      const beforeManifestEvents = [];
+      const afterManifestEvents = [];
+      let initCall = null;
+
+      stubs.forEach((arg) => {
+        const sliced = [].slice.call(arg);
+        if (!Array.isArray(sliced)) {
+          return
+        }
+
+        if (sliced[0] === 'init') {
+          initCall = sliced.slice(1);
+          return
+        }
+
+        if (sliced[0] === 'tag') {
+          afterManifestEvents.push({
+            name: sliced[0],
+            arguments: sliced.slice(1),
+          });
+          return
+        }
+
+        beforeManifestEvents.push({
+          name: sliced[0],
+          arguments: sliced.slice(1),
+        });
+      });
+
+      if (initCall) {
+        initCall[0]['afterManifestEvents'] = afterManifestEvents;
+        handleStubs({
+          name: 'init',
+          arguments: initCall,
+        });
+      }
+
+      beforeManifestEvents.forEach(handleStubs);
     })();
 
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/edgetag-sdk-browser",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Browser SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",