@microsoft/1ds-core-js
Version:
Microsoft Application Insights JavaScript SDK - 1ds-core-js
1,484 lines (1,475 loc) • 358 kB
JavaScript
/*!
* 1DS JS SDK Core, 4.4.3
* Copyright (c) Microsoft and contributors. All rights reserved.
* (Microsoft Internal Only)
*/
(function (global, factory) {
var undef = "undefined";
typeof exports === "object" && typeof module !== undef ? factory(exports) :
typeof define === "function" && define.amd ? define(["exports"], factory) :
(function(global){
var nsKey, key, nm, theExports = {}, modName = "es5_ms_core_4_4_3", msMod="__ms$mod__";
var mods={}, modDetail=mods[modName]={}, ver="4.4.3";
// Versioned namespace "oneDS4"
var exportNs=global, nsKey="oneDS4", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
// Global namespace "oneDS"
var destNs=global, nsKey="oneDS", destNs=destNs[nsKey]=(destNs[nsKey]||{});
var expNsDetail=(exportNs[msMod]=(exportNs[msMod] || {})), expNameVer=(expNsDetail["v"]=(expNsDetail["v"] || []));
var destNsDetail=(destNs[msMod]=(destNs[msMod] || {})), destNameVer=(destNsDetail["v"]=(destNsDetail["v"] || []));
(destNsDetail["o"]=(destNsDetail["o"] || [])).push(mods);
factory(theExports);
for(var key in theExports) {
// Always set the imported value into the "export" versioned namespace (last-write wins)
nm="x", exportNs[key]=theExports[key], expNameVer[key]=ver;
// Copy over any named element that is not already present (first-write wins)
typeof destNs[key]===undef ? (nm="n", destNs[key]=theExports[key]) && (destNameVer[key]=ver) : !destNameVer[key] && (destNameVer[key]="---");
(modDetail[nm] = (modDetail[nm] || [])).push(key);
}
})(typeof globalThis !== undef ? globalThis : global || self);
})(this, (function (exports) {
'use strict';
var MinChannelPriorty = 100;
/*! https://github.com/nevware21/ts-utils v0.15.0 */
/*#__NO_SIDE_EFFECTS__*/
function _pureAssign(func1, func2) {
return func1 || func2;
}
/*#__NO_SIDE_EFFECTS__*/
function _pureRef(value, name) {
return value !== null && value !== undefined ? value[name] : undefined;
}
var UNDEF_VALUE = undefined;
var NULL_VALUE = null;
var EMPTY = "";
var FUNCTION = "function";
var OBJECT = "object";
var PROTOTYPE = "prototype";
var __PROTO__ = "__proto__";
var UNDEFINED = "undefined";
var CONSTRUCTOR = "constructor";
var SYMBOL = "Symbol";
var LENGTH = "length";
var NAME = "name";
var CALL = "call";
var TO_STRING = "toString";
var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
var ObjClass$1 = (/*#__PURE__*/_pureAssign(Object));
var ObjProto = (/*#__PURE__*/_pureRef(ObjClass$1, PROTOTYPE));
var StrCls = (/*#__PURE__*/_pureAssign(String));
var StrProto = (/*#__PURE__*/_pureRef(StrCls, PROTOTYPE));
var MathCls = (/*#__PURE__*/_pureAssign(Math));
var ArrCls = (/*#__PURE__*/_pureAssign(Array));
var ArrProto = (/*#__PURE__*/_pureRef(ArrCls, PROTOTYPE));
var ArrSlice = (/*#__PURE__*/_pureRef(ArrProto, "slice"));
var NumberCls = (/*#__PURE__*/_pureAssign(Number));
var NumberProto = (/*#__PURE__*/_pureRef(NumberCls, PROTOTYPE));
var FuncCls = (/*#__PURE__*/_pureAssign(Function));
var FuncProto = (/*#__PURE__*/_pureRef(FuncCls, PROTOTYPE));
var DateCls = (/*#__PURE__*/_pureAssign(Date));
var DateProto = (/*#__PURE__*/_pureRef(DateCls, PROTOTYPE));
var RegExpCls = (/*#__PURE__*/_pureAssign(RegExp));
var RegExpProto = (/*#__PURE__*/_pureRef(RegExpCls, PROTOTYPE));
var BooleanCls = (/*#__PURE__*/_pureAssign(Boolean));
var BooleanProto = (/*#__PURE__*/_pureRef(BooleanCls, PROTOTYPE));
var ErrorCls = (/*#__PURE__*/_pureAssign(Error));
var ErrorProto = (/*#__PURE__*/_pureRef(ErrorCls, PROTOTYPE));
var POLYFILL_TAG = "_polyfill";
var POLYFILL_TYPE_NAME = "__nw21$polytype__";
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
}
catch (e) {
return { e: e };
}
}
/*#__NO_SIDE_EFFECTS__*/
function safeGet(cb, defValue, argArray) {
var result = safe(cb, argArray);
return result.e ? defValue : result.v;
}
var _primitiveTypes;
/*#__NO_SIDE_EFFECTS__*/
function _createIs(theType) {
return function (value) {
return typeof value === theType;
};
}
/*#__NO_SIDE_EFFECTS__*/
function _createObjIs(theName) {
var theType = "[object " + theName + "]";
return function (value) {
return !!(value && objToString(value) === theType);
};
}
/*#__NO_SIDE_EFFECTS__*/
function objToString(value) {
return ObjProto[TO_STRING].call(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isTypeof(value, theType) {
return typeof value === theType;
}
/*#__NO_SIDE_EFFECTS__*/
function isUndefined(value) {
return typeof value === UNDEFINED || value === UNDEFINED;
}
/*#__NO_SIDE_EFFECTS__*/
function isStrictUndefined(arg) {
return arg === UNDEF_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function isNullOrUndefined(value) {
return value === NULL_VALUE || isUndefined(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || value === UNDEF_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function isDefined(arg) {
return !!arg || arg !== UNDEF_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function isPrimitiveType(theType) {
!_primitiveTypes && (_primitiveTypes = ["string", "number", "boolean", UNDEFINED, "symbol", "bigint"]);
return !!(theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1);
}
var isString = (/*#__PURE__*/_createIs("string"));
var isFunction = (/*#__PURE__*/_createIs(FUNCTION));
/*#__NO_SIDE_EFFECTS__*/
function isObject(value) {
if (!value && isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
var isArray = (/*#__PURE__*/_pureRef(ArrCls, "isArray"));
var isDate = (/*#__PURE__*/_createObjIs("Date"));
var isNumber = (/*#__PURE__*/_createIs("number"));
var isBoolean = (/*#__PURE__*/_createIs("boolean"));
var isError = (/*#__PURE__*/_createObjIs("Error"));
/*#__NO_SIDE_EFFECTS__*/
function isPromiseLike(value) {
return !!(value && value.then && isFunction(value.then));
}
/*#__NO_SIDE_EFFECTS__*/
function isNotTruthy(value) {
return !value || !isTruthy(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isTruthy(value) {
return !(!value || safeGet(function () { return !(value && (0 + value)); }, !value));
}
function _returnNothing() {
return;
}
function _returnEmptyArray() {
return [];
}
function _returnFalse() {
return false;
}
var asString = (/*#__PURE__*/_pureAssign(StrCls));
var ERROR_TYPE = "[object Error]";
/*#__NO_SIDE_EFFECTS__*/
function dumpObj(object, format) {
var propertyValueDump = EMPTY;
var objType = ObjProto[TO_STRING][CALL](object);
if (objType === ERROR_TYPE) {
object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
}
try {
propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === "number") ? format : 4) : UNDEF_VALUE);
propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
}
catch (e) {
propertyValueDump = " - " + dumpObj(e, format);
}
return objType + ": " + propertyValueDump;
}
function throwError(message) {
throw new Error(message);
}
function throwTypeError(message) {
throw new TypeError(message);
}
function _throwIfNullOrUndefined(obj) {
if (isStrictNullOrUndefined(obj)) {
throwTypeError("Cannot convert undefined or null to object");
}
}
function _throwIfNotString(value) {
if (!isString(value)) {
throwTypeError("'" + dumpObj(value) + "' is not a string");
}
}
/*#__NO_SIDE_EFFECTS__*/
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
}
var _objGetOwnPropertyDescriptor$2 = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
var objHasOwn = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "hasOwn")), polyObjHasOwn));
/*#__NO_SIDE_EFFECTS__*/
function polyObjHasOwn(obj, prop) {
_throwIfNullOrUndefined(obj);
return objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
}
/*#__NO_SIDE_EFFECTS__*/
function isUnsafePropKey(key) {
return key === __PROTO__ || key === CONSTRUCTOR || key === PROTOTYPE;
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && (isObject(theObject) || isFunction(theObject))) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
var len = theArray[LENGTH] >>> 0;
for (var idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
var _unwrapFunction = _unwrapFunctionWithPoly;
/*#__NO_SIDE_EFFECTS__*/
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function (thisArg) {
var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
};
}
/*#__NO_SIDE_EFFECTS__*/
function _unwrapFunctionNoInstWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function (thisArg) {
var theFunc = clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
};
}
/*#__NO_SIDE_EFFECTS__*/
function _unwrapProp(propName) {
return function (thisArg) {
return thisArg[propName];
};
}
function _objPropertyIsEnum(obj, propKey) {
var desc;
var fn = ObjClass$1.getOwnPropertyDescriptor;
if (!isStrictNullOrUndefined(obj) && fn) {
desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
}
if (!desc && !isStrictNullOrUndefined(obj)) {
desc = safe(function () {
for (var key in obj) {
if (key == propKey) {
return { enumerable: objHasOwnProperty(obj, key) };
}
}
}).v;
}
return (desc && desc.enumerable) || false;
}
var _objPropertyIsEnumerable = (/*#__PURE__*/_unwrapFunctionNoInstWithPoly("propertyIsEnumerable", ObjProto, _objPropertyIsEnum));
var _objGetOwnPropertyDescriptor$1 = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
var _objGetOwnPropertySymbols = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
var propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
/*#__NO_SIDE_EFFECTS__*/
function _createProp(value) {
var prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = function () { return value.l.v; };
var desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
if (desc && desc.set) {
prop.set = function (newValue) {
value.l.v = newValue;
};
}
}
objForEachKey(value, function (key, value) {
prop[propMap[key]] = isStrictUndefined(value) ? prop[propMap[key]] : value;
});
return prop;
}
var objDefineProp = (/*#__PURE__*/_pureRef(ObjClass$1, "defineProperty"));
var objDefineProperties = (/*#__PURE__*/_pureRef(ObjClass$1, "defineProperties"));
function objDefineAccessors(target, prop, getProp, setProp, configurable, enumerable) {
var desc = {
e: enumerable,
c: configurable
};
if (getProp) {
desc.g = getProp;
}
if (setProp) {
desc.s = setProp;
}
return objDefineProp(target, prop, _createProp(desc));
}
function objDefine(target, key, propDesc) {
return objDefineProp(target, key, _createProp(propDesc));
}
function objDefineProps(target, propDescMap) {
var props = {};
objForEachKey(propDescMap, function (key, value) {
props[key] = _createProp(value);
});
arrForEach(_objGetOwnPropertySymbols(propDescMap), function (sym) {
if (_objPropertyIsEnumerable(propDescMap, sym)) {
props[sym] = _createProp(propDescMap[sym]);
}
});
return objDefineProperties(target, props);
}
/*#__NO_SIDE_EFFECTS__*/
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
var theMap = {};
objForEachKey(values, function (key, value) {
_assignMapValue(theMap, key, keyType ? value : key);
_assignMapValue(theMap, value, valueType ? value : key);
});
return completeFn ? completeFn(theMap) : theMap;
}
function _assignMapValue(theMap, key, value, writable) {
objDefineProp(theMap, key, {
value: value,
enumerable: true,
writable: false
});
}
function polyObjIs(value1, value2) {
if (value1 !== value1) {
return value2 !== value2;
}
if (value1 === 0 && value2 === 0) {
return 1 / value1 === 1 / value2;
}
return value1 === value2;
}
var objIsFrozen = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "isFrozen")), _returnFalse));
var _objFreeze = (/*#__PURE__*/_pureRef(ObjClass$1, "freeze"));
function _doNothing(value) {
return value;
}
/*#__NO_SIDE_EFFECTS__*/
function _getProto(value) {
_throwIfNullOrUndefined(value);
return value[__PROTO__] || NULL_VALUE;
}
var objAssign = (/*#__PURE__*/_pureRef(ObjClass$1, "assign"));
var objKeys = (/*#__PURE__*/_pureRef(ObjClass$1, "keys"));
function _deepFreeze(val, visited) {
if ((isArray(val) || isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
for (var lp = 0; lp < visited.length; lp++) {
if (visited[lp] === val) {
return val;
}
}
visited.push(val);
objForEachKey(val, function (_key, propValue) {
_deepFreeze(propValue, visited);
});
objFreeze(val);
}
return val;
}
function objDeepFreeze(value) {
return _objFreeze ? _deepFreeze(value, []) : value;
}
var objFreeze = (/*#__PURE__*/_pureAssign(_objFreeze, _doNothing));
var objSeal = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "seal")), _doNothing));
var objGetPrototypeOf = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "getPrototypeOf")), _getProto));
var objIs = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "is")), polyObjIs));
/*#__NO_SIDE_EFFECTS__*/
function createEnum(values) {
return _createKeyValueMap(values, 1 , 0 , objFreeze);
}
/*#__NO_SIDE_EFFECTS__*/
function createEnumKeyMap(values) {
return _createKeyValueMap(values, 0 , 0 , objFreeze);
}
var _wellKnownSymbolMap = (/*#__PURE__*/createEnumKeyMap({
asyncIterator: 0 ,
hasInstance: 1 ,
isConcatSpreadable: 2 ,
iterator: 3 ,
match: 4 ,
matchAll: 5 ,
replace: 6 ,
search: 7 ,
species: 8 ,
split: 9 ,
toPrimitive: 10 ,
toStringTag: 11 ,
unscopables: 12
}));
var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
var _globalCfg;
/*#__NO_SIDE_EFFECTS__*/
function _getGlobalValue() {
var result;
if (typeof globalThis !== UNDEFINED) {
result = globalThis;
}
if (!result && typeof self !== UNDEFINED) {
result = self;
}
if (!result && typeof window !== UNDEFINED) {
result = window;
}
if (!result && typeof global !== UNDEFINED) {
result = global;
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function _getGlobalConfig() {
if (!_globalCfg) {
var gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
var mathMax = (/*#__PURE__*/_pureRef(MathCls, "max"));
var strSlice = (/*#__PURE__*/_unwrapFunction("slice", StrProto));
var strSubstring = (/*#__PURE__*/_unwrapFunction("substring", StrProto));
var strSubstr = (/*#__PURE__*/_unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
/*#__NO_SIDE_EFFECTS__*/
function polyStrSubstr(value, start, length) {
_throwIfNullOrUndefined(value);
if (length < 0) {
return EMPTY;
}
start = start || 0;
if (start < 0) {
start = mathMax(start + value[LENGTH], 0);
}
if (isUndefined(length)) {
return strSlice(value, start);
}
return strSlice(value, start, start + length);
}
/*#__NO_SIDE_EFFECTS__*/
function strLeft(value, count) {
return strSubstring(value, 0, count);
}
function _tagAsPolyfill(target, polyfillTypeName) {
if (target) {
safe(function () {
target[POLYFILL_TAG] = true;
target[POLYFILL_TYPE_NAME] = polyfillTypeName;
});
safe(objDefine, [target, POLYFILL_TAG, {
v: true,
w: false,
e: false
}]);
safe(objDefine, [target, POLYFILL_TYPE_NAME, {
v: polyfillTypeName,
w: false,
e: false
}]);
}
return target;
}
var objCreate = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "create")), polyObjCreate));
/*#__NO_SIDE_EFFECTS__*/
function polyObjCreate(obj, properties) {
var newObj = null;
function tempFunc() { }
if (!isStrictNullOrUndefined(obj)) {
var type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
}
tempFunc[PROTOTYPE] = obj;
safe(function () {
tempFunc[__PROTO__] = obj;
});
newObj = new tempFunc();
}
else {
newObj = {};
}
if (properties) {
safe(objDefineProperties, [newObj, properties]);
}
return newObj;
}
/*#__NO_SIDE_EFFECTS__*/
function utcNow() {
return (Date.now || polyUtcNow)();
}
/*#__NO_SIDE_EFFECTS__*/
function polyUtcNow() {
return new Date().getTime();
}
function fnApply(fn, thisArg, argArray) {
return fn.apply(thisArg, argArray);
}
var _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = _getGlobalConfig();
}
/*#__NO_SIDE_EFFECTS__*/
function getLazy(cb, argArray) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function () {
var result = fnApply(cb, null, argArray);
if (!_globalLazyTestHooks.lzy) {
objDefineProp(lazyValue, "v", {
value: result
});
}
lazyValue.b = _globalLazyTestHooks.lzy;
return result;
}
});
return lazyValue;
}
var mathRandom = (/*#__PURE__*/_pureRef(MathCls, "random"));
var _uniqueInstanceId = (/*#__PURE__*/getLazy(function () {
var value = (utcNow().toString(36).slice(2));
while (value.length < 16) {
value += mathRandom().toString(36).slice(2);
}
value = value.substring(0, 16);
return value;
}));
var UNIQUE_REGISTRY_ID = "_urid";
var POLY_SYM = "$nw21sym";
var _polySymbols;
var _polyId = 0;
/*#__NO_SIDE_EFFECTS__*/
function _globalSymbolRegistry() {
if (!_polySymbols) {
var gblCfg = _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
var _wellKnownSymbolCache;
/*#__NO_SIDE_EFFECTS__*/
function polyNewSymbol(description) {
var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
var symString = SYMBOL + "(" + description + ")";
function _setProp(name, value) {
objDefine(theSymbol, name, {
v: value,
e: false,
w: false
});
}
var theSymbol = objCreate(null);
_setProp("description", asString(description));
_setProp(TO_STRING, function () { return symString + POLY_SYM + uniqueId; });
_setProp("valueOf", function () { return theSymbol; });
_setProp("v", symString);
_setProp("_uid", uniqueId);
return _tagAsPolyfill(theSymbol, "symbol");
}
/*#__NO_SIDE_EFFECTS__*/
function polySymbolFor(key) {
var registry = _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
var newSymbol_1 = polyNewSymbol(key);
var regId_1 = objKeys(registry.s).length;
newSymbol_1[UNIQUE_REGISTRY_ID] = function () { return regId_1 + "_" + newSymbol_1[TO_STRING](); };
registry.k[key] = newSymbol_1;
registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
}
return registry.k[key];
}
/*#__NO_SIDE_EFFECTS__*/
function polyGetKnownSymbol(name) {
!_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
var result;
var knownName = _wellKnownSymbolMap[name];
if (knownName) {
result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function createCachedValue(value) {
return objDefineProp({
toJSON: function () { return value; }
}, "v", { value: value });
}
/*#__NO_SIDE_EFFECTS__*/
function getDeferred(cb, argArray) {
var theValue = {
toJSON: function () { return theValue.v; }
};
return objDefineProp(theValue, "v", {
get: function () {
var result = fnApply(cb, null, argArray);
cb = NULL_VALUE;
objDefineProp(theValue, "v", { value: result });
return result;
},
configurable: true
});
}
var WINDOW = "window";
var _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
var cachedValue;
return function () {
!_globalLazyTestHooks && _initTestHooks();
if (!cachedValue || _globalLazyTestHooks.lzy) {
cachedValue = createCachedValue(safe(getFn, theArgs).v);
}
return cachedValue.v;
};
}
function getGlobal(useCached) {
!_globalLazyTestHooks && _initTestHooks();
if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
_cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
}
return _cachedGlobal.v;
}
/*#__NO_SIDE_EFFECTS__*/
function getInst(name, useCached) {
var gbl;
if (!_cachedGlobal || useCached === false) {
gbl = getGlobal(useCached);
}
else {
gbl = _cachedGlobal.v;
}
if (gbl && gbl[name]) {
return gbl[name];
}
if (name === WINDOW) {
try {
return window;
}
catch (e) {
}
}
return NULL_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function hasDocument() {
return !!getDocument();
}
var getDocument = (/*#__PURE__*/_getGlobalInstFn(getInst, ["document"]));
/*#__NO_SIDE_EFFECTS__*/
function hasWindow() {
return !!getWindow();
}
var getWindow = (/*#__PURE__*/_getGlobalInstFn(getInst, [WINDOW]));
/*#__NO_SIDE_EFFECTS__*/
function hasNavigator() {
return !!getNavigator();
}
var getNavigator = (/*#__PURE__*/_getGlobalInstFn(getInst, ["navigator"]));
/*#__NO_SIDE_EFFECTS__*/
function hasHistory() {
return !!getHistory();
}
var getHistory = (/*#__PURE__*/_getGlobalInstFn(getInst, ["history"]));
var isNode = (/*#__PURE__*/_getGlobalInstFn(function () {
return !!safe(function () {
var processInst = getInst("process");
return processInst && (processInst.versions || {}).node;
}).v;
}));
var _symbol;
var _symbolFor;
/*#__NO_SIDE_EFFECTS__*/
function _initSymbol() {
_symbol = (/*#__PURE__*/createCachedValue(safe((getInst), [SYMBOL]).v));
return _symbol;
}
function _getSymbolKey(key) {
var gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
}
/*#__NO_SIDE_EFFECTS__*/
function hasSymbol() {
return !!getSymbol();
}
/*#__NO_SIDE_EFFECTS__*/
function getSymbol() {
!_globalLazyTestHooks && _initTestHooks();
return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol()).v;
}
/*#__NO_SIDE_EFFECTS__*/
function getKnownSymbol(name, noPoly) {
var knownName = _wellKnownSymbolMap[name];
!_globalLazyTestHooks && _initTestHooks();
var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
}
/*#__NO_SIDE_EFFECTS__*/
function newSymbol(description, noPoly) {
!_globalLazyTestHooks && _initTestHooks();
var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return sym.v ? sym.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
}
/*#__NO_SIDE_EFFECTS__*/
function symbolFor(key) {
!_globalLazyTestHooks && _initTestHooks();
_symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || (/*#__PURE__*/createCachedValue(safe((_getSymbolKey), ["for"]).v)));
return (_symbolFor.v || polySymbolFor)(key);
}
/*#__NO_SIDE_EFFECTS__*/
function isIterator(value) {
return !!value && isFunction(value.next);
}
/*#__NO_SIDE_EFFECTS__*/
function isIterable(value) {
return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
}
var _iterSymbol$1;
function iterForOf(iter, callbackfn, thisArg) {
if (iter) {
if (!isIterator(iter)) {
!_iterSymbol$1 && (_iterSymbol$1 = createCachedValue(getKnownSymbol(3 )));
iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
}
if (isIterator(iter)) {
var err = UNDEF_VALUE;
var iterResult = UNDEF_VALUE;
try {
var count = 0;
while (!(iterResult = iter.next()).done) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? iter : thisArg, iterResult.value, count, iter) === -1) {
break;
}
count++;
}
}
catch (failed) {
err = { e: failed };
if (iter.throw) {
iterResult = NULL_VALUE;
iter.throw(err);
}
}
finally {
try {
if (iterResult && !iterResult.done) {
iter.return && iter.return(iterResult);
}
}
finally {
if (err) {
throw err.e;
}
}
}
}
}
}
function arrAppend(target, elms) {
if (!isUndefined(elms) && target) {
if (isArray(elms)) {
fnApply(target.push, target, elms);
}
else if (isIterator(elms) || isIterable(elms)) {
iterForOf(elms, function (elm) {
target.push(elm);
});
}
else {
target.push(elms);
}
}
return target;
}
var arrIndexOf = (/*#__PURE__*/_unwrapFunction("indexOf", ArrProto));
var arrMap = (/*#__PURE__*/_unwrapFunction("map", ArrProto));
function arrSlice(theArray, start, end) {
return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
}
/*#__NO_SIDE_EFFECTS__*/
function polyArrIncludes(theArray, searchElement, fromIndex) {
return arrIndexOf(theArray, searchElement, fromIndex) !== -1;
}
var arrIncludes = (/*#__PURE__*/_unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
var getLength = (/*#__PURE__*/_unwrapProp(LENGTH));
var mathFloor = (/*#__PURE__*/_pureRef(MathCls, "floor"));
/*#__NO_SIDE_EFFECTS__*/
function createIterator(ctx) {
var isDone = false;
function _value() {
return ctx.v;
}
function _next() {
if (!isDone) {
isDone = (ctx.n ? ctx.n(arguments) : true);
}
var result = {
done: isDone
};
if (!isDone) {
objDefine(result, "value", { g: _value });
}
return result;
}
function _return(value) {
isDone = true;
return {
done: true,
value: ctx.r && ctx.r(value)
};
}
function _throw(e) {
isDone = true;
return {
done: true,
value: ctx.t && ctx.t(e)
};
}
var theIterator = {
next: _next
};
if (ctx.r) {
theIterator.return = _return;
}
if (ctx.t) {
theIterator.throw = _throw;
}
return theIterator;
}
var arrReduce = (/*#__PURE__*/_unwrapFunction("reduce", ArrProto));
var _isProtoArray;
var objSetPrototypeOf = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, "setPrototypeOf")), _polyObjSetPrototypeOf));
function _polyObjSetPrototypeOf(obj, proto) {
var _a;
!_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
_isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function (key, value) { return obj[key] = value; });
return obj;
}
/*#__NO_SIDE_EFFECTS__*/
function _createCustomError(name, d, b) {
safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
d = objSetPrototypeOf(d, b);
function __() {
this[CONSTRUCTOR] = d;
safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
}
d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
return d;
}
function _setName(baseClass, name) {
name && (baseClass[NAME] = name);
}
/*#__NO_SIDE_EFFECTS__*/
function createCustomError(name, constructCb, errorBase, superArgsFn) {
var theBaseClass = errorBase || Error;
var orgName = theBaseClass[PROTOTYPE][NAME];
var captureFn = Error.captureStackTrace;
return _createCustomError(name, function () {
var _this = this;
var theArgs = arguments;
try {
safe(_setName, [theBaseClass, name]);
var _self = fnApply(theBaseClass, _this, superArgsFn ? superArgsFn(theArgs) : ArrSlice[CALL](theArgs)) || _this;
if (_self !== _this) {
var orgProto = objGetPrototypeOf(_this);
if (orgProto !== objGetPrototypeOf(_self)) {
objSetPrototypeOf(_self, orgProto);
}
}
captureFn && captureFn(_self, _this[CONSTRUCTOR]);
constructCb && constructCb(_self, theArgs);
return _self;
}
finally {
safe(_setName, [theBaseClass, orgName]);
}
}, theBaseClass);
}
var strReplace = (/*#__PURE__*/_unwrapFunction("replace", StrProto));
/*#__NO_SIDE_EFFECTS__*/
function _createTrimFn(exp) {
return function _doTrim(value) {
_throwIfNullOrUndefined(value);
value = asString(value);
if (value) {
value = strReplace(value, exp, EMPTY);
}
return value;
};
}
var polyStrTrim = (/*#__PURE__*/_createTrimFn(/^\s+|(?=\s)\s+$/g));
var strTrim = (/*#__PURE__*/_unwrapFunctionWithPoly("trim", StrProto, polyStrTrim));
var strLower = (/*#__PURE__*/_unwrapFunction("toLowerCase", StrProto));
/*#__NO_SIDE_EFFECTS__*/
function safeGetDeferred(cb, defValue, argArray) {
return getDeferred(function () {
var result = safe(cb, argArray);
return result.e ? defValue : result.v;
});
}
var objGetOwnPropertyDescriptor = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
var objGetOwnPropertySymbols = (/*#__PURE__*/_pureAssign((/*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
function forEachOwnKey(theObject, callbackfn, thisArg) {
if (theObject !== NULL_VALUE && theObject !== UNDEF_VALUE) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, prop, theObject[prop]) === -1) {
return;
}
}
}
arrForEach(objGetOwnPropertySymbols(theObject), function (key) {
if (_objPropertyIsEnumerable(theObject, key)) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, key, theObject[key]) === -1) {
return -1;
}
}
});
}
}
function forEachOwnKeySafe(theObject, callbackfn, thisArg) {
forEachOwnKey(theObject, function (key, value) {
if (!isUnsafePropKey(key)) {
return callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, key, value);
}
}, thisArg);
}
var _fnToString;
var _objCtrFnString;
var _gblWindow;
/*#__NO_SIDE_EFFECTS__*/
function isPlainObject(value) {
if (!value || typeof value !== OBJECT) {
return false;
}
if (!_gblWindow) {
_gblWindow = hasWindow() ? getWindow() : true;
}
var result = false;
if (value !== _gblWindow) {
if (!_objCtrFnString) {
_fnToString = Function[PROTOTYPE][TO_STRING];
_objCtrFnString = _fnToString[CALL](ObjClass$1);
}
try {
var proto = objGetPrototypeOf(value);
result = !proto;
if (!result) {
if (objHasOwnProperty(proto, CONSTRUCTOR)) {
proto = proto[CONSTRUCTOR];
}
result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
}
}
catch (ex) {
}
}
return result;
}
var _unsafeTargets;
/*#__NO_SIDE_EFFECTS__*/
function _addTargetProto(targets, ctor) {
}
/*#__NO_SIDE_EFFECTS__*/
function _getUnsafeTargets() {
var targets = [
ObjProto,
StrProto,
ArrProto,
NumberProto,
FuncProto,
DateProto,
RegExpProto,
BooleanProto,
ErrorProto
];
_addTargetProto(targets, safe(getInst, ["Map"]).v);
_addTargetProto(targets, safe(getInst, ["Set"]).v);
_addTargetProto(targets, safe(getInst, ["WeakMap"]).v);
_addTargetProto(targets, safe(getInst, ["WeakSet"]).v);
_addTargetProto(targets, safe(getInst, ["Promise"]).v);
_addTargetProto(targets, safe(getInst, ["Symbol"]).v);
_addTargetProto(targets, safe(getInst, ["ArrayBuffer"]).v);
_addTargetProto(targets, safe(getInst, ["SharedArrayBuffer"]).v);
_addTargetProto(targets, safe(getInst, ["DataView"]).v);
_addTargetProto(targets, safe(getInst, ["Int8Array"]).v);
_addTargetProto(targets, safe(getInst, ["Uint8Array"]).v);
_addTargetProto(targets, safe(getInst, ["Uint8ClampedArray"]).v);
_addTargetProto(targets, safe(getInst, ["Int16Array"]).v);
_addTargetProto(targets, safe(getInst, ["Uint16Array"]).v);
_addTargetProto(targets, safe(getInst, ["Int32Array"]).v);
_addTargetProto(targets, safe(getInst, ["Uint32Array"]).v);
_addTargetProto(targets, safe(getInst, ["Float32Array"]).v);
_addTargetProto(targets, safe(getInst, ["Float64Array"]).v);
_addTargetProto(targets, safe(getInst, ["BigInt64Array"]).v);
_addTargetProto(targets, safe(getInst, ["BigUint64Array"]).v);
_addTargetProto(targets, safe(getInst, ["WeakRef"]).v);
_addTargetProto(targets, safe(getInst, ["FinalizationRegistry"]).v);
return targets;
}
/*#__NO_SIDE_EFFECTS__*/
function isUnsafeTarget(target) {
if (!_unsafeTargets) {
_unsafeTargets = createCachedValue(_getUnsafeTargets());
}
return arrIndexOf(_unsafeTargets.v, target) >= 0;
}
/*#__NO_SIDE_EFFECTS__*/
function _defaultDeepCopyHandler(details) {
details.value && plainObjDeepCopyHandler(details);
return true;
}
var defaultDeepCopyHandlers = [
arrayDeepCopyHandler,
plainObjDeepCopyHandler,
functionDeepCopyHandler,
dateDeepCopyHandler
];
/*#__NO_SIDE_EFFECTS__*/
function _getSetVisited(visitMap, source, newPath, cb) {
var theEntry;
arrForEach(visitMap, function (entry) {
if (entry.k === source) {
theEntry = entry;
return -1;
}
});
if (!theEntry) {
theEntry = { k: source, v: source };
visitMap.push(theEntry);
cb(theEntry);
}
return theEntry.v;
}
function _deepCopy(visitMap, value, ctx, key) {
var userHandler = ctx.handler;
var newPath = ctx.path ? (key ? ctx.path.concat(key) : ctx.path) : [];
var newCtx = {
handler: ctx.handler,
src: ctx.src,
path: newPath
};
var theType = typeof value;
var isPlain = false;
var isPrim = value === NULL_VALUE;
if (!isPrim) {
if (value && theType === OBJECT) {
isPlain = isPlainObject(value);
}
else {
isPrim = isPrimitiveType(theType);
}
}
var details = {
type: theType,
isPrim: isPrim,
isPlain: isPlain,
value: value,
result: value,
path: newPath,
origin: ctx.src,
copy: function (source, newKey) {
return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
},
copyTo: function (target, source) {
return _copyProps(visitMap, target, source, newCtx);
}
};
if (!details.isPrim) {
return _getSetVisited(visitMap, value, newPath, function (newEntry) {
objDefine(details, "result", {
g: function () {
return newEntry.v;
},
s: function (newValue) {
newEntry.v = newValue;
}
});
var idx = 0;
var handler = userHandler;
while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler))[CALL](ctx, details)) {
handler = NULL_VALUE;
}
});
}
if (userHandler && userHandler[CALL](ctx, details)) {
return details.result;
}
return value;
}
function _copyProps(visitMap, target, source, ctx) {
if (!isUnsafeTarget(source)) {
forEachOwnKeySafe(source, function (key, value) {
target[key] = _deepCopy(visitMap, value, ctx, key);
});
}
return target;
}
function objCopyProps(target, source, handler) {
var ctx = {
handler: handler,
src: source,
path: []
};
return _copyProps([], target, source, ctx);
}
/*#__NO_SIDE_EFFECTS__*/
function objDeepCopy(source, handler) {
var ctx = {
handler: handler,
src: source
};
return _deepCopy([], source, ctx);
}
function arrayDeepCopyHandler(details) {
var value = details.value;
if (isArray(value)) {
var target = details.result = [];
target.length = value.length;
details.copyTo(target, value);
return true;
}
return false;
}
function dateDeepCopyHandler(details) {
var value = details.value;
if (isDate(value)) {
details.result = new Date(value.getTime());
return true;
}
return false;
}
function functionDeepCopyHandler(details) {
if (details.type === FUNCTION) {
return true;
}
return false;
}
function plainObjDeepCopyHandler(details) {
var value = details.value;
if (value && details.isPlain) {
var target = details.result = {};
details.copyTo(target, value);
return true;
}
return false;
}
function _doExtend(target, theArgs) {
arrForEach(theArgs, function (theArg) {
objCopyProps(target, theArg);
});
return target;
}
function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
return _doExtend(objDeepCopy(target) || {}, ArrSlice[CALL](arguments));
}
var strSplit = (/*#__PURE__*/_unwrapFunction("split", StrProto));
var _perf;
/*#__NO_SIDE_EFFECTS__*/
function getPerformance() {
!_globalLazyTestHooks && _initTestHooks();
if (!_perf || _globalLazyTestHooks.lzy) {
_perf = createCachedValue(safe((getInst), ["performance"]).v);
}
return _perf.v;
}
/*#__NO_SIDE_EFFECTS__*/
function perfNow() {
var perf = getPerformance();
if (perf && perf.now) {
return perf.now();
}
return utcNow();
}
var strIndexOf = (/*#__PURE__*/_unwrapFunction("indexOf", StrProto));
var strEndsWith = (/*#__PURE__*/_unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
/*#__NO_SIDE_EFFECTS__*/
function polyStrEndsWith(value, searchString, length) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var end = (!isUndefined(length) && length < value[LENGTH]) ? length : value[LENGTH];
return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
}
var strStartsWith = (/*#__PURE__*/_unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith));
/*#__NO_SIDE_EFFECTS__*/
function polyStrStartsWith(value, searchString, position) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var pos = position > 0 ? position : 0;
return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;
}
var REF = "ref";
var UNREF = "unref";
var HAS_REF = "hasRef";
var ENABLED = "enabled";
/*#__NO_SIDE_EFFECTS__*/
function _createTimerHandler(startTimer, refreshFn, cancelFn) {
var ref = true;
var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
var theTimerHandler;
function _unref() {
ref = false;
timerId && timerId[UNREF] && timerId[UNREF]();
return theTimerHandler;
}
function _cancel() {
timerId && cancelFn(timerId);
timerId = NULL_VALUE;
}
function _refresh() {
timerId = refreshFn(timerId);
if (!ref) {
_unref();
}
return theTimerHandler;
}
function _setEnabled(value) {
!value && timerId && _cancel();
value && !timerId && _refresh();
}
theTimerHandler = {
cancel: _cancel,
refresh: _refresh
};
theTimerHandler[HAS_REF] = function () {
if (timerId && timerId[HAS_REF]) {
return timerId[HAS_REF]();
}
return ref;
};
theTimerHandler[REF] = function () {
ref = true;
timerId && timerId[REF] && timerId[REF]();
return theTimerHandler;
};
theTimerHandler[UNREF] = _unref;
theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
get: function () { return !!timerId; },
set: _setEnabled
});
return {
h: theTimerHandler,
dn: function () {
timerId = NULL_VALUE;
}
};
}
var _setTimeoutFn;
var _clearTimeoutFn;
function _resolveTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
if (!result) {
var globalOverrides = _getGlobalConfig().tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
result = globalOverrides[0];
}
}
return result || setTimeout;
}
function _resolveClearTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
if (!result) {
var globalOverrides = _getGlobalConfig().tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
result = globalOverrides[1];
}
}
return result || clearTimeout;
}
function _createTimeoutWith(startTimer, overrideFn, theArgs) {
var isArr = isArray(overrideFn);
var len = isArr ? overrideFn.length : 0;
var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE));
var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
var timerFn = theArgs[0];
theArgs[0] = function () {
handler.dn();
fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
};
var handler = _createTimerHandler(startTimer, function (timerId) {
if (timerId) {
if (timerId.refresh) {
timerId.refresh();
return timerId;
}
fnApply(clearFn, UNDEF_VALUE, [timerId]);
}
return fnApply(setFn, UNDEF_VALUE, theArgs);
}, function (timerId) {
fnApply(clearFn, UNDEF_VALUE, [timerId]);
});
return handler.h;
}
function scheduleTimeout(callback, timeout) {
return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
function createTimeout(callback, timeout) {
return _createTimeoutWith(false, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
var createEnumStyle = createEnum;
var EventsDiscardedReason = (/*@__PURE__*/createEnumStyle({
Unknown: 0 ,
NonRetryableStatus: 1 ,
InvalidEvent: 2 ,
SizeLimitExceeded: 3 ,
KillSwitch: 4 ,
QueueFull: 5 ,
BeaconSendFailure: 6
}));
var ActiveStatus = (/*@__PURE__*/createEnumStyle({
NONE: 0 ,
PENDING: 3 ,
INACTIVE: 1 ,
ACTIVE: 2
}));
var _DYN_TO_LOWER_CASE = "toLowerCase";
var _DYN_LENGTH = "length";
var _DYN_WARN_TO_CONSOLE = "warnToConsole";
var _DYN_THROW_INTERNAL = "throwInternal";
var _DYN_WATCH = "watch";
var _DYN_APPLY = "apply";
var _DYN_PUSH = "push";
var _DYN_SPLICE = "splice";
var _DYN_LOGGER = "logger";
var _DYN_CANCEL = "cancel";
var _DYN_INITIALIZE = "initialize";
var _DYN_IDENTIFIER = "identifier";
var _DYN_REMOVE_NOTIFICATION_0 = "removeNotificationListener";
var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
var _DYN_STRINGIFY = "stringify";
var _DYN_TRACE_ID = "traceId";
var _DYN_SPAN_ID = "spanId";
var _DYN_TRACE_FLAGS = "traceFlags";
var _DYN_IS_INITIALIZED = "isInitialized";
var _DYN_TRACE_HDR_MODE = "traceHdrMode";
var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
var _DYN_GET_PLUGIN = "getPlugin";
var _DYN_TRACK = "track";
var _DYN_NAME = "name";
var _DYN_I_KEY = "iKey";
var _DYN_TIME = "time";
var _DYN_PROCESS_NEXT = "processNext";
var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
var _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
var _DYN_VALUE = "value";
var _DYN_ENABLED = "enabled";
var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
var _DYN_UNLOAD = "unload";
var _DYN_ON_COMPLETE = "onComplete";
var _DYN_REASON = "reason";
var _DYN_FLUSH = "flush";
var _DYN_GET_TRACE_CTX = "getTraceCtx";
var _DYN_SET_TRACE_CTX = "setTraceCtx";
var _DYN_GET_ACTIVE_SPAN = "getActiveSpan";
var _DYN_SET_ACTIVE_SPAN = "setActiveSpan";
var _DYN_SPAN_CONTEXT = "spanContext";
var _DYN_PARENT_SPAN_CONTEXT = "parentSpanContext";
var _DYN_PARENT_SPAN_ID = "parentSpanId";
var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
var _DYN_JOIN = "join";
var _DYN_CREATE_NEW = "createNew";
var _DYN_TEARDOWN = "teardown";
var _DYN_MESSAGE_ID = "messageId";
var _DYN_MESSAGE = "message";
var _DYN_ATTRIBUTE_COUNT_LIMI5 = "attributeCountLimit";
var _DYN_SUPPRESS_TRACING = "suppressTracing";
var _DYN_NOT_IMPLEMENTED = "notImplemented";
var _DYN_DIAG_LOG = "diagLog";
var _DYN__DO_TEARDOWN = "_doTeardown";
var _DYN_UPDATE = "update";
var _DYN_GET_NEXT = "getNext";
var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
var _DYN_SPLIT = "split";
var _DYN_IS_CHILD_EVT = "isChildEvt";
var _DYN_DATA = "data";
var _DYN_GET_CTX = "getCtx";
var _DYN_SET_CTX = "setCtx";
var _DYN_CONFIG = "config";
var _DYN_CALL = "call";
var _DYN_ITEMS_RECEIVED = "itemsReceived";
var _DYN_REPLACE = "replace";
var _DYN_HEADERS = "headers";
var _DYN_URL_STRING = "urlString";
var _DYN_TIMEOUT = "timeout";
var _DYN_STATUS = "status";
var _DYN_HAS_OWN_PROPERTY = "hasOwnProperty";
var _DYN_INDEX_OF = "indexOf";
var _DYN_TYPE = "type";
var _DYN_SET_TRACE_FLAGS = "setTraceFlags";
var _DYN_PATHNAME = "pathname";
var _DYN_TRACE_STATE = "traceState";
var _DYN_TIMINGS = "timings";
var _DYN_BASE_DATA = "baseData";
var _DYN_PROPERTIES = "properties";
var _DYN_USER_AGENT = "userAgent";
var _DYN_ATTRIBUTES = "attributes";
var _DYN_KIND = "kind";
var _DYN_START_TIME = "startTime";
var _DYN_DURATION = "duration";
var _DYN_TO_STRING = "toString";
var _DYN_PROCESS_TELEMETRY_ST6 = "processTelemetryStart";
var _DYN_HANDLE_FIELD = "handleField";
var _DYN_RM_SANITIZER = "rmSanitizer";
var _DYN_RM_FIELD_SANITIZER = "rmFieldSanitizer";
var _DYN_CAN_HANDLE = "canHandle";
var _DYN_HANDLER = "handler";
var _DYN_ERROR_HANDLERS = "errorHandlers";
var _DYN_EVT_NAME = "evtName";
var _DYN_CONCAT = "concat";
var _DYN_SUBSTRING = "substring";
var _DYN_GET_ALL_RESPONSE_HEA7 = "getAllResponseHeaders";
var _DYN_ENTRIES = "entries";
var _DYN_TRACE_CFG = "traceCfg";
var aggregationErrorType;
function throwAggregationError(message, sourceErrors) {
if (!aggregationErrorType) {
aggregationErrorType = createCustomError("AggregationError", function (self, args) {
if (args[_DYN_LENGTH ] > 1) {
self.errors = args[1];
}
});
}
var theMessage = message || "One or more errors occurred.";
arrForEach(sourceErrors, function (srcError, idx) {
theMessage += "\n".concat(idx, " > ").concat(dumpObj(srcError));
});
throw new aggregationErrorType(theMessage, sourceErrors || []);
}
var strShimFu