@blotoutio/edgetag-sdk-browser 0.6.0 → 0.6.1

package/index.js

@@ -0,0 +1,1116 @@
+(function () {
+    'use strict';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    const tagStorage = 'edgeTag';
+    const consentKey = 'consent';
+    const providersKey = 'providers';
+    const keyPrefix = `_worker`;
+
+    const initKey = `${keyPrefix}Store`;
+    const getCookieValue = (key) => {
+        if (!document || !document.cookie) {
+            return '';
+        }
+        const name = `${key}=`;
+        const decodedCookie = decodeURIComponent(document.cookie);
+        const ca = decodedCookie.split(';');
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) === ' ') {
+                c = c.substring(1);
+            }
+            if (c.indexOf(name) === 0) {
+                return c.substring(name.length, c.length);
+            }
+        }
+        return '';
+    };
+    const saveDataPerKey = (persistType, provider, value, key) => {
+        const storage = getData$1(persistType);
+        if (!storage['data']) {
+            storage['data'] = {};
+        }
+        if (!storage['data'][provider]) {
+            storage['data'][provider] = {};
+        }
+        storage['data'][provider][key] = value;
+        saveData(persistType, storage);
+    };
+    const savePerKey = (persistType, provider, value, key) => {
+        const storage = getData$1(persistType);
+        if (!storage[provider]) {
+            storage[provider] = {};
+        }
+        storage[provider][key] = value;
+        saveData(persistType, storage);
+    };
+    const getDataPerKey = (persistType, provider, key) => {
+        const storage = getData$1(persistType);
+        if (!storage[provider]) {
+            return undefined;
+        }
+        return storage[provider][key];
+    };
+    const saveData = (persistType, value, key = initKey) => {
+        if (persistType === 'session') {
+            saveSession(value, key);
+            return;
+        }
+        saveLocal(value, key);
+    };
+    const getData$1 = (persistType, key = initKey) => {
+        if (persistType === 'session') {
+            return getSession(key);
+        }
+        return getLocal(key);
+    };
+    const saveKV = (data) => {
+        let currentSession = getData$1('session');
+        if (!currentSession) {
+            currentSession = {};
+        }
+        if (!currentSession['kv']) {
+            currentSession['kv'] = {};
+        }
+        currentSession['kv'] = Object.assign(Object.assign({}, currentSession['kv']), data);
+        saveData('session', currentSession);
+    };
+    const saveLocal = (value, key) => {
+        localStorage.setItem(key, JSON.stringify(value));
+    };
+    const getLocal = (key) => {
+        const data = localStorage.getItem(key);
+        if (!data) {
+            return {};
+        }
+        return JSON.parse(data) || {};
+    };
+    const saveSession = (value, key) => {
+        sessionStorage.setItem(key, JSON.stringify(value));
+    };
+    const getSession = (key) => {
+        const data = sessionStorage.getItem(key);
+        if (!data) {
+            return {};
+        }
+        return JSON.parse(data) || {};
+    };
+
+    let endpointUrl = '';
+    const generateUrl = (path) => {
+        const endpoint = getUrl();
+        if (!endpoint) {
+            console.log('URL is not valid');
+            return '';
+        }
+        return `${endpoint}${path}`;
+    };
+    const getUrl = () => {
+        return endpointUrl;
+    };
+    const setUrl = (url) => {
+        if (url == null) {
+            return;
+        }
+        endpointUrl = url;
+    };
+    const getTagURL = () => {
+        return generateUrl('/tag');
+    };
+    const getInitURL = () => {
+        return generateUrl('/init');
+    };
+    const getConsentURL = () => {
+        return generateUrl('/consent');
+    };
+    const getUserURL = () => {
+        return generateUrl('/user');
+    };
+    const getDataURL = () => {
+        return generateUrl(`/data`);
+    };
+    const getGetDataURL = (keys) => {
+        return generateUrl(`/data?keys=${encodeURIComponent(keys.join(','))}`);
+    };
+    const getKeysURL = () => {
+        return generateUrl(`/keys`);
+    };
+
+    let consentDisabled = false;
+    let providers = [];
+    const setPreferences = (preferences) => {
+        if (!preferences) {
+            return false;
+        }
+        if (!preferences.edgeURL) {
+            console.error('Please provide URL for EdgeTag');
+            return false;
+        }
+        consentDisabled = !!preferences.disableConsentCheck;
+        providers = preferences.providers || [];
+        if (window && window.edgetagPackages) {
+            providers = [...window.edgetagPackages, ...providers];
+        }
+        setUrl(preferences.edgeURL);
+        return true;
+    };
+    const isConsentDisabled = () => consentDisabled;
+    const getProvidersPackage = () => providers;
+
+    const getUserAgent = () => {
+        const nav = navigator;
+        let ua = nav.userAgent;
+        ua += nav.brave ? `${ua} Brave` : '';
+        return ua;
+    };
+    const allowTag = (providers) => {
+        const consent = getDataPerKey('local', tagStorage, consentKey);
+        if (isConsentDisabled()) {
+            return true;
+        }
+        if (!consent) {
+            return false;
+        }
+        if (consent['all']) {
+            return true;
+        }
+        if (!providers) {
+            return (Object.values(consent).find((isAllowed) => isAllowed) || false);
+        }
+        const allProviders = (getDataPerKey('local', tagStorage, providersKey) ||
+            []);
+        for (const provider of allProviders) {
+            const tagProviderSetting = providers[provider];
+            if (tagProviderSetting ||
+                (providers['all'] === true && tagProviderSetting === undefined) ||
+                (providers['all'] === false && tagProviderSetting === true)) {
+                if (consent[provider]) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    const allowProvider = (providers, providerId) => {
+        const consent = getDataPerKey('local', tagStorage, consentKey);
+        if (isConsentDisabled()) {
+            return true;
+        }
+        if (!consent) {
+            return false;
+        }
+        if (consent['all']) {
+            return true;
+        }
+        if (!providers) {
+            return consent[providerId];
+        }
+        const tagProvider = providers[providerId];
+        if (tagProvider ||
+            (providers['all'] === true && tagProvider === undefined) ||
+            (providers['all'] === false && tagProvider === true)) {
+            if (consent[providerId]) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    const beacon = (url, payload) => {
+        let blob;
+        if (payload) {
+            blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+        }
+        return navigator.sendBeacon(url, blob);
+    };
+    const ajax = (method, url, payload) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield fetch(url, {
+            method,
+            headers: {
+                'Content-type': 'application/json; charset=utf-8',
+                Accept: 'application/json; charset=utf-8',
+            },
+            body: JSON.stringify(payload),
+            credentials: 'include',
+        })
+            .then((response) => response.json().then((data) => ({ status: response.status, body: data })))
+            .then((data) => {
+            if (data.status < 200 || data.status >= 300) {
+                // Q: do we need to retry?
+                return Promise.reject(new Error(JSON.stringify(data.body)));
+            }
+            return Promise.resolve(data.body);
+        })
+            .catch((error) => {
+            // Q: do we need to retry?
+            return Promise.reject(new Error(error));
+        });
+    });
+    const getStandardPayload = (payload) => {
+        const data = Object.assign({ pageUrl: window.location.href, userAgent: getUserAgent() }, (payload || {}));
+        let storage = {};
+        const session = getData$1('session');
+        if (session) {
+            storage = Object.assign(Object.assign({}, storage), session);
+        }
+        const local = getData$1('local');
+        if (local) {
+            storage = Object.assign(Object.assign({}, storage), local);
+        }
+        data.storage = storage;
+        return data;
+    };
+    function postRequest(url, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!url) {
+                return Promise.reject(new Error('URL is empty'));
+            }
+            const payload = getStandardPayload(data);
+            if (options && options.method === 'beacon') {
+                return Promise.resolve(beacon(url, payload));
+            }
+            return yield ajax('POST', url, payload);
+        });
+    }
+    function getRequest(url, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!url) {
+                return Promise.reject(new Error('URL is empty'));
+            }
+            if (options && options.method === 'beacon') {
+                return {
+                    result: Promise.resolve(beacon(url)),
+                };
+            }
+            return yield ajax('GET', url);
+        });
+    }
+
+    const info = (data) => {
+    };
+
+    const saveConsent = (consent) => {
+        savePerKey('local', tagStorage, consent, consentKey);
+    };
+    const handleConsent = (consent) => {
+        const payload = {
+            consentString: consent,
+        };
+        saveConsent(consent);
+        postRequest(getConsentURL(), payload).catch(info);
+    };
+
+    // 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);
+    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);
+
+        if (!getRandomValues) {
+          throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+      }
+
+      return getRandomValues(rnds8);
+    }
+
+    var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+    function validate(uuid) {
+      return typeof uuid === 'string' && REGEX.test(uuid);
+    }
+
+    /**
+     * Convert array of 16 byte values to UUID string format of the form:
+     * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+     */
+
+    var byteToHex = [];
+
+    for (var i = 0; i < 256; ++i) {
+      byteToHex.push((i + 0x100).toString(16).substr(1));
+    }
+
+    function stringify(arr) {
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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;
+    }
+
+    function parse(uuid) {
+      if (!validate(uuid)) {
+        throw TypeError('Invalid UUID');
+      }
+
+      var v;
+      var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+      arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+      arr[1] = v >>> 16 & 0xff;
+      arr[2] = v >>> 8 & 0xff;
+      arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+      arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+      arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+      arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+      arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+      arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+      arr[9] = v & 0xff; // Parse ........-....-....-....-############
+      // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+      arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+      arr[11] = v / 0x100000000 & 0xff;
+      arr[12] = v >>> 24 & 0xff;
+      arr[13] = v >>> 16 & 0xff;
+      arr[14] = v >>> 8 & 0xff;
+      arr[15] = v & 0xff;
+      return arr;
+    }
+
+    function stringToBytes(str) {
+      str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+      var bytes = [];
+
+      for (var 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) {
+      function generateUUID(value, namespace, buf, offset) {
+        if (typeof value === 'string') {
+          value = stringToBytes(value);
+        }
+
+        if (typeof namespace === 'string') {
+          namespace = parse(namespace);
+        }
+
+        if (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);
+        bytes.set(namespace);
+        bytes.set(value, namespace.length);
+        bytes = hashfunc(bytes);
+        bytes[6] = bytes[6] & 0x0f | version;
+        bytes[8] = bytes[8] & 0x3f | 0x80;
+
+        if (buf) {
+          offset = offset || 0;
+
+          for (var i = 0; i < 16; ++i) {
+            buf[offset + i] = bytes[i];
+          }
+
+          return buf;
+        }
+
+        return stringify(bytes);
+      } // Function#name is not settable on some platforms (#270)
+
+
+      try {
+        generateUUID.name = name; // eslint-disable-next-line no-empty
+      } catch (err) {} // For CommonJS default export support
+
+
+      generateUUID.DNS = DNS;
+      generateUUID.URL = URL$1;
+      return generateUUID;
+    }
+
+    /*
+     * Browser-compatible JavaScript MD5
+     *
+     * Modification of JavaScript MD5
+     * https://github.com/blueimp/JavaScript-MD5
+     *
+     * Copyright 2011, Sebastian Tschan
+     * https://blueimp.net
+     *
+     * Licensed under the MIT license:
+     * https://opensource.org/licenses/MIT
+     *
+     * Based on
+     * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+     * Digest Algorithm, as defined in RFC 1321.
+     * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+     * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+     * Distributed under the BSD License
+     * See http://pajhome.org.uk/crypt/md5 for more info.
+     */
+    function md5(bytes) {
+      if (typeof bytes === 'string') {
+        var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+        bytes = new Uint8Array(msg.length);
+
+        for (var i = 0; i < msg.length; ++i) {
+          bytes[i] = msg.charCodeAt(i);
+        }
+      }
+
+      return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+    }
+    /*
+     * Convert an array of little-endian words to an array of bytes
+     */
+
+
+    function md5ToHexEncodedArray(input) {
+      var output = [];
+      var length32 = input.length * 32;
+      var 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);
+        output.push(hex);
+      }
+
+      return output;
+    }
+    /**
+     * Calculate output length with padding and bit length
+     */
+
+
+    function getOutputLength(inputLength8) {
+      return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+    }
+    /*
+     * Calculate the MD5 of an array of little-endian words, and a bit length.
+     */
+
+
+    function wordsToMd5(x, len) {
+      /* 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;
+        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);
+        b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+        a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+        d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+        c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+        b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+        a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+        d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+        c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+        b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+        a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+        d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+        c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+        b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+        a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+        d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+        c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+        b = md5gg(b, c, d, a, x[i], 20, -373897302);
+        a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+        d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+        c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+        b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+        a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+        d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+        c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+        b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+        a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+        d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+        c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+        b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+        a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+        d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+        c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+        b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+        a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+        d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+        c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+        b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+        a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+        d = md5hh(d, a, b, c, x[i], 11, -358537222);
+        c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+        b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+        a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+        d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+        c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+        b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+        a = md5ii(a, b, c, d, x[i], 6, -198630844);
+        d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+        c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+        b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+        a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+        d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+        c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+        b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+        a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+        d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+        c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+        b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+        a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+        d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+        c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+        b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+        a = safeAdd(a, olda);
+        b = safeAdd(b, oldb);
+        c = safeAdd(c, oldc);
+        d = safeAdd(d, oldd);
+      }
+
+      return [a, b, c, d];
+    }
+    /*
+     * Convert an array bytes to an array of little-endian words
+     * Characters >255 have their high-byte silently ignored.
+     */
+
+
+    function bytesToWords(input) {
+      if (input.length === 0) {
+        return [];
+      }
+
+      var length8 = input.length * 8;
+      var output = new Uint32Array(getOutputLength(length8));
+
+      for (var i = 0; i < length8; i += 8) {
+        output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
+      }
+
+      return output;
+    }
+    /*
+     * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+     * to work around bugs in some JS interpreters.
+     */
+
+
+    function safeAdd(x, y) {
+      var lsw = (x & 0xffff) + (y & 0xffff);
+      var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+      return msw << 16 | lsw & 0xffff;
+    }
+    /*
+     * Bitwise rotate a 32-bit number to the left.
+     */
+
+
+    function bitRotateLeft(num, cnt) {
+      return num << cnt | num >>> 32 - cnt;
+    }
+    /*
+     * These functions implement the four basic operations the algorithm uses.
+     */
+
+
+    function md5cmn(q, a, b, x, s, t) {
+      return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+    }
+
+    function md5ff(a, b, c, d, x, s, t) {
+      return md5cmn(b & c | ~b & d, a, b, x, s, t);
+    }
+
+    function md5gg(a, b, c, d, x, s, t) {
+      return md5cmn(b & d | c & ~d, a, b, x, s, t);
+    }
+
+    function md5hh(a, b, c, d, x, s, t) {
+      return md5cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+
+    function md5ii(a, b, c, d, x, s, t) {
+      return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+
+    v35('v3', 0x30, md5);
+
+    function v4(options, buf, offset) {
+      options = options || {};
+      var 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
+
+      if (buf) {
+        offset = offset || 0;
+
+        for (var i = 0; i < 16; ++i) {
+          buf[offset + i] = rnds[i];
+        }
+
+        return buf;
+      }
+
+      return stringify(rnds);
+    }
+
+    // Adapted from Chris Veness' SHA1 code at
+    // http://www.movable-type.co.uk/scripts/sha1.html
+    function f(s, x, y, z) {
+      switch (s) {
+        case 0:
+          return x & y ^ ~x & z;
+
+        case 1:
+          return x ^ y ^ z;
+
+        case 2:
+          return x & y ^ x & z ^ y & z;
+
+        case 3:
+          return x ^ y ^ z;
+      }
+    }
+
+    function ROTL(x, n) {
+      return x << n | x >>> 32 - n;
+    }
+
+    function sha1(bytes) {
+      var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+      var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+      if (typeof bytes === 'string') {
+        var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+        bytes = [];
+
+        for (var i = 0; i < msg.length; ++i) {
+          bytes.push(msg.charCodeAt(i));
+        }
+      } else if (!Array.isArray(bytes)) {
+        // Convert Array-like to Array
+        bytes = Array.prototype.slice.call(bytes);
+      }
+
+      bytes.push(0x80);
+      var l = bytes.length / 4 + 2;
+      var N = Math.ceil(l / 16);
+      var M = new Array(N);
+
+      for (var _i = 0; _i < N; ++_i) {
+        var 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];
+        }
+
+        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 (var t = 0; t < 16; ++t) {
+          W[t] = M[_i2][t];
+        }
+
+        for (var _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];
+
+        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;
+          e = d;
+          d = c;
+          c = ROTL(b, 30) >>> 0;
+          b = a;
+          a = T;
+        }
+
+        H[0] = H[0] + a >>> 0;
+        H[1] = H[1] + b >>> 0;
+        H[2] = H[2] + c >>> 0;
+        H[3] = H[3] + d >>> 0;
+        H[4] = H[4] + e >>> 0;
+      }
+
+      return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+    }
+
+    v35('v5', 0x50, sha1);
+
+    const generateEventId = (name) => {
+        let time = Date.now().toString();
+        if (typeof performance !== 'undefined' &&
+            typeof performance.now === 'function') {
+            const perf = performance.now();
+            if (perf) {
+                time = perf.toFixed(4);
+            }
+        }
+        return `${btoa(name)}-${v4()}-${time}`;
+    };
+
+    const handleGetUserId = () => {
+        return getCookieValue('tag_user_id');
+    };
+
+    const manifestVariables = {};
+    const addProviderVariable = (name, variables) => {
+        manifestVariables[name] = variables;
+    };
+    const getProviderVariables = (name) => manifestVariables[name] || {};
+
+    const sendTag = ({ eventName, eventId, data, providerData, providers, options, }) => {
+        const payload = {
+            eventName,
+            eventId,
+            timestamp: Date.now(),
+            data,
+            providerData,
+        };
+        if (providers) {
+            payload.providers = providers;
+        }
+        postRequest(getTagURL(), payload, options).catch(info);
+    };
+    const handleTag = (eventName, data = {}, providers, options) => {
+        if (!allowTag(providers)) {
+            console.log('No consent');
+            return;
+        }
+        let eventId = data['eventId'];
+        if (!eventId) {
+            eventId = generateEventId(eventName);
+        }
+        const providerPackages = getProvidersPackage();
+        const userId = handleGetUserId();
+        const providerData = {};
+        if (providerPackages) {
+            providerPackages.forEach((pkg) => {
+                if (!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;
+                    }
+                }
+            });
+        }
+        sendTag({
+            eventName,
+            eventId,
+            data,
+            providerData,
+            providers,
+            options,
+        });
+    };
+
+    const handleCaptureQuery = (provider, key, persistType) => {
+        if (!window) {
+            return;
+        }
+        const params = new URLSearchParams(window.location.search);
+        if (!params || !params.get(key)) {
+            return;
+        }
+        saveDataPerKey(persistType, provider, params.get(key), key);
+    };
+    const handleCaptureStorage = (provider, key, persistType, location) => {
+        let data;
+        switch (location) {
+            case 'cookie': {
+                data = getCookieValue(key);
+                break;
+            }
+            case 'local': {
+                data = sessionStorage && sessionStorage.getItem(key);
+                break;
+            }
+            case 'session': {
+                data = localStorage && localStorage.getItem(key);
+                break;
+            }
+        }
+        if (!data) {
+            return;
+        }
+        saveDataPerKey(persistType, provider, data, key);
+    };
+    const handleCapture = (provider, params) => {
+        params.forEach((param) => {
+            switch (param.type) {
+                case 'query': {
+                    handleCaptureQuery(provider, param.key, param.persist);
+                    break;
+                }
+                case 'storage': {
+                    handleCaptureStorage(provider, param.key, param.persist, param.location);
+                    break;
+                }
+            }
+        });
+    };
+
+    const handleManifest = (manifest) => {
+        const providers = [];
+        const providerPackages = getProvidersPackage();
+        const userId = handleGetUserId();
+        manifest.forEach((provider) => {
+            providers.push(provider.package);
+            addProviderVariable(provider.package, provider.variables);
+            if (provider.rules) {
+                Object.entries(provider.rules).forEach(([name, recipe]) => {
+                    switch (name) {
+                        case 'capture': {
+                            handleCapture(provider.package, recipe);
+                            return;
+                        }
+                    }
+                });
+            }
+            if (providerPackages) {
+                const pkg = providerPackages.find((pkg) => pkg.name === provider.package);
+                if (pkg && pkg.init) {
+                    pkg.init({ userId, manifest: provider, sendTag });
+                }
+            }
+        });
+        savePerKey('local', tagStorage, providers, providersKey);
+    };
+
+    const handleInit = (preferences) => {
+        const success = setPreferences(preferences);
+        if (!success) {
+            return;
+        }
+        const url = new URL(getInitURL());
+        if (preferences.disableConsentCheck) {
+            url.searchParams.set('consentDisabled', 'true');
+            saveConsent({ all: true });
+        }
+        if (preferences.userId) {
+            url.searchParams.set('userId', preferences.userId);
+        }
+        getRequest(url.href)
+            .then((result) => {
+            if (!result) {
+                console.log('init failed');
+                return;
+            }
+            handleManifest(result.result);
+        })
+            .catch(info);
+    };
+
+    const handleUser = (key, value, options) => {
+        if (!key || !value) {
+            console.error('Key or Value is missing in user API.');
+            return;
+        }
+        saveKV({
+            [key]: value,
+        });
+        postRequest(getUserURL(), {
+            key,
+            value,
+        }, 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.');
+            return;
+        }
+        getRequest(getGetDataURL(keys))
+            .then((result) => {
+            callback((result === null || result === void 0 ? void 0 : result.result) || {});
+        })
+            .catch(info);
+    };
+
+    const handleKeys = (callback) => {
+        getRequest(getKeysURL())
+            .then((result) => {
+            callback((result === null || result === void 0 ? void 0 : result.result) || []);
+        })
+            .catch(info);
+    };
+
+    const init = (preferences) => {
+        handleInit(preferences);
+    };
+    const tag = (name, data, providers, options) => {
+        handleTag(name, data, providers, options);
+    };
+    const consent = (consent) => {
+        handleConsent(consent);
+    };
+    const user = (key, value, options) => {
+        handleUser(key, value, options);
+    };
+    const data = (data, options) => {
+        handleData(data, options);
+    };
+    const getData = (keys, callback) => {
+        handleGetData(keys, callback);
+    };
+    const keys = (callback) => {
+        handleKeys(callback);
+    };
+
+    // TODO https://github.com/blotoutio/solutions/issues/826
+
+    class API {
+      init(preferences) {
+        init(preferences);
+      }
+
+      tag(name, data, providers, options) {
+        tag(name, data, providers, options);
+      }
+
+      consent(consentString) {
+        consent(consentString);
+      }
+
+      user(key, value, options) {
+        user(key, value, options);
+      }
+
+      data(data$1, options) {
+        data(data$1, options);
+      }
+
+      getData(keys, callback) {
+        getData(keys, callback);
+      }
+
+      keys(callback) {
+        keys(callback);
+      }
+    }
+
+    var api = new API();
+
+    (function () {
+      const handleFunction = (arg) => {
+        const sliced = [].slice.call(arg);
+        if (!Array.isArray(sliced)) {
+          return
+        }
+
+        try {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          return library[sliced[0]](...sliced.slice(1))
+        } catch (e) {
+          console.error(e);
+        }
+      };
+
+      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)
+      };
+
+      // restore calls that were triggered before lib was ready
+      stubs.forEach(handleFunction);
+    })();
+
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/edgetag-sdk-browser",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Browser SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",
@@ -15,7 +15,6 @@
   },
   "files": [
     "index.js",
-    "index.cjs",
     "package.json",
     "README.md"
   ]