@microsoft/applicationinsights-web-basic 3.0.0-beta.2303-11 → 3.0.0-beta.2304-07

package/browser/{aib.3.0.0-beta.2303-11.js → es5/aib.3.0.0-beta.2304-07.js}

@@ -1,1139 +1,1185 @@
 /*!
- * Application Insights JavaScript Web SDK - Basic, 3.0.0-beta.2303-11
+ * Application Insights JavaScript Web SDK - Basic, 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';
 
-    /*!
-     * 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() {
-        var result;
-        if (typeof globalThis !== UNDEFINED$1) {
-            result = globalThis;
-        }
-        if (!result && typeof self !== UNDEFINED$1) {
-            result = self;
-        }
-        if (!result && typeof window !== UNDEFINED$1) {
-            result = window;
+    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$1 = Object;
+    var ObjProto$1 = ObjClass$1[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();
         }
-        if (!result && typeof global !== UNDEFINED$1) {
-            result = global;
+        catch (e) {
         }
-        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);
+        return result;
     }
-    function _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype] || target === Array[Prototype]);
+
+    var PRIMITIVE_TYPES = [STRING, NUMBER, BOOLEAN, UNDEFINED, "symbol", "bigint"];
+    function _createIs(theType) {
+        return function (value) {
+            return typeof value === theType;
+        };
     }
-    function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+    function _createObjIs(theName) {
+        var theType = "[object " + theName + "]";
+        return function (value) {
+            return !!(value && objToString(value) === theType);
+        };
     }
-    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;
-            }
-        }
-        return newProto;
+    function objToString(value) {
+        return ObjProto$1.toString.call(value);
     }
-    function _forEachProp(target, func) {
-        var props = [];
-        if (_objGetOwnProps) {
-            props = _objGetOwnProps(target);
-        }
-        else {
-            for (var name_1 in target) {
-                if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
-                    props.push(name_1);
-                }
-            }
-        }
-        if (props && props.length > 0) {
-            for (var lp = 0; lp < props.length; lp++) {
-                func(props[lp]);
-            }
-        }
+    function isUndefined(value) {
+        return typeof value === UNDEFINED || value === UNDEFINED;
     }
-    function _isDynamicCandidate(target, funcName, skipOwn) {
-        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
+    function isNullOrUndefined(value) {
+        return value === null || isUndefined(value);
     }
-    function _throwTypeError(message) {
-        throw new TypeError("DynamicProto: " + message);
+    function isStrictNullOrUndefined(value) {
+        return value === null || !isDefined(value);
     }
-    function _getInstanceFuncs(thisTarget) {
-        var instFuncs = {};
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
-            }
-        });
-        return instFuncs;
+    function isDefined(arg) {
+        return !!arg || arg !== UNDEF_VALUE;
     }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
-                return true;
-            }
+    function isPrimitive(value) {
+        var theType = typeof value;
+        if (value && theType === OBJECT) {
+            return false;
         }
-        return false;
+        return value === null || PRIMITIVE_TYPES.indexOf(theType) !== -1;
     }
-    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);
-        });
-        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);
+    var isString = _createIs(STRING);
+    var isFunction = _createIs(FUNCTION);
+    function isObject(value) {
+        if (!value && isNullOrUndefined(value)) {
+            return false;
         }
-        return baseFuncs;
+        return !!value && typeof value === OBJECT;
     }
-    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);
+    var isArray = ArrCls.isArray;
+    var isDate = _createObjIs("Date");
+    var isNumber = _createIs(NUMBER);
+    var isBoolean = _createIs(BOOLEAN);
+    var isError = _createObjIs("Error");
+    function isTruthy(value) {
+        return !(!value || _safeGet(function () { return !(value && (0 + value)); }, !value));
+    }
+
+    var objGetOwnPropertyDescriptor = ObjClass$1.getOwnPropertyDescriptor;
+
+    function objHasOwnProperty(obj, prop) {
+        return obj && ObjProto$1.hasOwnProperty.call(obj, prop);
+    }
+
+    var objHasOwn = ObjClass$1["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;
                     }
-                    visited.push(objProto);
-                    objProto = _getObjProto(objProto);
-                }
-                try {
-                    if (canAddInst) {
-                        target[funcName] = instFunc;
-                    }
-                    instFunc[DynInstChkTag] = 1;
-                }
-                catch (e) {
-                    instFuncTable[DynAllowInstChkTag] = false;
                 }
             }
         }
-        return instFunc;
     }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto(proto)[funcName];
+
+    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$1["freeze"];
+    var _doNothing = function (value) { return value; };
+    var objAssign = ObjClass$1["assign"];
+    function objKeys(value) {
+        if (!isObject(value) || value === null) {
+            throwTypeError("objKeys called on non-object");
         }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        return ObjClass$1.keys(value);
+    }
+    function objDeepFreeze(value) {
+        if (_objFreeze) {
+            objForEachKey(value, function (key, value) {
+                if (isArray(value) || isObject(value)) {
+                    _objFreeze(value);
+                }
+            });
         }
-        return protoFunc;
+        return objFreeze(value);
     }
-    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;
-            }
-            _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);
-                    }
-                }
-            });
-        }
+    var objFreeze = _objFreeze || _doNothing;
+    var objGetPrototypeOf = ObjClass$1["getPrototypeOf"] || _doNothing;
+
+    function createEnum(values) {
+        return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
     }
-    function _checkPrototype(classProto, thisTarget) {
-        if (_objGetPrototypeOf) {
-            var visited = [];
-            var thisProto = _getObjProto(thisTarget);
-            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-                if (thisProto === classProto) {
-                    return true;
-                }
-                visited.push(thisProto);
-                thisProto = _getObjProto(thisProto);
-            }
-            return false;
-        }
-        return true;
+    function createEnumKeyMap(values) {
+        return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
     }
-    function _getObjName(target, unknownValue) {
-        if (_hasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
-        }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+    function createSimpleMap(values) {
+        var mapClass = {};
+        objForEachKey(values, function (key, value) {
+            mapClass[key] = value[1];
+            mapClass[value[0]] = value[1];
+        });
+        return objDeepFreeze(mapClass);
     }
-    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) + "]");
+    function createTypeMap(values) {
+        return createSimpleMap(values);
+    }
+
+    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) {
+            result = globalThis;
         }
-        var className = null;
-        if (_hasOwnProperty(classProto, DynClassName)) {
-            className = classProto[DynClassName];
+        if (!result && typeof self !== UNDEFINED) {
+            result = self;
         }
-        else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
-            _gblInst.n++;
-            classProto[DynClassName] = className;
+        if (!result && typeof window !== UNDEFINED) {
+            result = window;
         }
-        var perfOptions = dynamicProto[DynProtoDefaultOptions];
-        var useBaseInst = !!perfOptions[strUseBaseInst];
-        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-            useBaseInst = !!options[strUseBaseInst];
+        if (!result && typeof global !== UNDEFINED) {
+            result = global;
         }
-        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 result;
+    }
+    function _getGlobalConfig() {
+        if (!_globalCfg) {
+            var gbl = _getGlobalValue() || {};
+            _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
         }
-        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+        return _globalCfg;
     }
-    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
-
-    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;
+    function dumpObj(object, format) {
+        var propertyValueDump = EMPTY;
+        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);
             }
-            if (!result && typeof window !== strShimUndefined) {
-                result = window;
+            catch (e) {
+                propertyValueDump = " - " + dumpObj(e, format);
             }
-            if (!result && typeof global !== strShimUndefined) {
-                result = global;
+        }
+        return objToString(object) + ": " + propertyValueDump;
+    }
+
+    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);
             }
-            _cachedGlobal$1 = result;
+            throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+        };
+    }
+
+    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 result;
+        if (length < 0) {
+            return EMPTY;
+        }
+        start = start || 0;
+        if (start < 0) {
+            start = mathMax(start + value[LENGTH], 0);
+        }
+        if (isUndefined(length)) {
+            return strSlice(value, start);
+        }
+        return strSlice(value, start, start + length);
     }
-    function throwTypeError$1(message) {
-        throw new TypeError(message);
+    function strLeft(value, count) {
+        return strSubstring(value, 0, count);
     }
-    function objCreateFn(obj) {
-        var func = ObjCreate;
-        if (func) {
-            return func(obj);
+
+    var _polySymbols;
+    function _globalSymbolRegistry() {
+        if (!_polySymbols) {
+            var gblCfg = _getGlobalConfig();
+            _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
         }
-        if (obj == null) {
-            return {};
+        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);
         }
-        var type = typeof obj;
-        if (type !== strShimObject && type !== strShimFunction) {
-            throwTypeError$1("Object prototype may only be an Object:" + obj);
+        return registry.k[key];
+    }
+    function polyGetKnownSymbol(name) {
+        var result;
+        var knownName = _wellKnownSymbolMap[name];
+        if (knownName) {
+            result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
         }
-        function tmpFunc() { }
-        tmpFunc[strShimPrototype] = obj;
-        return new tmpFunc();
+        return result;
     }
 
-    (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 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 t;
+        objForEachKey(value, function (key, value) {
+            prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
+        });
+        return prop;
+    }
+    var objDefineProp = ObjClass$1["defineProperty"];
+    function objDefine(target, key, propDesc) {
+        return objDefineProp(target, key, _createProp(propDesc));
+    }
+
+    var _globalLazyTestHooks;
+    var _fetchLazyTestHooks = function () {
+        _globalLazyTestHooks = _getGlobalConfig();
+        _fetchLazyTestHooks = null;
     };
-    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];
+    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;
                     }
                 }
-            };
-        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;
-        }
-        d[strShimPrototype] = b === null ? objCreateFn(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+                if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                    lazyValue.b = _globalLazyTestHooks.lzy;
+                }
+                return result;
+            }
+        });
+        return lazyValue;
     }
-    function __spreadArrayFn(to, from) {
-        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) {
-            to[j] = from[i];
-        }
-        return to;
+
+    function _lazySafeGet(cb, defValue) {
+        return getLazy(function () { return _safeGet(cb, defValue); });
     }
 
-    /*!
-     * 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;
-        try {
-            result = cb();
+    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];
         }
-        catch (e) {
+        if (name === WINDOW && _cachedWindow) {
+            return _cachedWindow.v;
         }
-        return result;
+        return null;
     }
-    var PRIMITIVE_TYPES = [STRING, NUMBER, BOOLEAN, UNDEFINED, "symbol", "bigint"];
-    function _createIs(theType) {
-        return function (value) {
-            return typeof value === theType;
-        };
+    function hasDocument() {
+        return !!getDocument();
     }
-    function _createObjIs(theName) {
-        var theType = "[object " + theName + "]";
-        return function (value) {
-            return !!(value && objToString(value) === theType);
-        };
+    function getDocument() {
+        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst("document"));
+        return _cachedDocument.v;
     }
-    function objToString(value) {
-        return ObjProto.toString.call(value);
+    function hasWindow() {
+        return !!getWindow();
     }
-    function isUndefined(value) {
-        return typeof value === UNDEFINED || value === UNDEFINED;
+    function getWindow() {
+        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
+        return _cachedWindow.v;
     }
-    function isNullOrUndefined(value) {
-        return value === null || isUndefined(value);
+    function hasNavigator() {
+        return !!getNavigator();
     }
-    function isDefined(arg) {
-        return !!arg || arg !== UNDEF_VALUE;
+    function getNavigator() {
+        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst("navigator"));
+        return _cachedNavigator.v;
     }
-    function isPrimitive(value) {
-        var theType = typeof value;
-        if (value && theType === OBJECT) {
-            return false;
-        }
-        return value === null || PRIMITIVE_TYPES.indexOf(theType) !== -1;
+
+    var _symbol;
+    var _symbolFor;
+    var _symbolKeyFor;
+    function _getSymbolValue(name) {
+        return _lazySafeGet(function () {
+            return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+        }, UNDEF_VALUE);
     }
-    var isString = _createIs(STRING);
-    var isFunction = _createIs(FUNCTION);
-    function isObject(value) {
-        if (!value && isNullOrUndefined(value)) {
-            return false;
-        }
-        return !!value && typeof value === OBJECT;
+    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 isArray = ArrCls.isArray;
-    var isDate = _createObjIs("Date");
-    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 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 objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
-    function objHasOwnProperty(obj, prop) {
-        return obj && ObjProto[HAS_OWN_PROPERTY].call(obj, prop);
+    function newSymbol(description, noPoly) {
+        (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
     }
-    var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
-    function polyObjHasOwn(obj, prop) {
-        return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+    function symbolFor(key) {
+        (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+        return (_symbolFor.v || polySymbolFor)(key);
     }
-    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 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 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");
+
+    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 ObjClass.keys(value);
+        return target;
     }
-    function objDeepFreeze(value) {
-        if (_objFreeze) {
-            objForEachKey(value, function (key, value) {
-                if (isArray(value) || isObject(value)) {
-                    _objFreeze(value);
+
+    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;
+                    }
                 }
-            });
+            }
         }
-        return objFreeze(value);
-    }
-    var objFreeze = _objFreeze || _doNothing;
-    var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _doNothing;
-    function createEnum(values) {
-        return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
-    }
-    function createEnumKeyMap(values) {
-        return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
-    }
-    function createSimpleMap(values) {
-        var mapClass = {};
-        objForEachKey(values, function (key, value) {
-            mapClass[key] = value[1];
-            mapClass[value[0]] = value[1];
-        });
-        return objDeepFreeze(mapClass);
     }
-    function createTypeMap(values) {
-        return createSimpleMap(values);
+
+    var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
+
+    var arrMap = _unwrapFunction("map", ArrProto);
+
+    var arrReduce = _unwrapFunction("reduce", ArrProto);
+
+    var arrSlice = _unwrapFunction(SLICE, ArrProto);
+
+    function objSetPrototypeOf(obj, proto) {
+        var fn = ObjClass$1["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);
     }
-    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;
+
+    function _createCustomError(name, d, baseClass) {
+        objSetPrototypeOf(d, baseClass);
+        function __() {
+            this.constructor = d;
+            this[NAME] = name;
         }
-        if (!result && typeof self !== UNDEFINED) {
-            result = self;
+        __[PROTOTYPE] = baseClass[PROTOTYPE];
+        d[PROTOTYPE] = new __();
+        return d;
+    }
+    var _safeSetName = function (baseClass, name) {
+        try {
+            baseClass[PROTOTYPE][NAME] = name;
         }
-        if (!result && typeof window !== UNDEFINED) {
-            result = window;
+        catch (e) {
         }
-        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 {
+    };
+    function createCustomError(name, constructCb) {
+        var baseClass = Error;
+        var orgName = baseClass[PROTOTYPE][NAME];
+        var customError = _createCustomError(name, function () {
+            var _this = this;
             try {
-                propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+                _safeSetName(baseClass, name);
+                _this = baseClass.apply(_this, arguments) || _this;
+                _this[NAME] = name;
+                constructCb && constructCb(_this, arguments);
             }
-            catch (e) {
-                propertyValueDump = " - " + dumpObj(e, format);
+            finally {
+                _safeSetName(baseClass, orgName);
             }
-        }
-        return objToString(object) + ": " + propertyValueDump;
+            return _this;
+        }, baseClass);
+        return customError;
     }
-    function _extractArgs(args, startAt) {
-        var theArgs = [];
-        for (var lp = startAt; lp < args[LENGTH]; lp++) {
-            theArgs[lp - startAt] = args[lp];
-        }
-        return theArgs;
+
+    function utcNow() {
+        return (Date.now || polyUtcNow)();
     }
-    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);
-                }
+    function polyUtcNow() {
+        return new Date().getTime();
+    }
+
+    function _createTrimFn(exp) {
+        return function _doTrim(value) {
+            if (isNullOrUndefined(value)) {
+                throwTypeError("strTrim called [" + dumpObj(value) + "]");
             }
-            throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+            if (value && value.replace) {
+                value = value.replace(exp, EMPTY);
+            }
+            return value;
         };
     }
-    var strSubstring = _unwrapFunction("substring");
-    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: {} };
+    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;
         }
-        return _polySymbols;
-    }
-    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);
+        if (!_gblWindow) {
+            _gblWindow = hasWindow() ? getWindow() : true;
         }
-        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;
-        });
-        return prop;
-    }
-    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;
-        objDefine(lazyValue, "v", {
-            g: function () {
-                var result = cb();
-                if (!_globalLazyTestHooks.lzy) {
-                    objDefine(lazyValue, "v", { v: result });
-                    if (lazyValue.b) {
-                        delete lazyValue.b;
+        var result = false;
+        if (value !== _gblWindow) {
+            if (!_objCtrFnString) {
+                _fnToString = Function[PROTOTYPE].toString;
+                _objCtrFnString = _fnToString.call(ObjClass$1);
+            }
+            try {
+                var proto = objGetPrototypeOf(value);
+                result = !proto;
+                if (!result) {
+                    if (objHasOwnProperty(proto, CONSTRUCTOR)) {
+                        proto = proto[CONSTRUCTOR];
                     }
+                    result = proto && typeof proto === FUNCTION && _fnToString.call(proto) === _objCtrFnString;
                 }
-                if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
-                    lazyValue.b = _globalLazyTestHooks.lzy;
-                }
-                return result;
             }
-        });
-        return lazyValue;
-    }
-    function _lazySafeGet(cb, defValue) {
-        return getLazy(function () { return _safeGet(cb, defValue); });
+            catch (ex) {
+            }
+        }
+        return result;
     }
-    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);
+
+    function _defaultDeepCopyHandler(details) {
+        var target = details.result = {};
+        details.copyTo(target, details.value);
+        return true;
     }
-    function getGlobal(useCached) {
-        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
-        return _cachedGlobal.v;
+    var defaultDeepCopyHandlers = [
+        arrayDeepCopyHandler,
+        plainObjDeepCopyHandler,
+        functionDeepCopyHandler,
+        dateDeepCopyHandler
+    ];
+    function _getSetVisited(visitMap, source, newPath, cb) {
+        var theEntry;
+        arrForEach(visitMap, function (entry) {
+            if (entry.k === source) {
+                theEntry = entry;
+                return -1;
+            }
+        });
+        if (!theEntry) {
+            theEntry = { k: source, v: source };
+            visitMap.push(theEntry);
+            cb(theEntry);
+        }
+        return theEntry.v;
     }
-    function getInst(name, useCached) {
-        var gbl = getGlobal(useCached);
-        if (gbl && gbl[name]) {
-            return gbl[name];
+    function _deepCopy(visitMap, value, ctx, key) {
+        var userHandler = ctx.handler;
+        var newPath = ctx.path ? (key ? ctx.path.concat(key) : ctx.path) : [];
+        var newCtx = {
+            handler: ctx.handler,
+            src: ctx.src,
+            path: newPath
+        };
+        var details = {
+            type: typeof value,
+            isPrim: isPrimitive(value),
+            value: value,
+            result: value,
+            path: newPath,
+            origin: ctx.src,
+            copy: function (source, newKey) {
+                return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
+            },
+            copyTo: function (target, source) {
+                return _copyProps(visitMap, target, source, newCtx);
+            }
+        };
+        if (!details.isPrim) {
+            return _getSetVisited(visitMap, value, newPath, function (newEntry) {
+                objDefine(details, "result", {
+                    g: function () {
+                        return newEntry.v;
+                    },
+                    s: function (newValue) {
+                        newEntry.v = newValue;
+                    }
+                });
+                var idx = 0;
+                var handler = userHandler;
+                while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler)).call(ctx, details)) {
+                    handler = null;
+                }
+            });
         }
-        if (name === WINDOW && _cachedWindow) {
-            return _cachedWindow.v;
+        if (userHandler && userHandler.call(ctx, details)) {
+            return details.result;
         }
-        return null;
+        return value;
     }
-    function hasDocument() {
-        return !!getDocument();
+    function _copyProps(visitMap, target, source, ctx) {
+        if (!isNullOrUndefined(source)) {
+            for (var key in source) {
+                target[key] = _deepCopy(visitMap, source[key], ctx, key);
+            }
+        }
+        return target;
     }
-    function getDocument() {
-        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst(DOCUMENT));
-        return _cachedDocument.v;
+    function objCopyProps(target, source, handler) {
+        var ctx = {
+            handler: handler,
+            src: source,
+            path: []
+        };
+        return _copyProps([], target, source, ctx);
     }
-    function hasWindow() {
-        return !!getWindow();
+    function objDeepCopy(source, handler) {
+        var ctx = {
+            handler: handler,
+            src: source
+        };
+        return _deepCopy([], source, ctx);
     }
-    function getWindow() {
-        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
-        return _cachedWindow.v;
+    function arrayDeepCopyHandler(details) {
+        var value = details.value;
+        if (isArray(value)) {
+            var target = details.result = [];
+            target.length = value.length;
+            details.copyTo(target, value);
+            return true;
+        }
+        return false;
     }
-    function hasNavigator() {
-        return !!getNavigator();
+    function dateDeepCopyHandler(details) {
+        var value = details.value;
+        if (isDate(value)) {
+            details.result = new Date(value.getTime());
+            return true;
+        }
+        return false;
     }
-    function getNavigator() {
-        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst(NAVIGATOR));
-        return _cachedNavigator.v;
+    function functionDeepCopyHandler(details) {
+        if (details.type === FUNCTION) {
+            return true;
+        }
+        return false;
     }
-    var _symbol;
-    var _symbolFor;
-    var _symbolKeyFor;
-    function _getSymbolValue(name) {
-        return _lazySafeGet(function () {
-            return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
-        }, UNDEF_VALUE);
+    function plainObjDeepCopyHandler(details) {
+        var value = details.value;
+        if (isPlainObject(value)) {
+            var target = details.result = {};
+            details.copyTo(target, value);
+            return true;
+        }
+        return false;
     }
-    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 _doExtend(target, theArgs) {
+        arrForEach(theArgs, function (theArg) {
+            objCopyProps(target, theArg);
+        });
+        return target;
     }
-    function newSymbol(description, noPoly) {
-        (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
-        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
+    function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
+        return _doExtend(objDeepCopy(target) || {}, arrSlice(arguments));
     }
-    function symbolFor(key) {
-        (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
-        return (_symbolFor.v || polySymbolFor)(key);
+
+    var _objCreate = ObjClass$1["create"];
+    var objCreate = _objCreate || polyObjCreate;
+    function polyObjCreate(obj) {
+        if (!obj) {
+            return {};
+        }
+        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 isIterator(value) {
-        return !!value && isFunction(value.next);
+
+    var strEndsWith = _unwrapFunction("endsWith", StrProto, polyStrEndsWith);
+    function polyStrEndsWith(value, searchString, length) {
+        if (!isString(value)) {
+            throwTypeError("'" + dumpObj(value) + "' is not a string");
+        }
+        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;
     }
-    function arrAppend(target, elms) {
-        if (!isUndefined(elms) && target) {
-            if (isArray(elms)) {
-                target.push.apply(target, elms);
+
+    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]();
             }
-            else if (isIterator(elms)) {
-                var value = elms.next();
-                while (!value[DONE]) {
-                    target.push(value[VALUE]);
-                    value = elms.next();
-                }
+            return ref;
+        };
+        var _refresh = function () {
+            timerId = refreshFn(timerId);
+            if (!ref) {
+                _unref();
             }
-            else {
-                target.push(elms);
+            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;
             }
-        }
-        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 _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);
             }
-        }
-    }
-    var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
-    var arrMap = _unwrapFunction("map", ArrProto);
-    var arrReduce = _unwrapFunction("reduce", 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);
+            return setFn.apply(self, theArgs);
+        }, function (timerId) {
+            clearFn.call(self, timerId);
+        });
+        return handler.h;
     }
-    function _createCustomError(name, d, baseClass) {
-        objSetPrototypeOf(d, baseClass);
-        function __() {
-            this.constructor = d;
-            this[NAME] = name;
-        }
-        __[PROTOTYPE] = baseClass[PROTOTYPE];
-        d[PROTOTYPE] = new __();
-        return d;
+    function scheduleTimeout(callback, timeout) {
+        return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
     }
-    var _safeSetName = function (baseClass, name) {
-        try {
-            baseClass[PROTOTYPE][NAME] = name;
-        }
-        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;
+
+    function scheduleInterval(callback, timeout) {
+        var self = this;
+        var theArguments = arrSlice(arguments);
+        var handler = _createTimerHandler(true, function (intervalId) {
+            intervalId && clearInterval(intervalId);
+            return setInterval.apply(self, theArguments);
+        }, function (intervalId) {
+            clearInterval(intervalId);
+        });
+        return handler.h;
     }
-    function utcNow() {
-        return (Date.now || polyUtcNow)();
+
+    var _a$4;
+    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$4 = {},
+            _a$4[strSetInstFuncs] = true,
+            _a$4[strUseBaseInst] = true,
+            _a$4),
+        n: 1000
+    });
+    function _isObjectOrArrayPrototype(target) {
+        return target && (target === Obj[Prototype] || target === Array[Prototype]);
     }
-    function polyUtcNow() {
-        return new Date().getTime();
+    function _isObjectArrayOrFunctionPrototype(target) {
+        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
     }
-    var _fnToString;
-    var _objCtrFnString;
-    var _gblWindow;
-    function isPlainObject(value) {
-        if (!value || typeof value !== OBJECT) {
-            return false;
+    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;
+            }
         }
-        if (!_gblWindow) {
-            _gblWindow = hasWindow() ? getWindow() : true;
+        return newProto;
+    }
+    function _forEachProp(target, func) {
+        var props = [];
+        if (_objGetOwnProps) {
+            props = _objGetOwnProps(target);
         }
-        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;
+        else {
+            for (var name_1 in target) {
+                if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                    props.push(name_1);
                 }
             }
-            catch (ex) {
+        }
+        if (props && props.length > 0) {
+            for (var lp = 0; lp < props.length; lp++) {
+                func(props[lp]);
             }
         }
-        return result;
     }
-    function _defaultDeepCopyHandler(details) {
-        var target = details.result = {};
-        details.copyTo(target, details.value);
-        return true;
+    function _isDynamicCandidate(target, funcName, skipOwn) {
+        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
     }
-    var defaultDeepCopyHandlers = [
-        arrayDeepCopyHandler,
-        plainObjDeepCopyHandler,
-        functionDeepCopyHandler,
-        dateDeepCopyHandler
-    ];
-    function _getSetVisited(visitMap, source, newPath, cb) {
-        var theEntry;
-        arrForEach(visitMap, function (entry) {
-            if (entry.k === source) {
-                theEntry = entry;
-                return -1;
+    function _throwTypeError(message) {
+        throwTypeError("DynamicProto: " + message);
+    }
+    function _getInstanceFuncs(thisTarget) {
+        var instFuncs = {};
+        _forEachProp(thisTarget, function (name) {
+            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+                instFuncs[name] = thisTarget[name];
             }
         });
-        if (!theEntry) {
-            theEntry = { k: source, v: source };
-            visitMap.push(theEntry);
-            cb(theEntry);
+        return instFuncs;
+    }
+    function _hasVisited(values, value) {
+        for (var lp = values.length - 1; lp >= 0; lp--) {
+            if (values[lp] === value) {
+                return true;
+            }
         }
-        return theEntry.v;
+        return false;
     }
-    function _deepCopy(visitMap, value, ctx, key) {
-        var userHandler = ctx.handler;
-        var newPath = ctx.path ? (key ? ctx.path.concat(key) : ctx.path) : [];
-        var newCtx = {
-            handler: ctx.handler,
-            src: ctx.src,
-            path: newPath
-        };
-        var details = {
-            type: typeof value,
-            isPrim: isPrimitive(value),
-            value: value,
-            result: value,
-            path: newPath,
-            origin: ctx.src,
-            copy: function (source, newKey) {
-                return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
-            },
-            copyTo: function (target, source) {
-                return _copyProps(visitMap, target, source, newCtx);
+    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;
+                }
             }
-        };
-        if (!details.isPrim) {
-            return _getSetVisited(visitMap, value, newPath, function (newEntry) {
-                objDefine(details, "result", {
-                    g: function () {
-                        return newEntry.v;
-                    },
-                    s: function (newValue) {
-                        newEntry.v = newValue;
-                    }
-                });
-                var idx = 0;
-                var handler = userHandler;
-                while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler)).call(ctx, details)) {
-                    handler = null;
+            return function () {
+                return theFunc.apply(target, arguments);
+            };
+        }
+        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);
         }
-        if (userHandler && userHandler.call(ctx, details)) {
-            return details.result;
-        }
-        return value;
+        return baseFuncs;
     }
-    function _copyProps(visitMap, target, source, ctx) {
-        if (!isNullOrUndefined(source)) {
-            for (var key in source) {
-                target[key] = _deepCopy(visitMap, source[key], ctx, key);
+    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 target;
-    }
-    function objCopyProps(target, source, handler) {
-        var ctx = {
-            handler: handler,
-            src: source,
-            path: []
-        };
-        return _copyProps([], target, source, ctx);
+        return instFunc;
     }
-    function objDeepCopy(source, handler) {
-        var ctx = {
-            handler: handler,
-            src: source
-        };
-        return _deepCopy([], source, ctx);
+    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+        var protoFunc = proto[funcName];
+        if (protoFunc === currentDynProtoProxy) {
+            protoFunc = _getObjProto(proto)[funcName];
+        }
+        if (typeof protoFunc !== strFunction) {
+            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        }
+        return protoFunc;
     }
-    function arrayDeepCopyHandler(details) {
-        var value = details.value;
-        if (isArray(value)) {
-            var target = details.result = [];
-            target.length = value.length;
-            details.copyTo(target, value);
-            return 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;
+        }
+        if (!_isObjectOrArrayPrototype(proto)) {
+            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+            }
+            _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);
+                    }
+                }
+            });
         }
-        return false;
     }
-    function dateDeepCopyHandler(details) {
-        var value = details.value;
-        if (isDate(value)) {
-            details.result = new Date(value.getTime());
-            return true;
+    function _checkPrototype(classProto, thisTarget) {
+        if (_objGetPrototypeOf) {
+            var visited = [];
+            var thisProto = _getObjProto(thisTarget);
+            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+                if (thisProto === classProto) {
+                    return true;
+                }
+                visited.push(thisProto);
+                thisProto = _getObjProto(thisProto);
+            }
+            return false;
         }
-        return false;
+        return true;
     }
-    function functionDeepCopyHandler(details) {
-        if (details.type === FUNCTION) {
-            return true;
+    function _getObjName(target, unknownValue) {
+        if (objHasOwnProperty(target, Prototype)) {
+            return target.name || unknownValue || UnknownValue;
         }
-        return false;
+        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
     }
-    function plainObjDeepCopyHandler(details) {
-        var value = details.value;
-        if (isPlainObject(value)) {
-            var target = details.result = {};
-            details.copyTo(target, value);
-            return true;
+    function dynamicProto(theClass, target, delegateFunc, options) {
+        if (!objHasOwnProperty(theClass, Prototype)) {
+            _throwTypeError("theClass is an invalid class definition.");
         }
-        return false;
-    }
-    function _doExtend(target, theArgs) {
-        arrForEach(theArgs, function (theArg) {
-            objCopyProps(target, theArg);
-        });
-        return target;
-    }
-    function deepExtend(target) {
-        var theArgs = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            theArgs[_i - 1] = arguments[_i];
+        var classProto = theClass[Prototype];
+        if (!_checkPrototype(classProto, target)) {
+            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
         }
-        return _doExtend(objDeepCopy(target) || {}, theArgs);
-    }
-    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 className = null;
+        if (objHasOwnProperty(classProto, DynClassName)) {
+            className = classProto[DynClassName];
         }
-        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;
-            }
-        };
+        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);
     }
-    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;
+    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
+
+    var strShimFunction = "function";
+    var strShimObject = "object";
+    var strShimUndefined = "undefined";
+    var strShimPrototype = "prototype";
+    var ObjClass = Object;
+    var ObjProto = ObjClass[strShimPrototype];
+
+    (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[strHasOwnProperty].call(s, p)) {
+                    t[p] = s[p];
                 }
-                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));
+        }
+        return t;
+    };
+    var __assignFn = objAssign || __objAssignFnImpl;
+    var extendStaticsFn = function (d, b) {
+        extendStaticsFn = ObjClass["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 scheduleInterval(callback, timeout) {
-        var self = this;
-        var theArguments = _extractArgs(arguments, 0);
-        var handler = _createTimerHandler(true, function (intervalId) {
-            intervalId && clearInterval(intervalId);
-            return setInterval.apply(self, theArguments);
-        }, function (intervalId) {
-            clearInterval(intervalId);
-        });
-        return handler.h;
+    function __spreadArrayFn(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) {
+            to[j] = from[i];
+        }
+        return to;
     }
 
     var createEnumStyle = createEnum;
@@ -1206,7 +1252,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$1 = undefined;
@@ -1339,8 +1385,8 @@
         }());
     }
     function optimizeObject(theObject) {
-        if (theObject && ObjAssign) {
-            theObject = ObjClass$1(ObjAssign({}, theObject));
+        if (theObject && objAssign) {
+            theObject = ObjClass(objAssign({}, theObject));
         }
         return theObject;
     }
@@ -1530,15 +1576,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() {
@@ -1596,7 +1644,7 @@
         return result;
     }
 
-    var version = "3.0.0-beta.2303-11";
+    var version = "3.0.0-beta.2304-07";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -2445,7 +2493,7 @@
     var _supportsCookies = null;
     var _allowUaSameSite = null;
     var _parsedCookieValue = null;
-    var _doc = getDocument();
+    var _doc;
     var _cookieCache = {};
     var _globalCookieConfig = {};
     var rootDefaultConfig = (_a$3 = {
@@ -2461,6 +2509,9 @@
         },
         _a$3[strDisableCookiesUsage] = UNDEFINED_VALUE$1,
         _a$3);
+    function _getDoc() {
+        !_doc && (_doc = getLazy(function () { return getDocument(); }));
+    }
     function _isMgrEnabled(cookieMgr) {
         if (cookieMgr) {
             return cookieMgr.isEnabled();
@@ -2606,8 +2657,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) {
@@ -2650,8 +2702,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;
@@ -2661,8 +2714,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) {
@@ -3567,6 +3621,43 @@
         return BaseTelemetryPlugin;
     }());
 
+    function _addInitializer(_initializers, id, telemetryInitializer) {
+        var theInitializer = {
+            id: id,
+            fn: telemetryInitializer
+        };
+        arrAppend(_initializers, theInitializer);
+        var handler = {
+            remove: function () {
+                arrForEach(_initializers, function (initializer, idx) {
+                    if (initializer.id === theInitializer.id) {
+                        _initializers[_DYN_SPLICE ](idx, 1);
+                        return -1;
+                    }
+                });
+            }
+        };
+        return handler;
+    }
+    function _runInitializers(_initializers, item, logger) {
+        var doNotSendItem = false;
+        var telemetryInitializersCount = _initializers[_DYN_LENGTH$2 ];
+        for (var i = 0; i < telemetryInitializersCount; ++i) {
+            var telemetryInitializer = _initializers[i];
+            if (telemetryInitializer) {
+                try {
+                    if (telemetryInitializer.fn[_DYN_APPLY ](null, [item]) === false) {
+                        doNotSendItem = true;
+                        break;
+                    }
+                }
+                catch (e) {
+                    _throwInternal(logger, 2 , 64 , "Telemetry initializer failed: " + getExceptionName(e), { exception: dumpObj(e) }, true);
+                }
+            }
+        }
+        return !doNotSendItem;
+    }
     var TelemetryInitializerPlugin = /** @class */ (function (_super) {
         __extendsFn(TelemetryInitializerPlugin, _super);
         function TelemetryInitializerPlugin() {
@@ -3578,41 +3669,10 @@
             _initDefaults();
             dynamicProto(TelemetryInitializerPlugin, _this, function (_self, _base) {
                 _self.addTelemetryInitializer = function (telemetryInitializer) {
-                    var theInitializer = {
-                        id: _id++,
-                        fn: telemetryInitializer
-                    };
-                    _initializers[_DYN_PUSH$1 ](theInitializer);
-                    var handler = {
-                        remove: function () {
-                            arrForEach(_initializers, function (initializer, idx) {
-                                if (initializer.id === theInitializer.id) {
-                                    _initializers[_DYN_SPLICE ](idx, 1);
-                                    return -1;
-                                }
-                            });
-                        }
-                    };
-                    return handler;
+                    return _addInitializer(_initializers, _id++, telemetryInitializer);
                 };
                 _self[STR_PROCESS_TELEMETRY ] = function (item, itemCtx) {
-                    var doNotSendItem = false;
-                    var telemetryInitializersCount = _initializers[_DYN_LENGTH$2 ];
-                    for (var i = 0; i < telemetryInitializersCount; ++i) {
-                        var telemetryInitializer = _initializers[i];
-                        if (telemetryInitializer) {
-                            try {
-                                if (telemetryInitializer.fn[_DYN_APPLY ](null, [item]) === false) {
-                                    doNotSendItem = true;
-                                    break;
-                                }
-                            }
-                            catch (e) {
-                                _throwInternal(itemCtx[_DYN_DIAG_LOG$1 ](), 2 , 64 , "Telemetry initializer failed: " + getExceptionName(e), { exception: dumpObj(e) }, true);
-                            }
-                        }
-                    }
-                    if (!doNotSendItem) {
+                    if (_runInitializers(_initializers, item, itemCtx[_DYN_DIAG_LOG$1 ]())) {
                         _self[_DYN_PROCESS_NEXT ](item, itemCtx);
                     }
                 };
@@ -4734,7 +4794,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() || {};
@@ -4841,7 +4901,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 ]();
@@ -5743,6 +5803,7 @@
     var _DYN_ENVELOPE_TYPE = "envelopeType";
     var _DYN_TO_STRING = "toString";
     var _DYN_ON_LINE = "onLine";
+    var _DYN_IS_ONLINE = "isOnline";
     var _DYN__GET = "_get";
     var _DYN_ENQUEUE = "enqueue";
     var _DYN_COUNT = "count";
@@ -5893,7 +5954,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: "3.0.0-beta.2303-11"
+        Version: "3.0.0-beta.2304-07"
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -6046,6 +6107,7 @@
         eventOff(target, null, null, evtNamespace);
     }
     function createOfflineListener(parentEvtNamespace) {
+        var _a;
         var _document = getDocument();
         var _navigator = getNavigator();
         var _isListening = false;
@@ -6111,11 +6173,11 @@
                 _isListening = false;
             }
         }
-        return {
-            isOnline: _isOnline,
-            isListening: function () { return _isListening; },
-            unload: _unload
-        };
+        return _a = {},
+            _a[_DYN_IS_ONLINE ] = _isOnline,
+            _a.isListening = function () { return _isListening; },
+            _a.unload = _unload,
+            _a;
     }
 
     var BaseSendBuffer = /** @class */ (function () {
@@ -6592,7 +6654,6 @@
             _this.identifier = BreezeChannelIdentifier;
             var _consecutiveErrors;
             var _retryAt;
-            var _lastSend;
             var _paused;
             var _timeoutHandle;
             var _serializer;
@@ -6668,7 +6729,6 @@
                     _serializer = new Serializer(core.logger);
                     _consecutiveErrors = 0;
                     _retryAt = null;
-                    _lastSend = 0;
                     _self[_DYN__SENDER ] = null;
                     _stamp_specific_redirects = 0;
                     var diagLog = _self[_DYN_DIAG_LOG ]();
@@ -6849,7 +6909,6 @@
                                         _self[_DYN__SENDER ](payload, async);
                                     }
                                 }
-                                _lastSend = +new Date;
                             }
                             else {
                                 buffer[_DYN_CLEAR ]();
@@ -6926,7 +6985,9 @@
                 function _checkMaxSize(incomingPayload) {
                     var incomingSize = incomingPayload ? incomingPayload[_DYN_LENGTH ] : 0;
                     if ((_self[_DYN__BUFFER ].size() + incomingSize) > _maxBatchSizeInBytes) {
-                        _self[_DYN_TRIGGER_SEND ](true, null, 10 );
+                        if (!_offlineListener || _offlineListener[_DYN_IS_ONLINE ]()) {
+                            _self[_DYN_TRIGGER_SEND ](true, null, 10 );
+                        }
                         return true;
                     }
                     return false;
@@ -6955,7 +7016,7 @@
                             _self[_DYN__ON_ERROR ](payload, errorMessage);
                         }
                     }
-                    else if (_offlineListener && !_offlineListener.isOnline()) {
+                    else if (_offlineListener && !_offlineListener[_DYN_IS_ONLINE ]()) {
                         if (!_isRetryDisabled) {
                             var offlineBackOffMultiplier = 10;
                             _resendPayload(payload, offlineBackOffMultiplier);
@@ -7288,7 +7349,6 @@
                     _offlineListener = null;
                     _consecutiveErrors = 0;
                     _retryAt = null;
-                    _lastSend = null;
                     _paused = false;
                     _timeoutHandle = null;
                     _serializer = null;
@@ -7394,7 +7454,5 @@
     exports.proxyFunctions = proxyFunctions;
     exports.throwError = throwError;
 
-    Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
-//# sourceMappingURL=aib.3.0.0-beta.2303-11.js.map
+//# sourceMappingURL=aib.3.0.0-beta.2304-07.js.map