@vforcity/logger
Version:
时间线前端异常监控工具包。
1,543 lines (1,319 loc) • 200 kB
JavaScript
'use strict';
function _typeof(obj) {
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
Object.defineProperty(exports, '__esModule', {
value: true
});
function _typeof$1(obj) {
if (typeof Symbol === "function" && _typeof(Symbol.iterator) === "symbol") {
_typeof$1 = function _typeof$1(obj) {
return _typeof(obj);
};
} else {
_typeof$1 = function _typeof$1(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof(obj);
};
}
return _typeof$1(obj);
}
/* eslint-disable */
var regeneratorRuntime = typeof regeneratorRuntime !== 'undefined' ? regeneratorRuntime : function (exports) {
var Op = Object.prototype;
var hasOwn = Op.hasOwnProperty;
var undefined$1; // More compressible than void 0.
var $Symbol = typeof Symbol === 'function' ? Symbol : {};
var iteratorSymbol = $Symbol.iterator || '@@iterator';
var asyncIteratorSymbol = $Symbol.asyncIterator || '@@asyncIterator';
var toStringTagSymbol = $Symbol.toStringTag || '@@toStringTag';
function wrap(innerFn, outerFn, self, tryLocsList) {
// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
var generator = Object.create(protoGenerator.prototype);
var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next,
// .throw, and .return methods.
generator._invoke = makeInvokeMethod(innerFn, self, context);
return generator;
}
exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion
// record like context.tryEntries[i].completion. This interface could
// have been (and was previously) designed to take a closure to be
// invoked without arguments, but in all the cases we care about we
// already have an existing method we want to call, so there's no need
// to create a new function object. We can even get away with assuming
// the method takes exactly one argument, since that happens to be true
// in every case, so we don't have to touch the arguments object. The
// only additional allocation required is the completion record, which
// has a stable shape and so hopefully should be cheap to allocate.
function tryCatch(fn, obj, arg) {
try {
return {
type: 'normal',
arg: fn.call(obj, arg)
};
} catch (err) {
return {
type: 'throw',
arg: err
};
}
}
var GenStateSuspendedStart = 'suspendedStart';
var GenStateSuspendedYield = 'suspendedYield';
var GenStateExecuting = 'executing';
var GenStateCompleted = 'completed'; // Returning this object from the innerFn has the same effect as
// breaking out of the dispatch switch statement.
var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and
// .constructor.prototype properties for functions that return Generator
// objects. For full spec compliance, you may wish to configure your
// minifier not to mangle the names of these two functions.
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that
// don't natively support it.
var IteratorPrototype = {};
IteratorPrototype[iteratorSymbol] = function () {
return this;
};
var getProto = Object.getPrototypeOf;
var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
// This environment has a native %IteratorPrototype%; use it instead
// of the polyfill.
IteratorPrototype = NativeIteratorPrototype;
}
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
GeneratorFunctionPrototype.constructor = GeneratorFunction;
GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = 'GeneratorFunction'; // Helper for defining the .next, .throw, and .return methods of the
// Iterator interface in terms of a single ._invoke method.
function defineIteratorMethods(prototype) {
['next', 'throw', 'return'].forEach(function (method) {
prototype[method] = function (arg) {
return this._invoke(method, arg);
};
});
}
exports.isGeneratorFunction = function (genFun) {
var ctor = typeof genFun === 'function' && genFun.constructor;
return ctor ? ctor === GeneratorFunction // For the native GeneratorFunction constructor, the best we can
// do is to check its .name property.
|| (ctor.displayName || ctor.name) === 'GeneratorFunction' : false;
};
exports.mark = function (genFun) {
if (Object.setPrototypeOf) {
Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
} else {
genFun.__proto__ = GeneratorFunctionPrototype;
if (!(toStringTagSymbol in genFun)) {
genFun[toStringTagSymbol] = 'GeneratorFunction';
}
}
genFun.prototype = Object.create(Gp);
return genFun;
}; // Within the body of any async function, `await x` is transformed to
// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
// `hasOwn.call(value, "__await")` to determine if the yielded value is
// meant to be awaited.
exports.awrap = function (arg) {
return {
__await: arg
};
};
function AsyncIterator(generator) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if (record.type === 'throw') {
reject(record.arg);
} else {
var result = record.arg;
var value = result.value;
if (value && _typeof$1(value) === 'object' && hasOwn.call(value, '__await')) {
return Promise.resolve(value.__await).then(function (value) {
invoke('next', value, resolve, reject);
}, function (err) {
invoke('throw', err, resolve, reject);
});
}
return Promise.resolve(value).then(function (unwrapped) {
// When a yielded Promise is resolved, its final value becomes
// the .value of the Promise<{value,done}> result for the
// current iteration.
result.value = unwrapped;
resolve(result);
}, function (error) {
// If a rejected Promise was yielded, throw the rejection back
// into the async generator function so it can be handled there.
return invoke('throw', error, resolve, reject);
});
}
}
var previousPromise;
function enqueue(method, arg) {
function callInvokeWithMethodAndArg() {
return new Promise(function (resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise // If enqueue has been called before, then we want to wait until
// all previous Promises have been resolved before calling invoke,
// so that results are always delivered in the correct order. If
// enqueue has not been called before, then it is important to
// call invoke immediately, without waiting on a callback to fire,
// so that the async generator function has the opportunity to do
// any necessary setup in a predictable way. This predictability
// is why the Promise constructor synchronously invokes its
// executor callback, and why async functions synchronously
// execute code before the first await. Since we implement simple
// async functions in terms of async generators, it is especially
// important to get this right, even though it requires care.
= previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later
// invocations of the iterator.
callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
} // Define the unified helper method that is used to implement .next,
// .throw, and .return (see defineIteratorMethods).
this._invoke = enqueue;
}
defineIteratorMethods(AsyncIterator.prototype);
AsyncIterator.prototype[asyncIteratorSymbol] = function () {
return this;
};
exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of
// AsyncIterator objects; they just return a Promise for the value of
// the final result produced by the iterator.
exports.async = function (innerFn, outerFn, self, tryLocsList) {
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.
: iter.next().then(function (result) {
return result.done ? result.value : iter.next();
});
};
function makeInvokeMethod(innerFn, self, context) {
var state = GenStateSuspendedStart;
return function invoke(method, arg) {
if (state === GenStateExecuting) {
throw new Error('Generator is already running');
}
if (state === GenStateCompleted) {
if (method === 'throw') {
throw arg;
} // Be forgiving, per 25.3.3.3.3 of the spec:
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult();
}
context.method = method;
context.arg = arg;
while (true) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if (context.method === 'next') {
// Setting context._sent for legacy support of Babel's
// function.sent implementation.
context.sent = context._sent = context.arg;
} else if (context.method === 'throw') {
if (state === GenStateSuspendedStart) {
state = GenStateCompleted;
throw context.arg;
}
context.dispatchException(context.arg);
} else if (context.method === 'return') {
context.abrupt('return', context.arg);
}
state = GenStateExecuting;
var record = tryCatch(innerFn, self, context);
if (record.type === 'normal') {
// If an exception is thrown from innerFn, we leave state ===
// GenStateExecuting and loop back for another invocation.
state = context.done ? GenStateCompleted : GenStateSuspendedYield;
if (record.arg === ContinueSentinel) {
continue;
}
return {
value: record.arg,
done: context.done
};
} else if (record.type === 'throw') {
state = GenStateCompleted; // Dispatch the exception by looping back around to the
// context.dispatchException(context.arg) call above.
context.method = 'throw';
context.arg = record.arg;
}
}
};
} // Call delegate.iterator[context.method](context.arg) and handle the
// result, either by returning a { value, done } result from the
// delegate iterator, or by modifying context.method and context.arg,
// setting context.delegate to null, and returning the ContinueSentinel.
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (method === undefined$1) {
// A .throw or .return when the delegate iterator has no .throw
// method always terminates the yield* loop.
context.delegate = null;
if (context.method === 'throw') {
// Note: ["return"] must be used for ES3 parsing compatibility.
if (delegate.iterator['return']) {
// If the delegate iterator has a return method, give it a
// chance to clean up.
context.method = 'return';
context.arg = undefined$1;
maybeInvokeDelegate(delegate, context);
if (context.method === 'throw') {
// If maybeInvokeDelegate(context) changed context.method from
// "return" to "throw", let that override the TypeError below.
return ContinueSentinel;
}
}
context.method = 'throw';
context.arg = new TypeError("The iterator does not provide a 'throw' method");
}
return ContinueSentinel;
}
var record = tryCatch(method, delegate.iterator, context.arg);
if (record.type === 'throw') {
context.method = 'throw';
context.arg = record.arg;
context.delegate = null;
return ContinueSentinel;
}
var info = record.arg;
if (!info) {
context.method = 'throw';
context.arg = new TypeError('iterator result is not an object');
context.delegate = null;
return ContinueSentinel;
}
if (info.done) {
// Assign the result of the finished delegate to the temporary
// variable specified by delegate.resultName (see delegateYield).
context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield).
context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the
// exception, let the outer generator proceed normally. If
// context.method was "next", forget context.arg since it has been
// "consumed" by the delegate iterator. If context.method was
// "return", allow the original .return call to continue in the
// outer generator.
if (context.method !== 'return') {
context.method = 'next';
context.arg = undefined$1;
}
} else {
// Re-yield the result returned by the delegate method.
return info;
} // The delegate iterator is finished, so forget it and continue with
// the outer generator.
context.delegate = null;
return ContinueSentinel;
} // Define Generator.prototype.{next,throw,return} in terms of the
// unified ._invoke helper method.
defineIteratorMethods(Gp);
Gp[toStringTagSymbol] = 'Generator'; // A Generator should always return itself as the iterator object when the
// @@iterator function is called on it. Some browsers' implementations of the
// iterator prototype chain incorrectly implement this, causing the Generator
// object to not be returned from this call. This ensures that doesn't happen.
// See https://github.com/facebook/regenerator/issues/274 for more details.
Gp[iteratorSymbol] = function () {
return this;
};
Gp.toString = function () {
return '[object Generator]';
};
function pushTryEntry(locs) {
var entry = {
tryLoc: locs[0]
};
if (1 in locs) {
entry.catchLoc = locs[1];
}
if (2 in locs) {
entry.finallyLoc = locs[2];
entry.afterLoc = locs[3];
}
this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = 'normal';
delete record.arg;
entry.completion = record;
}
function Context(tryLocsList) {
// The root entry object (effectively a try statement without a catch
// or a finally block) gives us a place to store values thrown from
// locations where there is no enclosing try statement.
this.tryEntries = [{
tryLoc: 'root'
}];
tryLocsList.forEach(pushTryEntry, this);
this.reset(true);
}
exports.keys = function (object) {
var keys = [];
for (var key in object) {
keys.push(key);
}
keys.reverse(); // Rather than returning an object with a next method, we keep
// things simple and return the next function itself.
return function next() {
while (keys.length) {
var _key = keys.pop();
if (_key in object) {
next.value = _key;
next.done = false;
return next;
}
} // To avoid creating an additional object, we just hang the .value
// and .done properties off the next function object itself. This
// also ensures that the minifier will not anonymize the function.
next.done = true;
return next;
};
};
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) {
return iteratorMethod.call(iterable);
}
if (typeof iterable.next === 'function') {
return iterable;
}
if (!isNaN(iterable.length)) {
var i = -1,
next = function next() {
while (++i < iterable.length) {
if (hasOwn.call(iterable, i)) {
next.value = iterable[i];
next.done = false;
return next;
}
}
next.value = undefined$1;
next.done = true;
return next;
};
return next.next = next;
}
} // Return an iterator with no values.
return {
next: doneResult
};
}
exports.values = values;
function doneResult() {
return {
value: undefined$1,
done: true
};
}
Context.prototype = {
constructor: Context,
reset: function reset(skipTempReset) {
this.prev = 0;
this.next = 0; // Resetting context._sent for legacy support of Babel's
// function.sent implementation.
this.sent = this._sent = undefined$1;
this.done = false;
this.delegate = null;
this.method = 'next';
this.arg = undefined$1;
this.tryEntries.forEach(resetTryEntry);
if (!skipTempReset) {
for (var name in this) {
// Not sure about the optimal order of these conditions:
if (name.charAt(0) === 't' && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
this[name] = undefined$1;
}
}
}
},
stop: function stop() {
this.done = true;
var rootEntry = this.tryEntries[0];
var rootRecord = rootEntry.completion;
if (rootRecord.type === 'throw') {
throw rootRecord.arg;
}
return this.rval;
},
dispatchException: function dispatchException(exception) {
if (this.done) {
throw exception;
}
var context = this;
function handle(loc, caught) {
record.type = 'throw';
record.arg = exception;
context.next = loc;
if (caught) {
// If the dispatched exception was caught by a catch block,
// then let that catch block handle the exception normally.
context.method = 'next';
context.arg = undefined$1;
}
return !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
var record = entry.completion;
if (entry.tryLoc === 'root') {
// Exception thrown outside of any try block that could handle
// it, so set the completion value of the entire function to
// throw the exception.
return handle('end');
}
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, 'catchLoc');
var hasFinally = hasOwn.call(entry, 'finallyLoc');
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
} else if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else if (hasCatch) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
}
} else if (hasFinally) {
if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else {
throw new Error('try statement without catch or finally');
}
}
}
},
abrupt: function abrupt(type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev && hasOwn.call(entry, 'finallyLoc') && this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
if (finallyEntry && (type === 'break' || type === 'continue') && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
// Ignore the finally entry if control is not jumping to a
// location outside the try/catch block.
finallyEntry = null;
}
var record = finallyEntry ? finallyEntry.completion : {};
record.type = type;
record.arg = arg;
if (finallyEntry) {
this.method = 'next';
this.next = finallyEntry.finallyLoc;
return ContinueSentinel;
}
return this.complete(record);
},
complete: function complete(record, afterLoc) {
if (record.type === 'throw') {
throw record.arg;
}
if (record.type === 'break' || record.type === 'continue') {
this.next = record.arg;
} else if (record.type === 'return') {
this.rval = this.arg = record.arg;
this.method = 'return';
this.next = 'end';
} else if (record.type === 'normal' && afterLoc) {
this.next = afterLoc;
}
return ContinueSentinel;
},
finish: function finish(finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) {
this.complete(entry.completion, entry.afterLoc);
resetTryEntry(entry);
return ContinueSentinel;
}
}
},
"catch": function _catch(tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if (record.type === 'throw') {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
} // The context.catch method must only be called with a location
// argument that corresponds to a known catch block.
throw new Error('illegal catch attempt');
},
delegateYield: function delegateYield(iterable, resultName, nextLoc) {
this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
};
if (this.method === 'next') {
// Deliberately forget the last sent value so that we don't
// accidentally pass it on to the delegate.
this.arg = undefined$1;
}
return ContinueSentinel;
} // Regardless of whether this script is executing as a CommonJS module
// or not, return the runtime object so that we can declare the variable
// regeneratorRuntime in the outer scope, which allows this module to be
// injected easily by `bin/regenerator --include-runtime script.js`.
};
return exports;
}( // If this script is executing as a CommonJS module, use module.exports
// as the regeneratorRuntime namespace. Otherwise create a new empty
// object. Either way, the resulting object will be used to initialize
// the regeneratorRuntime variable at the top of this file.
(typeof module === "undefined" ? "undefined" : _typeof$1(module)) === 'object' ? module.exports : {});
function unwrapExports(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = {
exports: {}
}, fn(module, module.exports), module.exports;
}
var sentryMina = createCommonjsModule(function (module, exports) {
!function (e, t) {
module.exports = t();
}(window, function () {
return function (e) {
var t = {};
function n(r) {
if (t[r]) return t[r].exports;
var o = t[r] = {
i: r,
l: !1,
exports: {}
};
return e[r].call(o.exports, o, o.exports, n), o.l = !0, o.exports;
}
return n.m = e, n.c = t, n.d = function (e, t, r) {
n.o(e, t) || Object.defineProperty(e, t, {
enumerable: !0,
get: r
});
}, n.r = function (e) {
"undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e, Symbol.toStringTag, {
value: "Module"
}), Object.defineProperty(e, "__esModule", {
value: !0
});
}, n.t = function (e, t) {
if (1 & t && (e = n(e)), 8 & t) return e;
if (4 & t && "object" == _typeof(e) && e && e.__esModule) return e;
var r = Object.create(null);
if (n.r(r), Object.defineProperty(r, "default", {
enumerable: !0,
value: e
}), 2 & t && "string" != typeof e) for (var o in e) {
n.d(r, o, function (t) {
return e[t];
}.bind(null, o));
}
return r;
}, n.n = function (e) {
var t = e && e.__esModule ? function () {
return e["default"];
} : function () {
return e;
};
return n.d(t, "a", t), t;
}, n.o = function (e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}, n.p = "", n(n.s = 24);
}([function (e, t, n) {
n.r(t), n.d(t, "__extends", function () {
return o;
}), n.d(t, "__assign", function () {
return _i;
}), n.d(t, "__rest", function () {
return a;
}), n.d(t, "__decorate", function () {
return u;
}), n.d(t, "__param", function () {
return c;
}), n.d(t, "__metadata", function () {
return s;
}), n.d(t, "__awaiter", function () {
return l;
}), n.d(t, "__generator", function () {
return f;
}), n.d(t, "__exportStar", function () {
return p;
}), n.d(t, "__values", function () {
return d;
}), n.d(t, "__read", function () {
return h;
}), n.d(t, "__spread", function () {
return v;
}), n.d(t, "__await", function () {
return g;
}), n.d(t, "__asyncGenerator", function () {
return y;
}), n.d(t, "__asyncDelegator", function () {
return b;
}), n.d(t, "__asyncValues", function () {
return m;
}), n.d(t, "__makeTemplateObject", function () {
return _;
}), n.d(t, "__importStar", function () {
return w;
}), n.d(t, "__importDefault", function () {
return S;
});
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
var _r = function r(e, t) {
return (_r = Object.setPrototypeOf || {
__proto__: []
} instanceof Array && function (e, t) {
e.__proto__ = t;
} || function (e, t) {
for (var n in t) {
t.hasOwnProperty(n) && (e[n] = t[n]);
}
})(e, t);
};
function o(e, t) {
function n() {
this.constructor = e;
}
_r(e, t), e.prototype = null === t ? Object.create(t) : (n.prototype = t.prototype, new n());
}
var _i = function i() {
return (_i = Object.assign || function (e) {
for (var t, n = 1, r = arguments.length; n < r; n++) {
for (var o in t = arguments[n]) {
Object.prototype.hasOwnProperty.call(t, o) && (e[o] = t[o]);
}
}
return e;
}).apply(this, arguments);
};
function a(e, t) {
var n = {};
for (var r in e) {
Object.prototype.hasOwnProperty.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
}
if (null != e && "function" == typeof Object.getOwnPropertySymbols) {
var o = 0;
for (r = Object.getOwnPropertySymbols(e); o < r.length; o++) {
t.indexOf(r[o]) < 0 && (n[r[o]] = e[r[o]]);
}
}
return n;
}
function u(e, t, n, r) {
var o,
i = arguments.length,
a = i < 3 ? t : null === r ? r = Object.getOwnPropertyDescriptor(t, n) : r;
if ("object" == (typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) && "function" == typeof Reflect.decorate) a = Reflect.decorate(e, t, n, r);else for (var u = e.length - 1; u >= 0; u--) {
(o = e[u]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
}
return i > 3 && a && Object.defineProperty(t, n, a), a;
}
function c(e, t) {
return function (n, r) {
t(n, r, e);
};
}
function s(e, t) {
if ("object" == (typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) && "function" == typeof Reflect.metadata) return Reflect.metadata(e, t);
}
function l(e, t, n, r) {
return new (n || (n = Promise))(function (o, i) {
function a(e) {
try {
c(r.next(e));
} catch (e) {
i(e);
}
}
function u(e) {
try {
c(r["throw"](e));
} catch (e) {
i(e);
}
}
function c(e) {
e.done ? o(e.value) : new n(function (t) {
t(e.value);
}).then(a, u);
}
c((r = r.apply(e, t || [])).next());
});
}
function f(e, t) {
var n,
r,
o,
i,
a = {
label: 0,
sent: function sent() {
if (1 & o[0]) throw o[1];
return o[1];
},
trys: [],
ops: []
};
return i = {
next: u(0),
"throw": u(1),
"return": u(2)
}, "function" == typeof Symbol && (i[Symbol.iterator] = function () {
return this;
}), i;
function u(i) {
return function (u) {
return function (i) {
if (n) throw new TypeError("Generator is already executing.");
for (; a;) {
try {
if (n = 1, r && (o = 2 & i[0] ? r["return"] : i[0] ? r["throw"] || ((o = r["return"]) && o.call(r), 0) : r.next) && !(o = o.call(r, i[1])).done) return o;
switch (r = 0, o && (i = [2 & i[0], o.value]), i[0]) {
case 0:
case 1:
o = i;
break;
case 4:
return a.label++, {
value: i[1],
done: !1
};
case 5:
a.label++, r = i[1], i = [0];
continue;
case 7:
i = a.ops.pop(), a.trys.pop();
continue;
default:
if (!(o = (o = a.trys).length > 0 && o[o.length - 1]) && (6 === i[0] || 2 === i[0])) {
a = 0;
continue;
}
if (3 === i[0] && (!o || i[1] > o[0] && i[1] < o[3])) {
a.label = i[1];
break;
}
if (6 === i[0] && a.label < o[1]) {
a.label = o[1], o = i;
break;
}
if (o && a.label < o[2]) {
a.label = o[2], a.ops.push(i);
break;
}
o[2] && a.ops.pop(), a.trys.pop();
continue;
}
i = t.call(e, a);
} catch (e) {
i = [6, e], r = 0;
} finally {
n = o = 0;
}
}
if (5 & i[0]) throw i[1];
return {
value: i[0] ? i[1] : void 0,
done: !0
};
}([i, u]);
};
}
}
function p(e, t) {
for (var n in e) {
t.hasOwnProperty(n) || (t[n] = e[n]);
}
}
function d(e) {
var t = "function" == typeof Symbol && e[Symbol.iterator],
n = 0;
return t ? t.call(e) : {
next: function next() {
return e && n >= e.length && (e = void 0), {
value: e && e[n++],
done: !e
};
}
};
}
function h(e, t) {
var n = "function" == typeof Symbol && e[Symbol.iterator];
if (!n) return e;
var r,
o,
i = n.call(e),
a = [];
try {
for (; (void 0 === t || t-- > 0) && !(r = i.next()).done;) {
a.push(r.value);
}
} catch (e) {
o = {
error: e
};
} finally {
try {
r && !r.done && (n = i["return"]) && n.call(i);
} finally {
if (o) throw o.error;
}
}
return a;
}
function v() {
for (var e = [], t = 0; t < arguments.length; t++) {
e = e.concat(h(arguments[t]));
}
return e;
}
function g(e) {
return this instanceof g ? (this.v = e, this) : new g(e);
}
function y(e, t, n) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var r,
o = n.apply(e, t || []),
i = [];
return r = {}, a("next"), a("throw"), a("return"), r[Symbol.asyncIterator] = function () {
return this;
}, r;
function a(e) {
o[e] && (r[e] = function (t) {
return new Promise(function (n, r) {
i.push([e, t, n, r]) > 1 || u(e, t);
});
});
}
function u(e, t) {
try {
(n = o[e](t)).value instanceof g ? Promise.resolve(n.value.v).then(c, s) : l(i[0][2], n);
} catch (e) {
l(i[0][3], e);
}
var n;
}
function c(e) {
u("next", e);
}
function s(e) {
u("throw", e);
}
function l(e, t) {
e(t), i.shift(), i.length && u(i[0][0], i[0][1]);
}
}
function b(e) {
var t, n;
return t = {}, r("next"), r("throw", function (e) {
throw e;
}), r("return"), t[Symbol.iterator] = function () {
return this;
}, t;
function r(r, o) {
t[r] = e[r] ? function (t) {
return (n = !n) ? {
value: g(e[r](t)),
done: "return" === r
} : o ? o(t) : t;
} : o;
}
}
function m(e) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var t,
n = e[Symbol.asyncIterator];
return n ? n.call(e) : (e = d(e), t = {}, r("next"), r("throw"), r("return"), t[Symbol.asyncIterator] = function () {
return this;
}, t);
function r(n) {
t[n] = e[n] && function (t) {
return new Promise(function (r, o) {
(function (e, t, n, r) {
Promise.resolve(r).then(function (t) {
e({
value: t,
done: n
});
}, t);
})(r, o, (t = e[n](t)).done, t.value);
});
};
}
}
function _(e, t) {
return Object.defineProperty ? Object.defineProperty(e, "raw", {
value: t
}) : e.raw = t, e;
}
function w(e) {
if (e && e.__esModule) return e;
var t = {};
if (null != e) for (var n in e) {
Object.hasOwnProperty.call(e, n) && (t[n] = e[n]);
}
return t["default"] = e, t;
}
function S(e) {
return e && e.__esModule ? e : {
"default": e
};
}
}, function (e, t, n) {
Object.defineProperty(t, "__esModule", {
value: !0
});
var r = n(5),
o = r.getGlobalObject(),
i = new (function () {
function e() {
this.enabled = !1;
}
return e.prototype.disable = function () {
this.enabled = !1;
}, e.prototype.enable = function () {
this.enabled = !0;
}, e.prototype.log = function () {
for (var e = [], t = 0; t < arguments.length; t++) {
e[t] = arguments[t];
}
this.enabled && r.consoleSandbox(function () {
o.console.log("Sentry Logger [Log]: " + e.join(" "));
});
}, e.prototype.warn = function () {
for (var e = [], t = 0; t < arguments.length; t++) {
e[t] = arguments[t];
}
this.enabled && r.consoleSandbox(function () {
o.console.warn("Sentry Logger [Warn]: " + e.join(" "));
});
}, e.prototype.error = function () {
for (var e = [], t = 0; t < arguments.length; t++) {
e[t] = arguments[t];
}
this.enabled && r.consoleSandbox(function () {
o.console.error("Sentry Logger [Error]: " + e.join(" "));
});
}, e;
}())();
t.logger = i;
}, function (e, t, n) {
Object.defineProperty(t, "__esModule", {
value: !0
}), t.isError = function (e) {
switch (Object.prototype.toString.call(e)) {
case "[object Error]":
case "[object Exception]":
case "[object DOMException]":
return !0;
default:
return e instanceof Error;
}
}, t.isErrorEvent = function (e) {
return "[object ErrorEvent]" === Object.prototype.toString.call(e);
}, t.isDOMError = function (e) {
return "[object DOMError]" === Object.prototype.toString.call(e);
}, t.isDOMException = function (e) {
return "[object DOMException]" === Object.prototype.toString.call(e);
}, t.isUndefined = function (e) {
return void 0 === e;
}, t.isFunction = function (e) {
return "function" == typeof e;
}, t.isString = function (e) {
return "[object String]" === Object.prototype.toString.call(e);
}, t.isArray = function (e) {
return "[object Array]" === Object.prototype.toString.call(e);
}, t.isPlainObject = function (e) {
return "[object Object]" === Object.prototype.toString.call(e);
}, t.isRegExp = function (e) {
return "[object RegExp]" === Object.prototype.toString.call(e);
}, t.isNaN = function (e) {
return e != e;
};
}, function (e, t, n) {
Object.defineProperty(t, "__esModule", {
value: !0
});
var r = n(26);
t.addBreadcrumb = r.addBreadcrumb, t.captureException = r.captureException, t.captureEvent = r.captureEvent, t.captureMessage = r.captureMessage, t.configureScope = r.configureScope, t.withScope = r.withScope;
var o = n(6);
t.addGlobalEventProcessor = o.addGlobalEventProcessor, t.getCurrentHub = o.getCurrentHub, t.Hub = o.Hub, t.getHubFromCarrier = o.getHubFromCarrier, t.Scope = o.Scope;
var i = n(31);
t.API = i.API;
var a = n(32);
t.BaseClient = a.BaseClient;
var u = n(35);
t.BaseBackend = u.BaseBackend;
var c = n(10);
t.Dsn = c.Dsn;
var s = n(11);
t.SentryError = s.SentryError;
var l = n(14);
t.RequestBuffer = l.RequestBuffer;
var f = n(36);
t.LogLevel = f.LogLevel;
var p = n(37);
t.initAndBind = p.initAndBind;
var d = n(38);
t.Integrations = d;
}, function (e, t, n) {
Object.defineProperty(t, "__esModule", {
value: !0
}), t.setMinaContext = function (e) {
i = e;
}, t.getMinaContext = function () {
return i;
}, t.getMinaApiList = function () {
return Object.keys(i).filter(function (e) {
return "function" == typeof i[e];
});
}, t.getSystemInfo = function () {
try {
return a || (a = i.getSystemInfoSync());
} catch (t) {
r.logger.warn("getSystemInfoSync is undefined in minaContext");
var e = {};
return c.forEach(function (t) {
e[t] = "unknow";
}), e;
}
}, t.supportRequest = function () {
return !!i.request;
}, t.supportNavigations = function () {
var e = ["navigateBack", "navigateTo", "redirectTo", "reLaunch", "switchTab"].filter(function (e) {
return !!i[e];
});
return e.length > 0 ? e : null;
}, t.getCurrentPage = function () {
if ("function" == typeof getCurrentPages) {
var e = getCurrentPages();
return 0 === e.length ? "unknow" : e[e.length - 1].route;
}
return "unknow";
}, t.getPrevPage = function (e) {
if ("function" == typeof getCurrentPages) {
var t = getCurrentPages();
if (0 === t.length) return "unknow";
if (e || (e = 1), t[t.length - 1 - e]) return t[t.length - 1 - e].route;
}
return "unknow";
}, t.getMinaApp = function () {
return s.apply(this, arguments);
}, t.supportStorage = function () {
return 2 === ["setStorage", "getStorageSync"].filter(function (e) {
return !!i[e];
}).length;
}, t.supportLogManager = function () {
return !!i.getLogManager;
}, t.isWxUnhandledPromiseError = function (e) {
if (e && "string" == typeof e && /^(Unhandled|Uncaught)/i.test(e)) return !0;
return !1;
}, t.MINA_PAGE_LIFE_CYCLE = t.MINA_APP_LIFE_CYCLE = t.MINA_SYSTEMINFO_TAGS = void 0;
var r = n(1);
function o(e, t, n, r, o, i, a) {
try {
var u = e[i](a),
c = u.value;
} catch (e) {
return void n(e);
}
u.done ? t(c) : Promise.resolve(c).then(r, o);
}
var i = "undefined" != typeof wx ? wx : {},
a = null,
u = null,
c = ["brand", "model", "language", "version", "system", "platform", "SDKVersion"];
t.MINA_SYSTEMINFO_TAGS = c;
t.MINA_APP_LIFE_CYCLE = ["onAppShow", "onAppHide"];
function s() {
var e;
return e =
/*#__PURE__*/
regeneratorRuntime.mark(function _callee() {
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
return _context.abrupt("return", u || new Promise(function (e) {
!function t() {
var n = getApp({
allowDefault: !0
});
n ? (u = n, e(n)) : setTimeout(t, 20);
}();
}));
case 1:
case "end":
return _context.stop();
}
}
}, _callee);
}), (s = function s() {
var t = this,
n = arguments;
return new Promise(function (r, i) {
var a = e.apply(t, n);
function u(e) {
o(a, r, i, u, c, "next", e);
}
function c(e) {
o(a, r, i, u, c, "throw", e);
}
u(void 0);
});
}).apply(this, arguments);
}
t.MINA_PAGE_LIFE_CYCLE = ["onLoad", "onShow", "onHide", "onUnload", "onReady"];
}, function (e, t, n) {
(function (e, r) {
Object.defineProperty(t, "__esModule", {
value: !0
});
var o = n(2);
function i() {
return "[object process]" === Object.prototype.toString.call(void 0 !== e ? e : 0);
}
function a() {
return i() ? r : "undefined" != typeof window ? window : "undefined" != typeof self ? self : {};
}
function u(e) {
var t,
n,
r,
i,
a,
u = [];
if (!e || !e.tagName) return "";
if (u.push(e.tagName.toLowerCase()), e.id && u.push("#" + e.id), (t = e.className) && o.isString(t)) for (n = t.split(/\s+/), a = 0; a < n.length; a++) {
u.push("." + n[a]);
}
var c = ["type", "name", "title", "alt"];
for (a = 0; a < c.length; a++) {
r = c[a], (i = e.getAttribute(r)) && u.push("[" + r + '="' + i + '"]');
}
return u.join("");
}
t.dynamicRequire = function (e, t) {
return e.require(t);
}, t.isNodeEnv = i, t.getGlobalObject = a, t.uuid4 = function () {
var e = a(),
t = e.crypto || e.msCrypto;
if (void 0 !== t && t.getRandomValues) {
var n = new Uint16Array(8);
t.getRandomValues(n), n[3] = 4095 & n[3] | 16384, n[4] = 16383 & n[4] | 32768;
var r = function r(e) {
for (var t = e.toString(16); t.length < 4;) {
t = "0" + t;
}
return t;
};
return r(n[0]) + r(n[1]) + r(n[2]) + r(n[3]) + r(n[4]) + r(n[5]) + r(n[6]) + r(n[7]);
}
return "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(/[xy]/g, function (e) {
var t = 16 * Math.random() | 0;
return ("x" === e ? t : 3 & t | 8).toString(16);
});
}, t.htmlTreeAsString = function (e) {
for (var t, n = e, r = [], o = 0, i = 0, a = " > ".length; n && o++ < 5 && !("html" === (t = u(n)) || o > 1 && i + r.length * a + t.length >= 80);) {
r.push(t), i += t.length, n = n.parentNode;
}
return r.reverse().join(" > ");
}, t.htmlElementAsString = u, t.parseUrl = function (e) {
if (!e) return {};
var t = e.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
if (!t) return {};
var n = t[6] || "",
r = t[8] || "";
return {
host: t[4],
path: t[5],
protocol: t[2],
relative: t[5] + n + r
};
}, t.getEventDescription = function (e) {
if (e.message) return e.message;
if (e.exception && e.exception.values && e.exception.values[0]) {
var t = e.exception.values[0];
return t.type && t.value ? t.type + ": " + t.value : t.type || t.value || e.event_id || "<unknown>";
}
return e.event_id || "<unknown>";
}, t.consoleSandbox = function (e) {
var t = a();
if (!("console" in t)) return e();
var n = t.console,
r = {};
["debug", "info", "warn", "error", "log"].forEach(function (e) {
e in t.console && n[e].__sentry__ && (r[e] = n[e].__sentry_wrapped__, n[e] = n[e].__sentry_original__);
});
var o = e();
return Object.keys(r).forEach(function (e) {
n[e] = r[e];
}), o;
};
}).call(this, n(27), n(28));
}, function (e, t, n) {
Object.defineProperty(t, "__esModule", {
value: !0
});
var r = n(13);
t.addGlobalEventProcessor = r.addGlobalEventProcessor, t.Scope = r.Scope;
var o = n(29);
t.getCurrentHub = o.getCurrentHub, t.getHubFromCarrier = o.getHubFromCarrier, t.getMainCarrier = o.getMainCarrier, t.Hub = o.Hub, t.setHubOnCarrier = o.setHubOnCarrier;
}, function (e, t, n) {
Object.defineProperty(t, "__esModule", {
value: !0
});
var r = n(2);
var o = "[NaN]",
i = "[undefined]";
function a() {
var e = [],
t = [];
return function (n, a) {
var u = a;
if (r.isNaN(a) ? u = o : r.isUndefined(a) && (u = i), e.length > 0) {
var c = e.indexOf(this);
-1 !== c ? (e.splice(c + 1), t.splice(c, 1 / 0, n)) : (e.push(this), t.push(n)), -1 !== e.indexOf(u) && (u = function (n, r) {
return e[0] === r ? "[Circular ~]" : "[Circular ~." + t.slice(0, e.indexOf(r)).join(".") + "]";
}.call(this, n, u));
} else e.push(u);
return u instanceof Error ? function (e) {
var t = {
message: e.message,
name: e.name,