monitor-track 1.10.0

package/dist/index.js

@@ -0,0 +1,1534 @@
+var ShuyunTrack = (function (axios, uuid, uaParserJs, rrweb, ErrorStackParser, html2canvas) {
+    'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return Object.freeze(n);
+    }
+
+    var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+    var rrweb__namespace = /*#__PURE__*/_interopNamespace(rrweb);
+    var ErrorStackParser__default = /*#__PURE__*/_interopDefaultLegacy(ErrorStackParser);
+    var html2canvas__default = /*#__PURE__*/_interopDefaultLegacy(html2canvas);
+
+    /******************************************************************************
+    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.
+    ***************************************************************************** */
+
+    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 };
+        }
+    }
+
+    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 shuyunTrackId = 'shuyun-track-id';
+    var shuyunTrackSessionId = 'shuyun-track-session-id';
+
+    /*
+     * @Author: Mark.Zhang
+     * @Description 配置项相关参数及方法
+     */
+    /**  */
+    /**
+     * @description config配置项默认值
+     */
+    var Config = {
+        reportUrl: '',
+        projectID: '',
+        maxLength: 1000,
+        spa: false,
+        hash: false,
+        enableBehavior: true,
+        enableError: true,
+        enableVisualTrack: false,
+        ignore: {
+            urls: [],
+            errors: [],
+            apis: []
+        }
+    };
+    /**
+     * @description 设置config配置项
+     * @param config 配置项
+     */
+    function setConfig(config) {
+        Object.assign(Config, config);
+    }
+
+    /*
+     * @Author: Mark.Zhang
+     * @Date: 2020-10-26 11:10:04
+     * @Description 资源加载错误及js错误相关的处理方法
+     */
+    var eventsMatrix = [[]];
+    rrweb__namespace.record({
+        emit: function (event, isCheckout) {
+            // isCheckout 是一个标识，告诉你重新制作了快照
+            if (isCheckout) {
+                eventsMatrix.push([]);
+            }
+            if (eventsMatrix.length > 2) {
+                eventsMatrix.shift();
+            }
+            var lastEvents = eventsMatrix[eventsMatrix.length - 1];
+            lastEvents.push(event);
+        },
+        // 每30秒重新制作快照
+        checkoutEveryNms: 30 * 1000
+    });
+    /**
+     * @description 错误事件触发后的操作
+     */
+    function handleError(event) {
+        setReportValue('type', 'error');
+        if (event.type === 'error') {
+            if (event instanceof ErrorEvent) {
+                setCaughtError(event);
+            }
+            else {
+                setResourceError(event);
+            }
+        }
+        else if (event.type === 'unhandledrejection') {
+            setPromiseError(event);
+        }
+    }
+    /**
+     * @description 设置错误信息
+     */
+    function setCaughtError(event) {
+        var _a, _b;
+        if (ignoreError(event.message)) {
+            return;
+        }
+        var filename = event.filename, line = event.lineno, column = event.colno, functionName = '', stackFrame = JSON.stringify([]);
+        if (event.error && event.error.stack) {
+            var error = ErrorStackParser__default["default"].parse(event.error);
+            stackFrame = JSON.stringify(error);
+            var info = error.find(function (item) { return item.fileName && !/node_modules|vendor|bundle/.test(item.fileName); });
+            if (info) {
+                filename = info.fileName;
+                line = Number(info.lineNumber);
+                column = Number(info.columnNumber);
+                functionName = info.functionName || '';
+            }
+        }
+        setReportValue('error', {
+            subType: 'js',
+            line: line,
+            column: column,
+            message: event.message,
+            filename: filename,
+            functionName: functionName,
+            stack: ((_b = (_a = event === null || event === void 0 ? void 0 : event.error) === null || _a === void 0 ? void 0 : _a.stack) === null || _b === void 0 ? void 0 : _b.substring(0, Config.maxLength)) || '',
+            stackFrame: stackFrame,
+            events: getUserEvents(false)
+        });
+        report(getReport());
+    }
+    /**
+     * @description 设置异步错误信息
+     */
+    function setPromiseError(event) {
+        var message = event.reason;
+        if (event.reason && typeof event.reason === 'object') {
+            message = JSON.stringify(event.reason);
+            if (message === '{}') {
+                message = event.reason.stack;
+            }
+        }
+        if (ignoreError(message)) {
+            return;
+        }
+        setReportValue('error', {
+            subType: 'async',
+            message: message,
+            events: getUserEvents(false)
+        });
+        report(getReport());
+    }
+    /**
+     * @description 设置资源错误信息
+     */
+    function setResourceError(event) {
+        var target = event.target;
+        if (ignoreError(target.outerHTML)) {
+            return;
+        }
+        setReportValue('error', {
+            subType: 'resource',
+            message: target.outerHTML,
+            filename: target.src || target.currentSrc,
+            stack: target.localName.toUpperCase().substring(0, Config.maxLength),
+            events: getUserEvents(false)
+        });
+        report(getReport());
+    }
+    /**
+     * 忽略的error
+     * @param errorMsg 错误信息
+     */
+    function ignoreError(errorMsg) {
+        var _a;
+        var errors = ((_a = Config === null || Config === void 0 ? void 0 : Config.ignore) === null || _a === void 0 ? void 0 : _a.errors) || [];
+        var existIgnoreError = errors.findIndex(function (item) {
+            if (typeof item === 'string') {
+                return item === errorMsg;
+            }
+            else if (Object.prototype.toString.call(item) === '[object Object]') {
+                if (item.regExp && typeof item.input === 'string') {
+                    var regex = new RegExp(item.input, 'g');
+                    return regex.test(errorMsg);
+                }
+                return false;
+            }
+            else {
+                return false;
+            }
+        });
+        return existIgnoreError > -1;
+    }
+    /**
+     * 获取用户最近得操作,视频录像时间应当在30秒到60秒之间
+     */
+    var lastGetTime = Date.now(); //缓存操作录像，防止段时间内大量获取录像数据导滞内存溢出
+    function getUserEvents(notUseCache) {
+        var events;
+        if (Date.now() - lastGetTime > 2000 || notUseCache) {
+            lastGetTime = Date.now();
+            if (eventsMatrix.length >= 2) {
+                var finalVideoData = eventsMatrix[eventsMatrix.length - 1];
+                events = JSON.stringify(eventsMatrix[eventsMatrix.length - 2].concat(finalVideoData));
+                if (events.length > 1024 * 1024 * 15 && JSON.stringify(finalVideoData).length > 1024 * 1024) {
+                    //如果录像数据量太大且最后那个分片的数据量不算小，那么缩短上报的录像时长
+                    events = JSON.stringify(eventsMatrix[eventsMatrix.length - 1]);
+                }
+            }
+            else {
+                events = JSON.stringify(eventsMatrix);
+            }
+        }
+        return events;
+    }
+    function getFullScreenShoot(filename) {
+        var name = filename || uuid.v4();
+        return html2canvas__default["default"](document.body).then(function (canvas) {
+            var _a;
+            var urlData = canvas.toDataURL('image/png', 1);
+            var bytes = window.atob(urlData.split(',')[1]);
+            var mime = (_a = urlData.split(',')[0].match(/:(.*?);/)) === null || _a === void 0 ? void 0 : _a[1];
+            var ab = new ArrayBuffer(bytes.length);
+            var ia = new Uint8Array(ab);
+            for (var i = 0; i < bytes.length; i++) {
+                ia[i] = bytes.charCodeAt(i);
+            }
+            var file = new File([ab], "".concat(name, ".png"), { type: mime });
+            return file;
+        });
+    }
+
+    /** 上报数据映射 */
+    var reportMap = {
+        /** SDK 版本 */
+        version: '_v',
+        /** 项目ID */
+        projectID: 'pid',
+        /** location.host */
+        host: 'host',
+        /** 用户uuid */
+        uuid: '_id',
+        /** 上报日志的时间戳 */
+        time: 'time',
+        /** 源页面 */
+        originPage: 'o',
+        /** 当前页面 */
+        page: 'p',
+        /** 自定义payload */
+        customPayload: 'cP',
+        /** 信息类型 */
+        type: 't',
+        /** viewport的宽高 */
+        viewport: 'vp',
+        /** 屏幕宽高 */
+        screen: 'sc',
+        /** 页面title */
+        pageTitle: 'pt',
+        /** 页面referrer */
+        referrer: 'ref',
+        /** 页面编码 */
+        charset: 'char',
+        /** language */
+        language: 'lan',
+        /** vendor， 浏览器厂商 */
+        navigatorVendor: 'nV',
+        /** 网络连接类型 */
+        connectionType: 'cT',
+        /** 浏览器名称 */
+        browserName: 'bN',
+        /** 浏览器版本 */
+        browserVersion: 'bV',
+        /** 浏览器引擎名称 */
+        engineName: 'enN',
+        /** 浏览器引擎版本 */
+        engineVersion: 'enV',
+        /** 操作系统名称 */
+        osName: 'osN',
+        /** 操作系统版本 */
+        osVersion: 'osV',
+        pv: {
+            /** 子类型 */
+            subType: 'suT',
+            /** 停留时间 */
+            stayTime: 'sT'
+        },
+        error: {
+            /** 子类型 */
+            subType: 'suT',
+            /** 错误行 */
+            line: 'line',
+            /** 错误列 */
+            column: 'col',
+            /** 错误信息 */
+            message: 'msg',
+            /** 错误文件 */
+            filename: 'fil',
+            /** 错误函数名 */
+            functionName: 'fn',
+            /** 错误栈信息 */
+            stack: '_st',
+            /** 错误帧 */
+            stackFrame: '_sf',
+            /** 视频录制数据 */
+            events: 'evt',
+            /** 页面截图 */
+            picture: 'pic'
+        },
+        ua: {
+            /** 子类型 */
+            subType: 'suT',
+            /** x轴坐标 */
+            x: 'x',
+            /** y轴坐标 */
+            y: 'y',
+            /** 元素路径 */
+            path: 'path'
+        },
+        /** 性能数据 */
+        perf: {
+            navigation: {
+                /**
+               *一个无符号短整型，表示是如何导航到这个页面的。可能的值如下:
+                TYPE_NAVIGATE (0)
+                当前页面是通过点击链接，书签和表单提交，或者脚本操作，或者在url中直接输入地址，type值为0
+                TYPE_RELOAD (1)
+                点击刷新页面按钮或者通过Location.reload()方法显示的页面，type值为1
+                The page was accessed by clicking the Reload button or via the Location.reload() method.
+                TYPE_BACK_FORWARD (2)
+                页面通过历史记录和前进后退访问时。type值为2
+                TYPE_RESERVED (255)
+                任何其他方式，type值为255
+              */
+                type: 't',
+                /** 无符号短整型，表示在到达这个页面之前重定向了多少次。 */
+                redirectCount: 'rc'
+            },
+            memory: {
+                /** 上下文内可用堆的最大体积，以字节计算。 */
+                jsHeapSizeLimit: 'hsl',
+                /** 已分配的堆体积，以字节计算。 */
+                totalJSHeapSize: 'ths',
+                /** 当前 JS 堆活跃段（segment）的体积，以字节计算。 */
+                usedJSHeapSize: 'uhs'
+            },
+            /** 返回性能测量开始时的时间的高精度时间戳。 */
+            timeOrigin: 'to',
+            timing: {
+                /** 是一个无符号long long 型的毫秒数，返回浏览器与服务器之间的连接建立时的Unix毫秒时间戳。如果建立的是持久连接，则返回值等同于fetchStart属性的值。连接建立指的是所有握手和认证过程全部结束。 */
+                connectEnd: 'ce',
+                /** 是一个无符号long long 型的毫秒数，返回HTTP请求开始向服务器发送时的Unix毫秒时间戳。如果使用持久连接（persistent connection），则返回值等同于fetchStart属性的值 */
+                connectStart: 'cs',
+                /** 是一个无符号long long 型的毫秒数，返回当前文档解析完成，即Document.readyState 变为 'complete'且相对应的readystatechange (en-US) 被触发时的Unix毫秒时间戳。 */
+                domComplete: 'dc',
+                /** 是一个无符号long long 型的毫秒数，返回当所有需要立即执行的脚本已经被执行（不论执行顺序）时的Unix毫秒时间戳。 */
+                domContentLoadedEventEnd: 'scLee',
+                /** 是一个无符号long long 型的毫秒数，返回当解析器发送DOMContentLoaded (en-US) 事件，即所有需要被执行的脚本已经被解析时的Unix毫秒时间戳。 */
+                domContentLoadedEventStart: 'dcLes',
+                /** 是一个无符号long long 型的毫秒数，返回当前网页DOM结构结束解析、开始加载内嵌资源时（即Document.readyState属性变为“interactive”、相应的readystatechange (en-US)事件触发时）的Unix毫秒时间戳。 */
+                domInteractive: 'di',
+                /** 是一个无符号long long 型的毫秒数，返回当前网页DOM结构开始解析时（即Document.readyState属性变为“loading”、相应的 readystatechange (en-US)事件触发时）的Unix毫秒时间戳。 */
+                domLoading: 'dl',
+                /** 是一个无符号long long 型的毫秒数，表征了域名查询结束的UNIX时间戳。如果使用了持续连接(persistent connection)，或者这个信息存储到了缓存或者本地资源上，这个值将和 PerformanceTiming.fetchStart一致。 */
+                domainLookupEnd: 'dle',
+                /** 是一个无符号long long 型的毫秒数，表征了域名查询开始的UNIX时间戳。如果使用了持续连接(persistent connection)，或者这个信息存储到了缓存或者本地资源上，这个值将和 PerformanceTiming.fetchStart一致。 */
+                domainLookupStart: 'dls',
+                /** 是一个无符号long long 型的毫秒数，表征了浏览器准备好使用HTTP请求来获取(fetch)文档的UNIX时间戳。这个时间点会在检查任何应用缓存之前。 */
+                fetchStart: 'fs',
+                /** 是一个无符号long long 型的毫秒数，返回当load (en-US)事件结束，即加载事件完成时的Unix毫秒时间戳。如果这个事件还未被发送，或者尚未完成，它的值将会是0. */
+                loadEventEnd: 'lee',
+                /** 是一个无符号long long 型的毫秒数，返回该文档下，load (en-US)事件被发送时的Unix毫秒时间戳。如果这个事件还未被发送，它的值将会是0。 */
+                loadEventStart: 'les',
+                /** 是一个无符号long long 型的毫秒数，表征了从同一个浏览器上下文的上一个文档卸载(unload)结束时的UNIX时间戳。如果没有上一个文档，这个值会和PerformanceTiming.fetchStart相同 */
+                navigationStart: 'ns',
+                /** 是一个无符号long long 型的毫秒数，表征了最后一个HTTP重定向完成时（也就是说是HTTP响应的最后一个比特直接被收到的时间）的UNIX时间戳。如果没有重定向，或者重定向中的一个不同源，这个值会返回0. */
+                redirectEnd: 're',
+                /** 是一个无符号long long 型的毫秒数，表征了第一个HTTP重定向开始时的UNIX时间戳。如果没有重定向，或者重定向中的一个不同源，这个值会返回0. */
+                redirectStart: 'redS',
+                /** 是一个无符号long long 型的毫秒数，返回浏览器向服务器发出HTTP请求时（或开始读取本地缓存时）的Unix毫秒时间戳。 */
+                requestStart: 'reqS',
+                /** 是一个无符号long long 型的毫秒数，返回浏览器从服务器收到（或从本地缓存读取，或从本地资源读取）最后一个字节时（如果在此之前HTTP连接已经关闭，则返回关闭时）的Unix毫秒时间戳。 */
+                responseEnd: 'resE',
+                /** 是一个无符号long long 型的毫秒数，返回浏览器从服务器收到（或从本地缓存读取）第一个字节时的Unix毫秒时间戳。如果传输层在开始请求之后失败并且连接被重开，该属性将会被数制成新的请求的相对应的发起时间。 */
+                responseStart: 'resS',
+                /** 是一个无符号long long 型的毫秒数，返回浏览器与服务器开始安全链接的握手时的Unix毫秒时间戳。如果当前网页不要求安全连接，则返回0。 */
+                secureConnectionStart: 'scs',
+                /** 是一个无符号long long 型的毫秒数，表征了unload (en-US)事件处理完成时的UNIX时间戳。如果没有上一个文档，or if the previous document, or one of the needed redirects, is not of the same origin, 这个值会返回0. */
+                unloadEventEnd: 'uee',
+                /** 是一个无符号long long 型的毫秒数，表征了unload (en-US)事件抛出时的UNIX时间戳。如果没有上一个文档，or if the previous document, or one of the needed redirects, is not of the same origin, 这个值会返回0. */
+                unloadEventStart: 'ees'
+            }
+        },
+        /** api请求相关 */
+        req: {
+            /** 请求类型,xhr或fetch */
+            requestType: 'rT',
+            /** 请求地址 */
+            responseURL: 'url',
+            /** 请求结果 */
+            status: 'stat',
+            /** 请求耗时 */
+            loadTime: 'lT',
+            /** 请求状态 */
+            statusText: 'sT',
+            /** 上报原因, slow或failed */
+            reason: 're',
+            /** 上报时带上的详细信息 */
+            detail: 'de'
+        },
+        vD: {
+            /** 埋点名称 */
+            trackName: 'tN',
+            /** 埋点参数 */
+            params: 'params'
+        },
+        manualReport: 'mR',
+        lifeCycleId: 'li',
+        sessionId: 'sI'
+    };
+    var xhrFunc = function (filename, userId, asyncUpdateId, file, res, callback, rest) {
+        var formData = new FormData();
+        for (var i in rest) {
+            if (Object.prototype.hasOwnProperty.call(rest, i)) {
+                formData.append(i, rest[i]);
+            }
+        }
+        formData.append('filename', filename);
+        formData.append('asyncUpdateId', asyncUpdateId); //用于上传到oss后异步更新到db的id
+        formData.append('userId', userId);
+        formData.append('files', file);
+        var xhr = new XMLHttpRequest();
+        xhr.addEventListener('error', function () { return res(); }, false);
+        xhr.open('POST', Config.reportUrl);
+        xhr.onreadystatechange = function () {
+            var _a;
+            if (xhr.readyState === 4) {
+                if (xhr.status === 200) {
+                    try {
+                        var response = xhr.responseText;
+                        var resp = JSON.parse(response);
+                        callback((_a = resp.result) === null || _a === void 0 ? void 0 : _a.response);
+                    }
+                    catch (_err) {
+                        //
+                    }
+                    res();
+                }
+                else {
+                    res();
+                }
+            }
+        };
+        xhr.send(formData);
+    };
+    var ERROR_MESSAGE_MAP = {};
+    function reportFunc(data) {
+        var _a, _b, _c;
+        var payload = convertToSchema(data, reportMap);
+        payload.time = new Date().getTime(); // 设置上报时间
+        var picturePromise = Promise.resolve();
+        var hasErrorEvent = false;
+        var filename = uuid.v4();
+        if (data.type === 'error') {
+            var message_1 = ((_a = data.error) === null || _a === void 0 ? void 0 : _a.message) || 'default';
+            if (((_b = data.error) === null || _b === void 0 ? void 0 : _b.subType) === 'resource') {
+                message_1 = 'resource';
+            }
+            if (ERROR_MESSAGE_MAP[message_1]) ;
+            else {
+                ERROR_MESSAGE_MAP[message_1] = true;
+                setTimeout(function () {
+                    //节流效果，每隔3秒上报一次重复的错误录像和错误截图
+                    delete ERROR_MESSAGE_MAP[message_1];
+                }, 3000);
+                var p_1 = payload.p, pid_1 = payload.pid, host_1 = payload.host, bN_1 = payload.bN, pt_1 = payload.pt;
+                if ((_c = data.error) === null || _c === void 0 ? void 0 : _c.events) {
+                    hasErrorEvent = true;
+                    var errorEvent_1 = data.error.events;
+                    var delayTime = Math.ceil(Math.random() * 10000);
+                    setTimeout(function () {
+                        var blob = new Blob([errorEvent_1], { type: 'text/json' });
+                        return new Promise(function (res) {
+                            xhrFunc("".concat(filename, ".json"), data.uuid, filename, blob, res, function () { }, { p: p_1, pid: pid_1, host: host_1, bN: bN_1, pt: pt_1 });
+                        });
+                    }, delayTime < 3500 ? 3500 : delayTime);
+                }
+                picturePromise = getFullScreenShoot(filename)
+                    .then(function (file) {
+                    return new Promise(function (res) {
+                        xhrFunc(file.name, data.uuid, filename, file, res, function (result) {
+                            payload.error.pic = result;
+                        }, { p: p_1, pid: pid_1, host: host_1, bN: bN_1, pt: pt_1 });
+                    });
+                })["catch"](function (err) {
+                    payload.error.picError = (err === null || err === void 0 ? void 0 : err.stack) || (err === null || err === void 0 ? void 0 : err.toString());
+                });
+            }
+        }
+        return picturePromise
+            .then(function () {
+            var _a;
+            if ((_a = payload.error) === null || _a === void 0 ? void 0 : _a.evt)
+                delete payload.error.evt;
+            if (window && window.navigator && typeof window.navigator.sendBeacon === 'function') {
+                var formData_1 = new FormData();
+                Object.keys(payload).forEach(function (key) {
+                    var value = payload[key];
+                    if (value !== null && value !== undefined) {
+                        if (typeof value === 'object') {
+                            value = JSON.stringify(value);
+                        }
+                        formData_1.append(key, value);
+                    }
+                });
+                //eventErrorFilename,将错误录像的文件名附在错误上报的埋点里，便于将错误录像上报回调地址异步的更新到db
+                if (hasErrorEvent)
+                    formData_1.append('eef', filename);
+                window.navigator.sendBeacon(Config.reportUrl, formData_1);
+            }
+            else {
+                if (hasErrorEvent)
+                    payload.eef = filename;
+                new Image().src = "".concat(Config.reportUrl, "?").concat(serialize(payload));
+            }
+        })["catch"](function (_err) {
+            //
+        });
+    }
+    // 上报
+    function report(data) {
+        return new Promise(function (res) {
+            //在帧的空闲时间上报
+            var dataCopy = JSON.parse(JSON.stringify(data));
+            if (typeof window.requestIdleCallback === 'function') {
+                window.requestIdleCallback(function () { return reportFunc(dataCopy).then(res); }, { timeout: 2000 });
+            }
+            else {
+                setTimeout(function () { return reportFunc(dataCopy).then(res); }, 0);
+            }
+        });
+    }
+    /**
+     * @description 将数据转换成最终提交的数据，主要目的是简化数据的key的长度，从而降低荷载大小
+     * @param data 要转换的数据
+     * @param map 要转换的数据的字段映射
+     * @param redundancyData 冗余数据
+     */
+    function convertToSchema(data, map, redundancyData) {
+        var reportData = {};
+        if (redundancyData) {
+            map = __assign(__assign({}, map), redundancyData);
+        }
+        for (var _i = 0, _a = Object.entries(map); _i < _a.length; _i++) {
+            var result = _a[_i];
+            var _b = result, key = _b[0], mapKey = _b[1];
+            if (key === 'manualReport') {
+                reportData[mapKey] = data[key];
+            }
+            else {
+                //字段值为数组的场景，直接转换
+                if (typeof data[key] === 'object' && !Array.isArray(data[key])) {
+                    if (data[key]) {
+                        if (redundancyData && Object.prototype.hasOwnProperty.call(redundancyData, key)) {
+                            reportData[key] = data[key];
+                        }
+                        else {
+                            reportData[key] = convertToSchema(data[key], map[key]);
+                        }
+                    }
+                    else {
+                        reportData[key] = data[key];
+                    }
+                }
+                else {
+                    // 排除undefined
+                    if (data[key] !== undefined) {
+                        reportData[mapKey] = data[key];
+                    }
+                }
+            }
+        }
+        return reportData;
+    }
+
+    /* eslint-disable prefer-rest-params */
+    /** 路由栈数组，存储路由变化信息 */
+    var routerStack = [];
+    /** 路由触发的时间 */
+    var time = 0;
+    /**
+     * @description 派发pushState， replaceState 的监听
+     * @param type
+     */
+    function _history(type) {
+        var origin = history[type];
+        return function () {
+            // @ts-ignore
+            var r = origin.apply(this, arguments);
+            var e = new Event(type);
+            // @ts-ignore
+            e.arguments = arguments;
+            window.dispatchEvent(e);
+            return r;
+        };
+    }
+    /**
+     * @description 处理history变化
+     * @param e history事件
+     */
+    function handleHistoryChange(__e) {
+        visualTrackFunc();
+        setReport();
+    }
+    /**
+     * 设置信息并触发上报
+     */
+    function setReport() {
+        var pageUrl = location.href;
+        /**
+         * 此判断的逻辑是因为spa且hash模式下，路由搜索参数更改也会触发handleHistoryChange事件
+         * 所以路由栈中的信息只保存无搜索参数的地址
+         */
+        if (Config.hash && Config.spa) {
+            var currentUrlSplit = location.href.split('#');
+            var currentUrlPostfix = '';
+            if (currentUrlSplit[1]) {
+                var index = currentUrlSplit[1].indexOf('?');
+                if (index > -1) {
+                    currentUrlPostfix = currentUrlSplit[1].substring(0, index);
+                }
+                else {
+                    currentUrlPostfix = currentUrlSplit[1];
+                }
+            }
+            var currentUrlResult = "".concat(currentUrlSplit[0], "#").concat(currentUrlPostfix);
+            pageUrl = currentUrlResult;
+        }
+        var _a = setRouteStack(pageUrl), originPage = _a.originPage, page = _a.page;
+        // 愿页面等于当前页面，说明无路由变更。只有spa且hash模式下才会出现
+        if (originPage === page) {
+            return;
+        }
+        var currentTime = new Date().getTime();
+        // 页面停留时间
+        var stayTime = currentTime - time;
+        // 设置触发路由变化的时间
+        time = currentTime;
+        // 设置信息
+        setReportValue('originPage', originPage);
+        setReportValue('page', page);
+        setReportValue('type', 'pv');
+        setReportValue('pv', { stayTime: stayTime });
+        // 上报数据
+        report(getReport());
+    }
+    function setPVTime() {
+        time = new Date().getTime();
+    }
+    /**
+     * @description 添加路由栈信息
+     * @param page 页面信息
+     */
+    function setRouteStack(page) {
+        if (typeof page === 'string') {
+            routerStack.push(page);
+        }
+        else {
+            routerStack = routerStack.concat(page);
+        }
+        // 路由栈只需保留两个来作为源页面和当前页面
+        routerStack = routerStack.slice(-2);
+        return {
+            originPage: routerStack[0],
+            page: routerStack[1] || routerStack[0]
+        };
+    }
+
+    var version = "1.10.0";
+
+    // 上报数据
+    var Report = {
+        uuid: '',
+        projectID: '',
+        host: '',
+        originPage: '',
+        page: '',
+        time: 0,
+        browserName: '',
+        browserVersion: '',
+        engineName: '',
+        engineVersion: '',
+        language: '',
+        navigatorVendor: '',
+        connectionType: '2g',
+        osName: '',
+        osVersion: '',
+        type: 'init',
+        viewport: '',
+        screen: '',
+        version: '',
+        charset: '',
+        pageTitle: '',
+        referrer: '',
+        pv: null,
+        ua: null,
+        error: null,
+        dpr: 1,
+        perf: null,
+        vD: undefined,
+        manualReport: undefined,
+        lifeCycleId: uuid.v4(),
+        sessionId: getSessionId()
+    };
+    /**
+     * @description 初始化上报数据并上报
+     */
+    function initReport() {
+        if (document.readyState === 'complete') {
+            initReportFunc();
+        }
+        else {
+            // 注意：这里不要使用window.onload，因为一个项目window.onload只能用一次，如果这里用了就会影响宿主项目的功能
+            window.addEventListener('load', initReportFunc);
+        }
+    }
+    function initReportFunc() {
+        setRouteStack([location.href, location.href]);
+        setPVTime();
+        Report = __assign(__assign({}, getReport()), {
+            page: location.href,
+            originPage: location.href,
+            type: 'init',
+            perf: performance,
+            sessionId: getSessionId(),
+            lifeCycleId: uuid.v4()
+        });
+        report(Report);
+    }
+    /**
+     * @description 设置Report的值
+     * @param key Report key
+     * @param value Report 值
+     */
+    function setReportValue(key, value) {
+        if (Object.prototype.hasOwnProperty.call(Report, key)) {
+            if (['pv', 'ua', 'error', 'request'].includes(key)) {
+                Report = __assign(__assign({}, Report), {
+                    pv: null,
+                    ua: null,
+                    error: null,
+                    req: null,
+                    manualReport: undefined,
+                    perf: null
+                });
+            }
+            Report[key] = value;
+        }
+    }
+    /**
+     * @description 获取上报数据
+     */
+    function getReport() {
+        var nav = getNavigator();
+        var viewport = getViewport();
+        return __assign(__assign(__assign({}, Report), nav), {
+            version: version,
+            projectID: Config.projectID,
+            host: location.host,
+            uuid: getUid(),
+            viewport: viewport,
+            screen: "".concat(screen.width, " x ").concat(screen.height),
+            pageTitle: document.title,
+            referrer: document.referrer,
+            charset: document.charset,
+            customPayload: Config.customPayload,
+            dpr: window.devicePixelRatio
+        });
+    }
+    function ajaxEventTrigger(event) {
+        var ajaxEvent = new CustomEvent(event, {
+            detail: this
+        });
+        window.dispatchEvent(ajaxEvent);
+    }
+    var OldXHR = window.XMLHttpRequest;
+    function newXHR() {
+        var realXHR = new OldXHR();
+        realXHR.addEventListener('loadstart', function () {
+            ajaxEventTrigger.call(this, 'ajaxLoadStart');
+        }, false);
+        realXHR.addEventListener('loadend', function () {
+            ajaxEventTrigger.call(this, 'ajaxLoadEnd');
+        }, false);
+        // 此处的捕获的异常会连日志接口也一起捕获，如果日志上报接口异常了，就会导致死循环了。
+        realXHR.onerror = function (e) {
+            // eslint-disable-next-line no-console
+            console.warn('realXHR.onerror, e', e);
+        };
+        return realXHR;
+    }
+    /**
+     * 页面接口请求监控
+     */
+    var tempUrlInfo = {};
+    var recordXMLHttpRequestLog = function (XMLHttpRequestTimeout) {
+        XMLHttpRequestTimeout = typeof XMLHttpRequestTimeout === 'number' ? XMLHttpRequestTimeout : 1000;
+        var timeRecordArray = [];
+        window.__XMLHttpRequest__ = window.XMLHttpRequest;
+        window.XMLHttpRequest = newXHR;
+        window.addEventListener('ajaxLoadStart', function (e) {
+            var tempObj = {
+                timeStamp: new Date().getTime(),
+                event: e
+            };
+            timeRecordArray.push(tempObj);
+        });
+        window.addEventListener('ajaxLoadEnd', function () {
+            var timeRecordArrayCopy = [].concat(timeRecordArray);
+            var _loop_1 = function (i) {
+                if (timeRecordArrayCopy[i].event.detail && timeRecordArrayCopy[i].event.detail.status > 0) {
+                    var currentTime = new Date().getTime();
+                    var _a = timeRecordArrayCopy[i].event.detail, responseURL_1 = _a.responseURL, status_1 = _a.status, statusText = _a.statusText, timeStamp = _a.timeStamp;
+                    var previousTime = timeStamp || timeRecordArrayCopy[i].timeStamp;
+                    var loadTime = currentTime - previousTime;
+                    var request = {
+                        requestType: 'xhr',
+                        responseURL: responseURL_1,
+                        status: status_1,
+                        loadTime: loadTime,
+                        statusText: statusText,
+                        reason: '',
+                        detail: ''
+                    };
+                    if (loadTime && loadTime > XMLHttpRequestTimeout) {
+                        request.reason = 'slow';
+                        request.detail = "request is too slow, XMLHttpRequestTimeout: ".concat(XMLHttpRequestTimeout);
+                    }
+                    else if (status_1 && status_1 >= 300 && statusText && statusText.toLowerCase() !== 'ok') {
+                        request.reason = 'failed';
+                        request.detail = "request is failed, status: ".concat(status_1, ", statusText: ").concat(statusText);
+                    }
+                    else ;
+                    if (request.reason) {
+                        if (!tempUrlInfo[responseURL_1]) {
+                            tempUrlInfo[responseURL_1] = true;
+                            setTimeout(function () {
+                                delete tempUrlInfo[responseURL_1];
+                            }, 10);
+                            setReportValue('error', null);
+                            report(__assign(__assign({}, getReport()), {
+                                page: location.href,
+                                originPage: location.href,
+                                type: 'request',
+                                req: request
+                            }));
+                        }
+                    }
+                }
+                // 当前请求成功后就在数组中移除掉
+                timeRecordArray.splice(i, 1);
+            };
+            for (var i = 0; i < timeRecordArrayCopy.length; i++) {
+                _loop_1(i);
+            }
+        });
+    };
+    var hackFetch = function (XMLHttpRequestTimeout) {
+        XMLHttpRequestTimeout = typeof XMLHttpRequestTimeout === 'number' ? XMLHttpRequestTimeout : 1000;
+        if (typeof window.fetch === 'function') {
+            var __fetch__1 = window.fetch;
+            window.__fetch__ = __fetch__1;
+            window.fetch = function (t) {
+                var args = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    args[_i - 1] = arguments[_i];
+                }
+                var begin = Date.now();
+                //禁用数组的扩展运算符,否则portal的生产环境会报Uncaught TypeError: Object(...) is not a function,
+                //编译后的__spreadArray函数有问题,而这个函数来自于tslib.具体报错原因不知.
+                //其他平台使用数组的扩展运算符没有问题,比如前端监控平台的管理界面
+                var params = [].concat(t).concat(args);
+                return __fetch__1
+                    .apply(window, params)
+                    .then(function (res) {
+                    var response = res.clone();
+                    var headers = response.headers;
+                    if (headers && typeof headers.get === 'function') {
+                        var ct = headers.get('content-type');
+                        if (ct && !/(text)|(json)/.test(ct)) {
+                            return res;
+                        }
+                    }
+                    var loadTime = Date.now() - begin;
+                    response
+                        .text()
+                        .then(function (result) {
+                        var url = response.url, status = response.status, statusText = response.statusText, ok = response.ok;
+                        var request = {
+                            requestType: 'fetch',
+                            responseURL: url,
+                            status: status,
+                            loadTime: loadTime,
+                            statusText: statusText,
+                            reason: '',
+                            detail: ''
+                        };
+                        if (!ok || status >= 300) {
+                            request.reason = 'failed';
+                            request.detail = "request is failed, status: ".concat(status, ", statusText: ").concat(statusText);
+                        }
+                        else if (loadTime > XMLHttpRequestTimeout) {
+                            request.reason = 'slow';
+                            request.detail = "request is too slow, XMLHttpRequestTimeout: ".concat(XMLHttpRequestTimeout, ", result: ").concat(result === null || result === void 0 ? void 0 : result.slice(0, 500));
+                        }
+                        if (request.reason) {
+                            if (!tempUrlInfo[url]) {
+                                tempUrlInfo[url] = true;
+                                setTimeout(function () {
+                                    delete tempUrlInfo[url];
+                                }, 10);
+                                setReportValue('error', null);
+                                report(__assign(__assign({}, getReport()), {
+                                    page: location.href,
+                                    originPage: location.href,
+                                    type: 'request',
+                                    req: request
+                                }));
+                            }
+                        }
+                    })["catch"](function (err) {
+                        // eslint-disable-next-line no-console
+                        console.log('hackFetch response.text() err', err);
+                    });
+                    return res;
+                })["catch"](function (err) {
+                    // eslint-disable-next-line no-console
+                    console.log('hackFetch err', err);
+                });
+            };
+        }
+    };
+
+    /*
+     * @Author: Mark.Zhang
+     * @Date: 2020-10-26 11:10:04
+     * @Description 用户行为处理方法
+     */
+    /**
+     * @description 点击事件触发后的操作
+     */
+    function handleClick(event) {
+        var target = event.target;
+        if (target.nodeName === 'INPUT' || target.nodeName === 'TEXTAREA') {
+            return;
+        }
+        var path = getElmPath(target);
+        if (path) {
+            setReportValue('type', 'ua');
+            setReportValue('ua', {
+                subType: 'ui.click',
+                x: event.x,
+                y: event.y,
+                path: path
+            });
+            report(getReport());
+        }
+    }
+    /**
+     * @description 点击触发失焦后的操作
+     */
+    function handleBlur(event) {
+        var target = event.target;
+        if (target.nodeName !== 'INPUT' && target.nodeName !== 'TEXTAREA') {
+            return;
+        }
+        var path = getElmPath(target);
+        if (path) {
+            setReportValue('type', 'ua');
+            setReportValue('ua', {
+                subType: 'ui.blur',
+                x: event.x,
+                y: event.y,
+                path: path,
+                value: target.value
+            });
+            report(getReport());
+        }
+    }
+    /**
+     * @description 滚动的操作
+     */
+    var timeout$1;
+    function handleScroll(_event) {
+        clearTimeout(timeout$1);
+        timeout$1 = setTimeout(function () {
+            setReportValue('type', 'ua');
+            setReportValue('ua', {
+                subType: 'ui.scroll'
+            });
+            report(getReport());
+        }, 1000);
+    }
+
+    var parser = new uaParserJs.UAParser();
+    /**
+     * @description 获取uuid
+     */
+    function getUid() {
+        var uid = localStorage.getItem(shuyunTrackId) || '';
+        if (!uid) {
+            uid = uuid.v4();
+            localStorage.setItem(shuyunTrackId, uid);
+        }
+        return uid;
+    }
+    /**
+     * @description 获取session id
+     */
+    function getSessionId() {
+        var sessionId = sessionStorage.getItem(shuyunTrackSessionId);
+        if (sessionId) {
+            return sessionId;
+        }
+        else {
+            var id = uuid.v4();
+            sessionStorage.setItem(shuyunTrackSessionId, id);
+            return id;
+        }
+    }
+    /**
+     * @description 获取浏览器信息
+     */
+    function getNavigator() {
+        var _a;
+        var uaResult = parser.getResult();
+        return {
+            language: navigator.language,
+            navigatorVendor: navigator.vendor,
+            connectionType: ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType) || '2g',
+            browserName: uaResult.browser.name || '',
+            browserVersion: uaResult.browser.version || '',
+            engineName: uaResult.engine.name || '',
+            engineVersion: uaResult.engine.version || '',
+            osName: uaResult.os.name || '',
+            osVersion: uaResult.os.version || ''
+        };
+    }
+    /**
+     * @description 获取viewport的宽高
+     */
+    function getViewport() {
+        var w = document.documentElement.clientWidth || document.body.clientWidth;
+        var h = document.documentElement.clientHeight || document.body.clientHeight;
+        return "".concat(w, " x ").concat(h);
+    }
+    /**
+     * @description 获取元素路径，最多保留5层
+     * @param e
+     */
+    var getElmPath = function (target) {
+        if (!target || target.nodeType !== 1) {
+            return '';
+        }
+        var ret = [];
+        // 层数，最多5层
+        var deepLength = 0;
+        // 元素
+        var elm = '';
+        if (typeof target.innerText === 'string') {
+            ret.push("(".concat(target.innerText.substr(0, 50), ")"));
+        }
+        for (var t = target || null; t && deepLength++ < 5 && !((elm = normalTarget(t)) === 'html');) {
+            // eslint-disable-next-line no-sequences
+            ret.push(elm), (t = t.parentNode);
+        }
+        return ret.reverse().join(' > ');
+    };
+    /**
+     * @description 处理html node
+     * @param e
+     */
+    var normalTarget = function (target) {
+        var t, n, r, a, i;
+        var o = [];
+        if (!target || !target.tagName) {
+            return '';
+        }
+        o.push(target.tagName.toLowerCase());
+        if (target.id) {
+            o.push('#'.concat(target.id));
+        }
+        if ((t = target.className) && Object.prototype.toString.call(t) === '[object String]') {
+            for (n = t.split(/\s+/), i = 0; i < n.length; i++) {
+                // className包含active的不加入路径
+                if (n[i].indexOf('active') < 0)
+                    o.push('.'.concat(n[i]));
+            }
+        }
+        var s = ['type', 'name', 'title', 'alt'];
+        for (i = 0; i < s.length; i++) {
+            r = s[i];
+            if ((a = target.getAttribute(r))) {
+                o.push('['.concat(r, '="').concat(a, '"]'));
+            }
+        }
+        return o.join('');
+    };
+    /**
+     * @description 序列化对象
+     * @param obj
+     */
+    function serialize(obj) {
+        var str = [];
+        for (var p in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, p) && typeof obj[p] !== 'undefined') {
+                var value = typeof obj[p] === 'object' ? JSON.stringify(obj[p]) : obj[p];
+                str.push(encodeURIComponent(p) + '=' + encodeURIComponent(value));
+            }
+        }
+        return str.join('&');
+    }
+    /**
+     * @description 注册事件监听
+     * @param event 事件
+     * @param fn 回调方法
+     */
+    var on = function (event, fn) {
+        if (window.addEventListener) {
+            window.addEventListener(event, fn, true);
+        }
+        else {
+            window.attachEvent("on".concat(event), fn);
+        }
+    };
+    /**
+     * @description 移除事件监听
+     * @param event 事件
+     * @param fn 回调方法
+     */
+    var off = function (event, fn) {
+        if (window.removeEventListener) {
+            return window.removeEventListener(event, fn);
+        }
+        else {
+            return window.detachEvent("on".concat(event), fn);
+        }
+    };
+    var formatTrackElementXPath = function (xPath) {
+        var result = [];
+        var array = xPath.split('/');
+        array.forEach(function (item) {
+            if (!['svg', 'path', 'g', 'image', 'text', 'line', 'rect', 'polygon', 'circle', 'ellipse'].some(function (child) {
+                if (item.toLowerCase().split('[')[0] === child) {
+                    result.push("/*[name()=\"".concat(child, "\"]"));
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            })) {
+                result.push(item);
+            }
+        });
+        return result.join('/');
+    };
+    var formatElementXPath = function (info) {
+        var _a;
+        var elementXPathValue = '';
+        var elementXPath = info.elementXPath;
+        if (elementXPath) {
+            var xpathElement = document.evaluate(formatTrackElementXPath(elementXPath), document).iterateNext();
+            elementXPathValue = xpathElement ? (_a = (xpathElement.textContent || xpathElement.value)) === null || _a === void 0 ? void 0 : _a.trim() : '';
+        }
+        return {
+            elementXPath: elementXPath,
+            elementXPathValue: elementXPathValue
+        };
+    };
+    var existTrackListenEvent = {};
+    var elements = [];
+    var timeout;
+    var visualTrackFunc = function () {
+        if (Config.enableVisualTrack) {
+            if (timeout)
+                clearTimeout(timeout);
+            timeout = setTimeout(function () {
+                timeout = null;
+                var url = location.href.split('?')[0];
+                axios__default["default"]
+                    .get("".concat(Config.reportUrl.replace('/s/r', ''), "/visual/get_data_list?url=").concat(encodeURIComponent(url)))
+                    .then(function (res) {
+                    var _a, _b;
+                    var listData = (_b = (_a = res.data.result) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.dataList;
+                    if (Array.isArray(listData)) {
+                        try {
+                            listData.forEach(function (item) {
+                                if (item.trackType === 'mount') {
+                                    visualReportEvent(item);
+                                }
+                                else {
+                                    var element = document
+                                        .evaluate(formatTrackElementXPath(item.trackElementXPath), document)
+                                        .iterateNext();
+                                    var key = url + item.trackElementXPath;
+                                    if (element) {
+                                        if (!existTrackListenEvent[key]) {
+                                            existTrackListenEvent[key] = true;
+                                            elements.push(element);
+                                            //@ts-ignore
+                                            element.setAttribute('visual-track-data-attr', JSON.stringify(item));
+                                            element.addEventListener('click', clickEventFunc);
+                                        }
+                                    }
+                                    else {
+                                        var func_1 = function () {
+                                            var _a;
+                                            var _b = getNavigator(), browserName = _b.browserName, browserVersion = _b.browserVersion;
+                                            var payload = {
+                                                projectID: Config.projectID,
+                                                version: version,
+                                                url: url,
+                                                trackElementXPath: item.trackElementXPath,
+                                                trackNameInfo: item.trackNameInfo,
+                                                params: item.params,
+                                                customPayload: Config.customPayload,
+                                                type: 'visual_track_xpath_not_found',
+                                                browser: "".concat(browserName, " - ").concat(browserVersion)
+                                            };
+                                            if (typeof ((_a = window.navigator) === null || _a === void 0 ? void 0 : _a.sendBeacon) === 'function') {
+                                                var formData = new FormData();
+                                                for (var i in payload) {
+                                                    if (Object.prototype.hasOwnProperty.call(payload, i)) {
+                                                        var value = payload[i];
+                                                        formData.append(i, value && typeof value === 'object' ? JSON.stringify(value) : value);
+                                                    }
+                                                }
+                                                window.navigator.sendBeacon(Config.reportUrl, formData);
+                                            }
+                                            else {
+                                                new Image().src = "".concat(Config.reportUrl, "?").concat(serialize(payload));
+                                            }
+                                        };
+                                        if (typeof window.requestIdleCallback === 'function') {
+                                            window.requestIdleCallback(function () { return func_1(); }, { timeout: 2000 });
+                                        }
+                                        else {
+                                            setTimeout(function () { return func_1(); }, 0);
+                                        }
+                                    }
+                                }
+                            });
+                        }
+                        catch (err) {
+                            // eslint-disable-next-line no-console
+                            console.log('visual track evaluate err', err);
+                        }
+                    }
+                });
+            }, 1000);
+        }
+    };
+    var visualReportEvent = function (item) {
+        var _a;
+        var _b = formatElementXPath(item.trackNameInfo), elementXPath = _b.elementXPath, elementXPathValue = _b.elementXPathValue;
+        var visualTrackData = {
+            trackType: item.trackType,
+            trackName: elementXPath ? elementXPathValue : item.trackNameInfo.name,
+            params: (_a = item.params) === null || _a === void 0 ? void 0 : _a.map(function (child) {
+                var _a = formatElementXPath(child), elementXPath = _a.elementXPath, elementXPathValue = _a.elementXPathValue;
+                return {
+                    name: child.name,
+                    value: elementXPath ? elementXPathValue : child.value
+                };
+            })
+        };
+        setReportValue('type', 'visual');
+        setReportValue('vD', visualTrackData);
+        report(getReport());
+        setReportValue('vD', undefined);
+    };
+    var clickEventFunc = function (e) {
+        //@ts-ignore
+        var item = JSON.parse(e.target.getAttribute('visual-track-data-attr'));
+        visualReportEvent(item);
+    };
+    var initWindowObjectFunction = function () {
+        if (typeof window.manualReportTrackFunc === 'undefined') {
+            window.manualReportTrackFunc = function (data) {
+                if (Object.prototype.toString.call(data) !== '[object Object]') {
+                    // eslint-disable-next-line no-console
+                    console.warn('manualReportTrackFunc参数必须是一个对象！');
+                }
+                else {
+                    setReportValue('type', 'manual');
+                    setReportValue('manualReport', data);
+                    report(getReport());
+                    setReportValue('manualReport', undefined);
+                }
+            };
+        }
+        if (typeof window.getFullScreenShootFunc === 'undefined') {
+            //下载页面截图
+            window.getFullScreenShootFunc = function (filename) { return __awaiter(void 0, void 0, void 0, function () {
+                var file, url, tagA;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, getFullScreenShoot(filename)];
+                        case 1:
+                            file = _a.sent();
+                            url = window.URL.createObjectURL(file);
+                            tagA = document.createElement('a');
+                            tagA.setAttribute('href', url);
+                            tagA.setAttribute('download', file.name);
+                            tagA.setAttribute('target', '_blank');
+                            document.body.appendChild(tagA);
+                            tagA.click();
+                            document.body.removeChild(tagA);
+                            return [2 /*return*/];
+                    }
+                });
+            }); };
+        }
+        if (typeof window.getRRWebUserEventsCaptureFunc === 'undefined') {
+            window.getRRWebUserEventsCaptureFunc = function () {
+                setReportValue('type', 'error');
+                setReportValue('error', {
+                    subType: 'manual',
+                    message: 'manual trigger',
+                    events: getUserEvents(true)
+                });
+                report(getReport());
+            };
+        }
+    };
+    var prewHref = '';
+    var handleLocationChange = function (e) {
+        var curHref = location.href;
+        // href中`？`后面的值改变，不触发后续动作
+        if (prewHref.split('?')[0] === curHref.split('?')[0]) {
+            return;
+        }
+        prewHref = curHref;
+        handleHistoryChange();
+        elements.forEach(function (element) {
+            element === null || element === void 0 ? void 0 : element.removeEventListener('click', clickEventFunc);
+        });
+        //清空可视化埋点之前的数据
+        existTrackListenEvent = {};
+        elements.length = 0;
+        visualTrackFunc();
+    };
+
+    var Track = /** @class */ (function () {
+        function Track() {
+            this.visualTrack = function () {
+                window.onload = function () {
+                    visualTrackFunc();
+                };
+            };
+        }
+        Track.prototype.init = function (config) {
+            var _a;
+            // 是否开启日志收集
+            if (!config || !config.enable) {
+                return;
+            }
+            // 没有项目ID，则不监听任何事件
+            if (!config.projectID) {
+                // eslint-disable-next-line no-console
+                console.warn('缺少项目ID或token!');
+                return;
+            }
+            // 没有reportUrl
+            if (!config.reportUrl) {
+                // eslint-disable-next-line no-console
+                console.warn('缺少上报地址!');
+                return;
+            }
+            if (this.ignoreUrl(((_a = config === null || config === void 0 ? void 0 : config.ignore) === null || _a === void 0 ? void 0 : _a.urls) || [])) {
+                return;
+            }
+            setConfig(config);
+            initReport();
+            recordXMLHttpRequestLog(config.XMLHttpRequestTimeout);
+            hackFetch(config.XMLHttpRequestTimeout);
+            Config.spa && this.addListenRouterChange();
+            Config.enableBehavior && this.addListenUserActivity();
+            Config.enableError && this.addListenJSUncaught();
+            this.visualTrack();
+            this.addListenUnload();
+            initWindowObjectFunction();
+        };
+        /**
+         * @description 监听错误异常
+         */
+        Track.prototype.addListenJSUncaught = function () {
+            on('error', handleError);
+            on('unhandledrejection', handleError);
+        };
+        /**
+         * @description 监听行为
+         */
+        Track.prototype.addListenUserActivity = function () {
+            on('click', handleClick); // 非输入框点击
+            on('blur', handleBlur); // 输入框失焦
+            on('scroll', handleScroll); // 输入框失焦
+        };
+        /**
+         * @description 监听路由变化
+         */
+        Track.prototype.addListenRouterChange = function () {
+            on('popstate', handleLocationChange);
+            // on('hashchange', pv.handleHashChange);  //触发hashchange的同时也会触发popstate
+            if (Config.spa && !Config.hash) {
+                history.pushState = _history('pushState');
+                history.replaceState = _history('replaceState');
+                on('pushState', handleLocationChange);
+                on('replaceState', handleLocationChange);
+            }
+        };
+        /**
+         * @description 页面将要关闭
+         */
+        Track.prototype.addListenUnload = function () {
+            var _this = this;
+            on('beforeunload', function () {
+                _this.destroy();
+            });
+        };
+        /**
+         * 忽略的url
+         * @param urls
+         */
+        Track.prototype.ignoreUrl = function (urls) {
+            var someUrl = urls.some(function (url) { return location.href.includes(url); });
+            return someUrl;
+        };
+        /**
+         * @description 销毁监听器
+         */
+        Track.prototype.destroy = function () {
+            if (Config.spa) {
+                // off('hashchange', pv.handleHashChange);
+                off('pushState', handleHistoryChange);
+                off('popstate', handleHistoryChange);
+                off('replaceState', handleHistoryChange);
+            }
+            if (Config.enableBehavior) {
+                off('click', handleClick);
+                off('blur', handleBlur);
+                off('scroll', handleScroll);
+            }
+            if (Config.enableError) {
+                off('error', handleError);
+            }
+            sessionStorage.removeItem(shuyunTrackSessionId);
+        };
+        return Track;
+    }());
+
+    return Track;
+
+})(axios, uuid, uaParserJs, rrweb, ErrorStackParser, html2canvas);