/*!
 * Microsoft Application Insights JavaScript SDK - Shim functions, 3.0.1
 * 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.Microsoft.ApplicationInsights.Shims = {})));
})(this, (function (exports) { 'use strict';

    var strShimFunction = "function";
    var strShimObject = "object";
    var strShimUndefined = "undefined";
    var strShimPrototype = "prototype";
    var strDefault = "default";
    var ObjClass$1 = Object;
    var ObjProto$1 = ObjClass$1[strShimPrototype];

    var UNDEF_VALUE = undefined;
    var EMPTY = "";
    var FUNCTION = "function";
    var NUMBER = "number";
    var OBJECT = "object";
    var PROTOTYPE = "prototype";
    var UNDEFINED = "undefined";
    var ObjClass = Object;
    var ObjProto = ObjClass[PROTOTYPE];

    function _safeGet(cb, defValue) {
        var result = defValue;
        try {
            result = cb();
        }
        catch (e) {
        }
        return result;
    }

    function _createIs(theType) {
        return function (value) {
            return typeof value === theType;
        };
    }
    function _createObjIs(theName) {
        var theType = "[object " + theName + "]";
        return function (value) {
            return !!(value && objToString(value) === theType);
        };
    }
    function objToString(value) {
        return ObjProto.toString.call(value);
    }
    var isNumber = _createIs(NUMBER);
    var isError = _createObjIs("Error");

    function objHasOwnProperty(obj, prop) {
        return obj && ObjProto.hasOwnProperty.call(obj, prop);
    }

    function throwTypeError(message) {
        throw new TypeError(message);
    }

    var objAssign = ObjClass["assign"];

    var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
    var _globalCfg;
    function _getGlobalValue() {
        var result;
        if (typeof globalThis !== UNDEFINED) {
            result = globalThis;
        }
        if (!result && typeof self !== UNDEFINED) {
            result = self;
        }
        if (!result && typeof window !== UNDEFINED) {
            result = window;
        }
        if (!result && typeof global !== UNDEFINED) {
            result = global;
        }
        return result;
    }
    function _getGlobalConfig() {
        if (!_globalCfg) {
            var gbl = _getGlobalValue() || {};
            _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
        }
        return _globalCfg;
    }

    function dumpObj(object, format) {
        var propertyValueDump = 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);
            }
            catch (e) {
                propertyValueDump = " - " + dumpObj(e, format);
            }
        }
        return objToString(object) + ": " + propertyValueDump;
    }

    var objDefineProp = ObjClass["defineProperty"];

    var _globalLazyTestHooks;
    var _fetchLazyTestHooks = function () {
        _globalLazyTestHooks = _getGlobalConfig();
        _fetchLazyTestHooks = null;
    };
    function getLazy(cb) {
        var lazyValue = {};
        _fetchLazyTestHooks && _fetchLazyTestHooks();
        lazyValue.b = _globalLazyTestHooks.lzy;
        objDefineProp(lazyValue, "v", {
            configurable: true,
            get: function () {
                var result = cb();
                if (!_globalLazyTestHooks.lzy) {
                    objDefineProp(lazyValue, "v", {
                        value: result
                    });
                    if (lazyValue.b) {
                        delete lazyValue.b;
                    }
                }
                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); });
    }

    var _cachedGlobal;
    function getGlobal(useCached) {
        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
        return _cachedGlobal.v;
    }

    var _objCreate = ObjClass["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();
    }

    var SymbolObj = (getGlobal() || {})["Symbol"];
    var ReflectObj = (getGlobal() || {})["Reflect"];
    var __hasReflect = !!ReflectObj;
    var strDecorate = "decorate";
    var strMetadata = "metadata";
    var strGetOwnPropertySymbols = "getOwnPropertySymbols";
    var strIterator = "iterator";
    var strHasOwnProperty = "hasOwnProperty";
    var __objAssignFnImpl = function (t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) {
                if (ObjProto$1[strHasOwnProperty].call(s, p)) {
                    t[p] = s[p];
                }
            }
        }
        return t;
    };
    var __assignFn = objAssign || __objAssignFnImpl;
    var extendStaticsFn = function (d, b) {
        extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
            ({ __proto__: [] } instanceof Array && function (d, b) {
                d.__proto__ = b;
            }) ||
            function (d, b) {
                for (var p in b) {
                    if (b[strHasOwnProperty](p)) {
                        d[p] = b[p];
                    }
                }
            };
        return extendStaticsFn(d, b);
    };
    function __extendsFn(d, b) {
        if (typeof b !== strShimFunction && b !== null) {
            throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
        }
        extendStaticsFn(d, b);
        function __() {
            this.constructor = d;
        }
        d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
    }
    function __restFn(s, e) {
        var t = {};
        for (var k in s) {
            if (objHasOwnProperty(s, k) && e.indexOf(k) < 0) {
                t[k] = s[k];
            }
        }
        if (s != null && typeof ObjClass$1[strGetOwnPropertySymbols] === strShimFunction) {
            for (var i = 0, p = ObjClass$1[strGetOwnPropertySymbols](s); i < p.length; i++) {
                if (e.indexOf(p[i]) < 0 && ObjProto$1["propertyIsEnumerable"].call(s, p[i])) {
                    t[p[i]] = s[p[i]];
                }
            }
        }
        return t;
    }
    function __decorateFn(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = ObjClass$1["getOwnPropertyDescriptor"](target, key) : desc, d;
        if (__hasReflect && typeof ReflectObj[strDecorate] === strShimFunction) {
            r = ReflectObj[strDecorate](decorators, target, key, desc);
        }
        else {
            for (var i = decorators.length - 1; i >= 0; i--) {
                if (d = decorators[i]) {
                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
                }
            }
        }
        return c > 3 && r && objDefineProp(target, key, r), r;
    }
    function __paramFn(paramIndex, decorator) {
        return function (target, key) {
            decorator(target, key, paramIndex);
        };
    }
    function __metadataFn(metadataKey, metadataValue) {
        if (__hasReflect && ReflectObj[strMetadata] === strShimFunction) {
            return ReflectObj[strMetadata](metadataKey, metadataValue);
        }
    }
    function __exportStarFn(m, o) {
        for (var p in m) {
            if (p !== strDefault && !objHasOwnProperty(o, p)) {
                __createBindingFn(o, m, p);
            }
        }
    }
    function __createBindingFn(o, m, k, k2) {
        if (k2 === undefined) {
            k2 = k;
        }
        if (!!objDefineProp) {
            objDefineProp(o, k2, {
                enumerable: true,
                get: function () {
                    return m[k];
                }
            });
        }
        else {
            o[k2] = m[k];
        }
    }
    function __valuesFn(o) {
        var s = typeof SymbolObj === strShimFunction && SymbolObj[strIterator], m = s && o[s], i = 0;
        if (m) {
            return m.call(o);
        }
        if (o && typeof o.length === "number") {
            return {
                next: function () {
                    if (o && i >= o.length) {
                        o = void 0;
                    }
                    return { value: o && o[i++], done: !o };
                }
            };
        }
        throwTypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
    }
    function __readFn(o, n) {
        var m = typeof SymbolObj === strShimFunction && o[SymbolObj[strIterator]];
        if (!m) {
            return o;
        }
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
                ar.push(r.value);
            }
        }
        catch (error) {
            e = {
                error: error
            };
        }
        finally {
            try {
                if (r && !r.done && (m = i["return"])) {
                    m.call(i);
                }
            }
            finally {
                if (e) {
                    throw e.error;
                }
            }
        }
        return ar;
    }
    function __spreadArraysFn() {
        var theArgs = arguments;
        for (var s = 0, i = 0, il = theArgs.length; i < il; i++) {
            s += theArgs[i].length;
        }
        for (var r = Array(s), k = 0, i = 0; i < il; i++) {
            for (var a = theArgs[i], j = 0, jl = a.length; j < jl; j++, k++) {
                r[k] = a[j];
            }
        }
        return r;
    }
    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 __makeTemplateObjectFn(cooked, raw) {
        if (objDefineProp) {
            objDefineProp(cooked, "raw", { value: raw });
        }
        else {
            cooked.raw = raw;
        }
        return cooked;
    }
    function __importStarFn(mod) {
        if (mod && mod.__esModule) {
            return mod;
        }
        var result = {};
        if (mod != null) {
            for (var k in mod) {
                if (k !== strDefault && Object.prototype.hasOwnProperty.call(mod, k)) {
                    __createBindingFn(result, mod, k);
                }
            }
        }
        if (!!objDefineProp) {
            objDefineProp(result, strDefault, { enumerable: true, value: mod });
        }
        else {
            result[strDefault] = mod;
        }
        return result;
    }
    function __importDefaultFn(mod) {
        return (mod && mod.__esModule) ? mod : { strDefault: mod };
    }

    function __exposeGlobalTsLib() {
        var globalObj = getGlobal() || {};
        (function (root, assignFn, extendsFn, createBindingFn) {
            if (!root.__assign) {
                root.__assign = objAssign || assignFn;
            }
            if (!root.__extends) {
                root.__extends = extendsFn;
            }
            if (!root.__createBinding) {
                root.__createBinding = createBindingFn;
            }
        })(globalObj, __assignFn, __extendsFn, __createBindingFn);
        if (!__assign) {
            __assign = globalObj.__assign;
        }
        if (!__extends) {
            __extends = globalObj.__extends;
        }
        if (!__createBinding) {
            __createBinding = globalObj.__createBinding;
        }
    }

    exports.ObjAssign = objAssign;
    exports.ObjClass = ObjClass$1;
    exports.ObjDefineProperty = objDefineProp;
    exports.ObjProto = ObjProto$1;
    exports.__assignFn = __assignFn;
    exports.__createBindingFn = __createBindingFn;
    exports.__decorateFn = __decorateFn;
    exports.__exportStarFn = __exportStarFn;
    exports.__exposeGlobalTsLib = __exposeGlobalTsLib;
    exports.__extendsFn = __extendsFn;
    exports.__importDefaultFn = __importDefaultFn;
    exports.__importStarFn = __importStarFn;
    exports.__makeTemplateObjectFn = __makeTemplateObjectFn;
    exports.__metadataFn = __metadataFn;
    exports.__paramFn = __paramFn;
    exports.__readFn = __readFn;
    exports.__restFn = __restFn;
    exports.__spreadArrayFn = __spreadArrayFn;
    exports.__spreadArraysFn = __spreadArraysFn;
    exports.__valuesFn = __valuesFn;
    exports.getGlobal = getGlobal;
    exports.strDefault = strDefault;
    exports.strShimFunction = strShimFunction;
    exports.strShimObject = strShimObject;
    exports.strShimPrototype = strShimPrototype;
    exports.strShimUndefined = strShimUndefined;
    exports.throwTypeError = throwTypeError;

}));