@zonos/elements 1.3.270 → 1.3.273

package/dist/esm/collect-a235299d.js

@@ -0,0 +1,3092 @@
+import { c as createStore, z as zonosStore } from './zonosStore-8e19daff.js';
+import { t as translate, l as localizationStore, s as storageStore } from './localization-17546792.js';
+import { l as logError$1, h as handleFetch, s as sendErrorLog } from './handleFetch-a844cac1.js';
+import { l as log, b as allLogs } from './VarianceTest-572cecf5.js';
+import { b as stripeStore, K as stripeStoreBuildAddressForPartyCreate, d as cartStore, L as cartStoreUpdateSelectedShippingOption } from './cart-23e29950.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 = "./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,
+	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, } = 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) {
+        logError$1('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.zonosMode || zonosStore.zonosMode === 'production') &&
+            zonosStore.checkoutSettings.mode === 'LIVE';
+        initPromise = init({
+            enabledElements: ['payments'],
+            env: isProduction ? 'prod' : 'demo',
+            locale: airwallexStoreGetLocale(localizationStore.selectedLocale),
+        })
+            .then(() => {
+            airwallexStore.isReady = true;
+            log('Airwallex SDK initialized');
+            return true;
+        })
+            .catch((err) => {
+            logError$1(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: [
+                    translate('Thank you for submitting your payment. We appreciate your prompt attention.'),
+                    '',
+                    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: [
+                    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: [
+                    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: [
+                    translate('Payment failed. Please reload the page and try another payment method.'),
+                ],
+            };
+        }
+        default: {
+            return {
+                isError: true,
+                messages: [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('/api/zonos-elements/collect/airwallex-payment-intent', {
+        body: {
+            paymentIntentId,
+        },
+        method: 'POST',
+    });
+    if (errors.length || !json) {
+        logError$1('Failed to retrieve Airwallex payment intent', errors);
+        return { status: null };
+    }
+    return { status: json.airwallexPaymentIntent.status };
+};
+
+const { reset: collectStoreReset, state: collectStore } = 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('/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 = cartStore.checkoutSession) === null || _c === void 0 ? void 0 : _c.landedCost;
+    const checkoutSessionSubtotals = (_d = 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 sendErrorLog({
+            endpoint: 'COLLECT_NO_TOTAL_PAID',
+            errors: [],
+            metadata: {
+                landedCostId,
+                organizationId: zonosStore.organizationId,
+            },
+        });
+    }
+};
+const collectStoreAsyncAddressUpdate = async () => {
+    var _a, _b, _c, _d;
+    if (!((_a = stripeStore.stripeBillingAddressEventData) === null || _a === void 0 ? void 0 : _a.complete)) {
+        return {
+            partiesCreated: false,
+        };
+    }
+    const landedCostRootId = (_c = (_b = 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 sendErrorLog({
+            endpoint: 'PF_NO_SELECTED_LANDED_COST',
+            errors: ['No selected landed cost'],
+            metadata: {
+                allLogs,
+                cartId: window.Zonos.cartId,
+                checkoutSessionId: storageStore.checkoutSessionId,
+            },
+        });
+        return {
+            partiesCreated: false,
+        };
+    }
+    if (!storageStore.checkoutSessionId) {
+        void sendErrorLog({
+            endpoint: 'COLLECT_NO_CHECKOUT_SESSION_ID',
+            errors: ['No checkout session id'],
+            metadata: {
+                allLogs,
+                cartId: window.Zonos.cartId,
+                landedCostRootId,
+            },
+        });
+        return {
+            partiesCreated: false,
+        };
+    }
+    const billingAddress = stripeStoreBuildAddressForPartyCreate({
+        address: stripeStore.stripeBillingAddressEventData.value.address,
+        firstName: stripeStore.stripeBillingAddressEventData.value.firstName,
+        lastName: stripeStore.stripeBillingAddressEventData.value.lastName,
+        name: stripeStore.stripeBillingAddressEventData.value.name,
+        phone: stripeStore.stripeBillingAddressEventData.value.phone,
+    });
+    const isE2ETest = new URLSearchParams(window.location.search).get('zonosE2ETest') === '1';
+    const { errors, json } = await handleFetch('/api/zonos-elements/create-billing-party', {
+        body: {
+            billingAddress,
+            checkoutSessionId: storageStore.checkoutSessionId,
+            companyName: stripeStore.companyName,
+            email: ((_d = stripeStore.stripeLinkEventData) === null || _d === void 0 ? void 0 : _d.value.email) || '',
+            isTest: isE2ETest,
+            rootId: landedCostRootId,
+        },
+        method: 'POST',
+    });
+    if (errors.length || !json) {
+        logError$1('Error occurs when creating billing party', JSON.stringify(errors, null, 2));
+        void sendErrorLog({
+            endpoint: 'COLLECT_BILLING_PARTY_CREATE_FAILED',
+            errors: ['[COLLECT] Failed to create billing party'],
+            metadata: {
+                allLogs,
+                cartId: window.Zonos.cartId,
+                checkoutSessionId: 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
+    cartStore.landedCostData = [
+        Object.assign(Object.assign({}, checkoutSession), { landedCost: Object.assign({}, landedCost), landedCostId: landedCost.id }),
+    ];
+    return 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,
+    });
+};
+
+export { airwallexStoreSetFromSession as a, airwallexStore as b, collectStore as c, airwallexStoreRetrievePaymentIntent as d, airwallexStoreIsPaidStatus as e, airwallexStoreInitSdk as f, collectStoreUpdateSelectedShippingOption as g, collectStoreInitShippingInfo as h, collectStoreAsyncAddressUpdate as i, airwallexStoreMessageBasedOnStatus as j, airwallexStoreReset as k, createElement as l, airwallexStoreGetLocale as m, airwallexStoreOnChange as n };