@microsoft/applicationinsights-analytics-js 3.0.0-beta.2303-10 → 3.0.0-beta.2304-07

package/browser/{applicationinsights-analytics-js.js → es5/applicationinsights-analytics-js.js}

@@ -1,997 +1,1022 @@
 /*!
- * Application Insights JavaScript SDK - Web Analytics, 3.0.0-beta.2303-10
+ * Application Insights JavaScript SDK - Web Analytics, 3.0.0-beta.2304-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Microsoft = global.Microsoft || {}, global.Microsoft.ApplicationInsights = global.Microsoft.ApplicationInsights || {})));
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Microsoft = global.Microsoft || {}, global.Microsoft.ApplicationInsights3 = global.Microsoft.ApplicationInsights3 || {})));
 })(this, (function (exports) { 'use strict';
 
     var strShimFunction = "function";
     var strShimObject = "object";
     var strShimUndefined = "undefined";
     var strShimPrototype = "prototype";
-    var strShimHasOwnProperty = "hasOwnProperty";
     var ObjClass$1 = Object;
     var ObjProto$1 = ObjClass$1[strShimPrototype];
-    var ObjAssign = ObjClass$1["assign"];
-    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 MathCls = Math;
+    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");
+    function isTruthy(value) {
+        return !(!value || _safeGet(function () { return !(value && (0 + value)); }, !value));
     }
 
-    (getGlobal$1() || {})["Symbol"];
-    (getGlobal$1() || {})["Reflect"];
-    var __objAssignFnImpl = function (t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) {
-                if (ObjProto$1[strShimHasOwnProperty].call(s, p)) {
-                    t[p] = s[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 t;
-    };
-    var __assignFn = ObjAssign || __objAssignFnImpl;
-    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];
-                    }
-                }
-            };
-        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");
+    }
+
+    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; };
+    var objAssign = ObjClass["assign"];
+    function objKeys(value) {
+        if (!isObject(value) || value === null) {
+            throwTypeError("objKeys called on non-object");
         }
-        extendStaticsFn(d, b);
-        function __() {
-            this.constructor = d;
+        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$4;
-    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 createEnum(values) {
+        return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
+    }
+    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$4 = {},
-            _a$4[strSetInstFuncs] = true,
-            _a$4[strUseBaseInst] = true,
-            _a$4),
-        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$1(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 _getInstanceFuncs(thisTarget) {
-        var instFuncs = {};
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
+
+    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);
             }
-        });
-        return instFuncs;
+            throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+        };
     }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
-                return true;
-            }
+
+    var mathMax = MathCls.max;
+
+    var strSlice = _unwrapFunction(SLICE, StrProto);
+
+    var strSubstring = _unwrapFunction("substring", StrProto);
+    var strSubstr = _unwrapFunction("substr", StrProto, polyStrSubstr);
+    function polyStrSubstr(value, start, length) {
+        if (isNullOrUndefined(value)) {
+            throwTypeError("'polyStrSubstr called with invalid " + dumpObj(value));
         }
-        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;
-                }
-            }
-            return function () {
-                return theFunc.apply(target, arguments);
-            };
+        if (length < 0) {
+            return EMPTY;
         }
-        var baseFuncs = {};
-        _forEachProp(instFuncs, function (name) {
-            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
-        });
-        var baseProto = _getObjProto$1(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$1(baseProto);
+        start = start || 0;
+        if (start < 0) {
+            start = mathMax(start + value[LENGTH], 0);
         }
-        return baseFuncs;
-    }
-    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$1(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$1(objProto);
-                }
-                try {
-                    if (canAddInst) {
-                        target[funcName] = instFunc;
-                    }
-                    instFunc[DynInstChkTag] = 1;
-                }
-                catch (e) {
-                    instFuncTable[DynAllowInstChkTag] = false;
-                }
-            }
+        if (isUndefined(length)) {
+            return strSlice(value, start);
         }
-        return instFunc;
+        return strSlice(value, start, start + length);
     }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto$1(proto)[funcName];
+    function strLeft(value, count) {
+        return strSubstring(value, 0, count);
+    }
+
+    var _polySymbols;
+    function _globalSymbolRegistry() {
+        if (!_polySymbols) {
+            var gblCfg = _getGlobalConfig();
+            _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
         }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        return _polySymbols;
+    }
+    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 protoFunc;
+        return registry.k[key];
     }
-    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;
+    function polyGetKnownSymbol(name) {
+        var result;
+        var knownName = _wellKnownSymbolMap[name];
+        if (knownName) {
+            result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
         }
-        if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
-            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
-            if (instFuncTable[DynAllowInstChkTag] !== false) {
-                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+        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;
+                };
             }
-            _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);
-                    }
-                }
-            });
         }
+        objForEachKey(value, function (key, value) {
+            prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
+        });
+        return prop;
     }
-    function _checkPrototype(classProto, thisTarget) {
-        if (_objGetPrototypeOf) {
-            var visited = [];
-            var thisProto = _getObjProto$1(thisTarget);
-            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-                if (thisProto === classProto) {
-                    return true;
+    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;
+                    }
                 }
-                visited.push(thisProto);
-                thisProto = _getObjProto$1(thisProto);
+                if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                    lazyValue.b = _globalLazyTestHooks.lzy;
+                }
+                return result;
             }
-            return false;
-        }
-        return true;
+        });
+        return lazyValue;
     }
-    function _getObjName(target, unknownValue) {
-        if (_hasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
-        }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+
+    function _lazySafeGet(cb, defValue) {
+        return getLazy(function () { return _safeGet(cb, defValue); });
     }
-    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 WINDOW = "window";
+    var _cachedGlobal;
+    var _cachedWindow;
+    var _cachedDocument;
+    var _cachedNavigator;
+    var _cachedHistory;
+    var _isWebWorker;
+    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];
         }
-        var perfOptions = dynamicProto[DynProtoDefaultOptions];
-        var useBaseInst = !!perfOptions[strUseBaseInst];
-        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-            useBaseInst = !!options[strUseBaseInst];
+        if (name === WINDOW && _cachedWindow) {
+            return _cachedWindow.v;
         }
-        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);
+        return null;
     }
-    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 MathCls = Math;
-    var ArrCls = Array;
-    var ArrProto = ArrCls[PROTOTYPE];
-    function _safeGet(cb, defValue) {
-        var result = defValue;
-        try {
-            result = cb();
-        }
-        catch (e) {
-        }
-        return result;
+    function getDocument() {
+        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst("document"));
+        return _cachedDocument.v;
     }
-    function _createIs(theType) {
-        return function (value) {
-            return typeof value === theType;
-        };
+    function hasWindow() {
+        return !!getWindow();
     }
-    function _createObjIs(theName) {
-        var theType = "[object " + theName + "]";
-        return function (value) {
-            return !!(value && objToString(value) === theType);
-        };
+    function getWindow() {
+        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
+        return _cachedWindow.v;
     }
-    function objToString(value) {
-        return ObjProto.toString.call(value);
+    function getNavigator() {
+        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst("navigator"));
+        return _cachedNavigator.v;
     }
-    function isUndefined(value) {
-        return typeof value === UNDEFINED || value === UNDEFINED;
+    function hasHistory() {
+        return !!getHistory();
     }
-    function isNullOrUndefined(value) {
-        return value === null || isUndefined(value);
+    function getHistory() {
+        (!_cachedHistory || (_globalLazyTestHooks.lzy && !_cachedHistory.b)) && (_cachedHistory = _lazySafeGetInst("history"));
+        return _cachedHistory.v;
     }
-    function isDefined(arg) {
-        return !!arg || arg !== UNDEF_VALUE;
+    function isWebWorker() {
+        !_isWebWorker && (_isWebWorker = _lazySafeGet(function () { return !!(self && self instanceof WorkerGlobalScope); }, false));
+        return _isWebWorker.v;
     }
-    var isString = _createIs(STRING);
-    var isFunction = _createIs(FUNCTION);
-    function isObject(value) {
-        if (!value && isNullOrUndefined(value)) {
-            return false;
-        }
-        return !!value && typeof value === OBJECT;
+
+    var _symbol;
+    var _symbolFor;
+    var _symbolKeyFor;
+    function _getSymbolValue(name) {
+        return _lazySafeGet(function () {
+            return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+        }, UNDEF_VALUE);
     }
-    var isArray = ArrCls.isArray;
-    var isNumber = _createIs(NUMBER);
-    var isBoolean = _createIs(BOOLEAN);
-    var isError = _createObjIs("Error");
-    function isTruthy(value) {
-        return !(!value || _safeGet(function () { return !(value && (0 + value)); }, !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;
     }
-    var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
-    function objHasOwnProperty(obj, prop) {
-        return obj && ObjProto[HAS_OWN_PROPERTY].call(obj, prop);
+    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);
     }
-    var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
-    function polyObjHasOwn(obj, prop) {
-        return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+    function newSymbol(description, noPoly) {
+        (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
     }
-    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;
+    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;
+            }
+            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);
+                }
+                catch (e) {
+                    iter.throw && iter.throw(e);
                 }
             }
         }
     }
-    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 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);
+            }
+        }
+        return target;
     }
-    function throwError(message) {
-        throw new Error(message);
+
+    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;
+                    }
+                }
+            }
+        }
     }
-    function throwTypeError(message) {
-        throw new TypeError(message);
+
+    var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
+
+    var arrMap = _unwrapFunction("map", 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);
     }
-    var _objFreeze = ObjClass["freeze"];
-    var _doNothing = function (value) { return value; };
-    function objKeys(value) {
-        if (!isObject(value) || value === null) {
-            throwTypeError("objKeys called on non-object");
+
+    function _createCustomError(name, d, baseClass) {
+        objSetPrototypeOf(d, baseClass);
+        function __() {
+            this.constructor = d;
+            this[NAME] = name;
         }
-        return ObjClass.keys(value);
+        __[PROTOTYPE] = baseClass[PROTOTYPE];
+        d[PROTOTYPE] = new __();
+        return d;
     }
-    function objDeepFreeze(value) {
-        if (_objFreeze) {
-            objForEachKey(value, function (key, value) {
-                if (isArray(value) || isObject(value)) {
-                    _objFreeze(value);
-                }
-            });
+    var _safeSetName = function (baseClass, name) {
+        try {
+            baseClass[PROTOTYPE][NAME] = name;
         }
-        return objFreeze(value);
+        catch (e) {
+        }
+    };
+    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;
     }
-    var objFreeze = _objFreeze || _doNothing;
-    var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _doNothing;
-    function createEnum(values) {
-        return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
+
+    function utcNow() {
+        return (Date.now || polyUtcNow)();
     }
-    function createEnumKeyMap(values) {
-        return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+    function polyUtcNow() {
+        return new Date().getTime();
     }
-    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;
+
+    function _createTrimFn(exp) {
+        return function _doTrim(value) {
+            if (isNullOrUndefined(value)) {
+                throwTypeError("strTrim called [" + dumpObj(value) + "]");
+            }
+            if (value && value.replace) {
+                value = value.replace(exp, EMPTY);
+            }
+            return value;
+        };
+    }
+    var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
+
+    var strTrim = _unwrapFunction("trim", StrProto, polyStrTrim);
+
+    var _fnToString;
+    var _objCtrFnString;
+    var _gblWindow;
+    function isPlainObject(value) {
+        if (!value || typeof value !== OBJECT) {
+            return false;
         }
-        if (!result && typeof window !== UNDEFINED) {
-            result = window;
+        if (!_gblWindow) {
+            _gblWindow = hasWindow() ? getWindow() : true;
         }
-        if (!result && typeof global !== UNDEFINED) {
-            result = global;
+        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 _getGlobalConfig() {
-        if (!_globalCfg) {
-            var gbl = _getGlobalValue() || {};
-            _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
+
+    var _perf;
+    function getPerformance() {
+        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
+        return _perf.v;
+    }
+
+    var _objCreate = ObjClass["create"];
+    var objCreate = _objCreate || polyObjCreate;
+    function polyObjCreate(obj) {
+        if (!obj) {
+            return {};
         }
-        return _globalCfg;
+        var type = typeof obj;
+        if (type !== OBJECT && type !== FUNCTION) {
+            throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
+        }
+        function tempFunc() { }
+        tempFunc[PROTOTYPE] = obj;
+        return new tempFunc();
     }
-    function dumpObj(object, format) {
-        var propertyValueDump = "";
-        if (isError(object)) {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+
+    var strEndsWith = _unwrapFunction("endsWith", StrProto, polyStrEndsWith);
+    function polyStrEndsWith(value, searchString, length) {
+        if (!isString(value)) {
+            throwTypeError("'" + dumpObj(value) + "' is not a string");
         }
-        else {
-            try {
-                propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+        var searchValue = isString(searchString) ? searchString : asString(searchString);
+        var chkLen = searchValue[LENGTH];
+        var len = value[LENGTH];
+        var end = !isUndefined(length) && length < len ? length : len;
+        return strSubstring(value, end - chkLen, end) === searchValue;
+    }
+
+    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]();
             }
-            catch (e) {
-                propertyValueDump = " - " + dumpObj(e, format);
+            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;
+                }
+                clearFn.call(self, timerId);
+            }
+            return setFn.apply(self, theArgs);
+        }, function (timerId) {
+            clearFn.call(self, timerId);
+        });
+        return handler.h;
+    }
+    function scheduleTimeout(callback, timeout) {
+        return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
+    }
+
+    (getGlobal() || {})["Symbol"];
+    (getGlobal() || {})["Reflect"];
+    var strHasOwnProperty = "hasOwnProperty";
+    var __objAssignFnImpl = function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) {
+                if (ObjProto$1[strHasOwnProperty].call(s, p)) {
+                    t[p] = s[p];
+                }
             }
         }
-        return objToString(object) + ": " + propertyValueDump;
+        return t;
+    };
+    var __assignFn = objAssign || __objAssignFnImpl;
+    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");
+        }
+        extendStaticsFn(d, b);
+        function __() {
+            this.constructor = d;
+        }
+        d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
     }
-    function _extractArgs(args, startAt) {
-        var theArgs = [];
-        for (var lp = startAt; lp < args[LENGTH]; lp++) {
-            theArgs[lp - startAt] = args[lp];
+
+    var _a$3;
+    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$3 = {},
+            _a$3[strSetInstFuncs] = true,
+            _a$3[strUseBaseInst] = true,
+            _a$3),
+        n: 1000
+    });
+    function _isObjectOrArrayPrototype(target) {
+        return target && (target === Obj[Prototype] || target === Array[Prototype]);
+    }
+    function _isObjectArrayOrFunctionPrototype(target) {
+        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+    }
+    function _getObjProto$1(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 _forEachProp(target, func) {
+        var props = [];
+        if (_objGetOwnProps) {
+            props = _objGetOwnProps(target);
         }
-        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);
+        else {
+            for (var name_1 in target) {
+                if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                    props.push(name_1);
                 }
             }
-            throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
-        };
-    }
-    var mathMax = MathCls.max;
-    var strSlice = _unwrapFunction("slice");
-    var SUB_STR = "substr";
-    var strSubstring = _unwrapFunction("substring");
-    var strSubstr = _unwrapFunction(SUB_STR, UNDEF_VALUE, polyStrSubstr);
-    function polyStrSubstr(value, start, length) {
-        if (isNullOrUndefined(value)) {
-            throwTypeError("'polyStrSubstr called with invalid " + dumpObj(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);
+        if (props && props.length > 0) {
+            for (var lp = 0; lp < props.length; lp++) {
+                func(props[lp]);
+            }
         }
-        return strSlice(value, start, start + length);
     }
-    function strLeft(value, count) {
-        return strSubstring(value, 0, count);
+    function _isDynamicCandidate(target, funcName, skipOwn) {
+        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
     }
-    var _polySymbols;
-    function _globalSymbolRegistry() {
-        if (!_polySymbols) {
-            var gblCfg = _getGlobalConfig();
-            _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
-        }
-        return _polySymbols;
+    function _throwTypeError(message) {
+        throwTypeError("DynamicProto: " + message);
     }
-    function polyNewSymbol(description) {
-        var theSymbol = {
-            description: asString(description),
-            toString: function () { return SYMBOL + "(" + description + ")"; }
-        };
-        theSymbol[POLYFILL_TAG] = true;
-        return theSymbol;
+    function _getInstanceFuncs(thisTarget) {
+        var instFuncs = {};
+        _forEachProp(thisTarget, function (name) {
+            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+                instFuncs[name] = thisTarget[name];
+            }
+        });
+        return instFuncs;
     }
-    function polySymbolFor(key) {
-        var registry = _globalSymbolRegistry();
-        if (!objHasOwn(registry, key)) {
-            var newSymbol = polyNewSymbol(key);
-            registry.k[key] = newSymbol;
-            registry.s[newSymbol] = asString(key);
+    function _hasVisited(values, value) {
+        for (var lp = values.length - 1; lp >= 0; lp--) {
+            if (values[lp] === value) {
+                return true;
+            }
         }
-        return registry.k[key];
+        return false;
     }
-    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;
+    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;
+                }
+            }
+            return function () {
+                return theFunc.apply(target, arguments);
+            };
+        }
+        var baseFuncs = {};
+        _forEachProp(instFuncs, function (name) {
+            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
         });
-        return prop;
-    }
-    var objDefineProp = ObjClass["defineProperty"];
-    function objDefine(target, key, propDesc) {
-        return objDefineProp(target, key, _createProp(propDesc));
+        var baseProto = _getObjProto$1(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$1(baseProto);
+        }
+        return baseFuncs;
     }
-    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;
+    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$1(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$1(objProto);
+                }
+                try {
+                    if (canAddInst) {
+                        target[funcName] = instFunc;
                     }
+                    instFunc[DynInstChkTag] = 1;
                 }
-                if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
-                    lazyValue.b = _globalLazyTestHooks.lzy;
+                catch (e) {
+                    instFuncTable[DynAllowInstChkTag] = false;
                 }
-                return result;
             }
-        });
-        return lazyValue;
-    }
-    function _lazySafeGet(cb, defValue) {
-        return getLazy(function () { return _safeGet(cb, defValue); });
-    }
-    var DOCUMENT = "document";
-    var HISTORY = "history";
-    var NAVIGATOR = "navigator";
-    var WINDOW = "window";
-    var _cachedGlobal;
-    var _cachedWindow;
-    var _cachedDocument;
-    var _cachedNavigator;
-    var _cachedHistory;
-    var _isWebWorker;
-    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;
+        }
+        return instFunc;
     }
-    function getInst(name, useCached) {
-        var gbl = getGlobal(useCached);
-        if (gbl && gbl[name]) {
-            return gbl[name];
+    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+        var protoFunc = proto[funcName];
+        if (protoFunc === currentDynProtoProxy) {
+            protoFunc = _getObjProto$1(proto)[funcName];
         }
-        if (name === WINDOW && _cachedWindow) {
-            return _cachedWindow.v;
+        if (typeof protoFunc !== strFunction) {
+            _throwTypeError("[" + funcName + "] is not a " + strFunction);
         }
-        return null;
-    }
-    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;
-    }
-    function hasHistory() {
-        return !!getHistory();
-    }
-    function getHistory() {
-        (!_cachedHistory || (_globalLazyTestHooks.lzy && !_cachedHistory.b)) && (_cachedHistory = _lazySafeGetInst(HISTORY));
-        return _cachedHistory.v;
-    }
-    function isWebWorker() {
-        !_isWebWorker && (_isWebWorker = _lazySafeGet(function () { return !!(self && self instanceof WorkerGlobalScope); }, false));
-        return _isWebWorker.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 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);
+        return protoFunc;
     }
-    function arrAppend(target, elms) {
-        if (!isUndefined(elms) && target) {
-            if (isArray(elms)) {
-                target.push.apply(target, elms);
+    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;
             }
-            else if (isIterator(elms)) {
-                var value = elms.next();
-                while (!value[DONE]) {
-                    target.push(value[VALUE]);
-                    value = elms.next();
+            _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);
+                    }
                 }
-            }
-            else {
-                target.push(elms);
-            }
+            });
         }
-        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;
-                    }
+    function _checkPrototype(classProto, thisTarget) {
+        if (_objGetPrototypeOf) {
+            var visited = [];
+            var thisProto = _getObjProto$1(thisTarget);
+            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+                if (thisProto === classProto) {
+                    return true;
                 }
+                visited.push(thisProto);
+                thisProto = _getObjProto$1(thisProto);
             }
+            return false;
         }
+        return true;
     }
-    var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
-    var arrMap = _unwrapFunction("map", 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;
+    function _getObjName(target, unknownValue) {
+        if (objHasOwnProperty(target, Prototype)) {
+            return target.name || unknownValue || UnknownValue;
         }
-        __[PROTOTYPE] = baseClass[PROTOTYPE];
-        d[PROTOTYPE] = new __();
-        return d;
+        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
     }
-    var _safeSetName = function (baseClass, name) {
-        try {
-            baseClass[PROTOTYPE][NAME] = name;
+    function dynamicProto(theClass, target, delegateFunc, options) {
+        if (!objHasOwnProperty(theClass, Prototype)) {
+            _throwTypeError("theClass is an invalid class definition.");
         }
-        catch (e) {
+        var classProto = theClass[Prototype];
+        if (!_checkPrototype(classProto, target)) {
+            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
         }
-    };
-    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();
-    }
-    var _fnToString;
-    var _objCtrFnString;
-    var _gblWindow;
-    function isPlainObject(value) {
-        if (!value || typeof value !== OBJECT) {
-            return false;
+        var className = null;
+        if (objHasOwnProperty(classProto, DynClassName)) {
+            className = classProto[DynClassName];
         }
-        if (!_gblWindow) {
-            _gblWindow = hasWindow() ? getWindow() : true;
+        else {
+            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+            _gblInst.n++;
+            classProto[DynClassName] = className;
         }
-        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) {
-            }
+        var perfOptions = dynamicProto[DynProtoDefaultOptions];
+        var useBaseInst = !!perfOptions[strUseBaseInst];
+        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+            useBaseInst = !!options[strUseBaseInst];
         }
-        return result;
-    }
-    var _perf;
-    function getPerformance() {
-        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
-        return _perf.v;
-    }
-    var ENDS_WITH = "endsWith";
-    var strEndsWith = _unwrapFunction(ENDS_WITH, UNDEF_VALUE, polyStrEndsWith);
-    function polyStrEndsWith(value, searchString, length) {
-        if (!isString(value)) {
-            throwTypeError("'" + dumpObj(value) + "' is not a string");
+        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];
         }
-        var searchValue = isString(searchString) ? searchString : asString(searchString);
-        var chkLen = searchValue[LENGTH];
-        var len = value[LENGTH];
-        var end = !isUndefined(length) && length < len ? length : len;
-        return strSubstring(value, end - chkLen, end) === searchValue;
-    }
-    var strIndexOf = _unwrapFunction(INDEX_OF);
-    function _createTrimFn(exp) {
-        return function _doTrim(value) {
-            if (isNullOrUndefined(value)) {
-                throwTypeError("strTrim called [" + dumpObj(value) + "]");
-            }
-            if (value && value.replace) {
-                value = value.replace(exp, "");
-            }
-            return value;
-        };
-    }
-    var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
-    var TRIM = "trim";
-    var strTrim = _unwrapFunction(TRIM, UNDEF_VALUE, polyStrTrim);
-    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;
-                }
-                clearFn.call(self, timerId);
-            }
-            return setFn.apply(self, theArgs);
-        }, function (timerId) {
-            clearFn.call(self, timerId);
-        });
-        return handler.h;
-    }
-    function scheduleTimeout(callback, timeout) {
-        return _createTimeoutWith(this, true, UNDEF_VALUE, _extractArgs(arguments, 0));
+        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
     }
+    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
     var createEnumStyle = createEnum;
 
@@ -1030,7 +1055,6 @@
     var _DYN_SPLIT$1 = "split";
     var _DYN_NODE_TYPE = "nodeType";
     var _DYN_REPLACE = "replace";
-    var _DYN_ENABLE_DEBUG_EXCEPTI5 = "enableDebugExceptions";
     var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
     var _DYN_TYPE = "type";
     var _DYN_HANDLER = "handler";
@@ -1052,7 +1076,7 @@
         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;
@@ -1198,15 +1222,17 @@
 
     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() {
@@ -1264,7 +1290,7 @@
         return result;
     }
 
-    var version = "3.0.0-beta.2303-10";
+    var version = "3.0.0-beta.2304-07";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -1786,8 +1812,19 @@
         function _watch(configHandler) {
             return _createAndUseHandler(theState, configHandler);
         }
-        function _block(configHandler) {
-            theState.use(null, configHandler);
+        function _block(configHandler, allowUpdate) {
+            theState.use(null, function (details) {
+                var prevUpd = theState.upd;
+                try {
+                    if (!isUndefined(allowUpdate)) {
+                        theState.upd = allowUpdate;
+                    }
+                    configHandler(details);
+                }
+                finally {
+                    theState.upd = prevUpd;
+                }
+            });
         }
         function _ref(target, name) {
             return _setDynamicProperty(theState, target, name, target[name], true)[name];
@@ -1909,17 +1946,15 @@
         return ns ? ns["ChromeDbgExt"] : null;
     }
 
-    var _a$3;
     var AiNonUserActionablePrefix = "AI (Internal): ";
     var AiUserActionablePrefix = "AI: ";
     var AIInternalMessagePrefix = "AITR_";
-    var defaultValues$2 = (_a$3 = {
-            loggingLevelConsole: 0,
-            loggingLevelTelemetry: 1,
-            maxMessageLimit: 25
-        },
-        _a$3[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = false,
-        _a$3);
+    var defaultValues$2 = {
+        loggingLevelConsole: 0,
+        loggingLevelTelemetry: 1,
+        maxMessageLimit: 25,
+        enableDebug: false
+    };
     function _sanitizeDiagnosticText(text) {
         if (text) {
             return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
@@ -1969,17 +2004,14 @@
             var _loggingLevelConsole;
             var _loggingLevelTelemetry;
             var _maxInternalMessageLimit;
-            var _enableDebugExceptions;
+            var _enableDebug;
             dynamicProto(DiagnosticLogger, this, function (_self) {
                 _setDefaultsFromConfig(config || {});
                 _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
-                _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
-                _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
-                _self[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = function () { return _enableDebugExceptions; };
                 _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
                     if (isUserAct === void 0) { isUserAct = false; }
                     var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-                    if (_enableDebugExceptions) {
+                    if (_enableDebug) {
                         throw dumpObj(message);
                     }
                     else {
@@ -2055,7 +2087,7 @@
                         _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
                         _loggingLevelTelemetry = config.loggingLevelTelemetry;
                         _maxInternalMessageLimit = config.maxMessageLimit;
-                        _enableDebugExceptions = config[_DYN_ENABLE_DEBUG_EXCEPTI5 ];
+                        _enableDebug = config.enableDebug;
                     });
                 }
                 function _areInternalMessagesThrottled() {
@@ -2094,7 +2126,7 @@
     var _supportsCookies = null;
     var _allowUaSameSite = null;
     var _parsedCookieValue = null;
-    var _doc = getDocument();
+    var _doc;
     var _cookieCache = {};
     var _globalCookieConfig = {};
     var rootDefaultConfig = (_a$2 = {
@@ -2110,6 +2142,9 @@
         },
         _a$2[strDisableCookiesUsage] = UNDEFINED_VALUE,
         _a$2);
+    function _getDoc() {
+        !_doc && (_doc = getLazy(function () { return getDocument(); }));
+    }
     function _gblCookieMgr(config, logger) {
         var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
         if (!inst) {
@@ -2282,8 +2317,9 @@
     function areCookiesSupported(logger) {
         if (_supportsCookies === null) {
             _supportsCookies = false;
+            !_doc && _getDoc();
             try {
-                var doc = _doc || {};
+                var doc = _doc.v || {};
                 _supportsCookies = doc[strCookie] !== undefined;
             }
             catch (e) {
@@ -2326,8 +2362,9 @@
     }
     function _getCookieValue(name) {
         var cookieValue = STR_EMPTY;
-        if (_doc) {
-            var theCookie = _doc[strCookie] || STR_EMPTY;
+        !_doc && _getDoc();
+        if (_doc.v) {
+            var theCookie = _doc.v[strCookie] || STR_EMPTY;
             if (_parsedCookieValue !== theCookie) {
                 _cookieCache = _extractParts(theCookie);
                 _parsedCookieValue = theCookie;
@@ -2337,8 +2374,9 @@
         return cookieValue;
     }
     function _setCookieValue(name, cookieValue) {
-        if (_doc) {
-            _doc[strCookie] = name + "=" + cookieValue;
+        !_doc && _getDoc();
+        if (_doc.v) {
+            _doc.v[strCookie] = name + "=" + cookieValue;
         }
     }
     function uaDisallowsSameSiteNone(userAgent) {
@@ -3522,7 +3560,7 @@
     }
     function dsPadNumber(num) {
         var s = "00" + num;
-        return s.substr(s[_DYN_LENGTH$1 ] - 3);
+        return strSubstr(s, s[_DYN_LENGTH$1 ] - 3);
     }
 
     var _document = getDocument() || {};
@@ -3666,7 +3704,7 @@
     var _canUseSessionStorage = undefined;
     function _getVerifiedStorageObject(storageType) {
         try {
-            if (isNullOrUndefined(getGlobal$1())) {
+            if (isNullOrUndefined(getGlobal())) {
                 return null;
             }
             var uid = (new Date)[_DYN_TO_STRING$1 ]();
@@ -5409,14 +5447,12 @@
             });
             return _this;
         }
-        AnalyticsPlugin.Version = "3.0.0-beta.2303-10";
+        AnalyticsPlugin.Version = "3.0.0-beta.2304-07";
         return AnalyticsPlugin;
     }(BaseTelemetryPlugin));
 
     exports.AnalyticsPlugin = AnalyticsPlugin;
     exports.ApplicationInsights = AnalyticsPlugin;
 
-    Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
 //# sourceMappingURL=applicationinsights-analytics-js.js.map