@zonos/elements 1.3.272 → 1.3.273

package/dist/cjs/collect-286a9d04.js

@@ -0,0 +1,3107 @@
+'use strict';
+
+const zonosStore = require('./zonosStore-45a87908.js');
+const localization = require('./localization-f4a64f6f.js');
+const handleFetch = require('./handleFetch-954f30e1.js');
+const VarianceTest = require('./VarianceTest-bec00ea8.js');
+const cart = require('./cart-660e115c.js');
+
+// src/constant/common.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var Environment = /* @__PURE__ */ function(Environment2) {
+    Environment2["production"] = "prod";
+    Environment2["demo"] = "demo";
+    Environment2["staging"] = "staging";
+    return Environment2;
+}(Environment || {});
+// src/constant/config.ts
+var UNKNOWN_VALUE = "airTracker_unknown";
+var DEFAULT_CONFIG = {
+    appName: UNKNOWN_VALUE,
+    appVersion: UNKNOWN_VALUE,
+    env: "staging" /* staging */ ,
+    isWebappContainer: false,
+    delay: 2e3,
+    errorRepeatTime: 3,
+    enableErrorMonitoring: false,
+    assetSpeedMonitoringWhiteList: [],
+    enableDetectPageChange: false,
+    enableRecordPageRetention: false,
+    hideSearchParams: false,
+    useSessionStorageForSessionId: false,
+    assetSpeedMonitoringWhiteListByMFE: {}
+};
+var DEFAULT_COMMON_DATA = {
+    appName: UNKNOWN_VALUE,
+    env: "staging" /* staging */ ,
+    sessionId: UNKNOWN_VALUE,
+    deviceId: UNKNOWN_VALUE
+};
+// src/util/jsonHelper.ts
+var isJSON = function(str) {
+    if (!str) {
+        return false;
+    }
+    if (/^\s*$/.test(str)) return false;
+    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@");
+    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]");
+    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, "");
+    return /^[\],:{}\s]*$/.test(str);
+};
+var safeReplacer = function() {
+    var seen = /* @__PURE__ */ new WeakSet();
+    return function(key, value) {
+        if (_instanceof(value, Error)) {
+            return "Error.message: ".concat(value.message, " \n  Error.stack: ").concat(value.stack);
+        }
+        if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null) {
+            if (seen.has(value)) {
+                return "[Circular ".concat(key || "root", "]");
+            }
+            seen.add(value);
+        }
+        if (typeof value === "function") {
+            return "function";
+        }
+        if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "symbol") {
+            return "symbol";
+        }
+        if (typeof value === "undefined") {
+            return null;
+        }
+        return value;
+    };
+};
+var safeStringify = function(obj) {
+    if (typeof obj === "string") {
+        return obj;
+    }
+    try {
+        if (_instanceof(obj, Error)) {
+            return (JSON.stringify(obj, safeReplacer()) || "undefined").replace(/"/gim, "");
+        }
+        return JSON.stringify(obj, safeReplacer());
+    } catch (e) {
+        return '{"error":"error happen when airTracker stringify"}';
+    }
+};
+// src/util/http.ts
+var request = function(param) {
+    var _param_method = param.method, method = _param_method === void 0 ? "post" : _param_method, url = param.url, data = param.data, success = param.success, fail = param.fail;
+    if (!isJSON(data)) {
+        return;
+    }
+    var xhr = new XMLHttpRequest();
+    xhr.addEventListener("readystatechange", function() {
+        if (xhr.readyState === 4) {
+            if (xhr.status >= 400 || xhr.status === 0) {
+                fail === null || fail === void 0 ? void 0 : fail(xhr.response);
+            } else {
+                success === null || success === void 0 ? void 0 : success(xhr.response);
+            }
+        }
+    });
+    xhr.open(method, url);
+    xhr.setRequestHeader("Content-Type", "application/json");
+    xhr.send(data);
+};
+// src/constant/lifeCycleEventName.ts
+var lifeCycleEventName = {
+    onInit: "onInit",
+    onConfigInit: "onConfigInit",
+    onConfigUpdated: "onConfigUpdated",
+    onCommonDataInit: "onCommonDataInit",
+    onCommonUpdated: "onCommonUpdated",
+    onPageChange: "onPageChange",
+    onDestroy: "onDestroy,"
+};
+// src/constant/index.ts
+var DEVICE_ID_STORAGE_KEY = "AIR_ANALYTICS_DEVICE_ID";
+var SESSION_ID_STORAGE_KEY = "AIR_ANALYTICS_SESSION_ID";
+var RISK_DEVICE_ID_STORAGE_KEY = "AWX_RISK_ID";
+var loggingServiceUrl = function(env) {
+    if (env == "prod" /* production */ ) {
+        return "https://o11y.airwallex.com/airtracker/logs";
+    }
+    if (env == "demo" /* demo */ ) {
+        return "https://o11y-demo.airwallex.com/airtracker/logs";
+    }
+    return "https://o11y-staging.airwallex.com/airtracker/logs";
+};
+var loggingServiceMetricsUrl = function(env) {
+    if (env == "prod" /* production */ ) {
+        return "https://o11y.airwallex.com/airtracker/metrics";
+    }
+    if (env == "demo" /* demo */ ) {
+        return "https://o11y-demo.airwallex.com/airtracker/metrics";
+    }
+    return "https://o11y-staging.airwallex.com/airtracker/metrics";
+};
+// src/util/index.ts
+var generateUId = function() {
+    var deviceId = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+        var r = Math.random() * 16 | 0;
+        var v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+    });
+    return deviceId;
+};
+var getMFEName = function(airTracker2) {
+    var _location_pathname_split, _location_pathname, _location;
+    if (airTracker2.config.getMFEName) {
+        return airTracker2.config.getMFEName();
+    }
+    return ((_location = location) === null || _location === void 0 ? void 0 : (_location_pathname = _location.pathname) === null || _location_pathname === void 0 ? void 0 : (_location_pathname_split = _location_pathname.split("/")) === null || _location_pathname_split === void 0 ? void 0 : _location_pathname_split[2]) || "unknown";
+};
+var getSessionId = function() {
+    try {
+        var sessionId = window.sessionStorage.getItem(SESSION_ID_STORAGE_KEY);
+        if (!sessionId) {
+            sessionId = generateUId();
+            window.sessionStorage.setItem(SESSION_ID_STORAGE_KEY, sessionId);
+        }
+        return sessionId;
+    } catch (e) {
+        return generateUId();
+    }
+};
+var getDeviceId = function() {
+    try {
+        var deviceId = window.localStorage.getItem(DEVICE_ID_STORAGE_KEY);
+        if (!deviceId) {
+            deviceId = generateUId();
+            window.localStorage.setItem(DEVICE_ID_STORAGE_KEY, deviceId);
+        }
+        return deviceId;
+    } catch (e) {}
+};
+var getRiskDeviceId = function() {
+    try {
+        var deviceId = window.localStorage.getItem(RISK_DEVICE_ID_STORAGE_KEY);
+        return deviceId || void 0;
+    } catch (e) {}
+};
+var getNetworkType = function() {
+    var _navigator;
+    var netType = "";
+    var arr = navigator.userAgent.match(/NetType\/(\w+)/);
+    if (arr) {
+        var ref;
+        ref = _sliced_to_array(arr, 2), netType = ref[1];
+    } else if ((_navigator = navigator) === null || _navigator === void 0 ? void 0 : _navigator.connection) {
+        var _navigator_connection, _navigator1, _navigator_connection1, _navigator2;
+        netType = ((_navigator1 = navigator) === null || _navigator1 === void 0 ? void 0 : (_navigator_connection = _navigator1.connection) === null || _navigator_connection === void 0 ? void 0 : _navigator_connection.effectiveType) || ((_navigator2 = navigator) === null || _navigator2 === void 0 ? void 0 : (_navigator_connection1 = _navigator2.connection) === null || _navigator_connection1 === void 0 ? void 0 : _navigator_connection1.type);
+    }
+    if (!netType) {
+        netType = "unknown";
+    }
+    return parseNetType(netType);
+};
+var parseNetType = function(net) {
+    net = String(net).toLowerCase();
+    if (net.indexOf("4g") >= 0) return "net4g" /* net4g */ ;
+    if (net.indexOf("wifi") >= 0) return "wifi" /* wifi */ ;
+    if (net.indexOf("5g") >= 0) return "net5g" /* net5g */ ;
+    if (net.indexOf("3g") >= 0) return "net3g" /* net3g */ ;
+    if (net.indexOf("2g") >= 0) return "net2g" /* net2g */ ;
+    return "unknown" /* unknown */ ;
+};
+var canUseResourceTiming = function canUseResourceTiming() {
+    return typeof window.performance !== "undefined" && typeof window.performance.clearResourceTimings === "function" && typeof window.performance.getEntriesByType === "function" && typeof window.performance.now === "function";
+};
+var formatUrl = function(url) {
+    if (typeof url === "string") {
+        var hostUrl = url.split("?")[0] || "";
+        return hostUrl.slice(0, 200);
+    }
+    return url;
+};
+var getQueryString = function(url) {
+    if (typeof url === "string") {
+        return url.split("?")[1] || "";
+    }
+    return url;
+};
+var urlIsHttps = function(url) {
+    var isHostProtocol = typeof url === "string" && url.startsWith("//");
+    return isHostProtocol ? typeof location !== "undefined" && location.protocol === "https:" : /^https/.test(url);
+};
+var getReportVal = function(rawVal, isDefaultByString) {
+    if (typeof rawVal === "number") {
+        return rawVal;
+    }
+    if (typeof rawVal === "string") {
+        return rawVal;
+    }
+    return isDefaultByString ? "" /* string */  : -1 /* number */ ;
+};
+var checkIfInWhiteList = function(url, airTracker2) {
+    var _airTracker2_config_assetSpeedMonitoringWhiteListByMFE;
+    var isInWhiteList = false;
+    if (!airTracker2.config.isWebappContainer) {
+        isInWhiteList = checkIfInWhiteListHelper(url, airTracker2.config.assetSpeedMonitoringWhiteList);
+        return isInWhiteList;
+    }
+    var MFEName = getMFEName(airTracker2);
+    return isInWhiteList || checkIfInWhiteListHelper(url, (_airTracker2_config_assetSpeedMonitoringWhiteListByMFE = airTracker2.config.assetSpeedMonitoringWhiteListByMFE) === null || _airTracker2_config_assetSpeedMonitoringWhiteListByMFE === void 0 ? void 0 : _airTracker2_config_assetSpeedMonitoringWhiteListByMFE[MFEName]);
+};
+var checkIfInWhiteListHelper = function(url, whiteList) {
+    if (!(whiteList === null || whiteList === void 0 ? void 0 : whiteList.length)) {
+        return false;
+    }
+    for(var i = 0; i < whiteList.length; i++){
+        var cur = whiteList[i];
+        if (_instanceof(cur, RegExp) && cur.test(url)) {
+            return true;
+        }
+        if (typeof cur == "string" && url.includes(cur)) {
+            return true;
+        }
+    }
+    return false;
+};
+var roundSubtract = function(a, b) {
+    var precision = 100;
+    return Math.round((a - b) * precision) / precision;
+};
+// src/pipes/send.ts
+var sendNormalLogPipe = function(airTracker2) {
+    return function(logs) {
+        var _airTracker2_MFECommonDataMap, _navigator;
+        var MFEName = getMFEName(airTracker2);
+        var commonData = airTracker2.config.isWebappContainer ? _object_spread({}, airTracker2.commonData || {}, ((_airTracker2_MFECommonDataMap = airTracker2.MFECommonDataMap) === null || _airTracker2_MFECommonDataMap === void 0 ? void 0 : _airTracker2_MFECommonDataMap[MFEName]) || {}) : airTracker2.commonData;
+        var data = Array.isArray(logs) ? logs : [
+            logs
+        ];
+        if (data.length === 0) {
+            return;
+        }
+        var finalLog = {
+            commonData: commonData,
+            data: data
+        };
+        var dataBody = safeStringify(finalLog);
+        var sendOptions = {
+            method: "post",
+            url: loggingServiceUrl(airTracker2.commonData.env),
+            data: dataBody
+        };
+        if (typeof ((_navigator = navigator) === null || _navigator === void 0 ? void 0 : _navigator.sendBeacon) === "function") {
+            var success = navigator.sendBeacon(sendOptions.url, dataBody);
+            if (!success) {
+                request(sendOptions);
+            }
+        } else {
+            request(sendOptions);
+        }
+    };
+};
+var sendMetricsLogPipe = function(airTracker2) {
+    return function(logs) {
+        var _airTracker2_MFECommonDataMap, _navigator;
+        var MFEName = getMFEName(airTracker2);
+        var commonData = airTracker2.config.isWebappContainer ? _object_spread({}, airTracker2.commonData || {}, ((_airTracker2_MFECommonDataMap = airTracker2.MFECommonDataMap) === null || _airTracker2_MFECommonDataMap === void 0 ? void 0 : _airTracker2_MFECommonDataMap[MFEName]) || {}) : airTracker2.commonData;
+        var finalLog = {
+            commonData: commonData,
+            data: Array.isArray(logs) ? logs : [
+                logs
+            ]
+        };
+        var dataBody = safeStringify(finalLog);
+        var sendOptions = {
+            method: "post",
+            url: loggingServiceMetricsUrl(airTracker2.commonData.env),
+            data: dataBody
+        };
+        if (typeof ((_navigator = navigator) === null || _navigator === void 0 ? void 0 : _navigator.sendBeacon) === "function") {
+            var success = navigator.sendBeacon(sendOptions.url, dataBody);
+            if (!success) {
+                request(sendOptions);
+            }
+        } else {
+            request(sendOptions);
+        }
+    };
+};
+// src/pipes/throttle.ts
+var throttlePipe = function(airTracker2, maxLength) {
+    var timer;
+    var retainedLogs = [];
+    var config = airTracker2.config;
+    window.addEventListener("beforeunload", function() {
+        if (retainedLogs.length > 0) {
+            airTracker2.immediateSendPipe(retainedLogs.splice(0, retainedLogs.length));
+            timer && clearTimeout(timer);
+        }
+    });
+    return function(log, resolve) {
+        retainedLogs.push(log);
+        airTracker2.lifeCycle.on(lifeCycleEventName.onCommonUpdated, function() {
+            if (retainedLogs.length > 0) {
+                resolve === null || resolve === void 0 ? void 0 : resolve(retainedLogs.splice(0, retainedLogs.length));
+                airTracker2.lifeCycle.remove(lifeCycleEventName.onCommonUpdated);
+                timer && clearTimeout(timer);
+            }
+        });
+        if (maxLength && retainedLogs.length >= maxLength) {
+            resolve === null || resolve === void 0 ? void 0 : resolve(retainedLogs.splice(0, retainedLogs.length));
+            timer && clearTimeout(timer);
+            return;
+        }
+        timer && clearTimeout(timer);
+        timer = setTimeout(function() {
+            timer = null;
+            if (retainedLogs.length > 0) {
+                resolve === null || resolve === void 0 ? void 0 : resolve(retainedLogs.splice(0, retainedLogs.length));
+                airTracker2.lifeCycle.remove(lifeCycleEventName.onCommonUpdated);
+            }
+        }, config.delay);
+    };
+};
+// src/pipes/errorRepeatLimit.ts
+var errorLogLimitPipe = function(airTracker2) {
+    var errorLogMap = {};
+    return function(logs, resolve) {
+        var maxNum = typeof airTracker2.config.errorRepeatTime === "number" ? airTracker2.config.errorRepeatTime : 5;
+        if (maxNum === 0) {
+            return resolve === null || resolve === void 0 ? void 0 : resolve(logs);
+        }
+        resolve === null || resolve === void 0 ? void 0 : resolve(logs.filter(function(log) {
+            if (log.severity == "autoDetectError" /* AUTO_DETECT_ERROR */ ) {
+                errorLogMap[log.error] = errorLogMap[log.error] || 0;
+                errorLogMap[log.error] += 1;
+                if (errorLogMap[log.error] > maxNum) {
+                    return false;
+                }
+                return true;
+            }
+            return true;
+        }));
+    };
+};
+// src/pipes/index.ts
+var noop = function() {};
+var createPipeline = function(pipeArr) {
+    if (!pipeArr || !pipeArr.reduce || !pipeArr.length) {
+        throw new TypeError("createPipeline need at least one function param");
+    }
+    if (pipeArr.length === 1) {
+        return function(msg, resolve) {
+            pipeArr[0](msg, resolve || noop);
+        };
+    }
+    return pipeArr.reduce(function(prePipe, pipe) {
+        return function(msg) {
+            var nextPipe = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
+            return prePipe(msg, function(msg2) {
+                return pipe === null || pipe === void 0 ? void 0 : pipe(msg2, nextPipe);
+            });
+        };
+    });
+};
+// src/util/eventEmitter.ts
+var EventEmitter = /*#__PURE__*/ function() {
+    function EventEmitter() {
+        var _this = this;
+        _class_call_check(this, EventEmitter);
+        this.emit = function(name, data) {
+            if (!_this) return;
+            var events = _this.eventsList[name];
+            var handler;
+            if (events === null || events === void 0 ? void 0 : events.length) {
+                events = events.slice();
+                for(var i = 0; i < events.length; i++){
+                    handler = events[i];
+                    try {
+                        var result = handler.callback.apply(_this, [
+                            data
+                        ]);
+                        if (1 === handler.type) {
+                            _this.remove(name, handler.callback);
+                        }
+                        if (false === result) {
+                            break;
+                        }
+                    } catch (e) {
+                        throw e;
+                    }
+                }
+            }
+            return _this;
+        };
+        this.eventsList = {};
+    }
+    _create_class(EventEmitter, [
+        {
+            key: "indexOf",
+            value: function indexOf(array, value) {
+                for(var i = 0; i < array.length; i++){
+                    if (array[i].callback === value) {
+                        return i;
+                    }
+                }
+                return -1;
+            }
+        },
+        {
+            key: "on",
+            value: function on(name, callback) {
+                var type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+                if (!this) return;
+                var events = this.eventsList[name];
+                if (!events) {
+                    this.eventsList[name] = [];
+                    events = this.eventsList[name];
+                }
+                if (this.indexOf(events, callback) === -1) {
+                    var handler = {
+                        name: name,
+                        type: type || 0,
+                        callback: callback
+                    };
+                    events.push(handler);
+                    return this;
+                }
+                return this;
+            }
+        },
+        {
+            key: "one",
+            value: function one(name, callback) {
+                this.on(name, callback, 1);
+            }
+        },
+        {
+            key: "remove",
+            value: function remove(name, callback) {
+                if (!this) return;
+                var events = this.eventsList[name];
+                if (!events) {
+                    return null;
+                }
+                if (!callback) {
+                    try {
+                        delete this.eventsList[name];
+                    } catch (e) {}
+                    return null;
+                }
+                if (events.length) {
+                    var index = this.indexOf(events, callback);
+                    events.splice(index, 1);
+                }
+                return this;
+            }
+        },
+        {
+            key: "clear",
+            value: function clear() {
+                this.eventsList = {};
+            }
+        }
+    ]);
+    return EventEmitter;
+}();
+// src/interface/plugins.ts
+var AirTrackerPlugin = /*#__PURE__*/ function() {
+    function AirTrackerPlugin(pluginOption) {
+        _class_call_check(this, AirTrackerPlugin);
+        this.name = "";
+        // initiation flag
+        this.isInit = false;
+        this.name = pluginOption.name;
+        this.option = pluginOption;
+    }
+    _create_class(AirTrackerPlugin, [
+        {
+            key: "patch",
+            value: function patch(airTracker2) {
+                if (!this.isInit) {
+                    var _this_option_setUp, _this_option;
+                    this.isInit = true;
+                    (_this_option = this.option) === null || _this_option === void 0 ? void 0 : (_this_option_setUp = _this_option.setUp) === null || _this_option_setUp === void 0 ? void 0 : _this_option_setUp.call(this.option, airTracker2);
+                }
+            }
+        },
+        {
+            key: "uninstall",
+            value: function uninstall() {
+                var _this_option_destroy, _this_option;
+                (_this_option = this.option) === null || _this_option === void 0 ? void 0 : (_this_option_destroy = _this_option.destroy) === null || _this_option_destroy === void 0 ? void 0 : _this_option_destroy.apply(this);
+                this.isInit = false;
+            }
+        }
+    ]);
+    return AirTrackerPlugin;
+}();
+// src/plugins/onErrorPlugin.ts
+var airTracker;
+var onError = function(event) {
+    var errString = "".concat(safeStringify(event.message) || "", " @ (").concat(safeStringify(event.filename) || "", ":").concat(event.lineno || 0, ":").concat(event.colno || 0, ")\n").concat(safeStringify(event.error || ""));
+    airTracker.normalLogPipeLine({
+        severity: "autoDetectError" /* AUTO_DETECT_ERROR */ ,
+        eventName: "windowOnError" /* windowOnError */ ,
+        extraInfo: {
+            error: errString
+        }
+    });
+};
+var unhandledrejectionHandler = function(event) {
+    var reason = event && safeStringify(event.reason);
+    airTracker.normalLogPipeLine({
+        severity: "autoDetectError" /* AUTO_DETECT_ERROR */ ,
+        eventName: "promiseError" /* promiseError */ ,
+        extraInfo: {
+            error: reason
+        }
+    });
+};
+var errorHandler = function(event) {
+    var target = (event === null || event === void 0 ? void 0 : event.target) || (event === null || event === void 0 ? void 0 : event.srcElement);
+    if (!target) {
+        return;
+    }
+    var url = (target === null || target === void 0 ? void 0 : target.src) || (target === null || target === void 0 ? void 0 : target.href);
+    var tagName = target.tagName;
+    var staticFileType = "unknown" /* unknown */ ;
+    if (typeof url === "string" && tagName) {
+        if (window.location.href.indexOf(url) > -1) {
+            return;
+        }
+        if (/\.js$/.test(url)) {
+            staticFileType = "script" /* script */ ;
+        } else if (/\.css$/.test(url)) {
+            staticFileType = "css" /* css */ ;
+        } else {
+            switch(tagName.toLowerCase()){
+                case "script":
+                    staticFileType = "script" /* script */ ;
+                    break;
+                case "link":
+                    staticFileType = "css" /* css */ ;
+                    break;
+                case "img":
+                    staticFileType = "image" /* img */ ;
+                    break;
+                case "audio":
+                case "video":
+                    staticFileType = "media" /* media */ ;
+                    break;
+                default:
+                    return;
+            }
+        }
+        airTracker.normalLogPipeLine({
+            severity: "autoDetectError" /* AUTO_DETECT_ERROR */ ,
+            eventName: "staticFileLoadError" /* staticFileLoadError */ ,
+            extraInfo: {
+                staticFileType: staticFileType,
+                error: "".concat(tagName, " load fail: ").concat(url)
+            }
+        });
+    }
+};
+var errorDetectionPlugin = new AirTrackerPlugin({
+    name: "errorDetectionPlugin",
+    setUp: function(airTrackerInst) {
+        airTracker = airTrackerInst;
+        window.addEventListener("error", onError);
+        window.addEventListener("unhandledrejection", unhandledrejectionHandler);
+        window.document.addEventListener("error", errorHandler, true);
+    },
+    destroy: function() {
+        window.removeEventListener("unhandledrejection", unhandledrejectionHandler);
+        window.document.removeEventListener("error", errorHandler, true);
+        window.removeEventListener("error", onError);
+    }
+});
+// src/plugins/assetsSpeedPlugin.ts
+var ASSETS_INITIATOR_TYPE = [
+    "img",
+    "css",
+    "script",
+    "link",
+    "audio",
+    "video",
+    "iframe"
+];
+var COLLECTED_ENTRY_TYPE = "resource";
+var generateSpeedLog = function(entry) {
+    var resourceURl = entry.name;
+    return {
+        url: formatUrl(resourceURl),
+        method: "get",
+        // duration = redirect + DNS + CONNECTION + request + response
+        duration: Number(entry.duration.toFixed(2)),
+        // time it takes to load
+        type: "static",
+        isHttps: urlIsHttps(resourceURl),
+        urlQuery: getQueryString(resourceURl),
+        domainLookup: getReportVal(entry.domainLookupEnd - entry.domainLookupStart),
+        connectTime: getReportVal(entry.connectEnd - entry.connectStart)
+    };
+};
+var publishSpeedLogs = function(entries, airTracker2) {
+    for(var i = 0, l = entries.length; i < l; i++){
+        var entry = entries[i];
+        if (ASSETS_INITIATOR_TYPE.indexOf(entry.initiatorType) !== -1 && checkIfInWhiteList(entry.name, airTracker2)) {
+            airTracker2.normalLogPipeLine({
+                severity: "performance" /* PERFORMANCE */ ,
+                eventName: "assets_speed" /* ASSETS_SPEED */ ,
+                extraInfo: {
+                    log: generateSpeedLog(entry)
+                }
+            });
+        }
+    }
+};
+var interval;
+var observer;
+var assetSpeedPlugin = new AirTrackerPlugin({
+    name: "assetsSpeedPlugin",
+    setUp: function(airTracker2) {
+        if (!canUseResourceTiming()) return;
+        var collectCur = 0;
+        window.performance.onresourcetimingbufferfull = function() {
+            collectCur = 0;
+            window.performance.clearResourceTimings();
+        };
+        if (typeof window.PerformanceObserver === "function") {
+            publishSpeedLogs(window.performance.getEntriesByType(COLLECTED_ENTRY_TYPE), airTracker2);
+            observer = new window.PerformanceObserver(function(list) {
+                publishSpeedLogs(list.getEntries(), airTracker2);
+            });
+            observer.observe({
+                entryTypes: [
+                    COLLECTED_ENTRY_TYPE
+                ]
+            });
+        } else {
+            interval = setInterval(function() {
+                var allEntries = window.performance.getEntriesByType(COLLECTED_ENTRY_TYPE);
+                var collectEntries = allEntries.slice(collectCur);
+                collectCur = allEntries.length;
+                publishSpeedLogs(collectEntries, airTracker2);
+            }, 3e3);
+        }
+    },
+    destroy: function() {
+        observer === null || observer === void 0 ? void 0 : observer.disconnect();
+        interval && clearInterval(interval);
+    }
+});
+// src/plugins/onPageChangePlugin.ts
+var observer2;
+var onPageChangePlugin = new AirTrackerPlugin({
+    name: "onPageChangePlugin",
+    setUp: /*#__PURE__*/ function() {
+        var _ref = _async_to_generator(function(airTracker2) {
+            var _location, previousUrl, body, sendOnPageChangeEvent, config;
+            return _ts_generator(this, function(_state) {
+                previousUrl = (_location = location) === null || _location === void 0 ? void 0 : _location.href;
+                body = document.querySelector("body");
+                sendOnPageChangeEvent = function(param) {
+                    var prevHref = param.prevHref;
+                    var _location, _location1, _location2, _location3, _location4;
+                    airTracker2.normalLogPipeLine({
+                        severity: "autoDetectEvent" /* AUTO_DETECT_EVENT */ ,
+                        eventName: "onPageChange" /* onPageChange */ ,
+                        extraInfo: {
+                            prevHref: prevHref,
+                            href: ((_location = location) === null || _location === void 0 ? void 0 : _location.href) || "",
+                            hostname: (_location1 = location) === null || _location1 === void 0 ? void 0 : _location1.hostname,
+                            pathName: (_location2 = location) === null || _location2 === void 0 ? void 0 : _location2.pathname,
+                            protocol: (_location3 = location) === null || _location3 === void 0 ? void 0 : _location3.protocol,
+                            search: (_location4 = location) === null || _location4 === void 0 ? void 0 : _location4.search
+                        }
+                    });
+                };
+                sendOnPageChangeEvent({
+                    prevHref: ""
+                });
+                observer2 = new MutationObserver(function() {
+                    if (location.href !== previousUrl) {
+                        var tempPreviousUrl = previousUrl;
+                        previousUrl = location.href;
+                        sendOnPageChangeEvent({
+                            prevHref: tempPreviousUrl
+                        });
+                    }
+                });
+                config = {
+                    subtree: true,
+                    childList: true
+                };
+                observer2.observe(body || document, config);
+                return [
+                    2
+                ];
+            });
+        });
+        return function(airTracker2) {
+            return _ref.apply(this, arguments);
+        };
+    }(),
+    destroy: function() {
+        observer2 === null || observer2 === void 0 ? void 0 : observer2.disconnect();
+    }
+});
+// src/plugins/pageRetentionPlugin.ts
+var observer3;
+var onPageRetentionPlugin = new AirTrackerPlugin({
+    name: "onPageRetentionPlugin",
+    setUp: /*#__PURE__*/ function() {
+        var _ref = _async_to_generator(function(airTracker2) {
+            var _location, previousUrl, body, enterPageTimeStamp, startRecording, sendPageRetentionEvent, config;
+            return _ts_generator(this, function(_state) {
+                if (typeof document.visibilityState === "undefined") {
+                    return [
+                        2
+                    ];
+                }
+                previousUrl = (_location = location) === null || _location === void 0 ? void 0 : _location.href;
+                body = document.querySelector("body");
+                startRecording = function() {
+                    enterPageTimeStamp = Date.now();
+                };
+                startRecording();
+                document.addEventListener("visibilitychange", function() {
+                    if (document.visibilityState === "hidden") {
+                        sendPageRetentionEvent({
+                            href: location.href,
+                            leftReason: "visibilityChange" /* visibilityChange */ 
+                        });
+                    } else if (document.visibilityState === "visible") {
+                        startRecording();
+                    }
+                });
+                window.addEventListener("beforeunload", function() {
+                    sendPageRetentionEvent({
+                        href: location.href,
+                        sendImmediate: true,
+                        leftReason: "pageClose" /* pageClose */ 
+                    });
+                });
+                sendPageRetentionEvent = function(param) {
+                    var href = param.href, sendImmediate = param.sendImmediate, leftReason = param.leftReason;
+                    if (!enterPageTimeStamp) {
+                        return;
+                    }
+                    var duration = Date.now() - enterPageTimeStamp;
+                    if (duration === 0) {
+                        return;
+                    }
+                    enterPageTimeStamp = void 0;
+                    var payload = {
+                        severity: "autoDetectEvent" /* AUTO_DETECT_EVENT */ ,
+                        eventName: "onPageRetention" /* onPageRetention */ ,
+                        extraInfo: {
+                            href: href,
+                            duration: duration,
+                            leftReason: leftReason
+                        }
+                    };
+                    if (sendImmediate) {
+                        airTracker2.ImmediatePipeline(payload);
+                        return;
+                    }
+                    airTracker2.normalLogPipeLine(payload);
+                };
+                observer3 = new MutationObserver(function() {
+                    if (location.href !== previousUrl) {
+                        var tempPreviousUrl = previousUrl;
+                        previousUrl = location.href;
+                        sendPageRetentionEvent({
+                            href: tempPreviousUrl,
+                            leftReason: "nextPage" /* nextPage */ 
+                        });
+                        startRecording();
+                    }
+                });
+                config = {
+                    subtree: true,
+                    childList: true
+                };
+                observer3.observe(body || document, config);
+                return [
+                    2
+                ];
+            });
+        });
+        return function(airTracker2) {
+            return _ref.apply(this, arguments);
+        };
+    }(),
+    destroy: function() {
+        observer3 === null || observer3 === void 0 ? void 0 : observer3.disconnect();
+    }
+});
+// src/plugins/apiPerformancePlugin/utils.ts
+var generateRandomId = function() {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2, 15);
+};
+var checkIfInWhiteList2 = function(url, whiteList) {
+    var defaultWhiteList = [
+        /^https?:\/\/[^\/]*\.airwallex\.com($|\/)/
+    ];
+    var defaultExclusionList = [
+        /authenticate\/heartbeat/,
+        /papluginlogs\/.*/,
+        /airtracker\/.*/,
+        /o11y(-staging|-demo)?\.airwallex\.com/,
+        /\.(png|jpe?g|gif|svg|ico|webp|avif|css|js|json|woff2?|ttf|eot|map|txt|csv|xml)(\?.*)?(#.*)?$/i
+    ];
+    if (defaultExclusionList.some(function(item) {
+        return item.test(url);
+    })) {
+        return false;
+    }
+    return checkIfInWhiteListHelper(url, whiteList || defaultWhiteList);
+};
+var findMainEntry = function(performanceItem) {
+    var startTime = performanceItem.startTime, endTime = performanceItem.endTime, entries = performanceItem.entries;
+    if (entries.length === 0) {
+        return void 0;
+    }
+    if (entries.length === 1) {
+        return entries[0];
+    }
+    var filteredEntries = entries.filter(function(entry) {
+        return entry.startTime >= startTime && endTime && entry.responseEnd <= endTime;
+    }).sort(function(a, b) {
+        return a.startTime - b.startTime;
+    });
+    return filteredEntries === null || filteredEntries === void 0 ? void 0 : filteredEntries[0];
+};
+var round2Decimal = function(value) {
+    return Math.round(value * 100) / 100;
+};
+var processPerformanceEntry = function(entry) {
+    var startTime = entry.startTime, duration = entry.duration, responseStart = entry.responseStart, connectEnd = entry.connectEnd, connectStart = entry.connectStart, domainLookupEnd = entry.domainLookupEnd, domainLookupStart = entry.domainLookupStart, requestStart = entry.requestStart, secureConnectionStart = entry.secureConnectionStart, redirectEnd = entry.redirectEnd, redirectStart = entry.redirectStart, responseStatus = entry.responseStatus, responseEnd = entry.responseEnd, encodedBodySize = entry.encodedBodySize, decodedBodySize = entry.decodedBodySize, transferSize = entry.transferSize, deliveryType = entry.deliveryType, initiatorType = entry.initiatorType;
+    return {
+        startTime: round2Decimal(startTime),
+        totalDuration: round2Decimal(duration),
+        timeToFirstByte: roundSubtract(responseStart, startTime),
+        tcpDuration: roundSubtract(connectEnd, connectStart),
+        dnsDuration: roundSubtract(domainLookupEnd, domainLookupStart),
+        tlsDuration: roundSubtract(requestStart, secureConnectionStart),
+        redirectDuration: roundSubtract(redirectEnd, redirectStart),
+        responseDuration: roundSubtract(responseEnd, responseStart),
+        encodeResponseSize: encodedBodySize,
+        decodeResponseSize: decodedBodySize,
+        transferSize: transferSize,
+        deliveryType: deliveryType,
+        statusCode: responseStatus,
+        initiatorType: initiatorType
+    };
+};
+var getPayload = function(performanceItem, extraInfo) {
+    var url = performanceItem.url, method = performanceItem.method, errorType = performanceItem.errorType, errorDetail = performanceItem.errorDetail;
+    var mainEntry = findMainEntry(performanceItem);
+    var _ref = new URL(url, window.location.href), href = _ref.href, protocol = _ref.protocol;
+    var payloadFromPerformanceEntry = mainEntry ? processPerformanceEntry(mainEntry) : {};
+    var payload = {
+        severity: "autoDetectEvent" /* AUTO_DETECT_EVENT */ ,
+        eventName: "httpClientMetrics" /* httpClientMetrics */ ,
+        extraInfo: _object_spread(_object_spread_props(_object_spread({
+            httpUrl: href,
+            method: method,
+            scheme: protocol
+        }, errorType && {
+            errorType: errorType
+        }, errorDetail && {
+            errorDetail: errorDetail
+        }, payloadFromPerformanceEntry), {
+            // use injected response as fallback
+            statusCode: (payloadFromPerformanceEntry === null || payloadFromPerformanceEntry === void 0 ? void 0 : payloadFromPerformanceEntry.statusCode) || (performanceItem === null || performanceItem === void 0 ? void 0 : performanceItem.responseStatus),
+            startTime: (payloadFromPerformanceEntry === null || payloadFromPerformanceEntry === void 0 ? void 0 : payloadFromPerformanceEntry.startTime) || (performanceItem === null || performanceItem === void 0 ? void 0 : performanceItem.startTime),
+            initiatorType: (payloadFromPerformanceEntry === null || payloadFromPerformanceEntry === void 0 ? void 0 : payloadFromPerformanceEntry.initiatorType) || (performanceItem === null || performanceItem === void 0 ? void 0 : performanceItem.initiatorType)
+        }), extraInfo)
+    };
+    return payload;
+};
+var isGraphQLError = function(responseBody) {
+    return(// Has data or errors at root level
+    responseBody && (typeof responseBody === "undefined" ? "undefined" : _type_of(responseBody)) === "object" && "errors" in responseBody && // If errors exist, they should be an array with proper GraphQL error shape
+    Array.isArray(responseBody.errors) && responseBody.errors.every(function(error) {
+        return error && (typeof error === "undefined" ? "undefined" : _type_of(error)) === "object" && "message" in error;
+    }));
+};
+// src/plugins/apiPerformancePlugin/type.ts
+var API_PERFORMANCE_QUEUE = "awx_airtracker_api_performance_queue";
+var API_PERFORMANCE_PLUGIN_LOADED = "awx_airtracker_api_performance_plugin_loaded";
+// src/plugins/apiPerformancePlugin/index.ts
+var OBSERVER_WAIT_TIME_MS = 300;
+var TIMEOUT_WAIT_TIME_MS = 1e4;
+var globalObject = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+globalObject[API_PERFORMANCE_QUEUE] = globalObject[API_PERFORMANCE_QUEUE] || [];
+var handlePayloadAndSendLog = function(apiPerformanceItem, airTracker2, extraInfo) {
+    setTimeout(function() {
+        var payload = getPayload(apiPerformanceItem, extraInfo);
+        airTracker2.observerPipeline(payload);
+        globalObject[API_PERFORMANCE_QUEUE] = globalObject[API_PERFORMANCE_QUEUE].filter(function(item) {
+            return item.id !== apiPerformanceItem.id;
+        });
+    }, OBSERVER_WAIT_TIME_MS);
+};
+var handleTimeout = function(requestId, airTracker2) {
+    setTimeout(function() {
+        var matchedApiPerformanceItem = globalObject[API_PERFORMANCE_QUEUE].find(function(item) {
+            return item.id === requestId;
+        });
+        if (!matchedApiPerformanceItem) {
+            return;
+        }
+        var payload = getPayload(matchedApiPerformanceItem, {
+            exceptionType: "timeout-without-response"
+        });
+        airTracker2.observerPipeline(payload);
+        globalObject[API_PERFORMANCE_QUEUE] = globalObject[API_PERFORMANCE_QUEUE].filter(function(item) {
+            return item.id !== requestId;
+        });
+    }, TIMEOUT_WAIT_TIME_MS);
+};
+var injectXMLHttpRequest = function(airTracker2) {
+    var originalOpen = XMLHttpRequest.prototype.open;
+    var originalSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.open = function injectXMLHttpRequest(method, url, async, username, password) {
+        try {
+            var _airTracker2_config;
+            var requestId = generateRandomId();
+            this.__requestId = requestId;
+            var urlString = _instanceof(url, URL) ? url.href : new URL(url, window.location.href).href;
+            if (!checkIfInWhiteList2(urlString, (_airTracker2_config = airTracker2.config) === null || _airTracker2_config === void 0 ? void 0 : _airTracker2_config.enableRecordAPIPerformanceWhitelist)) {
+                return originalOpen.call(this, method, url, async !== null && async !== void 0 ? async : true, username, password);
+            }
+            var apiPerformanceItem = {
+                id: requestId,
+                startTime: performance.now(),
+                method: method,
+                url: urlString,
+                entries: [],
+                initiatorType: "xmlhttprequest"
+            };
+            globalObject[API_PERFORMANCE_QUEUE].push(apiPerformanceItem);
+            handleTimeout(requestId, airTracker2);
+            return originalOpen.call(this, method, url, async !== null && async !== void 0 ? async : true, username, password);
+        } catch (error) {
+            airTracker2.normalLogPipeLine({
+                severity: "warn" /* WARN */ ,
+                eventName: "apiPerformancePluginError",
+                extraInfo: {
+                    message: "Inject XHR open error",
+                    error: error
+                }
+            });
+            return originalOpen.call(this, method, url, async !== null && async !== void 0 ? async : true, username, password);
+        }
+    };
+    XMLHttpRequest.prototype.send = function sendXHRRequest() {
+        var _this = this;
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        try {
+            var matchedApiPerformanceItem = globalObject[API_PERFORMANCE_QUEUE].find(function(item) {
+                return item.id === _this.__requestId;
+            });
+            if (!matchedApiPerformanceItem) {
+                return originalSend.apply(this, args);
+            }
+            var _this1 = this;
+            this.addEventListener("loadend", /*#__PURE__*/ _async_to_generator(function() {
+                var endTime, duration, status, responseBody, blob, parsedBody, e;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            endTime = performance.now();
+                            duration = endTime - matchedApiPerformanceItem.startTime;
+                            status = _this1.status;
+                            if (status === 0) {
+                                return [
+                                    2
+                                ];
+                            }
+                            matchedApiPerformanceItem.endTime = endTime;
+                            matchedApiPerformanceItem.duration = duration;
+                            matchedApiPerformanceItem.responseStatus = status;
+                            _state.label = 1;
+                        case 1:
+                            _state.trys.push([
+                                1,
+                                6,
+                                ,
+                                7
+                            ]);
+                            if (!(_this1.responseType === "" || _this1.responseType === "text")) return [
+                                3,
+                                2
+                            ];
+                            responseBody = _this1.responseText;
+                            return [
+                                3,
+                                5
+                            ];
+                        case 2:
+                            if (!(_this1.responseType === "json")) return [
+                                3,
+                                3
+                            ];
+                            responseBody = _this1.response;
+                            return [
+                                3,
+                                5
+                            ];
+                        case 3:
+                            if (!(_this1.responseType === "blob")) return [
+                                3,
+                                5
+                            ];
+                            blob = _this1.response;
+                            if (!((blob === null || blob === void 0 ? void 0 : blob.type) === "application/json")) return [
+                                3,
+                                5
+                            ];
+                            return [
+                                4,
+                                blob.text()
+                            ];
+                        case 4:
+                            responseBody = _state.sent();
+                            _state.label = 5;
+                        case 5:
+                            parsedBody = responseBody && typeof responseBody === "string" ? JSON.parse(responseBody) : responseBody;
+                            if (parsedBody && isGraphQLError(parsedBody)) {
+                                matchedApiPerformanceItem.errorType = "graphqlError";
+                                matchedApiPerformanceItem.errorDetail = parsedBody.errors;
+                            }
+                            return [
+                                3,
+                                7
+                            ];
+                        case 6:
+                            e = _state.sent();
+                            airTracker2.normalLogPipeLine({
+                                severity: "warn" /* WARN */ ,
+                                eventName: "apiPerformancePluginError",
+                                extraInfo: {
+                                    message: "Parse response body error in XHR",
+                                    url: matchedApiPerformanceItem === null || matchedApiPerformanceItem === void 0 ? void 0 : matchedApiPerformanceItem.url,
+                                    error: e
+                                }
+                            });
+                            return [
+                                3,
+                                7
+                            ];
+                        case 7:
+                            handlePayloadAndSendLog(matchedApiPerformanceItem, airTracker2);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            }));
+            this.addEventListener("error", function() {
+                handlePayloadAndSendLog(matchedApiPerformanceItem, airTracker2, {
+                    exceptionType: "network-error"
+                });
+            });
+            this.addEventListener("abort", function() {
+                handlePayloadAndSendLog(matchedApiPerformanceItem, airTracker2, {
+                    exceptionType: "abort-error"
+                });
+            });
+            this.addEventListener("timeout", function() {
+                handlePayloadAndSendLog(matchedApiPerformanceItem, airTracker2, {
+                    exceptionType: "timeout-error"
+                });
+            });
+            return originalSend.apply(this, args);
+        } catch (error) {
+            airTracker2.normalLogPipeLine({
+                severity: "warn" /* WARN */ ,
+                eventName: "apiPerformancePluginError",
+                extraInfo: {
+                    message: "InjectXHR send error",
+                    error: error
+                }
+            });
+            throw error;
+        }
+    };
+};
+var injectFetch = function(airTracker2) {
+    var originalFetch = window.fetch;
+    window.fetch = /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, _airTracker2_config, apiPerformanceItem, url, _this, startTime, id, response, endTime, clonedResponse, responseBody, error, error1, exceptionType;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    url = new URL(_instanceof(args[0], Request) ? args[0].url : String(args[0]), window.location.href).href;
+                    if (!!checkIfInWhiteList2(url, (_airTracker2_config = airTracker2.config) === null || _airTracker2_config === void 0 ? void 0 : _airTracker2_config.enableRecordAPIPerformanceWhitelist)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        originalFetch.apply(this, args)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 2:
+                    _state.trys.push([
+                        2,
+                        9,
+                        ,
+                        10
+                    ]);
+                    startTime = performance.now();
+                    id = generateRandomId();
+                    apiPerformanceItem = {
+                        id: id,
+                        startTime: startTime,
+                        method: ((_this = _instanceof(args[0], Request) ? args[0] : args[1]) === null || _this === void 0 ? void 0 : _this.method) || "GET",
+                        url: url,
+                        entries: [],
+                        initiatorType: "fetch"
+                    };
+                    globalObject[API_PERFORMANCE_QUEUE].push(apiPerformanceItem);
+                    handleTimeout(id, airTracker2);
+                    return [
+                        4,
+                        originalFetch.apply(this, args)
+                    ];
+                case 3:
+                    response = _state.sent();
+                    endTime = performance.now();
+                    apiPerformanceItem.endTime = endTime;
+                    apiPerformanceItem.duration = endTime - startTime;
+                    apiPerformanceItem.responseStatus = response.status;
+                    clonedResponse = response.clone();
+                    _state.label = 4;
+                case 4:
+                    _state.trys.push([
+                        4,
+                        7,
+                        ,
+                        8
+                    ]);
+                    if (!clonedResponse.ok) return [
+                        3,
+                        6
+                    ];
+                    return [
+                        4,
+                        clonedResponse.json()
+                    ];
+                case 5:
+                    responseBody = _state.sent();
+                    if (responseBody && isGraphQLError(responseBody)) {
+                        apiPerformanceItem.errorType = "graphqlError";
+                        apiPerformanceItem.errorDetail = responseBody.errors;
+                    }
+                    _state.label = 6;
+                case 6:
+                    return [
+                        3,
+                        8
+                    ];
+                case 7:
+                    error = _state.sent();
+                    airTracker2.normalLogPipeLine({
+                        severity: "warn" /* WARN */ ,
+                        eventName: "apiPerformancePluginError",
+                        extraInfo: {
+                            message: "Parse response body error in fetch",
+                            url: apiPerformanceItem === null || apiPerformanceItem === void 0 ? void 0 : apiPerformanceItem.url,
+                            error: error
+                        }
+                    });
+                    return [
+                        3,
+                        8
+                    ];
+                case 8:
+                    handlePayloadAndSendLog(apiPerformanceItem, airTracker2);
+                    return [
+                        2,
+                        response
+                    ];
+                case 9:
+                    error1 = _state.sent();
+                    if (apiPerformanceItem && apiPerformanceItem.id && globalObject[API_PERFORMANCE_QUEUE].find(function(item) {
+                        return item.id === (apiPerformanceItem === null || apiPerformanceItem === void 0 ? void 0 : apiPerformanceItem.id);
+                    })) {
+                        exceptionType = "fetch-error";
+                        if (_instanceof(error1, TypeError)) {
+                            exceptionType = "network-error";
+                        } else if (_instanceof(error1, DOMException) && error1.name === "AbortError") {
+                            exceptionType = "abort-error";
+                        }
+                        handlePayloadAndSendLog(apiPerformanceItem, airTracker2, {
+                            exceptionType: exceptionType
+                        });
+                    } else {
+                        airTracker2.normalLogPipeLine({
+                            severity: "warn" /* WARN */ ,
+                            eventName: "apiPerformancePluginError",
+                            extraInfo: {
+                                message: "Inject fetch error",
+                                error: error1
+                            }
+                        });
+                    }
+                    throw error1;
+                case 10:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+};
+var setUpAPIPerformancePlugin = function(airTracker2) {
+    var _window;
+    injectXMLHttpRequest(airTracker2);
+    injectFetch(airTracker2);
+    if ((_window = window) === null || _window === void 0 ? void 0 : _window.PerformanceObserver) {
+        var observer4 = new window.PerformanceObserver(function(list) {
+            var entries = list.getEntries();
+            entries.forEach(function(entry) {
+                var resourceEntry = entry;
+                if (resourceEntry.initiatorType === "fetch" || resourceEntry.initiatorType === "xmlhttprequest") {
+                    var items = globalObject[API_PERFORMANCE_QUEUE].filter(function(item) {
+                        return item.url === resourceEntry.name;
+                    });
+                    items.forEach(function(item) {
+                        item.entries.push(resourceEntry);
+                    });
+                }
+            });
+        });
+        observer4.observe({
+            entryTypes: [
+                "resource"
+            ],
+            buffered: true
+        });
+    } else {
+        airTracker2.normalLogPipeLine({
+            severity: "warn" /* WARN */ ,
+            eventName: "apiPerformancePluginError",
+            extraInfo: {
+                error: "PerformanceObserver Not Supported"
+            }
+        });
+    }
+};
+var apiPerformancePlugin = new AirTrackerPlugin({
+    name: "apiPerformancePlugin",
+    setUp: /*#__PURE__*/ function() {
+        var _ref = _async_to_generator(function(airTracker2) {
+            var _airTracker2_config, _airTracker2_config1;
+            return _ts_generator(this, function(_state) {
+                if (globalObject[API_PERFORMANCE_PLUGIN_LOADED]) {
+                    return [
+                        2
+                    ];
+                }
+                if (((_airTracker2_config = airTracker2.config) === null || _airTracker2_config === void 0 ? void 0 : _airTracker2_config.enableRecordAPIPerformance) && Math.random() < (((_airTracker2_config1 = airTracker2.config) === null || _airTracker2_config1 === void 0 ? void 0 : _airTracker2_config1.enableRecordAPIPerformancePercentage) || 0)) {
+                    globalObject[API_PERFORMANCE_PLUGIN_LOADED] = true;
+                    setUpAPIPerformancePlugin(airTracker2);
+                }
+                return [
+                    2
+                ];
+            });
+        });
+        return function(airTracker2) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+});
+// src/util/version.ts
+var SDK_VERSION = "3.1.0";
+// src/airTracker.ts
+var AirTracker = /*#__PURE__*/ function() {
+    function AirTracker(param) {
+        var _this = this;
+        var config = param.config, _param_plugins = param.plugins, plugins = _param_plugins === void 0 ? [] : _param_plugins;
+        _class_call_check(this, AirTracker);
+        this.config = DEFAULT_CONFIG;
+        this.lifeCycle = new EventEmitter();
+        this.plugins = [];
+        this._commonData = DEFAULT_COMMON_DATA;
+        this._MFECommonDataMap = {};
+        // customized speed log
+        this.timeMap = {};
+        this.packedDataConvert = function(param) {
+            var severity = param.severity, eventName = param.eventName, extraInfo = param.extraInfo;
+            var _location, _location1;
+            var packedData = _object_spread({
+                severity: severity,
+                eventName: eventName,
+                currentHref: _this.config.hideSearchParams ? (((_location = location) === null || _location === void 0 ? void 0 : _location.href) || "").split("?")[0] || "" : ((_location1 = location) === null || _location1 === void 0 ? void 0 : _location1.href) || ""
+            }, extraInfo);
+            if (_this.config.isWebappContainer) {
+                packedData.MFEName = getMFEName(_this);
+            }
+            return packedData;
+        };
+        this.normalPipelineObj = createPipeline([
+            throttlePipe(this, 8),
+            errorLogLimitPipe(this),
+            sendNormalLogPipe(this)
+        ]);
+        this.observerPipelineObj = createPipeline([
+            throttlePipe(this, 8),
+            sendMetricsLogPipe(this)
+        ]);
+        this.immediateSendPipe = sendNormalLogPipe(this);
+        this.observerPipeline = function(param) {
+            var severity = param.severity, eventName = param.eventName, extraInfo = param.extraInfo;
+            var packedData = _this.packedDataConvert({
+                severity: severity,
+                eventName: eventName,
+                extraInfo: extraInfo
+            });
+            return _this.observerPipelineObj(packedData);
+        };
+        this.normalLogPipeLine = function(param) {
+            var severity = param.severity, eventName = param.eventName, extraInfo = param.extraInfo;
+            var packedData = _this.packedDataConvert({
+                severity: severity,
+                eventName: eventName,
+                extraInfo: extraInfo
+            });
+            if (_this.config.disableThrottle) {
+                return _this.immediateSendPipe(packedData);
+            } else {
+                return _this.normalPipelineObj(packedData);
+            }
+        };
+        this.ImmediatePipeline = function(param) {
+            var severity = param.severity, eventName = param.eventName, extraInfo = param.extraInfo;
+            var packedData = _this.packedDataConvert({
+                severity: severity,
+                eventName: eventName,
+                extraInfo: extraInfo
+            });
+            return _this.immediateSendPipe(packedData);
+        };
+        this.plugins = _to_consumable_array(plugins);
+        this.setConfig(config);
+        this.initCommonData(config);
+        this.lifeCycle.emit(lifeCycleEventName.onInit);
+        if (config.enableErrorMonitoring) {
+            this.plugins.push(errorDetectionPlugin);
+        }
+        if ((config === null || config === void 0 ? void 0 : config.assetSpeedMonitoringWhiteList) && config.assetSpeedMonitoringWhiteList.length > 0 || config.isWebappContainer) {
+            this.plugins.push(assetSpeedPlugin);
+        }
+        if (config === null || config === void 0 ? void 0 : config.enableDetectPageChange) {
+            this.plugins.push(onPageChangePlugin);
+        }
+        if (config === null || config === void 0 ? void 0 : config.enableRecordPageRetention) {
+            this.plugins.push(onPageRetentionPlugin);
+        }
+        if ((config === null || config === void 0 ? void 0 : config.enableRecordAPIPerformance) && (config === null || config === void 0 ? void 0 : config.enableRecordAPIPerformancePercentage) && config.enableRecordAPIPerformancePercentage > 0 && config.enableRecordAPIPerformancePercentage <= 1) {
+            this.plugins.push(apiPerformancePlugin);
+        }
+        this.installPlugins();
+    }
+    _create_class(AirTracker, [
+        {
+            key: "installPlugins",
+            value: function installPlugins() {
+                var _this = this;
+                this.plugins.forEach(function(item) {
+                    item.patch(_this);
+                });
+            }
+        },
+        {
+            key: "commonData",
+            get: function get() {
+                return this._commonData;
+            }
+        },
+        {
+            key: "MFECommonDataMap",
+            get: function get() {
+                return this._MFECommonDataMap;
+            }
+        },
+        {
+            key: "initCommonData",
+            value: function initCommonData(config) {
+                this._commonData.sessionId = config.useSessionStorageForSessionId ? getSessionId() : generateUId();
+                this._commonData.deviceId = getDeviceId() || UNKNOWN_VALUE;
+                this._commonData.riskDeviceId = getRiskDeviceId();
+                this._commonData.networkType = getNetworkType() || "unknown" /* unknown */ ;
+                this._commonData.env = config.env || this._commonData.env;
+                this._commonData.accountId = config.accountId || UNKNOWN_VALUE;
+                this._commonData.appVersion = config.appVersion;
+                this._commonData.appName = config.appName;
+                this._commonData.sdkVersion = SDK_VERSION;
+                this.lifeCycle.emit(lifeCycleEventName.onCommonDataInit, this.commonData);
+            }
+        },
+        {
+            key: "updateCommonDataBasedOnConfig",
+            value: function updateCommonDataBasedOnConfig(config) {
+                this.lifeCycle.emit(lifeCycleEventName.onCommonUpdated, this._commonData);
+                this._commonData.env = config.env || this._commonData.env;
+                this._commonData.appName = config.appName || this._commonData.appName;
+                this._commonData.env = config.env || this._commonData.env;
+                this._commonData.accountId = config.accountId || this._commonData.accountId;
+                this._commonData.appVersion = config.appVersion || this._commonData.appVersion;
+            }
+        },
+        {
+            // Can add extra common data based on developers' needs
+            key: "updateCommonData",
+            value: function updateCommonData(extraData) {
+                this.lifeCycle.emit(lifeCycleEventName.onCommonUpdated, this._commonData);
+                this._commonData = _object_spread({}, this._commonData, extraData);
+            }
+        },
+        {
+            key: "removeCommonDataByKey",
+            value: function removeCommonDataByKey(keys) {
+                var _this = this;
+                this.lifeCycle.emit(lifeCycleEventName.onCommonUpdated, this._commonData);
+                setTimeout(function() {
+                    keys.forEach(function(item) {
+                        delete _this._commonData[item];
+                    });
+                }, 1e3);
+            }
+        },
+        {
+            // only worked if isWebappContainer is true
+            key: "addToMFECommonData",
+            value: function addToMFECommonData(param) {
+                var MFEName = param.MFEName, MFECommonData = param.MFECommonData;
+                var _this__MFECommonDataMap;
+                if (!this.config.isWebappContainer) {
+                    return;
+                }
+                if (!MFEName || !MFECommonData) {
+                    return;
+                }
+                this._MFECommonDataMap = _object_spread_props(_object_spread({}, this._MFECommonDataMap || {}), _define_property({}, MFEName, _object_spread({}, ((_this__MFECommonDataMap = this._MFECommonDataMap) === null || _this__MFECommonDataMap === void 0 ? void 0 : _this__MFECommonDataMap[MFEName]) || {}, MFECommonData)));
+            }
+        },
+        {
+            // support set config later
+            key: "setConfig",
+            value: function setConfig(config) {
+                var _this = this;
+                if (this.config.isWebappContainer) {
+                    return;
+                }
+                var setValue = function(key, value) {
+                    _this.config[key] = value;
+                };
+                Object.entries(config).forEach(function(item) {
+                    var _item = _sliced_to_array(item, 2), key = _item[0], val = _item[1];
+                    if ((typeof val === "undefined" ? "undefined" : _type_of(val)) !== void 0) {
+                        setValue(key, val);
+                    }
+                });
+                this.lifeCycle.emit(lifeCycleEventName.onConfigInit, this.config);
+                this.updateCommonDataBasedOnConfig(config);
+            }
+        },
+        {
+            // send verbose level log
+            key: "verbose",
+            value: function verbose(eventName, extraInfo) {
+                this.normalLogPipeLine({
+                    severity: "verbose" /* VERBOSE */ ,
+                    eventName: eventName,
+                    extraInfo: extraInfo
+                });
+            }
+        },
+        {
+            // send HTTP request log
+            key: "httpLog",
+            value: function httpLog(eventName, extraInfo) {
+                this.normalLogPipeLine({
+                    severity: "http" /* HTTP */ ,
+                    eventName: eventName,
+                    extraInfo: extraInfo
+                });
+            }
+        },
+        {
+            // send info level log
+            key: "info",
+            value: function info(eventName, extraInfo) {
+                this.normalLogPipeLine({
+                    severity: "info" /* INFO */ ,
+                    eventName: eventName,
+                    extraInfo: extraInfo
+                });
+            }
+        },
+        {
+            // send warn level log
+            key: "warn",
+            value: function warn(eventName, extraInfo) {
+                this.normalLogPipeLine({
+                    severity: "warn" /* WARN */ ,
+                    eventName: eventName,
+                    extraInfo: extraInfo
+                });
+            }
+        },
+        {
+            // send error level log
+            key: "error",
+            value: function error(eventName, extraInfo) {
+                console.error("error", eventName);
+                this.normalLogPipeLine({
+                    severity: "error" /* ERROR */ ,
+                    eventName: eventName,
+                    extraInfo: extraInfo
+                });
+            }
+        },
+        {
+            // send business related log, usually used for data analysis
+            // all the logs with isBusinessData == true, will be sync to bigQuery / looker
+            key: "businessLog",
+            value: function businessLog(eventName, extraInfo) {
+                this.normalLogPipeLine({
+                    severity: "info" /* INFO */ ,
+                    eventName: eventName,
+                    extraInfo: _object_spread_props(_object_spread({}, extraInfo), {
+                        isBusinessLog: true
+                    })
+                });
+            }
+        },
+        {
+            // duration: milliseconds
+            key: "reportDuration",
+            value: function reportDuration(eventName, duration, extraInfo) {
+                if (typeof eventName !== "string") {
+                    console.warn("reportDuration: eventName (first param) must be a string");
+                    return;
+                }
+                if (typeof duration !== "number") {
+                    console.warn("reportDuration: duration (second param) must be number");
+                    return;
+                }
+                if (duration < 0 || duration > 6e4) {
+                    console.warn("reportDuration: duration (second param) must between 0 and 60000");
+                    return;
+                }
+                this.normalLogPipeLine({
+                    severity: "speed" /* SPEED */ ,
+                    eventName: eventName,
+                    extraInfo: _object_spread({
+                        duration: duration
+                    }, extraInfo)
+                });
+            }
+        },
+        {
+            key: "getTimerKey",
+            value: function getTimerKey(eventName) {
+                var MFEName = getMFEName(this);
+                return this.config.isWebappContainer ? "".concat(MFEName, "_").concat(eventName) : eventName;
+            }
+        },
+        {
+            key: "timeStart",
+            value: function timeStart(eventName) {
+                if (typeof eventName !== "string") {
+                    console.warn("time: first param must be a string");
+                    return;
+                }
+                if (this.timeMap[this.getTimerKey(eventName)]) {
+                    console.warn("Timer ".concat(eventName, " already exists"));
+                }
+                this.timeMap[this.getTimerKey(eventName)] = Date.now();
+            }
+        },
+        {
+            key: "timeEnd",
+            value: function timeEnd(eventName, delta) {
+                if (typeof eventName !== "string") {
+                    console.warn("timeEnd: first param must be a string");
+                    return;
+                }
+                if (this.timeMap[this.getTimerKey(eventName)]) {
+                    var duration = Date.now() - this.timeMap[this.getTimerKey(eventName)] + (delta || 0);
+                    this.normalLogPipeLine({
+                        severity: "speed" /* SPEED */ ,
+                        eventName: eventName,
+                        extraInfo: {
+                            duration: duration
+                        }
+                    });
+                    delete this.timeMap[this.getTimerKey(eventName)];
+                } else {
+                    console.warn("Timer key :".concat(eventName, " does not exist"));
+                }
+            }
+        },
+        {
+            // only worked if isWebappContainer is true
+            key: "addToAssetSpeedWhiteListByMFE",
+            value: function addToAssetSpeedWhiteListByMFE(param) {
+                var MFEName = param.MFEName, whiteList = param.whiteList;
+                var _this_config_assetSpeedMonitoringWhiteListByMFE;
+                if (!this.config.isWebappContainer) {
+                    return;
+                }
+                if (!MFEName || !(whiteList === null || whiteList === void 0 ? void 0 : whiteList.length)) {
+                    return;
+                }
+                if (!this.config.assetSpeedMonitoringWhiteListByMFE) {
+                    this.config.assetSpeedMonitoringWhiteListByMFE = {};
+                }
+                if (!((_this_config_assetSpeedMonitoringWhiteListByMFE = this.config.assetSpeedMonitoringWhiteListByMFE) === null || _this_config_assetSpeedMonitoringWhiteListByMFE === void 0 ? void 0 : _this_config_assetSpeedMonitoringWhiteListByMFE[MFEName])) {
+                    this.config.assetSpeedMonitoringWhiteListByMFE = _object_spread_props(_object_spread({}, this.config.assetSpeedMonitoringWhiteListByMFE), _define_property({}, MFEName, whiteList));
+                } else {
+                    var _this_config_assetSpeedMonitoringWhiteListByMFE_MFEName;
+                    var _this_config_assetSpeedMonitoringWhiteListByMFE_MFEName1, _this_config_assetSpeedMonitoringWhiteListByMFE1;
+                    (_this_config_assetSpeedMonitoringWhiteListByMFE1 = this.config.assetSpeedMonitoringWhiteListByMFE) === null || _this_config_assetSpeedMonitoringWhiteListByMFE1 === void 0 ? void 0 : (_this_config_assetSpeedMonitoringWhiteListByMFE_MFEName1 = _this_config_assetSpeedMonitoringWhiteListByMFE1[MFEName]) === null || _this_config_assetSpeedMonitoringWhiteListByMFE_MFEName1 === void 0 ? void 0 : (_this_config_assetSpeedMonitoringWhiteListByMFE_MFEName = _this_config_assetSpeedMonitoringWhiteListByMFE_MFEName1).push.apply(_this_config_assetSpeedMonitoringWhiteListByMFE_MFEName, _to_consumable_array(whiteList));
+                }
+            }
+        },
+        {
+            // please call destroy from your app root component when your app unmount
+            key: "destroy",
+            value: function destroy() {
+                if (this.config.isWebappContainer) {
+                    return;
+                }
+                this.plugins.forEach(function(item) {
+                    item.uninstall();
+                });
+            }
+        }
+    ]);
+    return AirTracker;
+}();
+// src/index.ts
+var src_default = AirTracker;
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var name = "@airwallex/components-sdk";
+var version = "1.30.2";
+var main = "./lib/index.js";
+var module$1 = "./lib/index.mjs";
+var types = "./lib/index.d.ts";
+var files = [
+	"lib/**"
+];
+var license = "MIT";
+var scripts = {
+	"load-types": "node ./load-types.js && yarn prettier -w src/types/*d.ts",
+	prebuild: "yarn clean",
+	build: "yarn rollup --config",
+	postbuild: "yarn bundle-types",
+	"bundle-types": "dts-bundle-generator -o ./lib/index.d.ts ./src/index.ts",
+	clean: "rm -rf dist lib",
+	lint: "eslint \"src/**/*.ts*\"",
+	test: "jest",
+	sonar: "sonar-scanner",
+	release: "semantic-release",
+	"lint-stage": "lint-staged",
+	prepare: "husky"
+};
+var prettier = {
+	semi: true,
+	singleQuote: true,
+	printWidth: 80,
+	trailingComma: "all"
+};
+var publishConfig = {
+	access: "public"
+};
+var devDependencies = {
+	"@babel/preset-typescript": "^7.18.6",
+	"@rollup/plugin-commonjs": "^25.0.7",
+	"@rollup/plugin-json": "^6.1.0",
+	"@rollup/plugin-node-resolve": "^15.2.3",
+	"@rollup/plugin-terser": "^0.4.4",
+	"@rollup/plugin-typescript": "^11.1.6",
+	"@semantic-release/changelog": "^5.0.1",
+	"@semantic-release/commit-analyzer": "^8.0.1",
+	"@semantic-release/git": "^9.0.0",
+	"@semantic-release/gitlab": "^6.1.0",
+	"@semantic-release/release-notes-generator": "^9.0.0",
+	"@swc/core": "^1.3.46",
+	"@types/jest": "^29.5.0",
+	"@typescript-eslint/eslint-plugin": "^5.57.0",
+	"@typescript-eslint/parser": "^5.57.0",
+	"dts-bundle-generator": "^9.0.0",
+	eslint: "^7.23.0",
+	"eslint-config-prettier": "^8.3.0",
+	"eslint-plugin-prettier": "^5.1.3",
+	husky: "^9.0.11",
+	jest: "^29.5.0",
+	"jest-environment-jsdom": "^29.5.0",
+	"lint-staged": "^15.2.7",
+	prettier: "^3.3.2",
+	rollup: "^4.9.6",
+	"semantic-release": "^17.3.8",
+	"sonarqube-scanner": "^3.0.1",
+	"ts-jest": "^29.0.5",
+	"ts-loader": "^9.5.1",
+	tslib: "^2.6.2",
+	typescript: "^4.5.2"
+};
+var dependencies = {
+	"@airwallex/airtracker": "^3.0.0"
+};
+var packageJson = {
+	name: name,
+	version: version,
+	main: main,
+	module: module$1,
+	types: types,
+	files: files,
+	license: license,
+	scripts: scripts,
+	prettier: prettier,
+	"lint-staged": {
+	"src/**/*.{ts,tsx}": [
+		"yarn lint"
+	],
+	"src/**/*.{js,jsx,ts,tsx,json,css,scss,md}": "prettier --write"
+},
+	publishConfig: publishConfig,
+	devDependencies: devDependencies,
+	dependencies: dependencies
+};
+
+var airTrackerENV = {
+    dev: Environment.staging,
+    staging: Environment.staging,
+    demo: Environment.demo,
+    prod: Environment.production
+};
+var initializeAirTracker = function (env, clientId) {
+    if (env === void 0) { env = Environment.production; }
+    if (!window._AirwallexSDKs.airTracker) {
+        window._AirwallexSDKs.airTracker = new src_default({
+            config: {
+                appName: 'components-sdk',
+                appVersion: packageJson.version,
+                env: airTrackerENV[env] || Environment.production
+            }
+        });
+        window._AirwallexSDKs.airTracker.updateCommonData({ clientId: clientId });
+    }
+    return window._AirwallexSDKs.airTracker;
+};
+var maskPII = function (data) {
+    if (typeof data !== 'object') {
+        return data;
+    }
+    try {
+        var result_1 = JSON.parse(JSON.stringify(data));
+        Object.keys(result_1).forEach(function (key) {
+            if (typeof key === 'string' &&
+                ['auth', 'code'].some(function (sens) { return key.includes(sens); })) {
+                result_1[key] = '***';
+            }
+        });
+        return result_1;
+    }
+    catch (_a) {
+        return data;
+    }
+};
+var logError = function (eventName, data) {
+    var _a, _b;
+    (_b = (_a = window._AirwallexSDKs) === null || _a === void 0 ? void 0 : _a.airTracker) === null || _b === void 0 ? void 0 : _b.error(eventName, __assign(__assign({}, data), { context: 'components-sdk' }));
+};
+var logWarning = function (eventName, data) {
+    var _a;
+    (_a = window._AirwallexSDKs.airTracker) === null || _a === void 0 ? void 0 : _a.warn(eventName, __assign(__assign({}, data), { context: 'components-sdk' }));
+};
+var logInfo = function (eventName, data) {
+    var _a;
+    (_a = window._AirwallexSDKs.airTracker) === null || _a === void 0 ? void 0 : _a.info(eventName, __assign(__assign({}, data), { context: 'components-sdk' }));
+};
+
+var LoadScriptError = /** @class */ (function (_super) {
+    __extends(LoadScriptError, _super);
+    function LoadScriptError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.code = 'LOAD_SCRIPT_ERROR';
+        return _this;
+    }
+    return LoadScriptError;
+}(Error));
+
+var _a, _b;
+var ENV;
+(function (ENV) {
+    ENV["dev"] = "dev";
+    ENV["staging"] = "staging";
+    ENV["demo"] = "demo";
+    ENV["prod"] = "prod";
+    ENV["sandbox"] = "sandbox";
+})(ENV || (ENV = {}));
+var PA_STATIC_HOST = (_a = {},
+    _a[ENV.dev] = 'https://checkout-staging.airwallex.com',
+    _a[ENV.staging] = 'https://checkout-staging.airwallex.com',
+    _a[ENV.demo] = 'https://checkout-demo.airwallex.com',
+    _a[ENV.prod] = 'https://checkout.airwallex.com',
+    _a[ENV.sandbox] = 'https://checkout.sandbox.airwallex.com',
+    _a);
+var STATIC_HOST = (_b = {},
+    _b[ENV.dev] = 'https://static-staging.airwallex.com',
+    _b[ENV.staging] = 'https://static-staging.airwallex.com',
+    _b[ENV.demo] = 'https://static-demo.airwallex.com',
+    _b[ENV.prod] = 'https://static.airwallex.com',
+    _b[ENV.sandbox] = 'https://static.sandbox.airwallex.com',
+    _b);
+var SDK_CONTROLLER = 'sdkController';
+var PAYMENTS = 'payments';
+var SDK_URL_MAPPING = {
+    kyc: '/widgets/kyc/sdk/v1/index.js',
+    rfi: '/widgets/kycRfi/sdk/v1/index.js',
+    paymentsKyb: '/widgets/paymentsKyb/sdk/v1/index.js',
+    sdkController: '/widgets/sdk-controller/sdk/v1/index.js',
+    payouts: '/widgets/payouts/sdk/v1/index.js',
+    payments: '/assets/elements.bundle.min.js',
+    sca: '/hosted-sca/sdk/v1/index.js',
+    taxForm: '/widgets/taxForm/sdk/v1/index.js',
+    billing: '/widgets/checkout/sdk/v1/index.js'
+};
+var ELEMENT_TO_SDK = {
+    // legacy
+    kyc: 'kyc',
+    paymentsKyb: 'paymentsKyb',
+    // rfi elements
+    kycRfi: 'rfi',
+    transactionRfi: 'rfi',
+    paymentEnablementRfi: 'rfi',
+    lendingRfi: 'rfi',
+    mrmRfi: 'rfi',
+    // payouts elements
+    payoutForm: 'payouts',
+    beneficiaryForm: 'payouts',
+    // payment elements
+    hpp: 'payments',
+    cvc: 'payments',
+    card: 'payments',
+    expiry: 'payments',
+    dropIn: 'payments',
+    cardNumber: 'payments',
+    applePayButton: 'payments',
+    googlePayButton: 'payments',
+    krCardNumber: 'payments',
+    krCardIdentifier: 'payments',
+    krCardExpiry: 'payments',
+    krCardPswFirstTwo: 'payments',
+    // sca elements
+    scaSetup: 'sca',
+    scaVerify: 'sca',
+    scaManagement: 'sca',
+    taxForm: 'taxForm',
+    // billing elements
+    embeddedCheckout: 'billing'
+};
+var ELEMENT_GROUP_TO_ELEMENT = {
+    payments: [
+        'hpp',
+        'cvc',
+        'card',
+        'expiry',
+        'dropIn',
+        'cardNumber',
+        'applePayButton',
+        'googlePayButton',
+        'krCardNumber',
+        'krCardIdentifier',
+        'krCardExpiry',
+        'krCardPswFirstTwo',
+    ],
+    payouts: ['payoutForm', 'beneficiaryForm'],
+    onboarding: ['kyc', 'paymentsKyb'],
+    risk: [
+        'scaSetup',
+        'scaVerify',
+        'scaManagement',
+        'transactionRfi',
+        'kycRfi',
+        'paymentEnablementRfi',
+        'lendingRfi',
+        'mrmRfi',
+    ],
+    billing: ['embeddedCheckout']
+};
+var SDK_DEPENDENCIES = {
+    billing: ['payments']
+};
+var DOMAIN_FUNCTIONS_NAMESPACES = ['payments', 'sca'];
+
+var InvalidStaticResourceError = /** @class */ (function (_super) {
+    __extends(InvalidStaticResourceError, _super);
+    function InvalidStaticResourceError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.code = 'INVALID_STATIC_RESOURCE_ERROR';
+        return _this;
+    }
+    return InvalidStaticResourceError;
+}(Error));
+
+var timestamp = Date.now();
+var isElementGroup = function (name) { return Object.keys(ELEMENT_GROUP_TO_ELEMENT).includes(name); };
+var sleep = function (delay) {
+    if (delay === void 0) { delay = 500; }
+    return new Promise(function (resolve) { return window.setTimeout(resolve, delay); });
+};
+var getSDKByElementName = function (elementName) {
+    return ELEMENT_TO_SDK[elementName];
+};
+var getHost = function (name, env) {
+    var host = name === PAYMENTS ? PA_STATIC_HOST : STATIC_HOST;
+    return host[env] || host.prod;
+};
+/**
+ * get the elements and sdks that need registry by controller
+ * @param enabledElements the enabledElements passed in init params
+ * @returns array of deduplicated elementName pair with sdkName
+ */
+var getSDKsByEnabledElements = function (enabledElements) {
+    // e.g., ['hpp', 'payoutForm', 'kyc', 'kyc']
+    var usedElements = enabledElements.reduce(function (elementArr, enabledEle) {
+        return elementArr.concat(isElementGroup(enabledEle)
+            ? ELEMENT_GROUP_TO_ELEMENT[enabledEle]
+            : enabledEle);
+    }, []);
+    return Array.from(new Set(usedElements)).map(function (elementName) { return ({
+        elementName: elementName,
+        sdkName: getSDKByElementName(elementName)
+    }); });
+};
+var getFunctionsByEnabledElements = function (enabledElements) {
+    return Array.from(new Set(getSDKsByEnabledElements(enabledElements)
+        .map(function (_a) {
+        var sdkName = _a.sdkName;
+        return sdkName;
+    })
+        .filter(function (usedSdkName) {
+        return DOMAIN_FUNCTIONS_NAMESPACES.includes(usedSdkName);
+    })));
+};
+var getWindowSDKInstanceName = function (name) {
+    return name === 'payments' ? 'payment' : name;
+};
+/**
+ * get the CDN url of a specific package
+ * @param name declare the element name
+ * @param env the environment of package
+ * @returns string the CDN url
+ */
+var getSDKUrl = function (_a) {
+    var name = _a.name, _b = _a.env, env = _b === void 0 ? ENV.prod : _b;
+    var staticHost = getHost(name, env);
+    var elementUri = SDK_URL_MAPPING[name];
+    if (!elementUri) {
+        logError('[components-sdk] Element static resource not found', {
+            sdkName: name
+        });
+        throw new InvalidStaticResourceError("Element ".concat(name, " static resource URL is invalid."));
+    }
+    return "".concat(staticHost).concat(elementUri, "?ts=").concat(timestamp);
+};
+var getFunctionsInstanceWithNamespace = function () {
+    return DOMAIN_FUNCTIONS_NAMESPACES.reduce(function (result, namespace) {
+        var _a;
+        return (__assign(__assign({}, result), (_a = {}, _a[namespace] = window._AirwallexSDKs.__controller__.internalSDKs[namespace], _a)));
+    }, {});
+};
+var getSDKDependencies = function (sdkName) {
+    return SDK_DEPENDENCIES[sdkName] || [];
+};
+var now = function () { return Math.floor(performance.now()); };
+
+var createScript = function (url) {
+    var script = document.createElement('script');
+    script.src = url;
+    script.type = 'module';
+    var parentDom = document.head || document.body;
+    parentDom.appendChild(script);
+    return script;
+};
+var MAX_RETRY_COUNT = 3;
+var loadScript = function (url) { return __awaiter(void 0, void 0, void 0, function () {
+    var retryCount, tryToResolve;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (typeof window === 'undefined') {
+                    throw new Error('Please load script in browser environment');
+                }
+                retryCount = 0;
+                tryToResolve = function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var start, urlObj, script;
+                    return __generator(this, function (_a) {
+                        start = now();
+                        if (retryCount > 0 && url.includes('?ts=')) {
+                            urlObj = new URL(url, window.location.href);
+                            urlObj.searchParams.set('ts', "".concat(Date.now()));
+                            url = urlObj.toString();
+                        }
+                        script = createScript(url);
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                script.addEventListener('load', function () {
+                                    var end = now();
+                                    logInfo('[components-sdk] SDK script loaded', {
+                                        scriptUrl: url,
+                                        start: start,
+                                        latency: end - start,
+                                        end: end,
+                                        retryCount: retryCount
+                                    });
+                                    resolve(true);
+                                });
+                                script.addEventListener('error', function (err) {
+                                    script.remove();
+                                    console.error(err);
+                                    var end = now();
+                                    logError('[components-sdk] Failed to load script', {
+                                        scriptUrl: url,
+                                        error: err,
+                                        start: start,
+                                        latency: end - start,
+                                        end: end,
+                                        retryCount: retryCount
+                                    });
+                                    reject(new LoadScriptError("Failed to load Airwallex SDK scripts: ".concat(url)));
+                                });
+                            })];
+                    });
+                }); };
+                _a.label = 1;
+            case 1:
+                if (!(retryCount < MAX_RETRY_COUNT)) return [3 /*break*/, 7];
+                _a.label = 2;
+            case 2:
+                _a.trys.push([2, 4, , 6]);
+                return [4 /*yield*/, tryToResolve()];
+            case 3: return [2 /*return*/, _a.sent()];
+            case 4:
+                _a.sent();
+                retryCount++;
+                return [4 /*yield*/, sleep()];
+            case 5:
+                _a.sent();
+                return [3 /*break*/, 6];
+            case 6: return [3 /*break*/, 1];
+            case 7:
+                logError('[components-sdk] Failed to load script after retry', {
+                    scriptUrl: url,
+                    retryCount: retryCount
+                });
+                throw new LoadScriptError("Failed to load Airwallex SDK scripts: ".concat(url));
+        }
+    });
+}); };
+
+var InstanceNotFoundError = /** @class */ (function (_super) {
+    __extends(InstanceNotFoundError, _super);
+    function InstanceNotFoundError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.code = 'INSTANCE_NOT_FOUND_ERROR';
+        return _this;
+    }
+    return InstanceNotFoundError;
+}(Error));
+
+var initPromise$1;
+/**
+ * ensure one script one promise
+ */
+var promiseMap = new Map();
+/**
+ * get the Promise to load the element script
+ * @param scriptName declare the SDK or Functions namespace
+ * @param env the resource url
+ * @returns Promise to load the script
+ */
+var getLoadScriptPromise = function (_a) {
+    var env = _a.env, scriptName = _a.scriptName;
+    var url = getSDKUrl({ name: scriptName, env: env });
+    // if promise was made
+    var sdkPromise = promiseMap.get(scriptName);
+    if (sdkPromise) {
+        return sdkPromise;
+    }
+    var loadScriptPromise = loadScript(url);
+    promiseMap.set(scriptName, loadScriptPromise);
+    return loadScriptPromise;
+};
+/**
+ * Load an SDK script along with its dependencies
+ * @param scriptName the SDK name to load
+ * @param env the environment
+ * @returns Promise that resolves when the SDK and all its dependencies are loaded
+ */
+var loadSDKWithDependencies = function (_a) {
+    var env = _a.env, scriptName = _a.scriptName;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var dependencies;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dependencies = getSDKDependencies(scriptName);
+                    if (!(dependencies.length > 0)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, Promise.all(dependencies.map(function (dep) { return getLoadScriptPromise({ env: env, scriptName: dep }); }))];
+                case 1:
+                    _b.sent();
+                    _b.label = 2;
+                case 2: return [2 /*return*/, getLoadScriptPromise({ env: env, scriptName: scriptName })];
+            }
+        });
+    });
+};
+/**
+ * SDK init, load controller script
+ * @param options SDK init options
+ * @returns Promise to load the script
+ */
+var init = function (options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (typeof window === 'undefined') {
+            throw new Error('Please call the `init()` function in a browser environment.');
+        }
+        // initialize airTracker
+        initializeAirTracker(options.env, options.clientId);
+        logInfo('[components-sdk] SDK init start', {
+            options: maskPII(options),
+            start: now()
+        });
+        initPromise$1 = new Promise(function (resolve, reject) {
+            var _a;
+            var initOptions = __assign(__assign({}, options), { env: options.env && ENV[options.env] ? options.env : ENV.prod });
+            window.AirwallexComponentsSDK.__env__ = initOptions.env;
+            // load SDK controller script
+            var controllerPromise = getLoadScriptPromise({
+                env: initOptions.env,
+                scriptName: SDK_CONTROLLER
+            }).then(function () { return window._AirwallexSDKs.__controller__.init(initOptions); });
+            // For old version backward compatibility
+            var enabledElements = (_a = options.enabledElements) !== null && _a !== void 0 ? _a : [];
+            var functionsNamespaces = getFunctionsByEnabledElements(enabledElements);
+            // load SDK functions scripts
+            var functionsPromises = functionsNamespaces.map(function (functionsNamespace) {
+                return getLoadScriptPromise({
+                    env: initOptions.env,
+                    scriptName: functionsNamespace
+                })
+                    .then(function () { return controllerPromise; })
+                    .then(function () {
+                    var instance = window._AirwallexSDKs[getWindowSDKInstanceName(functionsNamespace)];
+                    if (!instance) {
+                        logError('[components-sdk] SDK instance not found', {
+                            functionsNamespace: functionsNamespace,
+                            windowSDKInstanceName: getWindowSDKInstanceName(functionsNamespace)
+                        });
+                        throw new InstanceNotFoundError("SDK instance not found");
+                    }
+                    return window._AirwallexSDKs.__controller__.registerFunctions({
+                        functionsNamespace: functionsNamespace,
+                        instance: instance
+                    });
+                });
+            });
+            // load SDK elements scripts
+            var enabledSDKs = getSDKsByEnabledElements(enabledElements);
+            var elementsPromises = enabledSDKs.map(function (_a) {
+                var sdkNamespace = _a.sdkName, elementName = _a.elementName;
+                return loadSDKWithDependencies({
+                    scriptName: sdkNamespace,
+                    env: initOptions.env
+                })
+                    .then(function () { return controllerPromise; })
+                    .then(function () {
+                    var instance = window._AirwallexSDKs[getWindowSDKInstanceName(sdkNamespace)];
+                    if (!instance) {
+                        logError('[components-sdk] SDK instance not found', {
+                            sdkName: sdkNamespace,
+                            windowSDKInstanceName: getWindowSDKInstanceName(sdkNamespace)
+                        });
+                        throw new InstanceNotFoundError("SDK instance not found");
+                    }
+                    return window._AirwallexSDKs.__controller__.registerElement({
+                        sdkName: sdkNamespace,
+                        elementName: elementName,
+                        instance: instance
+                    });
+                });
+            });
+            Promise.all(__spreadArray(__spreadArray([controllerPromise], functionsPromises, true), elementsPromises, true))
+                .then(function () {
+                logInfo('[components-sdk] SDK initialized', {
+                    options: maskPII(options),
+                    start: now()
+                });
+                resolve(getFunctionsInstanceWithNamespace());
+            })["catch"](function (error) {
+                if (!error.code) {
+                    logError('[components-sdk] Unexpected errors when init', { error: error });
+                }
+                reject(error);
+            });
+        });
+        return [2 /*return*/, initPromise$1];
+    });
+}); };
+/**
+ * load SDK element script and call SDK instance.createElement.
+ * @param elementName the element name to create
+ * @param options createElement options
+ * @returns return type of SDK instance.createElement
+ */
+var createElement = function (elementName, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var sdkName, start, elementInstance, end, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!elementName) {
+                    throw new Error('Element type is missing. Please specify a valid element.');
+                }
+                logInfo('[components-sdk] SDK createElement start', {
+                    elementName: elementName,
+                    options: maskPII(options),
+                    timestamp: now()
+                });
+                if (!initPromise$1) {
+                    logWarning('[components-sdk] Did not call init before createElement');
+                    throw new Error('Please initialize the Element before creating it.');
+                }
+                return [4 /*yield*/, initPromise$1];
+            case 1:
+                _a.sent();
+                sdkName = getSDKByElementName(elementName);
+                if (!sdkName) {
+                    throw new Error("`createElement()` with type `".concat(elementName, "` is not supported. Please specify a valid Element type."));
+                }
+                start = now();
+                _a.label = 2;
+            case 2:
+                _a.trys.push([2, 6, , 7]);
+                return [4 /*yield*/, loadSDKWithDependencies({
+                        scriptName: sdkName,
+                        env: window.AirwallexComponentsSDK.__env__ || ENV.prod
+                    })];
+            case 3:
+                _a.sent();
+                return [4 /*yield*/, window._AirwallexSDKs.__controller__.registerElement({
+                        sdkName: sdkName,
+                        elementName: elementName,
+                        instance: window._AirwallexSDKs[getWindowSDKInstanceName(sdkName)]
+                    })];
+            case 4:
+                _a.sent();
+                return [4 /*yield*/, window._AirwallexSDKs.__controller__.createElement(elementName, options)];
+            case 5:
+                elementInstance = _a.sent();
+                end = now();
+                logInfo('[components-sdk] SDK createElement being called', {
+                    elementName: elementName,
+                    options: maskPII(options),
+                    start: start,
+                    latency: end - start,
+                    end: end
+                });
+                return [3 /*break*/, 7];
+            case 6:
+                error_1 = _a.sent();
+                if (!error_1.code) {
+                    logError('[components-sdk] Unexpected errors when createElement', {
+                        error: error_1
+                    });
+                }
+                else {
+                    throw error_1;
+                }
+                return [3 /*break*/, 7];
+            case 7: return [2 /*return*/, elementInstance];
+        }
+    });
+}); };
+
+/**
+ * List of scripts to prefetch
+ */
+var PREFETCH_SCRIPT_LIST = [SDK_CONTROLLER, PAYMENTS];
+/**
+ * Prefetch scripts by preload link, only for production as there's no environment context before SDK init
+ */
+var prefetchScripts = function () {
+    PREFETCH_SCRIPT_LIST.forEach(function (scriptName) {
+        var url = getSDKUrl({ name: scriptName, env: ENV.prod });
+        var preloadLink = document.createElement('link');
+        preloadLink.href = url;
+        preloadLink.rel = 'modulepreload';
+        preloadLink.as = 'script';
+        var parentDom = document.head || document.body;
+        parentDom.appendChild(preloadLink);
+    });
+};
+/**
+ * @airwallex/components-sdk may run in node environment, e.g., in Next.js
+ * Prefetch scripts only in browser environment
+ */
+var isNode = typeof document === 'undefined' || typeof window === 'undefined';
+if (!isNode) {
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', prefetchScripts);
+    }
+    else {
+        prefetchScripts();
+    }
+}
+
+if (typeof window !== 'undefined') {
+    if (!window.AirwallexComponentsSDK) {
+        Object.defineProperties(window, {
+            AirwallexComponentsSDK: {
+                value: {},
+                writable: false
+            },
+            _AirwallexSDKs: {
+                value: {},
+                writable: false
+            }
+        });
+    }
+    window.AirwallexComponentsSDK.init = init;
+    window.AirwallexComponentsSDK.createElement = createElement;
+}
+
+const { onChange: airwallexStoreOnChange, reset: airwallexStoreReset, state: airwallexStore, } = zonosStore.createStore(() => ({
+    clientSecret: null,
+    currency: null,
+    hasPaymentError: false,
+    isReady: false,
+    paymentConfirmed: false,
+    paymentIntentId: null,
+}));
+/**
+ * Populate the store from a collect checkout session response.
+ *
+ * @returns `true` when the session uses Airwallex and has the data required to
+ * render the payment element.
+ */
+const airwallexStoreSetFromSession = (checkoutSession) => {
+    if (checkoutSession.paymentProcessor !== 'AIRWALLEX') {
+        return false;
+    }
+    // Only overwrite when the session provides a value — the client secret /
+    // payment intent id may already have been seeded from the payment-intent
+    // create response, which is more reliable than a follow-up session fetch.
+    if (checkoutSession.clientSecret) {
+        airwallexStore.clientSecret = checkoutSession.clientSecret;
+    }
+    if (checkoutSession.paymentIntentId) {
+        airwallexStore.paymentIntentId = checkoutSession.paymentIntentId;
+    }
+    if (!airwallexStore.clientSecret) {
+        handleFetch.logError('Airwallex checkout session is missing the client secret');
+        return false;
+    }
+    return true;
+};
+/**
+ * Map a Zonos locale to an Airwallex-supported locale. Locales without an
+ * Airwallex equivalent (e.g. Norwegian, Vietnamese, Turkish, Hebrew) fall back
+ * to English.
+ */
+const airwallexLocaleByCode = {
+    ar: 'ar',
+    da: 'da',
+    de: 'de',
+    en: 'en',
+    es: 'es',
+    fr: 'fr',
+    id: 'id',
+    it: 'it',
+    ja: 'ja',
+    ko: 'ko',
+    nl: 'nl',
+    pl: 'pl',
+    pt: 'pt',
+    ru: 'ru',
+    sv: 'sv',
+    zh: 'zh',
+};
+const airwallexStoreGetLocale = (locale) => airwallexLocaleByCode[locale] || 'en';
+// Ensure the SDK is only initialized once, even across re-renders/components.
+let initPromise = null;
+/**
+ * Load and initialize the Airwallex components SDK (idempotent). Uses the `prod`
+ * environment only when the API is in production and the checkout mode is `LIVE`
+ * (mirrors how PayPal decides production vs. sandbox), otherwise `demo`, so the
+ * SDK environment matches the payment intents created by the checkout backend.
+ * Also uses the shopper's selected locale from localization.
+ *
+ * @returns `true` once the SDK is ready to create elements.
+ */
+const airwallexStoreInitSdk = async () => {
+    if (airwallexStore.isReady) {
+        return true;
+    }
+    if (!initPromise) {
+        // Production only when the API is in production environment and the checkout
+        // mode is `LIVE` (not sandbox) — same rule as the PayPal integration.
+        const isProduction = (!zonosStore.zonosStore.zonosMode || zonosStore.zonosStore.zonosMode === 'production') &&
+            zonosStore.zonosStore.checkoutSettings.mode === 'LIVE';
+        initPromise = init({
+            enabledElements: ['payments'],
+            env: isProduction ? 'prod' : 'demo',
+            locale: airwallexStoreGetLocale(localization.localizationStore.selectedLocale),
+        })
+            .then(() => {
+            airwallexStore.isReady = true;
+            VarianceTest.log('Airwallex SDK initialized');
+            return true;
+        })
+            .catch((err) => {
+            handleFetch.logError(err);
+            // Allow a later retry by clearing the cached promise.
+            initPromise = null;
+            return false;
+        });
+    }
+    return initPromise;
+};
+/**
+ * Statuses that mean the payment has gone through (or is on its way with no
+ * further action required from the customer) — i.e. the order should move to the
+ * finish step rather than render the payment form.
+ */
+const airwallexPaidStatuses = [
+    'SUCCEEDED',
+    'REQUIRES_CAPTURE',
+    'PENDING_REVIEW',
+    'PENDING',
+];
+/**
+ * Whether the given status means the payment is settled or in progress (no
+ * further customer action required).
+ */
+const airwallexStoreIsPaidStatus = (status) => !!status && airwallexPaidStatuses.includes(status);
+/**
+ * Map an Airwallex payment intent status to a customer-facing message and an
+ * error flag — the Airwallex equivalent of `stripeStoreMessageBasedOnStatus`.
+ * @see https://www.airwallex.com/docs/payments/reference/payment-statuses
+ */
+const airwallexStoreMessageBasedOnStatus = (status) => {
+    switch (status) {
+        // The payment is complete.
+        case 'SUCCEEDED': {
+            return {
+                isError: false,
+                messages: [
+                    localization.translate('Thank you for submitting your payment. We appreciate your prompt attention.'),
+                    '',
+                    localization.translate('A confirmation email with your payment details has been sent for your records. If you have any questions or need support, our team is here to help.'),
+                ],
+            };
+        }
+        // Authorized / pending the final result — no further action required.
+        case 'PENDING':
+        case 'PENDING_REVIEW':
+        case 'REQUIRES_CAPTURE': {
+            return {
+                isError: false,
+                messages: [
+                    localization.translate("Payment processing. We'll update you when payment is received."),
+                ],
+            };
+        }
+        // Waiting for further customer action (e.g. 3DS verification).
+        case 'REQUIRES_CUSTOMER_ACTION': {
+            return {
+                isError: false,
+                messages: [
+                    localization.translate('Your selected payment method requires additional verification. Please follow the instructions provided by your payment provider to complete the transaction.'),
+                ],
+            };
+        }
+        // Not paid (awaiting a payment method) or canceled.
+        case 'CANCELLED':
+        case 'REQUIRES_PAYMENT_METHOD': {
+            return {
+                isError: true,
+                messages: [
+                    localization.translate('Payment failed. Please reload the page and try another payment method.'),
+                ],
+            };
+        }
+        default: {
+            return {
+                isError: true,
+                messages: [localization.translate('Something went wrong.')],
+            };
+        }
+    }
+};
+/**
+ * Retrieve the latest Airwallex payment intent status by id.
+ *
+ * @returns the status, or `null` when the lookup failed.
+ */
+const airwallexStoreRetrievePaymentIntent = async (paymentIntentId) => {
+    const { errors, json } = await handleFetch.handleFetch('/api/zonos-elements/collect/airwallex-payment-intent', {
+        body: {
+            paymentIntentId,
+        },
+        method: 'POST',
+    });
+    if (errors.length || !json) {
+        handleFetch.logError('Failed to retrieve Airwallex payment intent', errors);
+        return { status: null };
+    }
+    return { status: json.airwallexPaymentIntent.status };
+};
+
+const { reset: collectStoreReset, state: collectStore } = zonosStore.createStore(() => ({
+    amountDutyTaxFeeTotal: null,
+    amountTotalPaid: null,
+    collectLogoUrl: null,
+    isFetchingShippingInfo: true,
+    landedCostShortId: null,
+    originCompanyName: null,
+    partyBillingId: null,
+    paymentProcessor: null,
+    shippingAddress: null,
+}));
+const collectStoreInitShippingInfo = async ({ landedCostId, retries = 5, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    collectStore.isFetchingShippingInfo = true;
+    const response = await handleFetch.handleFetch('/api/zonos-elements/collect/get-shipping-info-by-lc-id', {
+        body: {
+            landedCostId,
+        },
+        method: 'POST',
+    });
+    if (response.errors.length) {
+        if (retries > 0) {
+            // Wait for 1 second before retrying
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Keep retrying until we get the shipping address or we run out of retries
+            return collectStoreInitShippingInfo({
+                landedCostId,
+                retries: retries - 1,
+            });
+        }
+        return null;
+    }
+    collectStore.landedCostShortId = ((_a = response.json) === null || _a === void 0 ? void 0 : _a.landedCostShortId) || null;
+    collectStore.isFetchingShippingInfo = false;
+    collectStore.shippingAddress = ((_b = response.json) === null || _b === void 0 ? void 0 : _b.shipping) || null;
+    const landedCost = (_c = cart.cartStore.checkoutSession) === null || _c === void 0 ? void 0 : _c.landedCost;
+    const checkoutSessionSubtotals = (_d = cart.cartStore.checkoutSession) === null || _d === void 0 ? void 0 : _d.subtotals;
+    const amountTotalPaid = (((_e = landedCost === null || landedCost === void 0 ? void 0 : landedCost.amountSubtotals) === null || _e === void 0 ? void 0 : _e.shipping) || 0) +
+        (((_f = landedCost === null || landedCost === void 0 ? void 0 : landedCost.amountSubtotals) === null || _f === void 0 ? void 0 : _f.items) || 0);
+    // Convert the amount to the presentment currency
+    collectStore.amountTotalPaid =
+        amountTotalPaid * (((_g = checkoutSessionSubtotals === null || checkoutSessionSubtotals === void 0 ? void 0 : checkoutSessionSubtotals.exchangeRate) === null || _g === void 0 ? void 0 : _g.rate) || 1);
+    collectStore.amountDutyTaxFeeTotal =
+        ((checkoutSessionSubtotals === null || checkoutSessionSubtotals === void 0 ? void 0 : checkoutSessionSubtotals.duties) || 0) +
+            ((checkoutSessionSubtotals === null || checkoutSessionSubtotals === void 0 ? void 0 : checkoutSessionSubtotals.taxes) || 0) +
+            ((checkoutSessionSubtotals === null || checkoutSessionSubtotals === void 0 ? void 0 : checkoutSessionSubtotals.fees) || 0);
+    collectStore.originCompanyName = ((_j = (_h = response.json) === null || _h === void 0 ? void 0 : _h.origin) === null || _j === void 0 ? void 0 : _j.companyName) || null;
+    collectStore.collectLogoUrl = ((_k = response.json) === null || _k === void 0 ? void 0 : _k.collectLogoUrl) || null;
+    if (collectStore.amountTotalPaid === 0) {
+        void handleFetch.sendErrorLog({
+            endpoint: 'COLLECT_NO_TOTAL_PAID',
+            errors: [],
+            metadata: {
+                landedCostId,
+                organizationId: zonosStore.zonosStore.organizationId,
+            },
+        });
+    }
+};
+const collectStoreAsyncAddressUpdate = async () => {
+    var _a, _b, _c, _d;
+    if (!((_a = cart.stripeStore.stripeBillingAddressEventData) === null || _a === void 0 ? void 0 : _a.complete)) {
+        return {
+            partiesCreated: false,
+        };
+    }
+    const landedCostRootId = (_c = (_b = cart.cartStore.checkoutSession) === null || _b === void 0 ? void 0 : _b.landedCost) === null || _c === void 0 ? void 0 : _c.rootId;
+    if (!landedCostRootId) {
+        // do nothing if we don't have selected landed cost
+        void handleFetch.sendErrorLog({
+            endpoint: 'PF_NO_SELECTED_LANDED_COST',
+            errors: ['No selected landed cost'],
+            metadata: {
+                allLogs: VarianceTest.allLogs,
+                cartId: window.Zonos.cartId,
+                checkoutSessionId: localization.storageStore.checkoutSessionId,
+            },
+        });
+        return {
+            partiesCreated: false,
+        };
+    }
+    if (!localization.storageStore.checkoutSessionId) {
+        void handleFetch.sendErrorLog({
+            endpoint: 'COLLECT_NO_CHECKOUT_SESSION_ID',
+            errors: ['No checkout session id'],
+            metadata: {
+                allLogs: VarianceTest.allLogs,
+                cartId: window.Zonos.cartId,
+                landedCostRootId,
+            },
+        });
+        return {
+            partiesCreated: false,
+        };
+    }
+    const billingAddress = cart.stripeStoreBuildAddressForPartyCreate({
+        address: cart.stripeStore.stripeBillingAddressEventData.value.address,
+        firstName: cart.stripeStore.stripeBillingAddressEventData.value.firstName,
+        lastName: cart.stripeStore.stripeBillingAddressEventData.value.lastName,
+        name: cart.stripeStore.stripeBillingAddressEventData.value.name,
+        phone: cart.stripeStore.stripeBillingAddressEventData.value.phone,
+    });
+    const isE2ETest = new URLSearchParams(window.location.search).get('zonosE2ETest') === '1';
+    const { errors, json } = await handleFetch.handleFetch('/api/zonos-elements/create-billing-party', {
+        body: {
+            billingAddress,
+            checkoutSessionId: localization.storageStore.checkoutSessionId,
+            companyName: cart.stripeStore.companyName,
+            email: ((_d = cart.stripeStore.stripeLinkEventData) === null || _d === void 0 ? void 0 : _d.value.email) || '',
+            isTest: isE2ETest,
+            rootId: landedCostRootId,
+        },
+        method: 'POST',
+    });
+    if (errors.length || !json) {
+        handleFetch.logError('Error occurs when creating billing party', JSON.stringify(errors, null, 2));
+        void handleFetch.sendErrorLog({
+            endpoint: 'COLLECT_BILLING_PARTY_CREATE_FAILED',
+            errors: ['[COLLECT] Failed to create billing party'],
+            metadata: {
+                allLogs: VarianceTest.allLogs,
+                cartId: window.Zonos.cartId,
+                checkoutSessionId: localization.storageStore.checkoutSessionId,
+                errors,
+                json,
+            },
+        });
+        return {
+            partiesCreated: false,
+        };
+    }
+    collectStore.partyBillingId = json.billToPartyId;
+    return {
+        partiesCreated: true,
+    };
+};
+const collectStoreUpdateSelectedShippingOption = async (checkoutSession) => {
+    const landedCost = checkoutSession.landedCost;
+    if (!landedCost) {
+        return false;
+    }
+    // Convert the landed cost to the format that cartStore expects
+    cart.cartStore.landedCostData = [
+        Object.assign(Object.assign({}, checkoutSession), { landedCost: Object.assign({}, landedCost), landedCostId: landedCost.id }),
+    ];
+    return cart.cartStoreUpdateSelectedShippingOption({
+        // No need to update checkout session again, we already called it when starting collect, only need to apply subtotals here to utilize the cart store
+        applySubtotalsOnly: true,
+        landedCostId: landedCost.id,
+        selectedShippingOption: landedCost.shipmentRating,
+    });
+};
+
+exports.airwallexStore = airwallexStore;
+exports.airwallexStoreGetLocale = airwallexStoreGetLocale;
+exports.airwallexStoreInitSdk = airwallexStoreInitSdk;
+exports.airwallexStoreIsPaidStatus = airwallexStoreIsPaidStatus;
+exports.airwallexStoreMessageBasedOnStatus = airwallexStoreMessageBasedOnStatus;
+exports.airwallexStoreOnChange = airwallexStoreOnChange;
+exports.airwallexStoreReset = airwallexStoreReset;
+exports.airwallexStoreRetrievePaymentIntent = airwallexStoreRetrievePaymentIntent;
+exports.airwallexStoreSetFromSession = airwallexStoreSetFromSession;
+exports.collectStore = collectStore;
+exports.collectStoreAsyncAddressUpdate = collectStoreAsyncAddressUpdate;
+exports.collectStoreInitShippingInfo = collectStoreInitShippingInfo;
+exports.collectStoreUpdateSelectedShippingOption = collectStoreUpdateSelectedShippingOption;
+exports.createElement = createElement;