@microsoft/applicationinsights-clickanalytics-js 3.0.0-beta.2303-11 → 3.0.0-nightly3.2304-28

package/browser/{ai.clck.3.cjs.js → es5/ai.clck.3.cjs.js}

@@ -1,912 +1,934 @@
 /*!
- * Application Insights JavaScript SDK - Click Analytics, 3.0.0-beta.2303-11
+ * Application Insights JavaScript SDK - Click Analytics, 3.0.0-nightly3.2304-28
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var strShimFunction = "function";
 var strShimObject = "object";
 var strShimUndefined = "undefined";
 var strShimPrototype = "prototype";
-var strShimHasOwnProperty = "hasOwnProperty";
 var ObjClass$1 = Object;
-var ObjCreate = ObjClass$1["create"];
 
-var _cachedGlobal$1 = null;
-function getGlobal$1(useCached) {
-    if (useCached === void 0) { useCached = true; }
-    var result = useCached === false ? null : _cachedGlobal$1;
-    if (!result) {
-        if (typeof globalThis !== strShimUndefined) {
-            result = globalThis;
-        }
-        if (!result && typeof self !== strShimUndefined) {
-            result = self;
-        }
-        if (!result && typeof window !== strShimUndefined) {
-            result = window;
-        }
-        if (!result && typeof global !== strShimUndefined) {
-            result = global;
-        }
-        _cachedGlobal$1 = result;
+var UNDEF_VALUE = undefined;
+var EMPTY = "";
+var BOOLEAN = "boolean";
+var FUNCTION = "function";
+var NUMBER = "number";
+var OBJECT = "object";
+var PROTOTYPE = "prototype";
+var STRING = "string";
+var UNDEFINED = "undefined";
+var CONSTRUCTOR = "constructor";
+var SYMBOL = "Symbol";
+var POLYFILL_TAG = "_polyfill";
+var INDEX_OF = "indexOf";
+var LENGTH = "length";
+var DONE = "done";
+var VALUE = "value";
+var NAME = "name";
+var SLICE = "slice";
+var ObjClass = Object;
+var ObjProto = ObjClass[PROTOTYPE];
+var StrCls = String;
+var StrProto = StrCls[PROTOTYPE];
+var ArrCls = Array;
+var ArrProto = ArrCls[PROTOTYPE];
+
+function _safeGet(cb, defValue) {
+    var result = defValue;
+    try {
+        result = cb();
+    }
+    catch (e) {
     }
     return result;
 }
-function throwTypeError$1(message) {
-    throw new TypeError(message);
+
+function _createIs(theType) {
+    return function (value) {
+        return typeof value === theType;
+    };
 }
-function objCreateFn(obj) {
-    var func = ObjCreate;
-    if (func) {
-        return func(obj);
-    }
-    if (obj == null) {
-        return {};
-    }
-    var type = typeof obj;
-    if (type !== strShimObject && type !== strShimFunction) {
-        throwTypeError$1("Object prototype may only be an Object:" + obj);
+function _createObjIs(theName) {
+    var theType = "[object " + theName + "]";
+    return function (value) {
+        return !!(value && objToString(value) === theType);
+    };
+}
+function objToString(value) {
+    return ObjProto.toString.call(value);
+}
+function isUndefined(value) {
+    return typeof value === UNDEFINED || value === UNDEFINED;
+}
+function isNullOrUndefined(value) {
+    return value === null || isUndefined(value);
+}
+function isStrictNullOrUndefined(value) {
+    return value === null || !isDefined(value);
+}
+function isDefined(arg) {
+    return !!arg || arg !== UNDEF_VALUE;
+}
+var isString = _createIs(STRING);
+var isFunction = _createIs(FUNCTION);
+function isObject(value) {
+    if (!value && isNullOrUndefined(value)) {
+        return false;
     }
-    function tmpFunc() { }
-    tmpFunc[strShimPrototype] = obj;
-    return new tmpFunc();
+    return !!value && typeof value === OBJECT;
 }
+var isArray = ArrCls.isArray;
+var isNumber = _createIs(NUMBER);
+var isBoolean = _createIs(BOOLEAN);
+var isError = _createObjIs("Error");
 
-(getGlobal$1() || {})["Symbol"];
-(getGlobal$1() || {})["Reflect"];
-var extendStaticsFn = function (d, b) {
-    extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
-        ({ __proto__: [] } instanceof Array && function (d, b) {
-            d.__proto__ = b;
-        }) ||
-        function (d, b) {
-            for (var p in b) {
-                if (b[strShimHasOwnProperty](p)) {
-                    d[p] = b[p];
+var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
+
+function objHasOwnProperty(obj, prop) {
+    return obj && ObjProto.hasOwnProperty.call(obj, prop);
+}
+
+var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
+function polyObjHasOwn(obj, prop) {
+    return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+}
+
+function objForEachKey(theObject, callbackfn, thisArg) {
+    if (theObject && isObject(theObject)) {
+        for (var prop in theObject) {
+            if (objHasOwn(theObject, prop)) {
+                if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
+                    break;
                 }
             }
-        };
-    return extendStaticsFn(d, b);
-};
-function __extendsFn(d, b) {
-    if (typeof b !== strShimFunction && b !== null) {
-        throwTypeError$1("Class extends value " + String(b) + " is not a constructor or null");
+        }
     }
-    extendStaticsFn(d, b);
-    function __() {
-        this.constructor = d;
+}
+
+function _createKeyValueMap(values, keyType, valueType, completeFn) {
+    var theMap = {};
+    objForEachKey(values, function (key, value) {
+        theMap[key] = keyType ? value : key;
+        theMap[value] = valueType ? value : key;
+    });
+    return completeFn(theMap);
+}
+
+function throwError(message) {
+    throw new Error(message);
+}
+function throwTypeError(message) {
+    throw new TypeError(message);
+}
+
+var _objFreeze = ObjClass["freeze"];
+var _doNothing = function (value) { return value; };
+function objKeys(value) {
+    if (!isObject(value) || value === null) {
+        throwTypeError("objKeys called on non-object");
+    }
+    return ObjClass.keys(value);
+}
+function objDeepFreeze(value) {
+    if (_objFreeze) {
+        objForEachKey(value, function (key, value) {
+            if (isArray(value) || isObject(value)) {
+                _objFreeze(value);
+            }
+        });
     }
-    d[strShimPrototype] = b === null ? objCreateFn(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+    return objFreeze(value);
 }
+var objFreeze = _objFreeze || _doNothing;
+var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _doNothing;
 
-/*!
- * Microsoft Dynamic Proto Utility, 1.1.8
- * Copyright (c) Microsoft and contributors. All rights reserved.
- */
-var _a$2;
-var UNDEFINED$1 = "undefined";
-var Constructor = 'constructor';
-var Prototype = 'prototype';
-var strFunction = 'function';
-var DynInstFuncTable = '_dynInstFuncs';
-var DynProxyTag = '_isDynProxy';
-var DynClassName = '_dynClass';
-var DynClassNamePrefix = '_dynCls$';
-var DynInstChkTag = '_dynInstChk';
-var DynAllowInstChkTag = DynInstChkTag;
-var DynProtoDefaultOptions = '_dfOpts';
-var UnknownValue = '_unknown_';
-var str__Proto = "__proto__";
-var DynProtoBaseProto = "_dyn" + str__Proto;
-var DynProtoGlobalSettings = "__dynProto$Gbl";
-var DynProtoCurrent = "_dynInstProto";
-var strUseBaseInst = 'useBaseInst';
-var strSetInstFuncs = 'setInstFuncs';
-var Obj = Object;
-var _objGetPrototypeOf = Obj["getPrototypeOf"];
-var _objGetOwnProps = Obj["getOwnPropertyNames"];
-function _getGlobal() {
+function createEnumKeyMap(values) {
+    return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+}
+
+var _wellKnownSymbolMap = 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 asString = StrCls;
+
+var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
+var _globalCfg;
+function _getGlobalValue() {
     var result;
-    if (typeof globalThis !== UNDEFINED$1) {
+    if (typeof globalThis !== UNDEFINED) {
         result = globalThis;
     }
-    if (!result && typeof self !== UNDEFINED$1) {
+    if (!result && typeof self !== UNDEFINED) {
         result = self;
     }
-    if (!result && typeof window !== UNDEFINED$1) {
+    if (!result && typeof window !== UNDEFINED) {
         result = window;
     }
-    if (!result && typeof global !== UNDEFINED$1) {
+    if (!result && typeof global !== UNDEFINED) {
         result = global;
     }
-    return result || {};
-}
-var _gbl = _getGlobal();
-var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
-    o: (_a$2 = {},
-        _a$2[strSetInstFuncs] = true,
-        _a$2[strUseBaseInst] = true,
-        _a$2),
-    n: 1000
-});
-function _hasOwnProperty(obj, prop) {
-    return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
-}
-function _isObjectOrArrayPrototype(target) {
-    return target && (target === Obj[Prototype] || target === Array[Prototype]);
-}
-function _isObjectArrayOrFunctionPrototype(target) {
-    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+    return result;
 }
-function _getObjProto(target) {
-    var newProto;
-    if (target) {
-        if (_objGetPrototypeOf) {
-            return _objGetPrototypeOf(target);
-        }
-        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
-        newProto = target[DynProtoBaseProto] || curProto;
-        if (!_hasOwnProperty(target, DynProtoBaseProto)) {
-            delete target[DynProtoCurrent];
-            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
-            target[DynProtoCurrent] = curProto;
-        }
+function _getGlobalConfig() {
+    if (!_globalCfg) {
+        var gbl = _getGlobalValue() || {};
+        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
     }
-    return newProto;
+    return _globalCfg;
 }
-function _forEachProp(target, func) {
-    var props = [];
-    if (_objGetOwnProps) {
-        props = _objGetOwnProps(target);
+
+function dumpObj(object, format) {
+    var propertyValueDump = EMPTY;
+    if (isError(object)) {
+        propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
     }
     else {
-        for (var name_1 in target) {
-            if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
-                props.push(name_1);
-            }
+        try {
+            propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
         }
-    }
-    if (props && props.length > 0) {
-        for (var lp = 0; lp < props.length; lp++) {
-            func(props[lp]);
+        catch (e) {
+            propertyValueDump = " - " + dumpObj(e, format);
         }
     }
+    return objToString(object) + ": " + propertyValueDump;
 }
-function _isDynamicCandidate(target, funcName, skipOwn) {
-    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
-}
-function _throwTypeError(message) {
-    throw new TypeError("DynamicProto: " + message);
+
+function _unwrapFunction(funcName, target, polyFunc) {
+    return function (thisArg) {
+        var theFunc = (thisArg && thisArg[funcName]) || (target && target[funcName]);
+        if (theFunc || polyFunc) {
+            var theArgs = arguments;
+            return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrProto[SLICE].call(theArgs, 1) : theArgs);
+        }
+        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+    };
 }
-function _getInstanceFuncs(thisTarget) {
-    var instFuncs = {};
-    _forEachProp(thisTarget, function (name) {
-        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-            instFuncs[name] = thisTarget[name];
-        }
-    });
-    return instFuncs;
+
+var strSubstring = _unwrapFunction("substring", StrProto);
+
+var _polySymbols;
+function _globalSymbolRegistry() {
+    if (!_polySymbols) {
+        var gblCfg = _getGlobalConfig();
+        _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
+    }
+    return _polySymbols;
 }
-function _hasVisited(values, value) {
-    for (var lp = values.length - 1; lp >= 0; lp--) {
-        if (values[lp] === value) {
-            return true;
-        }
+var _wellKnownSymbolCache = {};
+function polyNewSymbol(description) {
+    var theSymbol = {
+        description: asString(description),
+        toString: function () { return SYMBOL + "(" + description + ")"; }
+    };
+    theSymbol[POLYFILL_TAG] = true;
+    return theSymbol;
+}
+function polySymbolFor(key) {
+    var registry = _globalSymbolRegistry();
+    if (!objHasOwn(registry, key)) {
+        var newSymbol = polyNewSymbol(key);
+        registry.k[key] = newSymbol;
+        registry.s[newSymbol] = asString(key);
     }
-    return false;
+    return registry.k[key];
 }
-function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
-    function _instFuncProxy(target, funcHost, funcName) {
-        var theFunc = funcHost[funcName];
-        if (theFunc[DynProxyTag] && useBaseInst) {
-            var instFuncTable = target[DynInstFuncTable] || {};
-            if (instFuncTable[DynAllowInstChkTag] !== false) {
-                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
-            }
+function polyGetKnownSymbol(name) {
+    var result;
+    var knownName = _wellKnownSymbolMap[name];
+    if (knownName) {
+        result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+    }
+    return result;
+}
+
+var propMap = {
+    e: "enumerable",
+    c: "configurable",
+    v: VALUE,
+    w: "writable",
+    g: "get",
+    s: "set"
+};
+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(value.l, "v");
+        if (desc && desc.set) {
+            prop.set = function (newValue) {
+                value.l.v = newValue;
+            };
         }
-        return function () {
-            return theFunc.apply(target, arguments);
-        };
     }
-    var baseFuncs = {};
-    _forEachProp(instFuncs, function (name) {
-        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+    objForEachKey(value, function (key, value) {
+        prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
     });
-    var baseProto = _getObjProto(classProto);
-    var visited = [];
-    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-        _forEachProp(baseProto, function (name) {
-            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
-                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
-            }
-        });
-        visited.push(baseProto);
-        baseProto = _getObjProto(baseProto);
-    }
-    return baseFuncs;
+    return prop;
 }
-function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
-    var instFunc = null;
-    if (target && _hasOwnProperty(proto, DynClassName)) {
-        var instFuncTable = target[DynInstFuncTable] || {};
-        instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
-        if (!instFunc) {
-            _throwTypeError("Missing [" + funcName + "] " + strFunction);
-        }
-        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
-            var canAddInst = !_hasOwnProperty(target, funcName);
-            var objProto = _getObjProto(target);
-            var visited = [];
-            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
-                var protoFunc = objProto[funcName];
-                if (protoFunc) {
-                    canAddInst = (protoFunc === currentDynProtoProxy);
-                    break;
-                }
-                visited.push(objProto);
-                objProto = _getObjProto(objProto);
-            }
-            try {
-                if (canAddInst) {
-                    target[funcName] = instFunc;
+var objDefineProp = ObjClass["defineProperty"];
+function objDefine(target, key, propDesc) {
+    return objDefineProp(target, key, _createProp(propDesc));
+}
+
+var _globalLazyTestHooks;
+var _fetchLazyTestHooks = function () {
+    _globalLazyTestHooks = _getGlobalConfig();
+    _fetchLazyTestHooks = null;
+};
+function getLazy(cb) {
+    var lazyValue = {};
+    _fetchLazyTestHooks && _fetchLazyTestHooks();
+    lazyValue.b = _globalLazyTestHooks.lzy;
+    objDefineProp(lazyValue, "v", {
+        configurable: true,
+        get: function () {
+            var result = cb();
+            if (!_globalLazyTestHooks.lzy) {
+                objDefineProp(lazyValue, "v", {
+                    value: result
+                });
+                if (lazyValue.b) {
+                    delete lazyValue.b;
                 }
-                instFunc[DynInstChkTag] = 1;
             }
-            catch (e) {
-                instFuncTable[DynAllowInstChkTag] = false;
+            if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                lazyValue.b = _globalLazyTestHooks.lzy;
             }
+            return result;
         }
-    }
-    return instFunc;
+    });
+    return lazyValue;
 }
-function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-    var protoFunc = proto[funcName];
-    if (protoFunc === currentDynProtoProxy) {
-        protoFunc = _getObjProto(proto)[funcName];
+
+function _lazySafeGet(cb, defValue) {
+    return getLazy(function () { return _safeGet(cb, defValue); });
+}
+
+var WINDOW = "window";
+var _cachedGlobal;
+var _cachedWindow;
+var _cachedDocument;
+var _cachedNavigator;
+function _lazySafeGetInst(name) {
+    return _lazySafeGet(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+}
+function getGlobal(useCached) {
+    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
+    return _cachedGlobal.v;
+}
+function getInst(name, useCached) {
+    var gbl = getGlobal(useCached);
+    if (gbl && gbl[name]) {
+        return gbl[name];
     }
-    if (typeof protoFunc !== strFunction) {
-        _throwTypeError("[" + funcName + "] is not a " + strFunction);
+    if (name === WINDOW && _cachedWindow) {
+        return _cachedWindow.v;
     }
-    return protoFunc;
+    return null;
 }
-function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
-    function _createDynamicPrototype(proto, funcName) {
-        var dynProtoProxy = function () {
-            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
-            return instFunc.apply(this, arguments);
-        };
-        dynProtoProxy[DynProxyTag] = 1;
-        return dynProtoProxy;
-    }
-    if (!_isObjectOrArrayPrototype(proto)) {
-        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
-        var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
-        if (instFuncTable[DynAllowInstChkTag] !== false) {
-            instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+function hasDocument() {
+    return !!getDocument();
+}
+function getDocument() {
+    (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst("document"));
+    return _cachedDocument.v;
+}
+function hasWindow() {
+    return !!getWindow();
+}
+function getWindow() {
+    (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
+    return _cachedWindow.v;
+}
+function getNavigator() {
+    (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst("navigator"));
+    return _cachedNavigator.v;
+}
+
+var _symbol;
+var _symbolFor;
+var _symbolKeyFor;
+function _getSymbolValue(name) {
+    return _lazySafeGet(function () {
+        return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+    }, UNDEF_VALUE);
+}
+function getSymbol() {
+    var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
+    resetCache && (_symbol = _lazySafeGetInst(SYMBOL));
+    (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
+    (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
+    return _symbol.v;
+}
+function getKnownSymbol(name, noPoly) {
+    var knownName = _wellKnownSymbolMap[name];
+    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return _symbol.v ? _symbol.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+}
+function newSymbol(description, noPoly) {
+    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
+}
+function symbolFor(key) {
+    (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return (_symbolFor.v || polySymbolFor)(key);
+}
+
+function isIterator(value) {
+    return !!value && isFunction(value.next);
+}
+function isIterable(value) {
+    return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
+}
+
+function iterForOf(iter, callbackfn, thisArg) {
+    if (iter) {
+        if (!isIterator(iter)) {
+            var itSymbol = getKnownSymbol(3 );
+            iter = iter[itSymbol] ? iter[itSymbol]() : null;
         }
-        _forEachProp(target, function (name) {
-            if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
-                instFuncs_1[name] = target[name];
-                delete target[name];
-                if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
-                    proto[name] = _createDynamicPrototype(proto, name);
+        if (isIterator(iter)) {
+            try {
+                var count = 0;
+                var value = iter.next();
+                while (!value[DONE]) {
+                    if (callbackfn.call(thisArg || iter, value[VALUE], count, iter) === -1) {
+                        break;
+                    }
+                    count++;
+                    value = iter.next();
                 }
+                iter.return && iter.return(value);
             }
-        });
-    }
-}
-function _checkPrototype(classProto, thisTarget) {
-    if (_objGetPrototypeOf) {
-        var visited = [];
-        var thisProto = _getObjProto(thisTarget);
-        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-            if (thisProto === classProto) {
-                return true;
+            catch (e) {
+                iter.throw && iter.throw(e);
             }
-            visited.push(thisProto);
-            thisProto = _getObjProto(thisProto);
         }
-        return false;
     }
-    return true;
 }
-function _getObjName(target, unknownValue) {
-    if (_hasOwnProperty(target, Prototype)) {
-        return target.name || unknownValue || UnknownValue;
-    }
-    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
-}
-function dynamicProto(theClass, target, delegateFunc, options) {
-    if (!_hasOwnProperty(theClass, Prototype)) {
-        _throwTypeError("theClass is an invalid class definition.");
-    }
-    var classProto = theClass[Prototype];
-    if (!_checkPrototype(classProto, target)) {
-        _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
-    }
-    var className = null;
-    if (_hasOwnProperty(classProto, DynClassName)) {
-        className = classProto[DynClassName];
-    }
-    else {
-        className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
-        _gblInst.n++;
-        classProto[DynClassName] = className;
-    }
-    var perfOptions = dynamicProto[DynProtoDefaultOptions];
-    var useBaseInst = !!perfOptions[strUseBaseInst];
-    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-        useBaseInst = !!options[strUseBaseInst];
+
+function arrAppend(target, elms) {
+    if (!isUndefined(elms) && target) {
+        if (isArray(elms)) {
+            target.push.apply(target, elms);
+        }
+        else if (isIterator(elms) || isIterable(elms)) {
+            iterForOf(elms, function (elm) {
+                target.push(elm);
+            });
+        }
+        else {
+            target.push(elms);
+        }
     }
-    var instFuncs = _getInstanceFuncs(target);
-    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
-    delegateFunc(target, baseFuncs);
-    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
-    if (setInstanceFunc && options) {
-        setInstanceFunc = !!options[strSetInstFuncs];
+    return target;
+}
+
+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(thisArg || theArray, theArray[idx], idx, theArray) === -1) {
+                    break;
+                }
+            }
+        }
     }
-    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
 }
-dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
-/*!
- * NevWare21 - ts-utils, 0.8.1
- * https://github.com/nevware21/ts-utils
- * Copyright (c) NevWare21 and contributors. All rights reserved.
- * Licensed under the MIT license.
- */
-var UNDEF_VALUE = undefined;
-var EMPTY = "";
-var BOOLEAN = "boolean";
-var FUNCTION = "function";
-var NUMBER = "number";
-var OBJECT = "object";
-var PROTOTYPE = "prototype";
-var STRING = "string";
-var UNDEFINED = "undefined";
-var CONSTRUCTOR = "constructor";
-var HAS_OWN_PROPERTY = "hasOwnProperty";
-var SYMBOL = "Symbol";
-var POLYFILL_TAG = "_polyfill";
-var INDEX_OF = "indexOf";
-var LENGTH = "length";
-var DONE = "done";
-var VALUE = "value";
-var NAME = "name";
-var ObjClass = Object;
-var ObjProto = ObjClass[PROTOTYPE];
-var StrCls = String;
-var ArrCls = Array;
-var ArrProto = ArrCls[PROTOTYPE];
-function _safeGet(cb, defValue) {
-    var result = defValue;
+var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
+
+var arrSlice = _unwrapFunction(SLICE, ArrProto);
+
+function objSetPrototypeOf(obj, proto) {
+    var fn = ObjClass["setPrototypeOf"] ||
+        ({ __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        }) ||
+        function (d, b) {
+            objForEachKey(b, function (key, value) { return d[key] = value; });
+        };
+    return fn(obj, proto);
+}
+
+function _createCustomError(name, d, baseClass) {
+    objSetPrototypeOf(d, baseClass);
+    function __() {
+        this.constructor = d;
+        this[NAME] = name;
+    }
+    __[PROTOTYPE] = baseClass[PROTOTYPE];
+    d[PROTOTYPE] = new __();
+    return d;
+}
+var _safeSetName = function (baseClass, name) {
     try {
-        result = cb();
+        baseClass[PROTOTYPE][NAME] = name;
     }
     catch (e) {
     }
-    return result;
-}
-function _createIs(theType) {
-    return function (value) {
-        return typeof value === theType;
-    };
-}
-function _createObjIs(theName) {
-    var theType = "[object " + theName + "]";
-    return function (value) {
-        return !!(value && objToString(value) === theType);
-    };
-}
-function objToString(value) {
-    return ObjProto.toString.call(value);
-}
-function isUndefined(value) {
-    return typeof value === UNDEFINED || value === UNDEFINED;
+};
+function createCustomError(name, constructCb) {
+    var baseClass = Error;
+    var orgName = baseClass[PROTOTYPE][NAME];
+    var customError = _createCustomError(name, function () {
+        var _this = this;
+        try {
+            _safeSetName(baseClass, name);
+            _this = baseClass.apply(_this, arguments) || _this;
+            _this[NAME] = name;
+            constructCb && constructCb(_this, arguments);
+        }
+        finally {
+            _safeSetName(baseClass, orgName);
+        }
+        return _this;
+    }, baseClass);
+    return customError;
 }
-function isNullOrUndefined(value) {
-    return value === null || isUndefined(value);
+
+function utcNow() {
+    return (Date.now || polyUtcNow)();
 }
-function isDefined(arg) {
-    return !!arg || arg !== UNDEF_VALUE;
+function polyUtcNow() {
+    return new Date().getTime();
 }
-var isString = _createIs(STRING);
-var isFunction = _createIs(FUNCTION);
-function isObject(value) {
-    if (!value && isNullOrUndefined(value)) {
+
+var _fnToString;
+var _objCtrFnString;
+var _gblWindow;
+function isPlainObject(value) {
+    if (!value || typeof value !== OBJECT) {
         return false;
     }
-    return !!value && typeof value === OBJECT;
-}
-var isArray = ArrCls.isArray;
-var isNumber = _createIs(NUMBER);
-var isBoolean = _createIs(BOOLEAN);
-var isError = _createObjIs("Error");
-var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
-function objHasOwnProperty(obj, prop) {
-    return obj && ObjProto[HAS_OWN_PROPERTY].call(obj, prop);
-}
-var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
-function polyObjHasOwn(obj, prop) {
-    return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
-}
-function objForEachKey(theObject, callbackfn, thisArg) {
-    if (theObject && isObject(theObject)) {
-        for (var prop in theObject) {
-            if (objHasOwn(theObject, prop)) {
-                if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
-                    break;
+    if (!_gblWindow) {
+        _gblWindow = hasWindow() ? getWindow() : true;
+    }
+    var result = false;
+    if (value !== _gblWindow) {
+        if (!_objCtrFnString) {
+            _fnToString = Function[PROTOTYPE].toString;
+            _objCtrFnString = _fnToString.call(ObjClass);
+        }
+        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;
 }
-function _createKeyValueMap(values, keyType, valueType, completeFn) {
-    var theMap = {};
-    objForEachKey(values, function (key, value) {
-        theMap[key] = keyType ? value : key;
-        theMap[value] = valueType ? value : key;
-    });
-    return completeFn(theMap);
-}
-function throwError(message) {
-    throw new Error(message);
-}
-function throwTypeError(message) {
-    throw new TypeError(message);
+
+var _perf;
+function getPerformance() {
+    (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
+    return _perf.v;
 }
-var _objFreeze = ObjClass["freeze"];
-var _doNothing = function (value) { return value; };
-function objKeys(value) {
-    if (!isObject(value) || value === null) {
-        throwTypeError("objKeys called on non-object");
+
+var _objCreate = ObjClass["create"];
+var objCreate = _objCreate || polyObjCreate;
+function polyObjCreate(obj) {
+    if (!obj) {
+        return {};
     }
-    return ObjClass.keys(value);
-}
-function objDeepFreeze(value) {
-    if (_objFreeze) {
-        objForEachKey(value, function (key, value) {
-            if (isArray(value) || isObject(value)) {
-                _objFreeze(value);
-            }
-        });
+    var type = typeof obj;
+    if (type !== OBJECT && type !== FUNCTION) {
+        throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
     }
-    return objFreeze(value);
-}
-var objFreeze = _objFreeze || _doNothing;
-var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _doNothing;
-function createEnumKeyMap(values) {
-    return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+    function tempFunc() { }
+    tempFunc[PROTOTYPE] = obj;
+    return new tempFunc();
 }
-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 asString = StrCls;
-var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
-var _globalCfg;
-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;
-}
-function _getGlobalConfig() {
-    if (!_globalCfg) {
-        var gbl = _getGlobalValue() || {};
-        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
-    }
-    return _globalCfg;
-}
-function dumpObj(object, format) {
-    var propertyValueDump = "";
-    if (isError(object)) {
-        propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
-    }
-    else {
-        try {
-            propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
-        }
-        catch (e) {
-            propertyValueDump = " - " + dumpObj(e, format);
+
+var strIndexOf = _unwrapFunction(INDEX_OF, StrProto);
+
+var REF = "ref";
+var UNREF = "un" + REF;
+var HAS_REF = "hasRef";
+var ENABLED = "enabled";
+function _createTimerHandler(startTimer, refreshFn, cancelFn) {
+    var _a;
+    var ref = true;
+    var timerId = startTimer ? refreshFn(null) : null;
+    var theTimerHandler;
+    var _unref = function () {
+        ref = false;
+        timerId && timerId[UNREF] && timerId[UNREF]();
+        return theTimerHandler;
+    };
+    var _ref = function () {
+        ref = true;
+        timerId && timerId[REF] && timerId[REF]();
+        return theTimerHandler;
+    };
+    var _hasRef = function () {
+        if (timerId && timerId[HAS_REF]) {
+            return timerId[HAS_REF]();
         }
-    }
-    return objToString(object) + ": " + propertyValueDump;
-}
-function _extractArgs(args, startAt) {
-    var theArgs = [];
-    for (var lp = startAt; lp < args[LENGTH]; lp++) {
-        theArgs[lp - startAt] = args[lp];
-    }
-    return theArgs;
-}
-function _unwrapFunction(funcName, target, polyFunc) {
-    return function (thisArg) {
-        if ((thisArg || thisArg === EMPTY)) {
-            var theFunc = thisArg[funcName] || (target && target[funcName]);
-            if (theFunc) {
-                return theFunc.apply(thisArg, _extractArgs(arguments, 1));
-            }
-            if (polyFunc) {
-                return polyFunc.apply(thisArg, arguments);
-            }
+        return ref;
+    };
+    var _refresh = function () {
+        timerId = refreshFn(timerId);
+        if (!ref) {
+            _unref();
         }
-        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+        return theTimerHandler;
     };
-}
-var _polySymbols;
-function _globalSymbolRegistry() {
-    if (!_polySymbols) {
-        var gblCfg = _getGlobalConfig();
-        _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
-    }
-    return _polySymbols;
-}
-function polyNewSymbol(description) {
-    var theSymbol = {
-        description: asString(description),
-        toString: function () { return SYMBOL + "(" + description + ")"; }
+    var _cancel = function () {
+        timerId && cancelFn(timerId);
+        timerId = null;
     };
-    theSymbol[POLYFILL_TAG] = true;
-    return theSymbol;
-}
-function polySymbolFor(key) {
-    var registry = _globalSymbolRegistry();
-    if (!objHasOwn(registry, key)) {
-        var newSymbol = polyNewSymbol(key);
-        registry.k[key] = newSymbol;
-        registry.s[newSymbol] = asString(key);
-    }
-    return registry.k[key];
-}
-var propMap = {
-    e: "enumerable",
-    c: "configurable",
-    v: VALUE,
-    w: "writable",
-    g: "get",
-    s: "set"
-};
-function _createProp(value) {
-    var prop = {};
-    prop[propMap["c"]] = true;
-    prop[propMap["e"]] = true;
-    objForEachKey(value, function (key, value) {
-        prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
+    var _setEnabled = function (value) {
+        !value && timerId && _cancel();
+        value && !timerId && _refresh();
+    };
+    theTimerHandler = (_a = {
+            cancel: _cancel,
+            refresh: _refresh
+        },
+        _a[HAS_REF] = _hasRef,
+        _a[REF] = _ref,
+        _a[UNREF] = _unref,
+        _a[ENABLED] = false,
+        _a);
+    objDefineProp(theTimerHandler, ENABLED, {
+        get: function () { return !!timerId; },
+        set: _setEnabled
     });
-    return prop;
-}
-var objDefineProp = ObjClass["defineProperty"];
-function objDefine(target, key, propDesc) {
-    return objDefineProp(target, key, _createProp(propDesc));
+    return {
+        h: theTimerHandler,
+        dn: function () {
+            timerId = null;
+        }
+    };
 }
-var _globalLazyTestHooks;
-var _fetchLazyTestHooks = function () {
-    _globalLazyTestHooks = _getGlobalConfig();
-    _fetchLazyTestHooks = null;
-};
-function getLazy(cb) {
-    var lazyValue = {};
-    _fetchLazyTestHooks && _fetchLazyTestHooks();
-    lazyValue.b = _globalLazyTestHooks.lzy;
-    objDefine(lazyValue, "v", {
-        g: function () {
-            var result = cb();
-            if (!_globalLazyTestHooks.lzy) {
-                objDefine(lazyValue, "v", { v: result });
-                if (lazyValue.b) {
-                    delete lazyValue.b;
-                }
-            }
-            if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
-                lazyValue.b = _globalLazyTestHooks.lzy;
+
+function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
+    var isArr = isArray(overrideFn);
+    var len = isArr ? overrideFn.length : 0;
+    var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;
+    var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;
+    var timerFn = theArgs[0];
+    theArgs[0] = function () {
+        handler.dn();
+        timerFn.apply(self, arguments);
+    };
+    var handler = _createTimerHandler(startTimer, function (timerId) {
+        if (timerId) {
+            if (timerId.refresh) {
+                timerId.refresh();
+                return timerId;
             }
-            return result;
+            clearFn.call(self, timerId);
         }
+        return setFn.apply(self, theArgs);
+    }, function (timerId) {
+        clearFn.call(self, timerId);
     });
-    return lazyValue;
-}
-function _lazySafeGet(cb, defValue) {
-    return getLazy(function () { return _safeGet(cb, defValue); });
-}
-var DOCUMENT = "document";
-var NAVIGATOR = "navigator";
-var WINDOW = "window";
-var _cachedGlobal;
-var _cachedWindow;
-var _cachedDocument;
-var _cachedNavigator;
-function _lazySafeGetInst(name) {
-    return _lazySafeGet(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+    return handler.h;
 }
-function getGlobal(useCached) {
-    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
-    return _cachedGlobal.v;
+function scheduleTimeout(callback, timeout) {
+    return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
 }
-function getInst(name, useCached) {
-    var gbl = getGlobal(useCached);
-    if (gbl && gbl[name]) {
-        return gbl[name];
+
+(getGlobal() || {})["Symbol"];
+(getGlobal() || {})["Reflect"];
+var strHasOwnProperty = "hasOwnProperty";
+var extendStaticsFn = function (d, b) {
+    extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
+        ({ __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        }) ||
+        function (d, b) {
+            for (var p in b) {
+                if (b[strHasOwnProperty](p)) {
+                    d[p] = b[p];
+                }
+            }
+        };
+    return extendStaticsFn(d, b);
+};
+function __extendsFn(d, b) {
+    if (typeof b !== strShimFunction && b !== null) {
+        throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
     }
-    if (name === WINDOW && _cachedWindow) {
-        return _cachedWindow.v;
+    extendStaticsFn(d, b);
+    function __() {
+        this.constructor = d;
     }
-    return null;
-}
-function hasDocument() {
-    return !!getDocument();
+    d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
 }
-function getDocument() {
-    (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst(DOCUMENT));
-    return _cachedDocument.v;
-}
-function hasWindow() {
-    return !!getWindow();
-}
-function getWindow() {
-    (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
-    return _cachedWindow.v;
+
+var _a$2;
+var Constructor = 'constructor';
+var Prototype = 'prototype';
+var strFunction = 'function';
+var DynInstFuncTable = '_dynInstFuncs';
+var DynProxyTag = '_isDynProxy';
+var DynClassName = '_dynClass';
+var DynClassNamePrefix = '_dynCls$';
+var DynInstChkTag = '_dynInstChk';
+var DynAllowInstChkTag = DynInstChkTag;
+var DynProtoDefaultOptions = '_dfOpts';
+var UnknownValue = '_unknown_';
+var str__Proto = "__proto__";
+var DynProtoBaseProto = "_dyn" + str__Proto;
+var DynProtoGlobalSettings = "__dynProto$Gbl";
+var DynProtoCurrent = "_dynInstProto";
+var strUseBaseInst = 'useBaseInst';
+var strSetInstFuncs = 'setInstFuncs';
+var Obj = Object;
+var _objGetPrototypeOf = Obj["getPrototypeOf"];
+var _objGetOwnProps = Obj["getOwnPropertyNames"];
+var _gbl = getGlobal();
+var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
+    o: (_a$2 = {},
+        _a$2[strSetInstFuncs] = true,
+        _a$2[strUseBaseInst] = true,
+        _a$2),
+    n: 1000
+});
+function _isObjectOrArrayPrototype(target) {
+    return target && (target === Obj[Prototype] || target === Array[Prototype]);
 }
-function getNavigator() {
-    (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst(NAVIGATOR));
-    return _cachedNavigator.v;
+function _isObjectArrayOrFunctionPrototype(target) {
+    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
 }
-var _symbol;
-var _symbolFor;
-var _symbolKeyFor;
-function _getSymbolValue(name) {
-    return _lazySafeGet(function () {
-        return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
-    }, UNDEF_VALUE);
+function _getObjProto(target) {
+    var newProto;
+    if (target) {
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
+        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+        newProto = target[DynProtoBaseProto] || curProto;
+        if (!objHasOwnProperty(target, DynProtoBaseProto)) {
+            delete target[DynProtoCurrent];
+            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+            target[DynProtoCurrent] = curProto;
+        }
+    }
+    return newProto;
 }
-function getSymbol() {
-    var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
-    resetCache && (_symbol = _lazySafeGetInst(SYMBOL));
-    (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
-    (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
-    return _symbol.v;
+function _forEachProp(target, func) {
+    var props = [];
+    if (_objGetOwnProps) {
+        props = _objGetOwnProps(target);
+    }
+    else {
+        for (var name_1 in target) {
+            if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                props.push(name_1);
+            }
+        }
+    }
+    if (props && props.length > 0) {
+        for (var lp = 0; lp < props.length; lp++) {
+            func(props[lp]);
+        }
+    }
 }
-function newSymbol(description, noPoly) {
-    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
-    return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
+function _isDynamicCandidate(target, funcName, skipOwn) {
+    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
 }
-function symbolFor(key) {
-    (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
-    return (_symbolFor.v || polySymbolFor)(key);
+function _throwTypeError(message) {
+    throwTypeError("DynamicProto: " + message);
 }
-function isIterator(value) {
-    return !!value && isFunction(value.next);
+function _getInstanceFuncs(thisTarget) {
+    var instFuncs = {};
+    _forEachProp(thisTarget, function (name) {
+        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+            instFuncs[name] = thisTarget[name];
+        }
+    });
+    return instFuncs;
 }
-function arrAppend(target, elms) {
-    if (!isUndefined(elms) && target) {
-        if (isArray(elms)) {
-            target.push.apply(target, elms);
+function _hasVisited(values, value) {
+    for (var lp = values.length - 1; lp >= 0; lp--) {
+        if (values[lp] === value) {
+            return true;
         }
-        else if (isIterator(elms)) {
-            var value = elms.next();
-            while (!value[DONE]) {
-                target.push(value[VALUE]);
-                value = elms.next();
+    }
+    return false;
+}
+function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
+    function _instFuncProxy(target, funcHost, funcName) {
+        var theFunc = funcHost[funcName];
+        if (theFunc[DynProxyTag] && useBaseInst) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
             }
         }
-        else {
-            target.push(elms);
-        }
+        return function () {
+            return theFunc.apply(target, arguments);
+        };
     }
-    return target;
+    var baseFuncs = {};
+    _forEachProp(instFuncs, function (name) {
+        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+    });
+    var baseProto = _getObjProto(classProto);
+    var visited = [];
+    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+        _forEachProp(baseProto, function (name) {
+            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
+                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+            }
+        });
+        visited.push(baseProto);
+        baseProto = _getObjProto(baseProto);
+    }
+    return baseFuncs;
 }
-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(thisArg || theArray, theArray[idx], idx, theArray) === -1) {
+function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+    var instFunc = null;
+    if (target && objHasOwnProperty(proto, DynClassName)) {
+        var instFuncTable = target[DynInstFuncTable] || {};
+        instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+        if (!instFunc) {
+            _throwTypeError("Missing [" + funcName + "] " + strFunction);
+        }
+        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+            var canAddInst = !objHasOwnProperty(target, funcName);
+            var objProto = _getObjProto(target);
+            var visited = [];
+            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                var protoFunc = objProto[funcName];
+                if (protoFunc) {
+                    canAddInst = (protoFunc === currentDynProtoProxy);
                     break;
                 }
+                visited.push(objProto);
+                objProto = _getObjProto(objProto);
+            }
+            try {
+                if (canAddInst) {
+                    target[funcName] = instFunc;
+                }
+                instFunc[DynInstChkTag] = 1;
+            }
+            catch (e) {
+                instFuncTable[DynAllowInstChkTag] = false;
             }
         }
     }
+    return instFunc;
 }
-var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
-function objSetPrototypeOf(obj, proto) {
-    var fn = ObjClass["setPrototypeOf"] ||
-        ({ __proto__: [] } instanceof Array && function (d, b) {
-            d.__proto__ = b;
-        }) ||
-        function (d, b) {
-            objForEachKey(b, function (key, value) { return d[key] = value; });
-        };
-    return fn(obj, proto);
-}
-function _createCustomError(name, d, baseClass) {
-    objSetPrototypeOf(d, baseClass);
-    function __() {
-        this.constructor = d;
-        this[NAME] = name;
-    }
-    __[PROTOTYPE] = baseClass[PROTOTYPE];
-    d[PROTOTYPE] = new __();
-    return d;
-}
-var _safeSetName = function (baseClass, name) {
-    try {
-        baseClass[PROTOTYPE][NAME] = name;
+function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+    var protoFunc = proto[funcName];
+    if (protoFunc === currentDynProtoProxy) {
+        protoFunc = _getObjProto(proto)[funcName];
     }
-    catch (e) {
+    if (typeof protoFunc !== strFunction) {
+        _throwTypeError("[" + funcName + "] is not a " + strFunction);
     }
-};
-function createCustomError(name, constructCb) {
-    var baseClass = Error;
-    var orgName = baseClass[PROTOTYPE][NAME];
-    var customError = _createCustomError(name, function () {
-        var _this = this;
-        try {
-            _safeSetName(baseClass, name);
-            _this = baseClass.apply(_this, arguments) || _this;
-            _this[NAME] = name;
-            constructCb && constructCb(_this, arguments);
-        }
-        finally {
-            _safeSetName(baseClass, orgName);
-        }
-        return _this;
-    }, baseClass);
-    return customError;
-}
-function utcNow() {
-    return (Date.now || polyUtcNow)();
-}
-function polyUtcNow() {
-    return new Date().getTime();
+    return protoFunc;
 }
-var _fnToString;
-var _objCtrFnString;
-var _gblWindow;
-function isPlainObject(value) {
-    if (!value || typeof value !== OBJECT) {
-        return false;
-    }
-    if (!_gblWindow) {
-        _gblWindow = hasWindow() ? getWindow() : true;
+function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+    function _createDynamicPrototype(proto, funcName) {
+        var dynProtoProxy = function () {
+            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+            return instFunc.apply(this, arguments);
+        };
+        dynProtoProxy[DynProxyTag] = 1;
+        return dynProtoProxy;
     }
-    var result = false;
-    if (value !== _gblWindow) {
-        if (!_objCtrFnString) {
-            _fnToString = Function[PROTOTYPE].toString;
-            _objCtrFnString = _fnToString.call(ObjClass);
+    if (!_isObjectOrArrayPrototype(proto)) {
+        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+        var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+        if (instFuncTable[DynAllowInstChkTag] !== false) {
+            instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
         }
-        try {
-            var proto = objGetPrototypeOf(value);
-            result = !proto;
-            if (!result) {
-                if (objHasOwnProperty(proto, CONSTRUCTOR)) {
-                    proto = proto[CONSTRUCTOR];
+        _forEachProp(target, function (name) {
+            if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                instFuncs_1[name] = target[name];
+                delete target[name];
+                if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                    proto[name] = _createDynamicPrototype(proto, name);
                 }
-                result = proto && typeof proto === FUNCTION && _fnToString.call(proto) === _objCtrFnString;
             }
-        }
-        catch (ex) {
-        }
+        });
     }
-    return result;
-}
-var _perf;
-function getPerformance() {
-    (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
-    return _perf.v;
 }
-var strIndexOf = _unwrapFunction(INDEX_OF);
-var REF = "ref";
-var UNREF = "un" + REF;
-var HAS_REF = "hasRef";
-var ENABLED = "enabled";
-function _createTimerHandler(startTimer, refreshFn, cancelFn) {
-    var _a;
-    var ref = true;
-    var timerId = startTimer ? refreshFn(null) : null;
-    var theTimerHandler;
-    var _unref = function () {
-        ref = false;
-        timerId && timerId[UNREF] && timerId[UNREF]();
-        return theTimerHandler;
-    };
-    var _ref = function () {
-        ref = true;
-        timerId && timerId[REF] && timerId[REF]();
-        return theTimerHandler;
-    };
-    var _hasRef = function () {
-        if (timerId && timerId[HAS_REF]) {
-            return timerId[HAS_REF]();
-        }
-        return ref;
-    };
-    var _refresh = function () {
-        timerId = refreshFn(timerId);
-        if (!ref) {
-            _unref();
-        }
-        return theTimerHandler;
-    };
-    var _cancel = function () {
-        timerId && cancelFn(timerId);
-        timerId = null;
-    };
-    var _setEnabled = function (value) {
-        !value && timerId && _cancel();
-        value && !timerId && _refresh();
-    };
-    theTimerHandler = (_a = {
-            cancel: _cancel,
-            refresh: _refresh
-        },
-        _a[HAS_REF] = _hasRef,
-        _a[REF] = _ref,
-        _a[UNREF] = _unref,
-        _a[ENABLED] = false,
-        _a);
-    objDefineProp(theTimerHandler, ENABLED, {
-        get: function () { return !!timerId; },
-        set: _setEnabled
-    });
-    return {
-        h: theTimerHandler,
-        dn: function () {
-            timerId = null;
-        }
-    };
-}
-function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
-    var isArr = isArray(overrideFn);
-    var len = isArr ? overrideFn.length : 0;
-    var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;
-    var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;
-    var timerFn = theArgs[0];
-    theArgs[0] = function () {
-        handler.dn();
-        timerFn.apply(self, arguments);
-    };
-    var handler = _createTimerHandler(startTimer, function (timerId) {
-        if (timerId) {
-            if (timerId.refresh) {
-                timerId.refresh();
-                return timerId;
+function _checkPrototype(classProto, thisTarget) {
+    if (_objGetPrototypeOf) {
+        var visited = [];
+        var thisProto = _getObjProto(thisTarget);
+        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+            if (thisProto === classProto) {
+                return true;
             }
-            clearFn.call(self, timerId);
+            visited.push(thisProto);
+            thisProto = _getObjProto(thisProto);
         }
-        return setFn.apply(self, theArgs);
-    }, function (timerId) {
-        clearFn.call(self, timerId);
-    });
-    return handler.h;
+        return false;
+    }
+    return true;
 }
-function scheduleTimeout(callback, timeout) {
-    return _createTimeoutWith(this, true, UNDEF_VALUE, _extractArgs(arguments, 0));
+function _getObjName(target, unknownValue) {
+    if (objHasOwnProperty(target, Prototype)) {
+        return target.name || unknownValue || UnknownValue;
+    }
+    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+}
+function dynamicProto(theClass, target, delegateFunc, options) {
+    if (!objHasOwnProperty(theClass, Prototype)) {
+        _throwTypeError("theClass is an invalid class definition.");
+    }
+    var classProto = theClass[Prototype];
+    if (!_checkPrototype(classProto, target)) {
+        _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+    }
+    var className = null;
+    if (objHasOwnProperty(classProto, DynClassName)) {
+        className = classProto[DynClassName];
+    }
+    else {
+        className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+        _gblInst.n++;
+        classProto[DynClassName] = className;
+    }
+    var perfOptions = dynamicProto[DynProtoDefaultOptions];
+    var useBaseInst = !!perfOptions[strUseBaseInst];
+    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+        useBaseInst = !!options[strUseBaseInst];
+    }
+    var instFuncs = _getInstanceFuncs(target);
+    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+    delegateFunc(target, baseFuncs);
+    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
+    if (setInstanceFunc && options) {
+        setInstanceFunc = !!options[strSetInstFuncs];
+    }
+    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
 }
+dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
 var _DYN_TO_LOWER_CASE = "toLowerCase";
 var _DYN_LENGTH$1 = "length";
@@ -964,7 +986,7 @@ function throwAggregationError(message, sourceErrors) {
     arrForEach(sourceErrors, function (srcError, idx) {
         theMessage += "\n".concat(idx, " > ").concat(dumpObj(srcError));
     });
-    throw new aggregationErrorType(message, sourceErrors || []);
+    throw new aggregationErrorType(theMessage, sourceErrors || []);
 }
 
 var UNDEFINED_VALUE = undefined;
@@ -1136,15 +1158,17 @@ function isIE() {
 
 var UInt32Mask = 0x100000000;
 var MaxUInt32 = 0xffffffff;
+var SEED1 = 123456789;
+var SEED2 = 987654321;
 var _mwcSeeded = false;
-var _mwcW = 123456789;
-var _mwcZ = 987654321;
+var _mwcW = SEED1;
+var _mwcZ = SEED2;
 function _mwcSeed(seedValue) {
     if (seedValue < 0) {
         seedValue >>>= 0;
     }
-    _mwcW = (123456789 + seedValue) & MaxUInt32;
-    _mwcZ = (987654321 - seedValue) & MaxUInt32;
+    _mwcW = (SEED1 + seedValue) & MaxUInt32;
+    _mwcZ = (SEED2 - seedValue) & MaxUInt32;
     _mwcSeeded = true;
 }
 function _autoSeedMwc() {
@@ -1202,7 +1226,7 @@ function newId(maxLength) {
     return result;
 }
 
-var version = "3.0.0-beta.2303-11";
+var version = "3.0.0-nightly3.2304-28";
 var instanceName = "." + newId(6);
 var _dataUid = 0;
 function _canAcceptData(target) {
@@ -3600,7 +3624,7 @@ var DomContentHandler = /** @class */ (function () {
                     default:
                         contentName = element.value || element[_DYN_NAME ] || element.alt || element.innerText || element.id;
                 }
-                return contentName.substring(0, MAX_CONTENTNAME_LENGTH);
+                return strSubstring(contentName, 0, MAX_CONTENTNAME_LENGTH);
             }
             function _isTracked(element, dataTag, aiBlobAttributeTag) {
                 var attrs = element[_DYN_ATTRIBUTES ];
@@ -3795,7 +3819,7 @@ var ClickAnalyticsPlugin = /** @class */ (function (_super) {
         });
         return _this;
     }
-    ClickAnalyticsPlugin.Version = "3.0.0-beta.2303-11";
+    ClickAnalyticsPlugin.Version = "3.0.0-nightly3.2304-28";
     return ClickAnalyticsPlugin;
 }(BaseTelemetryPlugin));