ba-js-tracker
Version:
1,551 lines • 54.1 kB
JavaScript
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
var js_cookie = { exports: {} };
/*!
* JavaScript Cookie v2.2.1
* https://github.com/js-cookie/js-cookie
*
* Copyright 2006, 2015 Klaus Hartl & Fagner Brack
* Released under the MIT license
*/
(function(module, exports) {
(function(factory) {
var registeredInModuleLoader;
{
module.exports = factory();
registeredInModuleLoader = true;
}
if (!registeredInModuleLoader) {
var OldCookies = window.Cookies;
var api = window.Cookies = factory();
api.noConflict = function() {
window.Cookies = OldCookies;
return api;
};
}
})(function() {
function extend() {
var i = 0;
var result = {};
for (; i < arguments.length; i++) {
var attributes = arguments[i];
for (var key in attributes) {
result[key] = attributes[key];
}
}
return result;
}
function decode2(s) {
return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);
}
function init(converter) {
function api() {
}
function set(key, value, attributes) {
if (typeof document === "undefined") {
return;
}
attributes = extend({
path: "/"
}, api.defaults, attributes);
if (typeof attributes.expires === "number") {
attributes.expires = new Date(new Date() * 1 + attributes.expires * 864e5);
}
attributes.expires = attributes.expires ? attributes.expires.toUTCString() : "";
try {
var result = JSON.stringify(value);
if (/^[\{\[]/.test(result)) {
value = result;
}
} catch (e) {
}
value = converter.write ? converter.write(value, key) : encodeURIComponent(String(value)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);
key = encodeURIComponent(String(key)).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent).replace(/[\(\)]/g, escape);
var stringifiedAttributes = "";
for (var attributeName in attributes) {
if (!attributes[attributeName]) {
continue;
}
stringifiedAttributes += "; " + attributeName;
if (attributes[attributeName] === true) {
continue;
}
stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
}
return document.cookie = key + "=" + value + stringifiedAttributes;
}
function get(key, json) {
if (typeof document === "undefined") {
return;
}
var jar = {};
var cookies = document.cookie ? document.cookie.split("; ") : [];
var i = 0;
for (; i < cookies.length; i++) {
var parts = cookies[i].split("=");
var cookie = parts.slice(1).join("=");
if (!json && cookie.charAt(0) === '"') {
cookie = cookie.slice(1, -1);
}
try {
var name = decode2(parts[0]);
cookie = (converter.read || converter)(cookie, name) || decode2(cookie);
if (json) {
try {
cookie = JSON.parse(cookie);
} catch (e) {
}
}
jar[name] = cookie;
if (key === name) {
break;
}
} catch (e) {
}
}
return key ? jar[key] : jar;
}
api.set = set;
api.get = function(key) {
return get(key, false);
};
api.getJSON = function(key) {
return get(key, true);
};
api.remove = function(key, attributes) {
set(key, "", extend(attributes, {
expires: -1
}));
};
api.defaults = {};
api.withConverter = init;
return api;
}
return init(function() {
});
});
})(js_cookie);
var Cookies = js_cookie.exports;
var rngBrowser = { exports: {} };
var getRandomValues = typeof crypto != "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto != "undefined" && typeof window.msCrypto.getRandomValues == "function" && msCrypto.getRandomValues.bind(msCrypto);
if (getRandomValues) {
var rnds8 = new Uint8Array(16);
rngBrowser.exports = function whatwgRNG() {
getRandomValues(rnds8);
return rnds8;
};
} else {
var rnds = new Array(16);
rngBrowser.exports = function mathRNG() {
for (var i = 0, r; i < 16; i++) {
if ((i & 3) === 0)
r = Math.random() * 4294967296;
rnds[i] = r >>> ((i & 3) << 3) & 255;
}
return rnds;
};
}
var byteToHex = [];
for (var i = 0; i < 256; ++i) {
byteToHex[i] = (i + 256).toString(16).substr(1);
}
function bytesToUuid$1(buf, offset) {
var i = offset || 0;
var bth = byteToHex;
return [
bth[buf[i++]],
bth[buf[i++]],
bth[buf[i++]],
bth[buf[i++]],
"-",
bth[buf[i++]],
bth[buf[i++]],
"-",
bth[buf[i++]],
bth[buf[i++]],
"-",
bth[buf[i++]],
bth[buf[i++]],
"-",
bth[buf[i++]],
bth[buf[i++]],
bth[buf[i++]],
bth[buf[i++]],
bth[buf[i++]],
bth[buf[i++]]
].join("");
}
var bytesToUuid_1 = bytesToUuid$1;
var rng = rngBrowser.exports;
var bytesToUuid = bytesToUuid_1;
function v4(options, buf, offset) {
var i = buf && offset || 0;
if (typeof options == "string") {
buf = options === "binary" ? new Array(16) : null;
options = null;
}
options = options || {};
var rnds = options.random || (options.rng || rng)();
rnds[6] = rnds[6] & 15 | 64;
rnds[8] = rnds[8] & 63 | 128;
if (buf) {
for (var ii = 0; ii < 16; ++ii) {
buf[i + ii] = rnds[ii];
}
}
return buf || bytesToUuid(rnds);
}
var v4_1 = v4;
var queryString = {};
var strictUriEncode = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
var token = "%[a-f0-9]{2}";
var singleMatcher = new RegExp(token, "gi");
var multiMatcher = new RegExp("(" + token + ")+", "gi");
function decodeComponents(components, split) {
try {
return decodeURIComponent(components.join(""));
} catch (err) {
}
if (components.length === 1) {
return components;
}
split = split || 1;
var left = components.slice(0, split);
var right = components.slice(split);
return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
}
function decode(input) {
try {
return decodeURIComponent(input);
} catch (err) {
var tokens = input.match(singleMatcher);
for (var i = 1; i < tokens.length; i++) {
input = decodeComponents(tokens, i).join("");
tokens = input.match(singleMatcher);
}
return input;
}
}
function customDecodeURIComponent(input) {
var replaceMap = {
"%FE%FF": "\uFFFD\uFFFD",
"%FF%FE": "\uFFFD\uFFFD"
};
var match = multiMatcher.exec(input);
while (match) {
try {
replaceMap[match[0]] = decodeURIComponent(match[0]);
} catch (err) {
var result = decode(match[0]);
if (result !== match[0]) {
replaceMap[match[0]] = result;
}
}
match = multiMatcher.exec(input);
}
replaceMap["%C2"] = "\uFFFD";
var entries = Object.keys(replaceMap);
for (var i = 0; i < entries.length; i++) {
var key = entries[i];
input = input.replace(new RegExp(key, "g"), replaceMap[key]);
}
return input;
}
var decodeUriComponent = function(encodedURI) {
if (typeof encodedURI !== "string") {
throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
}
try {
encodedURI = encodedURI.replace(/\+/g, " ");
return decodeURIComponent(encodedURI);
} catch (err) {
return customDecodeURIComponent(encodedURI);
}
};
var splitOnFirst = (string, separator) => {
if (!(typeof string === "string" && typeof separator === "string")) {
throw new TypeError("Expected the arguments to be of type `string`");
}
if (separator === "") {
return [string];
}
const separatorIndex = string.indexOf(separator);
if (separatorIndex === -1) {
return [string];
}
return [
string.slice(0, separatorIndex),
string.slice(separatorIndex + separator.length)
];
};
var filterObj = function(obj, predicate) {
var ret = {};
var keys = Object.keys(obj);
var isArr = Array.isArray(predicate);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var val = obj[key];
if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
ret[key] = val;
}
}
return ret;
};
(function(exports) {
const strictUriEncode$1 = strictUriEncode;
const decodeComponent = decodeUriComponent;
const splitOnFirst$1 = splitOnFirst;
const filterObject = filterObj;
const isNullOrUndefined = (value) => value === null || value === void 0;
const encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
function encoderForArrayFormat(options) {
switch (options.arrayFormat) {
case "index":
return (key) => (result, value) => {
const index = result.length;
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, [encode(key, options), "[", index, "]"].join("")];
}
return [
...result,
[encode(key, options), "[", encode(index, options), "]=", encode(value, options)].join("")
];
};
case "bracket":
return (key) => (result, value) => {
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, [encode(key, options), "[]"].join("")];
}
return [...result, [encode(key, options), "[]=", encode(value, options)].join("")];
};
case "colon-list-separator":
return (key) => (result, value) => {
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, [encode(key, options), ":list="].join("")];
}
return [...result, [encode(key, options), ":list=", encode(value, options)].join("")];
};
case "comma":
case "separator":
case "bracket-separator": {
const keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
return (key) => (result, value) => {
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
value = value === null ? "" : value;
if (result.length === 0) {
return [[encode(key, options), keyValueSep, encode(value, options)].join("")];
}
return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
};
}
default:
return (key) => (result, value) => {
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, encode(key, options)];
}
return [...result, [encode(key, options), "=", encode(value, options)].join("")];
};
}
}
function parserForArrayFormat(options) {
let result;
switch (options.arrayFormat) {
case "index":
return (key, value, accumulator) => {
result = /\[(\d*)\]$/.exec(key);
key = key.replace(/\[\d*\]$/, "");
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === void 0) {
accumulator[key] = {};
}
accumulator[key][result[1]] = value;
};
case "bracket":
return (key, value, accumulator) => {
result = /(\[\])$/.exec(key);
key = key.replace(/\[\]$/, "");
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === void 0) {
accumulator[key] = [value];
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
case "colon-list-separator":
return (key, value, accumulator) => {
result = /(:list)$/.exec(key);
key = key.replace(/:list$/, "");
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === void 0) {
accumulator[key] = [value];
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
case "comma":
case "separator":
return (key, value, accumulator) => {
const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
const isEncodedArray = typeof value === "string" && !isArray && decode2(value, options).includes(options.arrayFormatSeparator);
value = isEncodedArray ? decode2(value, options) : value;
const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode2(item, options)) : value === null ? value : decode2(value, options);
accumulator[key] = newValue;
};
case "bracket-separator":
return (key, value, accumulator) => {
const isArray = /(\[\])$/.test(key);
key = key.replace(/\[\]$/, "");
if (!isArray) {
accumulator[key] = value ? decode2(value, options) : value;
return;
}
const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map((item) => decode2(item, options));
if (accumulator[key] === void 0) {
accumulator[key] = arrayValue;
return;
}
accumulator[key] = [].concat(accumulator[key], arrayValue);
};
default:
return (key, value, accumulator) => {
if (accumulator[key] === void 0) {
accumulator[key] = value;
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
}
}
function validateArrayFormatSeparator(value) {
if (typeof value !== "string" || value.length !== 1) {
throw new TypeError("arrayFormatSeparator must be single character string");
}
}
function encode(value, options) {
if (options.encode) {
return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
}
return value;
}
function decode2(value, options) {
if (options.decode) {
return decodeComponent(value);
}
return value;
}
function keysSorter(input) {
if (Array.isArray(input)) {
return input.sort();
}
if (typeof input === "object") {
return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
}
return input;
}
function removeHash(input) {
const hashStart = input.indexOf("#");
if (hashStart !== -1) {
input = input.slice(0, hashStart);
}
return input;
}
function getHash(url) {
let hash = "";
const hashStart = url.indexOf("#");
if (hashStart !== -1) {
hash = url.slice(hashStart);
}
return hash;
}
function extract(input) {
input = removeHash(input);
const queryStart = input.indexOf("?");
if (queryStart === -1) {
return "";
}
return input.slice(queryStart + 1);
}
function parseValue(value, options) {
if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
value = Number(value);
} else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
value = value.toLowerCase() === "true";
}
return value;
}
function parse(query, options) {
options = Object.assign({
decode: true,
sort: true,
arrayFormat: "none",
arrayFormatSeparator: ",",
parseNumbers: false,
parseBooleans: false
}, options);
validateArrayFormatSeparator(options.arrayFormatSeparator);
const formatter = parserForArrayFormat(options);
const ret = /* @__PURE__ */ Object.create(null);
if (typeof query !== "string") {
return ret;
}
query = query.trim().replace(/^[?#&]/, "");
if (!query) {
return ret;
}
for (const param of query.split("&")) {
if (param === "") {
continue;
}
let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, " ") : param, "=");
value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode2(value, options);
formatter(decode2(key, options), value, ret);
}
for (const key of Object.keys(ret)) {
const value = ret[key];
if (typeof value === "object" && value !== null) {
for (const k of Object.keys(value)) {
value[k] = parseValue(value[k], options);
}
} else {
ret[key] = parseValue(value, options);
}
}
if (options.sort === false) {
return ret;
}
return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
const value = ret[key];
if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
result[key] = keysSorter(value);
} else {
result[key] = value;
}
return result;
}, /* @__PURE__ */ Object.create(null));
}
exports.extract = extract;
exports.parse = parse;
exports.stringify = (object, options) => {
if (!object) {
return "";
}
options = Object.assign({
encode: true,
strict: true,
arrayFormat: "none",
arrayFormatSeparator: ","
}, options);
validateArrayFormatSeparator(options.arrayFormatSeparator);
const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
const formatter = encoderForArrayFormat(options);
const objectCopy = {};
for (const key of Object.keys(object)) {
if (!shouldFilter(key)) {
objectCopy[key] = object[key];
}
}
const keys = Object.keys(objectCopy);
if (options.sort !== false) {
keys.sort(options.sort);
}
return keys.map((key) => {
const value = object[key];
if (value === void 0) {
return "";
}
if (value === null) {
return encode(key, options);
}
if (Array.isArray(value)) {
if (value.length === 0 && options.arrayFormat === "bracket-separator") {
return encode(key, options) + "[]";
}
return value.reduce(formatter(key), []).join("&");
}
return encode(key, options) + "=" + encode(value, options);
}).filter((x) => x.length > 0).join("&");
};
exports.parseUrl = (url, options) => {
options = Object.assign({
decode: true
}, options);
const [url_, hash] = splitOnFirst$1(url, "#");
return Object.assign({
url: url_.split("?")[0] || "",
query: parse(extract(url), options)
}, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode2(hash, options) } : {});
};
exports.stringifyUrl = (object, options) => {
options = Object.assign({
encode: true,
strict: true,
[encodeFragmentIdentifier]: true
}, options);
const url = removeHash(object.url).split("?")[0] || "";
const queryFromUrl = exports.extract(object.url);
const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
const query = Object.assign(parsedQueryFromUrl, object.query);
let queryString2 = exports.stringify(query, options);
if (queryString2) {
queryString2 = `?${queryString2}`;
}
let hash = getHash(object.url);
if (object.fragmentIdentifier) {
hash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
}
return `${url}${queryString2}${hash}`;
};
exports.pick = (input, filter, options) => {
options = Object.assign({
parseFragmentIdentifier: true,
[encodeFragmentIdentifier]: false
}, options);
const { url, query, fragmentIdentifier } = exports.parseUrl(input, options);
return exports.stringifyUrl({
url,
query: filterObject(query, filter),
fragmentIdentifier
}, options);
};
exports.exclude = (input, filter, options) => {
const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
return exports.pick(input, exclusionFilter, options);
};
})(queryString);
var isMergeableObject = function isMergeableObject2(value) {
return isNonNullObject(value) && !isSpecial(value);
};
function isNonNullObject(value) {
return !!value && typeof value === "object";
}
function isSpecial(value) {
var stringValue = Object.prototype.toString.call(value);
return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
}
var canUseSymbol = typeof Symbol === "function" && Symbol.for;
var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
function isReactElement(value) {
return value.$$typeof === REACT_ELEMENT_TYPE;
}
function emptyTarget(val) {
return Array.isArray(val) ? [] : {};
}
function cloneUnlessOtherwiseSpecified(value, options) {
return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
}
function defaultArrayMerge(target, source, options) {
return target.concat(source).map(function(element) {
return cloneUnlessOtherwiseSpecified(element, options);
});
}
function getMergeFunction(key, options) {
if (!options.customMerge) {
return deepmerge;
}
var customMerge = options.customMerge(key);
return typeof customMerge === "function" ? customMerge : deepmerge;
}
function getEnumerableOwnPropertySymbols(target) {
return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
return target.propertyIsEnumerable(symbol);
}) : [];
}
function getKeys(target) {
return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
}
function propertyIsOnObject(object, property) {
try {
return property in object;
} catch (_) {
return false;
}
}
function propertyIsUnsafe(target, key) {
return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
}
function mergeObject(target, source, options) {
var destination = {};
if (options.isMergeableObject(target)) {
getKeys(target).forEach(function(key) {
destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
});
}
getKeys(source).forEach(function(key) {
if (propertyIsUnsafe(target, key)) {
return;
}
if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
} else {
destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
}
});
return destination;
}
function deepmerge(target, source, options) {
options = options || {};
options.arrayMerge = options.arrayMerge || defaultArrayMerge;
options.isMergeableObject = options.isMergeableObject || isMergeableObject;
options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
var sourceIsArray = Array.isArray(source);
var targetIsArray = Array.isArray(target);
var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
if (!sourceAndTargetTypesMatch) {
return cloneUnlessOtherwiseSpecified(source, options);
} else if (sourceIsArray) {
return options.arrayMerge(target, source, options);
} else {
return mergeObject(target, source, options);
}
}
deepmerge.all = function deepmergeAll(array, options) {
if (!Array.isArray(array)) {
throw new Error("first argument should be an array");
}
return array.reduce(function(prev, next) {
return deepmerge(prev, next, options);
}, {});
};
var deepmerge_1 = deepmerge;
var cjs = deepmerge_1;
function pickBy(object = {}, predicate) {
const obj = {};
if (typeof predicate === "function") {
for (const key in object) {
const value = object[key];
if (predicate(value, key)) {
obj[key] = value;
}
}
}
return obj;
}
const baAnalyticsServer = "https://yofu4i8sfe.execute-api.eu-west-1.amazonaws.com";
const { hostname } = window.location || {};
if (/^mbe-test2\./.test(hostname))
;
else if (/^mbe-livetest\./.test(hostname))
;
else if (/^mbe-qatesting\./.test(hostname))
;
else if (/^static-qatesting\./.test(hostname))
;
else if (/^demo\./.test(hostname))
;
else if (/^mbe-demo\./.test(hostname))
;
else if (/^static\./.test(hostname))
;
else if (/^localhost\b/.test(hostname))
;
else if (/^(\d+\.)+\b/.test(hostname))
;
const BA_ANALYTICS_SERVER = `${baAnalyticsServer}`;
var baTracker = () => ({
event: (baBookingTrackerData = {}) => {
var _a;
const { baAnalyticsEndPoint, baAnalyticsEndPointOrig } = ((_a = baBookingTrackerData.trackers) == null ? void 0 : _a.BookassistAnalytics) || {};
const defaultEndPoint = `${BA_ANALYTICS_SERVER}/prod`;
const client = pickBy(window && window.navigator || {}, (v) => typeof v !== "function" && !!v);
client.date = new Date().toString();
const {
availHeight,
availLeft,
availTop,
availWidth,
colorDepth,
height,
pixelDepth,
width
} = window.screen;
return fetch(`${baAnalyticsEndPoint || defaultEndPoint}`, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
Record: {
Data: cjs.all([
baBookingTrackerData,
{
trackers: {
BookassistAnalytics: {
baAnalyticsEndPointOrig: baAnalyticsEndPointOrig || defaultEndPoint
}
}
},
{
query: getRequestData(),
session: getSession(),
referrer: document.referrer,
cookie: document.cookie,
client,
screen: {
availHeight,
availLeft,
availTop,
availWidth,
colorDepth,
height,
pixelDepth,
width
}
}
]),
Tab: ` `,
NewLine: `
`
}
})
}).catch((err) => {
console.error(err);
});
}
});
var loadGtag = function() {
let promise;
function loadScript(accounts) {
window.dataLayer = window.dataLayer || [];
function gtag() {
dataLayer.push(arguments);
}
const cookieConsent = Cookies.get("cookie-consent");
const consent = cookieConsent === "15" ? "granted" : "denied";
gtag("consent", "default", {
ad_storage: consent,
ad_user_data: consent,
ad_personalization: consent,
analytics_storage: consent
});
gtag("js", new Date());
const { clientId, gsessionId } = queryString.parse(window.location.search);
accounts.forEach((account) => {
const { trackingId, sendPageView } = account;
gtag("config", trackingId, __spreadProps(__spreadValues(__spreadValues(__spreadValues({
cookie_flags: "SameSite=None; Secure"
}, typeof sendPageView === "boolean" && {
send_page_view: sendPageView
}), clientId && { client_id: clientId }), gsessionId && trackingId.startsWith("G-") && {
session_id: gsessionId
}), {
url_passthrough: true
}));
});
window.gtag = gtag;
const checkCookie = function() {
let lastCookie = cookieConsent;
let lastConsent = consent;
return function() {
const currentCookie = Cookies.get("cookie-consent");
if (currentCookie !== lastCookie) {
const currentConsent = currentCookie === "15" ? "granted" : "denied";
if (currentConsent !== lastConsent) {
gtag("consent", "update", {
ad_storage: currentConsent,
ad_user_data: currentConsent,
ad_personalization: currentConsent,
analytics_storage: currentConsent
});
lastConsent = currentConsent;
}
lastCookie = currentCookie;
}
};
}();
setInterval(checkCookie, 1e3);
return new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error("loadGtag timeout"));
}, 5e3);
const script = document.createElement("script");
script.src = `https://www.googletagmanager.com/gtag/js?id=${accounts[0].trackingId}`;
document.head.insertBefore(script, document.head.firstChild);
script.addEventListener("load", resolve);
script.addEventListener("error", () => {
reject(new Error(`gtag failed to load.`));
});
});
}
return function(accounts) {
if (!promise) {
promise = new Promise((resolve, reject) => __async(this, null, function* () {
try {
yield loadScript(accounts);
resolve();
} catch (e) {
reject(e);
}
}));
}
return promise;
};
}();
class gtagTracker$1 {
constructor(accountMap) {
let accounts;
if (accountMap.measurementIds) {
accounts = accountMap.measurementIds.filter((account) => /^(?!UA-)/.test(account.id)).map((account) => __spreadProps(__spreadValues({}, account), {
name: account.owner,
trackingId: account.id
}));
} else {
accounts = Object.values(accountMap);
}
this.accounts = accounts;
this.loadGtag = loadGtag(accounts).catch((err) => console.error(err));
}
getLoadGtag() {
return this.loadGtag;
}
getTrackers() {
return this.accounts;
}
gtag(...args) {
return __async(this, null, function* () {
try {
yield loadGtag(this.accounts);
window.gtag(...args);
} catch (err) {
console.error(err);
}
});
}
config(target, params) {
this.gtag("config", target, params);
}
consent(action, params) {
this.gtag("consent", action, params);
}
get(target, fieldName) {
return new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error("gtag get() timeout"));
}, 5e3);
this.gtag("get", target, fieldName, resolve);
}).catch((err) => {
console.error(err);
});
}
set(params) {
this.gtag("set", params);
}
event(name, params) {
const _a = params, { send_to } = _a, rest = __objRest(_a, ["send_to"]);
return new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error("gtag event() timeout"));
}, 5e3);
this.gtag("event", name, __spreadProps(__spreadValues({
send_to: send_to || this.getTrackers().map((t) => t.trackingId)
}, rest), {
event_callback: resolve
}));
}).catch((err) => {
console.error(err);
});
}
}
var pulseTracker = ({ accounts }) => {
const tracker = new gtagTracker$1(accounts);
const pageView = ({ request = {} }) => {
const { page } = request;
const extraFields = {};
if (page) {
extraFields.page_path = page;
}
return tracker.event("page_view", extraFields);
};
return {
event: (baBookingTrackerData) => {
try {
const {
event: { type }
} = baBookingTrackerData;
if (type === "pageView") {
return pageView(baBookingTrackerData);
}
return Promise.resolve();
} catch (err) {
return Promise.reject(err);
}
}
};
};
var gtagTracker = ({ accounts }) => {
const tracker = new gtagTracker$1(accounts);
const trackers = tracker.getTrackers();
const pageView = ({ request = {}, context = {}, event }) => {
const { page } = request;
const { hotel, client } = context;
const extraFields = {};
if (page && hotel) {
let pathname;
let search;
try {
const url = new URL(page, window.location.origin);
({ pathname, search } = url);
} catch (e) {
({ pathname, search } = window.location);
}
if (client === "v15") {
pathname = `/${event.pathname}`;
}
const query = queryString.parse(search);
let sortedSearch = `?hotel_id=${hotel.hotelId}&guide_id=${hotel.guideId}&`;
if (query) {
const order = [
"cgs",
"price_group",
"promo_code",
"voucher_code",
"date_in",
"date_out",
"nn",
"adults",
"children",
"user_language",
"user_currency",
"service_model",
"bp",
"from_page",
"action",
"ref",
"version",
"client-version",
"err"
];
order.forEach((param) => {
if (query[param]) {
sortedSearch += `${param}=${query[param]}&`;
}
});
sortedSearch = sortedSearch.slice(0, -1);
}
extraFields.page_path = `${pathname}${sortedSearch}`;
}
return tracker.event("page_view", extraFields);
};
const getCategory = (type, hotelName, groupName) => {
if (/^(room|extraBed)$/.test(type)) {
return `${hotelName}/Rooms/${groupName}`;
}
if (type === "mealPlan") {
return `${hotelName}/Mealplans/Mealplans`;
}
if (type === "addon") {
return `${hotelName}/Addons/${groupName}`;
}
return void 0;
};
const getEnhancedProducts = (products, { context: { hotel } }) => {
const getIdPref = (type) => {
const types = {
mealPlan: "bam",
addon: "baa",
extraBed: "bae",
default: "bar"
};
return types[type] || types.default;
};
return products.map(({
id,
type,
name,
variationGroupName,
addonGroupName,
position,
price,
quantity,
priceGroupName,
priceGroupId,
dynamicDiscountName = "No dynamic discount",
promoCode
}) => {
let item_list_id;
let item_list_name;
if (priceGroupName && priceGroupId.length > 0) {
item_list_id = priceGroupId.concat().sort((a, b) => +a - +b).join(",");
item_list_name = priceGroupName;
}
return pickBy({
item_id: `${getIdPref(type)}_${id}_${hotel.hotelId}_${hotel.guideId}`,
item_name: name,
affiliation: hotel.name,
coupon: promoCode,
index: position,
item_brand: variationGroupName,
item_category: getCategory(type, hotel.name, variationGroupName || addonGroupName),
item_category2: dynamicDiscountName,
item_list_id,
item_list_name,
price,
quantity
}, (v) => typeof v !== "undefined");
});
};
const chooseProduct = (baBookingTrackerData) => {
const {
rooms: { impressions = [] }
} = baBookingTrackerData;
const promises = [];
let items = [];
getEnhancedProducts(impressions, baBookingTrackerData).forEach((impression, i) => {
items.push(impression);
if (i > 0 && i % 10 === 9 || i + 1 === impressions.length) {
promises.push(tracker.event("view_item", {
items: [...items]
}));
items = [];
}
});
return Promise.all(promises);
};
const getAddRemoveProducts = (baBookingTrackerData, productType) => {
const { addons, mealPlans, rooms, extraBeds } = baBookingTrackerData;
const items = [];
[rooms, mealPlans, addons, extraBeds].forEach(({ cart }) => {
getEnhancedProducts(cart.filter((product) => !!product[productType]), baBookingTrackerData).forEach((product) => {
items.push(product);
});
});
return items;
};
const addProduct = (baBookingTrackerData) => {
const {
request: { hotelCurrency },
purchase: { revenue }
} = baBookingTrackerData;
const items = getAddRemoveProducts(baBookingTrackerData, "addProduct");
const promises = [];
if (items.length > 0) {
promises.push(tracker.event("add_to_cart", {
items,
currency: hotelCurrency,
value: revenue
}));
}
return Promise.all(promises);
};
const removeProduct = (baBookingTrackerData) => {
const {
request: { hotelCurrency },
purchase: { revenue }
} = baBookingTrackerData;
const items = getAddRemoveProducts(baBookingTrackerData, "removeProduct");
const promises = [];
if (items.length > 0) {
promises.push(tracker.event("remove_from_cart", {
items,
currency: hotelCurrency,
value: revenue
}));
}
return Promise.all(promises);
};
const checkout = (baBookingTrackerData) => {
const {
addons,
mealPlans,
rooms,
extraBeds,
request: { hotelCurrency },
purchase: { revenue }
} = baBookingTrackerData;
const promises = [];
const priceGroupIds = [];
const items = [];
[rooms, mealPlans, addons, extraBeds].forEach(({ cart }) => {
getEnhancedProducts(cart.map((product) => {
const _a = product, { priceGroupName, priceGroupId } = _a, rest = __objRest(_a, ["priceGroupName", "priceGroupId"]);
if (priceGroupName && priceGroupId) {
priceGroupIds.push(...priceGroupId);
}
return rest;
}), baBookingTrackerData).forEach((product) => {
items.push(product);
});
});
if (items.length > 0) {
promises.push(tracker.event("begin_checkout", {
items,
currency: hotelCurrency,
value: revenue
}));
}
return Promise.all(promises);
};
const payment = (baBookingTrackerData) => {
const {
addons,
mealPlans,
rooms,
extraBeds,
payment: { paymentType, paymentOption },
request: { hotelCurrency },
purchase: { revenue }
} = baBookingTrackerData;
const promises = [];
const priceGroupIds = [];
const items = [];
[rooms, mealPlans, addons, extraBeds].forEach(({ cart }) => {
getEnhancedProducts(cart.map((product) => {
const _a = product, { priceGroupName, priceGroupId } = _a, rest = __objRest(_a, ["priceGroupName", "priceGroupId"]);
if (priceGroupName && priceGroupId) {
priceGroupIds.push(...priceGroupId);
}
return rest;
}), baBookingTrackerData).forEach((product) => {
items.push(product);
});
});
if (items.length > 0) {
let option = paymentType.replace(/_/g, " ");
if (paymentOption) {
option = `${option} (${paymentOption})`;
}
const coupon = (rooms.cart.find((r) => !!r.promoCode) || {}).promoCode;
promises.push(tracker.event("add_payment_info", __spreadProps(__spreadValues({
items,
payment_type: option
}, coupon && { coupon }), {
currency: hotelCurrency,
value: revenue
})));
}
return Promise.all(promises);
};
const confirmation = (baBookingTrackerData) => {
const {
addons,
mealPlans,
extraBeds,
rooms,
context: {
client,
hotel: { name, hotelId, guideId }
},
request: { arrivalDate, hotelCurrency, lengthOfStay },
purchase: { bookingReference, revenue },
payment: { paymentType }
} = baBookingTrackerData;
const promises = [];
let priceGroupIds = [];
let pgName;
const items = [];
[rooms, mealPlans, addons, extraBeds].forEach(({ cart }) => {
getEnhancedProducts(cart.map((product) => {
const _a = product, { priceGroupName, priceGroupId } = _a, rest = __objRest(_a, ["priceGroupName", "priceGroupId"]);
if (priceGroupName && priceGroupId) {
pgName = priceGroupName.replace(/\s*\([{0-9},]+\)$/, "");
priceGroupIds.push(...priceGroupId);
}
return rest;
}), baBookingTrackerData).forEach((product) => {
items.push(product);
});
});
if (items.length > 0) {
priceGroupIds = priceGroupIds.filter((value, index, self) => self.indexOf(value) === index);
if (priceGroupIds.length > 1) {
priceGroupIds.sort((a, b) => +a - +b);
pgName = "Mixed";
}
const coupon = (rooms.cart.find((r) => !!r.promoCode) || {}).promoCode;
promises.push(tracker.event("purchase", __spreadProps(__spreadValues({
items,
currency: hotelCurrency,
transaction_id: `bar_${hotelId}_${guideId}_${bookingReference}`,
affiliation: `${name} - ${paymentType} - ${client}`,
item_list_id: priceGroupIds.join(","),
item_list_name: pgName
}, coupon && { coupon }), {
value: revenue
})));
const eventAction = "selected";
const eventLabel = arrivalDate;
const eventValue = lengthOfStay;
trackers.forEach(({ name: trackerName, trackingId }) => {
const eventCategory = trackerName === "BA" ? "Confirmed booking" : `Confirmed booking (${hotelId}_${guideId})`;
promises.push(tracker.event(eventAction, {
event_category: eventCategory,
event_label: eventLabel,
event_value: eventValue,
send_to: trackingId
}));
});
}
return Promise.all(promises);
};
const cancellation = (baBookingTrackerData) => {
const {
context: {
hotel: { hotelId, guideId }
},
request: { hotelCurrency },
purchase: { bookingReference, revenue }
} = baBookingTrackerData;
const promises = [];
promises.push(tracker.event("refund", {
transaction_id: `bar_${hotelId}_${guideId}_${bookingReference}`,
currency: hotelCurrency,
value: revenue
}));
};
const systemMessageKeys = [
"ExtraBedNotSet",
"FormValidationError",
"InvalidPromoCode",
"InvalidVoucher",
"PricesUpdated",
"UnexpectedError"
];
const onClickEventKeys = [
"AddressLink",
"HomeLink",
"MapLink",
"SeeEmail",
"SeePhone"
];
const reSystemMessages = new RegExp(`^(${systemMessageKeys.join("|")})$`);
const reOnclickEvents = new RegExp(`^(${onClickEventKeys.join("|")})$`);
const userInteraction = (baBookingTrackerData) => {
const {
event: { key }
} = baBookingTrackerData;
let eventCategory;
let eventAction;
const eventLabel = key.replace(/([a-z])([A-Z])/g, "$1 $2");
if (reOnclickEvents.test(key)) {
eventCategory = "Mobile BE interaction";
eventAction = `Onclick events - ${window.location.pathname}`;
} else if (reSystemMessages.test(key)) {
eventCategory = "Mobile BE system messages";
eventAction = `System messages - ${window.location.pathname}`;
}
if (eventCategory && eventAction && eventLabel) {
return tracker.event(eventAction, {
event_category: eventCategory,
event_label: eventLabel
});
}
return Promise.resolve();
};
const gaEvent = (fieldsObject) => {
const _a = fieldsObject, { eventAction, eventCategory, eventLabel, eventValue } = _a, rest = __objRest(_a, ["eventAction", "eventCategory", "eventLabel", "eventValue"]);
return tracker.event(eventAction, __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, eventCategory && { event_category: eventCategory }), eventLabel && { event_label: eventLabel }), eventValue && { event_value: eventValue }), rest));
};
return {
event: (baBookingTrackerData) => {
try {
const {
event: { type, key, fieldsObject }
} = baBookingTrackerData;
if (type === "pageView") {
return pageView(baBookingTrackerData);
}
if (type === "technical") {
if (key === "chooseProduct") {
return chooseProduct(baBookingTrackerData);
}
if (key === "addProduct") {
return addProduct(baBookingTrackerData);
}
if (key === "removeProduct") {
return removeProduct(baBookingTrackerData);
}
if (key === "checkout") {
return checkout(baBookingTrackerData);
}
if (key === "payment") {
return payment(baBookingTrackerData);
}
if (key === "confirmation") {
return confirmation(baBookingTrackerData);
}
if (key === "cancellation") {
return cancellation(baBookingTrackerData);
}
} else if (type === "userInteraction") {
return userInteraction(baBookingTrackerData);
} else if (type === "gaEvent") {
return gaEvent(fieldsObject);
}
return Promise.resolve();
} catch (err) {
return Promise.reject(err);
}
},
gtagLoaded: tracker.getLoadGtag()
};
};
const factories = {
BookassistAnalytics: baTracker,
GoogleAnalytics: gtagTracker,
Pulse: pulseTracker
};
var trackerFactory = (tracker, config) => typeof factories[tracker] === "function" && factories[tracker](__spreadProps(__spreadValues({}, config), { tracker }));
const getDomain = () => {
try {
let i = 0;
let { domain } = document;
const p = domain.split(".");
const s = `_gd${new Date().getTime()}`;
while (i < p.length - 1 && document.cookie.indexOf(`${s}=${s}`) === -1) {
domain = p.slice(-1 - ++i).join(".");
document.cookie = `${s}=${s};domain=${domain};`;
}
document.cookie = `${s}=;expires=Thu, 01 Jan 1970 00:00:01 GMT;domain=${domain};`;
return domain;
} catch (e) {
return void 0;
}
};
const getSession = () => {
let uuidCS;
let uuidCU;
const { bas } = queryString.parse(window.location.search);
if (bas) {
try {
;
({ uuidCS, uuidCU } = JSON.parse(decodeURIComponent(atob(bas))));
} catch (err) {
console.error(err);
}
}
if (!uuidCS || !uuidCU) {
uuidCS = Cookies.get("bassist-session-uuid") || v4_1();
uuidCU = Cookies.get("bassist-user-uuid") || uuidCS;
}
const rootDomain = getDomain();
Cookies.set("bassist-session-uuid", uuidCS, {
domain: rootDomain,
path: "/",
secure: true,
sameSite: "none"
});
Cookies.set("bassist-user-uuid", uuidCU, {
domain: rootDomain,
path: "/",
expires: 730,
secure: true,
sameSite: "none"
});
return {
uuidCS,
uuidCU
};
};
const getRequestData = () => {
const { href, pathname, search } = window.location;
const params = queryString.parse(search);
return {
href,
path: pathname,
query: queryString.stringify(params),
params
};
};
const getClientData = () => {
var _a, _b;
return {
date: new Date().toString(),
cookies: Cookies.get(),
BA: {
extraParams: (_a = window.BA) == null ? void 0 : _a.extraParams,
rrDoc: (_b = window.BA) == null ? void 0 : _b.rrDoc
}
};
};
const checkAdBlocker = function checkAdblock() {
let promise;
return function checkAdblockPromise() {
return __async(this, null, function* () {
if (!promise) {
promise = fetch(new Request("https://www.googletagmanager.com/gtag/js", {
method: "HEAD",
mode: "no-cors"
})).then(() => false).catch(() => true);
}
return promise;
});
};
}();
const universalTracker = (baBookingTrackerData = {}) => {
const defaultTrackers = { BookassistAnalytics: {} };
const trackerConfigs = Object.entries(cjs(defaultTrackers, baBookingTrackerData.trackers || {}));
const trackers = trackerConfigs.map(([tracker, config]) => trackerFactory(tracker, config));
return {
event: (...trackerDatas) => __async(this, null, function* () {
const cloned = structu