beaver-logger
Version:
Client side logger.
1,044 lines (1,043 loc) • 57.6 kB
JavaScript
!function(root, factory) {
"object" == typeof exports && "object" == typeof module ? module.exports = factory() : "function" == typeof define && define.amd ? define("beaver", [], factory) : "object" == typeof exports ? exports.beaver = factory() : root.beaver = factory();
}("undefined" != typeof self ? self : this, (function() {
return function(modules) {
var installedModules = {};
function __webpack_require__(moduleId) {
if (installedModules[moduleId]) return installedModules[moduleId].exports;
var module = installedModules[moduleId] = {
i: moduleId,
l: !1,
exports: {}
};
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
module.l = !0;
return module.exports;
}
__webpack_require__.m = modules;
__webpack_require__.c = installedModules;
__webpack_require__.d = function(exports, name, getter) {
__webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {
enumerable: !0,
get: getter
});
};
__webpack_require__.r = function(exports) {
"undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
value: "Module"
});
Object.defineProperty(exports, "__esModule", {
value: !0
});
};
__webpack_require__.t = function(value, mode) {
1 & mode && (value = __webpack_require__(value));
if (8 & mode) return value;
if (4 & mode && "object" == typeof value && value && value.__esModule) return value;
var ns = Object.create(null);
__webpack_require__.r(ns);
Object.defineProperty(ns, "default", {
enumerable: !0,
value: value
});
if (2 & mode && "string" != typeof value) for (var key in value) __webpack_require__.d(ns, key, function(key) {
return value[key];
}.bind(null, key));
return ns;
};
__webpack_require__.n = function(module) {
var getter = module && module.__esModule ? function() {
return module.default;
} : function() {
return module;
};
__webpack_require__.d(getter, "a", getter);
return getter;
};
__webpack_require__.o = function(object, property) {
return {}.hasOwnProperty.call(object, property);
};
__webpack_require__.p = "";
return __webpack_require__(__webpack_require__.s = 0);
}([ function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, "Logger", (function() {
return Logger;
}));
__webpack_require__.d(__webpack_exports__, "LOG_LEVEL", (function() {
return LOG_LEVEL;
}));
__webpack_require__.d(__webpack_exports__, "PROTOCOL", (function() {
return constants_PROTOCOL;
}));
__webpack_require__.d(__webpack_exports__, "canUseSendBeacon", (function() {
return canUseSendBeacon;
}));
__webpack_require__.d(__webpack_exports__, "extendIfDefined", (function() {
return extendIfDefined;
}));
__webpack_require__.d(__webpack_exports__, "isAmplitude", (function() {
return util_isAmplitude;
}));
__webpack_require__.d(__webpack_exports__, "sendBeacon", (function() {
return sendBeacon;
}));
__webpack_require__.d(__webpack_exports__, "getHTTPTransport", (function() {
return getHTTPTransport;
}));
function _extends() {
return (_extends = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) ({}).hasOwnProperty.call(source, key) && (target[key] = source[key]);
}
return target;
}).apply(this, arguments);
}
function utils_isPromise(item) {
try {
if (!item) return !1;
if ("undefined" != typeof Promise && item instanceof Promise) return !0;
if ("undefined" != typeof window && "function" == typeof window.Window && item instanceof window.Window) return !1;
if ("undefined" != typeof window && "function" == typeof window.constructor && item instanceof window.constructor) return !1;
var _toString = {}.toString;
if (_toString) {
var name = _toString.call(item);
if ("[object Window]" === name || "[object global]" === name || "[object DOMWindow]" === name) return !1;
}
if ("function" == typeof item.then) return !0;
} catch (err) {
return !1;
}
return !1;
}
var dispatchedErrors = [];
var possiblyUnhandledPromiseHandlers = [];
var activeCount = 0;
var flushPromise;
function flushActive() {
if (!activeCount && flushPromise) {
var promise = flushPromise;
flushPromise = null;
promise.resolve();
}
}
function startActive() {
activeCount += 1;
}
function endActive() {
activeCount -= 1;
flushActive();
}
var promise_ZalgoPromise = function() {
function ZalgoPromise(handler) {
var _this = this;
this.resolved = void 0;
this.rejected = void 0;
this.errorHandled = void 0;
this.value = void 0;
this.error = void 0;
this.handlers = void 0;
this.dispatching = void 0;
this.stack = void 0;
this.resolved = !1;
this.rejected = !1;
this.errorHandled = !1;
this.handlers = [];
if (handler) {
var _result;
var _error;
var resolved = !1;
var rejected = !1;
var isAsync = !1;
startActive();
try {
handler((function(res) {
if (isAsync) _this.resolve(res); else {
resolved = !0;
_result = res;
}
}), (function(err) {
if (isAsync) _this.reject(err); else {
rejected = !0;
_error = err;
}
}));
} catch (err) {
endActive();
this.reject(err);
return;
}
endActive();
isAsync = !0;
resolved ? this.resolve(_result) : rejected && this.reject(_error);
}
}
var _proto = ZalgoPromise.prototype;
_proto.resolve = function(result) {
if (this.resolved || this.rejected) return this;
if (utils_isPromise(result)) throw new Error("Can not resolve promise with another promise");
this.resolved = !0;
this.value = result;
this.dispatch();
return this;
};
_proto.reject = function(error) {
var _this2 = this;
if (this.resolved || this.rejected) return this;
if (utils_isPromise(error)) throw new Error("Can not reject promise with another promise");
if (!error) {
var _err = error && "function" == typeof error.toString ? error.toString() : {}.toString.call(error);
error = new Error("Expected reject to be called with Error, got " + _err);
}
this.rejected = !0;
this.error = error;
this.errorHandled || setTimeout((function() {
_this2.errorHandled || function(err, promise) {
if (-1 === dispatchedErrors.indexOf(err)) {
dispatchedErrors.push(err);
setTimeout((function() {
throw err;
}), 1);
for (var j = 0; j < possiblyUnhandledPromiseHandlers.length; j++) possiblyUnhandledPromiseHandlers[j](err, promise);
}
}(error, _this2);
}), 1);
this.dispatch();
return this;
};
_proto.asyncReject = function(error) {
this.errorHandled = !0;
this.reject(error);
return this;
};
_proto.dispatch = function() {
var resolved = this.resolved, rejected = this.rejected, handlers = this.handlers;
if (!this.dispatching && (resolved || rejected)) {
this.dispatching = !0;
startActive();
var chain = function(firstPromise, secondPromise) {
return firstPromise.then((function(res) {
secondPromise.resolve(res);
}), (function(err) {
secondPromise.reject(err);
}));
};
for (var i = 0; i < handlers.length; i++) {
var _handlers$i = handlers[i], onSuccess = _handlers$i.onSuccess, onError = _handlers$i.onError, promise = _handlers$i.promise;
var _result2 = void 0;
if (resolved) try {
_result2 = onSuccess ? onSuccess(this.value) : this.value;
} catch (err) {
promise.reject(err);
continue;
} else if (rejected) {
if (!onError) {
promise.reject(this.error);
continue;
}
try {
_result2 = onError(this.error);
} catch (err) {
promise.reject(err);
continue;
}
}
if (_result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected)) {
var promiseResult = _result2;
promiseResult.resolved ? promise.resolve(promiseResult.value) : promise.reject(promiseResult.error);
promiseResult.errorHandled = !0;
} else utils_isPromise(_result2) ? _result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected) ? _result2.resolved ? promise.resolve(_result2.value) : promise.reject(_result2.error) : chain(_result2, promise) : promise.resolve(_result2);
}
handlers.length = 0;
this.dispatching = !1;
endActive();
}
};
_proto.then = function(onSuccess, onError) {
if (onSuccess && "function" != typeof onSuccess && !onSuccess.call) throw new Error("Promise.then expected a function for success handler");
if (onError && "function" != typeof onError && !onError.call) throw new Error("Promise.then expected a function for error handler");
var promise = new ZalgoPromise;
this.handlers.push({
promise: promise,
onSuccess: onSuccess,
onError: onError
});
this.errorHandled = !0;
this.dispatch();
return promise;
};
_proto.catch = function(onError) {
return this.then(void 0, onError);
};
_proto.finally = function(onFinally) {
if (onFinally && "function" != typeof onFinally && !onFinally.call) throw new Error("Promise.finally expected a function");
return this.then((function(result) {
return ZalgoPromise.try(onFinally).then((function() {
return result;
}));
}), (function(err) {
return ZalgoPromise.try(onFinally).then((function() {
throw err;
}));
}));
};
_proto.timeout = function(time, err) {
var _this3 = this;
if (this.resolved || this.rejected) return this;
var timeout = setTimeout((function() {
_this3.resolved || _this3.rejected || _this3.reject(err || new Error("Promise timed out after " + time + "ms"));
}), time);
return this.then((function(result) {
clearTimeout(timeout);
return result;
}));
};
_proto.toPromise = function() {
if ("undefined" == typeof Promise) throw new TypeError("Could not find Promise");
return Promise.resolve(this);
};
_proto.lazy = function() {
this.errorHandled = !0;
return this;
};
ZalgoPromise.resolve = function(value) {
return value instanceof ZalgoPromise ? value : utils_isPromise(value) ? new ZalgoPromise((function(resolve, reject) {
return value.then(resolve, reject);
})) : (new ZalgoPromise).resolve(value);
};
ZalgoPromise.reject = function(error) {
return (new ZalgoPromise).reject(error);
};
ZalgoPromise.asyncReject = function(error) {
return (new ZalgoPromise).asyncReject(error);
};
ZalgoPromise.all = function(promises) {
var promise = new ZalgoPromise;
var count = promises.length;
var results = [].slice();
if (!count) {
promise.resolve(results);
return promise;
}
var chain = function(i, firstPromise, secondPromise) {
return firstPromise.then((function(res) {
results[i] = res;
0 == (count -= 1) && promise.resolve(results);
}), (function(err) {
secondPromise.reject(err);
}));
};
for (var i = 0; i < promises.length; i++) {
var prom = promises[i];
if (prom instanceof ZalgoPromise) {
if (prom.resolved) {
results[i] = prom.value;
count -= 1;
continue;
}
} else if (!utils_isPromise(prom)) {
results[i] = prom;
count -= 1;
continue;
}
chain(i, ZalgoPromise.resolve(prom), promise);
}
0 === count && promise.resolve(results);
return promise;
};
ZalgoPromise.hash = function(promises) {
var result = {};
var awaitPromises = [];
var _loop = function(key) {
if (promises.hasOwnProperty(key)) {
var value = promises[key];
utils_isPromise(value) ? awaitPromises.push(value.then((function(res) {
result[key] = res;
}))) : result[key] = value;
}
};
for (var key in promises) _loop(key);
return ZalgoPromise.all(awaitPromises).then((function() {
return result;
}));
};
ZalgoPromise.map = function(items, method) {
return ZalgoPromise.all(items.map(method));
};
ZalgoPromise.onPossiblyUnhandledException = function(handler) {
return function(handler) {
possiblyUnhandledPromiseHandlers.push(handler);
return {
cancel: function() {
possiblyUnhandledPromiseHandlers.splice(possiblyUnhandledPromiseHandlers.indexOf(handler), 1);
}
};
}(handler);
};
ZalgoPromise.try = function(method, context, args) {
if (method && "function" != typeof method && !method.call) throw new Error("Promise.try expected a function");
var result;
startActive();
try {
result = method.apply(context, args || []);
} catch (err) {
endActive();
return ZalgoPromise.reject(err);
}
endActive();
return ZalgoPromise.resolve(result);
};
ZalgoPromise.delay = function(_delay) {
return new ZalgoPromise((function(resolve) {
setTimeout(resolve, _delay);
}));
};
ZalgoPromise.isPromise = function(value) {
return !!(value && value instanceof ZalgoPromise) || utils_isPromise(value);
};
ZalgoPromise.flush = function() {
return function(Zalgo) {
var promise = flushPromise = flushPromise || new Zalgo;
flushActive();
return promise;
}(ZalgoPromise);
};
return ZalgoPromise;
}();
var IE_WIN_ACCESS_ERROR = "Call was rejected by callee.\r\n";
function getActualProtocol(win) {
void 0 === win && (win = window);
return win.location.protocol;
}
function getProtocol(win) {
void 0 === win && (win = window);
if (win.mockDomain) {
var protocol = win.mockDomain.split("//")[0];
if (protocol) return protocol;
}
return getActualProtocol(win);
}
function isAboutProtocol(win) {
void 0 === win && (win = window);
return "about:" === getProtocol(win);
}
function canReadFromWindow(win) {
try {
return !0;
} catch (err) {}
return !1;
}
function getActualDomain(win) {
void 0 === win && (win = window);
var location = win.location;
if (!location) throw new Error("Can not read window location");
var protocol = getActualProtocol(win);
if (!protocol) throw new Error("Can not read window protocol");
if ("file:" === protocol) return "file://";
if ("about:" === protocol) {
var parent = function(win) {
void 0 === win && (win = window);
if (win) try {
if (win.parent && win.parent !== win) return win.parent;
} catch (err) {}
}(win);
return parent && canReadFromWindow() ? getActualDomain(parent) : "about://";
}
var host = location.host;
if (!host) throw new Error("Can not read window host");
return protocol + "//" + host;
}
function getDomain(win) {
void 0 === win && (win = window);
var domain = getActualDomain(win);
return domain && win.mockDomain && 0 === win.mockDomain.indexOf("mock:") ? win.mockDomain : domain;
}
function isSameDomain(win) {
if (!function(win) {
try {
if (win === window) return !0;
} catch (err) {}
try {
var desc = Object.getOwnPropertyDescriptor(win, "location");
if (desc && !1 === desc.enumerable) return !1;
} catch (err) {}
try {
if (isAboutProtocol(win) && canReadFromWindow()) return !0;
} catch (err) {}
try {
if (function(win) {
void 0 === win && (win = window);
return "mock:" === getProtocol(win);
}(win) && canReadFromWindow()) return !0;
} catch (err) {}
try {
if (getActualDomain(win) === getActualDomain(window)) return !0;
} catch (err) {}
return !1;
}(win)) return !1;
try {
if (win === window) return !0;
if (isAboutProtocol(win) && canReadFromWindow()) return !0;
if (getDomain(window) === getDomain(win)) return !0;
} catch (err) {}
return !1;
}
var iframeWindows = [];
var iframeFrames = [];
function isWindowClosed(win, allowMock) {
void 0 === allowMock && (allowMock = !0);
try {
if (win === window) return !1;
} catch (err) {
return !0;
}
try {
if (!win) return !0;
} catch (err) {
return !0;
}
try {
if (win.closed) return !0;
} catch (err) {
return !err || err.message !== IE_WIN_ACCESS_ERROR;
}
if (allowMock && isSameDomain(win)) try {
if (win.mockclosed) return !0;
} catch (err) {}
try {
if (!win.parent || !win.top) return !0;
} catch (err) {}
var iframeIndex = function(collection, item) {
for (var i = 0; i < collection.length; i++) try {
if (collection[i] === item) return i;
} catch (err) {}
return -1;
}(iframeWindows, win);
if (-1 !== iframeIndex) {
var frame = iframeFrames[iframeIndex];
if (frame && function(frame) {
if (!frame.contentWindow) return !0;
if (!frame.parentNode) return !0;
var doc = frame.ownerDocument;
if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {
var parent = frame;
for (;parent.parentNode && parent.parentNode !== parent; ) parent = parent.parentNode;
if (!parent.host || !doc.documentElement.contains(parent.host)) return !0;
}
return !1;
}(frame)) return !0;
}
return !1;
}
function isWindow(obj) {
try {
if (obj === window) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if ("[object Window]" === {}.toString.call(obj)) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (window.Window && obj instanceof window.Window) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && obj.self === obj) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && obj.parent === obj) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && obj.top === obj) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && "__unlikely_value__" === obj.__cross_domain_utils_window_check__) return !1;
} catch (err) {
return !0;
}
try {
if ("postMessage" in obj && "self" in obj && "location" in obj) return !0;
} catch (err) {}
return !1;
}
function util_safeIndexOf(collection, item) {
for (var i = 0; i < collection.length; i++) try {
if (collection[i] === item) return i;
} catch (err) {}
return -1;
}
var weakmap_CrossDomainSafeWeakMap = function() {
function CrossDomainSafeWeakMap() {
this.name = void 0;
this.weakmap = void 0;
this.keys = void 0;
this.values = void 0;
this.name = "__weakmap_" + (1e9 * Math.random() >>> 0) + "__";
if (function() {
if ("undefined" == typeof WeakMap) return !1;
if (void 0 === Object.freeze) return !1;
try {
var testWeakMap = new WeakMap;
var testKey = {};
Object.freeze(testKey);
testWeakMap.set(testKey, "__testvalue__");
return "__testvalue__" === testWeakMap.get(testKey);
} catch (err) {
return !1;
}
}()) try {
this.weakmap = new WeakMap;
} catch (err) {}
this.keys = [];
this.values = [];
}
var _proto = CrossDomainSafeWeakMap.prototype;
_proto._cleanupClosedWindows = function() {
var weakmap = this.weakmap;
var keys = this.keys;
for (var i = 0; i < keys.length; i++) {
var value = keys[i];
if (isWindow(value) && isWindowClosed(value)) {
if (weakmap) try {
weakmap.delete(value);
} catch (err) {}
keys.splice(i, 1);
this.values.splice(i, 1);
i -= 1;
}
}
};
_proto.isSafeToReadWrite = function(key) {
return !isWindow(key);
};
_proto.set = function(key, value) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
weakmap.set(key, value);
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) try {
var name = this.name;
var entry = key[name];
entry && entry[0] === key ? entry[1] = value : Object.defineProperty(key, name, {
value: [ key, value ],
writable: !0
});
return;
} catch (err) {}
this._cleanupClosedWindows();
var keys = this.keys;
var values = this.values;
var index = util_safeIndexOf(keys, key);
if (-1 === index) {
keys.push(key);
values.push(value);
} else values[index] = value;
};
_proto.get = function(key) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
if (weakmap.has(key)) return weakmap.get(key);
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) try {
var entry = key[this.name];
return entry && entry[0] === key ? entry[1] : void 0;
} catch (err) {}
this._cleanupClosedWindows();
var index = util_safeIndexOf(this.keys, key);
if (-1 !== index) return this.values[index];
};
_proto.delete = function(key) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
weakmap.delete(key);
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) try {
var entry = key[this.name];
entry && entry[0] === key && (entry[0] = entry[1] = void 0);
} catch (err) {}
this._cleanupClosedWindows();
var keys = this.keys;
var index = util_safeIndexOf(keys, key);
if (-1 !== index) {
keys.splice(index, 1);
this.values.splice(index, 1);
}
};
_proto.has = function(key) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
if (weakmap.has(key)) return !0;
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) try {
var entry = key[this.name];
return !(!entry || entry[0] !== key);
} catch (err) {}
this._cleanupClosedWindows();
return -1 !== util_safeIndexOf(this.keys, key);
};
_proto.getOrSet = function(key, getter) {
if (this.has(key)) return this.get(key);
var value = getter();
this.set(key, value);
return value;
};
return CrossDomainSafeWeakMap;
}();
function getFunctionName(fn) {
return fn.name || fn.__name__ || fn.displayName || "anonymous";
}
function setFunctionName(fn, name) {
try {
delete fn.name;
fn.name = name;
} catch (err) {}
fn.__name__ = fn.displayName = name;
return fn;
}
function uniqueID() {
var chars = "0123456789abcdef";
return "uid_" + "xxxxxxxxxx".replace(/./g, (function() {
return chars.charAt(Math.floor(Math.random() * chars.length));
})) + "_" + function(str) {
if ("function" == typeof btoa) return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (function(m, p1) {
return String.fromCharCode(parseInt(p1, 16));
}))).replace(/[=]/g, "");
if ("undefined" != typeof Buffer) return Buffer.from(str, "utf8").toString("base64").replace(/[=]/g, "");
throw new Error("Can not find window.btoa or Buffer");
}((new Date).toISOString().slice(11, 19).replace("T", ".")).replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
}
var objectIDs;
function serializeArgs(args) {
try {
return JSON.stringify([].slice.call(args), (function(subkey, val) {
return "function" == typeof val ? "memoize[" + function(obj) {
objectIDs = objectIDs || new weakmap_CrossDomainSafeWeakMap;
if (null == obj || "object" != typeof obj && "function" != typeof obj) throw new Error("Invalid object");
var uid = objectIDs.get(obj);
if (!uid) {
uid = typeof obj + ":" + uniqueID();
objectIDs.set(obj, uid);
}
return uid;
}(val) + "]" : function(element) {
var passed = !1;
try {
(element instanceof window.Element || null !== element && "object" == typeof element && 1 === element.nodeType && "object" == typeof element.style && "object" == typeof element.ownerDocument) && (passed = !0);
} catch (_) {}
return passed;
}(val) ? {} : val;
}));
} catch (err) {
throw new Error("Arguments not serializable -- can not be used to memoize");
}
}
function getEmptyObject() {
return {};
}
var memoizeGlobalIndex = 0;
var memoizeGlobalIndexValidFrom = 0;
function memoize(method, options) {
void 0 === options && (options = {});
var _options$thisNamespac = options.thisNamespace, thisNamespace = void 0 !== _options$thisNamespac && _options$thisNamespac, cacheTime = options.time;
var simpleCache;
var thisCache;
var memoizeIndex = memoizeGlobalIndex;
memoizeGlobalIndex += 1;
var memoizedFunction = function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
if (memoizeIndex < memoizeGlobalIndexValidFrom) {
simpleCache = null;
thisCache = null;
memoizeIndex = memoizeGlobalIndex;
memoizeGlobalIndex += 1;
}
var cache;
cache = thisNamespace ? (thisCache = thisCache || new weakmap_CrossDomainSafeWeakMap).getOrSet(this, getEmptyObject) : simpleCache = simpleCache || {};
var cacheKey;
try {
cacheKey = serializeArgs(args);
} catch (_unused) {
return method.apply(this, arguments);
}
var cacheResult = cache[cacheKey];
if (cacheResult && cacheTime && Date.now() - cacheResult.time < cacheTime) {
delete cache[cacheKey];
cacheResult = null;
}
if (cacheResult) return cacheResult.value;
var time = Date.now();
var value = method.apply(this, arguments);
cache[cacheKey] = {
time: time,
value: value
};
return value;
};
memoizedFunction.reset = function() {
simpleCache = null;
thisCache = null;
};
return setFunctionName(memoizedFunction, (options.name || getFunctionName(method)) + "::memoized");
}
memoize.clear = function() {
memoizeGlobalIndexValidFrom = memoizeGlobalIndex;
};
function src_util_noop() {}
memoize((function(obj) {
if (Object.values) return Object.values(obj);
var result = [];
for (var key in obj) obj.hasOwnProperty(key) && result.push(obj[key]);
return result;
}));
function objFilter(obj, filter) {
void 0 === filter && (filter = Boolean);
var result = {};
for (var key in obj) obj.hasOwnProperty(key) && filter(obj[key], key) && (result[key] = obj[key]);
return result;
}
Error;
function isDocumentReady() {
return Boolean(document.body) && "complete" === document.readyState;
}
function isDocumentInteractive() {
return Boolean(document.body) && "interactive" === document.readyState;
}
memoize((function() {
return new promise_ZalgoPromise((function(resolve) {
if (isDocumentReady() || isDocumentInteractive()) return resolve();
var interval = setInterval((function() {
if (isDocumentReady() || isDocumentInteractive()) {
clearInterval(interval);
return resolve();
}
}), 10);
}));
}));
function dom_isBrowser() {
return "undefined" != typeof window && void 0 !== window.location;
}
var currentScript = "undefined" != typeof document ? document.currentScript : null;
var getCurrentScript = memoize((function() {
if (currentScript) return currentScript;
if (currentScript = function() {
try {
var stack = function() {
try {
throw new Error("_");
} catch (err) {
return err.stack || "";
}
}();
var stackDetails = /.*at [^(]*\((.*):(.+):(.+)\)$/gi.exec(stack);
var scriptLocation = stackDetails && stackDetails[1];
if (!scriptLocation) return;
for (var _i22 = 0, _Array$prototype$slic2 = [].slice.call(document.getElementsByTagName("script")).reverse(); _i22 < _Array$prototype$slic2.length; _i22++) {
var script = _Array$prototype$slic2[_i22];
if (script.src && script.src === scriptLocation) return script;
}
} catch (err) {}
}()) return currentScript;
throw new Error("Can not determine current script");
}));
var currentUID = uniqueID();
memoize((function() {
var script;
try {
script = getCurrentScript();
} catch (err) {
return currentUID;
}
var uid = script.getAttribute("data-uid");
if (uid && "string" == typeof uid) return uid;
if ((uid = script.getAttribute("data-uid-auto")) && "string" == typeof uid) return uid;
if (script.src) {
var hashedString = function(str) {
var hash = "";
for (var i = 0; i < str.length; i++) {
var total = str[i].charCodeAt(0) * i;
str[i + 1] && (total += str[i + 1].charCodeAt(0) * (i - 1));
hash += String.fromCharCode(97 + Math.abs(total) % 26);
}
return hash;
}(JSON.stringify({
src: script.src,
dataset: script.dataset
}));
uid = "uid_" + hashedString.slice(hashedString.length - 30);
} else uid = uniqueID();
script.setAttribute("data-uid-auto", uid);
return uid;
}));
var http_headerBuilders = [];
var LOG_LEVEL = {
DEBUG: "debug",
INFO: "info",
WARN: "warn",
ERROR: "error"
};
var constants_PROTOCOL = {
FILE: "file:"
};
var AUTO_FLUSH_LEVEL = [ LOG_LEVEL.WARN, LOG_LEVEL.ERROR ];
var LOG_LEVEL_PRIORITY = [ LOG_LEVEL.ERROR, LOG_LEVEL.WARN, LOG_LEVEL.INFO, LOG_LEVEL.DEBUG ];
var DEFAULT_LOG_LEVEL = LOG_LEVEL.WARN;
var canUseSendBeacon = function(_ref) {
var headers = _ref.headers, enableSendBeacon = _ref.enableSendBeacon;
var hasHeaders = headers && Object.keys(headers).length;
return !!(window && window.navigator.sendBeacon && !hasHeaders && enableSendBeacon && window.Blob);
};
var util_isAmplitude = function(url) {
return "https://api2.amplitude.com/2/httpapi" === url;
};
var sendBeacon = function(_ref2) {
var _ref2$win = _ref2.win, win = void 0 === _ref2$win ? window : _ref2$win, url = _ref2.url, data = _ref2.data, _ref2$useBlob = _ref2.useBlob, useBlob = void 0 === _ref2$useBlob || _ref2$useBlob;
try {
var json = JSON.stringify(data);
if (!win.navigator.sendBeacon) throw new Error("No sendBeacon available");
if (useBlob) {
var blob = new Blob([ json ], {
type: "application/json"
});
return win.navigator.sendBeacon(url, blob);
}
return win.navigator.sendBeacon(url, json);
} catch (e) {
return !1;
}
};
var extendIfDefined = function(target, source) {
for (var key in source) source.hasOwnProperty(key) && (target[key] = source[key]);
};
function getHTTPTransport(httpWin) {
void 0 === httpWin && (httpWin = window);
var win = isSameDomain(httpWin) ? function(win) {
if (!isSameDomain(win)) throw new Error("Expected window to be same domain");
return win;
}(httpWin) : window;
return function(_ref) {
var url = _ref.url, method = _ref.method, headers = _ref.headers, json = _ref.json, _ref$enableSendBeacon = _ref.enableSendBeacon, enableSendBeacon = void 0 !== _ref$enableSendBeacon && _ref$enableSendBeacon;
return promise_ZalgoPromise.try((function() {
var beaconResult = !1;
canUseSendBeacon({
headers: headers,
enableSendBeacon: enableSendBeacon
}) && (beaconResult = util_isAmplitude(url) ? sendBeacon({
win: win,
url: url,
data: json,
useBlob: !1
}) : sendBeacon({
win: win,
url: url,
data: json,
useBlob: !0
}));
return beaconResult || function(_ref) {
var url = _ref.url, _ref$method = _ref.method, method = void 0 === _ref$method ? "get" : _ref$method, _ref$headers = _ref.headers, headers = void 0 === _ref$headers ? {} : _ref$headers, json = _ref.json, data = _ref.data, body = _ref.body, _ref$win = _ref.win, win = void 0 === _ref$win ? window : _ref$win, _ref$timeout = _ref.timeout, timeout = void 0 === _ref$timeout ? 0 : _ref$timeout;
return new promise_ZalgoPromise((function(resolve, reject) {
if (json && data || json && body || data && json) throw new Error("Only options.json or options.data or options.body should be passed");
var normalizedHeaders = {};
for (var _i4 = 0, _Object$keys2 = Object.keys(headers); _i4 < _Object$keys2.length; _i4++) {
var _key2 = _Object$keys2[_i4];
normalizedHeaders[_key2.toLowerCase()] = headers[_key2];
}
json ? normalizedHeaders["content-type"] = normalizedHeaders["content-type"] || "application/json" : (data || body) && (normalizedHeaders["content-type"] = normalizedHeaders["content-type"] || "application/x-www-form-urlencoded; charset=utf-8");
normalizedHeaders.accept = normalizedHeaders.accept || "application/json";
for (var _i6 = 0; _i6 < http_headerBuilders.length; _i6++) {
var builtHeaders = (0, http_headerBuilders[_i6])();
for (var _i8 = 0, _Object$keys4 = Object.keys(builtHeaders); _i8 < _Object$keys4.length; _i8++) {
var _key3 = _Object$keys4[_i8];
normalizedHeaders[_key3.toLowerCase()] = builtHeaders[_key3];
}
}
var xhr = new win.XMLHttpRequest;
xhr.addEventListener("load", (function() {
var responseHeaders = function(rawHeaders) {
void 0 === rawHeaders && (rawHeaders = "");
var result = {};
for (var _i2 = 0, _rawHeaders$trim$spli2 = rawHeaders.trim().split("\n"); _i2 < _rawHeaders$trim$spli2.length; _i2++) {
var _line$split = _rawHeaders$trim$spli2[_i2].split(":"), _key = _line$split[0], values = _line$split.slice(1);
result[_key.toLowerCase()] = values.join(":").trim();
}
return result;
}(this.getAllResponseHeaders());
if (!this.status) return reject(new Error("Request to " + method.toLowerCase() + " " + url + " failed: no response status code."));
var contentType = responseHeaders["content-type"];
var isJSON = contentType && (0 === contentType.indexOf("application/json") || 0 === contentType.indexOf("text/json"));
var responseBody = this.responseText;
try {
responseBody = JSON.parse(responseBody);
} catch (err) {
if (isJSON) return reject(new Error("Invalid json: " + this.responseText + "."));
}
return resolve({
status: this.status,
headers: responseHeaders,
body: responseBody
});
}), !1);
xhr.addEventListener("error", (function(evt) {
reject(new Error("Request to " + method.toLowerCase() + " " + url + " failed: " + evt.toString() + "."));
}), !1);
xhr.open(method, url, !0);
for (var _key4 in normalizedHeaders) normalizedHeaders.hasOwnProperty(_key4) && xhr.setRequestHeader(_key4, normalizedHeaders[_key4]);
json ? body = JSON.stringify(json) : data && (body = Object.keys(data).map((function(key) {
return encodeURIComponent(key) + "=" + (data ? encodeURIComponent(data[key]) : "");
})).join("&"));
xhr.timeout = timeout;
xhr.ontimeout = function() {
reject(new Error("Request to " + method.toLowerCase() + " " + url + " has timed out"));
};
xhr.send(body);
}));
}({
win: win,
url: url,
method: method,
headers: headers,
json: json
});
})).then(src_util_noop);
};
}
function Logger(_ref) {
var url = _ref.url, prefix = _ref.prefix, _ref$logLevel = _ref.logLevel, logLevel = void 0 === _ref$logLevel ? DEFAULT_LOG_LEVEL : _ref$logLevel, _ref$transport = _ref.transport, transport = void 0 === _ref$transport ? getHTTPTransport() : _ref$transport, amplitudeApiKey = _ref.amplitudeApiKey, _ref$flushInterval = _ref.flushInterval, flushInterval = void 0 === _ref$flushInterval ? 6e4 : _ref$flushInterval, _ref$enableSendBeacon = _ref.enableSendBeacon, enableSendBeacon = void 0 !== _ref$enableSendBeacon && _ref$enableSendBeacon;
var events = [];
var tracking = [];
var payloadBuilders = [];
var metaBuilders = [];
var trackingBuilders = [];
var headerBuilders = [];
function print(level, event, payload) {
if (dom_isBrowser() && window.console && window.console.log && !(LOG_LEVEL_PRIORITY.indexOf(level) > LOG_LEVEL_PRIORITY.indexOf(logLevel))) {
var args = [ event ];
args.push(payload);
(payload.error || payload.warning) && args.push("\n\n", payload.error || payload.warning);
try {
window.console[level] && window.console[level].apply ? window.console[level].apply(window.console, args) : window.console.log && window.console.log.apply && window.console.log.apply(window.console, args);
} catch (err) {}
}