kv-test-ang 1.0.0

package/fesm2015/kv-test-ang.mjs

@@ -0,0 +1,1649 @@
+import * as i0 from '@angular/core';
+import { Injectable, NgModule } from '@angular/core';
+import { __awaiter } from 'tslib';
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+const uuidv4 = () => {
+    return (`${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`).replace(/[018]/g, (c) => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
+};
+// returns the number of milliseconds elapsed since January 1, 1970 
+const getCurrTimeMS = () => Math.floor(Date.now());
+// returns the number of seconds elapsed since January 1, 1970 
+const getCurrTimeSec = () => Math.floor(Date.now() / 1000);
+const formatTime = (num) => {
+    if (num < 10 && num % 10 <= 9)
+        return "0" + num.toFixed(1).toString();
+    else
+        return num.toFixed(1).toString();
+};
+const getMsTime = () => {
+    const date = new Date();
+    return `${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}:${date.getMilliseconds()}`;
+};
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+var Level;
+(function (Level) {
+    Level["Off"] = "Off";
+    Level["Error"] = "Error";
+    Level["Warn"] = "Warn";
+    Level["Info"] = "Info";
+    Level["Debug"] = "Debug";
+    Level["Trace"] = "Trace";
+})(Level || (Level = {}));
+class Logger {
+    constructor() {
+        if (Logger.instance)
+            return;
+        this.levelPrio = {
+            Off: 0,
+            Error: 1,
+            Warn: 2,
+            Info: 3,
+            Debug: 4,
+            Trace: 5,
+        };
+        this.currLevel = Level.Info;
+        this.logObjects = false;
+        this.logsFilteredOut = {
+            Off: false,
+            Error: false,
+            Warn: false,
+            Info: false,
+            Debug: false,
+            Trace: false,
+            Diag: false,
+        };
+        Logger.instance = this;
+    }
+    setLogLevel(input) {
+        const levelStr = input[0].toUpperCase() + input.substring(1).toLowerCase();
+        const key = levelStr;
+        const level = Level[key];
+        if (level !== undefined && level !== null) {
+            this.currLevel = level;
+        }
+        else {
+            console.log(`Invalid logLevel ${level} passed in, defaulting to info.`);
+            this.currLevel = Level.Info;
+        }
+    }
+    getLogLevel() {
+        return this.currLevel.toString();
+    }
+    setLogObjects(enable) {
+        this.logObjects = enable;
+    }
+    disableLogType(input) {
+        const levelStr = input[0].toUpperCase() + input.substring(1).toLowerCase();
+        const key = levelStr;
+        this.logsFilteredOut[key] = true;
+    }
+    error(msg, ...args) {
+        this.print(Level.Error, msg, ...args);
+    }
+    warn(msg, ...args) {
+        this.print(Level.Warn, msg, ...args);
+    }
+    info(msg, ...args) {
+        this.print(Level.Info, msg, ...args);
+    }
+    debug(msg, ...args) {
+        this.print(Level.Debug, msg, ...args);
+    }
+    trace(msg, ...args) {
+        this.print(Level.Trace, msg, ...args);
+    }
+    diagInfo(msg, ...args) {
+        if (!this.logsFilteredOut.Diag)
+            this.print(Level.Info, "Kochava Diagnostic - " + msg, ...args);
+    }
+    diagDebug(msg, ...args) {
+        if (!this.logsFilteredOut.Diag)
+            this.print(Level.Debug, "Kochava Diagnostic - " + msg, ...args);
+    }
+    print(lvl, msg, ...args) {
+        if (this.levelPrio[this.currLevel.toString()] >= this.levelPrio[lvl.toString()] &&
+            !this.logsFilteredOut[lvl.toString()]) {
+            try {
+                const obj = JSON.parse(args[0]);
+                if (this.logObjects && obj) {
+                    console.log(`KVA :: ${getMsTime()} ${lvl.toString()}:`, msg, obj);
+                }
+                else {
+                    console.log(`KVA :: ${getMsTime()} ${lvl.toString()}:`, msg, ...args);
+                }
+            }
+            catch (_a) {
+                console.log(`KVA :: ${getMsTime()} ${lvl.toString()}:`, msg, ...args);
+            }
+        }
+    }
+}
+const Log = new Logger();
+
+const sendRequest = (payload, endpoint) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const headers = new Headers();
+        headers.append("Content-Type", "application/json");
+        Log.trace(`Request ${payload.nt_id} being sent to: `, endpoint);
+        const resp = yield fetch(endpoint, {
+            method: "POST",
+            headers: headers,
+            body: JSON.stringify(payload),
+        });
+        return yield resp.text();
+    }
+    catch (e) {
+        Log.error("Error in post request", e);
+        return "";
+    }
+});
+const wasRespSuccess = (success) => success === "1" || success === 1 || success === true;
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+const getPackageName = () => `com.${window.location.hostname}.web`;
+const getLanguage = () => (navigator) ? navigator.language : "";
+const getDeviceWidth = () => (window) ? window.screen.availWidth : 0;
+const getDeviceHeight = () => (window) ? window.screen.availHeight : 0;
+const getDeviceOrientation = () => (window) ? window.innerWidth < window.innerHeight
+    ? "portrait" : "landscape" : "";
+const getBaseDomain = () => {
+    try {
+        const regexResult = window.location.host.match(/[^.]*\.[^.]*$/);
+        if (regexResult)
+            return regexResult[0];
+        return "";
+    }
+    catch (err) {
+        return window.location.host;
+    }
+};
+const getPageName = () => {
+    let page = "";
+    if (window.location) {
+        page = window.location.pathname.substring(1);
+        page = page.replace(/\/+$/, "");
+    }
+    return page === "" ? "/" : page;
+};
+const getUrlParameter = (name) => {
+    if (!window.location || !window.location.search) {
+        return "";
+    }
+    name = name.replace(/[[]/, "\\[").replace(/[\]]/, "\\]");
+    const regex = new RegExp("[\\?&]" + name + "=([^&#]*)");
+    const results = regex.exec(window.location.search);
+    return results === null
+        ? ""
+        : decodeURIComponent(results[1].replace(/\+/g, " "));
+};
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+const constructPayload = (action, instance, originalNtId) => {
+    let nt_id = `${instance.kochavaSession}-${instance.kochavaSessionCount}-${uuidv4()}`;
+    if (originalNtId) {
+        Log.debug("Persisted call found with nt_id:", originalNtId);
+        nt_id = originalNtId;
+    }
+    return {
+        action: action,
+        kochava_app_id: instance.appGuid,
+        kochava_device_id: instance.kochavaDeviceId,
+        sdk_version: instance.version,
+        sdk_protocol: "17",
+        nt_id: nt_id,
+        init_token: (instance.kochavaConfig.config.init_token) || undefined,
+    };
+};
+const constructCommonData = (instance) => {
+    const currTime = getCurrTimeMS();
+    let uptime = (currTime - instance.startTimeMS) / 1000;
+    if (uptime < 0.0)
+        uptime = 0.0;
+    return {
+        starttime: instance.startTimeMS / 1000,
+        uptime: uptime,
+        usertime: currTime / 1000,
+    };
+};
+
+const constructPreStart$1 = (instance, eventName, eventData) => {
+    const preStart = {
+        action: "event",
+        sdk_version: instance.version,
+        sdk_protocol: "17",
+        data: {
+            event_name: eventName,
+            event_data: eventData,
+            device_orientation: getDeviceOrientation(),
+            disp_w: getDeviceWidth(),
+            disp_h: getDeviceHeight(),
+        },
+    };
+    if (instance.kochavaConfig)
+        preStart.init_token = (instance.kochavaConfig.config.init_token) || undefined;
+    return preStart;
+};
+const constructPostStart$1 = (instance, preStartBody) => {
+    const postStartBody = {
+        kochava_app_id: instance.appGuid,
+        kochava_device_id: instance.kochavaDeviceId,
+        nt_id: `${instance.kochavaSession}-${instance.kochavaSessionCount}-${uuidv4()}`,
+    };
+    postStartBody.data = Object.assign(Object.assign({}, constructCommonData(instance)), preStartBody.data);
+    instance.customValues.forEach((custom) => {
+        if (!custom.isDeviceId) {
+            const customKey = Object.keys(custom.data)[0];
+            if (instance.kochavaConfig.privacy) {
+                let keyAllowed = false;
+                for (const allowed of instance.kochavaConfig.privacy.allow_custom_ids) {
+                    if (customKey === allowed) {
+                        keyAllowed = true;
+                    }
+                }
+                if (keyAllowed)
+                    postStartBody.data = Object.assign(Object.assign({}, custom.data), postStartBody.data);
+            }
+        }
+    });
+    return postStartBody;
+};
+const build$3 = (instance, preStartBody, postStartBody) => {
+    const payload = Object.assign(Object.assign({}, preStartBody), postStartBody);
+    Log.debug("Event Payload", JSON.stringify(payload));
+    if (instance.kochavaConfig.privacy) {
+        instance.kochavaConfig.privacy.deny_datapoints.forEach(denyPoint => {
+            for (const point in payload.data) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload.data[key];
+            }
+            for (const point in payload) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload[key];
+            }
+        });
+    }
+    return payload;
+};
+const send$3 = (instance, preStartBody, postStartBody) => __awaiter(void 0, void 0, void 0, function* () {
+    const payload = build$3(instance, preStartBody, postStartBody);
+    const respStr = yield sendRequest(payload, (instance.overrideUrls.event) ?
+        instance.overrideUrls.event : instance.kochavaConfig.networking.urls.event);
+    let resp;
+    let success = false;
+    try {
+        Log.trace("Event Response string:", respStr);
+        resp = JSON.parse(respStr);
+        Log.debug("Event Response:", respStr);
+        success = wasRespSuccess(resp.success);
+    }
+    catch (e) {
+        Log.error("Error parsing Event Response", e);
+        success = false;
+    }
+    if (success) {
+        Log.info("Event success!");
+        return true;
+    }
+    Log.error("Event failed!");
+    return false;
+});
+
+const constructPreStart = (instance, idLink) => {
+    const preStart = {
+        action: "identityLink",
+        sdk_version: instance.version,
+        sdk_protocol: "17",
+        data: {
+            identity_link: Object.assign({}, idLink),
+        },
+    };
+    if (instance.kochavaConfig)
+        preStart.init_token = (instance.kochavaConfig.config.init_token) || undefined;
+    return preStart;
+};
+const constructPostStart = (instance, preStartBody) => {
+    const postStartBody = {
+        kochava_app_id: instance.appGuid,
+        kochava_device_id: instance.kochavaDeviceId,
+        nt_id: `${instance.kochavaSession}-${instance.kochavaSessionCount}-${uuidv4()}`,
+    };
+    postStartBody.data = Object.assign(Object.assign({}, preStartBody.data), constructCommonData(instance));
+    return postStartBody;
+};
+const build$2 = (instance, job) => {
+    const payload = Object.assign(Object.assign({}, job.preStartBody), job.postStartBody);
+    Log.debug("IdentityLink Payload", JSON.stringify(payload));
+    Log.diagDebug(`IdentityLink to be sent as stand alone`);
+    if (instance.kochavaConfig.privacy) {
+        instance.kochavaConfig.privacy.deny_datapoints.forEach(denyPoint => {
+            for (const point in payload.data) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload.data[key];
+            }
+            for (const point in payload) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload[key];
+            }
+        });
+    }
+    return payload;
+};
+const send$2 = (instance, job) => __awaiter(void 0, void 0, void 0, function* () {
+    const payload = build$2(instance, job);
+    const respStr = yield sendRequest(payload, (instance.overrideUrls.identityLink) ?
+        instance.overrideUrls.identityLink : instance.kochavaConfig.networking.urls.identityLink);
+    let resp;
+    let success = false;
+    try {
+        Log.trace("IdentityLink Response string:", respStr);
+        resp = JSON.parse(respStr);
+        Log.debug("IdentityLink Response:", respStr);
+        success = wasRespSuccess(resp.success);
+    }
+    catch (e) {
+        Log.error("Error parsing IdentityLink Response", e);
+        success = false;
+    }
+    if (success) {
+        Log.info("IdentityLink success!");
+        return true;
+    }
+    Log.error("IdentityLink failed!");
+    return false;
+});
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+const setCookie = (name, value) => {
+    let expires = "";
+    const date = new Date();
+    date.setTime(date.getTime() + 3650 * 24 * 60 * 60 * 1000);
+    expires = `; expires=${date.toUTCString()}`;
+    document.cookie =
+        name +
+            "=" +
+            (value || "") +
+            expires +
+            "; path=/;domain=" +
+            getBaseDomain();
+};
+const getCookie = (name) => {
+    const nameEQ = name + "=";
+    const charArray = document.cookie.split(';');
+    for (let i = 0; i < charArray.length; i++) {
+        let char = charArray[i];
+        while (char.charAt(0) === " ")
+            char = char.substring(1, char.length);
+        if (char.indexOf(nameEQ) === 0)
+            return char.substring(nameEQ.length, char.length);
+    }
+    return "";
+};
+const deleteCookie = (name) => {
+    if (getCookie(name)) {
+        const path = "/";
+        const domain = getBaseDomain();
+        document.cookie = name + "=" +
+            ((path) ? ";path=" + path : "") +
+            ((domain) ? ";domain=" + domain : "") +
+            ";expires=Thu, 01 Jan 1970 00:00:01 GMT";
+    }
+};
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+const MAX_STORED_IDLINKS = 10;
+var PersistKey;
+(function (PersistKey) {
+    PersistKey["LastKvinit"] = "com.kochava.tracker.LastKvinit";
+    PersistKey["EventQueue"] = "com.kochava.tracker.EventQueue";
+    PersistKey["IdLinkQueue"] = "com.kochava.tracker.IdLinkQueue";
+    PersistKey["DeviceId"] = "com.kochava.tracker.DeviceId";
+    PersistKey["InstallId"] = "com.kochava.tracker.InstallId";
+    PersistKey["FirstStartDate"] = "com.kochava.tracker.FirstStartDate";
+    PersistKey["InstallSentDate"] = "com.kochava.tracker.InstallSentDate";
+    PersistKey["KvinitSentDate"] = "com.kochava.tracker.KvinitSentDate";
+    PersistKey["SessionCount"] = "com.kochava.tracker.SessionCount";
+    PersistKey["IdentityLinks"] = "com.kochava.tracker.IdentityLinks";
+    PersistKey["OverrideAppId"] = "com.kochava.tracker.OverrideAppId";
+    PersistKey["OverrideDeviceId"] = "com.kochava.tracker.OverrideDeviceId";
+    PersistKey["OldKvid"] = "kv_id";
+})(PersistKey || (PersistKey = {}));
+const storedKeys = [
+    PersistKey.LastKvinit,
+    PersistKey.EventQueue,
+    PersistKey.IdLinkQueue,
+    PersistKey.DeviceId,
+    PersistKey.InstallId,
+    PersistKey.FirstStartDate,
+    PersistKey.InstallSentDate,
+    PersistKey.KvinitSentDate,
+    PersistKey.SessionCount,
+    PersistKey.IdentityLinks,
+    PersistKey.OverrideAppId,
+    PersistKey.OverrideDeviceId,
+];
+const checkInstallIdChange = (inputId, useCookies) => {
+    const persistedInstallId = readAndUpdatePersistedValue(PersistKey.InstallId, useCookies);
+    // if the input is empty, we don't need to change
+    if (!inputId)
+        return false;
+    // if the persistedId is empty, we will need to change
+    if (!persistedInstallId) {
+        updatePersistedValue(PersistKey.InstallId, inputId, useCookies);
+        return true;
+    }
+    // if the inputId and persistedId are the same, we dont need to change
+    if (inputId === persistedInstallId)
+        return false;
+    // at this point both inputId and persistedInstallId exist and are not equal,
+    // so we must need to change
+    updatePersistedValue(PersistKey.InstallId, inputId, useCookies);
+    return true;
+};
+const addToPersistedEventQueue = (job) => {
+    const persistedQueueStr = localStorage.getItem(PersistKey.EventQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    persistedQueue.push(job);
+    localStorage.setItem(PersistKey.EventQueue, JSON.stringify(persistedQueue));
+};
+const removeFromEventPersistedQueue = (job) => {
+    const persistedQueueStr = localStorage.getItem(PersistKey.EventQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    const queueWithJobRemoved = persistedQueue.filter(persistedJob => {
+        return persistedJob.id !== job.id;
+    });
+    localStorage.setItem(PersistKey.EventQueue, JSON.stringify(queueWithJobRemoved));
+};
+const updateOrAddPersistedIdLinkQueue = (job) => {
+    const idLinkKey = Object.keys(job.idLink)[0];
+    const persistedQueueStr = localStorage.getItem(PersistKey.IdLinkQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    let updated = false;
+    for (const persistedJob of persistedQueue) {
+        const persistedKey = Object.keys(persistedJob.idLink)[0];
+        // if the key is already there, update it
+        if (idLinkKey === persistedKey) {
+            persistedJob.idLink[idLinkKey] = job.idLink[idLinkKey];
+            updated = true;
+        }
+    }
+    // if the key is new, add it
+    if (!updated)
+        persistedQueue.push(job);
+    localStorage.setItem(PersistKey.IdLinkQueue, JSON.stringify(persistedQueue));
+};
+const removeFromIdLinkPersistedQueue = (job) => {
+    const persistedQueueStr = localStorage.getItem(PersistKey.IdLinkQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    const queueWithJobRemoved = persistedQueue.filter(persistedJob => {
+        return persistedJob.id !== job.id;
+    });
+    localStorage.setItem(PersistKey.IdLinkQueue, JSON.stringify(queueWithJobRemoved));
+};
+const addPersistedIdLinks = (key, value, useCookies) => {
+    const persistedIdLinksStr = localStorage.getItem(PersistKey.IdentityLinks);
+    const persistedIdLinks = JSON.parse(persistedIdLinksStr) || {};
+    const storedSoFar = Object.keys(persistedIdLinks);
+    if (storedSoFar.length > MAX_STORED_IDLINKS) {
+        Log.debug("Maximum stored idLinks reached, most recent idLink will not be stored.");
+        return;
+    }
+    persistedIdLinks[key] = value;
+    updatePersistedValue(PersistKey.IdentityLinks, JSON.stringify(persistedIdLinks), useCookies);
+};
+const checkDuplicateIdLink = (key, value) => {
+    const persistedIdLinksStr = localStorage.getItem(PersistKey.IdentityLinks);
+    if (persistedIdLinksStr) {
+        const persistedIdLinks = JSON.parse(persistedIdLinksStr) || {};
+        for (const persistedKey in persistedIdLinks) {
+            if (key === persistedKey && persistedIdLinks[persistedKey] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const getPersistedIdentityLinks = () => {
+    const persistedIdLinksStr = localStorage.getItem(PersistKey.IdentityLinks);
+    if (persistedIdLinksStr) {
+        return JSON.parse(persistedIdLinksStr);
+    }
+    return undefined;
+};
+const readAndUpdateUTM = (appGuid, useCookies) => {
+    const storageName = appGuid + "_click";
+    const urlValue = getUrlParameter("ko_click_id");
+    const storageValue = localStorage.getItem(storageName);
+    let cookieValue = "";
+    if (useCookies)
+        cookieValue = getCookie(storageName);
+    if (urlValue) {
+        localStorage.setItem(storageName, urlValue);
+        if (useCookies)
+            setCookie(storageName, urlValue);
+    }
+    else if (storageValue) {
+        if (useCookies)
+            setCookie(storageName, urlValue);
+    }
+    return (urlValue) ? urlValue :
+        (storageValue) ? storageValue :
+            (cookieValue) ? cookieValue : "";
+};
+const readAndUpdatePersistedValue = (key, useCookie) => {
+    const urlValue = getUrlParameter(key);
+    const storageValue = localStorage.getItem(key);
+    let cookieValue = "";
+    if (useCookie)
+        cookieValue = getCookie(key);
+    if (urlValue) {
+        updatePersistedValue(key, urlValue, useCookie);
+    }
+    else if (storageValue) {
+        updatePersistedValue(key, storageValue, useCookie);
+    }
+    else if (cookieValue) {
+        updatePersistedValue(key, storageValue, useCookie);
+    }
+    return (urlValue) ? urlValue :
+        (storageValue) ? storageValue :
+            (cookieValue) ? cookieValue : "";
+};
+const updatePersistedValue = (key, value, useCookie) => {
+    localStorage.setItem(key, value);
+    if (useCookie)
+        setCookie(key, value);
+};
+const deletePersistedValue = (item) => {
+    localStorage.removeItem(item);
+    deleteCookie(item);
+};
+const deleteAllPersisted = () => storedKeys.forEach(item => deletePersistedValue(item));
+const readAndUpdateDeviceId = (useCookie) => {
+    let storedDeviceId = readAndUpdatePersistedValue(PersistKey.DeviceId, useCookie);
+    if (!storedDeviceId) {
+        const kvId = `KB${getCurrTimeSec()}T${uuidv4()}`;
+        storedDeviceId = kvId.replace(/-/g, "");
+    }
+    updatePersistedValue(PersistKey.DeviceId, storedDeviceId, useCookie);
+    return storedDeviceId;
+};
+const readAndUpdateSessionCount = (useCookie) => {
+    const storedSessionCount = readAndUpdatePersistedValue(PersistKey.SessionCount, useCookie);
+    let sessionCount = 1;
+    if (storedSessionCount) {
+        sessionCount = parseInt(storedSessionCount);
+        sessionCount++;
+    }
+    updatePersistedValue(PersistKey.SessionCount, sessionCount.toString(), useCookie);
+    return sessionCount;
+};
+
+function jobIsEventJob(obj) {
+    return 'eventName' in obj;
+}
+function jobIsIdLinkJob(obj) {
+    return 'idLink' in obj;
+}
+class JobQueue {
+    constructor() {
+        this.eventQueue = [];
+        this.idLinkQueue = [];
+        this.processing = false;
+        this.stopped = false;
+        this.paused = false;
+    }
+    start(instance) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.eventQueue = JSON.parse(localStorage.getItem(PersistKey.EventQueue)) || [];
+            this.idLinkQueue = JSON.parse(localStorage.getItem(PersistKey.IdLinkQueue)) || [];
+            this.updateEventJobs(instance);
+            this.updateIdLinkJobs(instance);
+            Log.trace("Starting Event Queue", JSON.parse(JSON.stringify(this.eventQueue)));
+            Log.trace("Starting IdLink Queue", JSON.parse(JSON.stringify(this.idLinkQueue)));
+            this.stopped = false;
+            this.paused = false;
+            yield this.dequeueJob(instance);
+        });
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timeOut)
+            clearTimeout(this.timeOut);
+        this.processing = false;
+    }
+    pause() {
+        this.paused = true;
+    }
+    enqueueEvent(instance, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const eventName = args[0];
+            const eventData = args[1];
+            const eventPreStartBody = constructPreStart$1(instance, eventName, eventData);
+            if (instance.installDone && instance.kvinitDone) {
+                const postStartBody = constructPostStart$1(instance, eventPreStartBody);
+                const newJob = {
+                    id: uuidv4(),
+                    queuedBeforeStart: false,
+                    preStartBody: eventPreStartBody,
+                    postStartBody,
+                    retries: 0,
+                    eventName,
+                };
+                this.eventQueue.push(newJob);
+                addToPersistedEventQueue(newJob);
+                yield this.dequeueJob(instance);
+                return;
+            }
+            const newEventJob = {
+                id: uuidv4(),
+                queuedBeforeStart: true,
+                preStartBody: eventPreStartBody,
+                postStartBody: undefined,
+                retries: 0,
+                eventName,
+            };
+            this.eventQueue.push(newEventJob);
+            addToPersistedEventQueue(newEventJob);
+        });
+    }
+    enqueueIdLink(instance, idLink) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const idLinkPreStartBody = constructPreStart(instance, idLink);
+            if (instance.installDone && instance.kvinitDone) {
+                const postStartBody = constructPostStart(instance, idLinkPreStartBody);
+                const newJob = {
+                    id: uuidv4(),
+                    queuedBeforeStart: false,
+                    preStartBody: idLinkPreStartBody,
+                    postStartBody,
+                    retries: 0,
+                    idLink,
+                };
+                updateOrAddPersistedIdLinkQueue(newJob);
+                this.idLinkQueue.push(newJob);
+                yield this.dequeueJob(instance);
+                return;
+            }
+            const newJob = {
+                id: uuidv4(),
+                queuedBeforeStart: true,
+                preStartBody: idLinkPreStartBody,
+                postStartBody: undefined,
+                retries: 0,
+                idLink,
+            };
+            updateOrAddPersistedIdLinkQueue(newJob);
+            this.idLinkQueue.push(newJob);
+        });
+    }
+    dequeueJob(instance) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If queue is busy, prev job not finished
+            if (this.processing)
+                return false;
+            // If the queue is paused, do not dequeue a new job
+            if (this.paused)
+                return false;
+            // If the queue is stopped do not dequeue a new job
+            if (this.stopped) {
+                return false;
+            }
+            // Prioritize sending identityLinks first
+            // Remove first job from queue
+            const idLinkJob = this.idLinkQueue.shift();
+            if (idLinkJob) {
+                // handle idlinkjob
+                Log.trace("Dequeued Job: ", idLinkJob);
+                this.processing = true;
+                const result = yield this.processJob(instance, idLinkJob);
+                if (this.stopped) {
+                    return true;
+                }
+                this.processing = false;
+                // If the job succeeded, dequeue the next job
+                if (result) {
+                    removeFromIdLinkPersistedQueue(idLinkJob);
+                    return yield this.dequeueJob(instance);
+                }
+            }
+            const eventJob = this.eventQueue.shift();
+            if (eventJob) {
+                //handle eventJob
+                Log.trace("Dequeued Job: ", eventJob);
+                // Process the job
+                this.processing = true;
+                const result = yield this.processJob(instance, eventJob);
+                if (this.stopped) {
+                    return true;
+                }
+                this.processing = false;
+                // If the job succeeded, dequeue the next job
+                if (result) {
+                    removeFromEventPersistedQueue(eventJob);
+                    return yield this.dequeueJob(instance);
+                }
+            }
+            // If neither queue had a job, break out of recursion
+            if (!idLinkJob && !eventJob)
+                return false;
+            return true;
+        });
+    }
+    processJob(instance, job) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (jobIsEventJob(job)) {
+                for (const denyName of instance.kochavaConfig.privacy.deny_event_names) {
+                    if (denyName === job.eventName) {
+                        Log.debug(`Denied event_name ${denyName}, dropping request.`);
+                        return true;
+                    }
+                }
+            }
+            else if (jobIsIdLinkJob(job)) {
+                for (const denyIdLinkKey of instance.kochavaConfig.privacy.deny_identity_links) {
+                    if (denyIdLinkKey === Object.keys(job.idLink)[0]) {
+                        Log.debug(`Denied identity_link ${denyIdLinkKey}, dropping request.`);
+                        return true;
+                    }
+                }
+            }
+            let success = false;
+            do {
+                success = yield this.attemptJob(instance, job);
+                // If our job succeeded
+                if (success) {
+                    // Job Done
+                    Log.trace("Job processed successfully:", job);
+                    return true;
+                }
+                // If it didnt succeed, but we our queue isnt stopped
+                if (!this.stopped) {
+                    //retry the job
+                    const retryWaterfall = instance.kochavaConfig.networking.retry_waterfall;
+                    const retryIndex = (job.retries > retryWaterfall.length - 1) ?
+                        retryWaterfall.length - 1 : job.retries;
+                    const retrySec = retryWaterfall[retryIndex];
+                    Log.error(`Job failed, attempting again in ${retrySec} seconds`);
+                    yield new Promise(resolve => this.timeOut = setTimeout(resolve, retrySec * 1000));
+                    job.retries++;
+                }
+            } while (!success && !this.stopped);
+            // Job Canceled
+            return true;
+        });
+    }
+    attemptJob(instance, job) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (job.preStartBody.action === "event")
+                return yield send$3(instance, job.preStartBody, job.postStartBody);
+            else if (job.preStartBody.action === "identityLink")
+                return yield send$2(instance, job);
+            else {
+                Log.warn("Invalid action in job from jobqueue, cancelling.");
+                return true;
+            }
+        });
+    }
+    updateEventJobs(instance) {
+        for (const job of this.eventQueue) {
+            if (job.queuedBeforeStart) {
+                job.postStartBody = constructPostStart$1(instance, job.preStartBody);
+            }
+        }
+        updatePersistedValue(PersistKey.EventQueue, JSON.stringify(this.eventQueue), false);
+    }
+    updateIdLinkJobs(instance) {
+        for (const job of this.idLinkQueue) {
+            if (job.queuedBeforeStart) {
+                job.postStartBody = constructPostStart(instance, job.preStartBody);
+            }
+        }
+        updatePersistedValue(PersistKey.IdLinkQueue, JSON.stringify(this.idLinkQueue), false);
+    }
+}
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+const DEFAULTS = {
+    general: {
+        // DO NOT DEFAULT
+        app_id_override: "",
+        // DO NOT DEFAULT
+        device_id_override: "",
+    },
+    config: {
+        init_token: "",
+        refresh_minimum: 60,
+    },
+    install: {
+        // DO NOT DEFAULT
+        resend_id: "",
+        updates_enabled: true,
+    },
+    networking: {
+        urls: {
+            init: "https://kvinit-prod.api.kochava.com/track/kvinit",
+            install: "https://web-sdk.control.kochava.com/track/json/",
+            event: "https://web-sdk.control.kochava.com/track/json/",
+            identityLink: "https://web-sdk.control.kochava.com/v1/cpi/identityLink.php"
+        },
+        retry_waterfall: [7, 30, 300, 1800],
+    },
+    privacy: {
+        allow_custom_ids: [],
+        deny_datapoints: [],
+        deny_event_names: [],
+        deny_identity_links: [],
+    },
+};
+
+let timeOut$1;
+let canceled$1 = false;
+const build$1 = (instance) => {
+    const payload = constructPayload("init", instance);
+    payload.build_date = instance.buildDate;
+    payload.data = constructKvinitData(instance);
+    Log.debug("Kvinit Payload", JSON.stringify(payload));
+    return payload;
+};
+const cancelRetries$1 = () => {
+    canceled$1 = true;
+    clearTimeout(timeOut$1);
+};
+const send$1 = (instance, retryWaterfall, retries = 0) => __awaiter(void 0, void 0, void 0, function* () {
+    canceled$1 = false;
+    const payload = build$1(instance);
+    let success = false;
+    let resp;
+    do {
+        Log.trace("Kvinit endpoint:", instance.kochavaConfig.networking.urls.init);
+        const sendTime = getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Sending kvinit at ${formatTime(sendTime / 1000)} seconds`);
+        const respStr = yield sendRequest(payload, (instance.overrideUrls.init) ?
+            instance.overrideUrls.init : instance.kochavaConfig.networking.urls.init);
+        const respTime = getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Completed kvinit at ${formatTime(respTime / 1000)}
+      seconds with a network duration of ${formatTime((respTime - sendTime) / 1000)} seconds`);
+        if (canceled$1) {
+            Log.trace("Can no longer retry kvinit, cancelling.");
+            return false;
+        }
+        try {
+            resp = JSON.parse(respStr);
+            Log.debug("Kvinit Response:", resp);
+            success = wasRespSuccess(resp.success);
+        }
+        catch (e) {
+            Log.error("Error parsing Kvinit Response", e);
+            success = false;
+        }
+        if (success) {
+            Log.info("Kvinit success!");
+            updatePersistedValue(PersistKey.LastKvinit, JSON.stringify(resp), instance.useCookies);
+            return success;
+        }
+        if (!canceled$1) {
+            // retry kvinit
+            const retryIndex = (retries > retryWaterfall.length - 1) ? retryWaterfall.length - 1 : retries;
+            const retrySec = retryWaterfall[retryIndex];
+            Log.error(`Kvinit failed, attempting again in ${retrySec} seconds`);
+            yield new Promise(resolve => { timeOut$1 = setTimeout(resolve, retrySec * 1000); });
+            retries++;
+        }
+    } while (!success && !canceled$1);
+});
+const applyKvinitResp = (instance, resp) => {
+    if (resp.general) {
+        if (resp.general.device_id_override) {
+            Log.trace(`Device_id override found, going from ${instance.kochavaDeviceId} to
+        ${resp.general.device_id_override}`);
+            instance.kochavaConfig.general.device_id_override = resp.general.device_id_override;
+            instance.kochavaDeviceId = resp.general.device_id_override;
+            updatePersistedValue(PersistKey.OverrideDeviceId, resp.general.device_id_override, instance.useCookies);
+        }
+        if (resp.general.app_id_override) {
+            Log.trace(`App_id override found, going from ${instance.appGuid} to
+        ${resp.general.app_id_override}`);
+            instance.kochavaConfig.general.app_id_override = resp.general.app_id_override;
+            instance.appGuid = resp.general.app_id_override;
+            updatePersistedValue(PersistKey.OverrideAppId, resp.general.app_id_override, instance.useCookies);
+        }
+    }
+    if (resp.config) {
+        instance.kochavaConfig.config = {
+            init_token: resp.config.init_token || DEFAULTS.config.init_token,
+            refresh_minimum: (resp.config.refresh_minimum !== undefined &&
+                resp.config.refresh_minimum !== null) ? resp.config.refresh_minimum :
+                DEFAULTS.config.refresh_minimum,
+        };
+    }
+    if (resp.install) {
+        if (resp.install.resend_id) {
+            instance.kochavaConfig.install.resend_id = resp.install.resend_id;
+        }
+        instance.kochavaConfig.install.updates_enabled =
+            resp.install.updates_enabled || DEFAULTS.install.updates_enabled;
+    }
+    if (resp.networking) {
+        instance.kochavaConfig.networking.retry_waterfall =
+            resp.networking.retry_waterfall || DEFAULTS.networking.retry_waterfall;
+        instance.retryWaterfall =
+            instance.kochavaConfig.networking.retry_waterfall;
+        if (resp.networking.urls) {
+            instance.kochavaConfig.networking.urls = {
+                init: resp.networking.urls.init || DEFAULTS.networking.urls.init,
+                install: resp.networking.urls.install || DEFAULTS.networking.urls.install,
+                event: resp.networking.urls.event || DEFAULTS.networking.urls.event,
+                identityLink: resp.networking.urls.identityLink || DEFAULTS.networking.urls.identityLink,
+            };
+        }
+    }
+    if (resp.privacy) {
+        instance.kochavaConfig.privacy = {
+            allow_custom_ids: resp.privacy.allow_custom_ids || DEFAULTS.privacy.allow_custom_ids,
+            deny_datapoints: resp.privacy.deny_datapoints || DEFAULTS.privacy.deny_datapoints,
+            deny_event_names: resp.privacy.deny_event_names || DEFAULTS.privacy.deny_event_names,
+            deny_identity_links: resp.privacy.deny_identity_links || DEFAULTS.privacy.deny_identity_links,
+        };
+    }
+};
+const constructKvinitData = (instance) => {
+    const currTime = Math.floor(Date.now() / 1000);
+    let uptime = (currTime - instance.startTimeMS) / 1000;
+    if (uptime < 0.0)
+        uptime = 0.0;
+    return {
+        package: getPackageName(),
+        platform: "web",
+        starttime: instance.startTimeMS / 1000,
+        uptime,
+        usertime: currTime,
+    };
+};
+
+let timeOut;
+let canceled = false;
+const build = (instance) => {
+    const payload = constructPayload("install", instance);
+    instance.installStarted = true;
+    payload.data = constructInstallData(instance);
+    Log.debug("Install Payload", JSON.stringify(payload));
+    if (instance.kochavaConfig.privacy) {
+        instance.kochavaConfig.privacy.deny_datapoints.forEach(denyPoint => {
+            for (const point in payload.data) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload.data[key];
+            }
+            for (const point in payload) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload[key];
+            }
+        });
+    }
+    return payload;
+};
+const cancelRetries = () => {
+    canceled = true;
+    clearTimeout(timeOut);
+};
+const send = (instance, payload, retries = 0) => __awaiter(void 0, void 0, void 0, function* () {
+    canceled = false;
+    let success = false;
+    let resp;
+    do {
+        const sendTime = getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Sending install at ${formatTime(sendTime / 1000)} seconds`);
+        const respStr = yield sendRequest(payload, (instance.overrideUrls.install) ?
+            instance.overrideUrls.install : instance.kochavaConfig.networking.urls.install);
+        const respTime = getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Completed install at ${new Date().toLocaleTimeString()} 
+      seconds with a network duration of ${formatTime((respTime - sendTime) / 1000)} seconds`);
+        if (canceled) {
+            Log.trace("Can no longer retry install, cancelling.");
+            return false;
+        }
+        try {
+            Log.trace("Install Response string:", respStr);
+            resp = JSON.parse(respStr);
+            Log.debug("Install Response:", respStr);
+            success = wasRespSuccess(resp.success);
+        }
+        catch (e) {
+            Log.error("Error parsing Install Response", e);
+            success = false;
+        }
+        if (success) {
+            Log.info("Install success!");
+            return success;
+        }
+        if (!canceled) {
+            const retryWaterfall = instance.kochavaConfig.networking.retry_waterfall;
+            const retryIndex = (retries > retryWaterfall.length - 1) ? retryWaterfall.length - 1 : retries;
+            const retrySec = retryWaterfall[retryIndex];
+            Log.error(`Install failed, attempting again in ${retrySec} seconds`);
+            yield new Promise(resolve => { timeOut = setTimeout(resolve, retrySec * 1000); });
+            retries++;
+        }
+    } while (!success && !canceled);
+});
+const onSuccess = (instance) => {
+    instance.kochavaInstallDate = getCurrTimeMS();
+    updatePersistedValue(PersistKey.InstallSentDate, String(instance.kochavaInstallDate), instance.useCookies);
+};
+const constructInstallData = (instance) => {
+    const currTime = Math.floor(Date.now() / 1000);
+    let uptime = (currTime - instance.startTimeMS) / 1000;
+    if (uptime < 0.0)
+        uptime = 0.0;
+    let returnObj = {
+        starttime: instance.startTimeMS / 1000,
+        uptime: uptime,
+        usertime: determineInstallUserTime(instance, currTime),
+        device_orientation: getDeviceOrientation(),
+        package: getPackageName(),
+        disp_w: getDeviceWidth(),
+        disp_h: getDeviceHeight(),
+        language: getLanguage(),
+    };
+    if (instance.utm) {
+        returnObj = Object.assign(Object.assign({}, returnObj), { conversion_data: { utm_source: instance.utm } });
+    }
+    if (instance.customValues.length > 0)
+        returnObj.device_ids = {};
+    instance.customValues.forEach((custom) => {
+        const customKey = Object.keys(custom.data)[0];
+        if (instance.kochavaConfig.privacy) {
+            let keyAllowed = false;
+            for (const allowed of instance.kochavaConfig.privacy.allow_custom_ids) {
+                if (customKey === allowed) {
+                    keyAllowed = true;
+                }
+            }
+            if (keyAllowed) {
+                if (custom.isDeviceId)
+                    returnObj.device_ids = Object.assign(Object.assign({}, returnObj.device_ids), custom.data);
+                else
+                    returnObj = Object.assign(Object.assign({}, custom.data), returnObj);
+            }
+        }
+    });
+    // add the persisted identityLinks
+    const persistedIdLinks = getPersistedIdentityLinks();
+    if (persistedIdLinks) {
+        returnObj.identity_link = {};
+        for (const key in persistedIdLinks) {
+            let includeKey = true;
+            for (const denyIdLinkKey of instance.kochavaConfig.privacy.deny_identity_links) {
+                if (denyIdLinkKey === key) {
+                    Log.debug(`Denied identity_link ${denyIdLinkKey}, dropping from install.`);
+                    includeKey = false;
+                }
+            }
+            if (includeKey)
+                returnObj.identity_link[key] = persistedIdLinks[key];
+        }
+    }
+    return returnObj;
+};
+const determineInstallUserTime = (instance, currTime) => {
+    const firstStartStr = readAndUpdatePersistedValue(PersistKey.FirstStartDate, instance.useCookies);
+    if (firstStartStr) {
+        const firstStart = JSON.parse(firstStartStr);
+        // If its been 30 days since the sdk started
+        if ((currTime - firstStart) > 2592000) {
+            return currTime;
+        }
+        return firstStart;
+    }
+    return currTime;
+};
+
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m")
+        throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Kochava_instances, _Kochava_instance, _Kochava_jobQueue, _Kochava_resetInstance, _Kochava_initInstance, _Kochava_checkFirstLaunchAndMigrate, _Kochava_checkPersistedKvinit, _Kochava_checkPersistedState, _Kochava_printStartupMsgs, _Kochava_beginStart, _Kochava_performNewKvinit, _Kochava_checkResendId, _Kochava_performInstall;
+class Kochava {
+    // User will use the below factories instead of directly calling 
+    // the constructor
+    constructor() {
+        _Kochava_instances.add(this);
+        _Kochava_instance.set(this, void 0);
+        _Kochava_jobQueue.set(this, void 0);
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_resetInstance).call(this);
+        __classPrivateFieldSet(this, _Kochava_jobQueue, new JobQueue(), "f");
+    }
+    // ============================= PUBLIC =============================== //
+    static create() {
+        return new Kochava();
+    }
+    static createForNode() {
+        const kochava = new Kochava();
+        kochava.executeAdvancedInstruction("wrapper", JSON.stringify({ name: "Node", version: "" }));
+        return kochava;
+    }
+    static createForReact() {
+        const kochava = new Kochava();
+        kochava.executeAdvancedInstruction("wrapper", JSON.stringify({ name: "React", version: "" }));
+        return kochava;
+    }
+    static createForVue() {
+        const kochava = new Kochava();
+        kochava.executeAdvancedInstruction("wrapper", JSON.stringify({ name: "Vue", version: "" }));
+        return kochava;
+    }
+    static createForAngular() {
+        const kochava = new Kochava();
+        kochava.executeAdvancedInstruction("wrapper", JSON.stringify({ name: "Angular", version: "1.0.0" }));
+        return kochava;
+    }
+    /*
+      Set if the SDK should also store persisted values in cookie storage.
+      - Not all values can be persisted in cookies, such as event/idlink queues
+        due to size constraints.
+      - true = yes use cookies
+      - no = no don't use cookies
+      - defaults to false
+    */
+    useCookies(condition = false) {
+        __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies = condition;
+    }
+    /*
+      - Set whether the sdk shouldn't automatically send a page or should.
+      - true = no auto page
+      - false = yes auto page
+      - defaults to false
+    */
+    disableAutoPage(condition = false) {
+        __classPrivateFieldGet(this, _Kochava_instance, "f").disableAutoPage = condition;
+    }
+    /*
+      The primary means for starting the sdk.
+      Responsibilites:
+      - Checks for migrations.
+      - Creates the sdk instance.
+      - Checks for persisted state.
+      - Determines and sends kvinit.
+      - Determines and sends install.
+      - Optionally enqueues an auto_page.
+      - Starts the job queue.
+    */
+    startWithAppGuid(appGuid) {
+        if (!appGuid) {
+            Log.error(`Invalid appGuid ${appGuid}, start failed.`);
+            return;
+        }
+        if (!__classPrivateFieldGet(this, _Kochava_instance, "f"))
+            __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_resetInstance).call(this);
+        if (__classPrivateFieldGet(this, _Kochava_instance, "f").started) {
+            Log.warn("Kochava SDK already started.");
+            return;
+        }
+        Log.diagDebug(`Host called API: Start With App Guid ${appGuid}`);
+        __classPrivateFieldGet(this, _Kochava_instance, "f").started = true;
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_checkFirstLaunchAndMigrate).call(this);
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_initInstance).call(this, appGuid);
+        if (!__classPrivateFieldGet(this, _Kochava_instance, "f").disableAutoPage)
+            this.sendPageEvent();
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_checkPersistedState).call(this);
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_checkPersistedKvinit).call(this);
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_printStartupMsgs).call(this, appGuid);
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_beginStart).call(this);
+    }
+    /*
+      Primary means for stopping the sdk.
+      Will optionally delete all persisted data, and will shutdown the
+      sdk and job queue.
+    */
+    shutdown(deleteData) {
+        Log.diagDebug(`Host called API: Shutdown and ${deleteData ? "delete data" : "keep data"}`);
+        if (deleteData) {
+            Log.debug("Deleting persisted values");
+            deleteAllPersisted();
+        }
+        if (!__classPrivateFieldGet(this, _Kochava_instance, "f").started) {
+            Log.warn("SDK already shutdown.");
+        }
+        Log.info("SDK shutting down.");
+        cancelRetries$1();
+        cancelRetries();
+        __classPrivateFieldGet(this, _Kochava_jobQueue, "f").stop();
+        // wipe whatever was previously in the queue
+        __classPrivateFieldSet(this, _Kochava_jobQueue, new JobQueue(), "f");
+        __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_resetInstance).call(this);
+    }
+    /*
+      Changes the current logLevel.
+      Options include:
+      - Off   :: No logging whatsoever
+      - Error :: Only critical errors
+      - Warn  :: Only critical errors and non-critical warnings
+      - Info  :: High-level sdk behavior logs (default)
+      - Debug :: More in-depth sdk behavior logs and payload logs
+      - Trace :: Everything, granular detail
+    */
+    setLogLevel(logLevel) {
+        Log.diagDebug(`Host called API: Set Log Level ${logLevel}`);
+        Log.setLogLevel(logLevel);
+    }
+    /*
+      Used internally, for special SDK behavior not utilized by a client.
+      Examples include:
+      - urls    :: purposefully changing an endpoint for testing
+      - wrapper :: overwriting the version of a wrapper
+      several more ...
+    */
+    executeAdvancedInstruction(key, valueStr, callback) {
+        Log.diagDebug(`Host called API: Execute Advanced Instruction ${key}`);
+        switch (key) {
+            case "wrapper":
+                {
+                    const wrapperVersion = JSON.parse(valueStr);
+                    if (!__classPrivateFieldGet(this, _Kochava_instance, "f").version)
+                        __classPrivateFieldGet(this, _Kochava_instance, "f").version = "WebTracker 3.0.0";
+                    switch (wrapperVersion.name) {
+                        case "Angular":
+                            __classPrivateFieldGet(this, _Kochava_instance, "f").version += ` (${wrapperVersion.name} ${wrapperVersion.version})`;
+                            break;
+                        default:
+                            __classPrivateFieldGet(this, _Kochava_instance, "f").version += ` (${wrapperVersion.name})`;
+                            break;
+                    }
+                }
+                break;
+            case "urls":
+                {
+                    const overrideUrls = JSON.parse(valueStr);
+                    if (overrideUrls.init)
+                        __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.init = overrideUrls.init;
+                    if (overrideUrls.event)
+                        __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.event = overrideUrls.event;
+                    if (overrideUrls.install)
+                        __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.install = overrideUrls.install;
+                    if (overrideUrls.identityLink)
+                        __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.identityLink = overrideUrls.identityLink;
+                }
+                break;
+            case "urlsRestore":
+                {
+                    const restoreUrls = JSON.parse(valueStr);
+                    for (const url of restoreUrls) {
+                        if (url === "init")
+                            __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.init = DEFAULTS.networking.urls.init;
+                        if (url === "event")
+                            __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.event = DEFAULTS.networking.urls.event;
+                        if (url === "install")
+                            __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.install =
+                                DEFAULTS.networking.urls.install;
+                        if (url === "identityLink")
+                            __classPrivateFieldGet(this, _Kochava_instance, "f").overrideUrls.identityLink =
+                                DEFAULTS.networking.urls.identityLink;
+                    }
+                }
+                break;
+            case "logFilter":
+                {
+                    const disabled = JSON.parse(valueStr);
+                    disabled.forEach((level) => Log.disableLogType(level));
+                }
+                break;
+            case "getInstance":
+                {
+                    const currInstance = JSON.stringify(__classPrivateFieldGet(this, _Kochava_instance, "f"));
+                    callback(currInstance);
+                    Log.debug(`capturing instance: ${valueStr}`);
+                }
+                break;
+            case "logObjects":
+                Log.setLogObjects(JSON.parse(valueStr));
+                break;
+            default:
+                break;
+        }
+    }
+    /*
+      Builds and enqueues a kochava event. Must include an event_name string,
+      with optional event_data as either another string or object.
+    */
+    sendEvent(name, data) {
+        Log.diagDebug(`Host called API: Send Event`);
+        if (!name) {
+            Log.warn("Invalid event name, ignoring call.");
+            return;
+        }
+        __classPrivateFieldGet(this, _Kochava_jobQueue, "f").enqueueEvent(__classPrivateFieldGet(this, _Kochava_instance, "f"), [name, data]);
+    }
+    /*
+      Wraps the sendEvent call with predefined data specific to page events.
+    */
+    sendPageEvent(pageName, additionalData) {
+        if (pageName)
+            this.sendEvent("page", Object.assign({ page_name: pageName }, additionalData));
+        else
+            this.sendEvent("page", Object.assign({ page_name: getPageName() }, additionalData));
+    }
+    /*
+      - Registers new identity links with the sdk, either to be sent out with
+        the install, or standalone.
+      - Will update an identity link if its key already exists in storage.
+      - A max of 10 identity links are currently allowed to be stored
+        at any one time.
+    */
+    registerIdentityLink(name, identifier) {
+        Log.diagDebug(`Host called API: Register Identity Link ${name}`);
+        if (!name || !identifier) {
+            Log.warn("Invalid identity link, ignoring call.");
+            return;
+        }
+        if (checkDuplicateIdLink(name, identifier)) {
+            Log.debug("Duplicate Identity Link found, ignoring.");
+            return;
+        }
+        const idLink = {};
+        idLink[name] = identifier;
+        addPersistedIdLinks(name, identifier, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+        if (__classPrivateFieldGet(this, _Kochava_instance, "f").installStarted || __classPrivateFieldGet(this, _Kochava_instance, "f").installDone) {
+            // it will be sent standalone
+            __classPrivateFieldGet(this, _Kochava_jobQueue, "f").enqueueIdLink(__classPrivateFieldGet(this, _Kochava_instance, "f"), idLink);
+        }
+        // will be sent in install
+    }
+    // Allows the client to attach arbitrary data to certain payloads. 
+    registerCustomValue(name, value) {
+        Log.diagDebug(`Host called API: Register Custom Value ${name}`);
+        if (!name || !value) {
+            Log.warn("Invalid custom value, ignoring call.");
+            return;
+        }
+        const dataToAdorn = {};
+        dataToAdorn[name] = value;
+        __classPrivateFieldGet(this, _Kochava_instance, "f").customValues.push({ data: dataToAdorn, isDeviceId: false });
+    }
+    // Allows the client to attach arbitrary identifiers to go out in the install. 
+    registerCustomDeviceIdentifier(name, value) {
+        Log.diagDebug(`Host called API: Register Custom Device Identifier ${name}`);
+        if (!name || !value) {
+            Log.warn("Invalid custom device identifier, ignoring call.");
+            return;
+        }
+        const dataToAdorn = {};
+        dataToAdorn[name] = value;
+        __classPrivateFieldGet(this, _Kochava_instance, "f").customValues.push({ data: dataToAdorn, isDeviceId: true });
+    }
+    /*
+      Returns whether or not the sdk is in a "started" state.
+      This basically amounts to if start has been called,
+      not if kvinit is done or the queue is started.
+      Likewise, shutdown will set "started" to false;
+    */
+    getStarted() {
+        return __classPrivateFieldGet(this, _Kochava_instance, "f").started;
+    }
+    /*
+      Returns the current kochavaDeviceId, or "" if called too early.
+    */
+    getDeviceId() {
+        Log.diagDebug(`Host called API: Get Kochava Device Id`);
+        if (__classPrivateFieldGet(this, _Kochava_instance, "f").started)
+            return __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaDeviceId;
+        else
+            return "";
+    }
+    /*
+      Puts the sdk in a "sleep" state. This will stop the sdk from dequeuing
+      new jobs and retrying failed jobs. Different than shutdown, because the
+      current state is not destroyed.
+    */
+    setSleep(sleep) {
+        Log.diagDebug(`Host called API: Sleep ${sleep ? "Stop" : "Start"}`);
+        if (sleep && !__classPrivateFieldGet(this, _Kochava_instance, "f").sleep) {
+            // only pause if it was running
+            __classPrivateFieldGet(this, _Kochava_instance, "f").sleep = sleep;
+            __classPrivateFieldGet(this, _Kochava_jobQueue, "f").pause();
+        }
+        else if (!sleep && __classPrivateFieldGet(this, _Kochava_instance, "f").sleep) {
+            // only resume queueing if it was paused
+            __classPrivateFieldGet(this, _Kochava_instance, "f").sleep = sleep;
+            __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_beginStart).call(this);
+        }
+    }
+}
+_Kochava_instance = new WeakMap(), _Kochava_jobQueue = new WeakMap(), _Kochava_instances = new WeakSet(), _Kochava_resetInstance = function _Kochava_resetInstance() {
+    __classPrivateFieldSet(this, _Kochava_instance, {
+        appGuid: "",
+        started: false,
+        installStarted: false,
+        kvinitDone: false,
+        installDone: false,
+        disableAutoPage: false,
+        useCookies: false,
+        sleep: false,
+        version: "",
+        buildDate: "",
+        overrideUrls: {
+            init: "",
+            install: "",
+            event: "",
+            identityLink: "",
+        },
+        customValues: [],
+        kochavaSession: "",
+        retryWaterfall: [],
+        startTimeMS: 0,
+        utm: "",
+        kochavaDeviceId: "",
+        kochavaInstallId: "",
+        kochavaSessionCount: -1,
+        kochavaInstallDate: -1,
+        kochavaConfig: undefined,
+    }, "f");
+}, _Kochava_initInstance = function _Kochava_initInstance(appGuid) {
+    // init instance with defaults
+    __classPrivateFieldGet(this, _Kochava_instance, "f").appGuid = appGuid;
+    __classPrivateFieldGet(this, _Kochava_instance, "f").disableAutoPage = __classPrivateFieldGet(this, _Kochava_instance, "f").disableAutoPage || false;
+    __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies = __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies || false;
+    __classPrivateFieldGet(this, _Kochava_instance, "f").version = __classPrivateFieldGet(this, _Kochava_instance, "f").version || "WebTracker 3.0.0";
+    __classPrivateFieldGet(this, _Kochava_instance, "f").buildDate = "kbd: 3/31/2022, 11:47:52 AM";
+    __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaSession = uuidv4().substring(0, 5);
+    __classPrivateFieldGet(this, _Kochava_instance, "f").startTimeMS = getCurrTimeMS();
+    __classPrivateFieldGet(this, _Kochava_instance, "f").retryWaterfall = [7, 30, 300, 1800];
+    __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaConfig = JSON.parse(JSON.stringify(DEFAULTS));
+}, _Kochava_checkFirstLaunchAndMigrate = function _Kochava_checkFirstLaunchAndMigrate() {
+    // If this is our first launch ever, set it in persistence.
+    if (!readAndUpdatePersistedValue(PersistKey.FirstStartDate, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies)) {
+        updatePersistedValue(PersistKey.FirstStartDate, String(getCurrTimeSec()), __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+        /*
+          On a first launch of the v3 sdk, we need to migrate old persisted kv_id
+          from v2.2, v2.3, and v2.5
+        */
+        // perform migration
+        const oldKvId = readAndUpdatePersistedValue(PersistKey.OldKvid, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+        if (oldKvId) {
+            updatePersistedValue(PersistKey.DeviceId, oldKvId, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+            updatePersistedValue(PersistKey.InstallSentDate, JSON.stringify(getCurrTimeSec()), __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+        }
+    }
+}, _Kochava_checkPersistedKvinit = function _Kochava_checkPersistedKvinit() {
+    // check if persisted kvinit
+    let persistedKvinit = {};
+    const persistedKvinitStr = readAndUpdatePersistedValue(PersistKey.LastKvinit, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+    if (persistedKvinitStr) {
+        persistedKvinit = JSON.parse(persistedKvinitStr);
+        if (persistedKvinit) {
+            // if persisted kvinit, apply it
+            Log.trace("Found persisted kvinit.", persistedKvinit);
+            applyKvinitResp(__classPrivateFieldGet(this, _Kochava_instance, "f"), persistedKvinit);
+            Log.trace("KochavaConfig after persistedKvinit:", JSON.parse(JSON.stringify(__classPrivateFieldGet(this, _Kochava_instance, "f").kochavaConfig)));
+        }
+    }
+    // check refresh minimum too
+    const persistedKvinitDateStr = readAndUpdatePersistedValue(PersistKey.KvinitSentDate, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+    if (persistedKvinitDateStr) {
+        const lastKvinitDate = JSON.parse(persistedKvinitDateStr);
+        if (lastKvinitDate) {
+            const refreshMin = __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaConfig.config.refresh_minimum;
+            if (getCurrTimeSec() - lastKvinitDate < refreshMin)
+                __classPrivateFieldGet(this, _Kochava_instance, "f").kvinitDone = true;
+        }
+    }
+}, _Kochava_checkPersistedState = function _Kochava_checkPersistedState() {
+    __classPrivateFieldGet(this, _Kochava_instance, "f").installDone =
+        readAndUpdatePersistedValue(PersistKey.InstallSentDate, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies).length > 0;
+    __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaInstallId = readAndUpdatePersistedValue(PersistKey.InstallId, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+    __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaDeviceId = readAndUpdateDeviceId(__classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+    __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaSessionCount = readAndUpdateSessionCount(__classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+    __classPrivateFieldGet(this, _Kochava_instance, "f").utm = readAndUpdateUTM(__classPrivateFieldGet(this, _Kochava_instance, "f").appGuid, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+}, _Kochava_printStartupMsgs = function _Kochava_printStartupMsgs(appGuid) {
+    Log.diagInfo(`Started SDK ${__classPrivateFieldGet(this, _Kochava_instance, "f").version}
+      published ${__classPrivateFieldGet(this, _Kochava_instance, "f").buildDate}`);
+    Log.diagInfo(`The log level is set to ${Log.getLogLevel()}`);
+    Log.diagDebug(`This ${!__classPrivateFieldGet(this, _Kochava_instance, "f").installDone ? "is" : "is not"} the first tracker SDK launch`);
+    Log.diagDebug(`The kochava device id is ${__classPrivateFieldGet(this, _Kochava_instance, "f").kochavaDeviceId}`);
+    Log.diagDebug(`The kochava app GUID provided was ${appGuid}`);
+}, _Kochava_beginStart = function _Kochava_beginStart() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // if we need to send a new kvinit, send it
+        if (!__classPrivateFieldGet(this, _Kochava_instance, "f").kvinitDone) {
+            Log.diagDebug(`A new kvinit will be sent`);
+            yield __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_performNewKvinit).call(this);
+        }
+        else {
+            Log.diagDebug(`A new kvinit will not be sent`);
+        }
+        // if the install_id changed and thus a new install must go out
+        if (__classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_checkResendId).call(this))
+            __classPrivateFieldGet(this, _Kochava_instance, "f").installDone = false;
+        Log.diagDebug(`The install ${__classPrivateFieldGet(this, _Kochava_instance, "f").installDone ? "has already" : "has not yet"} been sent`);
+        if (__classPrivateFieldGet(this, _Kochava_instance, "f").sleep)
+            return;
+        if (!__classPrivateFieldGet(this, _Kochava_instance, "f").installDone) {
+            yield __classPrivateFieldGet(this, _Kochava_instances, "m", _Kochava_performInstall).call(this);
+        }
+        if (__classPrivateFieldGet(this, _Kochava_instance, "f").kvinitDone && __classPrivateFieldGet(this, _Kochava_instance, "f").installDone) {
+            yield __classPrivateFieldGet(this, _Kochava_jobQueue, "f").start(__classPrivateFieldGet(this, _Kochava_instance, "f"));
+        }
+    });
+}, _Kochava_performNewKvinit = function _Kochava_performNewKvinit() {
+    return __awaiter(this, void 0, void 0, function* () {
+        __classPrivateFieldGet(this, _Kochava_instance, "f").kvinitDone = yield send$1(__classPrivateFieldGet(this, _Kochava_instance, "f"), __classPrivateFieldGet(this, _Kochava_instance, "f").retryWaterfall);
+        updatePersistedValue(PersistKey.KvinitSentDate, String(getCurrTimeSec()), __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+        // if new kvinit, apply it
+        let newKvinit = {};
+        const newKvinitStr = readAndUpdatePersistedValue(PersistKey.LastKvinit, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+        if (newKvinitStr) {
+            newKvinit = JSON.parse(newKvinitStr);
+        }
+        applyKvinitResp(__classPrivateFieldGet(this, _Kochava_instance, "f"), newKvinit);
+        Log.trace("KochavaConfig after new Kvinit:", JSON.parse(JSON.stringify(__classPrivateFieldGet(this, _Kochava_instance, "f").kochavaConfig)));
+    });
+}, _Kochava_checkResendId = function _Kochava_checkResendId() {
+    let resendId = "";
+    if (__classPrivateFieldGet(this, _Kochava_instance, "f").kochavaConfig.install) {
+        resendId = __classPrivateFieldGet(this, _Kochava_instance, "f").kochavaConfig.install.resend_id;
+    }
+    const needsNewInstall = checkInstallIdChange(resendId, __classPrivateFieldGet(this, _Kochava_instance, "f").useCookies);
+    if (needsNewInstall) {
+        Log.debug(`resend_id ${resendId} found, forcing new install`);
+    }
+    return needsNewInstall;
+}, _Kochava_performInstall = function _Kochava_performInstall() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const request = build(__classPrivateFieldGet(this, _Kochava_instance, "f"));
+        __classPrivateFieldGet(this, _Kochava_instance, "f").installDone = yield send(__classPrivateFieldGet(this, _Kochava_instance, "f"), request);
+        if (!__classPrivateFieldGet(this, _Kochava_instance, "f").installDone)
+            return;
+        // If the install succeeded, remove all idLink that were passed to it
+        onSuccess(__classPrivateFieldGet(this, _Kochava_instance, "f"));
+        updatePersistedValue(PersistKey.IdLinkQueue, JSON.stringify(__classPrivateFieldGet(this, _Kochava_jobQueue, "f").idLinkQueue), false);
+    });
+};
+// Only here for generic Web integration
+window.kochava = Kochava.create();
+
+class KochavaAngularService {
+    constructor() {
+        this.kochava = Kochava.createForAngular();
+    }
+}
+KochavaAngularService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+KochavaAngularService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class KochavaAngularModule {
+    static forRoot() {
+        return {
+            ngModule: KochavaAngularModule,
+            providers: [KochavaAngularService],
+        };
+    }
+}
+KochavaAngularModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+KochavaAngularModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularModule });
+KochavaAngularModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KochavaAngularModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                }]
+        }] });
+
+/*
+ * Public API Surface of kochava-angular
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { KochavaAngularModule, KochavaAngularService };
+//# sourceMappingURL=kv-test-ang.mjs.map