@guomain/monitor-web 0.1.0

package/web.cjs.js

@@ -0,0 +1,774 @@
+'use strict';
+
+/******************************************************************************
+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, Iterator */
+
+
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+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 defaultLimits = {
+    maxQueueSize: 50
+};
+function createMonitor(config) {
+    if (!config.appId) {
+        throw new Error('appId is required');
+    }
+    if (!(config.dsn || config.transport)) {
+        throw new Error('dsn or transport is required');
+    }
+    var mergedLimits = __assign(__assign({}, defaultLimits), config.limits);
+    var plugins = [];
+    var pluginTeardowns = [];
+    var queue = [];
+    var queuedKeys = new Set();
+    var draining = false;
+    var idleDrainHandle;
+    var started = false;
+    function defaultTransport(payloads) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!config.dsn) {
+                            return [2];
+                        }
+                        if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+                            sent = navigator.sendBeacon(config.dsn, JSON.stringify(payloads));
+                            if (sent) {
+                                return [2];
+                            }
+                        }
+                        return [4, fetch(config.dsn, {
+                                method: 'POST',
+                                body: JSON.stringify(payloads),
+                                headers: { 'Content-Type': 'application/json' }
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    }
+    var setupPlugin = function (plugin) {
+        try {
+            var teardown = plugin.setup(monitor);
+            if (typeof teardown === 'function') {
+                pluginTeardowns.push(teardown);
+            }
+        }
+        catch (error) {
+            reportSdkError(monitor, error, {
+                stage: 'plugin',
+                pluginName: plugin.name
+            });
+        }
+    };
+    var monitor = {
+        config: config,
+        limits: mergedLimits,
+        start: function () {
+            if (started) {
+                return;
+            }
+            started = true;
+            plugins.forEach(function (plugin) {
+                setupPlugin(plugin);
+            });
+        },
+        stop: function () {
+            if (!started) {
+                return;
+            }
+            started = false;
+            var tasks = pluginTeardowns.splice(0).reverse();
+            tasks.forEach(function (task) {
+                task();
+            });
+        },
+        use: function (plugin) {
+            plugins.push(plugin);
+            if (started) {
+                setupPlugin(plugin);
+            }
+            return monitor;
+        },
+        capture: function (event) {
+            if (!started) {
+                return;
+            }
+            var key = stringifyQueueEvent(event);
+            if (queuedKeys.has(key)) {
+                return;
+            }
+            if (queue.length >= mergedLimits.maxQueueSize) {
+                var removed = queue.shift();
+                if (removed) {
+                    queuedKeys.delete(removed.key);
+                }
+            }
+            queuedKeys.add(key);
+            queue.push({ event: event, key: key });
+            scheduleIdleDrain();
+        },
+        flush: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, drainQueue()];
+                        case 1:
+                            _a.sent();
+                            return [2];
+                    }
+                });
+            });
+        }
+    };
+    function drainQueue() {
+        return __awaiter(this, void 0, void 0, function () {
+            var batch, context_1, _a, error_1, payloads, error_2;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (draining) {
+                            return [2];
+                        }
+                        cancelIdleDrain();
+                        draining = true;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, , 13, 14]);
+                        batch = queue.splice(0);
+                        if (!batch.length) {
+                            return [2];
+                        }
+                        batch.forEach(function (item) {
+                            queuedKeys.delete(item.key);
+                        });
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 7, , 8]);
+                        if (!config.context) return [3, 6];
+                        if (!(typeof config.context === 'function')) return [3, 4];
+                        return [4, config.context()];
+                    case 3:
+                        _a = _c.sent();
+                        return [3, 5];
+                    case 4:
+                        _a = config.context;
+                        _c.label = 5;
+                    case 5:
+                        context_1 = _a;
+                        _c.label = 6;
+                    case 6: return [3, 8];
+                    case 7:
+                        error_1 = _c.sent();
+                        reportSdkError(monitor, error_1, { stage: 'context' });
+                        return [3, 8];
+                    case 8:
+                        payloads = batch.map(function (_a) {
+                            var _b;
+                            var event = _a.event;
+                            return (__assign(__assign({}, event), { timestamp: (_b = event.timestamp) !== null && _b !== void 0 ? _b : Date.now(), appId: config.appId, release: config.release, context: context_1 }));
+                        });
+                        _c.label = 9;
+                    case 9:
+                        _c.trys.push([9, 11, , 12]);
+                        return [4, ((_b = config.transport) !== null && _b !== void 0 ? _b : defaultTransport)(payloads)];
+                    case 10:
+                        _c.sent();
+                        return [3, 12];
+                    case 11:
+                        error_2 = _c.sent();
+                        if (typeof console !== 'undefined' && console.error) {
+                            console.error('[gm-monitor] Transport failed:', error_2);
+                        }
+                        return [3, 12];
+                    case 12: return [3, 14];
+                    case 13:
+                        draining = false;
+                        return [7];
+                    case 14: return [2];
+                }
+            });
+        });
+    }
+    function scheduleIdleDrain() {
+        if (idleDrainHandle !== undefined) {
+            return;
+        }
+        if (typeof requestIdleCallback === 'function') {
+            idleDrainHandle = requestIdleCallback(function () {
+                idleDrainHandle = undefined;
+                void drainQueue();
+            });
+            return;
+        }
+        idleDrainHandle = setTimeout(function () {
+            idleDrainHandle = undefined;
+            void drainQueue();
+        }, 16);
+    }
+    function cancelIdleDrain() {
+        if (idleDrainHandle === undefined) {
+            return;
+        }
+        if (typeof cancelIdleCallback === 'function') {
+            cancelIdleCallback(idleDrainHandle);
+        }
+        else {
+            clearTimeout(idleDrainHandle);
+        }
+        idleDrainHandle = undefined;
+    }
+    return monitor;
+}
+function toErrorEvent(type, error, meta) {
+    if (error instanceof Error) {
+        return __assign({ type: type, message: error.message, stack: error.stack, timestamp: Date.now() }, meta);
+    }
+    var message;
+    if (typeof error === 'string') {
+        message = error;
+    }
+    else if (error === undefined) {
+        message = 'undefined';
+    }
+    else {
+        try {
+            message = JSON.stringify(error);
+        }
+        catch (_a) {
+            message = String(error);
+        }
+    }
+    return __assign({ type: type, message: message, timestamp: Date.now() }, meta);
+}
+function stringifyQueueEvent(event) {
+    return JSON.stringify({
+        type: event.type,
+        message: event.message,
+        url: event.url,
+        stack: event.stack,
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        tags: event.tags,
+        extra: event.extra
+    });
+}
+function reportSdkError(monitor, error, extra) {
+    try {
+        monitor.capture(toErrorEvent('sdk-error', error, { extra: extra }));
+    }
+    catch (_a) {
+        if (typeof console !== 'undefined' && console.error) {
+            console.error('[gm-monitor] SDK internal error:', error);
+        }
+    }
+}
+
+function on(target, type, listener, options) {
+    target.addEventListener(type, listener, options);
+    return function () { return target.removeEventListener(type, listener, options); };
+}
+function getResourceUrl(target) {
+    var _a, _b, _c;
+    if (!(target instanceof Element)) {
+        return undefined;
+    }
+    return ((_c = (_b = (_a = target.getAttribute('src')) !== null && _a !== void 0 ? _a : target.getAttribute('href')) !== null && _b !== void 0 ? _b : target.getAttribute('data')) !== null && _c !== void 0 ? _c : undefined);
+}
+
+function setupPromiseError(monitor) {
+    return on(window, 'unhandledrejection', function (event) {
+        monitor.capture(toErrorEvent('promise-error', event.reason));
+    });
+}
+
+var requestMonitors = new Set();
+var xhrInfo = new WeakMap();
+var originalFetch;
+var originalOpen;
+var originalSend;
+var activeTransportDepth = 0;
+function beginTransportScope() {
+    activeTransportDepth += 1;
+}
+function endTransportScope() {
+    if (activeTransportDepth > 0) {
+        activeTransportDepth -= 1;
+    }
+}
+function setupRequestError(monitor) {
+    requestMonitors.add(monitor);
+    patchFetch();
+    patchXhr();
+    return function () {
+        requestMonitors.delete(monitor);
+        restoreRequestPatch();
+    };
+}
+function patchFetch() {
+    var _this = this;
+    if (originalFetch || typeof fetch !== 'function') {
+        return;
+    }
+    originalFetch = fetch;
+    var localFetch = fetch;
+    globalThis.fetch = (function (input, init) { return __awaiter(_this, void 0, void 0, function () {
+        var info, response, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    info = getFetchInfo(input, init);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4, localFetch(input, init)];
+                case 2:
+                    response = _a.sent();
+                    if (response && !response.ok) {
+                        captureForActiveMonitors(__assign(__assign({}, info), { status: response.status, statusText: response.statusText }));
+                    }
+                    return [2, response];
+                case 3:
+                    error_1 = _a.sent();
+                    captureForActiveMonitors(__assign(__assign({}, info), { error: error_1 }));
+                    throw error_1;
+                case 4: return [2];
+            }
+        });
+    }); });
+}
+function patchXhr() {
+    if (originalOpen || typeof XMLHttpRequest === 'undefined') {
+        return;
+    }
+    var proto = XMLHttpRequest.prototype;
+    originalOpen = proto.open;
+    originalSend = proto.send;
+    proto.open = function open(method, url) {
+        var rest = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            rest[_i - 2] = arguments[_i];
+        }
+        xhrInfo.set(this, { method: method.toUpperCase(), url: String(url) });
+        return originalOpen.apply(this, __spreadArray([method, url], __read(rest), false));
+    };
+    proto.send = function send() {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var captured = false;
+        var handleDone = function (event) {
+            if (captured) {
+                return;
+            }
+            var info = xhrInfo.get(_this);
+            if (!info) {
+                return;
+            }
+            if (_this.status >= 400 || (_this.status === 0 && event.type !== 'loadend')) {
+                captured = true;
+                captureForActiveMonitors(__assign(__assign({}, info), { status: _this.status, statusText: _this.statusText }));
+            }
+        };
+        this.addEventListener('loadend', handleDone, { once: true });
+        this.addEventListener('error', handleDone, { once: true });
+        this.addEventListener('timeout', handleDone, { once: true });
+        return originalSend === null || originalSend === void 0 ? void 0 : originalSend.apply(this, args);
+    };
+}
+function restoreRequestPatch() {
+    if (requestMonitors.size > 0) {
+        return;
+    }
+    if (originalFetch) {
+        globalThis.fetch = originalFetch;
+        originalFetch = undefined;
+    }
+    if (typeof XMLHttpRequest !== 'undefined' && originalOpen && originalSend) {
+        XMLHttpRequest.prototype.open = originalOpen;
+        XMLHttpRequest.prototype.send = originalSend;
+        originalOpen = undefined;
+        originalSend = undefined;
+    }
+}
+function captureForActiveMonitors(info) {
+    if (activeTransportDepth > 0) {
+        return;
+    }
+    requestMonitors.forEach(function (monitor) {
+        if (!isMonitorDsn(monitor, info.url)) {
+            captureRequestError(monitor, info);
+        }
+    });
+}
+function captureRequestError(monitor, info) {
+    monitor.capture({
+        type: 'request-error',
+        message: "Request failed: ".concat(info.method, " ").concat(info.url),
+        timestamp: Date.now(),
+        url: info.url,
+        extra: __assign({}, info)
+    });
+}
+function getFetchInfo(input, init) {
+    var _a, _b, _c;
+    if (input instanceof Request) {
+        return {
+            method: ((_b = (_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : input.method) !== null && _b !== void 0 ? _b : 'GET').toUpperCase(),
+            url: input.url
+        };
+    }
+    return {
+        method: ((_c = init === null || init === void 0 ? void 0 : init.method) !== null && _c !== void 0 ? _c : 'GET').toUpperCase(),
+        url: String(input)
+    };
+}
+function isMonitorDsn(monitor, url) {
+    var dsn = monitor.config.dsn;
+    if (!dsn) {
+        return false;
+    }
+    return normalizeRequestUrl(url) === normalizeRequestUrl(dsn);
+}
+function normalizeRequestUrl(url) {
+    if (typeof URL === 'undefined') {
+        return url;
+    }
+    try {
+        var base = typeof location === 'undefined' ? undefined : location.href;
+        return new URL(url, base).href;
+    }
+    catch (_a) {
+        return url;
+    }
+}
+
+function setupResourceError(monitor) {
+    return on(window, 'error', function (event) {
+        if (event.target === window) {
+            return;
+        }
+        var url = getResourceUrl(event.target);
+        if (!url) {
+            return;
+        }
+        monitor.capture({
+            type: 'resource-error',
+            message: "Resource load failed: ".concat(url),
+            url: url,
+            timestamp: Date.now()
+        });
+    }, true);
+}
+
+function setupRuntimeError(monitor) {
+    return on(window, 'error', function (event) {
+        if (!('message' in event)) {
+            return;
+        }
+        monitor.capture({
+            type: 'runtime-error',
+            message: event.message,
+            stack: event.error instanceof Error ? event.error.stack : undefined,
+            filename: event.filename,
+            lineno: event.lineno,
+            colno: event.colno,
+            timestamp: Date.now()
+        });
+    }, true);
+}
+
+function setupWebError(monitor) {
+    var e_1, _a;
+    var teardowns = [];
+    var setup = [
+        { name: 'runtime', fn: function () { return setupRuntimeError(monitor); } },
+        { name: 'promise', fn: function () { return setupPromiseError(monitor); } },
+        { name: 'resource', fn: function () { return setupResourceError(monitor); } },
+        { name: 'request', fn: function () { return setupRequestError(monitor); } }
+    ];
+    try {
+        for (var setup_1 = __values(setup), setup_1_1 = setup_1.next(); !setup_1_1.done; setup_1_1 = setup_1.next()) {
+            var _b = setup_1_1.value, name_1 = _b.name, fn = _b.fn;
+            try {
+                teardowns.push(fn());
+            }
+            catch (_c) {
+                if (typeof console !== 'undefined' && console.warn) {
+                    console.warn("[gm-monitor] Failed to setup ".concat(name_1, " error listener"));
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (setup_1_1 && !setup_1_1.done && (_a = setup_1.return)) _a.call(setup_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return function () {
+        var cleanupTasks = teardowns.splice(0).reverse();
+        cleanupTasks.forEach(function (task) {
+            try {
+                task();
+            }
+            catch (_a) {
+            }
+        });
+    };
+}
+
+function createWebMonitor(config) {
+    var monitor = createMonitor(__assign(__assign({}, config), { transport: wrapTransport(config.transport) }));
+    var startCore = monitor.start;
+    var stopCore = monitor.stop;
+    var teardowns = [];
+    var ReactBoundary = createReactBoundaryType(monitor);
+    var webStarted = false;
+    monitor.start = function () {
+        if (webStarted) {
+            return;
+        }
+        startCore();
+        try {
+            webStarted = true;
+            if (config.error !== false) {
+                teardowns.push(setupWebError(monitor));
+            }
+            var teardownVue = setupVue(config, monitor);
+            if (teardownVue) {
+                teardowns.push(teardownVue);
+            }
+            teardowns.push(setupFlushOnPageUnload(monitor));
+        }
+        catch (_a) {
+            webStarted = false;
+            runTeardowns(teardowns);
+            stopCore();
+        }
+    };
+    monitor.stop = function () {
+        if (!webStarted) {
+            stopCore();
+            return;
+        }
+        runTeardowns(teardowns);
+        webStarted = false;
+        stopCore();
+    };
+    monitor.renderReact = function (root, element) {
+        root.render(createReactBoundaryElement(ReactBoundary, element));
+    };
+    return monitor;
+}
+function createReactBoundaryType(monitor) {
+    var MonitorReactBoundary = (function () {
+        function MonitorReactBoundary(props) {
+            this.state = { hasError: false };
+            this.props = props;
+        }
+        MonitorReactBoundary.getDerivedStateFromError = function () {
+            return { hasError: true };
+        };
+        MonitorReactBoundary.prototype.componentDidCatch = function (error, info) {
+            monitor.capture(toErrorEvent('react-error', error, { extra: { info: info } }));
+        };
+        MonitorReactBoundary.prototype.render = function () {
+            return this.state.hasError ? null : this.props.children;
+        };
+        return MonitorReactBoundary;
+    }());
+    Object.defineProperty(MonitorReactBoundary.prototype, 'isReactComponent', {
+        value: {}
+    });
+    return MonitorReactBoundary;
+}
+function createReactBoundaryElement(type, children) {
+    return {
+        $$typeof: Symbol.for('react.element'),
+        type: type,
+        key: null,
+        ref: null,
+        props: { children: children },
+        _owner: null
+    };
+}
+function setupVue(config, monitor) {
+    var _a;
+    var app = (_a = config.vue) === null || _a === void 0 ? void 0 : _a.app;
+    if (!app) {
+        return undefined;
+    }
+    var previousHandler = app.config.errorHandler;
+    app.config.errorHandler = function (err, instance, info) {
+        monitor.capture(toErrorEvent('vue-error', err, { extra: { info: info } }));
+        previousHandler === null || previousHandler === void 0 ? void 0 : previousHandler(err, instance, info);
+    };
+    return function () {
+        app.config.errorHandler = previousHandler;
+    };
+}
+function setupFlushOnPageUnload(monitor) {
+    if (typeof window === 'undefined') {
+        return function () { return undefined; };
+    }
+    var handlePageUnload = function () {
+        void monitor.flush();
+    };
+    window.addEventListener('pagehide', handlePageUnload);
+    window.addEventListener('beforeunload', handlePageUnload);
+    return function () {
+        window.removeEventListener('pagehide', handlePageUnload);
+        window.removeEventListener('beforeunload', handlePageUnload);
+    };
+}
+function runTeardowns(teardowns) {
+    var cleanupTasks = teardowns.splice(0).reverse();
+    cleanupTasks.forEach(function (task) {
+        try {
+            task();
+        }
+        catch (_a) {
+        }
+    });
+}
+function wrapTransport(transport) {
+    var _this = this;
+    if (!transport) {
+        return undefined;
+    }
+    return function (payloads) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    beginTransportScope();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 3, 4]);
+                    return [4, transport(payloads)];
+                case 2:
+                    _a.sent();
+                    return [3, 4];
+                case 3:
+                    endTransportScope();
+                    return [7];
+                case 4: return [2];
+            }
+        });
+    }); };
+}
+
+exports.createWebMonitor = createWebMonitor;